chadtmiller.com/hud
A remote MCP server that shows atproto records as interactive UI inside MCP Apps hosts
place.hud.hudkit 0.4.0 Latest 5 packages
0
0
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)
}
}