@proagentstore/cli 0.4.66 → 0.4.68

package/dist/browser-runner/coding/engine-acts.js

@@ -34,6 +34,7 @@
  * A raw engine emits nothing parseable, so an empty act list means "nothing observed", never
  * "nothing happened", and every consumer has to say so rather than render it as an all-clear.
  */
+import { splitHeredocs } from "./heredoc.js";
 /** Acts whose consequences reach outside the machine, or cannot be walked back locally. */
 const IRREVERSIBLE = new Set([
     "pr.merge",
@@ -77,10 +78,15 @@ export function redactCommand(command) {
  * Over-splitting costs nothing (a fragment simply matches no rule); under-splitting loses an act,
  * and the real-world shape of the case this exists for is exactly a compound line:
  * `cd repo && git push -u origin fix && gh pr create --fill && gh pr merge --squash`.
+ *
+ * Heredoc BODIES are removed first (#873): they are data — a commit message, a comment body, a
+ * script editing a test file — and their lines, split as commands, recorded pushes, merges and a
+ * repository deletion that never ran. This side sees the whole command, so a real command after
+ * the terminator is still read.
  */
 export function splitSegments(command) {
-    return String(command ?? "")
-        .split(/\|\||&&|[;|\n]/)
+    return splitHeredocs(String(command ?? ""))
+        .executed.split(/\|\||&&|[;|\n]/)
         .map((s) => s.trim())
         .filter(Boolean);
 }
@@ -265,7 +271,9 @@ export function classifySegment(segment) {
  * was on that line.
  */
 export function classifyCommand(id, command, at = new Date().toISOString()) {
-    const full = redactCommand(command);
+    // The evidence keeps what was executed and collapses each heredoc body to one line (#873), so
+    // the 400-character cap is not spent on a commit message while the push after it is cut off.
+    const full = redactCommand(splitHeredocs(command).elided);
     if (!full)
         return [];
     const out = [];

package/dist/browser-runner/coding/engine-adapter.js

@@ -156,9 +156,23 @@ function parseCodexLine(line) {
     if (type === "thread.started" && typeof ev.thread_id === "string" && ev.thread_id)
         return [{ kind: "session", sessionId: ev.thread_id }];
     if (type === "turn.completed" || type === "turn.failed") {
-        const result = typeof ev.error === "string" ? ev.error : typeof ev.message === "string" ? ev.message : type === "turn.failed" ? "failed" : "";
+        // Codex sends `error` as an OBJECT — `{"type":"turn.failed","error":{"message":"…401…"}}` — and
+        // reading only the string form reduced a 401 to the word "failed" (#889).
+        const result = typeof ev.error === "string"
+            ? ev.error
+            : typeof record(ev.error)?.message === "string"
+                ? record(ev.error)?.message
+                : typeof ev.message === "string"
+                    ? ev.message
+                    : type === "turn.failed"
+                        ? "failed"
+                        : "";
         return [{ kind: "turn_end", raw: ev, isError: type === "turn.failed", result }];
     }
+    if (type === "error") {
+        const text = typeof ev.message === "string" ? ev.message : typeof record(ev.error)?.message === "string" ? record(ev.error)?.message : "";
+        return text.trim() ? [{ kind: "engine_error", text: text.trim() }] : [];
+    }
     if (!item)
         return [];
     const itemType = typeof item.type === "string" ? item.type : "";

package/dist/browser-runner/coding/engine-check.js

@@ -0,0 +1,114 @@
+import { spawnSync } from "node:child_process";
+import { accessSync, constants, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, isAbsolute, join, resolve } from "node:path";
+import { handlerFor } from "./handlers.js";
+import { parseCommand } from "./headless.js";
+function defaultIsExecutable(p) {
+    try {
+        if (!statSync(p).isFile())
+            return false;
+        accessSync(p, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function defaultExists(p) {
+    try {
+        statSync(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function defaultKeychainItemStatus(service) {
+    // Existence only: without `-w`/`-g` the secret is never read, so this cannot prompt or leak.
+    const r = spawnSync("security", ["find-generic-password", "-s", service], { stdio: "ignore", timeout: 5_000 });
+    return r.error ? null : r.status;
+}
+/** The same resolution `spawn(bin)` does: a path is taken as-is, a bare name is searched on PATH. */
+export function resolveBinary(bin, deps = {}) {
+    const isExec = deps.isExecutable ?? defaultIsExecutable;
+    if (!bin)
+        return null;
+    if (bin.includes("/") || isAbsolute(bin)) {
+        const p = resolve(bin);
+        return isExec(p) ? p : null;
+    }
+    const env = deps.env ?? process.env;
+    const exts = (deps.platform ?? process.platform) === "win32" ? (env.PATHEXT || ".EXE;.CMD;.BAT").split(";") : [""];
+    for (const dir of (env.PATH || "").split(delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            const p = join(dir, bin + ext);
+            if (isExec(p))
+                return p;
+        }
+    }
+    return null;
+}
+/** Does this engine have a stored interactive login on the machine? */
+export function detectEngineLogin(engine, deps = {}) {
+    const env = deps.env ?? process.env;
+    const home = deps.home ?? homedir();
+    const exists = deps.exists ?? defaultExists;
+    const platform = deps.platform ?? process.platform;
+    if (engine === "codex") {
+        // `codex login` (ChatGPT subscription) writes auth.json under CODEX_HOME, default ~/.codex.
+        const dir = env.CODEX_HOME?.trim() || join(home, ".codex");
+        const file = join(dir, "auth.json");
+        return { login: exists(file) ? "found" : "missing", where: file };
+    }
+    if (engine === "claude") {
+        // An exported subscription token is a login the engine can read in `machine` mode.
+        if (env.CLAUDE_CODE_OAUTH_TOKEN?.trim())
+            return { login: "found", where: "CLAUDE_CODE_OAUTH_TOKEN" };
+        const dir = env.CLAUDE_CONFIG_DIR?.trim() || join(home, ".claude");
+        const file = join(dir, ".credentials.json");
+        if (exists(file))
+            return { login: "found", where: file };
+        if (platform === "darwin") {
+            // Claude Code keeps its macOS login in the keychain. 0 = the item exists, 44 = it does
+            // not; anything else (a locked keychain, no `security`) is not an answer.
+            const status = (deps.keychainItemStatus ?? defaultKeychainItemStatus)("Claude Code-credentials");
+            if (status === 0)
+                return { login: "found", where: "keychain" };
+            if (status === 44)
+                return { login: "missing", where: `keychain / ${file}` };
+            return { login: "unknown" };
+        }
+        return { login: "missing", where: file };
+    }
+    if (engine === "gemini") {
+        // Google sign-in lands here; Gemini also accepts other auth (gcloud, Vertex), so absence is
+        // not proof of "signed out".
+        const file = join(home, ".gemini", "oauth_creds.json");
+        return exists(file) ? { login: "found", where: file } : { login: "unknown" };
+    }
+    return { login: "unknown" };
+}
+/**
+ * The whole answer. `credentialInjected` is the cloud saying it will hand this spawn a credential
+ * of its own (a platform-stored subscription token), in which case the machine's login is not what
+ * the engine reads and is not checked.
+ */
+export function checkEngine(input, deps = {}) {
+    const engine = (["claude", "gemini", "codex", "grok", "generic"].includes(input.clientType ?? "") ? input.clientType : "claude");
+    const parsed = parseCommand(input.command);
+    const bin = parsed.bin || parseCommand(handlerFor(engine).cliCommand).bin || engine;
+    const binaryPath = resolveBinary(bin, deps);
+    const login = input.credentialInjected ? { login: "found", where: "platform" } : detectEngineLogin(engine, deps);
+    return {
+        checked: true,
+        engine,
+        bin,
+        binaryFound: binaryPath !== null,
+        ...(binaryPath ? { binaryPath } : {}),
+        login: login.login,
+        ...(login.where ? { loginWhere: login.where } : {}),
+    };
+}

package/dist/browser-runner/coding/engine-turn.js

@@ -19,6 +19,28 @@
  */
 /** Longest engine line carried as {@link EngineTurnReport.detail}. The pane holds the rest. */
 export const MAX_TURN_DETAIL = 240;
+/**
+ * How much of a turn's own output rides on its report as {@link EngineTurnReport.tail} (#889).
+ *
+ * The last LINES, because the actionable part of a failure is at the end — Codex retried a 401 five
+ * times and then said so in `turn.failed`. Bounded three ways (lines, per-line, total) because the
+ * report is re-sent on every snapshot and a runaway line must not grow it.
+ */
+export const MAX_TURN_TAIL_LINES = 60;
+export const MAX_TURN_TAIL_LINE = 400;
+export const MAX_TURN_TAIL_CHARS = 8000;
+/** Append one line of the turn's own output to its tail, keeping the newest within the bounds above. */
+export function appendTurnTail(tail, line) {
+    const text = line.trim();
+    if (!text)
+        return;
+    tail.push(text.length > MAX_TURN_TAIL_LINE ? `${text.slice(0, MAX_TURN_TAIL_LINE)}…` : text);
+    while (tail.length > MAX_TURN_TAIL_LINES)
+        tail.shift();
+    let total = tail.reduce((n, l) => n + l.length + 1, 0);
+    while (total > MAX_TURN_TAIL_CHARS && tail.length > 1)
+        total -= tail.shift().length + 1;
+}
 /**
  * A one-shot turn's process has exited — say what that means, and nothing more.
  *
@@ -26,14 +48,16 @@ export const MAX_TURN_DETAIL = 240;
  * 15-minute wedge ceiling and `interrupt()` both land here, and counting either as an engine
  * failure would let three slow builds read as a broken CLI.
  */
-export function turnReportFromExit(code, signal, lastLine = "", now = Date.now()) {
-    const detail = lastLine.trim().slice(0, MAX_TURN_DETAIL);
+export function turnReportFromExit(code, signal, lastLine = "", now = Date.now(), tail = []) {
+    const detail = (lastLine.trim() || tail.at(-1) || "").slice(0, MAX_TURN_DETAIL);
+    const verdict = signal !== null ? "killed" : code === 0 ? "ok" : "failed";
     return {
-        verdict: signal !== null ? "killed" : code === 0 ? "ok" : "failed",
+        verdict,
         exitCode: code,
         signal,
         at: now,
         ...(detail ? { detail } : {}),
+        ...(verdict === "failed" ? { tail: [...tail] } : {}),
     };
 }
 /**
@@ -43,7 +67,7 @@ export function turnReportFromExit(code, signal, lastLine = "", now = Date.now()
  * the shape of gap that makes a platform-wide claim ("we notice a failed turn") false in the one
  * case that runs most.
  */
-export function turnReportFromResult(isError, detail = "", now = Date.now()) {
+export function turnReportFromResult(isError, detail = "", now = Date.now(), tail = []) {
     const text = detail.trim().slice(0, MAX_TURN_DETAIL);
     return {
         verdict: isError ? "failed" : "ok",
@@ -51,5 +75,6 @@ export function turnReportFromResult(isError, detail = "", now = Date.now()) {
         signal: null,
         at: now,
         ...(text ? { detail: text } : {}),
+        ...(isError ? { tail: [...tail] } : {}),
     };
 }

package/dist/browser-runner/coding/headless.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { classifyCommand, commandFromToolInput, fillTargetFromResult, toolCallOk, toolResultMark } from "./engine-acts.js";
 import { parseEngineUsage } from "./engine-usage.js";
-import { turnReportFromExit, turnReportFromResult } from "./engine-turn.js";
+import { appendTurnTail, turnReportFromExit, turnReportFromResult } from "./engine-turn.js";
 import { renderToolResult, shortInput, stripAnsi } from "./transcript-lines.js";
 import { authoredTurn, authorTag } from "./turn-author.js";
 import { engineSpawnEnv, mergeEnv } from "./engine-env.js";
@@ -98,6 +98,8 @@ export class HeadlessSession {
      * carry a previous turn's line.
      */
     turnLastLine = "";
+    /** This turn's own output, newest last and bounded — reported on a failed turn (#889). */
+    turnTail = [];
     /** True once this session has retried an old Codex CLI without its unsupported `--json` flag. */
     fellBackToRaw = false;
     /** Structured events observed in the current one-shot process. */
@@ -408,8 +410,11 @@ export class HeadlessSession {
             this.lastOutputAt = Date.now();
             this.sawOutputSinceInput = true;
             const text = d.toString("utf8").trim();
-            if (text)
+            if (text) {
                 this.push(`[${this.binName}] ${stripAnsi(text)}`);
+                for (const l of stripAnsi(text).split("\n"))
+                    appendTurnTail(this.turnTail, l);
+            }
         });
         proc.on("exit", (code) => {
             // A stop() + re-start() on the SAME session object can leave this old process's
@@ -471,6 +476,7 @@ export class HeadlessSession {
         this.lastOutputAt = now;
         this.turnStartedAt = now;
         this.sawOutputSinceInput = false; // arm the persistent-raw idle heuristic for THIS turn
+        this.turnTail = []; // a one-shot turn re-arms it at its spawn too (a --json fallback re-runs the turn)
         try {
             // Brief first, instruction second, and never the other way round: it is background for
             // the request, and an engine that reads the request last acts on the request.
@@ -510,6 +516,7 @@ export class HeadlessSession {
         // Arm the per-turn line capture BEFORE the spawn, so a report can only ever carry a line
         // this turn produced (#545).
         this.turnLastLine = "";
+        this.turnTail = [];
         this.sawStructuredEvent = false;
         this.structuredOutputRejected = false;
         const resumedCodexThreadId = this.codexResumeThreadId;
@@ -546,6 +553,7 @@ export class HeadlessSession {
             if (this.proc !== proc)
                 return; // stale: a newer turn owns the session now
             this.push(`[${this.config.clientType}] failed to start: ${err.message}`);
+            appendTurnTail(this.turnTail, `failed to start: ${err.message}`);
             this.run = "idle";
             this.proc = null;
             // The command itself is unrunnable — report the session dead so the loop stops with a
@@ -610,7 +618,7 @@ export class HeadlessSession {
             //
             // A signal means WE ended it (the wedge ceiling, an interrupt), which is the `killed`
             // verdict: evidence about this platform's timers, not about the engine's health.
-            this.turnReport = turnReportFromExit(code, signal, this.turnLastLine);
+            this.turnReport = turnReportFromExit(code, signal, this.turnLastLine, Date.now(), this.turnTail);
             this.run = "idle";
             this.proc = null;
         });
@@ -664,8 +672,11 @@ export class HeadlessSession {
             if (this.mode === "stream-json") {
                 if (this.handle(line))
                     this.sawStructuredEvent = true;
-                else if (this.adapter.rejectsStructuredOutput?.(line))
-                    this.structuredOutputRejected = true;
+                else {
+                    if (this.adapter.rejectsStructuredOutput?.(line))
+                        this.structuredOutputRejected = true;
+                    this.pushUnframed(line);
+                }
             }
             else
                 this.pushRaw(line); // raw engine — the line IS the terminal output
@@ -687,11 +698,34 @@ export class HeadlessSession {
     get codexResumeThreadId() {
         return this.config.clientType === "codex" && this.mode === "stream-json" && isCodexThreadId(this.codexThreadId) ? this.codexThreadId : null;
     }
+    /**
+     * A line a STRUCTURED engine printed outside its protocol — not JSON at all (#889).
+     *
+     * A one-shot turn's stderr shares this stream, and it is where the diagnosis lives: Codex logged
+     * `ERROR codex_api…: 401 Unauthorized` there on every retry. It was dropped, which is how a turn
+     * that failed for a stated reason reached the pane and the report as no output at all. JSON this
+     * build does not recognise is still skipped — that is protocol noise, not the engine talking.
+     */
+    pushUnframed(line) {
+        try {
+            JSON.parse(line);
+            return;
+        }
+        catch {
+            /* not JSON — the engine's own words */
+        }
+        const clean = stripAnsi(line).trim();
+        if (!clean)
+            return;
+        this.push(`[${this.binName}] ${clean}`);
+        appendTurnTail(this.turnTail, clean);
+    }
     /** Raw-engine stdout: strip ANSI control codes and append to the transcript. */
     pushRaw(line) {
         const clean = stripAnsi(line);
         if (clean.trim()) {
             this.push(clean);
+            appendTurnTail(this.turnTail, clean);
             // The engine's own words, kept for the turn's report (#545) — captured on the way in,
             // never scraped back out of the rendered pane.
             this.turnLastLine = clean.trim();
@@ -734,15 +768,21 @@ export class HeadlessSession {
                     this.settleAct(ev.block);
                     break;
                 }
+                case "engine_error":
+                    this.push(`[${this.binName}] error: ${ev.text}`);
+                    appendTurnTail(this.turnTail, `error: ${ev.text}`);
+                    break;
                 case "turn_end": {
                     const failure = ev.isError ? ev.result : "";
-                    if (failure)
+                    if (failure) {
                         this.push(`[error] ${failure}`);
+                        appendTurnTail(this.turnTail, `[error] ${failure}`);
+                    }
                     // The structured path's ANALOGUE of a non-zero exit (#545). Claude has no process
                     // per turn, so `exitCode` is honestly null and the verdict comes from the protocol's
                     // own `is_error` — the same claim, in the words the engine states it in. Without
                     // this the field would exist for three engines and silently not for the flagship.
-                    this.turnReport = turnReportFromResult(ev.isError, failure);
+                    this.turnReport = turnReportFromResult(ev.isError, failure, Date.now(), this.turnTail);
                     // The same event that ends the turn also reports what the turn COST (#267). It was
                     // parsed and thrown away, which is why Engine spend was absent from the ledger.
                     // An errored turn still burned tokens, so this is recorded regardless of is_error.

package/dist/browser-runner/coding/heredoc.js

@@ -0,0 +1,103 @@
+/**
+ * Separate a shell command's heredoc BODIES from the text that is executed (#873).
+ *
+ * The act record carries the whole command line, and a heredoc body is data: a commit message, an
+ * issue-comment body, a Python script editing a test file. Read as commands, their lines produced
+ * acts that never happened ("merged a pull request #3" from a string inside a Python heredoc) and
+ * repository targets nobody wrote to (#872, `mcp/apps` from a comment body).
+ *
+ * VENDORED: `workers/api/src/lib/heredoc.ts` is the original; this is a copy, because a Worker must not
+ * import the runner package. `workers/api/src/lib/heredoc.test.ts` runs the same cases through both.
+ *
+ * The rules, and the one place this is stricter than "strip from `<<` to the terminator":
+ *  - `<<WORD`, `<<'WORD'`, `<<"WORD"`, `<<\WORD` and `<<-WORD` open a heredoc. `<<<` is a
+ *    here-string, not a heredoc. Several operators on one line are read in order, as the shell does.
+ *  - An operator only counts outside quotes, except inside a `$( … )` substitution, which is how
+ *    `git commit -m "$(cat <<'EOF'` is written — a `<<` inside `"a << b"` is not one.
+ *  - The body is the lines AFTER the operator's line, up to a line that is exactly the delimiter
+ *    (leading tabs allowed for `<<-`). The terminator line is dropped too.
+ *  - The REST OF THE OPERATOR'S LINE is executed and kept: `git commit -F - <<'EOF' && git push`
+ *    pushes, and dropping it would hide a real act.
+ *  - No terminator — the stored command is cut at 400 characters — makes everything after the
+ *    operator's line body. A heredoc that never closed cannot have run anything after it that
+ *    this text shows.
+ */
+/** A delimiter, read at the position just after `<<`. */
+const DELIMITER = /(-?)[ \t]*(?:'([^'\n]*)'|"([^"\n]*)"|\\?([A-Za-z_][A-Za-z0-9_]*))/y;
+/** The heredoc operators on one executed line, in order, respecting quotes and `$( … )`. */
+function operatorsOn(line) {
+    const out = [];
+    // A stack of contexts: "sh" (unquoted, including inside `$( … )`), "dq" and "sq".
+    const stack = ["sh"];
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        const top = stack[stack.length - 1];
+        if (top === "sq") {
+            if (ch === "'")
+                stack.pop();
+            continue;
+        }
+        if (ch === "\\") {
+            i++;
+            continue;
+        }
+        if (ch === "$" && line[i + 1] === "(") {
+            stack.push("sh");
+            i++;
+            continue;
+        }
+        if (top === "dq") {
+            if (ch === '"')
+                stack.pop();
+            continue;
+        }
+        if (ch === "'")
+            stack.push("sq");
+        else if (ch === '"')
+            stack.push("dq");
+        else if (ch === ")" && stack.length > 1)
+            stack.pop();
+        else if (ch === "#" && (i === 0 || /\s/.test(line[i - 1])))
+            break;
+        else if (ch === "<" && line[i + 1] === "<" && line[i + 2] !== "<" && line[i - 1] !== "<") {
+            DELIMITER.lastIndex = i + 2;
+            const m = DELIMITER.exec(line);
+            const word = m ? (m[2] ?? m[3] ?? m[4]) : undefined;
+            if (m && word) {
+                out.push({ word, dash: m[1] === "-" });
+                i = DELIMITER.lastIndex - 1;
+            }
+        }
+    }
+    return out;
+}
+export function splitHeredocs(command) {
+    const executed = [];
+    const bodies = [];
+    const elided = [];
+    const pending = [];
+    let bodyLines = 0;
+    const marker = () => `[heredoc body: ${bodyLines} line${bodyLines === 1 ? "" : "s"}]`;
+    for (const raw of String(command ?? "").split("\n")) {
+        const line = raw.replace(/\r$/, "");
+        if (pending.length) {
+            const { word, dash } = pending[0];
+            if ((dash ? line.replace(/^\t+/, "") : line) === word) {
+                pending.shift();
+                elided.push(marker(), raw);
+                bodyLines = 0;
+            }
+            else {
+                bodies.push(raw);
+                bodyLines++;
+            }
+            continue;
+        }
+        executed.push(raw);
+        elided.push(raw);
+        pending.push(...operatorsOn(line));
+    }
+    if (pending.length)
+        elided.push(marker());
+    return { executed: executed.join("\n"), bodies: bodies.join("\n"), unterminated: pending.length > 0, elided: elided.join("\n") };
+}

package/dist/browser-runner/server.js

@@ -2,6 +2,7 @@ import { createServer, } from "node:http";
 import { URL } from "node:url";
 import { LocalRunner, RunnerInputError } from "./runner.js";
 import { probeGitSshIdentity } from "./coding/repo.js";
+import { checkEngine } from "./coding/engine-check.js";
 import { listGithubOrgs, listGithubRepos, searchGithubRepos, getGithubRepoDetail, getGithubCredentialScope } from "./coding/github-browse.js";
 export function createRunnerServer(runner) {
     return createServer(async (req, res) => {
@@ -383,6 +384,18 @@ async function route(runner, req, res) {
             return json(res, 400, { error: e instanceof Error ? e.message : String(e) });
         }
     }
+    // Can this machine run an engine — its binary on PATH, its subscription login stored (#879)? Asked
+    // BEFORE a session is launched, so a missing engine is a named refusal rather than a dead pane.
+    // An older runner 404s this, and the cloud reads that as "unverified", never as "missing".
+    if (req.method === "POST" && path === "/coding/engine-check") {
+        const b = await readJson(req);
+        try {
+            return json(res, 200, checkEngine(b));
+        }
+        catch (e) {
+            return json(res, 400, { error: e instanceof Error ? e.message : String(e) });
+        }
+    }
     // Background cold-start clones (#858): start (or join) one, and read it back. An older runner 404s
     // both, and the cloud falls back to the synchronous `/coding/clone` below.
     if (req.method === "POST" && (path === "/coding/clone-start" || path === "/coding/clone-status")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.66",
+  "version": "0.4.68",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",