@nordbyte/nordrelay 0.5.1 → 0.6.0

package/dist/operations.js

@@ -1,5 +1,5 @@
-import { spawn, spawnSync } from "node:child_process";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, writeFileSync } from "node:fs";
+import { execFile, spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -21,6 +21,8 @@ const CLAUDE_CODE_SDK_PACKAGE_NAME = "@anthropic-ai/claude-agent-sdk";
 const DEFAULT_HOME = path.join(os.homedir(), ".nordrelay");
 const SECRET_RE = /(bot|token|api[_-]?key|authorization|bearer|password|secret)(["'=: ]+)([^\s"',]+)/gi;
 const DEFAULT_VERSION_CACHE_TTL_MS = 60 * 60 * 1000;
+const DEFAULT_CLI_VERSION_CACHE_TTL_MS = 60 * 1000;
+const cliVersionCache = new Map();
 export function getConnectorHome() {
     return process.env.NORDRELAY_HOME || DEFAULT_HOME;
 }
@@ -96,97 +98,86 @@ export async function getPackageVersion() {
     }
 }
 export async function getVersionChecks(options = {}) {
-    const nordrelayVersion = await getPackageVersion();
-    const codexCli = resolveCodexCli();
-    const piCli = resolvePiCli(process.env, options.piCliPath);
-    const hermesCli = resolveHermesCli(process.env, options.hermesCliPath);
-    const openClawCli = resolveOpenClawCli(process.env, options.openClawCliPath);
-    const claudeCodeCli = resolveClaudeCodeCli(process.env, options.claudeCodeCliPath);
-    const codexVersionLabel = codexCli.path
-        ? detectCliVersion(codexCli.path)
-        : readInstalledPackageVersion(CODEX_PACKAGE_NAME) ?? "not installed";
-    const piVersionLabel = piCli.path
-        ? detectCliVersion(piCli.path)
-        : readInstalledPackageVersion(PI_PACKAGE_NAME) ?? readInstalledPackageVersion(LEGACY_PI_PACKAGE_NAME) ?? "not installed";
-    const legacyPiPackageVersion = readInstalledPackageVersion(LEGACY_PI_PACKAGE_NAME);
-    const hermesVersionLabel = hermesCli.path ? detectCliVersion(hermesCli.path) : "not installed";
-    const openClawVersionLabel = openClawCli.path ? detectCliVersion(openClawCli.path) : "not installed";
-    const claudeCodeVersionLabel = claudeCodeCli.path
-        ? detectCliVersion(claudeCodeCli.path)
-        : readInstalledPackageVersion(CLAUDE_CODE_SDK_PACKAGE_NAME) ?? "bundled";
-    const claudeCodePackageName = claudeCodeCli.path ? CLAUDE_CODE_PACKAGE_NAME : CLAUDE_CODE_SDK_PACKAGE_NAME;
-    return {
-        nordrelay: buildVersionCheck({
+    const [nordrelayVersion, cliVersions] = await Promise.all([
+        getPackageVersion(),
+        resolveAgentCliVersions(options),
+    ]);
+    const [nordrelay, codex, pi, hermes, openclaw, claudeCode,] = await Promise.all([
+        buildVersionCheck({
             label: "NordRelay",
             packageName: PACKAGE_NAME,
             installedLabel: nordrelayVersion,
             installedVersion: extractVersion(nordrelayVersion),
         }),
-        codex: buildVersionCheck({
+        buildVersionCheck({
             label: "Codex",
             packageName: CODEX_PACKAGE_NAME,
-            installedLabel: codexVersionLabel,
-            installedVersion: extractVersion(codexVersionLabel),
-            notInstalled: codexVersionLabel === "not installed",
+            installedLabel: cliVersions.codexVersionLabel,
+            installedVersion: extractVersion(cliVersions.codexVersionLabel),
+            notInstalled: cliVersions.codexVersionLabel === "not installed",
         }),
-        pi: buildVersionCheck({
+        buildVersionCheck({
             label: "Pi",
             packageName: PI_PACKAGE_NAME,
-            installedLabel: piVersionLabel,
-            installedVersion: extractVersion(piVersionLabel),
-            notInstalled: piVersionLabel === "not installed",
-            detail: legacyPiPackageVersion ? `Legacy package ${LEGACY_PI_PACKAGE_NAME} is present; current package is ${PI_PACKAGE_NAME}.` : undefined,
+            installedLabel: cliVersions.piVersionLabel,
+            installedVersion: extractVersion(cliVersions.piVersionLabel),
+            notInstalled: cliVersions.piVersionLabel === "not installed",
+            detail: cliVersions.legacyPiPackageVersion ? `Legacy package ${LEGACY_PI_PACKAGE_NAME} is present; current package is ${PI_PACKAGE_NAME}.` : undefined,
         }),
-        hermes: buildHermesVersionCheck(hermesVersionLabel),
-        openclaw: buildVersionCheck({
+        buildHermesVersionCheck(cliVersions.hermesVersionLabel),
+        buildVersionCheck({
             label: "OpenClaw",
             packageName: OPENCLAW_PACKAGE_NAME,
-            installedLabel: openClawVersionLabel,
-            installedVersion: extractVersion(openClawVersionLabel),
-            notInstalled: openClawVersionLabel === "not installed",
+            installedLabel: cliVersions.openClawVersionLabel,
+            installedVersion: extractVersion(cliVersions.openClawVersionLabel),
+            notInstalled: cliVersions.openClawVersionLabel === "not installed",
         }),
-        claudeCode: buildVersionCheck({
+        buildVersionCheck({
             label: "Claude Code",
-            packageName: claudeCodePackageName,
-            installedLabel: claudeCodeVersionLabel,
-            installedVersion: extractVersion(claudeCodeVersionLabel),
-            notInstalled: claudeCodeVersionLabel === "not installed",
+            packageName: cliVersions.claudeCodePackageName,
+            installedLabel: cliVersions.claudeCodeVersionLabel,
+            installedVersion: extractVersion(cliVersions.claudeCodeVersionLabel),
+            notInstalled: cliVersions.claudeCodeVersionLabel === "not installed",
         }),
+    ]);
+    return {
+        nordrelay,
+        codex,
+        pi,
+        hermes,
+        openclaw,
+        claudeCode,
     };
 }
 export async function getConnectorHealth(options = {}) {
-    const rawState = await readConnectorState();
-    const version = await getPackageVersion();
+    const [rawState, version, cliVersions] = await Promise.all([
+        readConnectorState(),
+        getPackageVersion(),
+        resolveAgentCliVersions(options),
+    ]);
     const pidRunning = isProcessRunning(rawState.pid);
     const appPidRunning = isProcessRunning(rawState.appPid);
     const state = normalizeConnectorState(rawState, pidRunning, appPidRunning);
-    const codexCli = resolveCodexCli();
-    const piCli = resolvePiCli(process.env, options.piCliPath);
-    const hermesCli = resolveHermesCli(process.env, options.hermesCliPath);
-    const openClawCli = resolveOpenClawCli(process.env, options.openClawCliPath);
-    const claudeCodeCli = resolveClaudeCodeCli(process.env, options.claudeCodeCliPath);
     return {
         version,
         state,
         pidRunning,
         appPidRunning,
-        codexCli: describeCodexCli(codexCli),
-        codexCliPath: codexCli.path ?? null,
-        codexCliVersion: detectCliVersion(codexCli.path),
-        piCli: describePiCli(piCli),
-        piCliPath: piCli.path ?? null,
-        piCliVersion: detectCliVersion(piCli.path),
-        hermesCli: describeHermesCli(hermesCli),
-        hermesCliPath: hermesCli.path ?? null,
-        hermesCliVersion: detectCliVersion(hermesCli.path),
-        openClawCli: describeOpenClawCli(openClawCli),
-        openClawCliPath: openClawCli.path ?? null,
-        openClawCliVersion: detectCliVersion(openClawCli.path),
-        claudeCodeCli: describeClaudeCodeCli(claudeCodeCli),
-        claudeCodeCliPath: claudeCodeCli.path ?? null,
-        claudeCodeCliVersion: claudeCodeCli.path
-            ? detectCliVersion(claudeCodeCli.path)
-            : readInstalledPackageVersion(CLAUDE_CODE_SDK_PACKAGE_NAME) ?? "bundled",
+        codexCli: describeCodexCli(cliVersions.codexCli),
+        codexCliPath: cliVersions.codexCli.path ?? null,
+        codexCliVersion: cliVersions.codexVersionLabel,
+        piCli: describePiCli(cliVersions.piCli),
+        piCliPath: cliVersions.piCli.path ?? null,
+        piCliVersion: cliVersions.piVersionLabel,
+        hermesCli: describeHermesCli(cliVersions.hermesCli),
+        hermesCliPath: cliVersions.hermesCli.path ?? null,
+        hermesCliVersion: cliVersions.hermesVersionLabel,
+        openClawCli: describeOpenClawCli(cliVersions.openClawCli),
+        openClawCliPath: cliVersions.openClawCli.path ?? null,
+        openClawCliVersion: cliVersions.openClawVersionLabel,
+        claudeCodeCli: describeClaudeCodeCli(cliVersions.claudeCodeCli),
+        claudeCodeCliPath: cliVersions.claudeCodeCli.path ?? null,
+        claudeCodeCliVersion: cliVersions.claudeCodeVersionLabel,
         stateFile: getConnectorStatePath(),
         logFile: getConnectorLogPath(),
         databasePath: findLatestDatabase(),
@@ -208,23 +199,22 @@ export function spawnSelfUpdate() {
     const script = getWrapperScriptPath();
     const updateLog = getUpdateLogPath();
     const method = detectSelfUpdateMethod(sourceRoot);
-    const commands = method === "npm"
-        ? buildNpmSelfUpdateCommands()
-        : buildGitSelfUpdateCommands(script);
-    const logFd = openSync(updateLog, "a");
-    const command = [
-        "set -e",
-        `printf '\\n[%s] Starting ${method} connector self-update\\n' "$(date -Is)"`,
-        ...commands,
-    ].join(" && ");
-    const child = spawn("sh", ["-lc", command], {
+    mkdirSync(path.dirname(updateLog), { recursive: true });
+    const child = spawn(process.execPath, [
+        script,
+        "update",
+        "--method",
+        method,
+        "--home",
+        getConnectorHome(),
+        "--keep-pending-updates",
+    ], {
         cwd: sourceRoot,
         detached: true,
         env: process.env,
-        stdio: ["ignore", logFd, logFd],
+        stdio: "ignore",
     });
     child.unref();
-    closeSync(logFd);
     return {
         logPath: updateLog,
         method,
@@ -274,41 +264,62 @@ function normalizeConnectorState(state, pidRunning, appPidRunning) {
 function redactSecrets(text) {
     return text.replace(SECRET_RE, "$1$2[redacted]");
 }
-function buildGitSelfUpdateCommands(script) {
-    return [
-        "git pull --ff-only origin main",
-        "npm install",
-        "npm run check",
-        "npm test",
-        "npm run build",
-        `printf '[%s] Checks passed; restarting connector\\n' "$(date -Is)"`,
-        `${shellQuote(process.execPath)} ${shellQuote(script)} restart --keep-pending-updates`,
-    ];
-}
-function buildNpmSelfUpdateCommands() {
-    return [
-        `${resolveNpmCommand()} install -g ${PACKAGE_NAME}@latest`,
-        "nordrelay version",
-        `printf '[%s] npm update finished; restarting connector\\n' "$(date -Is)"`,
-        "nordrelay restart --keep-pending-updates",
-    ];
-}
-function resolveNpmCommand() {
-    const npm = resolveNpmSpawnCommand();
-    if (npm) {
-        return [npm.command, ...npm.argsPrefix].map(shellQuote).join(" ");
-    }
-    return "npm";
+async function resolveAgentCliVersions(options = {}) {
+    const codexCli = resolveCodexCli();
+    const piCli = resolvePiCli(process.env, options.piCliPath);
+    const hermesCli = resolveHermesCli(process.env, options.hermesCliPath);
+    const openClawCli = resolveOpenClawCli(process.env, options.openClawCliPath);
+    const claudeCodeCli = resolveClaudeCodeCli(process.env, options.claudeCodeCliPath);
+    const legacyPiPackageVersion = readInstalledPackageVersion(LEGACY_PI_PACKAGE_NAME);
+    const [codexVersionLabel, piVersionLabel, hermesVersionLabel, openClawVersionLabel, claudeCodeVersionLabel,] = await Promise.all([
+        codexCli.path ? detectCliVersion(codexCli.path) : Promise.resolve(readInstalledPackageVersion(CODEX_PACKAGE_NAME) ?? "not installed"),
+        piCli.path ? detectCliVersion(piCli.path) : Promise.resolve(readInstalledPackageVersion(PI_PACKAGE_NAME) ?? legacyPiPackageVersion ?? "not installed"),
+        hermesCli.path ? detectCliVersion(hermesCli.path) : Promise.resolve("not installed"),
+        openClawCli.path ? detectCliVersion(openClawCli.path) : Promise.resolve("not installed"),
+        claudeCodeCli.path ? detectCliVersion(claudeCodeCli.path) : Promise.resolve(readInstalledPackageVersion(CLAUDE_CODE_SDK_PACKAGE_NAME) ?? "bundled"),
+    ]);
+    return {
+        codexCli,
+        piCli,
+        hermesCli,
+        openClawCli,
+        claudeCodeCli,
+        codexVersionLabel,
+        piVersionLabel,
+        hermesVersionLabel,
+        openClawVersionLabel,
+        claudeCodeVersionLabel,
+        claudeCodePackageName: claudeCodeCli.path ? CLAUDE_CODE_PACKAGE_NAME : CLAUDE_CODE_SDK_PACKAGE_NAME,
+        legacyPiPackageVersion,
+    };
 }
-function detectCliVersion(commandPath) {
+async function detectCliVersion(commandPath) {
     if (!commandPath) {
         return "not installed";
     }
-    const result = spawnSync(commandPath, ["--version"], {
-        encoding: "utf8",
+    const ttlMs = parseCliVersionCacheTtlMs();
+    if (ttlMs > 0) {
+        const cached = cliVersionCache.get(commandPath);
+        if (cached && Date.now() < cached.expiresAt) {
+            if (cached.value !== undefined) {
+                return cached.value;
+            }
+            if (cached.promise) {
+                return cached.promise;
+            }
+        }
+        const promise = detectCliVersionUncached(commandPath);
+        cliVersionCache.set(commandPath, { promise, expiresAt: Date.now() + ttlMs });
+        const value = await promise;
+        cliVersionCache.set(commandPath, { value, expiresAt: Date.now() + ttlMs });
+        return value;
+    }
+    return detectCliVersionUncached(commandPath);
+}
+async function detectCliVersionUncached(commandPath) {
+    const result = await runCommand(commandPath, ["--version"], {
         shell: isWindowsShellScript(commandPath),
         timeout: 3000,
-        windowsHide: true,
     });
     const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
     if (result.error) {
@@ -319,9 +330,9 @@ function detectCliVersion(commandPath) {
     }
     return output || "unknown";
 }
-function buildHermesVersionCheck(installedLabel) {
+async function buildHermesVersionCheck(installedLabel) {
     if (installedLabel === "not installed") {
-        const latest = detectLatestNpmVersion(HERMES_PACKAGE_NAME);
+        const latest = await detectLatestNpmVersion(HERMES_PACKAGE_NAME);
         return {
             label: "Hermes",
             packageName: HERMES_PACKAGE_NAME,
@@ -346,9 +357,9 @@ function buildHermesVersionCheck(installedLabel) {
         detail: updateLine ?? (installedVersion ? undefined : "Could not parse Hermes version or update status"),
     };
 }
-function buildVersionCheck(options) {
+async function buildVersionCheck(options) {
     if (options.notInstalled) {
-        const latest = options.skipLatest ? { version: null, error: undefined } : detectLatestNpmVersion(options.packageName);
+        const latest = options.skipLatest ? { version: null, error: undefined } : await detectLatestNpmVersion(options.packageName);
         return {
             label: options.label,
             packageName: options.packageName,
@@ -370,7 +381,7 @@ function buildVersionCheck(options) {
             detail: options.detail ?? "Latest-version lookup is not available for this package source",
         };
     }
-    const latest = detectLatestNpmVersion(options.packageName);
+    const latest = await detectLatestNpmVersion(options.packageName);
     if (!options.installedVersion || !latest.version) {
         return {
             label: options.label,
@@ -392,7 +403,7 @@ function buildVersionCheck(options) {
         detail: [options.detail, latest.error].filter(Boolean).join(" ") || undefined,
     };
 }
-function detectLatestNpmVersion(packageName) {
+async function detectLatestNpmVersion(packageName) {
     const cached = readVersionCache(packageName);
     if (cached) {
         return cached;
@@ -401,11 +412,9 @@ function detectLatestNpmVersion(packageName) {
     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",
+    const result = await runCommand(npm.command, [...npm.argsPrefix, "view", packageName, "version", "--registry=https://registry.npmjs.org"], {
         shell: npm.shell,
         timeout: 5000,
-        windowsHide: true,
     });
     const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
     if (result.error) {
@@ -418,6 +427,49 @@ function detectLatestNpmVersion(packageName) {
     writeVersionCache(packageName, resolved.version);
     return resolved;
 }
+function runCommand(command, args, options) {
+    return new Promise((resolve) => {
+        const useShell = Boolean(options.shell);
+        execFile(useShell ? formatShellCommand(command, args) : command, useShell ? [] : args, {
+            encoding: "utf8",
+            shell: useShell,
+            timeout: options.timeout,
+            windowsHide: true,
+            env: process.env,
+            maxBuffer: 1024 * 1024,
+        }, (error, stdout, stderr) => {
+            const enriched = error;
+            resolve({
+                stdout: typeof stdout === "string" ? stdout : "",
+                stderr: typeof stderr === "string" ? stderr : "",
+                status: typeof enriched?.code === "number" ? enriched.code : error ? 1 : 0,
+                signal: enriched?.signal,
+                error: enriched ?? undefined,
+            });
+        });
+    });
+}
+function formatShellCommand(command, args) {
+    return [command, ...args].map(quoteShellArg).join(" ");
+}
+function quoteShellArg(value) {
+    if (process.platform === "win32") {
+        return quoteWindowsCmdArg(value);
+    }
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function quoteWindowsCmdArg(value) {
+    if (value.length === 0) {
+        return "\"\"";
+    }
+    if (!/[\s"&|<>()^%]/.test(value)) {
+        return value;
+    }
+    return `"${value
+        .replace(/%/g, "%%")
+        .replace(/(\\*)"/g, '$1$1\\"')
+        .replace(/(\\+)$/g, "$1$1")}"`;
+}
 export function resolveNpmSpawnCommand(env = process.env) {
     const npmExecPath = env.npm_execpath?.trim();
     if (npmExecPath && existsSync(npmExecPath)) {
@@ -512,6 +564,14 @@ function parseVersionCacheTtlMs() {
     const parsed = Number(raw);
     return Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed)) : DEFAULT_VERSION_CACHE_TTL_MS;
 }
+function parseCliVersionCacheTtlMs() {
+    const raw = process.env.NORDRELAY_CLI_VERSION_CACHE_TTL_MS;
+    if (!raw) {
+        return DEFAULT_CLI_VERSION_CACHE_TTL_MS;
+    }
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed)) : DEFAULT_CLI_VERSION_CACHE_TTL_MS;
+}
 function readInstalledPackageVersion(packageName) {
     try {
         const packagePath = path.join(getSourceRoot(), "node_modules", ...packageName.split("/"), "package.json");
@@ -543,9 +603,6 @@ function compareVersions(left, right) {
 function parseVersionParts(value) {
     return value.split(/[.-]/).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
 }
-function shellQuote(value) {
-    return `'${value.replace(/'/g, `'\\''`)}'`;
-}
 function formatLogLine(line) {
     const trimmed = line.trim();
     if (!trimmed) {

package/dist/relay-external-activity-monitor.js

@@ -2,6 +2,10 @@ import {} from "./agent.js";
 import { getExternalSnapshotForSession } from "./agent-activity.js";
 import { friendlyErrorText } from "./error-messages.js";
 import {} from "./web-state.js";
+const CLI_ACTIVITY_ACTOR = {
+    channel: "cli",
+    label: "CLI",
+};
 export class RelayExternalActivityMonitor {
     options;
     mirror = null;
@@ -16,7 +20,9 @@ export class RelayExternalActivityMonitor {
         if (!this.mirror) {
             return null;
         }
-        const startedAt = this.mirror.startedAt ?? new Date().toISOString();
+        const startedAt = this.mirror.startedAt instanceof Date
+            ? this.mirror.startedAt.toISOString()
+            : this.mirror.startedAt ?? new Date().toISOString();
         const startedMs = new Date(startedAt).getTime();
         return {
             id: this.mirror.turnId ?? "cli",
@@ -75,7 +81,7 @@ export class RelayExternalActivityMonitor {
                 startedAt: snapshot.activity.startedAt?.toISOString() ?? null,
             };
             if (snapshot.activity.active) {
-                this.startExternalTurn(snapshot);
+                this.startExternalTurn(snapshot, info);
             }
             return;
         }
@@ -85,9 +91,9 @@ export class RelayExternalActivityMonitor {
                 mirror.turnId = snapshot.activity.turnId;
                 mirror.startedAt = snapshot.activity.startedAt?.toISOString() ?? null;
                 mirror.latestAgentLine = undefined;
-                this.startExternalTurn(snapshot);
+                this.startExternalTurn(snapshot, info);
             }
-            this.broadcastExternalEvents(snapshot, snapshot.events.filter((event) => event.lineNumber > mirror.lastLine));
+            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");
@@ -122,6 +128,7 @@ export class RelayExternalActivityMonitor {
                 threadId: snapshot.threadId,
                 workspace: info.workspace,
                 agentId: info.agentId,
+                actor: CLI_ACTIVITY_ACTOR,
                 prompt: snapshot.latestUserMessage ?? undefined,
                 detail: `${snapshot.agentLabel} CLI task ${terminalEvent.status ?? "finished"}.`,
                 durationMs: durationFromDates(externalStartedAt, terminalEvent.timestamp),
@@ -136,7 +143,7 @@ export class RelayExternalActivityMonitor {
         }
         mirror.lastLine = Math.max(mirror.lastLine, snapshot.lineCount);
     }
-    startExternalTurn(snapshot) {
+    startExternalTurn(snapshot, info) {
         const prompt = snapshot.latestUserMessage ?? `${snapshot.agentLabel} CLI task`;
         this.options.chatStore.append({
             threadId: snapshot.threadId,
@@ -158,11 +165,14 @@ export class RelayExternalActivityMonitor {
             status: "running",
             type: "cli_turn_started",
             threadId: snapshot.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            actor: CLI_ACTIVITY_ACTOR,
             prompt,
             detail: `${snapshot.sourceLabel}: ${snapshot.sourcePath}`,
         });
     }
-    broadcastExternalEvents(snapshot, events) {
+    broadcastExternalEvents(snapshot, events, info) {
         for (const event of events) {
             if (event.kind === "tool" && event.status === "started") {
                 this.options.broadcast({
@@ -176,6 +186,9 @@ export class RelayExternalActivityMonitor {
                     status: "running",
                     type: "cli_tool_started",
                     threadId: snapshot.threadId,
+                    workspace: info.workspace,
+                    agentId: info.agentId,
+                    actor: CLI_ACTIVITY_ACTOR,
                     detail: event.toolName ?? "tool",
                 });
             }
@@ -186,6 +199,34 @@ export class RelayExternalActivityMonitor {
                     toolCallId: `cli-${event.lineNumber}`,
                     isError: false,
                 });
+                this.options.appendActivity({
+                    source: "cli",
+                    status: "completed",
+                    type: "cli_tool_completed",
+                    threadId: snapshot.threadId,
+                    workspace: info.workspace,
+                    agentId: info.agentId,
+                    actor: CLI_ACTIVITY_ACTOR,
+                    detail: event.toolName ?? "tool",
+                });
+            }
+            if (event.kind === "tool" && event.status === "failed") {
+                this.options.broadcast({
+                    type: "tool_end",
+                    id: snapshot.activity.turnId ?? "cli",
+                    toolCallId: `cli-${event.lineNumber}`,
+                    isError: true,
+                });
+                this.options.appendActivity({
+                    source: "cli",
+                    status: "failed",
+                    type: "cli_tool_failed",
+                    threadId: snapshot.threadId,
+                    workspace: info.workspace,
+                    agentId: info.agentId,
+                    actor: CLI_ACTIVITY_ACTOR,
+                    detail: event.toolName ?? "tool",
+                });
             }
         }
     }