@songsid/agend 2.3.1 → 2.3.2-beta.10

package/dist/web-api.js

@@ -15,6 +15,7 @@ import { AGENT_WIDGET_SLOTS, checkWidgetData, checkWidgetSpec } from "./web-widg
 import { checkOwnerCss, ownerCssAssetRefs } from "./web-owner-css.js";
 import { canonicalText } from "./web-theme.js";
 import { EFFECT_WIRE_LIMIT } from "./web-effect-upload.js";
+import { SKIN_WIRE_BYTES } from "./web-office-skins.js";
 import { gatewayRequestContext } from "./web-request-context.js";
 import { crossInstanceVisibility } from "./cross-instance-notice.js";
 import { permitWebContinuation } from "./web-continuation.js";
@@ -447,6 +448,230 @@ function handleAppIcon(req, res, url, ctx, method) {
     });
     return true;
 }
+/**
+ * #2636: Office share links — GET /ui/office-share (the open ones, and whether this fleet offers them), POST { office,
+ * minutes?, text? } (a new one; answers its URL once its tunnel is up, or why not), DELETE /ui/office-share/<id|all>.
+ * An admin session only — on the dashboard reached directly, or (the user, #2636 follow-up) a fleet admin signed in over
+ * the /web public link: the same check either way. Never the CLI token, a read-only session or a guest. The share's own
+ * tunnel and gateway stay apart from /web's. The person is asked again once the body is in.
+ */
+function handleOfficeShare(req, res, url, ctx, path, method) {
+    const service = ctx.officeShares;
+    if (!service) {
+        json(res, 404, { error: "Office share links are not kept on this fleet" });
+        return true;
+    }
+    const one = /^\/ui\/office-share\/([0-9a-f]{8}|all)$/.exec(path);
+    const known = (method === "GET" && path === "/ui/office-share") || (method === "POST" && path === "/ui/office-share") || (method === "DELETE" && !!one);
+    if (!known) {
+        json(res, 404, { error: "not found" });
+        return true;
+    }
+    const who = () => {
+        const verdict = evaluateWebRequest(req, url, ctx.webToken ?? null, ctx.webSessions, { touch: false });
+        if (verdict.kind !== "allow")
+            return { status: 401 };
+        if (verdict.via !== "session" || verdict.session?.tier !== "admin")
+            return { status: 403 };
+        const owner = verdict.session.owner;
+        return { person: owner ? webPersonKey(owner) : "admin-session", name: owner ? ctx.webPerson?.(owner)?.name ?? owner.userId : "admin" };
+    };
+    const refuse = (status) => json(res, status, { error: status === 401 ? WEB_TOKEN_INVALID_MESSAGE : "office_share_needs_an_admin_session" });
+    const first = who();
+    if ("status" in first) {
+        refuse(first.status);
+        return true;
+    }
+    res.setHeader("Cache-Control", "no-store");
+    if (method === "GET") {
+        // Each with its office's name as it is now (Settings' card has no office list of its own).
+        const names = new Map((ctx.officeStore?.list().offices ?? []).map(o => [o.id, o.name]));
+        json(res, 200, { enabled: service.enabled(), shares: service.list().map(s => ({ ...s, ...(names.has(s.office) ? { office_name: names.get(s.office) } : {}) })) });
+        return true;
+    }
+    if (method === "DELETE") {
+        const id = one[1];
+        const before = id === "all" ? null : service.list().find(s => s.id === id) ?? null;
+        const n = service.revoke(id);
+        if (n)
+            ctx.officeShareNotice?.("revoked", first.name, before, n);
+        json(res, n ? 200 : 404, n ? { revoked: n } : { error: "not_found" });
+        return true;
+    }
+    (async () => {
+        let body;
+        try {
+            body = await parseBody(req);
+        }
+        catch {
+            json(res, 400, { error: "Invalid JSON" });
+            return;
+        }
+        if (!permitWebContinuation(req, res, ctx))
+            return;
+        const now = who();
+        if ("status" in now) {
+            refuse(now.status);
+            return;
+        }
+        if (!body || typeof body !== "object" || Array.isArray(body) || typeof body.office !== "string"
+            || (body.minutes !== undefined && typeof body.minutes !== "number") || (body.text !== undefined && typeof body.text !== "boolean")) {
+            json(res, 400, { error: "office (string), minutes? (number), text? (boolean)" });
+            return;
+        }
+        const made = await service.create({ office: body.office, owner: now.person, ...(typeof body.minutes === "number" ? { minutes: body.minutes } : {}),
+            ...(typeof body.text === "boolean" ? { text: body.text } : {}) });
+        if (!made.ok) {
+            const status = made.error === "disabled" ? 404 : made.error === "tunnel" ? 503 : made.error === "too_many" ? 409 : 400;
+            json(res, status, { error: made.error, ...(made.reason ? { reason: made.reason } : {}) });
+            return;
+        }
+        ctx.officeShareNotice?.("created", now.name, made.share, 1);
+        json(res, 200, { share: made.share, url: made.url });
+    })().catch(err => {
+        ctx.logger.error({ err: err.message }, "Office share failed");
+        try {
+            json(res, 500, { error: "Office share failed" });
+        }
+        catch { /* already answered */ }
+    });
+    return true;
+}
+/**
+ * #2513: the Office view's skin packs (web-office-skins.ts). The reads are the offices' (GET /ui/offices): whoever may
+ * open the org chart, the public link too (its manifest lists them; a guest's routes do not): the list, a pack's
+ * manifest (?v=<sha>: immutable, else no-store) and its pictures (by the sha of their bytes: immutable, image/png,
+ * nosniff, sandboxed). The writes are PUT /ui/offices's: an admin session only — never the CLI token, never the public
+ * link (absent from its manifest, and refused here too) — asked again once the body is in; rate limited per person.
+ * Every page hears `office_skins` on the stream and reads the list again.
+ */
+function handleOfficeSkins(req, res, url, ctx, path, method) {
+    const store = ctx.officeSkins;
+    if (!store) {
+        json(res, 404, { error: "Skin packs are not kept on this fleet" });
+        return true;
+    }
+    const one = /^\/ui\/office-skins\/([A-Za-z0-9_-]{1,40})$/.exec(path);
+    const picture = /^\/ui\/office-skins\/([A-Za-z0-9_-]{1,40})\/img\/([0-9a-f]{32})\.png$/.exec(path);
+    if (method === "GET" || method === "HEAD") {
+        res.setHeader("X-Content-Type-Options", "nosniff");
+        if (path === "/ui/office-skins") {
+            res.setHeader("Cache-Control", "private, no-store");
+            json(res, 200, store.list());
+            return true;
+        }
+        if (one) {
+            const pack = store.get(one[1]);
+            if (!pack) {
+                res.setHeader("Cache-Control", "private, no-store");
+                json(res, 404, { error: "skin_unknown" });
+                return true;
+            }
+            const v = url.searchParams.get("v");
+            res.setHeader("Cache-Control", v === pack.sha ? "private, max-age=31536000, immutable" : "private, no-store");
+            json(res, 200, pack);
+            return true;
+        }
+        if (picture) {
+            const bytes = store.picture(picture[1], picture[2]);
+            if (!bytes) {
+                res.setHeader("Cache-Control", "private, no-store");
+                json(res, 404, { error: "No such image" });
+                return true;
+            }
+            res.setHeader("Content-Type", "image/png");
+            // Keyed by the sha of its bytes: a picture at this URL never changes.
+            res.setHeader("Cache-Control", "private, max-age=31536000, immutable");
+            res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
+            res.writeHead(200);
+            res.end(method === "HEAD" ? undefined : bytes);
+            return true;
+        }
+        json(res, 404, { error: "not found" });
+        return true;
+    }
+    const upload = method === "POST" && path === "/ui/office-skins", removal = method === "DELETE" && !!one;
+    if (!upload && !removal) {
+        json(res, 404, { error: "not found" });
+        return true;
+    }
+    if (gatewayRequestContext(req)) {
+        json(res, 403, { error: "skins_not_over_public_link" });
+        return true;
+    }
+    const who = () => {
+        const verdict = evaluateWebRequest(req, url, ctx.webToken ?? null, ctx.webSessions, { touch: false });
+        if (verdict.kind !== "allow")
+            return { status: 401 };
+        return verdict.via === "session" && verdict.session?.tier === "admin" ? { person: verdict.session.owner ? webPersonKey(verdict.session.owner) : "admin-session" } : { status: 403 };
+    };
+    const refuse = (status) => json(res, status, { error: status === 401 ? WEB_TOKEN_INVALID_MESSAGE : "skins_need_an_admin_session" });
+    const first = who();
+    if ("status" in first) {
+        refuse(first.status);
+        return true;
+    }
+    const limited = (person) => {
+        const allowed = ctx.officeSkinWrites ? ctx.officeSkinWrites.check(person) : { ok: true };
+        if (allowed.ok)
+            return false;
+        res.setHeader("Retry-After", String(allowed.retry_after_s));
+        json(res, 429, { error: "skins_rate_limited", retry_after_s: allowed.retry_after_s });
+        return true;
+    };
+    const answer = (r, body, person) => {
+        if (!r.ok) {
+            json(res, r.status, { error: r.error, ...(r.detail ? { detail: r.detail } : {}) });
+            return;
+        }
+        ctx.officeSkinWrites?.record(person);
+        ctx.emitSseEvent("office_skins", { rev: r.rev });
+        json(res, 200, body());
+    };
+    if (removal) {
+        if (limited(first.person))
+            return true;
+        const r = store.remove(one[1]);
+        answer(r, () => ({ rev: r.ok ? r.rev : "" }), first.person);
+        return true;
+    }
+    (async () => {
+        let bytes;
+        try {
+            bytes = await readBoundedWebBody(req, SKIN_WIRE_BYTES);
+        }
+        catch {
+            json(res, 413, { error: "skin_too_large", detail: `at most ${Math.floor(SKIN_WIRE_BYTES / 1024 / 1024)} MiB a request` });
+            return;
+        }
+        if (!permitWebContinuation(req, res, ctx))
+            return;
+        const now = who();
+        if ("status" in now) {
+            refuse(now.status);
+            return;
+        }
+        let body;
+        try {
+            body = JSON.parse(bytes.toString("utf8"));
+        }
+        catch {
+            json(res, 400, { error: "Invalid JSON" });
+            return;
+        }
+        if (limited(now.person))
+            return;
+        const r = store.add(body, now.person);
+        answer(r, () => (r.ok ? { rev: r.rev, pack: r.pack } : null), now.person);
+    })().catch(err => {
+        ctx.logger.error({ err: err.message }, "Uploading a skin pack failed");
+        try {
+            json(res, 500, { error: "Uploading a skin pack failed" });
+        }
+        catch { /* already answered */ }
+    });
+    return true;
+}
 /**
  * #1629 r4 §3: the owner-CSS routes (see their call site). `who()`, asked first and again after any body: the person a
  * signed-in human session is, or the status to answer.
@@ -782,6 +1007,103 @@ function handleEffectTrials(req, res, url, ctx, path, method) {
     catch { /* response ended */ } });
     return true;
 }
+/** #2599: the same closed browser controls as setup, for a current local human admin. */
+function handleBrowserBackendSignIns(req, res, url, ctx) {
+    res.setHeader("Cache-Control", "private, no-store");
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    const reading = req.method === "GET";
+    if (gatewayRequestContext(req)) {
+        json(res, reading ? 404 : 403, { error: "sign_in_not_over_public_link" });
+        return true;
+    }
+    const who = () => {
+        const v = evaluateWebRequest(req, url, ctx.webToken ?? null, ctx.webSessions, { touch: false });
+        return v.kind === "allow" && v.via === "session" && v.session.tier === "admin" && v.session.surface === "local" ? v.session : null;
+    };
+    const owner = who();
+    if (!owner) {
+        json(res, 403, { error: "sign_in_needs_a_local_admin" });
+        return true;
+    }
+    if (!["GET", "POST"].includes(req.method ?? "") || [...url.searchParams.keys()].length) {
+        json(res, 404, { error: "not_found" });
+        return true;
+    }
+    const service = ctx.browserBackendSignIns;
+    if (!service) {
+        json(res, 404, { error: "sign_in_unavailable" });
+        return true;
+    }
+    void (async () => {
+        let result;
+        if (reading)
+            result = await service.refresh(owner);
+        else {
+            let bytes;
+            try {
+                bytes = await readBoundedWebBody(req, 8192);
+            }
+            catch {
+                json(res, 413, { error: "sign_in_body_bound" });
+                return;
+            }
+            if (!permitWebContinuation(req, res, ctx))
+                return;
+            if (who() !== owner) {
+                json(res, 409, { error: "signin_session_expired" });
+                return;
+            }
+            let body;
+            try {
+                body = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+            }
+            catch {
+                json(res, 400, { error: "sign_in_json" });
+                return;
+            }
+            const parsed = z.discriminatedUnion("operation", [
+                z.strictObject({ operation: z.literal("select"), backends: z.array(z.enum(["kiro-cli", "claude-code", "codex", "antigravity"])).max(4) }),
+                z.strictObject({ operation: z.literal("start"), backend: z.enum(["kiro-cli", "claude-code", "codex"]), relogin: z.boolean().optional() }),
+                z.strictObject({ operation: z.literal("input"), id: z.string().regex(/^[0-9a-f]{32}$/), revision: z.number().int().nonnegative(), action: z.discriminatedUnion("kind", [
+                        z.strictObject({ kind: z.literal("method"), choice: z.string().max(32) }),
+                        z.strictObject({ kind: z.enum(["code", "start_url", "region"]), value: z.string().max(4096) }),
+                    ]) }),
+                z.strictObject({ operation: z.literal("skip"), backend: z.enum(["kiro-cli", "claude-code", "codex", "antigravity"]) }),
+                z.strictObject({ operation: z.literal("cancel") }), z.strictObject({ operation: z.literal("refresh") }),
+            ]).safeParse(body);
+            if (!parsed.success) {
+                json(res, 400, { error: "invalid_signin_action" });
+                return;
+            }
+            const action = parsed.data;
+            if (action.operation === "select")
+                result = await service.select(owner, action.backends);
+            else if (action.operation === "start")
+                result = await service.begin(owner, action.backend, action.relogin === true);
+            else if (action.operation === "input")
+                result = await service.input(owner, action.id, action.revision, action.action);
+            else if (action.operation === "skip")
+                result = await service.skip(owner, action.backend);
+            else if (action.operation === "cancel")
+                result = await service.cancel(owner);
+            else
+                result = await service.refresh(owner, true);
+        }
+        if (!permitWebContinuation(req, res, ctx))
+            return;
+        if (who() !== owner) {
+            json(res, 409, { error: "signin_session_expired" });
+            return;
+        }
+        json(res, 200, result);
+    })().catch(error => {
+        const code = error instanceof Error ? error.message : "";
+        const safe = /^(?:signin_(?:session_expired|console_only|cleanup_failed|action_(?:stale|invalid|ended|busy))|invalid_signin_(?:action|checklist))$/.test(code) ? code : "signin_failed";
+        if (!res.destroyed && !res.writableEnded)
+            json(res, safe === "signin_cleanup_failed" || safe === "signin_failed" ? 503 : 409, { error: safe });
+    });
+    return true;
+}
 /**
  * #2233: signing a backend in from the dashboard (web-backend-login.ts). A signed-in admin session on the local surface
  * only — never the CLI's header token (an agent's), a guest, a read session or the public link (refused before the body
@@ -1311,11 +1633,13 @@ function webAuthorityOf(req, url, ctx, instance) {
         peer: webPeerOf(req), ...(instance !== undefined ? { instance } : {}) });
 }
 /**
- * #1939 §3.4 / #2453 §0.2: where this request came from — the admin's named link by the gateway's own provenance (its
- * exact hostname), else what the TCP peer and Host say (a quick tunnel's request is `lan`, and refused as public_link).
+ * #1939 §3.4 / #2453 §0.2 / §0.3: where this request came from — over the public gateway, the link itself by the
+ * gateway's own provenance (never a header): the admin's named tunnel on its exact hostname, else the temporary
+ * quick-tunnel link. Off the gateway, what the TCP peer and Host say.
  */
 export function webPeerOf(req) {
-    return gatewayRequestContext(req)?.named === true ? "named_link" : classifyWebPeer(req);
+    const gateway = gatewayRequestContext(req);
+    return gateway ? (gateway.named === true ? "named_link" : "quick_link") : classifyWebPeer(req);
 }
 /**
  * #2122: what let this request in, asked now — its session (by handle, under the token it was signed in with) or the
@@ -2074,6 +2398,21 @@ export function handleWebRequest(req, res, url, ctx) {
         });
         return true;
     }
+    // #2578: GET /ui/office-acts { acts }: the agents' live acts (office_set), read as the offices are (the public link
+    // too, which has no stream); every change also comes as `office_acts` on the stream. Nothing here writes one.
+    if (method === "GET" && path === "/ui/office-acts") {
+        const acts = ctx.officeActs;
+        if (!acts) {
+            json(res, 404, { error: "Office acts are not kept on this fleet" });
+            return true;
+        }
+        json(res, 200, { acts: acts.live(), now: Date.now() }); // now: the host's clock, for the page's offset
+        return true;
+    }
+    if (path === "/ui/office-skins" || path.startsWith("/ui/office-skins/"))
+        return handleOfficeSkins(req, res, url, ctx, path, method);
+    if (path === "/ui/office-share" || path.startsWith("/ui/office-share/"))
+        return handleOfficeShare(req, res, url, ctx, path, method);
     // ── #1630: avatars and Discord server emoji, same-origin (the page never loads a platform's CDN; img-src stays 'self') ──
     const imageMatch = path.match(/^\/ui\/img\/(bot|avatar|emoji)\/([^/]+)$/);
     if (method === "GET" && imageMatch) {
@@ -2422,6 +2761,8 @@ export function handleWebRequest(req, res, url, ctx) {
     if (path === "/ui/effect-trials" || path.startsWith("/ui/effect-trials/"))
         return handleEffectTrials(req, res, url, ctx, path, method);
     // #2233: backend sign-in — absent from the public manifest and the guest table, and refused here too.
+    if (path === "/ui/browser-backend-signins")
+        return handleBrowserBackendSignIns(req, res, url, ctx);
     if (path === "/ui/backend-login" || path.startsWith("/ui/backend-login/"))
         return handleBackendLogin(req, res, url, ctx, path, method);
     if (path === "/ui/effects" || path.startsWith("/ui/effects/"))
@@ -3268,10 +3609,10 @@ export function handleWebRequest(req, res, url, ctx) {
                 return [403, "usage_report_not_over_public_link"];
             return null;
         };
-        // Over the public link, where to turn it on: Settings → Web on the dashboard reached directly (this computer's own
+        // Over the public link, where to turn it on: Settings → Web dashboard on the dashboard reached directly (this computer's own
         // address — the public link's Settings only reads). Never the public origin's own Settings, which cannot change it.
         const answer = ([status, error]) => json(res, status, {
-            error, ...(status === 403 ? { settings: `http://localhost:${ctx.fleetConfig?.health_port ?? 19280}/settings/web` } : {})
+            error, ...(status === 403 ? { settings: `http://localhost:${ctx.fleetConfig?.health_port ?? 19280}/settings/web-dashboard` } : {})
         });
         const first = refusal();
         if (first) {
@@ -3866,6 +4207,11 @@ function handleUpload(req, res, url, ctx) {
     // staging a file never wakes it. A stopped or deleted recipient must not regain an upload id.
     const deliverable = () => uploadRecipient(ctx, instance);
     const gone = () => drop(() => json(res, 404, { error: `Instance not found: ${instance}` }));
+    // #2366: a guest's scope (and whether guests may chat) is asked again at each commit point — narrowed, revoked or made
+    // read-only while the body was arriving, the upload is refused and its part file removed, as it would have been at
+    // the start. Read now: the scope is never stored (guestRequestOf's scope() is the fleet's guestScope as it is now).
+    const guestNow = () => guestChatRefusal(guestRequestOf(req), instance);
+    const refuseGuest = (r) => drop(() => json(res, r.status, { error: r.error }));
     req.on("end", () => {
         if (over)
             return;
@@ -3880,6 +4226,11 @@ function handleUpload(req, res, url, ctx) {
             drop(() => json(res, 415, { error: "the file is empty" }));
             return;
         }
+        const refusedAtEnd = guestNow();
+        if (refusedAtEnd) {
+            refuseGuest(refusedAtEnd);
+            return;
+        }
         if (!deliverable()) {
             gone();
             return;
@@ -3892,6 +4243,11 @@ function handleUpload(req, res, url, ctx) {
                 drop();
                 return;
             }
+            const refusedAtFinish = guestNow(); // #2366: and the guest's scope may have changed in it
+            if (refusedAtFinish) {
+                refuseGuest(refusedAtFinish);
+                return;
+            }
             if (!deliverable()) {
                 gone();
                 return;