@nordbyte/nordrelay 0.5.0 → 0.5.2

package/dist/relay-runtime.js

@@ -1,7 +1,6 @@
 import { randomUUID } from "node:crypto";
-import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { createArtifactZipBundle, collectRecentWorkspaceArtifacts, getArtifactTurnReport, ensureOutDir, listRecentArtifactReports, persistWorkspaceArtifactReport, removeArtifactTurn, totalArtifactSize, } from "./artifacts.js";
+import { ensureOutDir } from "./artifacts.js";
 import { buildFileInstructions, outboxPath, stageFile, } from "./attachments.js";
 import { CODEX_AGENT_CAPABILITIES, agentLabel, agentReasoningLabel, agentReasoningOptions, } from "./agent.js";
 import { getAgentDiagnostics, getExternalSnapshotForSession, } from "./agent-activity.js";
@@ -17,16 +16,19 @@ import { checkOpenClawAuthStatus } from "./openclaw-auth.js";
 import { clearLogFile, getAgentUpdateLogPath, getConnectorHealth, getConnectorLogPath, getPackageVersion, getUpdateLogPath, getVersionChecks, readConnectorState, readFormattedLogTail, spawnConnectorRestart, spawnSelfUpdate } from "./operations.js";
 import { checkPiAuthStatus } from "./pi-auth.js";
 import { PromptStore, toPromptEnvelope } from "./prompt-store.js";
+import { RelayArtifactService } from "./relay-artifact-service.js";
+import { RelayExternalActivityMonitor } from "./relay-external-activity-monitor.js";
+import { RelayQueueService } from "./relay-queue-service.js";
 import { renderSessionInfoPlain, renderSessionUsageRows } from "./session-format.js";
 import { SessionLockStore } from "./session-locks.js";
 import { SessionRegistry } from "./session-registry.js";
+import { createSupportBundle } from "./support-bundle.js";
 import { transcribeAudio } from "./voice.js";
 import { WebActivityStore, WebChatStore, } from "./web-state.js";
 import { evaluateWorkspacePolicy, filterAllowedWorkspaces } from "./workspace-policy.js";
 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;
@@ -36,15 +38,16 @@ export class RelayRuntime {
     auditStore;
     lockStore;
     agentUpdates;
+    queueService;
+    artifactService;
+    externalActivityMonitor;
     subscribers = new Set();
     externalMonitor;
     draining = false;
-    externalMonitorRunning = false;
     currentTurnId = null;
     accumulatedText = "";
     currentTurnStartedAt = 0;
     currentProgress = null;
-    externalMirror = null;
     constructor(config) {
         this.config = config;
         this.registry = new SessionRegistry(config, {
@@ -56,12 +59,27 @@ export class RelayRuntime {
         this.activityStore = new WebActivityStore(config.workspace, config.stateBackend, config.auditMaxEvents);
         this.auditStore = new AuditLogStore(config.workspace, config.stateBackend, config.auditMaxEvents);
         this.lockStore = new SessionLockStore(config.workspace, config.stateBackend);
+        this.queueService = new RelayQueueService(this.promptStore, WEB_CONTEXT_KEY);
+        this.artifactService = new RelayArtifactService(config);
         this.agentUpdates = new AgentUpdateManager({
             onUpdate: (job) => this.broadcast({ type: "agent_update", job }),
         });
+        this.externalActivityMonitor = new RelayExternalActivityMonitor({
+            config,
+            getSession: () => this.getSession(true),
+            publicInfo: (session) => this.publicInfo(session),
+            queueLength: () => this.queueService.length(),
+            chatStore: this.chatStore,
+            chatHistory: () => this.chatHistory(),
+            persistWorkspaceArtifactsForTurn: (workspace, turnId, startedAt) => this.artifactService.persistWorkspaceArtifactsForTurn(workspace, turnId, startedAt),
+            drainQueue: () => this.drainQueue(),
+            appendActivity: (input) => this.appendActivity(input),
+            broadcast: (event) => this.broadcast(event),
+            broadcastStatus: (message, level) => this.broadcastStatus(message, level),
+        });
         if (config.codexExternalBusyCheckMs > 0) {
             this.externalMonitor = setInterval(() => {
-                void this.monitorExternalActivitySafe();
+                void this.externalActivityMonitor.monitorSafe();
             }, config.codexExternalBusyCheckMs);
             this.externalMonitor.unref?.();
         }
@@ -87,10 +105,16 @@ export class RelayRuntime {
         };
     }
     async status() {
+        const cliOptions = this.cliPathOptions();
+        const [health, versionChecks, snapshot] = await Promise.all([
+            getConnectorHealth(cliOptions),
+            getVersionChecks(cliOptions),
+            this.snapshot(),
+        ]);
         return {
-            health: await getConnectorHealth({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath }),
-            versionChecks: await getVersionChecks({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath }),
-            snapshot: await this.snapshot(),
+            health,
+            versionChecks,
+            snapshot,
         };
     }
     async bootstrapStatus() {
@@ -103,10 +127,16 @@ export class RelayRuntime {
         };
     }
     async version() {
+        const cliOptions = this.cliPathOptions();
+        const [health, state, versionChecks] = await Promise.all([
+            getConnectorHealth(cliOptions),
+            readConnectorState(),
+            getVersionChecks(cliOptions),
+        ]);
         return {
-            health: await getConnectorHealth({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath }),
-            state: await readConnectorState(),
-            versionChecks: await getVersionChecks({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath }),
+            health,
+            state,
+            versionChecks,
         };
     }
     updateConnector() {
@@ -132,18 +162,18 @@ export class RelayRuntime {
     agentUpdateJobs() {
         return this.agentUpdates.list();
     }
-    startAgentUpdate(agentId) {
+    startAgentUpdate(agentId, operation = "update") {
         const job = this.agentUpdates.start(agentId, {
             piCliPath: this.config.piCliPath,
             hermesCliPath: this.config.hermesCliPath,
             openClawCliPath: this.config.openClawCliPath,
             claudeCodeCliPath: this.config.claudeCodeCliPath,
-        });
-        this.broadcastStatus(`${job.agentLabel} update started. Log: ${job.logPath}`, "warn");
+        }, operation);
+        this.broadcastStatus(`${job.agentLabel} ${operation} started. Log: ${job.logPath}`, "warn");
         this.appendActivity({
             source: "web",
             status: "info",
-            type: "agent_update_started",
+            type: operation === "install" ? "agent_install_started" : "agent_update_started",
             agentId,
             threadId: null,
             workspace: this.config.workspace,
@@ -154,7 +184,7 @@ export class RelayRuntime {
             status: "ok",
             contextKey: WEB_CONTEXT_KEY,
             agentId,
-            description: `update ${agentId}`,
+            description: `${operation} ${agentId}`,
             detail: job.summary,
         });
         return job;
@@ -181,22 +211,32 @@ export class RelayRuntime {
         return this.agentUpdates.cancel(id);
     }
     async diagnostics() {
+        const cliOptions = this.cliPathOptions();
+        const [health, versionChecks, snapshot, session] = await Promise.all([
+            getConnectorHealth(cliOptions),
+            getVersionChecks(cliOptions),
+            this.snapshot(),
+            this.getSession(true),
+        ]);
         return {
-            health: await getConnectorHealth({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath }),
-            versionChecks: await getVersionChecks({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath }),
-            snapshot: await this.snapshot(),
+            health,
+            versionChecks,
+            snapshot,
             runtime: {
                 stateBackend: this.config.stateBackend,
                 sourceWorkspace: this.config.workspace,
-                queuePaused: this.promptStore.isPaused(WEB_CONTEXT_KEY),
-                externalMirror: this.externalMirror ? { ...this.externalMirror } : null,
-                agentDiagnostics: getAgentDiagnostics(await this.getSession(true), this.config),
+                queuePaused: this.queueService.isPaused(),
+                externalMirror: this.externalActivityMonitor.snapshot(),
+                agentDiagnostics: getAgentDiagnostics(session, this.config),
             },
         };
     }
     async adapterHealth() {
-        const health = await getConnectorHealth({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath });
-        const versions = await getVersionChecks({ piCliPath: this.config.piCliPath, hermesCliPath: this.config.hermesCliPath, openClawCliPath: this.config.openClawCliPath, claudeCodeCliPath: this.config.claudeCodeCliPath });
+        const cliOptions = this.cliPathOptions();
+        const [health, versions] = await Promise.all([
+            getConnectorHealth(cliOptions),
+            getVersionChecks(cliOptions),
+        ]);
         return Promise.all(listAgentAdapterDescriptors().map(async (descriptor) => {
             const enabled = enabledAgents(this.config).includes(descriptor.id);
             const auth = descriptor.capabilities.auth && enabled
@@ -244,7 +284,7 @@ export class RelayRuntime {
     tasks() {
         return {
             current: this.currentProgress ? { ...this.currentProgress, tools: [...this.currentProgress.tools] } : null,
-            external: this.externalTask(),
+            external: this.externalActivityMonitor.task(),
             queue: this.queue(),
             queuePaused: this.queuePaused(),
             recent: this.activity({ limit: 20 }),
@@ -253,6 +293,32 @@ export class RelayRuntime {
     audit(limit = 50) {
         return this.auditStore.list(limit);
     }
+    async supportBundle() {
+        const bundle = await createSupportBundle({
+            config: this.config,
+            diagnostics: await this.diagnostics(),
+            adapterHealth: await this.adapterHealth(),
+            auditEvents: this.auditStore.list(100),
+            agentUpdateJobs: this.agentUpdates.list(),
+            source: "web",
+        });
+        this.appendActivity({
+            source: "web",
+            status: "info",
+            type: "diagnostics_bundle_exported",
+            threadId: null,
+            workspace: this.config.workspace,
+            detail: bundle.path,
+        });
+        this.appendAudit({
+            action: "command",
+            status: "ok",
+            contextKey: WEB_CONTEXT_KEY,
+            description: "export diagnostics bundle",
+            detail: bundle.path,
+        });
+        return bundle;
+    }
     locks() {
         return this.lockStore.list();
     }
@@ -463,7 +529,7 @@ export class RelayRuntime {
         return this.activityStore.list(options).map((event) => this.enrichActivityEvent(event, currentInfo));
     }
     async retry() {
-        const cached = this.promptStore.getLastPrompt(WEB_CONTEXT_KEY);
+        const cached = this.queueService.getLastPrompt();
         if (!cached) {
             throw new Error("Nothing to retry. Send a message first.");
         }
@@ -758,7 +824,7 @@ export class RelayRuntime {
         const session = await this.getSession(false);
         const external = getExternalSnapshotForSession(session, this.config, { maxEvents: 0 });
         if (session.isProcessing() || external?.activity.active) {
-            const queued = this.promptStore.enqueue(WEB_CONTEXT_KEY, envelope);
+            const queued = this.queueService.enqueue(envelope);
             const info = this.publicInfo(session);
             this.appendActivity({
                 source: "web",
@@ -770,7 +836,7 @@ export class RelayRuntime {
                 prompt: envelope.description,
                 detail: external?.activity.active
                     ? `Queued because ${external.agentLabel} CLI is still processing another task.`
-                    : `Queued at position ${this.promptStore.list(WEB_CONTEXT_KEY).length}.`,
+                    : `Queued at position ${this.queueService.length()}.`,
             });
             this.appendAudit({
                 action: "prompt_queued",
@@ -783,7 +849,7 @@ export class RelayRuntime {
                 description: envelope.description,
             });
             if (external?.activity.active) {
-                this.broadcastStatus(`Waiting for ${external.agentLabel} CLI task... ${this.promptStore.list(WEB_CONTEXT_KEY).length} queued.`, "info");
+                this.broadcastStatus(`Waiting for ${external.agentLabel} CLI task... ${this.queueService.length()} queued.`, "info");
             }
             this.broadcastQueue();
             return { queued: true, queueId: queued.id };
@@ -794,30 +860,14 @@ export class RelayRuntime {
         return { queued: false };
     }
     queue() {
-        return this.promptStore.list(WEB_CONTEXT_KEY).map(queueItemDto);
+        return this.queueService.list();
     }
     queuePaused() {
-        return this.promptStore.isPaused(WEB_CONTEXT_KEY);
+        return this.queueService.isPaused();
     }
     queueAction(action, id) {
-        if (action === "pause")
-            this.promptStore.pause(WEB_CONTEXT_KEY);
-        if (action === "resume")
-            this.promptStore.resume(WEB_CONTEXT_KEY);
-        if (action === "clear")
-            this.promptStore.clear(WEB_CONTEXT_KEY);
-        if (id && action === "cancel")
-            this.promptStore.remove(WEB_CONTEXT_KEY, id);
-        if (id && action === "top")
-            this.promptStore.moveToTop(WEB_CONTEXT_KEY, id);
-        if (id && action === "up")
-            this.promptStore.moveUp(WEB_CONTEXT_KEY, id);
-        if (id && action === "down")
-            this.promptStore.moveDown(WEB_CONTEXT_KEY, id);
+        this.queueService.apply(action, id);
         if (id && action === "run") {
-            const item = this.promptStore.remove(WEB_CONTEXT_KEY, id);
-            if (item)
-                this.promptStore.enqueueFront(WEB_CONTEXT_KEY, item);
             void this.drainQueue().catch((error) => this.broadcastStatus(friendlyErrorText(error), "error"));
         }
         this.appendActivity({
@@ -839,58 +889,23 @@ export class RelayRuntime {
     }
     async artifacts() {
         const session = await this.getSession(true);
-        return (await listRecentArtifactReports(session.getInfo().workspace, 20, this.config.maxFileSize)).map(artifactDto);
+        return this.artifactService.list(session.getInfo().workspace, 20);
     }
     async artifact(turnId) {
         const session = await this.getSession(true);
-        return getArtifactTurnReport(session.getInfo().workspace, turnId, this.config.maxFileSize);
+        return this.artifactService.get(session.getInfo().workspace, turnId);
     }
     async deleteArtifact(turnId) {
         const session = await this.getSession(true);
-        return removeArtifactTurn(session.getInfo().workspace, turnId);
+        return this.artifactService.delete(session.getInfo().workspace, turnId);
     }
     async createArtifactZip(turnId) {
-        const report = await this.artifact(turnId);
-        if (!report) {
-            return null;
-        }
-        const bundle = await createArtifactZipBundle(report.artifacts, report.outDir, {
-            maxFileSize: this.config.maxFileSize,
-            bundleName: `nordrelay-artifacts-${turnId}.zip`,
-        });
-        return bundle ? { path: bundle.localPath, name: bundle.name } : null;
+        const session = await this.getSession(true);
+        return this.artifactService.createZip(session.getInfo().workspace, turnId);
     }
     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"),
-        };
+        const session = await this.getSession(true);
+        return this.artifactService.preview(session.getInfo().workspace, turnId, relativePath);
     }
     async logs(target = "connector", lines = 100) {
         if (target === "update") {
@@ -934,158 +949,6 @@ export class RelayRuntime {
         this.registry.disposeAll();
         this.subscribers.clear();
     }
-    async monitorExternalActivity() {
-        const session = await this.getSession(true);
-        const info = this.publicInfo(session);
-        if (!info.capabilities.externalActivity || !info.threadId || session.isProcessing()) {
-            return;
-        }
-        const snapshot = getExternalSnapshotForSession(session, this.config, {
-            afterLine: this.externalMirror?.threadId === info.threadId ? this.externalMirror.lastLine : Number.MAX_SAFE_INTEGER,
-        }) ?? getExternalSnapshotForSession(session, this.config, {
-            maxEvents: 0,
-        });
-        if (!snapshot) {
-            return;
-        }
-        if (!this.externalMirror || this.externalMirror.threadId !== snapshot.threadId || this.externalMirror.rolloutPath !== snapshot.sourcePath) {
-            this.externalMirror = {
-                threadId: snapshot.threadId,
-                rolloutPath: snapshot.sourcePath,
-                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: `${snapshot.agentLabel} CLI task ${terminalEvent.status ?? "finished"}.`,
-                durationMs: durationFromDates(externalStartedAt, terminalEvent.timestamp),
-            });
-            if (externalStartedAt && terminalEvent.turnId) {
-                await this.persistWorkspaceArtifactsForTurn(info.workspace, terminalEvent.turnId, externalStartedAt);
-            }
-            mirror.latestStatus = `${snapshot.agentLabel} CLI task ${terminalEvent.status ?? "finished"}.`;
-            this.broadcastStatus(`${snapshot.agentLabel} CLI task ${terminalEvent.status ?? "finished"}.`, terminalEvent.status === "failed" ? "error" : terminalEvent.status === "aborted" ? "warn" : "info");
-            this.broadcast({ type: "chat_history", messages: await this.chatHistory() });
-            await this.drainQueue();
-        }
-        mirror.lastLine = Math.max(mirror.lastLine, snapshot.lineCount);
-    }
-    async monitorExternalActivitySafe() {
-        if (this.externalMonitorRunning) {
-            return;
-        }
-        this.externalMonitorRunning = true;
-        try {
-            await this.monitorExternalActivity();
-        }
-        catch (error) {
-            this.broadcastStatus(friendlyErrorText(error), "error");
-        }
-        finally {
-            this.externalMonitorRunning = false;
-        }
-    }
-    startExternalTurn(snapshot) {
-        const prompt = snapshot.latestUserMessage ?? `${snapshot.agentLabel} 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: `${snapshot.sourceLabel}: ${snapshot.sourcePath}`,
-        });
-    }
-    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 });
     }
@@ -1104,6 +967,14 @@ export class RelayRuntime {
         });
         return { session, dispose: true };
     }
+    cliPathOptions() {
+        return {
+            piCliPath: this.config.piCliPath,
+            hermesCliPath: this.config.hermesCliPath,
+            openClawCliPath: this.config.openClawCliPath,
+            claudeCodeCliPath: this.config.claudeCodeCliPath,
+        };
+    }
     async ensureActiveThread(session) {
         if (!session.hasActiveThread()) {
             await session.newThread();
@@ -1199,7 +1070,7 @@ export class RelayRuntime {
             outputChars: 0,
             tools: [],
         };
-        this.promptStore.setLastPrompt(WEB_CONTEXT_KEY, envelope);
+        this.queueService.setLastPrompt(envelope);
         const startedDate = new Date();
         const startedAt = startedDate.toISOString();
         this.chatStore.append({
@@ -1257,7 +1128,7 @@ export class RelayRuntime {
         try {
             await session.prompt(envelope.input, callbacks);
             this.updateSession(session);
-            await this.persistWorkspaceArtifactsForTurn(session.getInfo().workspace, turnId, startedDate);
+            await this.artifactService.persistWorkspaceArtifactsForTurn(session.getInfo().workspace, turnId, startedDate);
             if (this.accumulatedText.trim()) {
                 this.chatStore.append({
                     threadId: info.threadId ?? "pending",
@@ -1335,7 +1206,7 @@ export class RelayRuntime {
         }
     }
     async drainQueue() {
-        if (this.draining || this.promptStore.isPaused(WEB_CONTEXT_KEY)) {
+        if (this.draining || this.queueService.isPaused()) {
             return;
         }
         this.draining = true;
@@ -1344,10 +1215,10 @@ export class RelayRuntime {
             while (!session.isProcessing()) {
                 const external = getExternalSnapshotForSession(session, this.config, { maxEvents: 0 });
                 if (external?.activity.active) {
-                    this.broadcastStatus(`Waiting for ${external.agentLabel} CLI task... ${this.queue().length} queued.`, "info");
+                    this.broadcastStatus(`Waiting for ${external.agentLabel} CLI task... ${this.queueService.length()} queued.`, "info");
                     return;
                 }
-                const next = this.promptStore.dequeue(WEB_CONTEXT_KEY);
+                const next = this.queueService.dequeue();
                 this.broadcastQueue();
                 if (!next) {
                     return;
@@ -1417,31 +1288,6 @@ export class RelayRuntime {
         }
         this.updateCurrentProgress({ currentTool: toolName, lastTool: toolName });
     }
-    externalTask() {
-        if (!this.externalMirror) {
-            return null;
-        }
-        const startedAt = this.externalMirror.startedAt ?? new Date().toISOString();
-        const startedMs = new Date(startedAt).getTime();
-        return {
-            id: this.externalMirror.turnId ?? "cli",
-            source: "cli",
-            status: this.externalMirror.latestStatus?.includes("failed")
-                ? "failed"
-                : this.externalMirror.latestStatus?.includes("aborted")
-                    ? "aborted"
-                    : this.externalMirror.latestStatus?.includes("finished") || this.externalMirror.latestStatus?.includes("completed")
-                        ? "completed"
-                        : "running",
-            threadId: this.externalMirror.threadId,
-            startedAt,
-            updatedAt: new Date().toISOString(),
-            durationMs: Number.isFinite(startedMs) ? Math.max(0, Date.now() - startedMs) : 0,
-            outputChars: 0,
-            tools: [],
-            detail: this.externalMirror.latestStatus ?? this.externalMirror.rolloutPath,
-        };
-    }
     broadcastQueue() {
         this.broadcast({ type: "queue_update", queue: this.queue(), paused: this.queuePaused() });
     }
@@ -1468,53 +1314,6 @@ export class RelayRuntime {
             capabilities: info.capabilities ?? CODEX_AGENT_CAPABILITIES,
         };
     }
-    async persistWorkspaceArtifactsForTurn(workspace, turnId, startedAt) {
-        const report = await collectRecentWorkspaceArtifacts(workspace, {
-            since: startedAt,
-            until: new Date(),
-            maxFileSize: this.config.maxFileSize,
-            limit: 20,
-            ignoreDirs: this.config.artifactIgnoreDirs,
-            ignoreGlobs: this.config.artifactIgnoreGlobs,
-        });
-        if (report.artifacts.length === 0 && report.skippedCount === 0 && !report.omittedCount) {
-            return;
-        }
-        await persistWorkspaceArtifactReport(workspace, turnId, report);
-    }
-}
-function queueItemDto(item) {
-    return {
-        id: item.id,
-        description: item.description,
-        createdAt: new Date(item.createdAt).toISOString(),
-        attempts: item.attempts ?? 0,
-        notBefore: item.notBefore ? new Date(item.notBefore).toISOString() : undefined,
-        lastError: item.lastError,
-    };
-}
-function artifactDto(report) {
-    return {
-        turnId: report.turnId,
-        updatedAt: report.updatedAt.toISOString(),
-        source: report.source,
-        fileCount: report.artifacts.length,
-        totalSizeBytes: totalArtifactSize(report.artifacts),
-        skippedCount: report.skippedCount,
-        omittedCount: report.omittedCount,
-        artifacts: report.artifacts.map((artifact) => ({
-            name: artifact.name,
-            relativePath: artifact.relativePath.split(path.sep).join("/"),
-            sizeBytes: artifact.sizeBytes,
-        })),
-    };
-}
-function externalStatusLine(snapshot, queueLength) {
-    const elapsed = snapshot.activity.startedAt
-        ? formatDuration((Date.now() - snapshot.activity.startedAt.getTime()) / 1000)
-        : "-";
-    const tool = snapshot.latestToolName ?? "-";
-    return `${snapshot.agentLabel} CLI running · ${elapsed} · tool ${tool} · ${queueLength} queued`;
 }
 function cliHealthForAgent(agentId, health) {
     if (agentId === "pi") {
@@ -1572,23 +1371,6 @@ function hostLogoutCommand(info, config) {
     }
     return "codex logout";
 }
-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) {
@@ -1622,37 +1404,3 @@ 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);
-}