@prohost/cli 0.3.0 → 0.4.1

package/dist/agent/run.js

@@ -26,8 +26,8 @@ import os from 'node:os';
 import { spawnSync } from 'node:child_process';
 import WebSocket from 'ws';
 import { completeRun, postReply } from './api.js';
-import { claudeCommand, isClaudeExec, looksLikeResumeFailure, readClaudeStream, writeMcpConfig, } from './claude.js';
-import { MCP_API_KEY_ENV_VAR, codexBinary, codexCommand, codexMcpInventoryFlag, codexProfileName, codexShellSyntax, disableEntriesThatLoad, extraMcpEntries, isCodexExec, listMcpServers, mcpServersOverride, prohostMcpEntry, looksLikeCodexResumeFailure, parseCodexOutput, } from './codex.js';
+import { MAX_SALVAGE_CHARS, claudeCommand, isClaudeExec, looksLikeResumeFailure, readClaudeStream, writeMcpConfig, } from './claude.js';
+import { MCP_API_KEY_ENV_VAR, PLUGINS_DISABLED_OVERRIDE, codexBinary, codexCommand, codexMcpInventoryFlag, codexProfileName, codexShellSyntax, extraMcpEntries, isCodexExec, isolateConfiguredServers, listMcpServers, mcpServersOverride, prohostMcpEntry, looksLikeCodexResumeFailure, parseCodexOutput, } from './codex.js';
 import { EXTRA_MCP_FILENAME, loadExtraMcpServers } from './extras.js';
 import { MCP_SERVER_NAME, MCP_TOOL_PATTERN } from './mcp.js';
 import { EVENT_AGENT_RUN_REQUESTED, EVENT_MENTION_CREATED, EVENT_MESSAGE_TEAM_CHAT, RUN_ERROR_CANCELLED_BY_USER, eventData, heartbeatPathFor, parseRunRequest, } from './contract.js';
@@ -41,18 +41,36 @@ import { verifySignature } from './signature.js';
 import { isWebhookEvent } from '../forward.js';
 import { DEFAULT_WS_URL } from '../listen.js';
 /**
- * Default ceiling on one agent invocation.
+ * Default ceiling on one agent invocation: none.
  *
- * Two hours, up from five minutes. Five was a guess made when a run meant
- * "answer a mention", and it was wrong in the expensive direction: a paired
- * brain given a real coding task in production was killed at 300s, mid-edit,
- * and reported `timed out after 300000ms` to the person waiting. A coding
- * agent's unit of work is not a chat reply, and no local clock can tell a
- * wedged run from a productive one — the server's lease can, which is what
- * heartbeats are for. This is now a backstop against a genuinely stuck process
- * rather than a shape imposed on the work; `--timeout 0` removes it entirely.
+ * The wall clock kept being raised — five minutes, then two hours — because it
+ * was answering the wrong question. "How long has this run been going?" does
+ * not distinguish a wedged child from a productive one; it only distinguishes
+ * long work from short, and killing long work is precisely the failure the two
+ * previous defaults each produced in production. What the harness can actually
+ * observe is whether the child is *doing* anything, which is what
+ * {@link DEFAULT_IDLE_TIMEOUT_MS} watches.
+ *
+ * So a run is now bounded by three things, none of them a fixed duration:
+ * the inactivity watchdog (default 15 minutes of total silence), the server's
+ * lease on the run (heartbeats stop, the row is reaped), and the Stop button in
+ * ProhostAI (which reaches this machine on the next heartbeat). `--timeout`
+ * remains fully supported for anyone who wants a hard ceiling as well.
+ */
+export const DEFAULT_EXEC_TIMEOUT_MS = 0;
+/**
+ * Default silence window before a run is treated as stalled.
+ *
+ * Fifteen minutes is chosen against what real work looks like, not against
+ * what feels responsive: an agent mid-task emits stream events, tool calls and
+ * log lines continuously, so the gaps in a healthy run are seconds. The long
+ * tail that legitimately goes quiet is a single slow tool call — a test suite,
+ * a build, a big fetch — and fifteen minutes clears those comfortably while
+ * still catching the failure this exists for, a child wedged on a stdin prompt
+ * that heartbeats look perfectly healthy for and that burns the operator's
+ * tokens and their agent's availability indefinitely.
  */
-export const DEFAULT_EXEC_TIMEOUT_MS = 7_200_000;
+export const DEFAULT_IDLE_TIMEOUT_MS = 900_000;
 /** Reconnect backoff — full jitter between ``BASE`` and the current cap. */
 const RECONNECT_BASE_DELAY_MS = 1_000;
 const RECONNECT_MAX_DELAY_MS = 30_000;
@@ -311,19 +329,28 @@ function codexMcpEntries(options, extraServers, log, workdir) {
     if (acceptedExtraEntries.length === 0)
         acceptedExtraNames.clear();
     const targets = [...configuredNames].filter((name) => !acceptedExtraNames.has(name));
-    const { entries: disabled, failed } = disableEntriesThatLoad(binary, probe, targets, workdir);
+    const { entries: disabled, configOverrides, failed } = isolateConfiguredServers(binary, probe, targets, workdir);
     if (failed.length > 0) {
-        return fail(`these Codex MCP servers could not be disabled: ${failed.join(', ')}`);
+        // The remedy belongs in the message. This string is echoed into the thread
+        // the teammate is waiting in, and "could not be disabled" on its own leaves
+        // them with a run that will not start and nothing to do about it.
+        return fail(`these Codex MCP servers could not be disabled: ${failed.join(', ')} — remove them from ` +
+            '~/.codex/config.toml, or run the daemon with a dedicated CODEX_HOME containing only auth.json');
     }
     entries.push(...disabled);
-    if (disabled.length > 0) {
+    if (targets.length > 0) {
         log(`${timestamp()} ⚙ your own Codex MCP servers are disabled for agent runs: ${targets.join(', ')}`);
     }
+    if (configOverrides.includes(PLUGINS_DISABLED_OVERRIDE)) {
+        log(`${timestamp()} ⚙ Codex plugins are switched off for agent runs — a plugin supplies an MCP ` +
+            'server that cannot be disabled on its own');
+    }
     // Verify the exact combined override, not its pieces. This catches a config
     // merge that re-enables a server and a server installed between the initial
     // survey and this final probe.
     const override = mcpServersOverride(entries);
-    const finalListing = listMcpServers(binary, probe, override, workdir);
+    const runOverrides = [...configOverrides, ...(override ? [override] : [])];
+    const finalListing = listMcpServers(binary, probe, runOverrides, workdir);
     if (finalListing === null)
         return fail('Codex rejected the final isolated MCP configuration');
     const allowed = new Set([
@@ -341,6 +368,7 @@ function codexMcpEntries(options, extraServers, log, workdir) {
     }
     return {
         codexMcpEntries: entries,
+        codexConfigOverrides: configOverrides.length > 0 ? configOverrides : undefined,
         execEnv: Object.keys(execEnv).length > 0 ? execEnv : undefined,
         mcpWired: Boolean(options.credentials.mcp_url),
     };
@@ -365,6 +393,25 @@ function defaultProbe(command, cwd) {
     });
     return { status: result.status, stdout: result.stdout ?? '' };
 }
+/**
+ * What a killed plain command salvages: the last thing it printed.
+ *
+ * The streaming reader salvages the last thing the *agent* said, having parsed
+ * it out of the event stream. There is no parsing to do for a plain `--exec`
+ * command — its stdout is its reply — so its rolling tail is the same evidence
+ * reached the other way: what the run had produced before it stopped producing
+ * anything.
+ *
+ * Bounded to the same {@link MAX_SALVAGE_CHARS} for the same reason: the
+ * completion `error` this ends up in is capped server-side, and it has a stderr
+ * tail to carry as well.
+ */
+function partialStdout(tail) {
+    const text = tail.trim();
+    if (!text)
+        return undefined;
+    return text.length > MAX_SALVAGE_CHARS ? text.slice(-MAX_SALVAGE_CHARS) : text;
+}
 /**
  * Run the agent command once and turn its output into a reply.
  *
@@ -380,10 +427,14 @@ async function runTurn(run, prompt, options, runtime, mcp, control, log) {
     // share one deadline, which costs the retry nothing in practice — a rejected
     // `--resume` fails in milliseconds, long before any of the budget is spent.
     const budgetMs = options.timeoutMs ?? DEFAULT_EXEC_TIMEOUT_MS;
-    // `--timeout 0`: no local ceiling at all. The run then ends when the agent
-    // ends it, when somebody cancels it, or when the server stops renewing its
-    // lease — all of which are better judges of "stuck" than a fixed clock.
+    // `--timeout 0`, and the default: no wall-clock ceiling at all. The run then
+    // ends when the agent ends it, when the watchdog below finds it silent, when
+    // somebody cancels it, or when the server stops renewing its lease — all of
+    // which are better judges of "stuck" than a fixed clock.
     const capped = budgetMs > 0;
+    // Not shared between attempts the way the wall clock is: the watchdog bounds
+    // silence, and a fresh attempt starts a fresh silence.
+    const idleMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
     const startedAt = Date.now();
     const remainingMs = () => budgetMs - (Date.now() - startedAt);
     const timeLeft = () => !capped || remainingMs() > 0;
@@ -398,6 +449,16 @@ async function runTurn(run, prompt, options, runtime, mcp, control, log) {
     let recordedSession;
     /** The reader for the attempt currently running, if this brain streams. */
     let stream;
+    /**
+     * Rolling tail of a plain command's stdout — the last thing it printed.
+     *
+     * Kept as the output arrives rather than sliced off the captured `stdout` at
+     * the end, because capture is bounded at {@link MAX_OUTPUT_CHARS} from the
+     * *front*: a chatty command that overran that and then stalled would
+     * otherwise salvage half a megabyte of stale opening output and call it the
+     * unfinished answer.
+     */
+    let tail = '';
     /**
      * Act on what the stream has said so far.
      *
@@ -438,10 +499,12 @@ async function runTurn(run, prompt, options, runtime, mcp, control, log) {
         // session, and inheriting the failed attempt's id would resume nothing.
         const reader = runtime.brain === 'claude' ? readClaudeStream() : undefined;
         stream = reader;
+        tail = '';
         return execAgent({
             command,
             prompt,
             timeoutMs: capped ? Math.max(1, remainingMs()) : 0,
+            idleTimeoutMs: idleMs,
             cwd: runtime.workdir,
             env: mcp.execEnv,
             spawnImpl: options.spawnImpl,
@@ -451,7 +514,11 @@ async function runTurn(run, prompt, options, runtime, mcp, control, log) {
                     reader.push(chunk);
                     observe(reader);
                 }
-                : undefined,
+                : runtime.brain === 'plain'
+                    ? (chunk) => {
+                        tail = (tail + chunk).slice(-MAX_SALVAGE_CHARS);
+                    }
+                    : undefined,
         });
     };
     // Wall clock for the whole turn, retry included — what the operator waited,
@@ -462,10 +529,28 @@ async function runTurn(run, prompt, options, runtime, mcp, control, log) {
     }
     const failure = (result) => {
         // A killed run has no reply, but it usually has most of one. Reporting the
-        // tail of what the agent was writing turns "timed out after 7200000ms" into
+        // tail of what the agent was writing turns "no output for 15 minutes" into
         // something the person waiting can act on — and it is the only trace left
-        // of however many hours of work.
-        const salvaged = result.timedOut || result.cancelled ? stream?.salvage() : undefined;
+        // of however many hours of work. A stalled run is the case this matters
+        // most for: the last thing it said is the best clue to what it stalled on.
+        // A plain command has no stream to salvage a parsed answer from, but its
+        // stdout *is* its answer by contract — so the tail of what it managed to
+        // print is the same evidence, reached the other way. Without this a stalled
+        // plain run reports nothing but the fact that it stalled.
+        //
+        // Deliberately NOT extended to the shaped brains. Both are run with
+        // structured output (`--output-format stream-json`, `--json`), whose
+        // stream carries the agent's reasoning and the raw output of every local
+        // command and tool call it made — which `readClaudeStream`/
+        // `parseCodexOutput` exist to filter out. This string is persisted in the
+        // completion and echoed into a workspace thread, so tailing that stream
+        // raw would publish local shell output, and whatever was in it, to
+        // everyone who can read the conversation. A shaped brain whose parser
+        // salvaged nothing salvages nothing.
+        const killed = result.timedOut || result.idleTimedOut || result.cancelled;
+        const salvaged = killed
+            ? (stream?.salvage() ?? (runtime.brain === 'plain' ? partialStdout(tail) : undefined))
+            : undefined;
         // The stderr tail yields room when there is a salvaged answer to carry: the
         // completion `error` is capped server-side, and of the two, what the agent
         // was saying beats the last 500 characters of its logging.
@@ -498,6 +583,7 @@ async function runTurn(run, prompt, options, runtime, mcp, control, log) {
         ? codexCommand(options.exec, {
             sessionId: resume,
             mcpEntries: mcp.codexMcpEntries,
+            configOverrides: mcp.codexConfigOverrides,
             skipPermissions: runtime.skipPermissions,
         })
         : claudeCommand(options.exec, {
@@ -525,7 +611,11 @@ async function runTurn(run, prompt, options, runtime, mcp, control, log) {
         result = await exec(build());
     }
     if (!result.ok) {
-        if (!result.timedOut && !result.cancelled)
+        // A run we killed keeps its session, whichever clock killed it: the
+        // transcript is real, it holds however long the agent worked, and the next
+        // delivery on that surface can resume it. Only a turn that failed on its
+        // own — a crash, an unparseable answer — has no continuity worth keeping.
+        if (!result.timedOut && !result.idleTimedOut && !result.cancelled)
             forgetRecordedSession();
         return failure(result);
     }
@@ -598,8 +688,9 @@ async function handleRun(run, options, runtime, api, log, sleep, control) {
         // it is. See PromptContext.mcpToolPattern.
         mcpToolPattern: runtime.brain !== 'plain' && mcp.mcpWired ? MCP_TOOL_PATTERN : undefined,
         toolsGated: !runtime.skipPermissions,
-        // The real number, not a vague "there is a limit" — see PromptContext.
+        // The real numbers, not a vague "there is a limit" — see PromptContext.
         timeoutMs: options.timeoutMs ?? DEFAULT_EXEC_TIMEOUT_MS,
+        idleTimeoutMs: options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS,
     });
     const result = await runTurn(run, prompt, options, runtime, mcp, control, log);
     const seconds = (result.durationMs / 1000).toFixed(1);

package/dist/index.js

@@ -25,7 +25,7 @@ function printHelp() {
         'Usage:',
         '  prohost listen --forward-to <local-url> [--api-key <key>] [--url <ws-url>] [--machine <name>] [--subscription-id <id>]',
         '  prohost agent pair --code <pairing-code> [--webhook-url <https-url>] [--base-url <url>]',
-        "  prohost agent run --exec '<command>' [--timeout <seconds>] [--dry-run] [--workdir <dir>]",
+        "  prohost agent run --exec '<command>' [--idle-timeout <seconds>] [--timeout <seconds>] [--dry-run] [--workdir <dir>]",
         "  prohost agent install-daemon --exec '<command>' [--workdir <dir>]   Keep the agent running",
         '  prohost agent uninstall-daemon',
         '',
@@ -43,9 +43,12 @@ function printHelp() {
         '',
         'agent run flags:',
         '  --exec           Command to run for each mention; the prompt arrives on stdin (required)',
-        '  --timeout        Seconds one run may take before it is killed. Defaults to 7200 (2 hours).',
-        '                   Pass 0 for no local limit — the run then ends when the agent finishes,',
-        '                   when someone cancels it in ProhostAI, or when the server reaps it.',
+        '  --idle-timeout   Seconds a run may produce NO output at all before it is treated as',
+        '                   stalled and killed. Defaults to 900 (15 minutes). Any byte on stdout or',
+        '                   stderr resets it, so a working agent never trips it. Pass 0 to disable.',
+        '  --timeout        Seconds one run may take before it is killed, however busy it is.',
+        '                   Defaults to 0 — no wall-clock limit, because a long run is not a stuck',
+        '                   one. Set it if you want a hard ceiling as well as the stall watchdog.',
         '  --dry-run        Print the reply that would be posted; write nothing.',
         '  --workdir        Working directory for the agent command. Defaults to $PROHOST_HOME/workspace.',
         '                   Avoid pointing it at a code checkout: agents read CLAUDE.md, .claude/settings.json',
@@ -71,7 +74,8 @@ function printHelp() {
         '',
         'agent install-daemon flags:  (macOS: launchd; Linux: prints a systemd-user unit)',
         '  --exec           The same command you would pass to `agent run` (required).',
-        '  --workdir, --timeout, --machine, --url, --allow-unverified, --safe-tools — passed to `agent run`.',
+        '  --workdir, --idle-timeout, --timeout, --machine, --url, --allow-unverified, --safe-tools',
+        '                   — passed to `agent run`.',
         '',
         'Global flags:',
         '  --help, -h       Show this help and exit.',

package/dist/version.d.ts

@@ -7,6 +7,6 @@
  * `package.json`, so a release bump that forgets this file fails the suite
  * instead of shipping a `User-Agent` that lies about which build is calling.
  */
-export declare const CLI_VERSION = "0.3.0";
+export declare const CLI_VERSION = "0.4.1";
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
-export declare const USER_AGENT = "prohost-cli/0.3.0";
+export declare const USER_AGENT = "prohost-cli/0.4.1";

package/dist/version.js

@@ -7,6 +7,6 @@
  * `package.json`, so a release bump that forgets this file fails the suite
  * instead of shipping a `User-Agent` that lies about which build is calling.
  */
-export const CLI_VERSION = '0.3.0';
+export const CLI_VERSION = '0.4.1';
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
 export const USER_AGENT = `prohost-cli/${CLI_VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prohost/cli",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Run your own AI agent as a ProhostAI teammate, and stream your account's webhooks to your laptop.",
   "type": "module",
   "license": "MIT",