@testchimp/cli 0.1.37 → 0.1.39

package/dist/chimphands/run.js

@@ -16,12 +16,8 @@ const STATUS_RUNNING = "CHIMPHANDS_SESSION_STATUS_RUNNING";
 const STATUS_WAITING_USER = "CHIMPHANDS_SESSION_STATUS_WAITING_USER";
 const STATUS_IDLE = "CHIMPHANDS_SESSION_STATUS_IDLE";
 const STATUS_FAILED = "CHIMPHANDS_SESSION_STATUS_FAILED";
-function ensureTestchimpPrompt(content) {
-    const trimmed = content.trim();
-    if (!trimmed)
-        return trimmed;
-    const rest = trimmed.replace(/^\/testchimp\s*/i, "").trim();
-    return rest ? `/testchimp ${rest}` : "/testchimp";
+function normalizeUserMessage(content) {
+    return content.trim();
 }
 function apiHeaders(apiKey) {
     return {
@@ -63,7 +59,11 @@ function extractOpencodeFatalError(raw) {
     try {
         const ev = JSON.parse(line);
         if (ev.type === "error" || ev.name === "UnknownError") {
-            const msg = ev.data?.message || ev.message || line;
+            const msg = ev.error?.data?.message ||
+                ev.error?.message ||
+                ev.data?.message ||
+                ev.message ||
+                line;
             const ref = ev.data?.ref ? ` (ref ${ev.data.ref})` : "";
             return `${msg}${ref}`;
         }
@@ -83,6 +83,27 @@ function extractOpencodeFatalError(raw) {
     }
     return null;
 }
+function parseOpencodeEvent(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function formatToolUseContent(part) {
+    const title = part.state?.title || part.tool || "tool";
+    const output = part.state?.output?.trim();
+    if (output)
+        return `[${title}]\n${output}`;
+    return `[${title}]`;
+}
+function opencodeMessageId(prefix, part) {
+    const raw = part?.id || part?.messageID;
+    if (!raw)
+        return undefined;
+    return `${prefix}${raw}`;
+}
 function summarizeOpencodeFailure(stderr, stdout, exitCode) {
     for (const chunk of [stderr, stdout]) {
         for (const line of chunk.split("\n")) {
@@ -169,41 +190,65 @@ function runOpencode(prompt, model, childEnv, postEvent) {
         return new Promise((resolve) => {
             let buf = "";
             let fatalError = null;
+            const textByPartId = new Map();
+            const handleOpencodeLine = (line) => {
+                if (!line.trim())
+                    return;
+                const fatal = extractOpencodeFatalError(line);
+                if (fatal) {
+                    fatalError = fatal;
+                    return;
+                }
+                const ev = parseOpencodeEvent(line);
+                if (!ev?.type)
+                    return;
+                switch (ev.type) {
+                    case "text": {
+                        const chunk = ev.part?.text;
+                        if (!chunk)
+                            return;
+                        const partId = ev.part?.id || ev.part?.messageID;
+                        if (!partId) {
+                            postEvent(ROLE_ASSISTANT, chunk);
+                            return;
+                        }
+                        const next = (textByPartId.get(partId) || "") + chunk;
+                        textByPartId.set(partId, next);
+                        postEvent(ROLE_ASSISTANT, next, undefined, opencodeMessageId("oc_text_", ev.part));
+                        return;
+                    }
+                    case "tool_use": {
+                        if (ev.part?.state?.status !== "completed")
+                            return;
+                        postEvent(ROLE_TOOL, formatToolUseContent(ev.part), undefined, opencodeMessageId("oc_tool_", ev.part));
+                        return;
+                    }
+                    case "error": {
+                        const msg = ev.error?.data?.message ||
+                            ev.error?.message ||
+                            line.trim();
+                        if (msg)
+                            fatalError = msg;
+                        return;
+                    }
+                    case "step_start":
+                    case "step_finish":
+                        return;
+                    default:
+                        return;
+                }
+            };
             child.stdout.on("data", (chunk) => {
                 buf += chunk.toString();
                 const lines = buf.split("\n");
                 buf = lines.pop() || "";
                 for (const line of lines) {
-                    if (!line.trim())
-                        continue;
-                    const fatal = extractOpencodeFatalError(line);
-                    if (fatal) {
-                        fatalError = fatal;
-                        continue;
-                    }
-                    let content = line;
-                    let role = ROLE_ASSISTANT;
-                    try {
-                        const ev = JSON.parse(line);
-                        content = ev.content || ev.message || ev.text || JSON.stringify(ev);
-                        if (ev.type === "tool" || ev.role === "tool")
-                            role = ROLE_TOOL;
-                        if (ev.type === "status")
-                            role = ROLE_STATUS;
-                    }
-                    catch {
-                        /* plain line */
-                    }
-                    postEvent(role, content);
+                    handleOpencodeLine(line);
                 }
             });
             child.on("close", (code) => {
                 if (buf.trim()) {
-                    const fatal = extractOpencodeFatalError(buf);
-                    if (fatal)
-                        fatalError = fatal;
-                    else if (!fatalError)
-                        postEvent(ROLE_ASSISTANT, buf.trim());
+                    handleOpencodeLine(buf.trim());
                 }
                 const stderrFatal = extractOpencodeFatalError(err);
                 if (stderrFatal)
@@ -242,57 +287,83 @@ function runOpencode(prompt, model, childEnv, postEvent) {
         return Promise.resolve({ code: errObj.status || 1, err: fatal });
     }
 }
-function connectInbound(backend, apiKey, sessionId, onUserMessage, onIdle, onClosed) {
+function connectInboundStream(backend, apiKey, sessionId, handlers) {
     const url = new URL(`${backend}/api/chimphands/sessions/${encodeURIComponent(sessionId)}/inbound`);
     const lib = url.protocol === "https:" ? https : http;
-    const req = lib.request({
-        hostname: url.hostname,
-        port: url.port || (url.protocol === "https:" ? 443 : 80),
-        path: url.pathname + url.search,
-        method: "GET",
-        headers: {
-            "TestChimp-Api-Key": apiKey,
-            Accept: "text/event-stream",
-            "Cache-Control": "no-cache",
-        },
-    }, (res) => {
-        let buf = "";
-        let eventName = "message";
-        res.on("data", (chunk) => {
-            buf += chunk.toString();
-            const parts = buf.split("\n");
-            buf = parts.pop() || "";
-            for (const line of parts) {
-                if (line.startsWith("event:")) {
-                    eventName = line.slice(6).trim() || "message";
-                }
-                else if (line.startsWith("data:")) {
-                    const data = line.slice(5).trim();
-                    if (eventName === "idle") {
-                        onIdle();
+    let stopped = false;
+    let reconnectTimer = null;
+    let reconnectDelayMs = 1000;
+    const scheduleReconnect = () => {
+        if (stopped || !handlers.shouldRun())
+            return;
+        if (reconnectTimer)
+            return;
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = null;
+            connect();
+        }, reconnectDelayMs);
+        reconnectDelayMs = Math.min(reconnectDelayMs * 2, 15_000);
+    };
+    const connect = () => {
+        if (stopped || !handlers.shouldRun())
+            return;
+        const req = lib.request({
+            hostname: url.hostname,
+            port: url.port || (url.protocol === "https:" ? 443 : 80),
+            path: url.pathname + url.search,
+            method: "GET",
+            headers: {
+                "TestChimp-Api-Key": apiKey,
+                Accept: "text/event-stream",
+                "Cache-Control": "no-cache",
+            },
+        }, (res) => {
+            reconnectDelayMs = 1000;
+            let buf = "";
+            let eventName = "message";
+            res.on("data", (chunk) => {
+                buf += chunk.toString();
+                const parts = buf.split("\n");
+                buf = parts.pop() || "";
+                for (const line of parts) {
+                    if (line.startsWith("event:")) {
+                        eventName = line.slice(6).trim() || "message";
                     }
-                    else if (eventName === "user_message" || eventName === "message") {
-                        try {
-                            const msg = JSON.parse(data);
-                            const content = msg.content || "";
-                            if (content)
-                                onUserMessage(content);
+                    else if (line.startsWith("data:")) {
+                        const data = line.slice(5).trim();
+                        if (eventName === "idle") {
+                            handlers.onIdle();
                         }
-                        catch {
-                            /* ignore */
+                        else if (eventName === "user_message" || eventName === "message") {
+                            try {
+                                const msg = JSON.parse(data);
+                                handlers.onUserMessage({
+                                    id: msg.id || msg.message_id,
+                                    content: msg.content || "",
+                                });
+                            }
+                            catch {
+                                /* ignore */
+                            }
                         }
+                        eventName = "message";
+                    }
+                    else if (line === "") {
+                        eventName = "message";
                     }
-                    eventName = "message";
-                }
-                else if (line === "") {
-                    eventName = "message";
                 }
-            }
+            });
+            res.on("end", () => scheduleReconnect());
         });
-        res.on("end", () => onClosed());
-    });
-    req.on("error", () => onClosed());
-    req.end();
+        req.on("error", () => scheduleReconnect());
+        req.end();
+    };
+    connect();
+    return () => {
+        stopped = true;
+        if (reconnectTimer)
+            clearTimeout(reconnectTimer);
+    };
 }
 export async function runChimphands(opts) {
     const apiKey = requireApiKey();
@@ -324,15 +395,49 @@ export async function runChimphands(opts) {
     console.error(`ChimpHands OpenCode model: ${opencodeModel}`);
     const idleMs = (Number(boot.idle_timeout_seconds) || 600) * 1000;
     const queue = [];
+    const seenUserMessageIds = new Set();
     let idle = false;
-    let closed = false;
+    let sessionActive = true;
     let lastUserActivity = Date.now();
-    const postEvent = (role, content, status) => {
+    const enqueueUserMessage = (msg) => {
+        const id = msg.id?.trim();
+        if (id) {
+            if (seenUserMessageIds.has(id))
+                return;
+            seenUserMessageIds.add(id);
+        }
+        const content = normalizeUserMessage(msg.content || "");
+        if (!content)
+            return;
+        queue.push(content);
+        lastUserActivity = Date.now();
+        idle = false;
+    };
+    const pollPendingUserMessages = async () => {
+        try {
+            const text = await postJson(backend, apiKey, "/api/chimphands/consume_pending_user_messages", {
+                sessionId,
+            });
+            const data = JSON.parse(text);
+            for (const msg of data.messages || []) {
+                enqueueUserMessage({
+                    id: msg.id || msg.message_id,
+                    content: msg.content || "",
+                });
+            }
+        }
+        catch {
+            // Polling is best-effort when inbound SSE misses an event.
+        }
+    };
+    const postEvent = (role, content, status, messageId) => {
         const body = {
             sessionId,
             role,
             content: String(content || "").slice(0, 20000),
         };
+        if (messageId)
+            body.messageId = messageId;
         if (status != null)
             body.status = status;
         postJsonFireAndForget(backend, apiKey, "/api/chimphands/post_agent_event", body);
@@ -352,30 +457,46 @@ export async function runChimphands(opts) {
     };
     if (userId)
         childEnv.TESTCHIMP_USER_ID = userId;
-    connectInbound(backend, apiKey, sessionId, (content) => {
-        queue.push(ensureTestchimpPrompt(content));
-        lastUserActivity = Date.now();
-    }, () => {
-        idle = true;
-    }, () => {
-        closed = true;
+    const stopInbound = connectInboundStream(backend, apiKey, sessionId, {
+        onUserMessage: enqueueUserMessage,
+        onIdle: () => {
+            idle = true;
+        },
+        shouldRun: () => sessionActive,
     });
     postEvent(ROLE_STATUS, "Agent ready", STATUS_RUNNING);
-    let prompt = ensureTestchimpPrompt(promptInput || boot.initial_prompt || "");
+    let prompt = normalizeUserMessage(promptInput || boot.initial_prompt || "");
     if (boot.conversation_summary) {
         prompt = `Conversation so far:\n${boot.conversation_summary}\n\nCurrent task:\n${prompt}`;
     }
     for (const m of boot.pending_user_messages || []) {
         if (m?.content)
-            queue.push(ensureTestchimpPrompt(m.content));
+            enqueueUserMessage({ content: m.content });
     }
     const waitForNextPrompt = () => new Promise((resolve) => {
+        let lastPollAt = 0;
         const tick = () => {
             if (queue.length) {
-                resolve(ensureTestchimpPrompt(queue.shift()));
+                resolve(normalizeUserMessage(queue.shift()));
+                return;
+            }
+            const now = Date.now();
+            if (now - lastPollAt >= 1500) {
+                lastPollAt = now;
+                void pollPendingUserMessages().then(() => {
+                    if (queue.length) {
+                        resolve(normalizeUserMessage(queue.shift()));
+                        return;
+                    }
+                    if (idle || now - lastUserActivity >= idleMs) {
+                        resolve(null);
+                        return;
+                    }
+                    setTimeout(tick, 500);
+                });
                 return;
             }
-            if (idle || closed || Date.now() - lastUserActivity >= idleMs) {
+            if (idle || now - lastUserActivity >= idleMs) {
                 resolve(null);
                 return;
             }
@@ -384,7 +505,7 @@ export async function runChimphands(opts) {
         tick();
     });
     while (prompt) {
-        const result = await runOpencode(ensureTestchimpPrompt(prompt), opencodeModel, childEnv, postEvent);
+        const result = await runOpencode(prompt, opencodeModel, childEnv, postEvent);
         if (result.code !== 0) {
             const errMsg = (result.err || "opencode failed").trim() || "opencode failed";
             console.error(`ChimpHands OpenCode failed: ${errMsg}`);
@@ -417,6 +538,8 @@ export async function runChimphands(opts) {
         idle = false;
         prompt = (await waitForNextPrompt()) || "";
     }
+    sessionActive = false;
+    stopInbound();
     console.error("ChimpHands session idle — no user input before timeout; completing.");
     complete(STATUS_IDLE);
 }

package/package.json

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