@nordbyte/nordrelay 0.4.1 → 0.5.1

package/dist/operations.js

@@ -3,7 +3,7 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, writeFileSync
 import { readFile, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { describeCodexCli, resolveCodexCli } from "./codex-cli.js";
+import { describeCodexCli, findExecutableOnPath, resolveCodexCli } from "./codex-cli.js";
 import { findLatestDatabase } from "./codex-state.js";
 import { describeClaudeCodeCli, resolveClaudeCodeCli } from "./claude-code-cli.js";
 import { describeHermesCli, resolveHermesCli } from "./hermes-cli.js";
@@ -294,9 +294,9 @@ function buildNpmSelfUpdateCommands() {
     ];
 }
 function resolveNpmCommand() {
-    const npmExecPath = process.env.npm_execpath;
-    if (npmExecPath && existsSync(npmExecPath)) {
-        return `${shellQuote(process.execPath)} ${shellQuote(npmExecPath)}`;
+    const npm = resolveNpmSpawnCommand();
+    if (npm) {
+        return [npm.command, ...npm.argsPrefix].map(shellQuote).join(" ");
     }
     return "npm";
 }
@@ -306,6 +306,7 @@ function detectCliVersion(commandPath) {
     }
     const result = spawnSync(commandPath, ["--version"], {
         encoding: "utf8",
+        shell: isWindowsShellScript(commandPath),
         timeout: 3000,
         windowsHide: true,
     });
@@ -320,13 +321,15 @@ function detectCliVersion(commandPath) {
 }
 function buildHermesVersionCheck(installedLabel) {
     if (installedLabel === "not installed") {
+        const latest = detectLatestNpmVersion(HERMES_PACKAGE_NAME);
         return {
             label: "Hermes",
             packageName: HERMES_PACKAGE_NAME,
             installedLabel: "not installed",
             installedVersion: null,
-            latestVersion: null,
+            latestVersion: latest.version,
             status: "not-installed",
+            detail: latest.error,
         };
     }
     const lines = installedLabel.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
@@ -345,14 +348,15 @@ function buildHermesVersionCheck(installedLabel) {
 }
 function buildVersionCheck(options) {
     if (options.notInstalled) {
+        const latest = options.skipLatest ? { version: null, error: undefined } : detectLatestNpmVersion(options.packageName);
         return {
             label: options.label,
             packageName: options.packageName,
             installedLabel: "not installed",
             installedVersion: null,
-            latestVersion: null,
+            latestVersion: latest.version,
             status: "not-installed",
-            detail: options.detail,
+            detail: [options.detail, latest.error].filter(Boolean).join(" ") || undefined,
         };
     }
     if (options.skipLatest) {
@@ -393,14 +397,19 @@ function detectLatestNpmVersion(packageName) {
     if (cached) {
         return cached;
     }
-    const result = spawnSync("npm", ["view", packageName, "version", "--registry=https://registry.npmjs.org"], {
+    const npm = resolveNpmSpawnCommand();
+    if (!npm) {
+        return { version: null, error: "npm was not found on PATH; latest-version lookup is unavailable" };
+    }
+    const result = spawnSync(npm.command, [...npm.argsPrefix, "view", packageName, "version", "--registry=https://registry.npmjs.org"], {
         encoding: "utf8",
+        shell: npm.shell,
         timeout: 5000,
         windowsHide: true,
     });
     const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
     if (result.error) {
-        return { version: null, error: result.error.message };
+        return { version: null, error: `${npm.display}: ${result.error.message}` };
     }
     if (result.status !== 0) {
         return { version: null, error: output || `npm exited ${result.status ?? "unknown"}` };
@@ -409,6 +418,51 @@ function detectLatestNpmVersion(packageName) {
     writeVersionCache(packageName, resolved.version);
     return resolved;
 }
+export function resolveNpmSpawnCommand(env = process.env) {
+    const npmExecPath = env.npm_execpath?.trim();
+    if (npmExecPath && existsSync(npmExecPath)) {
+        return {
+            command: process.execPath,
+            argsPrefix: [npmExecPath],
+            display: `${process.execPath} ${npmExecPath}`,
+            shell: false,
+        };
+    }
+    const pathMatch = findExecutableOnPath("npm", env.PATH);
+    if (pathMatch) {
+        return {
+            command: pathMatch,
+            argsPrefix: [],
+            display: pathMatch,
+            shell: isWindowsShellScript(pathMatch),
+        };
+    }
+    for (const candidate of commonNpmCandidates(env)) {
+        if (!existsSync(candidate)) {
+            continue;
+        }
+        return {
+            command: candidate,
+            argsPrefix: [],
+            display: candidate,
+            shell: isWindowsShellScript(candidate),
+        };
+    }
+    return null;
+}
+function commonNpmCandidates(env) {
+    const names = process.platform === "win32" ? ["npm.cmd", "npm.bat", "npm"] : ["npm"];
+    const directories = [
+        path.dirname(process.execPath),
+        env.APPDATA ? path.join(env.APPDATA, "npm") : undefined,
+        env.ProgramFiles ? path.join(env.ProgramFiles, "nodejs") : undefined,
+        env["ProgramFiles(x86)"] ? path.join(env["ProgramFiles(x86)"], "nodejs") : undefined,
+    ].filter((value) => Boolean(value));
+    return directories.flatMap((directory) => names.map((name) => path.join(directory, name)));
+}
+function isWindowsShellScript(filePath) {
+    return process.platform === "win32" && /\.(?:cmd|bat)$/i.test(filePath);
+}
 function readVersionCache(packageName) {
     const ttlMs = parseVersionCacheTtlMs();
     if (ttlMs <= 0) {

package/dist/relay-artifact-service.js

@@ -0,0 +1,126 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { collectRecentWorkspaceArtifacts, createArtifactZipBundle, getArtifactTurnReport, listRecentArtifactReports, persistWorkspaceArtifactReport, removeArtifactTurn, totalArtifactSize, } from "./artifacts.js";
+const MAX_TEXT_PREVIEW_BYTES = 256 * 1024;
+export class RelayArtifactService {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async list(workspace, limit = 20) {
+        return (await listRecentArtifactReports(workspace, limit, this.config.maxFileSize)).map(artifactDto);
+    }
+    async get(workspace, turnId) {
+        return getArtifactTurnReport(workspace, turnId, this.config.maxFileSize);
+    }
+    async delete(workspace, turnId) {
+        return removeArtifactTurn(workspace, turnId);
+    }
+    async createZip(workspace, turnId) {
+        const report = await this.get(workspace, 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;
+    }
+    async preview(workspace, turnId, relativePath) {
+        const report = await this.get(workspace, 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 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 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 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/relay-external-activity-monitor.js

@@ -0,0 +1,216 @@
+import {} from "./agent.js";
+import { getExternalSnapshotForSession } from "./agent-activity.js";
+import { friendlyErrorText } from "./error-messages.js";
+import {} from "./web-state.js";
+export class RelayExternalActivityMonitor {
+    options;
+    mirror = null;
+    running = false;
+    constructor(options) {
+        this.options = options;
+    }
+    snapshot() {
+        return this.mirror ? { ...this.mirror } : null;
+    }
+    task() {
+        if (!this.mirror) {
+            return null;
+        }
+        const startedAt = this.mirror.startedAt ?? new Date().toISOString();
+        const startedMs = new Date(startedAt).getTime();
+        return {
+            id: this.mirror.turnId ?? "cli",
+            source: "cli",
+            status: this.mirror.latestStatus?.includes("failed")
+                ? "failed"
+                : this.mirror.latestStatus?.includes("aborted")
+                    ? "aborted"
+                    : this.mirror.latestStatus?.includes("finished") || this.mirror.latestStatus?.includes("completed")
+                        ? "completed"
+                        : "running",
+            threadId: this.mirror.threadId,
+            startedAt,
+            updatedAt: new Date().toISOString(),
+            durationMs: Number.isFinite(startedMs) ? Math.max(0, Date.now() - startedMs) : 0,
+            outputChars: 0,
+            tools: [],
+            detail: this.mirror.latestStatus ?? this.mirror.rolloutPath,
+        };
+    }
+    async monitorSafe() {
+        if (this.running) {
+            return;
+        }
+        this.running = true;
+        try {
+            await this.monitor();
+        }
+        catch (error) {
+            this.options.broadcastStatus(friendlyErrorText(error), "error");
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async monitor() {
+        const session = await this.options.getSession();
+        const info = this.options.publicInfo(session);
+        if (!info.capabilities.externalActivity || !info.threadId || session.isProcessing()) {
+            return;
+        }
+        const snapshot = getExternalSnapshotForSession(session, this.options.config, {
+            afterLine: this.mirror?.threadId === info.threadId ? this.mirror.lastLine : Number.MAX_SAFE_INTEGER,
+        }) ?? getExternalSnapshotForSession(session, this.options.config, {
+            maxEvents: 0,
+        });
+        if (!snapshot) {
+            return;
+        }
+        if (!this.mirror || this.mirror.threadId !== snapshot.threadId || this.mirror.rolloutPath !== snapshot.sourcePath) {
+            this.mirror = {
+                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.mirror;
+        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.options.queueLength());
+            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 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({
+                    threadId: snapshot.threadId,
+                    role: "agent",
+                    text: finalText,
+                    source: "cli",
+                    turnId: terminalEvent.turnId ?? undefined,
+                });
+                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(),
+            });
+            this.options.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.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() });
+            await this.options.drainQueue();
+        }
+        mirror.lastLine = Math.max(mirror.lastLine, snapshot.lineCount);
+    }
+    startExternalTurn(snapshot) {
+        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",
+        });
+        this.options.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.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",
+                    type: "cli_tool_started",
+                    threadId: snapshot.threadId,
+                    detail: event.toolName ?? "tool",
+                });
+            }
+            if (event.kind === "tool" && event.status === "finished") {
+                this.options.broadcast({
+                    type: "tool_end",
+                    id: snapshot.activity.turnId ?? "cli",
+                    toolCallId: `cli-${event.lineNumber}`,
+                    isError: false,
+                });
+            }
+        }
+    }
+}
+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 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`;
+}

package/dist/relay-queue-service.js

@@ -0,0 +1,66 @@
+export class RelayQueueService {
+    promptStore;
+    contextKey;
+    constructor(promptStore, contextKey) {
+        this.promptStore = promptStore;
+        this.contextKey = contextKey;
+    }
+    list() {
+        return this.rawList().map(queueItemDto);
+    }
+    rawList() {
+        return this.promptStore.list(this.contextKey);
+    }
+    length() {
+        return this.rawList().length;
+    }
+    isPaused() {
+        return this.promptStore.isPaused(this.contextKey);
+    }
+    enqueue(envelope) {
+        return this.promptStore.enqueue(this.contextKey, envelope);
+    }
+    enqueueFront(item) {
+        this.promptStore.enqueueFront(this.contextKey, item);
+    }
+    dequeue() {
+        return this.promptStore.dequeue(this.contextKey);
+    }
+    setLastPrompt(envelope) {
+        this.promptStore.setLastPrompt(this.contextKey, envelope);
+    }
+    getLastPrompt() {
+        return this.promptStore.getLastPrompt(this.contextKey);
+    }
+    apply(action, id) {
+        if (action === "pause")
+            this.promptStore.pause(this.contextKey);
+        if (action === "resume")
+            this.promptStore.resume(this.contextKey);
+        if (action === "clear")
+            this.promptStore.clear(this.contextKey);
+        if (id && action === "cancel")
+            this.promptStore.remove(this.contextKey, id);
+        if (id && action === "top")
+            this.promptStore.moveToTop(this.contextKey, id);
+        if (id && action === "up")
+            this.promptStore.moveUp(this.contextKey, id);
+        if (id && action === "down")
+            this.promptStore.moveDown(this.contextKey, id);
+        if (id && action === "run") {
+            const item = this.promptStore.remove(this.contextKey, id);
+            if (item)
+                this.promptStore.enqueueFront(this.contextKey, item);
+        }
+    }
+}
+export 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,
+    };
+}

package/dist/relay-runtime-types.js

@@ -0,0 +1 @@
+export {};