fraim-hub 2.0.272 → 2.0.274

package/dist/src/ai-hub/hosts.js

@@ -28,6 +28,7 @@ exports.parseHostLine = parseHostLine;
 exports.findGeminiSessionIdForPrompt = findGeminiSessionIdForPrompt;
 const crypto_1 = require("crypto");
 const child_process_1 = require("child_process");
+const tree_kill_1 = __importDefault(require("tree-kill"));
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
@@ -743,20 +744,40 @@ function resolveHostInvocation(plan) {
         args: ['/d', '/s', '/c', [command, ...args.map(escapeWindowsArg)].join(' ')],
     };
 }
+function stripProjectLocalNodeBinDirs(basePath) {
+    return (basePath ?? '')
+        .split(path_1.default.delimiter)
+        .filter(Boolean)
+        .filter((entry) => {
+        const normalized = path_1.default.normalize(entry).toLowerCase();
+        return !normalized.endsWith(`${path_1.default.sep}node_modules${path_1.default.sep}.bin`);
+    })
+        .join(path_1.default.delimiter);
+}
+function buildAgentVersionProbePath(basePath) {
+    const withoutManaged = (0, managed_agent_paths_1.stripManagedAgentBinDirsFromPath)(basePath);
+    const withoutProjectBins = stripProjectLocalNodeBinDirs(withoutManaged);
+    return (0, managed_agent_paths_1.appendBinDirsToPath)(withoutProjectBins, (0, managed_agent_paths_1.getManagedAgentBinDirs)());
+}
 // Single source for the probe environment, shared by the sync and async probes so the two
-// cannot drift on how the managed-agent bin directories are put on PATH.
+// cannot drift on how agent bin directories are put on PATH. Project-local npm shims are
+// intentionally excluded: the Hub is checking installed user agent CLIs, not devDependency
+// shims from whichever project happened to launch it.
 const versionProbeEnv = () => ({
     ...process.env,
-    PATH: (0, managed_agent_paths_1.buildPathWithManagedAgentBins)(process.env.PATH ?? process.env.Path),
-    Path: (0, managed_agent_paths_1.buildPathWithManagedAgentBins)(process.env.PATH ?? process.env.Path),
+    PATH: buildAgentVersionProbePath(process.env.PATH ?? process.env.Path),
+    Path: buildAgentVersionProbePath(process.env.PATH ?? process.env.Path),
 });
+// Returns the version string on success, or null when the CLI is absent.
 const availableByVersionProbe = (command) => {
     const invocation = resolveHostInvocation({ command, args: ['--version'] });
     const result = (0, child_process_1.spawnSync)(invocation.command, invocation.args, {
         encoding: 'utf8',
         env: versionProbeEnv(),
     });
-    return result.status === 0;
+    if (result.status !== 0 || result.error)
+        return null;
+    return (result.stdout || result.stderr || '').trim() || null;
 };
 // Issue #1010: the async counterpart of availableByVersionProbe. Same semantics (exit 0
 // from `<agent> --version` means the CLI is installed AND actually runs), but non-blocking
@@ -769,11 +790,13 @@ const availableByVersionProbe = (command) => {
 // print its version within 10s is reported unavailable rather than allowed to hang the Hub.
 // It is recoverable from the UI via the existing per-agent "Check" action.
 const VERSION_PROBE_TIMEOUT_MS = 10_000;
+// Returns the version string on success, or null when the CLI is absent.
 const availableByVersionProbeAsync = (command) => new Promise((resolve) => {
     const invocation = resolveHostInvocation({ command, args: ['--version'] });
     let settled = false;
     let timer;
     let child;
+    const chunks = [];
     const finish = (value) => {
         if (settled)
             return;
@@ -785,23 +808,28 @@ const availableByVersionProbeAsync = (command) => new Promise((resolve) => {
     try {
         child = (0, child_process_1.spawn)(invocation.command, invocation.args, {
             env: versionProbeEnv(),
-            stdio: 'ignore',
+            stdio: ['ignore', 'pipe', 'pipe'],
         });
+        child.stdout?.on('data', (chunk) => chunks.push(chunk));
+        child.stderr?.on('data', (chunk) => chunks.push(chunk));
         timer = setTimeout(() => {
             console.warn(`[ai-hub] agent version probe timed out after ${VERSION_PROBE_TIMEOUT_MS}ms: ${command}`);
             try {
                 child?.kill();
             }
             catch { /* already gone */ }
-            finish(false);
+            finish(null);
         }, VERSION_PROBE_TIMEOUT_MS);
         // Do not hold the process open just for a probe.
         timer.unref?.();
-        child.on('error', () => finish(false));
-        child.on('close', (code) => finish(code === 0));
+        child.on('error', () => finish(null));
+        child.on('close', (code) => {
+            const raw = Buffer.concat(chunks).toString('utf8').trim();
+            finish(code === 0 ? (raw || null) : null);
+        });
     }
     catch {
-        finish(false);
+        finish(null);
     }
 });
 // ─── Issue #1010: employee-detection cache ───────────────────────────────────
@@ -978,11 +1006,13 @@ function __getEmployeeProbeRoundsForTests() {
 function __resetEmployeeProbeRoundsForTests() {
     employeeProbeRounds = 0;
 }
-function buildEmployeeStatus(id, available) {
+function buildEmployeeStatus(id, version) {
+    const available = version !== null;
     return {
         id,
         label: EMPLOYEE_LABELS[id],
         available,
+        version,
         detail: available ? 'Installed and ready on this machine.' : 'CLI not detected on this machine.',
         supportsRaw: supportsDirectPath(id),
     };
@@ -1532,6 +1562,22 @@ function parseHostLine(hostId, line) {
             if (parsed.type === 'turn_context' && typeof parsed.payload?.model === 'string') {
                 return withSignal({ raw: trimmed, agentIdentity: { agentName: 'codex', agentModel: parsed.payload.model } });
             }
+            // Issue #1221: Codex reports stream failures (session-model mismatch
+            // notices, reconnect/rate-limit retries, and the terminal turn.failed)
+            // as `type: "error"` / `type: "item.completed" item.type: "error"` /
+            // `type: "turn.failed"`. These previously fell through to raw JSON,
+            // which the conversation projector drops as opaque payload — so a
+            // debilitating failure (e.g. an Azure rate limit) never reached the
+            // manager. Surface the message text as hostError instead.
+            if (parsed.type === 'error' && typeof parsed.message === 'string') {
+                return withSignal({ hostError: parsed.message, raw: trimmed });
+            }
+            if (parsed.type === 'item.completed' && parsed.item?.type === 'error' && typeof parsed.item.message === 'string') {
+                return withSignal({ hostError: parsed.item.message, raw: trimmed });
+            }
+            if (parsed.type === 'turn.failed' && typeof parsed.error?.message === 'string') {
+                return withSignal({ hostError: parsed.error.message, raw: trimmed });
+            }
             return withSignal({ raw: trimmed });
         }
         catch {
@@ -1595,6 +1641,40 @@ function parseHostLine(hostId, line) {
     }
     try {
         const parsed = JSON.parse(trimmed);
+        // Issue #1234: a task appearing in `background_tasks_changed.tasks` is a
+        // genuinely backgrounded (still-running) command. `task_started` /
+        // `task_notification` fire for every Bash call, sync or backgrounded, so
+        // they are deliberately NOT parsed here — only this event and
+        // `task_updated` distinguish real background-task state.
+        if (parsed.type === 'system' && parsed.subtype === 'background_tasks_changed' && Array.isArray(parsed.tasks)) {
+            return withSignal({
+                sessionId: parsed.session_id,
+                raw: trimmed,
+                hostLifecycle: {
+                    status: 'background_tasks_changed',
+                    source: hostId,
+                    backgroundTasks: parsed.tasks
+                        .filter((t) => typeof t.task_id === 'string')
+                        .map((t) => ({ taskId: t.task_id, description: t.description })),
+                },
+            });
+        }
+        // Issue #1234: the authoritative terminal-status update for a tracked
+        // background task. `patch.status` is `"completed"` or `"killed"` in the
+        // observed schema; treat anything else as `"killed"` conservatively.
+        if (parsed.type === 'system' && parsed.subtype === 'task_updated' && typeof parsed.task_id === 'string') {
+            const backgroundTaskStatus = parsed.patch?.status === 'completed' ? 'completed' : 'killed';
+            return withSignal({
+                sessionId: parsed.session_id,
+                raw: trimmed,
+                hostLifecycle: {
+                    status: 'background_task_updated',
+                    source: hostId,
+                    backgroundTaskId: parsed.task_id,
+                    backgroundTaskStatus,
+                },
+            });
+        }
         if (parsed.type === 'system' && parsed.session_id) {
             return withSignal({ sessionId: parsed.session_id, raw: trimmed });
         }
@@ -1776,6 +1856,16 @@ function normalizeGeminiPromptForMatch(value) {
     return String(value || '').replace(/\s+/g, ' ').trim();
 }
 class CliHostRuntime {
+    constructor(spawn = spawnHostProcess, killTree = (pid, signal) => (0, tree_kill_1.default)(pid, signal)) {
+        this.spawn = spawn;
+        this.killTree = killTree;
+        // Issue #1176: active continuation runs keyed by `${hostId}::${sessionId}` (R1,
+        // R13, R14). Lives on this long-lived singleton instance, in-memory only (R15).
+        // `spawn`/`killTree` are constructor-injectable so tests can prove queueing,
+        // batching, and course-correction deterministically without launching a real
+        // host CLI or touching a real OS process (R20).
+        this.activeContinueRuns = new Map();
+    }
     detectEmployees() {
         return detectEmployees();
     }
@@ -1784,16 +1874,91 @@ class CliHostRuntime {
         return detectEmployeesAsync();
     }
     startRun(hostId, projectPath, message, handlers, sessionId, launchContext) {
-        return spawnHostProcess(hostId, (0, configured_agents_1.decorateHostPlanWithConfiguredAgent)(buildStartPlan(hostId, message, sessionId), launchContext?.agent, launchContext?.env), projectPath, handlers);
+        // R11: start/startDirect mint sessions rather than resuming one, so they
+        // stay outside the continuation queue entirely.
+        return this.spawn(hostId, (0, configured_agents_1.decorateHostPlanWithConfiguredAgent)(buildStartPlan(hostId, message, sessionId), launchContext?.agent, launchContext?.env), projectPath, handlers);
     }
-    continueRun(hostId, projectPath, sessionId, message, handlers, launchContext) {
-        return spawnHostProcess(hostId, (0, configured_agents_1.decorateHostPlanWithConfiguredAgent)(buildContinuePlan(hostId, sessionId, message), launchContext?.agent, launchContext?.env), projectPath, handlers);
+    continueRun(hostId, projectPath, sessionId, message, handlers, launchContext, deliveryIntent) {
+        return this.guardedContinue(hostId, sessionId, { projectPath, message, handlers, launchContext, deliveryIntent });
     }
     startDirectRun(hostId, message, projectPath, handlers, sessionId, launchContext) {
-        return spawnHostProcess(hostId, (0, configured_agents_1.decorateHostPlanWithConfiguredAgent)(buildDirectStartPlan(hostId, message, sessionId), launchContext?.agent, launchContext?.env), projectPath, handlers);
+        return this.spawn(hostId, (0, configured_agents_1.decorateHostPlanWithConfiguredAgent)(buildDirectStartPlan(hostId, message, sessionId), launchContext?.agent, launchContext?.env), projectPath, handlers);
+    }
+    continueDirectRun(hostId, sessionId, message, projectPath, handlers, launchContext, deliveryIntent) {
+        // R10: continueDirectRun is protected by the same per-hostId::sessionId
+        // serialization as continueRun (same map, same key shape).
+        return this.guardedContinue(hostId, sessionId, { projectPath, message, handlers, launchContext, deliveryIntent, direct: true });
+    }
+    // Issue #1176 (R34/R35/AC22): 1-based position the NEXT continuation would
+    // take if queued right now, or null if it would spawn immediately.
+    getQueuePosition(hostId, sessionId) {
+        const active = this.activeContinueRuns.get(`${hostId}::${sessionId}`);
+        if (!active)
+            return null;
+        return active.pending.length + 1;
     }
-    continueDirectRun(hostId, sessionId, message, projectPath, handlers, launchContext) {
-        return spawnHostProcess(hostId, (0, configured_agents_1.decorateHostPlanWithConfiguredAgent)(buildDirectContinuePlan(hostId, sessionId, message), launchContext?.agent, launchContext?.env), projectPath, handlers);
+    guardedContinue(hostId, sessionId, entry) {
+        const key = `${hostId}::${sessionId}`;
+        const active = this.activeContinueRuns.get(key);
+        if (!active) {
+            return this.spawnAndRegister(key, hostId, sessionId, entry);
+        }
+        // R3/R31: an ordinary follow-up queues behind existing work; a course
+        // correction (deliveryIntent 'stop') jumps to the front of the queue and
+        // stops the active child so the correction is what runs next.
+        if (entry.deliveryIntent === 'stop') {
+            active.pending.unshift(entry);
+            if (active.child.pid != null) {
+                try {
+                    this.killTree(active.child.pid, 'SIGTERM');
+                }
+                catch {
+                    // Best-effort: `close` still fires on normal process exit either way.
+                }
+            }
+        }
+        else {
+            active.pending.push(entry);
+        }
+        // R17: the caller receives the ALREADY-active child, not a process of its
+        // own — callers must not treat this return value as proof the queued
+        // message has its own process; event routing for the queued message goes
+        // through `entry.handlers` once it is actually dequeued and spawned.
+        return active.child;
+    }
+    spawnAndRegister(key, hostId, sessionId, entry) {
+        const plan = (0, configured_agents_1.decorateHostPlanWithConfiguredAgent)(entry.direct ? buildDirectContinuePlan(hostId, sessionId, entry.message) : buildContinuePlan(hostId, sessionId, entry.message), entry.launchContext?.agent, entry.launchContext?.env);
+        const child = this.spawn(hostId, plan, entry.projectPath, entry.handlers);
+        const runEntry = { child, pending: [] };
+        this.activeContinueRuns.set(key, runEntry);
+        child.once('close', () => this.dequeueNext(key, hostId, sessionId, runEntry));
+        return child;
+    }
+    // R4-R6, R9, R16 (batch-delivery per issue #1176 Round 2 design feedback):
+    // when the active child closes, drain every pending continuation at once
+    // (FIFO), join their messages into a single combined turn, and spawn exactly
+    // one continuation for the whole batch. A course-correction entry (if any)
+    // leads the combined message (R31); any "after" messages queued before or
+    // during the redirect follow it, preserved rather than discarded (R32). The
+    // batch uses the LAST entry's projectPath/handlers/launchContext unless a
+    // 'stop' entry is present, in which case that correction's context wins —
+    // it is the manager's most recent, most urgent instruction.
+    dequeueNext(key, hostId, sessionId, runEntry) {
+        this.activeContinueRuns.delete(key);
+        const batch = runEntry.pending.splice(0);
+        if (!batch.length)
+            return;
+        const combinedMessage = batch.map((e) => e.message).join('\n\n');
+        const primary = batch.find((e) => e.deliveryIntent === 'stop') ?? batch[batch.length - 1];
+        try {
+            this.guardedContinue(hostId, sessionId, { ...primary, message: combinedMessage });
+        }
+        catch {
+            // R19: a synchronous spawn failure must not leave the queue permanently
+            // stuck behind this key — clear it so the next continueRun call spawns
+            // fresh instead of queueing behind a dead entry.
+            this.activeContinueRuns.delete(key);
+        }
     }
 }
 exports.CliHostRuntime = CliHostRuntime;
@@ -1801,11 +1966,11 @@ class FakeHostRuntime {
     constructor() {
         this.isTestDouble = true;
         this.employees = [
-            { id: 'codex', label: 'Codex', available: true, detail: 'Test double employee.', supportsRaw: true },
-            { id: 'claude', label: 'Claude Code', available: true, detail: 'Test double employee.', supportsRaw: true },
-            { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Test double employee.', supportsRaw: true },
-            { id: 'copilot', label: 'GitHub Copilot CLI', available: true, detail: 'Test double agent tool.', supportsRaw: true },
-            { id: 'antigravity', label: 'Antigravity CLI', available: true, detail: 'Test double agent tool.', supportsRaw: false },
+            { id: 'codex', label: 'Codex', available: true, detail: 'Test double employee.', supportsRaw: true, version: '1.0.0-test' },
+            { id: 'claude', label: 'Claude Code', available: true, detail: 'Test double employee.', supportsRaw: true, version: '1.0.0-test' },
+            { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Test double employee.', supportsRaw: true, version: '1.0.0-test' },
+            { id: 'copilot', label: 'GitHub Copilot CLI', available: true, detail: 'Test double agent tool.', supportsRaw: true, version: '1.0.0-test' },
+            { id: 'antigravity', label: 'Antigravity CLI', available: true, detail: 'Test double agent tool.', supportsRaw: false, version: '1.0.0-test' },
         ];
         // Remembered across turns like a resumed agent session: the job label from the
         // start turn. Issue #732 — a same-job continue no longer carries a /fraim <job>
@@ -1893,11 +2058,11 @@ class ScriptedHostRuntime {
     constructor() {
         this.isTestDouble = true;
         this.employees = [
-            { id: 'codex', label: 'Codex', available: true, detail: 'Scripted test double.', supportsRaw: true },
-            { id: 'claude', label: 'Claude Code', available: true, detail: 'Scripted test double.', supportsRaw: true },
-            { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Scripted test double.', supportsRaw: true },
-            { id: 'copilot', label: 'GitHub Copilot CLI', available: true, detail: 'Scripted test double.', supportsRaw: true },
-            { id: 'antigravity', label: 'Antigravity CLI', available: true, detail: 'Scripted test double.', supportsRaw: false },
+            { id: 'codex', label: 'Codex', available: true, detail: 'Scripted test double.', supportsRaw: true, version: '1.0.0-test' },
+            { id: 'claude', label: 'Claude Code', available: true, detail: 'Scripted test double.', supportsRaw: true, version: '1.0.0-test' },
+            { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Scripted test double.', supportsRaw: true, version: '1.0.0-test' },
+            { id: 'copilot', label: 'GitHub Copilot CLI', available: true, detail: 'Scripted test double.', supportsRaw: true, version: '1.0.0-test' },
+            { id: 'antigravity', label: 'Antigravity CLI', available: true, detail: 'Scripted test double.', supportsRaw: false, version: '1.0.0-test' },
         ];
         // Track each active run so the test can emit signals at it. The Hub
         // passes the run id as the requested start session id in test/demo paths;
@@ -2105,11 +2270,12 @@ class ScriptedHostRuntime {
     }
 }
 exports.ScriptedHostRuntime = ScriptedHostRuntime;
-const createHubMessage = (role, text) => ({
+const createHubMessage = (role, text, deliveryStatus) => ({
     id: (0, crypto_1.randomUUID)(),
     role,
     text,
     createdAt: new Date().toISOString(),
+    ...(deliveryStatus ? { deliveryStatus } : {}),
 });
 exports.createHubMessage = createHubMessage;
 const createHubEvent = (channel, text) => ({