@nordbyte/nordrelay 0.8.1 → 0.8.2

package/dist/peers/peer-web-proxy-contract.js

@@ -0,0 +1,127 @@
+import { WEB_API_ROUTE_DEFINITIONS } from "../web/web-api-contract.js";
+const LOCAL_ONLY_ROUTE_PATHS = new Set([
+    "/api/auth/me",
+    "/api/dashboard/logout",
+    "/api/permissions",
+    "/api/settings",
+    "/api/settings/wizard/test",
+    "/api/peers",
+    "/api/peers/invite",
+    "/api/peers/pair",
+    "/api/peers/probe",
+    "/api/peers/discover",
+    "/api/peers/discovery-jobs",
+    "/api/peers/discovery-jobs/:id",
+    "/api/peers/discovery-jobs/:id/cancel",
+    "/api/peers/discovery-jobs/:id/log",
+    "/api/peers/identity/backup",
+    "/api/peers/identity/restore",
+    "/api/peers/invitations/:id",
+    "/api/peers/:id",
+    "/api/peers/:id/repin",
+    "/api/peers/:id/health",
+    "/api/peers/:id/proxy",
+    "/api/peers/:id/events",
+    "/api/peers/global-sessions",
+    "/api/users",
+    "/api/users/:id",
+    "/api/users/:id/password",
+    "/api/users/:id/sessions",
+    "/api/users/:id/sessions/:sessionId",
+    "/api/users/:id/telegram",
+    "/api/users/:id/telegram/:identityId",
+    "/api/users/:id/discord",
+    "/api/users/:id/discord/:identityId",
+    "/api/users/:id/slack",
+    "/api/users/:id/slack/:identityId",
+    "/api/groups",
+    "/api/groups/:id",
+    "/api/telegram-chats",
+    "/api/telegram-chats/:id",
+    "/api/discord-channels",
+    "/api/discord-channels/:id",
+    "/api/slack-channels",
+    "/api/slack-channels/:id",
+    "/api/audit",
+]);
+const IMPLEMENTED_ROUTE_PATHS = new Set([
+    "/api/bootstrap",
+    "/api/health",
+    "/api/snapshot",
+    "/api/tasks",
+    "/api/progress",
+    "/api/metrics",
+    "/api/jobs",
+    "/api/jobs/:id/log",
+    "/api/jobs/:id/action",
+    "/api/active-sessions",
+    "/api/version",
+    "/api/update",
+    "/api/agent-updates",
+    "/api/agent-update",
+    "/api/agent-update/:id/log",
+    "/api/agent-update/:id/input",
+    "/api/agent-update/:id/cancel",
+    "/api/adapters/health",
+    "/api/adapters/conformance",
+    "/api/locks",
+    "/api/auth/status",
+    "/api/auth/login",
+    "/api/auth/logout",
+    "/api/control-options",
+    "/api/sessions",
+    "/api/sessions/new",
+    "/api/sessions/switch",
+    "/api/sessions/attach",
+    "/api/sessions/detail",
+    "/api/agent",
+    "/api/models",
+    "/api/session/model",
+    "/api/session/reasoning",
+    "/api/session/fast",
+    "/api/session/launch",
+    "/api/prompt",
+    "/api/prompt/upload",
+    "/api/abort",
+    "/api/stop",
+    "/api/handback",
+    "/api/retry",
+    "/api/sync",
+    "/api/queue",
+    "/api/chat/history",
+    "/api/chat/mirror",
+    "/api/activity",
+    "/api/artifacts",
+    "/api/artifacts/bulk",
+    "/api/artifacts/zip",
+    "/api/artifacts/file",
+    "/api/artifacts/preview",
+    "/api/logs",
+    "/api/logs/clear",
+    "/api/diagnostics",
+    "/api/diagnostics/bundle",
+    "/api/runtime/restart",
+]);
+export function peerProxyCoverage() {
+    const implemented = [];
+    const localOnly = [];
+    const missing = [];
+    for (const route of WEB_API_ROUTE_DEFINITIONS) {
+        for (const method of route.methods) {
+            const key = { method, path: route.path };
+            if (IMPLEMENTED_ROUTE_PATHS.has(route.path)) {
+                implemented.push(key);
+            }
+            else if (LOCAL_ONLY_ROUTE_PATHS.has(route.path)) {
+                localOnly.push(key);
+            }
+            else {
+                missing.push(key);
+            }
+        }
+    }
+    return { implemented, localOnly, missing };
+}
+export function isPeerProxyLocalOnlyPath(path) {
+    return LOCAL_ONLY_ROUTE_PATHS.has(path);
+}

package/dist/{metrics.js → runtime/metrics.js}

@@ -1,7 +1,8 @@
 import { monitorEventLoopDelay } from "node:perf_hooks";
-import { getDiscordRateLimitMetrics } from "./discord-rate-limit.js";
-import { getSlackRateLimitMetrics } from "./slack-rate-limit.js";
-import { getTelegramRateLimitMetrics } from "./telegram-rate-limit.js";
+import { getDiscordRateLimitMetrics } from "../channels/discord/discord-rate-limit.js";
+import { getSlackRateLimitMetrics } from "../channels/slack/slack-rate-limit.js";
+import { getTelegramRateLimitMetrics } from "../channels/telegram/telegram-rate-limit.js";
+import { getWebApiPerformanceMetrics } from "../web/web-performance.js";
 const startedAt = Date.now();
 const eventLoopDelay = monitorEventLoopDelay({ resolution: 20 });
 eventLoopDelay.enable();
@@ -38,6 +39,7 @@ export function buildRuntimeMetrics(input) {
             discord: getDiscordRateLimitMetrics(),
             slack: getSlackRateLimitMetrics(),
         },
+        web: getWebApiPerformanceMetrics(),
     };
 }
 function processMetrics() {

package/dist/{relay-artifact-service.js → runtime/relay-artifact-service.js}

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { collectRecentWorkspaceArtifacts, createArtifactZipBundle, getArtifactTurnReport, listRecentArtifactReports, persistWorkspaceArtifactReport, removeArtifactTurn, totalArtifactSize, } from "./artifacts.js";
+import { collectRecentWorkspaceArtifacts, createArtifactZipBundle, getArtifactTurnReport, listRecentArtifactReports, persistWorkspaceArtifactReport, removeArtifactTurn, totalArtifactSize, } from "../artifacts/artifacts.js";
 const MAX_TEXT_PREVIEW_BYTES = 256 * 1024;
 export class RelayArtifactService {
     config;

package/dist/runtime/relay-auth-service.js

@@ -0,0 +1,63 @@
+import { checkClaudeCodeAuthStatus, startClaudeCodeLogin, startClaudeCodeLogout } from "../agents/claude-code/claude-code-auth.js";
+import { checkAuthStatus, startLogin as startCodexLogin, startLogout as startCodexLogout } from "../agents/codex/codex-auth.js";
+import { checkHermesAuthStatus, startHermesLogin, startHermesLogout } from "../agents/hermes/hermes-auth.js";
+import { checkOpenClawAuthStatus } from "../agents/openclaw/openclaw-auth.js";
+import { checkPiAuthStatus } from "../agents/pi/pi-auth.js";
+export class RelayAuthService {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async check(info) {
+        if (info.agentId === "pi") {
+            return checkPiAuthStatus(info.model);
+        }
+        if (info.agentId === "hermes") {
+            return checkHermesAuthStatus({
+                baseUrl: this.config.hermesApiBaseUrl,
+                apiKey: this.config.hermesApiKey,
+            });
+        }
+        if (info.agentId === "openclaw") {
+            return checkOpenClawAuthStatus({
+                gatewayUrl: this.config.openClawGatewayUrl,
+                token: this.config.openClawGatewayToken,
+                password: this.config.openClawGatewayPassword,
+            });
+        }
+        if (info.agentId === "claude-code") {
+            return checkClaudeCodeAuthStatus(this.config.claudeCodeCliPath);
+        }
+        return checkAuthStatus(this.config.codexApiKey);
+    }
+    async startLogin(info) {
+        if (info.agentId === "hermes") {
+            return startHermesLogin(this.config.hermesCliPath);
+        }
+        if (info.agentId === "claude-code") {
+            return startClaudeCodeLogin(this.config.claudeCodeCliPath);
+        }
+        if (info.agentId === "codex") {
+            return startCodexLogin();
+        }
+        return {
+            success: false,
+            message: `${info.agentLabel} login is not managed by NordRelay. Run the agent login flow on the host.`,
+        };
+    }
+    async startLogout(info) {
+        if (info.agentId === "hermes") {
+            return startHermesLogout(this.config.hermesCliPath);
+        }
+        if (info.agentId === "claude-code") {
+            return startClaudeCodeLogout(this.config.claudeCodeCliPath);
+        }
+        if (info.agentId === "codex") {
+            return startCodexLogout();
+        }
+        return {
+            success: false,
+            message: `${info.agentLabel} logout is not managed by NordRelay. Run the agent logout flow on the host.`,
+        };
+    }
+}

package/dist/runtime/relay-dashboard-service.js

@@ -0,0 +1,139 @@
+import { enabledAgents } from "../agents/shared/agent-factory.js";
+import { listAgentAdapterDescriptors } from "../agents/shared/agent-adapter.js";
+import { friendlyErrorText } from "../core/error-messages.js";
+import { getAgentDiagnostics } from "../agents/shared/agent-activity.js";
+import { getConnectorHealth, getVersionChecks, readConnectorState } from "../support/operations.js";
+import { collectSlackDiagnostics } from "../channels/slack/slack-diagnostics.js";
+import { getSlackRateLimitMetrics } from "../channels/slack/slack-rate-limit.js";
+import { cliHealthForAgent, versionCheckForAgent } from "./relay-runtime-helpers.js";
+export class RelayDashboardService {
+    options;
+    keys = ["version", "adapterHealth", "diagnostics"];
+    warmTimer;
+    constructor(options) {
+        this.options = options;
+        options.cache.register("version", () => this.produceVersion());
+        options.cache.register("adapterHealth", () => this.produceAdapterHealth());
+        options.cache.register("diagnostics", () => this.produceDiagnostics());
+    }
+    startBackgroundRefresh() {
+        this.options.cache.warm(this.keys);
+        const ttlMs = this.options.config.dashboardCacheTtlMs;
+        if (ttlMs <= 0 || this.warmTimer) {
+            return;
+        }
+        const intervalMs = Math.max(5_000, ttlMs);
+        this.warmTimer = setInterval(() => this.options.cache.warm(this.keys), intervalMs);
+        this.warmTimer.unref?.();
+    }
+    stopBackgroundRefresh() {
+        if (!this.warmTimer) {
+            return;
+        }
+        clearInterval(this.warmTimer);
+        this.warmTimer = undefined;
+    }
+    async version() {
+        return this.cached("version");
+    }
+    async diagnostics() {
+        return this.cached("diagnostics");
+    }
+    async adapterHealth() {
+        return this.cached("adapterHealth");
+    }
+    invalidate(key) {
+        this.options.cache.invalidate(key);
+        if (key) {
+            this.options.cache.warm([key]);
+            return;
+        }
+        this.options.cache.warm(this.keys);
+    }
+    async cached(key) {
+        return (await this.options.cache.get(key, this.options.config.dashboardCacheTtlMs)).value;
+    }
+    async produceVersion() {
+        const cliOptions = this.options.cliPathOptions();
+        const [health, state, versionChecks] = await Promise.all([
+            getConnectorHealth(cliOptions),
+            readConnectorState(),
+            getVersionChecks(cliOptions),
+        ]);
+        return {
+            health,
+            state,
+            versionChecks,
+        };
+    }
+    async produceDiagnostics() {
+        const cliOptions = this.options.cliPathOptions();
+        const [health, versionChecks, snapshot, session] = await Promise.all([
+            getConnectorHealth(cliOptions),
+            getVersionChecks(cliOptions),
+            this.options.snapshot(),
+            this.options.getSession(),
+        ]);
+        return {
+            health,
+            versionChecks,
+            snapshot,
+            runtime: {
+                stateBackend: this.options.config.stateBackend,
+                sourceWorkspace: this.options.config.workspace,
+                queuePaused: this.options.queuePaused(),
+                externalMirror: this.options.externalMirror(),
+                agentDiagnostics: getAgentDiagnostics(session, this.options.config),
+                slackDiagnostics: await collectSlackDiagnostics({
+                    config: this.options.config,
+                    timeoutMs: 2_500,
+                    rateLimit: getSlackRateLimitMetrics(),
+                }),
+            },
+        };
+    }
+    async produceAdapterHealth() {
+        const cliOptions = this.options.cliPathOptions();
+        const [health, versions] = await Promise.all([
+            getConnectorHealth(cliOptions),
+            getVersionChecks(cliOptions),
+        ]);
+        return Promise.all(listAgentAdapterDescriptors().map(async (descriptor) => {
+            const enabled = enabledAgents(this.options.config).includes(descriptor.id);
+            const auth = descriptor.capabilities.auth && enabled
+                ? await this.options.authStatus(descriptor.id).catch((error) => ({
+                    agentId: descriptor.id,
+                    agentLabel: descriptor.label,
+                    supported: descriptor.capabilities.auth,
+                    authenticated: false,
+                    detail: friendlyErrorText(error),
+                    loginSupported: descriptor.capabilities.login,
+                    logoutSupported: descriptor.capabilities.logout,
+                }))
+                : null;
+            const cli = cliHealthForAgent(descriptor.id, health);
+            const version = versionCheckForAgent(descriptor.id, versions);
+            return {
+                id: descriptor.id,
+                label: descriptor.label,
+                enabled,
+                status: descriptor.status === "available" ? (enabled ? "enabled" : "disabled") : "planned",
+                auth: {
+                    supported: descriptor.capabilities.auth,
+                    authenticated: auth ? auth.authenticated : null,
+                    method: auth?.method,
+                    detail: auth?.detail,
+                },
+                cli,
+                version: {
+                    installed: version.installedLabel,
+                    latest: version.latestVersion,
+                    status: version.status,
+                    detail: version.detail,
+                },
+                capabilities: descriptor.capabilities,
+                notes: descriptor.notes,
+            };
+        }));
+    }
+}

package/dist/{relay-external-activity-monitor.js → runtime/relay-external-activity-monitor.js}

@@ -1,7 +1,8 @@
-import {} from "./agent.js";
-import { getExternalSnapshotForSession } from "./agent-activity.js";
-import { friendlyErrorText } from "./error-messages.js";
-import {} from "./web-state.js";
+import {} from "../agents/shared/agent.js";
+import { getExternalSnapshotForSession } from "../agents/shared/agent-activity.js";
+import { renderExternalMirrorEvent, renderExternalMirrorStatus, trimLine, } from "../channels/shared/bot-rendering.js";
+import { friendlyErrorText } from "../core/error-messages.js";
+import {} from "../web/web-state.js";
 const CLI_ACTIVITY_ACTOR = {
     channel: "cli",
     label: "CLI",
@@ -16,6 +17,9 @@ export class RelayExternalActivityMonitor {
     snapshot() {
         return this.mirror ? { ...this.mirror } : null;
     }
+    reset() {
+        this.mirror = null;
+    }
     task() {
         if (!this.mirror) {
             return null;
@@ -81,7 +85,7 @@ export class RelayExternalActivityMonitor {
                 startedAt: snapshot.activity.startedAt?.toISOString() ?? null,
             };
             if (snapshot.activity.active) {
-                this.startExternalTurn(snapshot, info);
+                await this.startExternalTurn(snapshot, info);
             }
             return;
         }
@@ -91,36 +95,51 @@ export class RelayExternalActivityMonitor {
                 mirror.turnId = snapshot.activity.turnId;
                 mirror.startedAt = snapshot.activity.startedAt?.toISOString() ?? null;
                 mirror.latestAgentLine = undefined;
-                this.startExternalTurn(snapshot, info);
+                mirror.latestStatusAt = undefined;
+                mirror.latestMirroredEventLine = undefined;
+                await this.startExternalTurn(snapshot, info);
+            }
+            const mirrorMode = this.options.mirrorMode();
+            const newEvents = snapshot.events.filter((event) => event.lineNumber > mirror.lastLine);
+            this.broadcastExternalEvents(snapshot, newEvents, info, mirrorMode === "full");
+            if (mirrorMode === "full") {
+                await this.appendExternalEventMessages(snapshot, newEvents, mirror);
             }
-            this.broadcastExternalEvents(snapshot, snapshot.events.filter((event) => event.lineNumber > mirror.lastLine), info);
             mirror.lastLine = Math.max(mirror.lastLine, snapshot.lineCount);
             mirror.latestStatus = externalStatusLine(snapshot, this.options.queueLength());
-            this.options.broadcastStatus(mirror.latestStatus, "info");
+            if (mirrorMode === "status" || mirrorMode === "full") {
+                await this.updateExternalStatusMessage(snapshot, mirror);
+            }
+            if (mirrorMode !== "off") {
+                this.options.broadcastStatus(mirror.latestStatus, "info");
+            }
             return;
         }
         const terminalEvent = [...snapshot.events].reverse().find((event) => event.kind === "task" && event.status && event.status !== "started");
         if (terminalEvent && terminalEvent.lineNumber > mirror.lastLine) {
+            const mirrorMode = this.options.mirrorMode();
             const finalAgent = snapshot.events.filter((event) => event.kind === "agent" && event.text).at(-1);
             const finalText = finalAgent?.text ?? snapshot.latestAgentMessage;
             const finalLine = finalAgent?.lineNumber ?? snapshot.lineCount;
-            if (finalText && finalLine !== mirror.latestAgentLine) {
-                this.options.chatStore.append({
+            if ((mirrorMode === "final" || mirrorMode === "full") && finalText && finalLine !== mirror.latestAgentLine) {
+                this.options.chatStore.appendWithResult({
                     threadId: snapshot.threadId,
                     role: "agent",
                     text: finalText,
                     source: "cli",
                     turnId: terminalEvent.turnId ?? undefined,
+                    key: externalMessageKey("final", snapshot, terminalEvent.lineNumber),
                 });
-                this.options.broadcast({ type: "text_delta", id: terminalEvent.turnId ?? "cli", delta: finalText });
                 mirror.latestAgentLine = finalLine;
             }
             const externalStartedAt = mirror.startedAt ? new Date(mirror.startedAt) : snapshot.activity.startedAt;
-            this.options.broadcast({
-                type: "turn_complete",
-                id: terminalEvent.turnId ?? "cli",
-                at: terminalEvent.timestamp?.toISOString() ?? new Date().toISOString(),
-            });
+            if (mirrorMode !== "off") {
+                this.options.broadcast({
+                    type: "turn_complete",
+                    id: terminalEvent.turnId ?? "cli",
+                    at: terminalEvent.timestamp?.toISOString() ?? new Date().toISOString(),
+                });
+            }
             this.options.appendActivity({
                 source: "cli",
                 status: terminalEvent.status === "aborted" ? "aborted" : terminalEvent.status === "failed" ? "failed" : "completed",
@@ -137,29 +156,35 @@ export class RelayExternalActivityMonitor {
                 await this.options.persistWorkspaceArtifactsForTurn(info.workspace, terminalEvent.turnId, externalStartedAt);
             }
             mirror.latestStatus = `${snapshot.agentLabel} CLI task ${terminalEvent.status ?? "finished"}.`;
-            this.options.broadcastStatus(`${snapshot.agentLabel} CLI task ${terminalEvent.status ?? "finished"}.`, terminalEvent.status === "failed" ? "error" : terminalEvent.status === "aborted" ? "warn" : "info");
-            this.options.broadcast({ type: "chat_history", messages: await this.options.chatHistory() });
+            if (mirrorMode === "status" || mirrorMode === "full") {
+                await this.updateExternalStatusMessage(snapshot, mirror, mirror.latestStatus);
+            }
+            if (mirrorMode !== "off") {
+                this.options.broadcastStatus(`${snapshot.agentLabel} CLI task ${terminalEvent.status ?? "finished"}.`, terminalEvent.status === "failed" ? "error" : terminalEvent.status === "aborted" ? "warn" : "info");
+                await this.broadcastChatHistory();
+            }
             await this.options.drainQueue();
         }
         mirror.lastLine = Math.max(mirror.lastLine, snapshot.lineCount);
     }
-    startExternalTurn(snapshot, info) {
+    async startExternalTurn(snapshot, info) {
         const prompt = snapshot.latestUserMessage ?? `${snapshot.agentLabel} CLI task`;
-        this.options.chatStore.append({
-            threadId: snapshot.threadId,
-            role: "user",
-            text: prompt,
-            source: "cli",
-            turnId: snapshot.activity.turnId ?? undefined,
-            timestamp: snapshot.activity.startedAt?.toISOString(),
-        });
-        this.options.broadcast({
-            type: "turn_start",
-            id: snapshot.activity.turnId ?? "cli",
-            prompt,
-            at: snapshot.activity.startedAt?.toISOString() ?? new Date().toISOString(),
-            source: "cli",
-        });
+        const mode = this.options.mirrorMode();
+        if (mode === "final" || mode === "full") {
+            this.options.chatStore.appendWithResult({
+                threadId: snapshot.threadId,
+                role: "system",
+                text: `Working on ${trimLine(prompt, 500)}`,
+                source: "cli",
+                turnId: snapshot.activity.turnId ?? undefined,
+                timestamp: snapshot.activity.startedAt?.toISOString(),
+                key: externalMessageKey("working", snapshot),
+            });
+            await this.broadcastChatHistory();
+        }
+        if ((mode === "status" || mode === "full") && this.mirror) {
+            await this.updateExternalStatusMessage(snapshot, this.mirror);
+        }
         this.options.appendActivity({
             source: "cli",
             status: "running",
@@ -172,15 +197,17 @@ export class RelayExternalActivityMonitor {
             detail: `${snapshot.sourceLabel}: ${snapshot.sourcePath}`,
         });
     }
-    broadcastExternalEvents(snapshot, events, info) {
+    broadcastExternalEvents(snapshot, events, info, broadcastTools) {
         for (const event of events) {
             if (event.kind === "tool" && event.status === "started") {
-                this.options.broadcast({
-                    type: "tool_start",
-                    id: snapshot.activity.turnId ?? "cli",
-                    toolCallId: `cli-${event.lineNumber}`,
-                    toolName: event.toolName ?? "tool",
-                });
+                if (broadcastTools) {
+                    this.options.broadcast({
+                        type: "tool_start",
+                        id: snapshot.activity.turnId ?? "cli",
+                        toolCallId: `cli-${event.lineNumber}`,
+                        toolName: event.toolName ?? "tool",
+                    });
+                }
                 this.options.appendActivity({
                     source: "cli",
                     status: "running",
@@ -193,12 +220,14 @@ export class RelayExternalActivityMonitor {
                 });
             }
             if (event.kind === "tool" && event.status === "finished") {
-                this.options.broadcast({
-                    type: "tool_end",
-                    id: snapshot.activity.turnId ?? "cli",
-                    toolCallId: `cli-${event.lineNumber}`,
-                    isError: false,
-                });
+                if (broadcastTools) {
+                    this.options.broadcast({
+                        type: "tool_end",
+                        id: snapshot.activity.turnId ?? "cli",
+                        toolCallId: `cli-${event.lineNumber}`,
+                        isError: false,
+                    });
+                }
                 this.options.appendActivity({
                     source: "cli",
                     status: "completed",
@@ -211,12 +240,14 @@ export class RelayExternalActivityMonitor {
                 });
             }
             if (event.kind === "tool" && event.status === "failed") {
-                this.options.broadcast({
-                    type: "tool_end",
-                    id: snapshot.activity.turnId ?? "cli",
-                    toolCallId: `cli-${event.lineNumber}`,
-                    isError: true,
-                });
+                if (broadcastTools) {
+                    this.options.broadcast({
+                        type: "tool_end",
+                        id: snapshot.activity.turnId ?? "cli",
+                        toolCallId: `cli-${event.lineNumber}`,
+                        isError: true,
+                    });
+                }
                 this.options.appendActivity({
                     source: "cli",
                     status: "failed",
@@ -230,6 +261,62 @@ export class RelayExternalActivityMonitor {
             }
         }
     }
+    async appendExternalEventMessages(snapshot, events, mirror) {
+        let changed = false;
+        for (const event of events) {
+            if (event.lineNumber <= (mirror.latestMirroredEventLine ?? mirror.lastLine)) {
+                continue;
+            }
+            const rendered = renderExternalMirrorEvent(event);
+            if (!rendered) {
+                continue;
+            }
+            const stored = this.options.chatStore.appendWithResult({
+                threadId: snapshot.threadId,
+                role: event.kind === "tool" ? "tool" : "system",
+                text: rendered.plain,
+                source: "cli",
+                turnId: event.turnId ?? snapshot.activity.turnId ?? undefined,
+                timestamp: event.timestamp?.toISOString(),
+                key: externalMessageKey("event", snapshot, event.lineNumber),
+            });
+            changed = changed || stored.inserted;
+            mirror.latestMirroredEventLine = event.lineNumber;
+        }
+        if (changed) {
+            await this.broadcastChatHistory();
+        }
+    }
+    async updateExternalStatusMessage(snapshot, mirror, text) {
+        const now = Date.now();
+        const minInterval = this.options.mirrorMinUpdateMs();
+        if (!text && mirror.latestStatusAt && now - mirror.latestStatusAt < minInterval) {
+            return;
+        }
+        this.options.chatStore.upsertByKey({
+            threadId: snapshot.threadId,
+            role: "system",
+            text: text ?? renderExternalMirrorStatus(snapshot, this.options.queueLength()).plain,
+            source: "cli",
+            turnId: snapshot.activity.turnId ?? undefined,
+            key: externalMessageKey("status", snapshot),
+        });
+        mirror.latestStatusAt = now;
+        await this.broadcastChatHistory();
+    }
+    async broadcastChatHistory() {
+        this.options.broadcast({ type: "chat_history", messages: await this.options.chatHistory() });
+    }
+}
+function externalMessageKey(kind, snapshot, lineNumber) {
+    return [
+        "external",
+        kind,
+        snapshot.agentId,
+        snapshot.threadId,
+        snapshot.activity.turnId ?? "turn",
+        lineNumber ?? "",
+    ].join(":");
 }
 function externalStatusLine(snapshot, queueLength) {
     const elapsed = snapshot.activity.startedAt