@spinabot/brigade 1.3.1 → 1.4.0

package/dist/core/server.js

@@ -38,12 +38,13 @@ import { DEFAULT_PORT, isFrame, modelToSummary, TICK_INTERVAL_MS, } from "../pro
 // session is surfaced for the turn's lifetime via `onSessionReady` so the
 // gateway can steer / abort / switch-model mid-stream.
 import { applyAutoEnableA2AAtBoot } from "../agents/a2a-policy-canonicalize.js";
-import { runResilientTurn } from "../agents/agent-loop.js";
+import { flattenAssistantContent, runResilientTurn } from "../agents/agent-loop.js";
 import { BUNDLED_MODULES, clearDiscoveryCache, loadModules } from "../agents/extensions/index.js";
 import { setActiveRegistry } from "../agents/extensions/active-registry.js";
 import { DEFAULT_MAX_BODY_BYTES, DEFAULT_TIMEOUT_MS, readBodyWithLimit } from "./webhook-guards.js";
 import { extractFrameTags, shouldDeliverFrame } from "./ws-subscription-filter.js";
 import { setActiveChannelManager } from "../agents/channels/active-manager.js";
+import { sanitizeReplyForChannel } from "../agents/channels/reply-sanitizer.js";
 import { startChannels } from "../agents/channels/manager.js";
 import { createChannelPluginManager, } from "../agents/channels/channel-plugin-manager.js";
 import { listWhatsAppAccountIds, whatsappChannelEnabled } from "../agents/channels/whatsapp/account-config.js";
@@ -51,6 +52,9 @@ import { createWhatsAppPlugin } from "../agents/channels/whatsapp/plugin.js";
 import { listTelegramAccountIds, telegramChannelEnabled, telegramThreadIdleTtlMs, } from "../agents/channels/telegram/account-config.js";
 import { createTelegramPlugin } from "../agents/channels/telegram/plugin.js";
 import { createPluginChannelManagerFacade } from "../agents/channels/plugin-channel-manager-facade.js";
+import { clearChannelMessagingRegistry, syncChannelMessagingAdaptersFromPlugins, } from "../agents/channels/channel-messaging-registry.js";
+import { clearChannelSecurityRegistry, syncChannelSecurityAdaptersFromPlugins, } from "../agents/channels/channel-security-registry.js";
+import { clearChannelMetaRegistry, registerChannelMeta } from "../agents/channels/channel-meta-registry.js";
 import { makeOpQueue, withTimeout } from "./extension-lifecycle.js";
 import { resolveModelNeverMiss } from "../agents/model-resolution.js";
 import { listOpenRouterModels } from "../integrations/provider-discovery.js";
@@ -116,6 +120,8 @@ import { queryMemory } from "../agents/memory/query.js";
 import { FactStore } from "../agents/memory/records.js";
 import { makeConsolidationLlm, markConsolidationRun, runConsolidation, shouldRunConsolidation, } from "../agents/memory/consolidate.js";
 import { loadBrigadeAuthStorage } from "./auth-bridge.js";
+import { validateApiKeyOnline } from "../providers/validate-key.js";
+import { upsertApiKeyProfile } from "../auth/profiles.js";
 import { getBrigadeWorkspaceDir, loadConfig, saveConfig } from "./config.js";
 import { mutateConfigAtomic } from "../config/io.js";
 import { acquireGatewayLock } from "./gateway-lock.js";
@@ -1950,6 +1956,53 @@ async function continueBoot(args) {
             }
         };
     };
+    /**
+     * OPTIONAL live-streaming delta forwarder. Subscribes to the SAME Pi session
+     * `attachTurnSession` watches, but extracts only the accumulating assistant
+     * ANSWER text from each `message_update` and forwards it to the channel's
+     * `onReplyDelta` sink so the channel can progressively edit its message. The
+     * `<think>` reasoning is stripped here with the same sanitizer the final
+     * reply uses, so a stream never leaks reasoning into a channel preview.
+     *
+     * When `sink` is undefined (TUI / cron / sub-agent / RPC callers) this is a
+     * no-op that returns an inert detach — those turns never stream.
+     */
+    const attachReplyDeltaForwarder = (session, sink) => {
+        if (!sink)
+            return () => { };
+        const detach = session.subscribe((piEvent) => {
+            if (piEvent.type !== "message_update" && piEvent.type !== "message_end")
+                return;
+            const message = piEvent.message;
+            if (!message || message.role !== "assistant")
+                return;
+            const raw = flattenAssistantContent(message.content);
+            if (!raw)
+                return;
+            // Strip reasoning so the live preview shows only the answer-in-progress.
+            const answer = sanitizeReplyForChannel(raw);
+            if (answer) {
+                try {
+                    sink(answer);
+                }
+                catch {
+                    /* a misbehaving sink must never break the turn */
+                }
+            }
+        });
+        let cleaned = false;
+        return () => {
+            if (cleaned)
+                return;
+            cleaned = true;
+            try {
+                detach();
+            }
+            catch {
+                /* session may already be torn down */
+            }
+        };
+    };
     // Sub-agent pi-event forwarder (Primitive #6). The gateway's
     // `attachTurnSession` only subscribes to the TOP-LEVEL Pi session — when
     // a sub-agent runs (via `subagent-runner` recursing into `runSingleTurn`),
@@ -2231,7 +2284,12 @@ async function continueBoot(args) {
                         if (turnState.cleanup)
                             turnState.cleanup();
                         turnState.activeSession = session;
-                        turnState.cleanup = attachTurnSession(session, turnSessionKey, targetAgentId);
+                        const detachStream = attachReplyDeltaForwarder(session, turn.onReplyDelta);
+                        const detachTurn = attachTurnSession(session, turnSessionKey, targetAgentId);
+                        turnState.cleanup = () => {
+                            detachStream();
+                            detachTurn();
+                        };
                     },
                 });
                 // Queue a debounced, batched memory-extraction sweep over the settled
@@ -2753,6 +2811,49 @@ async function continueBoot(args) {
                 broadcastStateAllBindings();
                 return undefined;
             }
+            case "add-provider": {
+                const p = params;
+                // Adding a provider persists a gateway-WIDE credential — strictly an
+                // operator write. Every WS connection is currently granted the full
+                // operator scope set (single-operator model), but gate explicitly so
+                // the day a narrower scope is issued, key-add stays owner-only.
+                if (!caller.scopes.includes("operator.write") &&
+                    !caller.scopes.includes("operator.admin")) {
+                    const err = new Error("add-provider requires operator.write");
+                    err.code = "forbidden";
+                    throw err;
+                }
+                const providerId = p.providerId?.trim();
+                const apiKey = p.apiKey?.trim();
+                if (!providerId)
+                    throw new Error("providerId is required");
+                if (!apiKey)
+                    throw new Error("apiKey is required");
+                // Live validation against the provider's models endpoint (8s timeout):
+                // 401/403 hard-reject; rate-limit / outage soft-accept with a warning.
+                let warning;
+                let modelCount;
+                if (!p.skipValidation) {
+                    const v = await validateApiKeyOnline(providerId, apiKey);
+                    if (!v.ok)
+                        throw new Error(v.reason);
+                    warning = v.warning;
+                    modelCount = v.modelCount;
+                }
+                // Persist into main's auth-profiles.json (mode 0600) — the same store
+                // `brigade onboard` writes, so the key survives a gateway restart.
+                upsertApiKeyProfile(DEFAULT_AGENT_ID, { provider: providerId, key: apiKey });
+                // Hot-load the credential into the gateway's live auth view so the model
+                // registry resolves this provider's models on the NEXT turn without a
+                // restart. `authStorage` is the boot store ModelRegistry was created with.
+                authStorage.set(providerId, { type: "api_key", key: apiKey });
+                // Drop cached per-agent auth views so non-boot agents rebuild from disk
+                // and see the new credential too (boot agent re-caches `authStorage`).
+                authStorageByAgent.clear();
+                modelRegistry.refresh();
+                broadcastStateAllBindings();
+                return { ok: true, provider: providerId, modelCount, warning };
+            }
             case "get-state": {
                 return buildSnapshot();
             }
@@ -4364,6 +4465,17 @@ async function continueBoot(args) {
                 opts.consoleStream?.info?.(`service ${id} stop error: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
+        // Reset the process-wide channel slot registries (messaging / security /
+        // meta). These are populated by `startExtensions()` via a `.set()`-only sync
+        // seam that never REMOVES a slot, so an operator who removes/edits a slot-
+        // bearing channel and reloads would otherwise leak its stale adapter: a stale
+        // security adapter keeps TIGHTENING DM policy (security-relevant) and a stale
+        // messaging adapter keeps rewriting outbound targets. Clearing here means a
+        // reload starts clean and `startExtensions()` re-syncs ONLY the currently-
+        // loaded channels. Each clear is idempotent + total, so shutdown is safe too.
+        clearChannelMessagingRegistry();
+        clearChannelSecurityRegistry();
+        clearChannelMetaRegistry();
     };
     // Load the extension registry and start/mount everything it yields: channels,
     // background services, HTTP routes, gateway methods, plus a built-in
@@ -4383,6 +4495,16 @@ async function continueBoot(args) {
         // pipeline reaching a TranscriptionProvider) can fetch it without threading it
         // through every channel adapter's args. Cleared on shutdown.
         setActiveRegistry(registry);
+        // Channel slot registries — populate the process-wide messaging + security
+        // registries from EVERY channel that declared `b.channelMessaging(...)` /
+        // `b.channelSecurity(...)`, over the FULL registered set (bundled + user
+        // channels alike), UNCONDITIONALLY — never gated on the multi-account branch
+        // below. Without this, a channel that declares a `messaging`/`security` slot
+        // is inert: the `send_message` outbound resolver + the inbound DM-policy
+        // consult never see it. A channel that omits the slot registers nothing and
+        // keeps today's raw-id / central-policy behaviour by construction.
+        syncChannelMessagingAdaptersFromPlugins(registry.channelMessagingAdapters);
+        syncChannelSecurityAdaptersFromPlugins(registry.channelSecurityAdapters);
         // Gateway methods: module-registered RPCs + two built-ins. The `system.`
         // prefix is reserved for built-ins — a module that uses it would be
         // silently overwritten below, so warn instead of failing quietly.
@@ -4611,6 +4733,16 @@ async function continueBoot(args) {
                 multiAccountSummary.push(`telegram x${telegramAccounts.length}`);
             }
             const pluginById = new Map(bundledChannelPlugins.map((p) => [p.id, p]));
+            // Register each constructed plugin's `meta` + its `messaging`/`security`
+            // slots into the process-wide registries. These are full `ChannelPlugin`
+            // objects (carrying the slots) that are NOT registered through the
+            // `b.channelMessaging`/`b.channelSecurity` context seam, so the
+            // registry-getter sync above doesn't see them — wire them here so a
+            // multi-account plugin's declared slots are live too.
+            for (const plugin of bundledChannelPlugins)
+                registerChannelMeta(plugin.meta);
+            syncChannelMessagingAdaptersFromPlugins(bundledChannelPlugins);
+            syncChannelSecurityAdaptersFromPlugins(bundledChannelPlugins);
             channelPluginManager = createChannelPluginManager({
                 loadConfig: () => cfg,
                 listChannelPlugins: () => bundledChannelPlugins,