@astrofoundry/pi-astro 0.21.2 → 0.22.0

package/README.md

@@ -68,6 +68,7 @@ pi                # launch; confirm [Extensions] lists astro-subagents, grimoire
 - `multi-edit` - registers the enhanced `edit` tool
 - `gemini-image` - registers `gemini_image` tool (requires a Gemini API key; prompts and saves on first use)
 - `security-guard` - blocks/prompts destructive bash commands and sensitive file access; configure at `~/.pi/agent/security-guard.json` (example written on first run); `/security-guard status|reload|test`
+- `astro-discord` - Discord access to the specialists: in the configured channels, `<specialist> <task>` runs `astro.<specialist>` and posts the answer as a reply (⏳ running, 🔒 waiting for an owner's approval of a risky call, ✅ done, ❌ failed). Owners may use every specialist and approve risky calls with buttons; other users only the specialists listed for them; everyone else is ignored. Inert unless the headless host sets `ASTRO_DISCORD=1`; setup with `node --disable-warning=ExperimentalWarning <package>/extensions/astro-discord/setup.ts`, which prompts for the bot token and ids, checks them against Discord, and writes the LaunchAgent. See [specialists/README.md](specialists/README.md#discord).
 - `specialist-gate` - gives each specialist agent (`astro.arcane`, `astro.identity`, `astro.network`, `astro.dns`, `astro.edge`, `astro.security`, `astro.backup`, `astro.proxmox`, `astro.inference`) its single tool, which runs the matching CLI wrapper as a dedicated macOS user through `sudo`, and blocks every other agent from calling those CLIs or reading their credentials. Inactive until the host has `~/.pi/agent/specialists.json`. `/specialists` prints the status. Host setup is described in [specialists/README.md](specialists/README.md).
 - `notify-on-stop` - runs a shell command when the agent finishes a turn (sound, voice, desktop notification). **Default: off.** Enable with `/notify on` (state persists in `~/.pi/agent/notify-on-stop.json`); disable with `/notify off`. macOS default command: plays the Glass system sound and speaks "Agent done" via `say` using the **`Samantha (Enhanced)`** voice. Linux default: `notify-send "pi" "Agent done"`. Override the voice with `PI_STOP_NOTIFY_VOICE=<voice-name>` (macOS only; e.g. `Alex`, `Karen`, `Daniel (Enhanced)`). Replace the full command with `PI_STOP_NOTIFY='afplay /System/Library/Sounds/Glass.aiff && say "Done"'`. Hard-kill (overrides `/notify on`) with `PI_STOP_NOTIFY_OFF=1`. Commands: `/notify [on|off|status|test]`. See [extensions/notify-on-stop/README.md](extensions/notify-on-stop/README.md) for full details.
   - **macOS voice install (required once for the default):** open **System Settings, Accessibility, Spoken Content, System Voice, Manage Voices...**, expand **English**, check **Samantha (Enhanced)**, click **Done** to download (~500 MB to 1 GB). Verify with `say -v "Samantha (Enhanced)" hi`. If the voice is missing, `say` errors silently and you'll only hear the Glass sound.

package/extensions/astro-discord/approvals.ts

@@ -0,0 +1,124 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { createServer, type Server } from "node:http";
+
+export type Decision = "approve" | "deny" | "timeout";
+
+export interface Ticket {
+    id: string;
+    agent: string;
+    service: string;
+    args: string[];
+    createdAt: number;
+    decision: Decision | null;
+    decidedBy: string | null;
+}
+
+export interface ApprovalEvents {
+    /** Called once per new ticket so the bridge can ask the operator. */
+    onTicket: (ticket: Ticket) => void;
+    /** Called when a ticket ran out of time without a decision. */
+    onExpired: (ticket: Ticket) => void;
+}
+
+/**
+ * Loopback HTTP endpoint the specialist gate talks to: `POST /approvals`
+ * creates a ticket, `GET /approvals/<id>` reports its decision. Only
+ * requests carrying the per-process bearer token are accepted.
+ */
+export class ApprovalServer {
+    readonly token = randomBytes(24).toString("hex");
+    private readonly tickets = new Map<string, Ticket>();
+    private server: Server | null = null;
+    private port = 0;
+
+    constructor(
+        private readonly events: ApprovalEvents,
+        private readonly timeoutMs: number,
+    ) {}
+
+    get url(): string {
+        return `http://127.0.0.1:${this.port}`;
+    }
+
+    ticket(id: string): Ticket | undefined {
+        return this.tickets.get(id);
+    }
+
+    decide(id: string, decision: Decision, by: string): Ticket | undefined {
+        const ticket = this.tickets.get(id);
+        if (!ticket || ticket.decision !== null) return undefined;
+        ticket.decision = decision;
+        ticket.decidedBy = by;
+        return ticket;
+    }
+
+    async listen(): Promise<void> {
+        const server = createServer((req, res) => {
+            const auth = req.headers.authorization ?? "";
+            if (auth !== `Bearer ${this.token}`) {
+                res.writeHead(401).end();
+                return;
+            }
+            const url = new URL(req.url ?? "/", "http://127.0.0.1");
+            if (req.method === "POST" && url.pathname === "/approvals") {
+                let body = "";
+                req.on("data", (chunk: Buffer) => {
+                    body += chunk.toString("utf-8");
+                    if (body.length > 65_536) req.destroy();
+                });
+                req.on("end", () => {
+                    let parsed: { agent?: unknown; service?: unknown; args?: unknown };
+                    try {
+                        parsed = JSON.parse(body) as typeof parsed;
+                    } catch {
+                        res.writeHead(400).end();
+                        return;
+                    }
+                    if (typeof parsed.agent !== "string" || typeof parsed.service !== "string" || !Array.isArray(parsed.args) || !parsed.args.every((a) => typeof a === "string")) {
+                        res.writeHead(400).end();
+                        return;
+                    }
+                    const ticket: Ticket = { id: randomUUID(), agent: parsed.agent, service: parsed.service, args: parsed.args as string[], createdAt: Date.now(), decision: null, decidedBy: null };
+                    this.tickets.set(ticket.id, ticket);
+                    setTimeout(() => {
+                        if (ticket.decision === null) {
+                            ticket.decision = "timeout";
+                            ticket.decidedBy = null;
+                            this.events.onExpired(ticket);
+                        }
+                        setTimeout(() => this.tickets.delete(ticket.id), 60_000).unref();
+                    }, this.timeoutMs).unref();
+                    this.events.onTicket(ticket);
+                    res.writeHead(201, { "Content-Type": "application/json" }).end(JSON.stringify({ id: ticket.id }));
+                });
+                return;
+            }
+            const match = /^\/approvals\/([0-9a-f-]{36})$/.exec(url.pathname);
+            if (req.method === "GET" && match) {
+                const ticket = this.tickets.get(match[1]);
+                if (!ticket) {
+                    res.writeHead(404).end();
+                    return;
+                }
+                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ id: ticket.id, decision: ticket.decision }));
+                return;
+            }
+            res.writeHead(404).end();
+        });
+        await new Promise<void>((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(0, "127.0.0.1", () => {
+                const address = server.address();
+                this.port = typeof address === "object" && address ? address.port : 0;
+                resolve();
+            });
+        });
+        server.unref();
+        this.server = server;
+    }
+
+    close(): void {
+        this.server?.close();
+        this.server = null;
+    }
+}

package/extensions/astro-discord/chunk.ts

@@ -0,0 +1,50 @@
+/** Discord's limit for one message body. */
+export const MESSAGE_LIMIT = 2000;
+
+/**
+ * Splits text into Discord-sized chunks, preferring paragraph and line
+ * boundaries and never leaving a code fence open across a chunk.
+ */
+export function chunkMessage(text: string, limit = MESSAGE_LIMIT): string[] {
+    const trimmed = text.trim();
+    if (trimmed.length === 0) return [];
+    const chunks: string[] = [];
+    let rest = trimmed;
+    let openFence: string | null = null;
+    while (rest.length > 0) {
+        const closing = 4;
+        const budget = limit - closing - (openFence ? openFence.length + 1 : 0);
+        let piece: string;
+        if (rest.length <= budget) {
+            piece = rest;
+            rest = "";
+        } else {
+            let cut = rest.lastIndexOf("\n\n", budget);
+            if (cut < budget / 2) cut = rest.lastIndexOf("\n", budget);
+            if (cut < budget / 2) cut = rest.lastIndexOf(" ", budget);
+            if (cut < budget / 2) cut = budget;
+            piece = rest.slice(0, cut);
+            rest = rest.slice(cut).replace(/^\s+/, "");
+        }
+        let body = openFence ? `${openFence}\n${piece}` : piece;
+        const fenceAfter = fenceState(body, null);
+        if (fenceAfter && rest.length > 0) {
+            body = `${body}\n\`\`\``;
+        }
+        openFence = fenceAfter;
+        chunks.push(body);
+    }
+    return chunks;
+}
+
+/** The fence line that is open at the end of `text`, or null when balanced. */
+export function fenceState(text: string, initial: string | null): string | null {
+    let open = initial;
+    for (const line of text.split("\n")) {
+        const match = /^(\s*)(```+|~~~+)(.*)$/.exec(line);
+        if (!match) continue;
+        if (open === null) open = `${match[2]}${match[3].trim()}`;
+        else if (line.trim().startsWith(open.slice(0, 3))) open = null;
+    }
+    return open;
+}

package/extensions/astro-discord/commands.ts

@@ -0,0 +1,36 @@
+export type Command = { kind: "run"; specialist: string; task: string } | { kind: "help" } | { kind: "status" } | { kind: "none" };
+
+/**
+ * `<specialist> <task>` or `@bot <specialist> <task>` in a watched channel.
+ * `help` lists what the sender may use; `status` shows running tasks.
+ */
+export function parseCommand(content: string, botUserId: string, specialists: readonly string[]): Command {
+    let text = content.trim().replace(new RegExp(`^<@!?${botUserId}>\\s*`), "");
+    text = text.replace(/^[!/]/, "");
+    if (text.length === 0) return { kind: "none" };
+    const [first, ...rest] = text.split(/\s+/);
+    const word = first.toLowerCase();
+    if (word === "help") return { kind: "help" };
+    if (word === "status") return { kind: "status" };
+    const specialist = word.replace(/^astro\./, "");
+    if (!specialists.includes(specialist)) return { kind: "none" };
+    const task = text.slice(first.length).trim();
+    if (task.length === 0) return { kind: "none" };
+    return { kind: "run", specialist, task: rest.length > 0 ? task : "" };
+}
+
+/** Prompt paragraph appended for tasks that arrive from a chat channel. */
+export const CHANNEL_RULES = `## Channel rules
+
+This task arrived from a Discord channel and your answer is posted there. Answer in plain text under 1500 characters when possible, facts first, no headings. When the task is ambiguous (which guest, which record, which host), do not act: ask one precise question and stop. Risky calls may wait for an operator's approval; if the tool reports a denial or a missing answer, report it and stop.`;
+
+export function helpText(allowed: readonly string[], isOwner: boolean): string {
+    if (allowed.length === 0) return "You may not use any specialist here.";
+    const lines = [
+        "Send `<specialist> <task>` in this channel. Specialists you may use:",
+        ...allowed.map((name) => `• \`${name}\``),
+        "React ⏳ means running, 🔒 waiting for an owner's approval, ✅ done, ❌ failed. `status` lists running tasks.",
+    ];
+    if (isOwner) lines.push("Owners approve risky calls with the buttons the bot posts and may use every specialist.");
+    return lines.join("\n");
+}

package/extensions/astro-discord/config.ts

@@ -0,0 +1,108 @@
+import { readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/** Set to "1" on the headless Pi host that should connect to Discord. */
+export const ACTIVATION_ENV = "ASTRO_DISCORD";
+
+export interface DiscordConfig {
+    applicationId: string;
+    guildId: string;
+    /** Channels the bot reads; messages elsewhere are ignored. */
+    channelIds: string[];
+    /** Users who may use every specialist and decide approvals. */
+    owners: string[];
+    /** Extra users per specialist name (without the astro. prefix). */
+    access: Record<string, string[]>;
+    approvalTimeoutMinutes: number;
+}
+
+const SNOWFLAKE = /^\d{17,20}$/;
+const SPECIALIST = /^[a-z][a-z0-9-]*$/;
+
+export function configDir(): string {
+    return process.env.ASTRO_DISCORD_DIR ?? join(homedir(), ".config", "astro-discord");
+}
+
+export function configPath(): string {
+    return join(configDir(), "config.json");
+}
+
+export function tokenPath(): string {
+    return join(configDir(), "token");
+}
+
+function snowflakes(value: unknown, where: string, errors: string[]): string[] {
+    if (!Array.isArray(value) || value.length === 0) {
+        errors.push(`${where} must be a non-empty array of Discord ids`);
+        return [];
+    }
+    const out: string[] = [];
+    for (const item of value) {
+        if (typeof item !== "string" || !SNOWFLAKE.test(item)) errors.push(`${where}: ${String(item)} is not a Discord id`);
+        else out.push(item);
+    }
+    return out;
+}
+
+export function validateConfig(raw: unknown, errors: string[]): DiscordConfig | null {
+    if (typeof raw !== "object" || raw === null) {
+        errors.push("config root is not an object");
+        return null;
+    }
+    const r = raw as Record<string, unknown>;
+    for (const key of ["applicationId", "guildId"]) {
+        if (typeof r[key] !== "string" || !SNOWFLAKE.test(r[key] as string)) errors.push(`${key} must be a Discord id`);
+    }
+    const channelIds = snowflakes(r.channelIds, "channelIds", errors);
+    const owners = snowflakes(r.owners, "owners", errors);
+    const access: Record<string, string[]> = {};
+    if (r.access !== undefined) {
+        if (typeof r.access !== "object" || r.access === null || Array.isArray(r.access)) errors.push("access must be an object of specialist name to id array");
+        else {
+            for (const [name, ids] of Object.entries(r.access as Record<string, unknown>)) {
+                if (!SPECIALIST.test(name)) errors.push(`access: ${name} is not a specialist name`);
+                access[name] = Array.isArray(ids) && ids.length === 0 ? [] : snowflakes(ids, `access.${name}`, errors);
+            }
+        }
+    }
+    const timeout = r.approvalTimeoutMinutes;
+    if (typeof timeout !== "number" || !Number.isInteger(timeout) || timeout < 1 || timeout > 240) errors.push("approvalTimeoutMinutes must be an integer from 1 to 240");
+    if (errors.length > 0) return null;
+    return { applicationId: r.applicationId as string, guildId: r.guildId as string, channelIds, owners, access, approvalTimeoutMinutes: timeout as number };
+}
+
+export function loadConfig(): { config: DiscordConfig | null; errors: string[] } {
+    const errors: string[] = [];
+    let parsed: unknown;
+    try {
+        parsed = JSON.parse(readFileSync(configPath(), "utf-8"));
+    } catch (err) {
+        return { config: null, errors: [`cannot read ${configPath()}: ${err instanceof Error ? err.message : String(err)}`] };
+    }
+    return { config: validateConfig(parsed, errors), errors };
+}
+
+/** The bot token; the file must be readable by its owner only. */
+export function loadToken(): string {
+    const path = tokenPath();
+    const mode = statSync(path).mode;
+    if ((mode & 0o077) !== 0) throw new Error(`${path} must be mode 0600`);
+    const token = readFileSync(path, "utf-8").trim();
+    if (token.length < 50) throw new Error(`${path} does not look like a bot token`);
+    return token;
+}
+
+export function isOwner(config: DiscordConfig, userId: string): boolean {
+    return config.owners.includes(userId);
+}
+
+/** Owners may use every specialist; others only those listed for them under `access`. */
+export function canUse(config: DiscordConfig, userId: string, specialist: string): boolean {
+    return isOwner(config, userId) || (config.access[specialist] ?? []).includes(userId);
+}
+
+/** Specialists a user may address, from the runtime list of `astro.*` agents. */
+export function allowedSpecialists(config: DiscordConfig, userId: string, available: readonly string[]): string[] {
+    return available.filter((name) => canUse(config, userId, name));
+}

package/extensions/astro-discord/discord.test.ts

@@ -0,0 +1,173 @@
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { ApprovalServer, type Ticket } from "./approvals.ts";
+import { chunkMessage, fenceState } from "./chunk.ts";
+import { helpText, parseCommand } from "./commands.ts";
+import { allowedSpecialists, canUse, loadConfig, loadToken, validateConfig } from "./config.ts";
+import { INTENTS, initialState, reduce } from "./gateway.ts";
+import { DiscordRest } from "./rest.ts";
+
+const ID = "123456789012345678";
+const OTHER = "223456789012345678";
+const THIRD = "323456789012345678";
+const valid = { applicationId: ID, guildId: ID, channelIds: [ID], owners: [ID], access: { dns: [OTHER] }, approvalTimeoutMinutes: 30 };
+
+describe("config", () => {
+    it("validates ids and shapes", () => {
+        const errors: string[] = [];
+        expect(validateConfig(valid, errors)).toEqual(valid);
+        expect(errors).toEqual([]);
+        expect(validateConfig({ ...valid, guildId: "abc" }, errors)).toBeNull();
+        expect(validateConfig({ ...valid, channelIds: [] }, [])).toBeNull();
+        expect(validateConfig({ ...valid, access: { "Bad Name": [ID] } }, [])).toBeNull();
+        expect(validateConfig({ ...valid, approvalTimeoutMinutes: 0 }, [])).toBeNull();
+        expect(validateConfig({ ...valid, access: undefined }, [])).toMatchObject({ access: {} });
+    });
+
+    it("grants owners everything and others their listed specialists", () => {
+        const config = validateConfig(valid, [])!;
+        expect(canUse(config, ID, "proxmox")).toBe(true);
+        expect(canUse(config, OTHER, "dns")).toBe(true);
+        expect(canUse(config, OTHER, "proxmox")).toBe(false);
+        expect(canUse(config, THIRD, "dns")).toBe(false);
+        expect(allowedSpecialists(config, OTHER, ["dns", "edge"])).toEqual(["dns"]);
+        expect(allowedSpecialists(config, ID, ["dns", "edge"])).toEqual(["dns", "edge"]);
+    });
+
+    describe("files", () => {
+        let dir: string;
+        beforeEach(() => {
+            dir = mkdtempSync(join(tmpdir(), "astro-discord-"));
+            process.env.ASTRO_DISCORD_DIR = dir;
+        });
+        afterEach(() => {
+            delete process.env.ASTRO_DISCORD_DIR;
+            rmSync(dir, { recursive: true, force: true });
+        });
+
+        it("loads config and refuses a readable token", () => {
+            writeFileSync(join(dir, "config.json"), JSON.stringify(valid));
+            expect(loadConfig().config).toEqual(valid);
+            writeFileSync(join(dir, "token"), `${"x".repeat(60)}\n`, { mode: 0o644 });
+            expect(() => loadToken()).toThrow(/0600/);
+            chmodSync(join(dir, "token"), 0o600);
+            expect(loadToken()).toBe("x".repeat(60));
+            writeFileSync(join(dir, "config.json"), "{");
+            expect(loadConfig().config).toBeNull();
+        });
+    });
+});
+
+describe("chunk", () => {
+    it("splits on paragraphs and keeps fences balanced", () => {
+        const text = `${"a".repeat(1500)}\n\n${"b".repeat(1500)}`;
+        const chunks = chunkMessage(text);
+        expect(chunks).toHaveLength(2);
+        expect(chunks[0]).toBe("a".repeat(1500));
+        const fenced = "intro\n```json\n" + "x\n".repeat(1500) + "```\nafter";
+        const parts = chunkMessage(fenced);
+        expect(parts.length).toBeGreaterThan(1);
+        for (const part of parts) {
+            expect(part.length).toBeLessThanOrEqual(2000);
+            expect(fenceState(part, null)).toBeNull();
+        }
+        expect(parts[1].startsWith("```json\n")).toBe(true);
+        expect(chunkMessage("   ")).toEqual([]);
+    });
+});
+
+describe("commands", () => {
+    const specialists = ["dns", "edge"];
+    it("parses specialist tasks, mentions, help, and status", () => {
+        expect(parseCommand("dns list the zones", ID, specialists)).toEqual({ kind: "run", specialist: "dns", task: "list the zones" });
+        expect(parseCommand(`<@${ID}> edge probe the front door`, ID, specialists)).toEqual({ kind: "run", specialist: "edge", task: "probe the front door" });
+        expect(parseCommand("!astro.dns zones", ID, specialists)).toEqual({ kind: "run", specialist: "dns", task: "zones" });
+        expect(parseCommand("help", ID, specialists)).toEqual({ kind: "help" });
+        expect(parseCommand("Status", ID, specialists)).toEqual({ kind: "status" });
+        expect(parseCommand("dns", ID, specialists)).toEqual({ kind: "none" });
+        expect(parseCommand("hello everyone", ID, specialists)).toEqual({ kind: "none" });
+        expect(parseCommand("", ID, specialists)).toEqual({ kind: "none" });
+    });
+
+    it("lists what a user may use", () => {
+        expect(helpText([], false)).toMatch(/may not/);
+        expect(helpText(["dns"], true)).toMatch(/`dns`/);
+        expect(helpText(["dns"], true)).toMatch(/Owners approve/);
+    });
+});
+
+describe("gateway reducer", () => {
+    it("identifies after hello, resumes with a session, heartbeats, and reconnects", () => {
+        const state = initialState();
+        const handlers = { dispatch: vi.fn(), log: vi.fn() };
+        expect(reduce(state, { op: 10, d: { heartbeat_interval: 1000 } }, handlers)).toEqual({ kind: "identify" });
+        expect(state.heartbeatMs).toBe(1000);
+        expect(reduce(state, { op: 0, t: "READY", s: 1, d: { session_id: "s1", resume_gateway_url: "wss://r" } }, handlers)).toEqual({ kind: "none" });
+        expect(state).toMatchObject({ sessionId: "s1", resumeUrl: "wss://r", seq: 1 });
+        expect(handlers.dispatch).toHaveBeenCalledWith("READY", expect.objectContaining({ session_id: "s1" }));
+        expect(reduce(state, { op: 0, t: "MESSAGE_CREATE", s: 2, d: { id: "m" } }, handlers)).toEqual({ kind: "none" });
+        expect(handlers.dispatch).toHaveBeenLastCalledWith("MESSAGE_CREATE", { id: "m" });
+        expect(reduce(state, { op: 1 }, handlers)).toEqual({ kind: "heartbeat-now" });
+        state.awaitingAck = true;
+        expect(reduce(state, { op: 11 }, handlers)).toEqual({ kind: "none" });
+        expect(state.awaitingAck).toBe(false);
+        expect(reduce(state, { op: 7 }, handlers)).toEqual({ kind: "reconnect", resume: true });
+        expect(reduce(state, { op: 9, d: false }, handlers)).toEqual({ kind: "reconnect", resume: false });
+        expect(reduce(state, { op: 10, d: { heartbeat_interval: 1000 } }, handlers)).toEqual({ kind: "resume" });
+        expect(INTENTS).toBe(33281);
+    });
+});
+
+describe("rest", () => {
+    it("sends JSON messages, multipart attachments, and retries once after 429", async () => {
+        const calls: { url: string; init: RequestInit }[] = [];
+        let first = true;
+        const fetchImpl = vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
+            calls.push({ url: String(url), init: init ?? {} });
+            if (first) {
+                first = false;
+                return new Response(JSON.stringify({ retry_after: 0.01 }), { status: 429 });
+            }
+            return new Response(JSON.stringify({ id: "m1", channel_id: "c1" }), { status: 200 });
+        }) as unknown as typeof fetch;
+        const rest = new DiscordRest("tok", fetchImpl);
+        const message = await rest.createMessage("c1", { content: "hi", replyTo: "m0" });
+        expect(message.id).toBe("m1");
+        expect(calls).toHaveLength(2);
+        expect(calls[1].url).toBe("https://discord.com/api/v10/channels/c1/messages");
+        expect((calls[1].init.headers as Record<string, string>).Authorization).toBe("Bot tok");
+        expect(JSON.parse(calls[1].init.body as string)).toMatchObject({ content: "hi", message_reference: { message_id: "m0" }, allowed_mentions: { parse: [] } });
+        await rest.createMessage("c1", { content: "long", file: { name: "a.md", content: "body" } });
+        expect(calls[2].init.body).toBeInstanceOf(FormData);
+        await rest.addReaction("c1", "m1", "⏳");
+        expect(calls[3].url).toBe(`https://discord.com/api/v10/channels/c1/messages/m1/reactions/${encodeURIComponent("⏳")}/@me`);
+        expect(calls[3].init.method).toBe("PUT");
+    });
+});
+
+describe("approval server", () => {
+    it("creates tickets, reports decisions, expires, and rejects bad tokens", async () => {
+        const tickets: Ticket[] = [];
+        const expired: Ticket[] = [];
+        const server = new ApprovalServer({ onTicket: (t) => tickets.push(t), onExpired: (t) => expired.push(t) }, 300);
+        await server.listen();
+        const headers = { Authorization: `Bearer ${server.token}`, "Content-Type": "application/json" };
+        expect((await fetch(`${server.url}/approvals`, { method: "POST", headers: { ...headers, Authorization: "Bearer nope" }, body: "{}" })).status).toBe(401);
+        expect((await fetch(`${server.url}/approvals`, { method: "POST", headers, body: JSON.stringify({ agent: "astro.dns" }) })).status).toBe(400);
+        const created = await fetch(`${server.url}/approvals`, { method: "POST", headers, body: JSON.stringify({ agent: "astro.dns", service: "dns", args: ["technitium", "primary", "zone-delete", "x"] }) });
+        expect(created.status).toBe(201);
+        const { id } = (await created.json()) as { id: string };
+        expect(tickets[0]).toMatchObject({ id, service: "dns", decision: null });
+        expect((await (await fetch(`${server.url}/approvals/${id}`, { headers })).json()) as object).toEqual({ id, decision: null });
+        expect(server.decide(id, "approve", ID)?.decidedBy).toBe(ID);
+        expect(server.decide(id, "deny", ID)).toBeUndefined();
+        expect((await (await fetch(`${server.url}/approvals/${id}`, { headers })).json()) as object).toEqual({ id, decision: "approve" });
+        const second = (await (await fetch(`${server.url}/approvals`, { method: "POST", headers, body: JSON.stringify({ agent: "astro.edge", service: "edge", args: ["vps", "reboot", "--confirm"] }) })).json()) as { id: string };
+        await new Promise((resolve) => setTimeout(resolve, 400));
+        expect(server.ticket(second.id)?.decision).toBe("timeout");
+        expect(expired.map((t) => t.id)).toEqual([second.id]);
+        server.close();
+    });
+});