@testchimp/cli 0.1.46 → 0.1.48

package/dist/chimphands/run.js

@@ -3,8 +3,8 @@
  * Relies on TESTCHIMP_API_KEY (+ optional TESTCHIMP_BACKEND_URL; defaults to prod).
  * Does not write mcp.json — TestChimp MCP is wired via opencode.json for OpenCode.
  */
-import { spawn } from "node:child_process";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { execSync, spawn } from "node:child_process";
+import { mkdirSync, openSync, writeFileSync } from "node:fs";
 import http from "node:http";
 import https from "node:https";
 import { URL } from "node:url";
@@ -18,7 +18,11 @@ const STATUS_WAITING_USER = "CHIMPHANDS_SESSION_STATUS_WAITING_USER";
 const STATUS_IDLE = "CHIMPHANDS_SESSION_STATUS_IDLE";
 const STATUS_FAILED = "CHIMPHANDS_SESSION_STATUS_FAILED";
 const OPENCODE_AGENT_ID = "chimphands";
-const STREAM_POST_MIN_INTERVAL_MS = 60;
+/** Coalesce live token fanout (~6–10 posts/s/session) while UI is attached. */
+const STREAM_POST_MIN_INTERVAL_MS = 150;
+function isStreamFanoutRole(role) {
+    return role === ROLE_ASSISTANT || role === ROLE_TOOL || role === ROLE_REASONING;
+}
 const CHIMPHANDS_AGENT_PROMPT = `You are ChimpHands, TestChimp's coding agent. You run on GitHub Actions, but this chat is an **interactive** conversation with the user in the TestChimp UI — same expectations as Cursor/Claude Code locally.
 
 ## Interactive session (mandatory — default)
@@ -102,13 +106,15 @@ async function postJson(backend, apiKey, path, body) {
     }
     return text;
 }
-/** Serializes post_agent_event calls so streaming chunks commit and fan out in order. */
+/** Serializes agent event posts so streaming chunks fan out in order. */
 class AgentEventPoster {
     backend;
     apiKey;
     sessionId;
     chain = Promise.resolve();
     lastStreamPostAt = 0;
+    /** When false, assistant/tool/reasoning tokens are dropped (async / no UI). */
+    uiAttached = false;
     constructor(backend, apiKey, sessionId) {
         this.backend = backend;
         this.apiKey = apiKey;
@@ -130,15 +136,36 @@ class AgentEventPoster {
             body.workingBranch = opts.workingBranch;
         if (opts?.pullRequestUrl)
             body.pullRequestUrl = opts.pullRequestUrl;
+        const ephemeral = isStreamFanoutRole(role);
+        if (ephemeral && !this.uiAttached) {
+            return this.chain;
+        }
         this.chain = this.chain.then(async () => {
-            if (opts?.throttle) {
+            if (opts?.throttle || ephemeral) {
                 const now = Date.now();
                 const wait = STREAM_POST_MIN_INTERVAL_MS - (now - this.lastStreamPostAt);
                 if (wait > 0)
                     await sleep(wait);
                 this.lastStreamPostAt = Date.now();
             }
-            await postJson(this.backend, this.apiKey, "/api/chimphands/post_agent_event", body);
+            const path = ephemeral
+                ? "/api/chimphands/post_ephemeral_agent_event"
+                : "/api/chimphands/post_agent_event";
+            // Ephemeral API only accepts session/role/content/messageId/opencodeSessionId.
+            if (ephemeral) {
+                const eph = {
+                    sessionId: this.sessionId,
+                    role,
+                    content: body.content,
+                };
+                if (opts?.messageId)
+                    eph.messageId = opts.messageId;
+                if (opts?.opencodeSessionId)
+                    eph.opencodeSessionId = opts.opencodeSessionId;
+                await postJson(this.backend, this.apiKey, path, eph);
+                return;
+            }
+            await postJson(this.backend, this.apiKey, path, body);
         });
         return this.chain;
     }
@@ -236,6 +263,173 @@ function opencodeMessageId(prefix, part) {
         return undefined;
     return `${prefix}${raw}`;
 }
+/**
+ * OpenCode `run --format json` only emits completed text (`part.time.end`).
+ * Live tokens come from the server SSE bus (`message.part.updated` + optional `delta`).
+ * Subscribe directly when attaching so the platform chat streams.
+ */
+function startOpencodeSseRelay(attachUrl, callbacks) {
+    const base = attachUrl.replace(/\/$/, "");
+    const ac = new AbortController();
+    let stopped = false;
+    const textByPartId = new Map();
+    const sessionMatches = (sessionId) => {
+        const active = callbacks.getActiveSessionId();
+        if (!sessionId)
+            return !active;
+        if (!active)
+            return true;
+        return sessionId === active;
+    };
+    const handleBusEvent = (raw) => {
+        if (!raw || typeof raw !== "object")
+            return;
+        const ev = raw;
+        const type = ev.type || "";
+        const props = ev.properties || {};
+        if (type === "message.part.updated" || type === "message.part.delta") {
+            const part = props.part;
+            if (!part)
+                return;
+            const sessionId = part.sessionID || props.sessionID;
+            if (!sessionMatches(sessionId))
+                return;
+            callbacks.noteSessionId(sessionId);
+            if (part.type === "text") {
+                const partId = part.id || part.messageID;
+                if (!partId)
+                    return;
+                let next = part.text || "";
+                if (props.delta) {
+                    next = (textByPartId.get(partId) || "") + props.delta;
+                }
+                else if (!next && props.delta === undefined) {
+                    return;
+                }
+                // Prefer cumulative part.text when present (idempotent); else delta accumulation.
+                if (part.text)
+                    next = part.text;
+                textByPartId.set(partId, next);
+                if (!next)
+                    return;
+                callbacks.postEvent(ROLE_ASSISTANT, next, {
+                    throttle: true,
+                    messageId: opencodeMessageId("oc_text_", part),
+                });
+                return;
+            }
+            if (part.type === "reasoning") {
+                const partId = part.id || part.messageID;
+                if (!partId)
+                    return;
+                let next = part.text || "";
+                if (props.delta && !part.text) {
+                    next = (textByPartId.get(`reasoning:${partId}`) || "") + props.delta;
+                }
+                if (part.text)
+                    next = part.text;
+                textByPartId.set(`reasoning:${partId}`, next);
+                if (!next)
+                    return;
+                callbacks.postEvent(ROLE_REASONING, next, {
+                    throttle: true,
+                    messageId: opencodeMessageId("oc_reasoning_", part),
+                });
+                return;
+            }
+            if (part.type === "tool") {
+                const status = part.state?.status;
+                if (!status || status === "pending" || status === "running")
+                    return;
+                const toolContent = formatToolUseContent(part);
+                callbacks.postEvent(ROLE_TOOL, toolContent, {
+                    messageId: opencodeMessageId("oc_tool_", part),
+                });
+                if (status === "completed") {
+                    const detected = detectWorkingBranchFromToolOutput(toolContent);
+                    if (detected.branch) {
+                        callbacks.onWorkingBranch?.(detected.branch, detected.pullRequestUrl);
+                    }
+                }
+            }
+            return;
+        }
+        if (type === "session.error") {
+            const sessionId = props.sessionID;
+            if (!sessionMatches(sessionId))
+                return;
+            const msg = props.error?.data?.message || props.error?.message || props.error?.name || "OpenCode session error";
+            callbacks.postEvent(ROLE_STATUS, String(msg), { status: STATUS_RUNNING });
+        }
+    };
+    const consume = async (body) => {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        while (!stopped) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            const chunks = buf.split("\n\n");
+            buf = chunks.pop() || "";
+            for (const chunk of chunks) {
+                const dataLines = chunk
+                    .split("\n")
+                    .filter((l) => l.startsWith("data:"))
+                    .map((l) => l.slice(5).trimStart());
+                if (!dataLines.length)
+                    continue;
+                const data = dataLines.join("\n");
+                if (!data || data === "[DONE]")
+                    continue;
+                try {
+                    handleBusEvent(JSON.parse(data));
+                }
+                catch {
+                    /* ignore malformed */
+                }
+            }
+        }
+    };
+    void (async () => {
+        for (const path of ["/event", "/global/event"]) {
+            if (stopped)
+                return;
+            try {
+                const res = await fetch(`${base}${path}`, {
+                    headers: { Accept: "text/event-stream" },
+                    signal: ac.signal,
+                });
+                if (!res.ok || !res.body) {
+                    console.error(`ChimpHands OpenCode SSE ${path} HTTP ${res.status}`);
+                    continue;
+                }
+                console.error(`ChimpHands OpenCode SSE streaming via ${path}`);
+                await consume(res.body);
+                return;
+            }
+            catch (err) {
+                if (stopped || ac.signal.aborted)
+                    return;
+                const detail = err instanceof Error ? err.message : String(err);
+                console.error(`ChimpHands OpenCode SSE ${path} failed: ${detail}`);
+            }
+        }
+        if (!stopped) {
+            console.error("ChimpHands OpenCode SSE unavailable — falling back to completed-only --format json events");
+        }
+    })();
+    return () => {
+        stopped = true;
+        try {
+            ac.abort();
+        }
+        catch {
+            /* ignore */
+        }
+    };
+}
 function summarizeOpencodeFailure(stderr, stdout, exitCode) {
     for (const chunk of [stderr, stdout]) {
         for (const line of chunk.split("\n")) {
@@ -350,10 +544,12 @@ function writeOpencodeConfig(backend, apiKey, boot) {
                 prompt: CHIMPHANDS_AGENT_PROMPT,
                 steps: 80,
                 permission: {
+                    "*": "allow",
                     skill: "allow",
                     bash: "allow",
                     edit: "allow",
                     read: "allow",
+                    question: "allow",
                 },
             },
         },
@@ -364,7 +560,8 @@ function writeOpencodeConfig(backend, apiKey, boot) {
             testchimp: {
                 type: "local",
                 enabled: true,
-                command: ["npx", "-y", "@testchimp/cli@latest", "mcp"],
+                // Prefer the already-installed global binary — `npx -y @latest` can hang in GHA.
+                command: ["testchimp", "mcp"],
                 environment: mcpEnv,
             },
         },
@@ -372,7 +569,20 @@ function writeOpencodeConfig(backend, apiKey, boot) {
     return model;
 }
 function buildOpencodeArgs(prompt, model, opencodeSessionId, attachUrl) {
-    const args = ["run", prompt, "--model", model, "--format", "json", "--agent", OPENCODE_AGENT_ID];
+    // --auto: headless CI must approve tool permissions (1.18+ otherwise auto-rejects).
+    // --print-logs: surface server/client progress on stderr while waiting for first token.
+    const args = [
+        "run",
+        prompt,
+        "--model",
+        model,
+        "--format",
+        "json",
+        "--agent",
+        OPENCODE_AGENT_ID,
+        "--auto",
+        "--print-logs",
+    ];
     if (opencodeSessionId?.trim()) {
         args.push("--session", opencodeSessionId.trim());
     }
@@ -381,21 +591,102 @@ function buildOpencodeArgs(prompt, model, opencodeSessionId, attachUrl) {
     }
     return args;
 }
+function killListenersOnPort(port) {
+    try {
+        const out = execSync(`lsof -tiTCP:${port} -sTCP:LISTEN`, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        for (const pid of out.split(/\s+/).filter(Boolean)) {
+            const n = Number(pid);
+            if (!Number.isFinite(n) || n <= 0)
+                continue;
+            try {
+                process.kill(n, "SIGTERM");
+            }
+            catch {
+                /* already gone */
+            }
+        }
+    }
+    catch {
+        /* nothing listening */
+    }
+}
+async function waitForOpencodeHttp(attachUrl, timeoutMs) {
+    const base = attachUrl.replace(/\/$/, "");
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        for (const path of ["/global/health", "/"]) {
+            try {
+                const res = await fetch(`${base}${path}`);
+                if (res.ok || res.status === 401 || res.status === 404)
+                    return;
+            }
+            catch {
+                /* retry */
+            }
+        }
+        await sleep(400);
+    }
+    throw new Error(`OpenCode server not ready at ${attachUrl} within ${timeoutMs}ms`);
+}
+/**
+ * Restart local `opencode serve` after writing opencode.json so the server loads
+ * TestChimp provider + default_agent. Workflow may have started serve earlier without config.
+ */
+async function restartLocalOpencodeServer(attachUrl) {
+    const u = new URL(attachUrl);
+    const hostname = u.hostname || "127.0.0.1";
+    const port = u.port || (u.protocol === "https:" ? "443" : "80");
+    killListenersOnPort(port);
+    await sleep(300);
+    const logFd = openSync("opencode-server.log", "a");
+    const child = spawn("opencode", ["serve", "--port", port, "--hostname", hostname], {
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+        env: process.env,
+    });
+    child.unref();
+    if (child.pid) {
+        try {
+            writeFileSync("/tmp/opencode-server.pid", String(child.pid));
+        }
+        catch {
+            /* best effort */
+        }
+    }
+    console.error(`ChimpHands restarted OpenCode serve on ${hostname}:${port} (pid ${child.pid ?? "?"})`);
+    await waitForOpencodeHttp(attachUrl, 60_000);
+}
 function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, attachUrl) {
     let activeSessionId = opencodeSessionId?.trim() || undefined;
     const baseArgs = buildOpencodeArgs(prompt, model, activeSessionId, attachUrl);
+    const preview = prompt.length > 120 ? `${prompt.slice(0, 117)}...` : prompt;
+    console.error(`ChimpHands invoking OpenCode: model=${model} attach=${attachUrl || "(local)"} session=${activeSessionId || "(new)"} prompt=${JSON.stringify(preview)}`);
+    // pipe+end stdin so OpenCode does not wait on Bun.stdin.text() (non-TTY).
     const child = spawn("opencode", baseArgs, {
-        stdio: ["ignore", "pipe", "pipe"],
+        stdio: ["pipe", "pipe", "pipe"],
         env: childEnv,
     });
+    try {
+        child.stdin?.end();
+    }
+    catch {
+        /* ignore */
+    }
     let err = "";
     child.stderr.on("data", (d) => {
-        err += d.toString();
+        const chunk = d.toString();
+        err += chunk;
+        // Live-forward so GHA shows progress while waiting for first JSON event.
+        process.stderr.write(chunk);
     });
     return new Promise((resolve) => {
         let buf = "";
         let fatalError = null;
         const textByPartId = new Map();
+        let sawStdout = false;
         const noteSessionId = (sessionId) => {
             const id = sessionId?.trim();
             if (!id || id === activeSessionId)
@@ -406,6 +697,10 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
         const handleOpencodeLine = (line) => {
             if (!line.trim())
                 return;
+            if (!sawStdout) {
+                sawStdout = true;
+                console.error("ChimpHands OpenCode first stdout event received");
+            }
             const fatal = extractOpencodeFatalError(line);
             if (fatal) {
                 fatalError = fatal;
@@ -608,6 +903,40 @@ export async function runChimphands(opts) {
     const boot = JSON.parse(bootText);
     const githubRunId = (process.env.GITHUB_RUN_ID || "").trim();
     const poster = new AgentEventPoster(backend, apiKey, sessionId);
+    poster.uiAttached = !!(boot.uiAttached ?? boot.ui_attached);
+    let stopLiveSse = null;
+    const syncLiveSse = (attached) => {
+        poster.uiAttached = attached;
+        if (!attachUrl)
+            return;
+        if (attached && !stopLiveSse) {
+            console.error("ChimpHands UI attached — starting OpenCode SSE fanout");
+            stopLiveSse = startOpencodeSseRelay(attachUrl, {
+                getActiveSessionId: () => opencodeSessionId,
+                noteSessionId: (id) => {
+                    if (id?.trim())
+                        opencodeSessionId = id.trim();
+                },
+                postEvent: (role, content, opts) => {
+                    poster.fireAndForget(role, content, {
+                        ...opts,
+                        opencodeSessionId: opts?.opencodeSessionId || opencodeSessionId,
+                    });
+                },
+                onWorkingBranch: noteWorkingBranchPlaceholder,
+            });
+        }
+        else if (!attached && stopLiveSse) {
+            console.error("ChimpHands UI detached — stopping OpenCode SSE fanout");
+            stopLiveSse();
+            stopLiveSse = null;
+        }
+    };
+    // noteWorkingBranch is defined later; bind via mutable holder until then.
+    let noteWorkingBranch = () => { };
+    const noteWorkingBranchPlaceholder = (branch, prUrl) => {
+        noteWorkingBranch(branch, prUrl);
+    };
     if (githubRunId) {
         await postJson(backend, apiKey, "/api/chimphands/post_agent_event", {
             sessionId,
@@ -635,7 +964,9 @@ export async function runChimphands(opts) {
         }
     }
     const stopHeartbeat = runtimeId
-        ? startRuntimeHeartbeat(backend, apiKey, runtimeId)
+        ? startRuntimeHeartbeat(backend, apiKey, runtimeId, (attached) => {
+            syncLiveSse(attached);
+        })
         : () => { };
     const stopTunnel = runtimeId && attachUrl
         ? startTunnelWorker(backend, apiKey, runtimeId, attachUrl)
@@ -649,6 +980,9 @@ export async function runChimphands(opts) {
     console.error(`ChimpHands OpenCode model: ${opencodeModel}`);
     if (attachUrl) {
         console.error(`ChimpHands OpenCode attach: ${attachUrl}`);
+        // Serve must load opencode.json (provider + default_agent). Workflow often starts
+        // serve before this file exists; restart so attach mode can omit --agent safely.
+        await restartLocalOpencodeServer(attachUrl);
     }
     let opencodeSessionId = bootStr(boot, "opencode_session_id", "opencodeSessionId") || undefined;
     const conversationSummary = bootStr(boot, "conversation_summary", "conversationSummary");
@@ -678,7 +1012,7 @@ export async function runChimphands(opts) {
             console.error(`ChimpHands export snapshot failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     };
-    const noteWorkingBranch = (branch, prUrl) => {
+    noteWorkingBranch = (branch, prUrl) => {
         const normalizedBranch = branch.trim();
         if (!normalizedBranch)
             return;
@@ -694,6 +1028,8 @@ export async function runChimphands(opts) {
             poster.reportWorkingBranch(normalizedBranch, nextPr);
         }
     };
+    // Apply bootstrap ui_attached now that session id + branch hooks exist.
+    syncLiveSse(poster.uiAttached);
     const idleMs = (bootNum(boot, "idle_timeout_seconds", "idleTimeoutSeconds") || 600) * 1000;
     const queue = [];
     const seenUserMessageIds = new Set();
@@ -769,6 +1105,10 @@ export async function runChimphands(opts) {
         stopInbound();
         stopTunnel();
         stopHeartbeat();
+        if (stopLiveSse) {
+            stopLiveSse();
+            stopLiveSse = null;
+        }
         await commitAndPushDirtyWorktree("chimphands: commit before session idle/shutdown");
         await poster.flush();
         await snapshotExport();
@@ -822,6 +1162,9 @@ export async function runChimphands(opts) {
             let useOpencodeSessionId = opencodeSessionId;
             let isNewOpencodeSession = !useOpencodeSessionId;
             let effectivePrompt = wrapPromptWithContext(conversationSummary, prompt, isNewOpencodeSession, workingBranch, pullRequestUrl);
+            // Visible in chat (not filtered as routine). OpenCode may not emit text until a
+            // part completes — without this the UI looks empty while the turn is running.
+            postEvent(ROLE_STATUS, "Agent is working…", { status: STATUS_RUNNING });
             let result = await runOpencode(effectivePrompt, opencodeModel, childEnv, useOpencodeSessionId, {
                 onSessionId: (id) => {
                     opencodeSessionId = id;
@@ -898,22 +1241,34 @@ export async function runChimphands(opts) {
         process.exit(exitCode);
     }
 }
-function startRuntimeHeartbeat(backend, apiKey, runtimeId) {
+function startRuntimeHeartbeat(backend, apiKey, runtimeId, onUiAttached) {
     let stopped = false;
+    let lastAttached;
     const tick = async () => {
         if (stopped)
             return;
         try {
             // Do not claim tunnel_connected here — only the tunnel poll loop should.
-            await postJson(backend, apiKey, "/api/chimphands/runtime_heartbeat", {
+            const text = await postJson(backend, apiKey, "/api/chimphands/runtime_heartbeat", {
                 runtimeId,
             });
+            try {
+                const data = JSON.parse(text);
+                const attached = !!(data.uiAttached ?? data.ui_attached);
+                if (attached !== lastAttached) {
+                    lastAttached = attached;
+                    onUiAttached?.(attached);
+                }
+            }
+            catch {
+                /* ignore parse */
+            }
         }
         catch (err) {
             console.error(`ChimpHands runtime_heartbeat failed: ${err instanceof Error ? err.message : String(err)}`);
         }
         if (!stopped)
-            setTimeout(tick, 15_000);
+            setTimeout(tick, 5_000);
     };
     void tick();
     return () => {
@@ -985,7 +1340,7 @@ async function commitAndPushDirtyWorktree(message) {
 }
 async function putOpencodeExport(backend, apiKey, sessionId, opencodeSessionId) {
     const exported = await new Promise((resolve, reject) => {
-        const child = spawn("opencode", ["export", opencodeSessionId, "--sanitize"], {
+        const child = spawn("opencode", ["export", opencodeSessionId], {
             stdio: ["ignore", "pipe", "pipe"],
         });
         let out = "";
@@ -1213,18 +1568,6 @@ export async function serveChimphands(opts) {
     if (!attachUrl) {
         throw new Error("--attach URL is required for chimphands serve");
     }
-    // Wait for OpenCode server readiness.
-    const deadline = Date.now() + 60_000;
-    while (Date.now() < deadline) {
-        try {
-            const res = await fetch(attachUrl.replace(/\/$/, "") + "/");
-            if (res.ok || res.status === 401 || res.status === 404)
-                break;
-        }
-        catch {
-            /* retry */
-        }
-        await sleep(500);
-    }
+    // Server is (re)started inside runChimphands after opencode.json is written.
     await runChimphands({ ...opts, attachUrl });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testchimp/cli",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "description": "TestChimp CLI and MCP server — coverage, plans, EaaS, TrueCoverage, API operations (calls /api/mcp/*)",
   "type": "module",
   "main": "dist/bin/testchimp.js",