@songsid/agend 2.3.5-alpha.4 → 2.3.5-alpha.5

package/dist/settings-api.js

@@ -4,6 +4,7 @@ import { DEFAULT_REPLY_TRIGGERS } from "./reply-triggers.js";
 import { PUBLIC_TUNNEL_SECRET_ID, PUBLIC_TUNNEL_TOKEN_HINT } from "./public-tunnel-config.js";
 import { withSpawnHoldReply } from "./spawn-hold-reply.js";
 import { normalizeSettingsInstancePatch, removesInstanceOverride } from "./settings-instance-patch.js";
+import { credentialProfileLogin, instanceCredentialProfile } from "./backend/credential-profile.js";
 import { isSettingsReplay, settingsRequestExecution, settingsRequestLocalAdmin, settingsRequestLocalAdminCurrent, settingsWrite } from "./settings-request-capability.js";
 import { noteSettingsWrite, settingsUndo, undoSettingsPaths } from "./settings-transaction.js";
 import { readBoundedWebBody } from "./web-body.js";
@@ -12,6 +13,7 @@ import { applyAppearanceChanges, applyGuestsPatch, applyVerifiedAuthorityPatch,
 import { APPEARANCE_BOUNDS, APPEARANCE_DEFAULTS, effectiveAppearanceLimits } from "./web-appearance-limits.js";
 import { permitWebContinuation } from "./web-continuation.js";
 import { parseRuntimesSettingsBody, runtimeSettingsView } from "./runtime-switches.js";
+import { hubMembershipSettings, parseHubMembership } from "./hub-membership-settings.js";
 import { evaluateWebRequest } from "./web-auth.js";
 import { redactInlineSecrets, restoreRedactedSecrets } from "./settings-redaction.js";
 /**
@@ -56,6 +58,7 @@ import { viewOf } from "./apply-job.js";
 import { handleQuickstartRequest } from "./quickstart-api.js";
 import { requestSessionBinding, } from "./connection-secrets.js";
 import { providerRegistryEnvKeys, isReservedProviderEnvKey } from "./provider-secret-registry.js";
+import { topicFields } from "./instance-topic-delete.js";
 import { STATUS_EMOJI_CONFIG_KEYS, STATUS_EMOJI_SUGGESTIONS, TELEGRAM_REACTION_EMOJIS, builtinStatusEmojis, customEmojiValue, emojiProxyUrl, previewStatusEmojis, } from "./status-emojis.js";
 /**
  * #2103 review: who may change guest sign-in outside the settings transaction — an admin's session (by its handle) or
@@ -96,7 +99,7 @@ function normalizeChannelIdValue(value, path) {
     return { ok: false, error: `${path} must be a string (or a safe integer)` };
 }
 export function isSettingsPath(path) {
-    return isSettingsPage(path) || path.startsWith("/api/settings/");
+    return isSettingsPage(path) || path.startsWith("/api/settings/") || path.startsWith("/api/hub/member/"); // S3c: the member's Hub card
 }
 const classicPath = (ctx) => join(ctx.dataDir, "classicBot.yaml");
 class ClassicConfigParseError extends Error {
@@ -739,8 +742,73 @@ export function handleSettingsRequest(req, res, url, ctx) {
         json(res, 200, job, true);
         return true;
     }
-    // Everything below mutates — needs an in-memory fleet config.
+    // Remaining fleet Settings routes use in-memory configuration when they mutate.
     const cfg = ctx.fleetConfig;
+    // This pure Settings surface remains available while membership is off; it imports no Hub runtime.
+    if (path === "/api/settings/hub/membership") {
+        if (gatewayRequestContext(req)) {
+            json(res, 403, { error: "hub_settings_not_over_public_link" });
+            return true;
+        }
+        if (method === "GET") {
+            if (!guestSettingsCaller(req, url, ctx)) {
+                json(res, 403, { error: "admin_required" });
+                return true;
+            }
+            try {
+                json(res, 200, { ok: true, ...hubMembershipSettings(ctx.getRawFleetConfig()) });
+            }
+            catch {
+                json(res, 409, { ok: false, error: "invalid_hub_membership" });
+            }
+            return true;
+        }
+        if (method !== "PUT") {
+            json(res, 405, { error: "method_not_allowed" });
+            return true;
+        }
+        const execution = settingsRequestExecution(req), configPath = ctx.configPath;
+        // Enabling is confirmed; disabling uses the same gate's immediate narrowing continuation.
+        let allowed = false;
+        try {
+            allowed = !!execution && settingsRequestLocalAdmin(req);
+        }
+        catch { /* stale */ }
+        if (!allowed || !execution) {
+            json(res, 403, { error: "admin_confirmation_required" });
+            return true;
+        }
+        if (!cfg || !configPath) {
+            json(res, 503, { ok: false, error: "unavailable" });
+            return true;
+        }
+        readBody(req, 1024).then(bytes => {
+            try {
+                execution.assert();
+                if (!settingsRequestLocalAdmin(req) || ctx.fleetConfig !== cfg || ctx.configPath !== configPath)
+                    throw Error("unavailable");
+                let input;
+                try {
+                    input = parseHubMembership(JSON.parse(bytes.toString("utf8")));
+                }
+                catch {
+                    json(res, 400, { ok: false, error: "invalid_hub_membership" });
+                    return;
+                }
+                settingsWrite(req, () => {
+                    if (!settingsRequestLocalAdmin(req) || ctx.fleetConfig !== cfg || ctx.configPath !== configPath)
+                        throw Error("unavailable");
+                    hubMembershipSettings(ctx.getRawFleetConfig());
+                    ctx.saveFleetConfig([{ path: ["hub_member", "enabled"], value: input.enabled }]);
+                });
+                json(res, 200, { ok: true, ...hubMembershipSettings(ctx.getRawFleetConfig()) });
+            }
+            catch {
+                json(res, 503, { ok: false, error: "unavailable" });
+            }
+        }).catch(() => json(res, 400, { ok: false, error: "invalid_hub_membership" }));
+        return true;
+    }
     // ── Manual pause / wake ──
     const actionMatch = path.match(/^\/api\/settings\/instances\/([^/]+)\/(pause|wake)$/);
     if (method === "POST" && actionMatch) {
@@ -910,6 +978,160 @@ export function handleSettingsRequest(req, res, url, ctx) {
         }).catch(() => json(res, 400, { error: "bad request" }));
         return true;
     }
+    // S3c (S-55): the member's exposures — local owner only, never over the public link. GET the list; POST publish or
+    // revise (only as a confirmed Settings replay: the confirmation layer intercepts the first request); POST
+    // .../<id>/withdraw at once (narrowing needs no confirmation), ok once the restrictive state is saved.
+    const hubExposures = path === "/api/hub/member/exposures" ? "list" : /^\/api\/hub\/member\/exposures\/[0-9a-f-]{36}\/withdraw$/.test(path) ? "withdraw" : null;
+    if (hubExposures) {
+        if (gatewayRequestContext(req)) {
+            json(res, 403, { error: "hub_member_not_over_public_link" });
+            return true;
+        }
+        const api = ctx.hubMemberExposures?.() ?? null;
+        if (!api) {
+            json(res, 404, { error: "unavailable" });
+            return true;
+        }
+        const refused = (err) => { const code = err.code; json(res, 409, { ok: false, error: typeof code === "string" ? code : "unsaved" }); };
+        if (hubExposures === "list" && method === "GET") {
+            if (!guestSettingsCaller(req, url, ctx)) {
+                json(res, 403, { error: "admin_required" });
+                return true;
+            }
+            try {
+                json(res, 200, { ok: true, exposures: api.list() });
+            }
+            catch (err) {
+                refused(err);
+            }
+            return true;
+        }
+        if (hubExposures === "list" && method === "POST") {
+            const execution = settingsRequestExecution(req);
+            let allowed = false;
+            try {
+                allowed = !!execution && isSettingsReplay(req) && settingsRequestLocalAdmin(req);
+            }
+            catch { /* stale */ }
+            if (!allowed || !execution) {
+                json(res, 403, { error: "admin_confirmation_required" });
+                return true;
+            }
+            readBody(req, 8192).then((bytes) => {
+                execution.assert();
+                if ((ctx.hubMemberExposures?.() ?? null) !== api) {
+                    json(res, 409, { ok: false, error: "unavailable" });
+                    return;
+                }
+                try {
+                    json(res, 200, { ok: true, view: api.publish(JSON.parse(bytes.toString("utf8"))) });
+                }
+                catch (err) {
+                    refused(err);
+                }
+            }).catch(() => json(res, 400, { ok: false, error: "unsaved" }));
+            return true;
+        }
+        if (hubExposures === "withdraw" && method === "POST") {
+            const caller = guestSettingsCaller(req, url, ctx);
+            if (!caller) {
+                json(res, 403, { error: "admin_required" });
+                return true;
+            }
+            const id = path.split("/")[5];
+            readBody(req, 4096).then(async (bytes) => {
+                // #3115 r1 P3: the same live caller (a rotated token or revoked session is no one) and the same composed member
+                // at the effect, after the body's wait.
+                if (guestSettingsCaller(req, url, ctx) !== caller) {
+                    json(res, 401, { error: "no longer authorized" });
+                    return;
+                }
+                if ((ctx.hubMemberExposures?.() ?? null) !== api) {
+                    json(res, 409, { ok: false, error: "unavailable" });
+                    return;
+                }
+                const body = JSON.parse(bytes.toString("utf8") || "{}");
+                if (!Number.isSafeInteger(body.expectedRevision)) {
+                    json(res, 400, { ok: false, error: "conflict" });
+                    return;
+                }
+                try {
+                    json(res, 200, { ok: true, ...(await api.withdraw(id, body.expectedRevision)) });
+                }
+                catch (err) {
+                    refused(err);
+                }
+            }).catch(() => json(res, 400, { ok: false, error: "unsaved" }));
+            return true;
+        }
+        json(res, 405, { error: "method_not_allowed" });
+        return true;
+    }
+    // S3c PR B: the member's pairing — GET the projection; POST connect / confirm / disconnect only as a confirmed
+    // local-admin Settings replay (its continuation is the S1 call); POST cancel at once (local only). Never over the
+    // public link; no member composed: 404 "unavailable".
+    const pairingRoute = path.match(/^\/api\/hub\/member\/pairing(?:\/(connect|confirm|disconnect|cancel))?$/);
+    if (pairingRoute) {
+        if (gatewayRequestContext(req)) {
+            json(res, 403, { error: "hub_member_not_over_public_link" });
+            return true;
+        }
+        const api = ctx.hubMemberPairing?.() ?? null;
+        if (!api) {
+            json(res, 404, { error: "unavailable" });
+            return true;
+        }
+        const step = pairingRoute[1];
+        if (!step && method === "GET") {
+            if (!guestSettingsCaller(req, url, ctx)) {
+                json(res, 403, { error: "admin_required" });
+                return true;
+            }
+            json(res, 200, { ok: true, pairing: api.view() });
+            return true;
+        }
+        if (step === "cancel" && method === "POST") {
+            if (!guestSettingsCaller(req, url, ctx)) {
+                json(res, 403, { error: "admin_required" });
+                return true;
+            }
+            json(res, 200, { ok: true, pairing: api.cancel() });
+            return true;
+        }
+        if (step && method === "POST") {
+            const execution = settingsRequestExecution(req);
+            let allowed = false;
+            try {
+                allowed = !!execution && isSettingsReplay(req) && settingsRequestLocalAdmin(req);
+            }
+            catch { /* stale */ }
+            if (!allowed || !execution) {
+                json(res, 403, { error: "admin_confirmation_required" });
+                return true;
+            }
+            const current = () => { try {
+                execution.assert();
+                return settingsRequestLocalAdminCurrent(req);
+            }
+            catch {
+                return false;
+            } };
+            readBody(req, 4096).then(async (bytes) => {
+                execution.assert();
+                if ((ctx.hubMemberPairing?.() ?? null) !== api) {
+                    json(res, 409, { ok: false, error: "unavailable" });
+                    return;
+                }
+                const body = JSON.parse(bytes.toString("utf8") || "{}");
+                const r = step === "connect" ? await api.connect({ address: body.address, code: body.code }, current)
+                    : step === "confirm" ? await api.confirmFingerprint(body.digest, current) : await api.disconnect({ hubId: body.hubId, binding: body.binding });
+                json(res, r.ok ? 200 : 409, r);
+            }).catch(() => json(res, 400, { ok: false, error: "unsaved" }));
+            return true;
+        }
+        json(res, 405, { error: "method_not_allowed" });
+        return true;
+    }
     if (path === "/api/settings/general-location" && (method === "GET" || method === "POST")) {
         if (gatewayRequestContext(req)) {
             json(res, 403, { error: "runtime_settings_not_over_public_link" });
@@ -946,7 +1168,131 @@ export function handleSettingsRequest(req, res, url, ctx) {
         }).catch(err => { ctx.logger.warn({ err }, "settings: General location change held"); json(res, 409, { error: err.message }); });
         return true;
     }
-    // One hot web toggle; an unrelated Settings edit never materializes defaults.
+    if (["/api/settings/hub/browser-certificate", "/api/settings/hub/browser-certificate/prepare", "/api/settings/hub/browser-certificate/apply"].includes(path)) {
+        if (gatewayRequestContext(req)) {
+            json(res, 403, { error: "hub_settings_not_over_public_link" });
+            return true;
+        }
+        const control = ctx.hubBrowserCertificate?.() ?? null;
+        if (!control) {
+            json(res, 404, { error: "unavailable" });
+            return true;
+        }
+        const refused = (err) => {
+            const code = err instanceof Error && ["invalid_browser_certificate", "conflict", "unavailable", "browser_certificate_busy"].includes(err.message) ? err.message : "unsaved";
+            json(res, code === "invalid_browser_certificate" ? 400 : code === "conflict" ? 409 : 503, { ok: false, error: code });
+        };
+        if (path.endsWith("/apply") && method === "POST") {
+            const execution = settingsRequestExecution(req);
+            let allowed = false;
+            try {
+                allowed = !!execution && isSettingsReplay(req) && settingsRequestLocalAdmin(req);
+            }
+            catch { /* stale */ }
+            if (!allowed || !execution) {
+                json(res, 403, { error: "admin_confirmation_required" });
+                return true;
+            }
+            readBody(req, 4096).then(bytes => {
+                try {
+                    execution.assert();
+                    if (ctx.hubBrowserCertificate?.() !== control)
+                        throw Error("unavailable");
+                    const certificate = settingsWrite(req, () => control.apply(JSON.parse(bytes.toString("utf8")), requestSessionBinding(req), () => settingsRequestLocalAdmin(req) && ctx.hubBrowserCertificate?.() === control));
+                    json(res, 200, { ok: true, certificate });
+                }
+                catch (err) {
+                    refused(err);
+                }
+            }).catch(refused);
+            return true;
+        }
+        const caller = guestSettingsCaller(req, url, ctx);
+        if (!caller) {
+            json(res, 403, { error: "admin_required" });
+            return true;
+        }
+        if (path.endsWith("/prepare") && method === "POST") {
+            const binding = requestSessionBinding(req);
+            const current = () => !req.aborted && !res.destroyed && ctx.hubBrowserCertificate?.() === control
+                && guestSettingsCaller(req, url, ctx) === caller && requestSessionBinding(req) === binding;
+            readBody(req, 16 * 1024).then(async (bytes) => {
+                if (!current())
+                    throw Error("unavailable");
+                const proposal = await control.prepare(JSON.parse(bytes.toString("utf8")), binding, current);
+                if (!current())
+                    throw Error("unavailable");
+                json(res, 200, { ok: true, proposal });
+            }).catch(refused);
+            return true;
+        }
+        if (path === "/api/settings/hub/browser-certificate" && method === "GET") {
+            try {
+                json(res, 200, { ok: true, certificate: control.read() });
+            }
+            catch (err) {
+                refused(err);
+            }
+            return true;
+        }
+        json(res, 405, { error: "method_not_allowed" });
+        return true;
+    }
+    if (path === "/api/settings/hub/retention") {
+        if (gatewayRequestContext(req)) {
+            json(res, 403, { error: "hub_settings_not_over_public_link" });
+            return true;
+        }
+        const control = ctx.hubRetention?.() ?? null;
+        if (!control) {
+            json(res, 404, { error: "unavailable" });
+            return true;
+        }
+        const refused = (err) => {
+            const code = err instanceof Error && ["invalid_retention", "conflict", "unavailable", "retention_unavailable"].includes(err.message) ? err.message : "unsaved";
+            json(res, code === "invalid_retention" ? 400 : code === "conflict" ? 409 : 503, { ok: false, error: code });
+        };
+        if (method === "GET") {
+            if (!guestSettingsCaller(req, url, ctx)) {
+                json(res, 403, { error: "admin_required" });
+                return true;
+            }
+            try {
+                json(res, 200, { ok: true, policy: control.read() });
+            }
+            catch (err) {
+                refused(err);
+            }
+            return true;
+        }
+        if (method === "PUT") {
+            const execution = settingsRequestExecution(req);
+            let allowed = false;
+            try {
+                allowed = !!execution && isSettingsReplay(req) && settingsRequestLocalAdmin(req);
+            }
+            catch { /* stale */ }
+            if (!allowed || !execution) {
+                json(res, 403, { error: "admin_confirmation_required" });
+                return true;
+            }
+            readBody(req, 4096).then(bytes => {
+                try {
+                    execution.assert();
+                    if (ctx.hubRetention?.() !== control)
+                        throw Error("unavailable");
+                    const policy = settingsWrite(req, () => control.update(JSON.parse(bytes.toString("utf8")), () => settingsRequestLocalAdmin(req) && ctx.hubRetention?.() === control));
+                    json(res, 200, { ok: true, policy });
+                }
+                catch (err) {
+                    refused(err);
+                }
+            }).catch(refused);
+            return true;
+        }
+        json(res, 405, { error: "method_not_allowed" });
+        return true;
+    }
     // ── M-2255: Settings → Runtime's switches — "Use this PC's Windows CLIs" (runtimes.windows_cli) and "Allow other
     // Windows computers to pair" (runtimes.remote_runtime). Off by default; the environment overrides them (said here).
     // Never over the public link. Switching one on is confirmed by a General admin (settings-change.ts); off applies at once.
@@ -1062,6 +1408,10 @@ export function handleSettingsRequest(req, res, url, ctx) {
                 web.preview_cdn = parsed.previewCdn;
                 changes.push({ path: ["web", "preview_cdn"], value: parsed.previewCdn });
             }
+            if (parsed.loginQr !== undefined) {
+                web.login_qr = parsed.loginQr;
+                changes.push({ path: ["web", "login_qr"], value: parsed.loginQr });
+            }
             if (parsed.publicLink) {
                 if (Object.keys(parsed.publicLink).length)
                     web.public_link = { ...web.public_link, ...parsed.publicLink };
@@ -1292,6 +1642,26 @@ export function handleSettingsRequest(req, res, url, ctx) {
             if ("path" in restored)
                 return json(res, 400, { error: `redacted value has no stored credential: defaults.${restored.path}` });
             const merged = { ...cfg.defaults, ...officeInputPatch(restored.value) };
+            // #3212: backend_options is replaced whole, like every nested map in this write (the top-level keys merge): Settings
+            // → Accounts sends the whole map, and so does the Advanced editor, where leaving a key out removes it.
+            if (body.backend_options !== undefined && body.backend_options && typeof body.backend_options === "object" && !Array.isArray(body.backend_options)) {
+                const sent = body.backend_options;
+                // A fleet default moved onto a signed-out profile would leave every agent that follows it at a sign-in prompt.
+                for (const b of Object.keys(sent)) {
+                    const after = instanceCredentialProfile(undefined, merged, b), before = instanceCredentialProfile(undefined, cfg.defaults, b);
+                    if (!after || after === before)
+                        continue;
+                    let login = null;
+                    try {
+                        login = credentialProfileLogin(ctx.dataDir, b, after);
+                    }
+                    catch {
+                        login = null;
+                    }
+                    if (login?.state === "signed-out")
+                        return json(res, 409, { error: "credential_profile_signed_out", backend: b, profile: after, loginCommand: login.loginCommand });
+                }
+            }
             // #1310: locale:null means "clear the key" (user chose Auto). Mirrors
             // how the instance save handles model ("" → delete) and nullable overrides.
             if (body.locale === null || body.locale === "")
@@ -1764,6 +2134,16 @@ export function handleSettingsRequest(req, res, url, ctx) {
                     changes.push({ path: ["instances", name, key, nestedKey], value: nestedValue, remove: nestedValue === null });
                 }
             }
+            else if (key === "backend_options" && value && typeof value === "object" && !Array.isArray(value)) {
+                // M-2446: per backend namespace and key, as normalizeSettingsInstancePatch merges it; null removes the key.
+                for (const [backend, options] of Object.entries(value)) {
+                    if (!options || typeof options !== "object" || Array.isArray(options))
+                        continue;
+                    for (const [optionKey, optionValue] of Object.entries(options)) {
+                        changes.push({ path: ["instances", name, key, backend, optionKey], value: optionValue, remove: optionValue === null });
+                    }
+                }
+            }
             else {
                 changes.push({ path: ["instances", name, key], value, remove: removesInstanceOverride(key, value) });
             }
@@ -1795,6 +2175,32 @@ export function handleSettingsRequest(req, res, url, ctx) {
         const after = validateFleet({ ...cfg, instances: { ...cfg.instances, [name]: mergedInst } });
         if (rejectIfWorse(res, before, after))
             return;
+        // #3212: moving an agent onto a named credential profile that is signed out is refused, as update_instance_config
+        // refuses it — the agent would wait at a sign-in prompt instead of working. Unknown (cannot tell) is let through.
+        if (!mergedInst.machine_id && mergedInst.runtime !== "windows") {
+            const backendAfter = String(mergedInst.backend ?? cfg.defaults?.backend ?? "claude-code");
+            const profileAfter = instanceCredentialProfile(mergedInst, cfg.defaults, backendAfter);
+            const profileBefore = exists ? instanceCredentialProfile(base, cfg.defaults, String(base.backend ?? cfg.defaults?.backend ?? "claude-code")) : null;
+            if (profileAfter && profileAfter !== profileBefore) {
+                let login = null;
+                try {
+                    login = credentialProfileLogin(ctx.dataDir, backendAfter, profileAfter);
+                }
+                catch {
+                    login = null;
+                }
+                if (login?.state === "signed-out") {
+                    json(res, 409, { error: "credential_profile_signed_out", backend: backendAfter, profile: profileAfter, loginCommand: login.loginCommand });
+                    return;
+                }
+            }
+        }
+        // #3055 review r2: a topic whose agent is being deleted is going away on the platform now — binding it here would
+        // lose it. Asked at commit, by physical destination; try again once the deletion is over.
+        if (ctx.topicBindingInFlight?.(mergedInst)) {
+            json(res, 409, { error: "topic_deletion_in_flight" });
+            return;
+        }
         settingsWrite(req, () => {
             Object.defineProperty(cfg.instances, name, { value: mergedInst, writable: true, enumerable: true, configurable: true });
             if (!exists)
@@ -1852,7 +2258,11 @@ export function handleSettingsRequest(req, res, url, ctx) {
                 // Settings → Agents → Delete, confirmed: the same removal as delete_instance — the agent stops, nothing of it is
                 // left behind (schedules, team places), and its fleet.yaml entry goes.
                 const execution = settingsRequestExecution(req), authorization = authorizeExplicitInstanceRemoval("dashboard-confirmed");
-                (execution ? ctx.removeInstance(name, authorization, execution) : ctx.removeInstance(name, authorization)).then(() => json(res, 200, { ok: true, deleted: name, warnings: validateFleet(cfg).warnings }), (err) => json(res, 500, { error: err.message }));
+                // …and its own topic (the user's default), as delete_instance does; the answer says whether the platform took it.
+                const removal = ctx.removeInstanceAndTopic
+                    ? ctx.removeInstanceAndTopic(name, authorization, { deleteTopic: true, ...(execution ? { execution } : {}) })
+                    : (execution ? ctx.removeInstance(name, authorization, execution) : ctx.removeInstance(name, authorization)).then(() => null);
+                removal.then((topic) => json(res, 200, { ok: true, deleted: name, ...topicFields(name, topic), warnings: validateFleet(cfg).warnings }), (err) => json(res, 500, { error: err.message }));
                 return true;
             }
             // DELETE never blocks on validation; surface any resulting warnings.