~ knotless Search/
↑↓ move↵ open⇧↵ all results

chadtmiller.com/hud

A remote MCP server that shows atproto records as interactive UI inside MCP Apps hosts

0
0
246 lines · 11.4 KB Raw History
import Foundation
import SwiftUI
import Testing

@testable import HUDKit

// The workspace as the web page reads it: a tile out of its view, the
// strip's columns in order with their stacks, the same call however it is
// written, and the live stream's events out of its lines.

private func tile(_ key: String, order: String, stack: String? = nil, width: String? = nil, from: String? = nil) -> Tile {
	var record: [String: JSON] = ["tool": "query", "arguments": ["method": "app.bsky.feed.getTimeline"], "title": "", "order": .string(order), "by": "person"]
	if let stack { record["stack"] = .string(stack) }
	if let width { record["width"] = .string(width) }
	if let from { record["from"] = .string(from) }
	return Tile(["key": .string(key), "author": "did:plc:a", "record": .object(record)])!
}

@Suite struct WorkspaceShapes {
	@Test func aTileIsReadFromItsViewItsArgumentsFromJSONTextWhereNeeded() throws {
		let view: JSON = [
			"key": "aaaaaaaaaaaa",
			"author": "did:plc:a",
			"icon": "https://hud.example/icon/bsky.app",
			"record": [
				"tool": "query",
				"argumentsJson": "{\"method\":\"app.bsky.feed.getPostThread\",\"params\":{\"uri\":\"at://did:plc:b/app.bsky.feed.post/1\",\"depth\":1.5}}",
				"title": "",
				"order": "2.5",
				"width": "two-thirds",
				"by": "agent",
				"from": "bbbbbbbbbbbb",
				"createdAt": "2026-11-16T00:00:00.000Z",
			],
		]
		let read = try #require(Tile(view))
		#expect(read.arguments["params"]?["depth"] == .number(1.5))
		#expect(read.width == .twoThirds)
		#expect(read.byAgent)
		#expect(read.from == "bbbbbbbbbbbb")
		#expect(read.icon == URL(string: "https://hud.example/icon/bsky.app"))
		#expect(read.heading == "Thread")
		#expect(read.account == "did:plc:b")
		#expect(Tile(["record": [:]]) == nil)
	}

	@Test func theStripIsInOrderEachStackUnderItsHead() {
		let tiles = [
			tile("c", order: "10"),
			tile("a", order: "1", width: "half"),
			tile("b2", order: "3", stack: "a"),
			tile("b1", order: "2", stack: "a"),
			tile("lost", order: "5", stack: "gone"),
		]
		let columns = stripColumns(tiles)
		#expect(columns.map(\.id) == ["a", "lost", "c"])
		#expect(columns[0].tiles.map(\.id) == ["a", "b1", "b2"])
		#expect(columns[0].width == .half)
		#expect(columns[2].width == .third)
	}

	/// As the web's strip map: a tile joins the chain of the one it was
	/// opened from in its stack, on its left, or past columns of that one's
	/// descendants alone; not past another; a chain keeps its colour.
	@Test func chainsAreColouredAsTheWebColoursThem() {
		let tiles = [
			tile("a", order: "1"),
			tile("b", order: "2", from: "a"),
			tile("b2", order: "2.5", stack: "b", from: "a"),
			tile("c", order: "3", from: "a"),
			tile("x", order: "4"),
			tile("y", order: "5", from: "x"),
			tile("z", order: "6", from: "a"),
			tile("lone", order: "7"),
		]
		var kept: [String: Int] = [:]
		let colours = chainColours(stripColumns(tiles), kept: &kept)
		// a, b, b2, c: the longest chain, the first colour; z is past x, not a's.
		#expect(["a", "b", "b2", "c"].map { colours[$0] } == [1, 1, 1, 1])
		#expect(colours["x"] == 2 && colours["y"] == 2)
		#expect(colours["z"] == nil && colours["lone"] == nil)
		// The x chain grown longer than a's keeps its colour.
		let grown = tiles + [tile("y2", order: "5.5", from: "y"), tile("y3", order: "5.7", from: "y2"), tile("y4", order: "5.8", from: "y3")]
		let again = chainColours(stripColumns(grown), kept: &kept)
		#expect(again["x"] == 2 && again["a"] == 1)
	}

	@Test func theSameCallIsTheSameWrittenAnyWay() {
		let one = Call("query", ["method": "app.bsky.feed.getFeed", "params": ["feed": "at://x", "cursor": ""]])
		let two = Call("query", ["params": ["feed": "at://x"], "method": "app.bsky.feed.getFeed", "view": [:]])
		#expect(Tile.callKey(one) == Tile.callKey(two))
		#expect(Tile.callKey(one) != Tile.callKey(Call("query", ["method": "app.bsky.feed.getFeed"])))
	}

	@Test func aTitleHUDMadeGivesWayToOneOfTheCall() {
		#expect(!Tile.given("app.bsky.feed.post · alice.test"))
		#expect(!Tile.given("query app.bsky.feed.getTimeline"))
		#expect(!Tile.given("Thread"))
		#expect(Tile.given("Coast trip"))
		#expect(Tile.words("getPostThread") == "Post thread")
		#expect(Tile.plural("Gallery") == "Galleries")
	}
}

@Suite struct WorkspaceStream {
	@Test func eachEventIsItsDataLinesJoinedAtTheBlankLine() {
		var parser = ServerEvents()
		var got: [String] = []
		for line in [": ping", "", "data: {\"a\":1}", "", "event: x", "data:{\"b\":", "data: 2}", "", ""] {
			if let data = parser.read(line) { got.append(data) }
		}
		#expect(got == ["{\"a\":1}", "{\"b\":\n2}"])
	}
}

@Suite struct WorkspaceAccountData {
	/// getAccountData's answer, as schemas/place.hud.getAccountData.json shapes it.
	@Test func whatHUDKeepsIsReadFromGetAccountData() throws {
		let answer = """
		{"did":"did:plc:alice","canvases":[{"canvas":"3kabcdefghij","name":"Reading","members":2},{"canvas":"3kbcdefghijk","name":"Alone","members":0}],"shared":1,"invitations":3,"themes":2,"chosenTheme":true}
		"""
		let held = try #require(AccountData(JSONDecoder().decode(JSON.self, from: Data(answer.utf8))))
		#expect(held.did == "did:plc:alice")
		#expect(held.canvases == [
			AccountData.Canvas(id: "3kabcdefghij", name: "Reading", members: 2),
			AccountData.Canvas(id: "3kbcdefghijk", name: "Alone", members: 0),
		])
		#expect(held.shared == 1 && held.invitations == 3 && held.themes == 2 && held.chosenTheme)
		#expect(!held.isEmpty)
		let none = try #require(AccountData(["did": "did:plc:bob", "canvases": [], "shared": 0, "invitations": 0, "themes": 0, "chosenTheme": false]))
		#expect(none.isEmpty)
		#expect(AccountData(["canvases": []]) == nil)
	}

	/// deleteAccountData is POSTed with the person's DID named again.
	@Test func deletingPostsTheDID() throws {
		let request = try WorkspaceClient.deleteAccountDataRequest(at: URL(string: "https://hud.place")!, did: "did:plc:alice")
		#expect(request.httpMethod == "POST")
		#expect(request.url?.absoluteString == "https://hud.place/xrpc/place.hud.deleteAccountData")
		#expect(request.value(forHTTPHeaderField: "Content-Type") == "application/json")
		let body = try JSONDecoder().decode(JSON.self, from: try #require(request.httpBody))
		#expect(body == ["did": "did:plc:alice"])
	}
}

/// themes/amber.json's palette, as getWorkspace lists it.
private let amber: [String: JSON] = [
	"canvas": "#050301", "background": "#1b150c", "panel": "#211a10", "soft": "#282013",
	"border": "#342819", "borderStrong": "#4c3b25", "text": "#ffdaa3", "textMuted": "#d8aa68",
	"textFaint": "#ba8c51", "primary": "#ffb238", "onPrimary": "#1a1006", "accent": "#ffbf5a",
	"accentSoft": "#3a2a11", "success": "#acd876", "danger": "#ff6d50", "done": "#e79ddb",
	"attention": "#ffd166", "neutral": "#a68f71", "onSolid": "#1b150c", "notice": "#33270d",
	"onNotice": "#ffd166",
]

private let bundled: JSON = [
	["key": "light", "name": "Light", "colorScheme": "light"],
	["key": "dark", "name": "Dark", "colorScheme": "dark"],
	["key": "amber", "name": "Amber", "colorScheme": "dark", "palette": .object(amber)],
]

@Suite struct WorkspaceThemes {
	@Test func theThemeChosenAndEveryThemeAreReadFromGetWorkspace() throws {
		let found = Theme.read(["me": ["did": "did:plc:a"], "open": [], "theme": ["key": "amber", "name": "Amber", "colorScheme": "dark", "palette": .object(amber)], "themes": bundled])
		#expect(found.chosen?.id == "amber" && found.chosen?.key == "amber" && found.chosen?.uri == nil)
		#expect(found.chosen?.palette?.colors[.canvas] == RGB(hex: "#050301"))
		#expect(found.themes.map(\.id) == ["light", "dark", "amber"])
		#expect(found.themes[0].palette == nil && found.themes[0].colorScheme == .light)
		#expect(found.themes[1].palette == nil && found.themes[1].colorScheme == .dark)
		let palette = try #require(found.themes[2].palette)
		#expect(found.themes[2].name == "Amber" && found.themes[2].colorScheme == .dark)
		#expect(palette.colors.count == Palette.Role.allCases.count)
		#expect(palette.colors[.canvas] == RGB(hex: "#050301"))
		#expect(palette.colors[.onNotice] == RGB(hex: "#FFD166"))
		#expect(palette.colors[.accent].map { [$0.red, $0.green, $0.blue] } == [0xff, 0xbf, 0x5a])
	}

	/// No theme chosen follows the system; a server older than themes lists none.
	@Test func withoutAThemeTheSystemsIsDrawn() {
		let none = Theme.read(["me": ["did": "did:plc:a"], "open": [], "themes": bundled])
		#expect(none.chosen == nil)
		#expect(none.themes.count == 3)
		let older = Theme.read(["me": ["did": "did:plc:a"], "open": []])
		#expect(older.chosen == nil && older.themes.isEmpty)
	}

	/// A colour that is not #rrggbb is left to the system's; the theme stands.
	@Test func aMalformedColourIsIgnoredNotTheTheme() throws {
		var palette = amber
		palette["text"] = "red"
		palette["accent"] = "#12345"
		palette["border"] = "#zzzzzz"
		palette["danger"] = "#+12345"
		palette["done"] = 7
		let found = Theme.read(["theme": ["key": "odd", "name": "Odd", "colorScheme": "light"], "themes": [
			["key": "odd", "name": "Odd", "colorScheme": "light", "palette": .object(palette)],
			["name": "No key", "colorScheme": "dark"],
		]])
		#expect(found.chosen?.id == "odd")
		let theme = try #require(found.themes.first)
		#expect(found.themes.count == 1)
		let read = try #require(theme.palette)
		for role in [Palette.Role.text, .accent, .border, .danger, .done] {
			#expect(read.colors[role] == nil)
		}
		#expect(read.colors.count == Palette.Role.allCases.count - 5)
		#expect(read.colors[.background] == RGB(hex: "#1b150c"))
	}

	/// A person's theme chosen is drawn as getWorkspace gives it, by its uri,
	/// with who made it, though HUD's themes do not list it.
	@Test func aPersonsThemeChosenIsDrawnAsGiven() throws {
		let uri = "at://did:plc:b/place.hud.theme/3kabc"
		let found = Theme.read(["me": ["did": "did:plc:a"], "open": [], "themes": bundled, "theme": [
			"uri": .string(uri), "creator": ["did": "did:plc:b", "handle": "bea.test"],
			"name": "Ember", "colorScheme": "dark", "palette": .object(amber),
		]])
		let chosen = try #require(found.chosen)
		#expect(chosen.id == uri && chosen.uri == uri && chosen.key == nil)
		#expect(chosen.creator == Viewer(did: "did:plc:b", handle: "bea.test"))
		#expect(chosen.name == "Ember" && chosen.colorScheme == .dark)
		#expect(chosen.palette?.colors[.accent] == RGB(hex: "#ffbf5a"))
		#expect(!found.themes.contains { $0.id == uri })
	}

	/// listThemes' page: each theme by its uri and creator, and the cursor on.
	@Test func aPageOfPeoplesThemesAndItsCursor() {
		let page = Theme.page(["cursor": "did:plc:c/3kxyz", "themes": [
			["uri": "at://did:plc:b/place.hud.theme/1", "creator": ["did": "did:plc:b"], "name": "One", "colorScheme": "light", "palette": .object(amber)],
			["uri": "at://did:plc:c/place.hud.theme/2", "creator": ["did": "did:plc:c", "handle": "cy.test"], "name": "Two", "colorScheme": "dark", "palette": .object(amber)],
		]])
		#expect(page.cursor == "did:plc:c/3kxyz")
		#expect(page.themes.map(\.id) == ["at://did:plc:b/place.hud.theme/1", "at://did:plc:c/place.hud.theme/2"])
		#expect(page.themes[0].creator?.handle == nil && page.themes[1].creator?.handle == "cy.test")
		let last = Theme.page(["themes": []])
		#expect(last.cursor == nil && last.themes.isEmpty)
	}

	/// A theme with neither key nor uri is dropped, wherever it is given.
	@Test func aThemeWithNeitherKeyNorURIIsDropped() {
		let nameless: JSON = ["name": "Nowhere", "colorScheme": "dark", "creator": ["did": "did:plc:b"]]
		#expect(Theme(nameless) == nil)
		#expect(Theme.read(["theme": nameless, "themes": [nameless]]).chosen == nil)
		#expect(Theme.page(["themes": [nameless, ["uri": "at://did:plc:b/place.hud.theme/1", "name": "One", "colorScheme": "light"]]]).themes.count == 1)
	}
}