@songsid/agend 2.3.0-beta.2 → 2.3.0-beta.4

package/dist/web-api.js

@@ -1,4 +1,5 @@
 import { webHumanOrigin } from "./human-delivery-receipts.js";
+import { guestChatRefusal, guestCommandText, guestDeliveries, guestFrameData, guestHistory, guestMessages, guestPollBody, guestPrefs, guestRequestOf, guestSeesMessage, guestStatus } from "./web-guest-access.js";
 import { withSpawnHoldReply } from "./spawn-hold-reply.js";
 import { binaryProbe } from "./binary-probe.js";
 import { settingsRequestExecution, settingsWrite, isSettingsReplay } from "./settings-request-capability.js";
@@ -97,11 +98,41 @@ const safeInstanceSegment = (name) => /^[^\\/\x00]+$/.test(name) && name !== "."
  * the eviction the dead entry leaks forever, and without the try/catch a
  * single dead client breaks delivery to every client iterated after it.
  */
+/** #1920 phase 1b: the open streams that are a guest's, and whose — each event is projected for them (guestFrameData). */
+const streamGuests = new WeakMap();
+/**
+ * #1920 §5.2: one event for the guests' streams only, each as projected for it — a message that has just become what
+ * its channel saw (an admin's page already has it, unchanged).
+ */
+export function broadcastToGuests(clients, event, data, onError) {
+    const guests = [...clients].filter((c) => streamGuests.has(c));
+    if (!guests.length)
+        return;
+    const live = new Set(guests);
+    broadcastSseEvent(live, event, data, onError);
+    for (const c of guests)
+        if (!live.has(c))
+            clients.delete(c); // the ones it ended (their session went)
+}
 export function broadcastSseEvent(clients, event, data, onError, id) {
     const payload = sseFrame(event, data, id);
     const dead = [];
     for (const client of clients) {
         try {
+            // An admin's stream gets these bytes; a guest's, the event as projected for its scope now, or nothing (no id: it
+            // never replays chat, so a cursor of the admin's stream is not its to hold).
+            const guest = streamGuests.get(client);
+            if (guest) {
+                // The exact session that opened it ended (revoked, expired, rotated away): nothing more, and the stream goes.
+                if (!guest.current()) {
+                    dead.push(client);
+                    continue;
+                }
+                const shown = guestFrameData(event, data, guest.scope(), guest);
+                if (shown !== undefined)
+                    client.write(sseFrame(event, shown));
+                continue;
+            }
             client.write(payload);
         }
         catch (err) {
@@ -382,7 +413,7 @@ function handleEffectTrials(req, res, url, ctx, path, method) {
                 css = value;
         }
         catch { /* unavailable is never off */ }
-        // CSS remains a checked runtime value. The authority refuses anything except off on start/read.
+        // CSS is diagnostic for Try; its host-owned shadow shell isolates controls and local paint.
         const actor = Object.freeze({ via: "session", surface: "local", tier: "admin", sessionHash: v.session.idHash, epoch: v.session.handle, person, ownerCss: css });
         return { actor, record: v.session, sessions };
     };
@@ -946,6 +977,17 @@ export function handleWebRequest(req, res, url, ctx) {
         return true;
     }
     // ── Backend detection ─────────────────────────────────
+    // #2072: the model a Settings field offers — the cached catalog of that backend (that instance's account's). Read only.
+    if (method === "GET" && path === "/ui/models") {
+        const backend = url.searchParams.get("backend") ?? "";
+        const instance = url.searchParams.get("instance");
+        if (!/^[a-z][a-z0-9-]{0,31}$/.test(backend) || (instance !== null && (instance.length < 1 || instance.length > 256))) {
+            json(res, 400, { error: "backend (and optional instance) required" });
+            return true;
+        }
+        json(res, 200, { backend, models: ctx.modelCatalogFor?.(backend, instance) ?? [] });
+        return true;
+    }
     if (method === "GET" && path === "/ui/backends") {
         const BACKENDS = [
             { name: "claude-code", binary: "claude" },
@@ -956,6 +998,16 @@ export function handleWebRequest(req, res, url, ctx) {
             { name: "grok", binary: "grok" },
             { name: "muse", binary: "muse" },
         ];
+        // #2072: the published availability snapshot — installed, signed in, new enough — when the fleet has one.
+        if (ctx.backendAvailabilityRows) {
+            const binaryOf = new Map(BACKENDS.map(b => [b.name, b]));
+            const backends = ctx.backendAvailabilityRows().filter(r => binaryOf.has(r.backend)).map(r => ({
+                name: r.backend, binary: binaryOf.get(r.backend).binary, installed: r.state !== "not_installed" && r.path !== null, path: r.path ?? "",
+                deprecated: binaryOf.get(r.backend).deprecated ?? false, state: r.state, minVersion: r.minVersion, ...(r.state === "unknown" ? { unknown: true } : {}),
+            }));
+            json(res, 200, { backends });
+            return true;
+        }
         // #1490: seven sequential 2 s `execFileSync("which")` calls used to block the event loop here. The shared probe
         // runs `which` as bounded async children and reuses an answer for BINARY_PROBE_TTL_MS. `unknown`: no answer in
         // time (shown as not installed, as the old timeout was).
@@ -978,9 +1030,24 @@ export function handleWebRequest(req, res, url, ctx) {
     // that arrived while the stream was silent is not skipped by the cursor this answer hands out (#1251
     // review). The page keeps one entry per boot+id, so what it already loaded from /ui/history is not doubled.
     if (method === "GET" && path === "/ui/poll") {
+        // #1920: a guest's poll is projected for its scope (web-guest-access.ts) — the same rule as its stream.
+        const guest = guestRequestOf(req);
         const history = ctx.webChatHistory;
         const after = url.searchParams.get("after");
         const fresh = after === null || after === ""; // a cursor that is not ours in shape still gets nothing
+        if (guest) {
+            // #2085 review: and what became the channel's after its cursor (an older row, its copy sent since), once each.
+            json(res, 200, guestPollBody(ctx.getUiStatus(), guest.scope(), Date.now(), guest, after, () => {
+                if (!history)
+                    return [];
+                if (fresh)
+                    return history.after(0);
+                const cursor = parseLastEventId(after);
+                const rows = [...history.replayFor(cursor), ...history.seenAfter(cursor)];
+                return rows.filter((m, i) => rows.findIndex((x) => x.boot === m.boot && x.id === m.id) === i);
+            }));
+            return true;
+        }
         json(res, 200, {
             status: ctx.getUiStatus(),
             messages: history ? (fresh ? history.after(0) : history.replayFor(parseLastEventId(after))) : [],
@@ -1013,30 +1080,49 @@ export function handleWebRequest(req, res, url, ctx) {
         });
         // #1823 (#1830 review): with the status, the server's clock — now and with every heartbeat — that the page counts a
         // poll down by (one write: the frames a connect sends are unchanged in number).
-        res.write(`event: status\ndata: ${JSON.stringify(ctx.getUiStatus())}\n\n${sseClock()}`);
+        // #1920: a guest's stream: its projected status now and with each heartbeat, its replay and ticks as it may see them
+        // (§5.2), then only what guestFrameData lets through — no prompts or Needs you.
+        const guest = guestRequestOf(req);
+        if (guest) {
+            streamGuests.set(res, guest);
+            guest.streamOpened?.();
+        }
+        const statusFrame = () => `event: status\ndata: ${JSON.stringify(guest ? guestStatus(ctx.getUiStatus(), guest.scope()) : ctx.getUiStatus())}\n\n`;
+        res.write(`${statusFrame()}${sseClock()}`);
         // An EventSource that reconnects says what it last saw: send what it missed, before anything new.
         const lastSeen = parseLastEventId(req.headers["last-event-id"]);
         if (lastSeen !== null && ctx.webChatHistory) {
             const history = ctx.webChatHistory;
-            for (const m of history.replayFor(lastSeen))
-                res.write(sseFrame("message", m, history.cursorOf(m)));
+            if (guest) {
+                // Its own projection, with no cursor: an admin's ids are not a guest's to hold (it reloads its history instead).
+                for (const m of guestMessages(history.replayFor(lastSeen), guest, guest.scope()))
+                    res.write(sseFrame("message", m));
+            }
+            else {
+                for (const m of history.replayFor(lastSeen))
+                    res.write(sseFrame("message", m, history.cursorOf(m)));
+            }
         }
         // Ticks change messages already sent and carry no cursor: every (re)connect gets where each one is now, so a
         // report that fell into a gap is not lost until a reload (#1253 review). No id: it is not a message.
-        if (ctx.webChatHistory)
-            res.write(`event: deliveries\ndata: ${JSON.stringify(ctx.webChatHistory.deliveries())}\n\n`);
+        if (ctx.webChatHistory) {
+            const ticks = guest ? guestDeliveries(ctx.webChatHistory, guest, guest.scope()) : ctx.webChatHistory.deliveries();
+            res.write(`event: deliveries\ndata: ${JSON.stringify(ticks)}\n\n`);
+        }
         // The same for the fleet prompts (C4): one posted, answered or expired during a gap is caught up here.
-        if (ctx.listWebPrompts)
+        if (!guest && ctx.listWebPrompts)
             res.write(`event: prompts\ndata: ${JSON.stringify(ctx.listWebPrompts())}\n\n`);
         // #1386: and "Needs you" as it is now; changes follow as `needs` events.
-        if (ctx.needsYouItems)
+        if (!guest && ctx.needsYouItems)
             res.write(`event: needs\ndata: ${JSON.stringify({ items: ctx.needsYouItems() })}\n\n`);
         ctx.sseClients.add(res);
         const interval = setInterval(() => {
             // A stream authorized once must not outlive the authorization. Re-checked
             // without counting as activity, or an open tab would keep an idle session
             // alive forever; a revoked, expired or rotated-away session ends here.
-            if (!isWebRequestAuthorized(req, url, ctx.webToken, ctx.webSessions, { touch: false })) {
+            // #2049 review: a guest's stream also needs the exact session that opened it — another cookie on the same request
+            // still authenticating does not keep a revoked device's stream (with its scope) alive.
+            if (!isWebRequestAuthorized(req, url, ctx.webToken, ctx.webSessions, { touch: false }) || (guest && !guest.current())) {
                 // Close the connection too, not just the response: an ended response leaves the socket idle in
                 // keep-alive, still held open by whoever's session just ended.
                 const socket = req.socket;
@@ -1049,7 +1135,7 @@ export function handleWebRequest(req, res, url, ctx) {
             }
             try {
                 // Every open dashboard tab, every 10 s: the status of every instance, serialized on the fleet's loop (#1235).
-                res.write(measureSyncWork("web.sseStatus", () => `event: status\ndata: ${JSON.stringify(ctx.getUiStatus())}\n\n`) + sseClock());
+                res.write(measureSyncWork("web.sseStatus", statusFrame) + sseClock());
             }
             catch {
                 cleanup();
@@ -1083,7 +1169,10 @@ export function handleWebRequest(req, res, url, ctx) {
             json(res, 400, { error: "instance (1-128 chars) and limit (1-500) required" });
             return true;
         }
-        json(res, 200, { messages: ctx.webChatHistory?.list(instance, limit) ?? [], boot: ctx.webChatHistory?.boot ?? null, lastId: ctx.webChatHistory?.lastId ?? 0 });
+        // #1920 §5.2: a guest gets what the channel showed of it, and its own messages (the gate checked the scope).
+        const guest = guestRequestOf(req);
+        const messages = !ctx.webChatHistory ? [] : guest ? guestHistory(ctx.webChatHistory, instance, limit, guest, guest.scope()) : ctx.webChatHistory.list(instance, limit);
+        json(res, 200, { messages, boot: ctx.webChatHistory?.boot ?? null, lastId: ctx.webChatHistory?.lastId ?? 0 });
         return true;
     }
     // ── #1218: the Log tab ─────────────────────────────────
@@ -1138,6 +1227,16 @@ export function handleWebRequest(req, res, url, ctx) {
     const fileMatch = path.match(/^\/ui\/file\/([^/]+)$/);
     if (method === "GET" && fileMatch) {
         const id = fileMatch[1];
+        // #1920: a guest gets a file only when its stored instance is in scope — "no such file" otherwise, like an unknown id
+        // (an id from another instance's chat is useless).
+        const guest = guestRequestOf(req);
+        if (guest) {
+            const served = isFileId(id) ? ctx.webFiles?.servedFile?.(id) ?? null : null;
+            if (!served || !guest.scope().has(served.instance)) {
+                json(res, 404, { error: "No such file" });
+                return true;
+            }
+        }
         // #1589: audio and video, played in the page — one byte range at a time (206), by id only, never a whole video in
         // memory. Every other type is answered exactly as before.
         const media = isFileId(id) ? ctx.webFiles?.mediaOf?.(id) ?? null : null;
@@ -1457,13 +1556,28 @@ export function handleWebRequest(req, res, url, ctx) {
                 json(res, 400, { error: "instance, id and index required" });
                 return;
             }
+            // #1920 step 2b: a guest clicks only on a reply it may see (§5.2), of an in-scope instance, while guests may chat.
+            const guest = guestRequestOf(req);
+            const refused = guestChatRefusal(guest, instance);
+            if (refused) {
+                json(res, refused.status, { error: refused.error });
+                return;
+            }
+            if (guest) {
+                const row = guest.history?.()?.findByButtons(instance, id);
+                if (!row || !guestSeesMessage(row, guest, guest.scope())) {
+                    json(res, 404, { error: "not found" });
+                    return;
+                }
+            }
             // #1823/#1827: the click is this page's person's — on a poll their vote (one per person, on every device of
             // theirs), on one-click buttons their choice — under their web id and name. A request that no longer passes the
             // gate (a session revoked meanwhile) clicks nothing as anyone.
             const person = webPersonOr401(req, res, url, ctx);
             if (!person)
                 return;
-            const r = await click(instance, id, index, { key: person.voterKey, userId: person.userId, name: person.name });
+            // #1920 review: a guest's choice reaches the agent marked as a guest's, as its typed messages do.
+            const r = await click(instance, id, index, { key: person.voterKey, userId: person.userId, name: person.name, ...(guest ? { guest: true } : {}) });
             json(res, r.status, r.status === 200 ? { answered: true, ...(r.options ? { options: r.options } : {}) } : { error: r.error ?? "Refused", ...(r.status === 409 ? { gone: true } : {}) });
         })().catch(err => {
             ctx.logger.error({ err: err.message }, "Web reply-button click failed");
@@ -1705,6 +1819,12 @@ export function handleWebRequest(req, res, url, ctx) {
             json(res, 404, { error: `Instance not found: ${name}` });
             return true;
         }
+        // #1920 step 2b: a guest's Cancel is the platform button's (anyone allowed there), while guests may chat.
+        const cancelRefused = guestChatRefusal(guestRequestOf(req), name);
+        if (cancelRefused) {
+            json(res, cancelRefused.status, { error: cancelRefused.error });
+            return true;
+        }
         if (!ctx.cancelInstance(name)) {
             json(res, 409, { error: `${name} is not running` });
             return true;
@@ -2131,6 +2251,12 @@ export function handleWebRequest(req, res, url, ctx) {
         json(res, 200, ctx.orgChart?.() ?? { general: [], teams: [], instances: {} });
         return true;
     }
+    // #1918: the org canvas's traffic on opening, and the public link's (which has no stream) on its poll cadence. The
+    // fleet works it out at most once every two seconds and caps it, whoever asks how often.
+    if (method === "GET" && path === "/ui/traffic") {
+        json(res, 200, ctx.trafficSnapshot?.() ?? { now: new Date().toISOString(), items: [] });
+        return true;
+    }
     if (method === "GET" && path === "/ui/teams") {
         const teams = ctx.fleetConfig?.teams ?? {};
         json(res, 200, { teams });
@@ -2342,6 +2468,17 @@ function handleSendMessage(req, res, ctx) {
                 return;
             }
             const { instance, message: typed, attachments = [] } = parsed.data;
+            // #1920 step 2b: a guest writes only to an in-scope instance, while guests may chat, and never a command.
+            const guest = guestRequestOf(req);
+            const refused = guestChatRefusal(guest, instance);
+            if (refused) {
+                json(res, refused.status, { error: refused.error });
+                return;
+            }
+            if (guest && guestCommandText(typed)) {
+                json(res, 403, { error: "guest_no_commands" });
+                return;
+            }
             const ipc = ctx.instanceIpcClients.get(instance);
             if (!ipc) {
                 json(res, 404, { error: `Instance not found: ${instance}` });
@@ -2389,11 +2526,13 @@ function handleSendMessage(req, res, ctx) {
                 && !ctx.isClassicInstance?.(instance) && syncAdapter && groupId && topicId != null;
             // Add no runtime credentials or local attachment paths to the display copy.
             const preview = webEchoPreview(message, files.map(f => f.name));
-            // ClassicBot echo (#1320 part B): same ordering lane, per-entry
-            // opt-in resolved at send time inside sendClassicWebEcho.
+            // ClassicBot echo (#1320 part B): same ordering lane, each room's setting (#2054: on unless it says false, or
+            // the fleet-wide switch is off for a room that is unset) resolved at send time inside sendClassicWebEcho.
             const canClassicEcho = ctx.isClassicInstance?.(instance) === true && !!ctx.sendClassicWebEcho;
             const settleClassicEcho = canClassicEcho ? ctx.reserveWebChannelEcho?.(instance, async () => {
-                await ctx.sendClassicWebEcho(instance, formatWebChannelEcho(person.name, preview, t("web.echo_full_text")), person.name);
+                const posted = await ctx.sendClassicWebEcho(instance, formatWebChannelEcho(person.name, preview, t("web.echo_full_text"), { guest: !!guest }), person.name);
+                if (posted > 0)
+                    ctx.webMessageInChannel?.(instance, messageId); // #1920 §5.2: the room saw it
             }) : undefined;
             const settleEcho = canEcho ? ctx.reserveWebChannelEcho?.(instance, async () => {
                 // A replacement adapter or edited binding is not the route we reserved.
@@ -2401,7 +2540,9 @@ function handleSendMessage(req, res, ctx) {
                     || (ctx.getGroupIdForInstance?.(instance) ?? String(ctx.fleetConfig?.channel?.group_id ?? "")) !== groupId
                     || ctx.fleetConfig?.instances[instance]?.topic_id !== topicId)
                     return;
-                return syncAdapter.sendText(String(groupId), formatWebChannelEcho(person.name, preview, t("web.echo_full_text")), { threadId: String(topicId), format: "text", allowedMentions: { parse: [] } });
+                const sent = await syncAdapter.sendText(String(groupId), formatWebChannelEcho(person.name, preview, t("web.echo_full_text"), { guest: !!guest }), { threadId: String(topicId), format: "text", allowedMentions: { parse: [] } });
+                ctx.webMessageInChannel?.(instance, messageId); // #1920 §5.2: the topic saw it
+                return sent;
             }) : undefined;
             let delivered;
             try {
@@ -2419,6 +2560,7 @@ function handleSendMessage(req, res, ctx) {
                         ts,
                         thread_id: topicId != null ? String(topicId) : "",
                         source: "web",
+                        ...(guest ? { web_guest: "1" } : {}), // #1920: "[user:… via web (guest), id:…]" (authority none)
                         adapter_id: syncAdapter?.id,
                         ...delivery.meta,
                     },
@@ -2455,7 +2597,8 @@ function handleSendMessage(req, res, ctx) {
             ctx.webFiles?.commit(files);
             ctx.lastInboundUser.set(instance, person.name);
             ctx.eventLog?.logActivity("message", person.name, (message || `[${files.length} file(s)]`).slice(0, 200), instance);
-            ctx.emitSseEvent("message", { instance, sender: person.name, role: "user", text: message, ts, attachments: files.map(publicAttachment), messageId });
+            // #1920: the account that wrote it (a guest sees its own); channel-visible once its copy was sent (above).
+            ctx.emitSseEvent("message", { instance, sender: person.name, role: "user", text: message, ts, attachments: files.map(publicAttachment), messageId, ...(person.bound ? { from: person.voterKey } : {}) });
             json(res, 200, { sent: true, messageId });
         }
         catch {
@@ -2479,6 +2622,13 @@ function handleUpload(req, res, url, ctx) {
         json(res, 404, { error: "uploads are not available" });
         return;
     }
+    // #1920 step 2b: a guest's upload is for an in-scope instance's message, while guests may chat.
+    const guestRefused = guestChatRefusal(guestRequestOf(req), instance);
+    if (guestRefused) {
+        req.resume();
+        json(res, guestRefused.status, { error: guestRefused.error });
+        return;
+    }
     if (!instance || instance.length > 128 || !safeInstanceSegment(instance) || !ctx.instanceIpcClients.has(instance)) {
         json(res, 404, { error: `Instance not found: ${instance}` });
         return;
@@ -2673,14 +2823,22 @@ function prefsViewer(req, url, ctx) {
     const v = evaluateWebRequest(req, url, ctx.webToken ?? null, ctx.webSessions, { touch: false });
     if (v.kind !== "allow")
         return null;
+    // #1920: a guest is a guest on every listener. The public link's page and reads too — before, a guest signed in through
+    // it (#2094) read the host's preferences unfiltered: the sidebar's order and favourites, naming instances out of its
+    // scope.
+    const guest = v.via === "session" && v.session?.tier === "guest" ? { guest: true } : {};
     if (!gatewayRequestContext(req) && v.via === "session" && v.session) {
         const person = webPersonKey(v.session.owner);
-        return { person, epoch: v.session.handle, scope: person === OPERATOR ? "operator" : "person", canWrite: v.session.tier === "admin", via: "session" };
+        return { person, epoch: v.session.handle, scope: person === OPERATOR ? "operator" : "person", canWrite: v.session.tier === "admin", via: "session", ...guest };
     }
-    return { person: null, epoch: null, scope: "none", canWrite: v.via !== "session" || v.session?.tier === "admin", via: v.via };
+    return { person: null, epoch: null, scope: "none", canWrite: v.via !== "session" || v.session?.tier === "admin", via: v.via, ...guest };
 }
 const prefsScope = (v) => ({ ownerScope: v?.scope ?? "none", ownerEpoch: v?.epoch ?? null });
-const prefsView = (prefs, v) => ({ ...prefs.readForViewer(v?.person ?? null), ...prefsScope(v) });
+// #1920: a guest reads the host's look and its own, never a preference that names an instance (guestPrefs).
+const prefsView = (prefs, v) => {
+    const view = { ...prefs.readForViewer(v?.person ?? null), ...prefsScope(v) };
+    return v?.guest ? guestPrefs(view) : view;
+};
 function shellHtmlTag(ctx, mode, viewer) {
     if (mode !== "full" || !ctx.webPrefs)
         return '<html lang="en">';