@netnodeag/kraftwerk 0.64.0 → 0.66.0

package/dist/core/vibeables.js

@@ -6,9 +6,10 @@ import path from "node:path";
 import { parse } from "yaml";
 import { resolveWorkspace, vibeablesRootFor } from "../config.js";
 import { workspaceRoot } from "./context.js";
-import { perWorkspace } from "./workspace.js";
+import { perWorkspace, workspaceOpen } from "./workspace.js";
 import { moveToTrash } from "./trash.js";
 import { newestMtime } from "./mtime.js";
+import { workspaceEnv } from "./env.js";
 export const VIBEABLE_CONFIG_FILE = "vibeable.yml";
 const SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 export function safeVibeableSlug(slug) {
@@ -353,7 +354,7 @@ async function startDevNow(slug) {
         detached: process.platform !== "win32",
         stdio: ["ignore", "pipe", "pipe"],
         env: {
-            ...process.env,
+            ...workspaceEnv(),
             PORT: String(port),
             BASE_PATH: basePath,
             PUBLIC_URL: basePath,
@@ -371,19 +372,22 @@ async function startDevNow(slug) {
         pushLog(d, Buffer.from(`spawn failed: ${err.message}\n`));
         d.exitCode = null;
         d.ready = false;
-        broadcast(slug, { type: "dev", dev: devView(slug) });
+        if (workspaceOpen())
+            broadcast(slug, { type: "dev", dev: devView(slug) });
     });
     child.on("exit", (code) => {
         d.exitCode = code;
         d.ready = false;
         pushLog(d, Buffer.from(`[exited with ${code ?? "signal"}]\n`));
-        broadcast(slug, { type: "dev", dev: devView(slug) });
+        // Closing the workspace ends its dev servers: their exit then has nobody to tell.
+        if (workspaceOpen())
+            broadcast(slug, { type: "dev", dev: devView(slug) });
     });
     broadcast(slug, { type: "dev", dev: devView(slug) });
     // Readiness runs in the background; the pane follows the dev events.
     void (async () => {
         const until = Date.now() + READY_TIMEOUT;
-        while (Date.now() < until && d.exitCode === undefined && devs().get(slug) === d) {
+        while (Date.now() < until && d.exitCode === undefined && workspaceOpen() && devs().get(slug) === d) {
             if (await probe(port)) {
                 d.ready = true;
                 broadcast(slug, { type: "dev", dev: devView(slug) });
@@ -432,3 +436,11 @@ export function disposeAllDevs() {
             if (d.exitCode === undefined)
                 killGroup(d, "SIGTERM");
 }
+/** The current workspace's dev servers and file watchers end (the workspace closes). */
+export function disposeWorkspaceDevs() {
+    for (const d of devs().values())
+        if (d.exitCode === undefined)
+            killGroup(d, "SIGTERM");
+    for (const slug of [...channels().keys()])
+        dropChannel(slug);
+}

package/dist/core/workspace.d.ts

@@ -18,19 +18,32 @@
 export declare class Workspace {
     readonly root: string;
     readonly outputDir: string;
+    /** Its address on this machine (kraftwerk.yml `slug`, else the folder name), when known. */
+    readonly slug?: string;
+    /** Its `.env` (parsed, not applied — see env.ts); {} when none was given. */
+    readonly env: Record<string, string>;
     private readonly slots;
     /** `root` defaults to the parent of the output dir (wrong for nested output dirs — pass it when known). */
     constructor(opts: {
         outputDir: string;
         root?: string;
+        slug?: string;
+        env?: Record<string, string>;
     });
     /** Run `fn` (and everything it starts) in this workspace. */
     run<T>(fn: () => T): T;
+    /** Closed (no longer served): its state is gone and may not come back — see close(). */
+    get closed(): boolean;
+    private isClosed;
     slot<T>(key: object, init: () => T): T;
+    /** No longer served: sweeps over all workspaces (shutdown, the idle reaper) skip it. Its slots are dropped. */
+    close(): void;
     peek<T>(key: object): T | undefined;
 }
 /** The workspace a single-workspace process serves; used outside any `ws.run`. */
 export declare function setDefaultWorkspace(ws: Workspace): Workspace;
+/** Whether the caller's workspace is still served (a background loop checks before its next round); true outside any. */
+export declare function workspaceOpen(): boolean;
 export declare function currentWorkspace(): Workspace;
 export interface PerWorkspace<T> {
     /** The current workspace's value, created on first use. */

package/dist/core/workspace.js

@@ -20,22 +20,42 @@ import path from "node:path";
 export class Workspace {
     root;
     outputDir;
+    /** Its address on this machine (kraftwerk.yml `slug`, else the folder name), when known. */
+    slug;
+    /** Its `.env` (parsed, not applied — see env.ts); {} when none was given. */
+    env;
     slots = new Map();
     /** `root` defaults to the parent of the output dir (wrong for nested output dirs — pass it when known). */
     constructor(opts) {
         this.outputDir = path.resolve(opts.outputDir);
         this.root = opts.root ? path.resolve(opts.root) : path.dirname(this.outputDir);
+        this.slug = opts.slug;
+        this.env = opts.env ?? {};
         known.add(this);
     }
     /** Run `fn` (and everything it starts) in this workspace. */
     run(fn) {
         return storage.run(this, fn);
     }
+    /** Closed (no longer served): its state is gone and may not come back — see close(). */
+    get closed() {
+        return this.isClosed;
+    }
+    isClosed = false;
     slot(key, init) {
+        // Something still running for a closed workspace (a fetch in flight, a heartbeat) must not bring its state back.
+        if (this.isClosed)
+            throw new Error("workspace closed");
         if (!this.slots.has(key))
             this.slots.set(key, init());
         return this.slots.get(key);
     }
+    /** No longer served: sweeps over all workspaces (shutdown, the idle reaper) skip it. Its slots are dropped. */
+    close() {
+        this.isClosed = true;
+        known.delete(this);
+        this.slots.clear();
+    }
     peek(key) {
         return this.slots.get(key);
     }
@@ -48,6 +68,11 @@ export function setDefaultWorkspace(ws) {
     fallback = ws;
     return ws;
 }
+/** Whether the caller's workspace is still served (a background loop checks before its next round); true outside any. */
+export function workspaceOpen() {
+    const ws = storage.getStore() ?? fallback;
+    return !ws?.closed;
+}
 export function currentWorkspace() {
     const ws = storage.getStore() ?? fallback;
     if (!ws)

package/dist/dotenv.d.ts

@@ -2,8 +2,8 @@
  * The project's `.env`: KEY=VALUE lines next to kraftwerk.yml, loaded into
  * this process at CLI start (a commander preAction hook in kraftwerk.ts),
  * so every kraftwerk process sees them and everything it spawns inherits
- * them — the inspector, the chat agents and routines, workflow runs, the
- * tunnel (TUNNEL_TOKEN), `requires:` checks.
+ * them — the inspector, the chat agents and routines, workflow runs,
+ * `requires:` checks.
  *
  * A variable already set in the shell wins over the file, the dotenv
  * convention, with one exception that makes restarts work: a value this

package/dist/dotenv.js

@@ -4,8 +4,8 @@ import path from "node:path";
  * The project's `.env`: KEY=VALUE lines next to kraftwerk.yml, loaded into
  * this process at CLI start (a commander preAction hook in kraftwerk.ts),
  * so every kraftwerk process sees them and everything it spawns inherits
- * them — the inspector, the chat agents and routines, workflow runs, the
- * tunnel (TUNNEL_TOKEN), `requires:` checks.
+ * them — the inspector, the chat agents and routines, workflow runs,
+ * `requires:` checks.
  *
  * A variable already set in the shell wins over the file, the dotenv
  * convention, with one exception that makes restarts work: a value this

package/dist/server/api/devices.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod";
+/** Paired devices: other machines that use this one's kraftwerk (see core/devices.ts). */
+export declare const deviceRoutes: (import("./router.js").Route<"devices.code", {
+    code: string;
+    expiresAt: string;
+    urls: string[];
+}, "/api/devices/code", undefined> | import("./router.js").Route<"devices.list", {
+    devices: import("../../core/devices.js").Device[];
+}, "/api/devices", undefined> | import("./router.js").Route<"devices.pair", import("./router.js").Reply<{
+    token: string;
+    device: import("../../core/devices.js").Device;
+}>, "/api/pair", z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>> | import("./router.js").Route<"devices.revoke", {
+    ok: boolean;
+}, "/api/devices/:id", undefined> | import("./router.js").Route<"devices.self", {
+    trust: "device" | "local" | "none";
+    device?: import("../../core/devices.js").Device | undefined;
+}, "/api/devices/self", undefined>)[];

package/dist/server/api/devices.js

@@ -0,0 +1,55 @@
+import * as z from "zod";
+import { createPairCode, listDevices, redeemPairCode, revokeDevice } from "../../core/devices.js";
+import { networkUrls } from "../bind.js";
+import { DEVICE_COOKIE } from "../trust.js";
+import { ApiError, fail, reply, route } from "./router.js";
+/** Failed pairing attempts per peer, to make guessing a code pointless: a code is 8 characters from 31 and lives 10 minutes. */
+const failures = new Map();
+const MAX_FAILURES = 10;
+const FAILURE_WINDOW_MS = 10 * 60_000;
+function guard(peer) {
+    const now = Date.now();
+    const recent = (failures.get(peer) ?? []).filter((t) => now - t < FAILURE_WINDOW_MS);
+    failures.set(peer, recent);
+    if (recent.length >= MAX_FAILURES)
+        fail(429, "too many wrong pairing codes — wait a few minutes");
+}
+/** Paired devices: other machines that use this one's kraftwerk (see core/devices.ts). */
+export const deviceRoutes = [
+    // Public: an unpaired device trades a code for its token. A browser also gets the token as an
+    // HttpOnly cookie, so previews, downloads and the socket work without script access to it.
+    route({
+        name: "devices.pair",
+        method: "POST",
+        path: "/api/pair",
+        summary: "trade a pairing code {code, name} for a device token",
+        access: "public",
+        body: z.object({ code: z.string().min(1), name: z.string().default("") }),
+    }, async (c) => {
+        const peer = c.req?.socket.remoteAddress ?? "socket";
+        guard(peer);
+        const { code, name } = await c.body();
+        try {
+            const paired = await redeemPairCode(code, name);
+            const secure = c.req?.headers["x-forwarded-proto"] === "https" ? "; Secure" : "";
+            return reply(200, paired, {
+                "set-cookie": `${DEVICE_COOKIE}=${encodeURIComponent(paired.token)}; HttpOnly; SameSite=Strict; Path=/; Max-Age=34560000${secure}`,
+            });
+        }
+        catch (err) {
+            failures.get(peer)?.push(Date.now()) ?? failures.set(peer, [Date.now()]);
+            throw new ApiError(400, err.message);
+        }
+    }),
+    route({ name: "devices.self", method: "GET", path: "/api/devices/self", summary: "how this caller is trusted: this machine or a paired device" }, async (c) => ({
+        trust: c.trust.kind,
+        ...(c.trust.kind === "device" ? { device: c.trust.device } : {}),
+    })),
+    route({ name: "devices.list", method: "GET", path: "/api/devices", summary: "every paired device", access: "local" }, async () => ({ devices: await listDevices() })),
+    // The code is shown once; the addresses are where a device on the network opens kraftwerk (none while bound to this machine only).
+    route({ name: "devices.code", method: "POST", path: "/api/devices/code", summary: "a one-time pairing code, valid 10 minutes", access: "local" }, async (c) => ({
+        ...(await createPairCode()),
+        urls: networkUrls(c.req?.socket.localPort ?? 0),
+    })),
+    route({ name: "devices.revoke", method: "DELETE", path: "/api/devices/:id", summary: "unpair a device: its token stops working at once", access: "local" }, async (c) => (await revokeDevice(c.params.id)) ? { ok: true } : fail(404, "no such device")),
+];

package/dist/server/api/hub.d.ts

@@ -0,0 +1,25 @@
+import * as z from "zod";
+/** What a hub serves (server.ts Hub): the machine's open workspaces, and opening or closing one. Need no workspace. */
+export declare const hubRoutes: (import("./router.js").Route<"hub.close", {
+    ok: boolean;
+}, "/api/hub/close", z.ZodObject<{
+    root: z.ZodString;
+}, z.core.$strip>> | import("./router.js").Route<"hub.list", {
+    daemon: boolean;
+    port: number;
+    workspaces: {
+        slug: string;
+        name: string;
+        url: string;
+        aliasPort?: number | undefined;
+        root?: string | undefined;
+        rootLabel?: string | undefined;
+    }[];
+}, "/api/hub", undefined> | import("./router.js").Route<"hub.open", {
+    slug: string;
+    name: string;
+    url: string;
+    aliasPort?: number | undefined;
+}, "/api/hub/open", z.ZodObject<{
+    root: z.ZodString;
+}, z.core.$strip>>)[];

package/dist/server/api/hub.js

@@ -0,0 +1,32 @@
+import * as z from "zod";
+import { tildify } from "../../core/instances.js";
+import { currentHub } from "../hub-context.js";
+import { fail, route } from "./router.js";
+const Root = z.object({ root: z.string().min(1, "root is required") });
+/** What a hub serves (server.ts Hub): the machine's open workspaces, and opening or closing one. Need no workspace. */
+export const hubRoutes = [
+    // The folder is this machine's business; a paired device sees names and addresses.
+    route({ name: "hub.list", method: "GET", path: "/api/hub", summary: "the workspaces this kraftwerk serves: slug, name, address" }, async (c) => {
+        const hub = currentHub();
+        return {
+            daemon: hub.daemon,
+            port: hub.port,
+            workspaces: hub.list().map((o) => ({
+                slug: o.slug,
+                name: o.name,
+                url: o.url,
+                ...(o.aliasPort ? { aliasPort: o.aliasPort } : {}),
+                ...(c.trust.kind === "local" ? { root: o.root, rootLabel: tildify(o.root) } : {}),
+            })),
+        };
+    }),
+    route({ name: "hub.open", method: "POST", path: "/api/hub/open", summary: "serve a workspace {root} next to the others", access: "local", body: Root, errors: 400 }, async (c) => {
+        const { root } = await c.body();
+        const o = await currentHub().open(root);
+        return { slug: o.slug, name: o.name, url: o.url, ...(o.aliasPort ? { aliasPort: o.aliasPort } : {}) };
+    }),
+    route({ name: "hub.close", method: "POST", path: "/api/hub/close", summary: "stop serving a workspace {root}; the others keep running", access: "local", body: Root }, async (c) => {
+        const { root } = await c.body();
+        return (await currentHub().close(root)) ? { ok: true } : fail(404, "not open here");
+    }),
+];

package/dist/server/api/index.d.ts

@@ -284,7 +284,24 @@ export declare const routes: (Route<"agents.addJournal", {
     ok: true;
 }, "/api/chats/:id/task-stop", z.ZodObject<{
     taskId: z.ZodDefault<z.ZodString>;
-}, z.core.$strip>> | Route<"files.delete", {
+}, z.core.$strip>> | Route<"devices.code", {
+    code: string;
+    expiresAt: string;
+    urls: string[];
+}, "/api/devices/code", undefined> | Route<"devices.list", {
+    devices: import("../../core/devices.js").Device[];
+}, "/api/devices", undefined> | Route<"devices.pair", import("./router.js").Reply<{
+    token: string;
+    device: import("../../core/devices.js").Device;
+}>, "/api/pair", z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>> | Route<"devices.revoke", {
+    ok: boolean;
+}, "/api/devices/:id", undefined> | Route<"devices.self", {
+    trust: "device" | "local" | "none";
+    device?: import("../../core/devices.js").Device | undefined;
+}, "/api/devices/self", undefined> | Route<"files.delete", {
     ok: boolean;
 }, "/api/files", undefined> | Route<"files.list", import("../../core/files.js").FilesListing, "/api/files/list", undefined> | Route<"files.mkdir", import("./router.js").Reply<import("../../core/files.js").FileEntry>, "/api/files/folder", z.ZodObject<{
     scope: z.ZodOptional<z.ZodString>;
@@ -320,7 +337,29 @@ export declare const routes: (Route<"agents.addJournal", {
 }>, "/api/git/pull", undefined> | Route<"git.push", import("./router.js").Reply<{
     ok: boolean;
     error?: string;
-}>, "/api/git/push", undefined> | Route<"git.status", import("../../core/git.js").GitStatus, "/api/git", undefined> | Route<"knowledge.concept", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/concept", undefined> | Route<"knowledge.create", import("../../okf.js").BundleInfo, "/api/knowledge", z.ZodObject<{
+}>, "/api/git/push", undefined> | Route<"git.status", import("../../core/git.js").GitStatus, "/api/git", undefined> | Route<"hub.close", {
+    ok: boolean;
+}, "/api/hub/close", z.ZodObject<{
+    root: z.ZodString;
+}, z.core.$strip>> | Route<"hub.list", {
+    daemon: boolean;
+    port: number;
+    workspaces: {
+        slug: string;
+        name: string;
+        url: string;
+        aliasPort?: number | undefined;
+        root?: string | undefined;
+        rootLabel?: string | undefined;
+    }[];
+}, "/api/hub", undefined> | Route<"hub.open", {
+    slug: string;
+    name: string;
+    url: string;
+    aliasPort?: number | undefined;
+}, "/api/hub/open", z.ZodObject<{
+    root: z.ZodString;
+}, z.core.$strip>> | Route<"knowledge.concept", import("../../okf.js").ConceptDetail, "/api/knowledge/:bundle/concept", undefined> | Route<"knowledge.create", import("../../okf.js").BundleInfo, "/api/knowledge", z.ZodObject<{
     name: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>> | Route<"knowledge.delete", {
     ok: boolean;
@@ -331,6 +370,7 @@ export declare const routes: (Route<"agents.addJournal", {
     id: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>> | Route<"meta.get", {
     workspaceName: string;
+    workspaceSlug: string;
     workspaceIcon: string;
     workspaceColor: string;
     workspaceNamed: boolean;

package/dist/server/api/index.js

@@ -3,6 +3,8 @@ import { agentRoutes } from "./agents.js";
 import { attentionRoutes } from "./attention.js";
 import { channelRoutes } from "./channels.js";
 import { chatRoutes } from "./chats.js";
+import { deviceRoutes } from "./devices.js";
+import { hubRoutes } from "./hub.js";
 import { fileRoutes } from "./files.js";
 import { gitRoutes } from "./git.js";
 import { knowledgeRoutes } from "./knowledge.js";
@@ -32,8 +34,10 @@ const domainRoutes = [
     ...fileRoutes,
     ...gitRoutes,
     ...vibeableRoutes,
+    ...deviceRoutes,
+    ...hubRoutes,
 ];
-const protocolRoute = route({ name: "protocol.get", method: "GET", path: "/api/protocol", summary: "the protocol version and every route" }, async () => ({
+const protocolRoute = route({ name: "protocol.get", method: "GET", path: "/api/protocol", summary: "the protocol version and every route", access: "public" }, async () => ({
     version: PROTOCOL_VERSION,
     routes: describe(),
 }));

package/dist/server/api/router.d.ts

@@ -1,5 +1,6 @@
 import type http from "node:http";
 import * as z from "zod";
+import type { Trust } from "../trust.js";
 /**
  * The API's routing: every endpoint is one named route — an RPC-style name
  * (`projects.get`), an HTTP method + path pattern, and a handler that
@@ -24,14 +25,17 @@ export interface Ctx<B = Record<string, unknown>> {
     query: URLSearchParams;
     /** The JSON body (parsed by the route's schema when it has one); an empty body is `{}`, malformed JSON a 400. Read once. */
     body<T = B>(): Promise<T>;
+    /** Who is asking (see trust.ts). */
+    trust: Trust;
 }
-/** A result with a status other than 200 (201 created, 409 with a body, …). */
+/** A result with a status other than 200 (201 created, 409 with a body, …), and headers for HTTP (a cookie); the socket ignores them. */
 export declare class Reply<B> {
     readonly status: number;
     readonly body: B;
-    constructor(status: number, body: B);
+    readonly headers: Record<string, string>;
+    constructor(status: number, body: B, headers?: Record<string, string>);
 }
-export declare const reply: <B>(status: number, body: B) => Reply<B>;
+export declare const reply: <B>(status: number, body: B, headers?: Record<string, string>) => Reply<B>;
 /** A refusal with a status; the body is `{error}` unless given. */
 export declare class ApiError extends Error {
     readonly status: number;
@@ -53,6 +57,12 @@ export interface RouteDef<N extends string, P extends string = string, S extends
     upload?: boolean;
     /** The JSON body's schema: validated before the handler, typed for clients. */
     body?: S;
+    /**
+     * Who may call it. Default: anyone trusted (this machine, a paired
+     * device). `public`: also unpaired callers (pairing, the protocol).
+     * `local`: this machine only (managing devices).
+     */
+    access?: "public" | "local";
 }
 /** What `c.body()` returns: the schema's output, else a loose object. */
 export type BodyOf<S> = S extends z.ZodType ? z.output<S> : Record<string, unknown>;
@@ -70,17 +80,22 @@ export type PathOf<R> = R extends Route<string, unknown, infer P, z.ZodType | un
 export declare const statusByMessage: (missing: RegExp) => (message: string) => number;
 export interface Router {
     routes: readonly Route[];
-    handle(req: http.IncomingMessage, res: http.ServerResponse, url: URL): Promise<void>;
+    handle(req: http.IncomingMessage, res: http.ServerResponse, url: URL, trust: Trust): Promise<void>;
     /**
      * Run a route by name without HTTP (the socket): path parameters by name,
      * `query` and `body` beside them. Raw and upload routes are refused.
      */
-    invoke(name: string, input: Record<string, unknown>): Promise<{
+    invoke(name: string, input: Record<string, unknown>, trust: Trust): Promise<{
         status: number;
         data: unknown;
     }>;
+    /** Why `trust` may not call route `name` ({status, error}), or undefined when it may. */
+    allowed(name: string, trust: Trust): {
+        status: number;
+        error: string;
+    } | undefined;
 }
-export declare function json(res: http.ServerResponse, body: unknown, status?: number): void;
+export declare function json(res: http.ServerResponse, body: unknown, status?: number, headers?: Record<string, string>): void;
 export declare function readBody(req: http.IncomingMessage): Promise<string>;
 /** A raw upload body (attachments), capped at `max` bytes. */
 export declare function readRawBody(req: http.IncomingMessage, max: number): Promise<Buffer>;

package/dist/server/api/router.js

@@ -1,15 +1,17 @@
 import * as z from "zod";
 import { touch } from "../live.js";
-/** A result with a status other than 200 (201 created, 409 with a body, …). */
+/** A result with a status other than 200 (201 created, 409 with a body, …), and headers for HTTP (a cookie); the socket ignores them. */
 export class Reply {
     status;
     body;
-    constructor(status, body) {
+    headers;
+    constructor(status, body, headers = {}) {
         this.status = status;
         this.body = body;
+        this.headers = headers;
     }
 }
-export const reply = (status, body) => new Reply(status, body);
+export const reply = (status, body, headers) => new Reply(status, body, headers);
 /** A refusal with a status; the body is `{error}` unless given. */
 export class ApiError extends Error {
     status;
@@ -37,6 +39,16 @@ function validate(route, raw) {
 }
 /** Maps an error message to a status by the usual wording: "no <thing>" is 404, "… are off" 409, else 400. */
 export const statusByMessage = (missing) => (message) => missing.test(message) ? 404 : /are off/.test(message) ? 409 : 400;
+/** Why a caller may not use a route, or undefined when it may. */
+function refusal(route, trust) {
+    if (route.access === "public")
+        return undefined;
+    if (trust.kind === "none")
+        return new ApiError(401, "pair this device first", { error: "pair this device first", pair: true });
+    if (route.access === "local" && trust.kind !== "local")
+        return new ApiError(403, "only on the machine kraftwerk runs on");
+    return undefined;
+}
 /** What a thrown error becomes: an ApiError's status and body, else the route's mapping. */
 function failure(route, err) {
     if (err instanceof ApiError)
@@ -44,11 +56,11 @@ function failure(route, err) {
     const message = err.message;
     return { status: typeof route.errors === "function" ? route.errors(message) : (route.errors ?? 500), data: { error: message } };
 }
-export function json(res, body, status = 200) {
+export function json(res, body, status = 200, headers = {}) {
     // A late error on an SSE response must not try to write headers again.
     if (res.headersSent)
         return void res.end();
-    res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+    res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", ...headers });
     res.end(JSON.stringify(body));
 }
 export function readBody(req) {
@@ -119,12 +131,16 @@ export function createRouter(routes) {
     };
     return {
         routes,
-        async handle(req, res, url) {
+        async handle(req, res, url, trust) {
             const seg = url.pathname.split("/").filter(Boolean);
             const found = match(req.method ?? "GET", seg);
+            // An unpaired caller learns nothing about which routes exist.
             if (!found)
-                return json(res, { error: "not found" }, 404);
+                return trust.kind === "none" ? json(res, { error: "pair this device first", pair: true }, 401) : json(res, { error: "not found" }, 404);
             const { route } = found;
+            const refused = refusal(route, trust);
+            if (refused)
+                return json(res, refused.body, refused.status);
             let bodyRead;
             try {
                 const params = Object.fromEntries(Object.entries(found.params).map(([k, v]) => [k, decode(v)]));
@@ -133,6 +149,7 @@ export function createRouter(routes) {
                     res,
                     url,
                     params,
+                    trust,
                     query: url.searchParams,
                     body: () => (bodyRead ??= readBody(req).then((raw) => {
                         if (!raw.trim())
@@ -153,7 +170,7 @@ export function createRouter(routes) {
                 if (route.raw)
                     return;
                 if (result instanceof Reply)
-                    return json(res, result.body, result.status);
+                    return json(res, result.body, result.status, result.headers);
                 return json(res, result);
             }
             catch (err) {
@@ -161,10 +178,20 @@ export function createRouter(routes) {
                 return json(res, f.data, f.status);
             }
         },
-        async invoke(name, input) {
+        allowed(name, trust) {
+            const route = byName.get(name);
+            if (!route)
+                return { status: 404, error: `no route ${name}` };
+            const refused = refusal(route, trust);
+            return refused ? { status: refused.status, error: refused.message } : undefined;
+        },
+        async invoke(name, input, trust) {
             const route = byName.get(name);
             if (!route)
                 return { status: 404, data: { error: `no route ${name}` } };
+            const refused = refusal(route, trust);
+            if (refused)
+                return { status: refused.status, data: refused.body };
             if (route.raw || route.upload)
                 return { status: 400, data: { error: `${name} is HTTP only` } };
             try {
@@ -183,6 +210,7 @@ export function createRouter(routes) {
                     url: new URL(`http://invoke${route.path}`),
                     params,
                     query,
+                    trust,
                     body: async () => validate(route, input.body ?? {}),
                 };
                 const result = await route.handle(c);

package/dist/server/api/socket.d.ts

@@ -1,3 +1,17 @@
 import type { Workspace } from "../../core/workspace.js";
+import type { Hub } from "../server.js";
+import type { Trust } from "../trust.js";
 import type { Socket } from "../ws.js";
-export declare function serveSocket(conn: Socket, workspace: Workspace, version: string): void;
+/**
+ * `recheck` re-derives the connection's trust (a device's token may have
+ * been revoked since it connected): a device whose answer is no longer
+ * `device` is disconnected at once (close code 4401).
+ */
+/**
+ * `workspaceOf` finds the workspace a message is for: its `ws` (a slug), or
+ * the connection's own (the one the socket was opened for) when it names
+ * none. A daemon's socket opened at its root has no workspace of its own:
+ * there, a message without `ws` reaches only the machine's routes (hub,
+ * devices, protocol).
+ */
+export declare function serveSocket(conn: Socket, workspaceOf: (slug?: string) => Workspace | undefined, version: string, trust: Trust, recheck: () => Promise<Trust>, hub: Hub): void;