@testchimp/cli 0.1.45 → 0.1.47

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";
@@ -33,6 +33,7 @@ const CHIMPHANDS_AGENT_PROMPT = `You are ChimpHands, TestChimp's coding agent. Y
 - This conversation uses ONE working branch and ONE pull request. Reuse them for all follow-up work in this chat.
 - If bootstrap lists a working branch, checkout that branch and push additional commits there — update the same PR.
 - Only create a NEW branch/PR when (a) no working branch exists yet for this conversation, or (b) the prior PR was merged/closed (verify with \`gh pr view\`).
+- Commit and push on the session working branch after meaningful edit batches. The host also commits any dirty worktree before idle teardown — keep the branch pushed so the UI can show diffs from GitHub.
 - Branch names MUST start with \`testchimp-\` or \`chimphands-\`.
 - When creating a NEW working branch: create it, then IMMEDIATELY publish it with
   \`git push -u origin <branch>\` BEFORE calling report-branch. Users open the branch URL in the UI —
@@ -371,7 +372,16 @@ 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];
+    const args = [
+        "run",
+        prompt,
+        "--model",
+        model,
+        "--format",
+        "json",
+        "--agent",
+        OPENCODE_AGENT_ID,
+    ];
     if (opencodeSessionId?.trim()) {
         args.push("--session", opencodeSessionId.trim());
     }
@@ -380,6 +390,74 @@ 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);
@@ -648,6 +726,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");
@@ -768,6 +849,7 @@ export async function runChimphands(opts) {
         stopInbound();
         stopTunnel();
         stopHeartbeat();
+        await commitAndPushDirtyWorktree("chimphands: commit before session idle/shutdown");
         await poster.flush();
         await snapshotExport();
         if (runtimeId) {
@@ -918,6 +1000,69 @@ function startRuntimeHeartbeat(backend, apiKey, runtimeId) {
         stopped = true;
     };
 }
+/** Commit+push dirty worktree on the session branch before idle/teardown (no default-branch writes). */
+async function commitAndPushDirtyWorktree(message) {
+    const run = (args, env) => new Promise((resolve) => {
+        const child = spawn("git", args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: env ? { ...process.env, ...env } : process.env,
+        });
+        let out = "";
+        let err = "";
+        child.stdout.on("data", (d) => {
+            out += d.toString();
+        });
+        child.stderr.on("data", (d) => {
+            err += d.toString();
+        });
+        child.on("close", (code) => resolve({ code: code ?? 1, out, err }));
+    });
+    try {
+        const branch = await run(["rev-parse", "--abbrev-ref", "HEAD"]);
+        if (branch.code !== 0) {
+            console.error(`ChimpHands git rev-parse failed: ${branch.err || branch.out}`);
+            return;
+        }
+        const current = branch.out.trim();
+        if (!current || current === "HEAD" || /^(main|master)$/i.test(current)) {
+            console.error(`ChimpHands skip commit-before-idle: refusing branch "${current || "(unknown)"}"`);
+            return;
+        }
+        const status = await run(["status", "--porcelain"]);
+        if (status.code !== 0) {
+            console.error(`ChimpHands git status failed: ${status.err || status.out}`);
+            return;
+        }
+        if (!status.out.trim()) {
+            return;
+        }
+        const add = await run(["add", "-A"]);
+        if (add.code !== 0) {
+            console.error(`ChimpHands git add failed: ${add.err || add.out}`);
+            return;
+        }
+        const commitEnv = {
+            GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME || "ChimpHands",
+            GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL || "chimphands@testchimp.io",
+            GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME || "ChimpHands",
+            GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL || "chimphands@testchimp.io",
+        };
+        const commit = await run(["-c", "user.name=ChimpHands", "-c", "user.email=chimphands@testchimp.io", "commit", "-m", message], commitEnv);
+        if (commit.code !== 0) {
+            console.error(`ChimpHands git commit: ${commit.err || commit.out}`);
+            return;
+        }
+        const push = await run(["push", "-u", "origin", "HEAD"]);
+        if (push.code !== 0) {
+            console.error(`ChimpHands git push failed: ${push.err || push.out}`);
+            return;
+        }
+        console.error(`ChimpHands committed and pushed dirty worktree on ${current} before shutdown`);
+    }
+    catch (err) {
+        console.error(`ChimpHands commit-before-idle failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 async function putOpencodeExport(backend, apiKey, sessionId, opencodeSessionId) {
     const exported = await new Promise((resolve, reject) => {
         const child = spawn("opencode", ["export", opencodeSessionId, "--sanitize"], {
@@ -1006,6 +1151,18 @@ function startTunnelWorker(backend, apiKey, runtimeId, attachUrl) {
                 return;
             socket.send(JSON.stringify(obj));
         };
+        /** Keep each WS text frame small — Tomcat default max is 8KiB; GCLB is happier with modest frames. */
+        const sendBodyChunk = (bytes) => {
+            const MAX = 24 * 1024;
+            for (let offset = 0; offset < bytes.length; offset += MAX) {
+                const slice = bytes.subarray(offset, Math.min(offset + MAX, bytes.length));
+                send({
+                    type: "http_response_chunk",
+                    requestId,
+                    bodyBase64: Buffer.from(slice).toString("base64"),
+                });
+            }
+        };
         try {
             const upstream = await fetch(target, init);
             const respHeaders = {};
@@ -1026,22 +1183,14 @@ function startTunnelWorker(backend, apiKey, runtimeId, attachUrl) {
                     if (done)
                         break;
                     if (value && value.length) {
-                        send({
-                            type: "http_response_chunk",
-                            requestId,
-                            bodyBase64: Buffer.from(value).toString("base64"),
-                        });
+                        sendBodyChunk(Buffer.from(value));
                     }
                 }
             }
             else {
                 const buf = Buffer.from(await upstream.arrayBuffer());
                 if (buf.length) {
-                    send({
-                        type: "http_response_chunk",
-                        requestId,
-                        bodyBase64: buf.toString("base64"),
-                    });
+                    sendBodyChunk(buf);
                 }
             }
             send({ type: "http_response_end", requestId });
@@ -1073,6 +1222,20 @@ function startTunnelWorker(backend, apiKey, runtimeId, attachUrl) {
         socket.on("open", () => {
             backoffMs = 1000;
             console.error(`ChimpHands agent tunnel WS connected: ${tunnelUrl}`);
+            // Application ping keeps LBs from idling out the tunnel (and proves liveness).
+            const ping = () => {
+                if (stopped || socket.readyState !== 1)
+                    return;
+                try {
+                    socket.send(JSON.stringify({ type: "ping" }));
+                }
+                catch {
+                    /* ignore */
+                }
+            };
+            ping();
+            const pingTimer = setInterval(ping, 20_000);
+            socket.once("close", () => clearInterval(pingTimer));
         });
         socket.on("message", (data) => {
             if (stopped)
@@ -1094,11 +1257,12 @@ function startTunnelWorker(backend, apiKey, runtimeId, attachUrl) {
                 console.error(`ChimpHands tunnel frame error: ${err instanceof Error ? err.message : String(err)}`);
             }
         });
-        socket.on("close", () => {
+        socket.on("close", (code, reason) => {
             ws = null;
             if (stopped)
                 return;
-            console.error(`ChimpHands agent tunnel WS closed; reconnecting in ${backoffMs}ms`);
+            const why = reason?.toString?.() || "";
+            console.error(`ChimpHands agent tunnel WS closed; code=${code} reason=${why || "(none)"} reconnecting in ${backoffMs}ms`);
             reconnectTimer = setTimeout(() => {
                 void connect();
             }, backoffMs);
@@ -1129,18 +1293,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.45",
+  "version": "0.1.47",
   "description": "TestChimp CLI and MCP server — coverage, plans, EaaS, TrueCoverage, API operations (calls /api/mcp/*)",
   "type": "module",
   "main": "dist/bin/testchimp.js",