@nordbyte/nordrelay 0.3.0 → 0.3.1

package/dist/relay-runtime.js

@@ -1,35 +1,58 @@
 import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { createArtifactZipBundle, getArtifactTurnReport, ensureOutDir, listRecentArtifactReports, removeArtifactTurn, totalArtifactSize, } from "./artifacts.js";
 import { buildFileInstructions, outboxPath, stageFile, } from "./attachments.js";
 import { CODEX_AGENT_CAPABILITIES, CODEX_REASONING_EFFORTS, PI_THINKING_LEVELS, agentLabel, agentReasoningLabel, } from "./agent.js";
 import { enabledAgents } from "./agent-factory.js";
 import { checkAuthStatus } from "./codex-auth.js";
+import { getThreadRolloutSnapshot, } from "./codex-state.js";
 import { friendlyErrorText } from "./error-messages.js";
-import { getConnectorHealth, getVersionChecks, readFormattedLogTail } from "./operations.js";
+import { getConnectorHealth, getVersionChecks, readFormattedLogTail, spawnConnectorRestart } from "./operations.js";
 import { PromptStore, toPromptEnvelope } from "./prompt-store.js";
 import { renderSessionInfoPlain } from "./session-format.js";
 import { SessionRegistry } from "./session-registry.js";
 import { transcribeAudio } from "./voice.js";
+import { WebActivityStore, WebChatStore, } from "./web-state.js";
 import { evaluateWorkspacePolicy, filterAllowedWorkspaces } from "./workspace-policy.js";
-const WEB_CONTEXT_KEY = "0";
+const WEB_CONTEXT_KEY = "web:dashboard";
 const MAX_WEB_SESSION_PAGE_SIZE = 50;
+const MAX_CHAT_HISTORY = 250;
+const MAX_TEXT_PREVIEW_BYTES = 256 * 1024;
 export class RelayRuntime {
     config;
     registry;
     promptStore;
+    chatStore;
+    activityStore;
     subscribers = new Set();
+    externalMonitor;
     draining = false;
     currentTurnId = null;
     accumulatedText = "";
+    currentTurnStartedAt = 0;
+    externalMirror = null;
     constructor(config) {
         this.config = config;
-        this.registry = new SessionRegistry(config);
+        this.registry = new SessionRegistry(config, {
+            fileName: "web-contexts.json",
+            sqliteKey: "web-contexts",
+        });
         this.promptStore = new PromptStore(config.workspace, config.stateBackend);
+        this.chatStore = new WebChatStore(config.workspace, config.stateBackend, MAX_CHAT_HISTORY);
+        this.activityStore = new WebActivityStore(config.workspace, config.stateBackend, config.auditMaxEvents);
+        if (config.codexExternalBusyCheckMs > 0) {
+            this.externalMonitor = setInterval(() => {
+                void this.monitorExternalActivity().catch((error) => this.broadcastStatus(friendlyErrorText(error), "error"));
+            }, config.codexExternalBusyCheckMs);
+            this.externalMonitor.unref?.();
+        }
     }
     subscribe(callback) {
         this.subscribers.add(callback);
         void this.snapshot().then((data) => callback({ type: "snapshot", data })).catch(() => { });
+        void this.chatHistory().then((messages) => callback({ type: "chat_history", messages })).catch(() => { });
+        callback({ type: "activity_update", events: this.activity({ limit: 50 }) });
         return () => this.subscribers.delete(callback);
     }
     async snapshot() {
@@ -39,6 +62,7 @@ export class RelayRuntime {
             session: info,
             sessionText: renderSessionInfoPlain(info),
             queue: this.queue(),
+            queuePaused: this.queuePaused(),
             processing: session.isProcessing(),
             enabledAgents: enabledAgents(this.config),
             workspaces: filterAllowedWorkspaces(session.listWorkspaces(), this.config),
@@ -51,6 +75,53 @@ export class RelayRuntime {
             snapshot: await this.snapshot(),
         };
     }
+    async diagnostics() {
+        return {
+            health: await getConnectorHealth(),
+            versionChecks: await getVersionChecks({ piCliPath: this.config.piCliPath }),
+            snapshot: await this.snapshot(),
+            runtime: {
+                stateBackend: this.config.stateBackend,
+                sourceWorkspace: this.config.workspace,
+                queuePaused: this.promptStore.isPaused(WEB_CONTEXT_KEY),
+                externalMirror: this.externalMirror ? { ...this.externalMirror } : null,
+            },
+        };
+    }
+    async controlOptions() {
+        const session = await this.getSession(true);
+        const info = this.publicInfo(session);
+        const capabilities = info.capabilities ?? CODEX_AGENT_CAPABILITIES;
+        return {
+            models: capabilities.modelSelection ? session.listModels() : [],
+            reasoningLabel: agentReasoningLabel(info.agentId),
+            reasoningOptions: info.agentId === "pi" ? PI_THINKING_LEVELS : CODEX_REASONING_EFFORTS,
+            launchProfiles: capabilities.launchProfiles
+                ? this.config.launchProfiles.map((profile) => ({
+                    id: profile.id,
+                    label: profile.label,
+                    behavior: `${profile.sandboxMode} / ${profile.approvalPolicy}`,
+                    unsafe: profile.unsafe,
+                }))
+                : [],
+            workspaces: filterAllowedWorkspaces(session.listWorkspaces(), this.config),
+            capabilities,
+        };
+    }
+    async chatHistory(limit = 200) {
+        const session = await this.getSession(true);
+        return this.chatStore.list(this.publicInfo(session).threadId, limit);
+    }
+    async clearChatHistory() {
+        const session = await this.getSession(true);
+        const removed = this.chatStore.clear(this.publicInfo(session).threadId);
+        const messages = await this.chatHistory();
+        this.broadcast({ type: "chat_history", messages });
+        return { removed, messages };
+    }
+    activity(options = {}) {
+        return this.activityStore.list(options);
+    }
     async listSessions(limit = 80, query = "") {
         return this.filteredSessions(await this.getSession(true), query, Math.max(1, limit * 3)).slice(0, limit);
     }
@@ -101,10 +172,32 @@ export class RelayRuntime {
         return this.publicInfo(session);
     }
     async newSession(options = {}) {
-        const session = await this.getSession(true);
+        const session = options.agentId ? await this.registry.switchAgent(WEB_CONTEXT_KEY, options.agentId) : await this.getSession(true);
         this.ensureIdle(session);
+        if (options.reasoningEffort) {
+            const reasoningOptions = session.getInfo().agentId === "pi" ? PI_THINKING_LEVELS : CODEX_REASONING_EFFORTS;
+            if (!reasoningOptions.includes(options.reasoningEffort)) {
+                throw new Error(`Invalid ${agentReasoningLabel(session.getInfo().agentId)} value: ${options.reasoningEffort}`);
+            }
+            session.setReasoningEffort(options.reasoningEffort);
+        }
+        if (options.launchProfileId && (session.getInfo().capabilities ?? CODEX_AGENT_CAPABILITIES).launchProfiles) {
+            session.setLaunchProfile(options.launchProfileId);
+        }
+        if (typeof options.fastMode === "boolean" && (session.getInfo().capabilities ?? CODEX_AGENT_CAPABILITIES).fastMode) {
+            session.setFastMode(options.fastMode);
+        }
         const info = await session.newThread(options.workspace, options.model);
         this.updateSession(session);
+        this.appendActivity({
+            source: "web",
+            status: "info",
+            type: "session_new",
+            threadId: info.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            detail: "New dashboard session created.",
+        });
         return this.publicInfo(session);
     }
     async switchSession(threadId) {
@@ -112,6 +205,16 @@ export class RelayRuntime {
         this.ensureIdle(session);
         const info = await session.switchSession(threadId);
         this.updateSession(session);
+        this.broadcast({ type: "chat_history", messages: await this.chatHistory() });
+        this.appendActivity({
+            source: "web",
+            status: "info",
+            type: "session_switch",
+            threadId: info.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            detail: "Dashboard switched session.",
+        });
         return this.publicInfo(session);
     }
     async attachSession(threadId) {
@@ -240,6 +343,17 @@ export class RelayRuntime {
         const session = await this.getSession(false);
         if (session.isProcessing()) {
             const queued = this.promptStore.enqueue(WEB_CONTEXT_KEY, envelope);
+            const info = this.publicInfo(session);
+            this.appendActivity({
+                source: "web",
+                status: "queued",
+                type: "prompt_queued",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                prompt: envelope.description,
+                detail: `Queued at position ${this.promptStore.list(WEB_CONTEXT_KEY).length}.`,
+            });
             this.broadcastQueue();
             return { queued: true, queueId: queued.id };
         }
@@ -251,6 +365,9 @@ export class RelayRuntime {
     queue() {
         return this.promptStore.list(WEB_CONTEXT_KEY).map(queueItemDto);
     }
+    queuePaused() {
+        return this.promptStore.isPaused(WEB_CONTEXT_KEY);
+    }
     queueAction(action, id) {
         if (action === "pause")
             this.promptStore.pause(WEB_CONTEXT_KEY);
@@ -272,6 +389,14 @@ export class RelayRuntime {
                 this.promptStore.enqueueFront(WEB_CONTEXT_KEY, item);
             void this.drainQueue().catch((error) => this.broadcastStatus(friendlyErrorText(error), "error"));
         }
+        this.appendActivity({
+            source: "web",
+            status: "info",
+            type: "queue_updated",
+            threadId: null,
+            workspace: this.config.workspace,
+            detail: id ? `${action}: ${id}` : action,
+        });
         this.broadcastQueue();
         return this.queue();
     }
@@ -298,6 +423,38 @@ export class RelayRuntime {
         });
         return bundle ? { path: bundle.localPath, name: bundle.name } : null;
     }
+    async artifactPreview(turnId, relativePath) {
+        const report = await this.artifact(turnId);
+        const artifact = report?.artifacts.find((candidate) => candidate.relativePath.split(path.sep).join("/") === relativePath);
+        if (!artifact) {
+            return null;
+        }
+        const extension = path.extname(artifact.name).toLowerCase();
+        if ([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"].includes(extension)) {
+            return {
+                kind: "image",
+                name: artifact.name,
+                sizeBytes: artifact.sizeBytes,
+            };
+        }
+        if (!isPreviewableTextFile(extension, artifact.sizeBytes)) {
+            return {
+                kind: "unsupported",
+                name: artifact.name,
+                sizeBytes: artifact.sizeBytes,
+                detail: artifact.sizeBytes > MAX_TEXT_PREVIEW_BYTES ? "File is too large for inline preview." : "File type is not previewable.",
+            };
+        }
+        const buffer = await readFile(artifact.localPath);
+        const truncated = buffer.byteLength > MAX_TEXT_PREVIEW_BYTES;
+        return {
+            kind: "text",
+            name: artifact.name,
+            sizeBytes: artifact.sizeBytes,
+            truncated,
+            text: buffer.subarray(0, MAX_TEXT_PREVIEW_BYTES).toString("utf8"),
+        };
+    }
     async logs(target = "connector", lines = 100) {
         if (target === "update") {
             const { getUpdateLogPath } = await import("./operations.js");
@@ -305,10 +462,160 @@ export class RelayRuntime {
         }
         return readFormattedLogTail(lines);
     }
+    restartConnector() {
+        spawnConnectorRestart();
+        this.broadcastStatus("Restart requested. The dashboard may disconnect briefly.", "warn");
+        this.appendActivity({
+            source: "web",
+            status: "info",
+            type: "restart_requested",
+            threadId: null,
+            workspace: this.config.workspace,
+            detail: "Dashboard requested a connector restart.",
+        });
+        return { ok: true, message: "Restart requested." };
+    }
     dispose() {
+        if (this.externalMonitor) {
+            clearInterval(this.externalMonitor);
+        }
         this.registry.disposeAll();
         this.subscribers.clear();
     }
+    async monitorExternalActivity() {
+        const session = await this.getSession(true);
+        const info = this.publicInfo(session);
+        if (!info.capabilities.externalActivity || info.agentId !== "codex" || !info.threadId || session.isProcessing()) {
+            return;
+        }
+        const snapshot = getThreadRolloutSnapshot(info.threadId, {
+            afterLine: this.externalMirror?.threadId === info.threadId ? this.externalMirror.lastLine : Number.MAX_SAFE_INTEGER,
+            staleAfterMs: this.config.codexExternalBusyStaleMs,
+        }) ?? getThreadRolloutSnapshot(info.threadId, {
+            staleAfterMs: this.config.codexExternalBusyStaleMs,
+            maxEvents: 0,
+        });
+        if (!snapshot) {
+            return;
+        }
+        if (!this.externalMirror || this.externalMirror.threadId !== snapshot.threadId || this.externalMirror.rolloutPath !== snapshot.rolloutPath) {
+            this.externalMirror = {
+                threadId: snapshot.threadId,
+                rolloutPath: snapshot.rolloutPath,
+                lastLine: snapshot.lineCount,
+                turnId: snapshot.activity.turnId,
+                startedAt: snapshot.activity.startedAt?.toISOString() ?? null,
+            };
+            if (snapshot.activity.active) {
+                this.startExternalTurn(snapshot);
+            }
+            return;
+        }
+        const mirror = this.externalMirror;
+        if (snapshot.activity.active) {
+            if (mirror.turnId !== snapshot.activity.turnId) {
+                mirror.turnId = snapshot.activity.turnId;
+                mirror.startedAt = snapshot.activity.startedAt?.toISOString() ?? null;
+                mirror.latestAgentLine = undefined;
+                this.startExternalTurn(snapshot);
+            }
+            this.broadcastExternalEvents(snapshot, snapshot.events.filter((event) => event.lineNumber > mirror.lastLine));
+            mirror.lastLine = Math.max(mirror.lastLine, snapshot.lineCount);
+            mirror.latestStatus = externalStatusLine(snapshot, this.queue().length);
+            this.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 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.chatStore.append({
+                    threadId: snapshot.threadId,
+                    role: "agent",
+                    text: finalText,
+                    source: "cli",
+                    turnId: terminalEvent.turnId ?? undefined,
+                });
+                this.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.broadcast({
+                type: "turn_complete",
+                id: terminalEvent.turnId ?? "cli",
+                at: terminalEvent.timestamp?.toISOString() ?? new Date().toISOString(),
+            });
+            this.appendActivity({
+                source: "cli",
+                status: terminalEvent.status === "aborted" ? "aborted" : terminalEvent.status === "failed" ? "failed" : "completed",
+                type: "cli_turn_finished",
+                threadId: snapshot.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                prompt: snapshot.latestUserMessage ?? undefined,
+                detail: `Codex CLI task ${terminalEvent.status ?? "finished"}.`,
+                durationMs: durationFromDates(externalStartedAt, terminalEvent.timestamp),
+            });
+            this.broadcastStatus(`Codex CLI task ${terminalEvent.status ?? "finished"}.`, terminalEvent.status === "failed" ? "error" : terminalEvent.status === "aborted" ? "warn" : "info");
+            this.broadcast({ type: "chat_history", messages: await this.chatHistory() });
+        }
+        mirror.lastLine = Math.max(mirror.lastLine, snapshot.lineCount);
+    }
+    startExternalTurn(snapshot) {
+        const prompt = snapshot.latestUserMessage ?? "Codex CLI task";
+        this.chatStore.append({
+            threadId: snapshot.threadId,
+            role: "user",
+            text: prompt,
+            source: "cli",
+            turnId: snapshot.activity.turnId ?? undefined,
+            timestamp: snapshot.activity.startedAt?.toISOString(),
+        });
+        this.broadcast({
+            type: "turn_start",
+            id: snapshot.activity.turnId ?? "cli",
+            prompt,
+            at: snapshot.activity.startedAt?.toISOString() ?? new Date().toISOString(),
+            source: "cli",
+        });
+        this.appendActivity({
+            source: "cli",
+            status: "running",
+            type: "cli_turn_started",
+            threadId: snapshot.threadId,
+            prompt,
+            detail: `Rollout: ${snapshot.rolloutPath}`,
+        });
+    }
+    broadcastExternalEvents(snapshot, events) {
+        for (const event of events) {
+            if (event.kind === "tool" && event.status === "started") {
+                this.broadcast({
+                    type: "tool_start",
+                    id: snapshot.activity.turnId ?? "cli",
+                    toolCallId: `cli-${event.lineNumber}`,
+                    toolName: event.toolName ?? "tool",
+                });
+                this.appendActivity({
+                    source: "cli",
+                    status: "running",
+                    type: "cli_tool_started",
+                    threadId: snapshot.threadId,
+                    detail: event.toolName ?? "tool",
+                });
+            }
+            if (event.kind === "tool" && event.status === "finished") {
+                this.broadcast({
+                    type: "tool_end",
+                    id: snapshot.activity.turnId ?? "cli",
+                    toolCallId: `cli-${event.lineNumber}`,
+                    isError: false,
+                });
+            }
+        }
+    }
     async getSession(deferThreadStart) {
         return this.registry.getOrCreate(WEB_CONTEXT_KEY, { deferThreadStart });
     }
@@ -338,9 +645,28 @@ export class RelayRuntime {
         }
         const turnId = randomUUID().slice(0, 12);
         this.currentTurnId = turnId;
+        this.currentTurnStartedAt = Date.now();
         this.accumulatedText = "";
         this.promptStore.setLastPrompt(WEB_CONTEXT_KEY, envelope);
-        this.broadcast({ type: "turn_start", id: turnId, prompt: envelope.description, at: new Date().toISOString() });
+        const startedAt = new Date().toISOString();
+        this.chatStore.append({
+            threadId: info.threadId ?? "pending",
+            role: "user",
+            text: envelope.description,
+            source: "web",
+            turnId,
+            timestamp: startedAt,
+        });
+        this.appendActivity({
+            source: "web",
+            status: "running",
+            type: "prompt_started",
+            threadId: info.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            prompt: envelope.description,
+        });
+        this.broadcast({ type: "turn_start", id: turnId, prompt: envelope.description, at: startedAt, source: "web" });
         const callbacks = {
             onTextDelta: (delta) => {
                 this.accumulatedText += delta;
@@ -356,10 +682,50 @@ export class RelayRuntime {
         try {
             await session.prompt(envelope.input, callbacks);
             this.updateSession(session);
+            if (this.accumulatedText.trim()) {
+                this.chatStore.append({
+                    threadId: info.threadId ?? "pending",
+                    role: "agent",
+                    text: this.accumulatedText,
+                    source: "web",
+                    turnId,
+                });
+            }
+            this.appendActivity({
+                source: "web",
+                status: "completed",
+                type: "prompt_completed",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                prompt: envelope.description,
+                durationMs: Date.now() - this.currentTurnStartedAt,
+            });
             this.broadcast({ type: "turn_complete", id: turnId, at: new Date().toISOString() });
+            this.broadcast({ type: "chat_history", messages: await this.chatHistory() });
         }
         catch (error) {
-            this.broadcast({ type: "turn_error", id: turnId, error: friendlyErrorText(error), at: new Date().toISOString() });
+            const errorText = friendlyErrorText(error);
+            this.chatStore.append({
+                threadId: info.threadId ?? "pending",
+                role: "system",
+                text: `Error: ${errorText}`,
+                source: "web",
+                turnId,
+            });
+            this.appendActivity({
+                source: "web",
+                status: "failed",
+                type: "prompt_failed",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                prompt: envelope.description,
+                detail: errorText,
+                durationMs: Date.now() - this.currentTurnStartedAt,
+            });
+            this.broadcast({ type: "turn_error", id: turnId, error: errorText, at: new Date().toISOString() });
+            this.broadcast({ type: "chat_history", messages: await this.chatHistory() });
             throw error;
         }
         finally {
@@ -391,8 +757,13 @@ export class RelayRuntime {
         this.registry.updateMetadata(WEB_CONTEXT_KEY, session);
         this.broadcast({ type: "session_update", session: this.publicInfo(session) });
     }
+    appendActivity(input) {
+        const event = this.activityStore.append(input);
+        this.broadcast({ type: "activity_update", events: this.activity({ limit: 50 }) });
+        return event;
+    }
     broadcastQueue() {
-        this.broadcast({ type: "queue_update", queue: this.queue() });
+        this.broadcast({ type: "queue_update", queue: this.queue(), paused: this.queuePaused() });
     }
     broadcastStatus(message, level = "info") {
         this.broadcast({ type: "status", message, level, at: new Date().toISOString() });
@@ -444,6 +815,30 @@ function artifactDto(report) {
         })),
     };
 }
+function externalStatusLine(snapshot, queueLength) {
+    const elapsed = snapshot.activity.startedAt
+        ? formatDuration((Date.now() - snapshot.activity.startedAt.getTime()) / 1000)
+        : "-";
+    const tool = snapshot.latestToolName ?? "-";
+    return `Codex CLI running · ${elapsed} · tool ${tool} · ${queueLength} queued`;
+}
+function durationFromDates(start, end) {
+    if (!start || !end) {
+        return undefined;
+    }
+    return Math.max(0, end.getTime() - start.getTime());
+}
+function formatDuration(seconds) {
+    if (!Number.isFinite(seconds) || seconds < 0) {
+        return "-";
+    }
+    if (seconds < 60) {
+        return `${Math.round(seconds)}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainder = Math.round(seconds % 60);
+    return `${minutes}m ${remainder}s`;
+}
 function normalizeMimeType(value, name) {
     const configured = value?.trim();
     if (configured) {
@@ -477,3 +872,37 @@ function uploadFileDtos(files) {
         sizeBytes: file.sizeBytes,
     }));
 }
+function isPreviewableTextFile(extension, sizeBytes) {
+    if (sizeBytes > MAX_TEXT_PREVIEW_BYTES * 4) {
+        return false;
+    }
+    return [
+        "",
+        ".c",
+        ".conf",
+        ".cpp",
+        ".css",
+        ".csv",
+        ".env",
+        ".go",
+        ".html",
+        ".java",
+        ".js",
+        ".json",
+        ".jsx",
+        ".log",
+        ".md",
+        ".py",
+        ".rb",
+        ".rs",
+        ".sh",
+        ".sql",
+        ".toml",
+        ".ts",
+        ".tsx",
+        ".txt",
+        ".xml",
+        ".yaml",
+        ".yml",
+    ].includes(extension);
+}

package/dist/session-registry.js

@@ -8,12 +8,12 @@ export class SessionRegistry {
     metadata = new Map();
     store;
     onRemoveCallback;
-    constructor(config) {
+    constructor(config, options = {}) {
         this.config = config;
         this.store = createDocumentStore({
             workspace: config.workspace,
-            fileName: "contexts.json",
-            sqliteKey: "contexts",
+            fileName: options.fileName ?? "contexts.json",
+            sqliteKey: options.sqliteKey ?? "contexts",
             backend: config.stateBackend,
         });
         this.loadPersistedMetadata();