@testchimp/cli 0.1.38 → 0.1.40

package/dist/chimphands/run.js

@@ -11,17 +11,14 @@ import { URL } from "node:url";
 import { getBackendUrl, requireApiKey } from "../core/client.js";
 const ROLE_ASSISTANT = "CHIMPHANDS_MESSAGE_ROLE_ASSISTANT";
 const ROLE_TOOL = "CHIMPHANDS_MESSAGE_ROLE_TOOL";
+const ROLE_REASONING = "CHIMPHANDS_MESSAGE_ROLE_REASONING";
 const ROLE_STATUS = "CHIMPHANDS_MESSAGE_ROLE_STATUS";
 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 {
@@ -221,6 +218,21 @@ function runOpencode(prompt, model, childEnv, postEvent) {
                         postEvent(ROLE_ASSISTANT, next, undefined, opencodeMessageId("oc_text_", ev.part));
                         return;
                     }
+                    case "reasoning": {
+                        const chunk = ev.part?.text;
+                        if (!chunk)
+                            return;
+                        const partId = ev.part?.id || ev.part?.messageID;
+                        if (!partId) {
+                            postEvent(ROLE_REASONING, chunk);
+                            return;
+                        }
+                        const reasoningKey = `reasoning:${partId}`;
+                        const next = (textByPartId.get(reasoningKey) || "") + chunk;
+                        textByPartId.set(reasoningKey, next);
+                        postEvent(ROLE_REASONING, next, undefined, opencodeMessageId("oc_reasoning_", ev.part));
+                        return;
+                    }
                     case "tool_use": {
                         if (ev.part?.state?.status !== "completed")
                             return;
@@ -291,57 +303,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();
@@ -373,9 +411,41 @@ 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 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,
@@ -403,30 +473,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;
             }
@@ -435,7 +521,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}`);
@@ -468,6 +554,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.38",
+  "version": "0.1.40",
   "description": "TestChimp CLI and MCP server — coverage, plans, EaaS, TrueCoverage, API operations (calls /api/mcp/*)",
   "type": "module",
   "main": "dist/bin/testchimp.js",