@testchimp/cli 0.1.60 → 0.1.62

package/dist/chimphands/run.js

@@ -168,6 +168,8 @@ class AgentEventPoster {
             body.workingBranch = opts.workingBranch;
         if (opts?.pullRequestUrl)
             body.pullRequestUrl = opts.pullRequestUrl;
+        if (opts?.toolExecution)
+            body.toolExecution = opts.toolExecution;
         const streamRole = isStreamFanoutRole(role);
         this.chain = this.chain.then(async () => {
             const live = !!opts?.liveStream && !opts?.durable;
@@ -193,6 +195,8 @@ class AgentEventPoster {
                     eph.messageId = opts.messageId;
                 if (opts?.opencodeSessionId)
                     eph.opencodeSessionId = opts.opencodeSessionId;
+                if (opts?.toolExecution)
+                    eph.toolExecution = opts.toolExecution;
                 try {
                     await postJson(this.backend, this.apiKey, "/api/chimphands/post_ephemeral_agent_event", eph);
                     this.ephemeralFailCount = 0;
@@ -282,6 +286,62 @@ function extractOpencodeFatalError(raw) {
     }
     return null;
 }
+const TOOL_STATUS_RUNNING = "CHIMPHANDS_TOOL_EXECUTION_STATUS_RUNNING";
+const TOOL_STATUS_PENDING = "CHIMPHANDS_TOOL_EXECUTION_STATUS_PENDING";
+const TOOL_STATUS_COMPLETED = "CHIMPHANDS_TOOL_EXECUTION_STATUS_COMPLETED";
+const TOOL_STATUS_ERROR = "CHIMPHANDS_TOOL_EXECUTION_STATUS_ERROR";
+function normalizeEpochMillis(raw) {
+    if (raw == null || !Number.isFinite(raw) || raw <= 0)
+        return undefined;
+    // OpenCode uses epoch millis; guard seconds.
+    return raw < 1_000_000_000_000 ? Math.round(raw * 1000) : Math.round(raw);
+}
+function coerceTimeoutMillis(input) {
+    if (!input)
+        return undefined;
+    const raw = input.timeout ?? input.timeoutMs ?? input.timeout_ms;
+    const n = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : NaN;
+    if (!Number.isFinite(n) || n <= 0)
+        return undefined;
+    return Math.round(n);
+}
+function mapToolExecutionStatus(status) {
+    const s = String(status || "").trim().toLowerCase();
+    if (!s)
+        return undefined;
+    if (s === "pending")
+        return TOOL_STATUS_PENDING;
+    if (s === "running")
+        return TOOL_STATUS_RUNNING;
+    if (s === "completed")
+        return TOOL_STATUS_COMPLETED;
+    if (s === "error" || s === "failed" || s === "cancelled")
+        return TOOL_STATUS_ERROR;
+    return undefined;
+}
+function toolExecutionFromOpencodePart(part) {
+    const status = mapToolExecutionStatus(part.state?.status);
+    if (!status)
+        return undefined;
+    const startedAtMillis = normalizeEpochMillis(part.state?.time?.start) ??
+        (status === TOOL_STATUS_RUNNING ? Date.now() : undefined);
+    const endedAtMillis = normalizeEpochMillis(part.state?.time?.end);
+    const toolName = String(part.state?.title || part.tool || "").trim() || undefined;
+    const timeoutMillis = coerceTimeoutMillis(part.state?.input);
+    return {
+        status,
+        toolName,
+        startedAtMillis,
+        timeoutMillis,
+        endedAtMillis,
+    };
+}
+function toolEventOptions(part, extra) {
+    const toolExecution = toolExecutionFromOpencodePart(part);
+    if (!toolExecution)
+        return extra ?? {};
+    return { ...extra, toolExecution };
+}
 /**
  * OpenCode `message.part.delta` always sends `field: "text"` for both reasoning and
  * answer parts. Resolve kind from partID → type learned via `message.part.updated`.
@@ -482,9 +542,9 @@ async function reconcileOpencodeSessionMessages(attachUrl, opencodeSessionId, po
                 if (!status || status === "pending" || status === "running")
                     continue;
                 const toolContent = formatToolUseContent(part);
-                postEvent(ROLE_TOOL, toolContent, {
+                postEvent(ROLE_TOOL, toolContent, toolEventOptions(part, {
                     messageId: opencodeMessageId("oc_tool_", part),
-                });
+                }));
                 posted += 1;
                 if (status === "completed") {
                     const detected = detectWorkingBranchFromToolOutput(toolContent);
@@ -663,17 +723,17 @@ function startOpencodeSseRelay(attachUrl, callbacks) {
                 // Ephemeral "(running)" bubbles while UI attached (liveStream gated in poster).
                 if (status === "running") {
                     const toolContent = formatToolUseContent(part);
-                    callbacks.postEvent(ROLE_TOOL, toolContent, liveOpts({
+                    callbacks.postEvent(ROLE_TOOL, toolContent, toolEventOptions(part, liveOpts({
                         messageId: opencodeMessageId("oc_tool_", part),
                         throttle: false,
-                    }));
+                    })));
                     return;
                 }
                 const toolContent = formatToolUseContent(part);
-                callbacks.postEvent(ROLE_TOOL, toolContent, liveOpts({
+                callbacks.postEvent(ROLE_TOOL, toolContent, toolEventOptions(part, liveOpts({
                     messageId: opencodeMessageId("oc_tool_", part),
                     throttle: false,
-                }));
+                })));
                 if (status === "completed") {
                     const detected = detectWorkingBranchFromToolOutput(toolContent);
                     if (detected.branch) {
@@ -946,6 +1006,35 @@ function writeOpencodeConfig(backend, apiKey, boot) {
     }, null, 2));
     return model;
 }
+/** Abort in-flight tool/LLM work on the local OpenCode server (attach mode). */
+async function abortOpencodeSession(attachUrl, opencodeSessionId) {
+    const base = attachUrl.replace(/\/$/, "");
+    const url = `${base}/session/${encodeURIComponent(opencodeSessionId)}/abort`;
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                Accept: "application/json",
+                "x-opencode-directory": process.cwd(),
+            },
+        });
+        console.error(`ChimpHands OpenCode session abort: session=${opencodeSessionId} http=${res.status}`);
+    }
+    catch (err) {
+        console.error(`ChimpHands OpenCode session abort failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function parseInboundUserMessage(data) {
+    if (!data || typeof data !== "object")
+        return null;
+    const msg = data;
+    const content = typeof msg.content === "string" ? msg.content : "";
+    const idRaw = (typeof msg.id === "string" && msg.id) ||
+        (typeof msg.message_id === "string" && msg.message_id) ||
+        (typeof msg.messageId === "string" && msg.messageId) ||
+        "";
+    return { id: idRaw || undefined, content };
+}
 function buildOpencodeArgs(prompt, model, opencodeSessionId, attachUrl) {
     // --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.
@@ -1081,6 +1170,34 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
         const textByPartId = new Map();
         const partTypeById = new Map();
         let sawStdout = false;
+        let cancelEscalationTimer = null;
+        let cancelWatcher = null;
+        const clearCancelWatcher = () => {
+            if (cancelWatcher) {
+                clearInterval(cancelWatcher);
+                cancelWatcher = null;
+            }
+            if (cancelEscalationTimer) {
+                clearTimeout(cancelEscalationTimer);
+                cancelEscalationTimer = null;
+            }
+        };
+        const killActiveChild = (signal) => {
+            try {
+                if (!child.killed)
+                    child.kill(signal);
+            }
+            catch {
+                /* ignore */
+            }
+        };
+        cancelWatcher = setInterval(() => {
+            if (!callbacks.getCancelRequested?.())
+                return;
+            clearCancelWatcher();
+            killActiveChild("SIGTERM");
+            cancelEscalationTimer = setTimeout(() => killActiveChild("SIGKILL"), 2000);
+        }, 500);
         let progressTicker = setInterval(() => {
             if (sawStdout) {
                 if (progressTicker) {
@@ -1200,9 +1317,9 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
                     if (!status || status === "pending" || status === "running")
                         return;
                     const toolContent = formatToolUseContent(ev.part);
-                    callbacks.postEvent(ROLE_TOOL, toolContent, {
+                    callbacks.postEvent(ROLE_TOOL, toolContent, toolEventOptions(ev.part, {
                         messageId: opencodeMessageId("oc_tool_", ev.part),
-                    });
+                    }));
                     if (status === "completed") {
                         const detected = detectWorkingBranchFromToolOutput(toolContent);
                         if (detected.branch) {
@@ -1236,6 +1353,7 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
         });
         child.on("close", (code) => {
             callbacks.onActiveChild?.(null);
+            clearCancelWatcher();
             if (progressTicker) {
                 clearInterval(progressTicker);
                 progressTicker = null;
@@ -1380,6 +1498,7 @@ function connectInboundStream(backend, apiKey, sessionId, handlers) {
                             catch {
                                 /* ignore malformed payload */
                             }
+                            console.error(`ChimpHands inbound SSE cancel_turn for session ${sessionId}`);
                             handlers.onCancelTurn?.();
                         }
                         else if (eventName === "user_file_edit") {
@@ -1403,11 +1522,11 @@ function connectInboundStream(backend, apiKey, sessionId, handlers) {
                         }
                         else if (eventName === "user_message" || eventName === "message") {
                             try {
-                                const msg = JSON.parse(data);
-                                handlers.onUserMessage({
-                                    id: msg.id || msg.message_id,
-                                    content: msg.content || "",
-                                });
+                                const msg = parseInboundUserMessage(JSON.parse(data));
+                                if (!msg)
+                                    continue;
+                                console.error(`ChimpHands inbound SSE user_message for session ${sessionId}`);
+                                handlers.onUserMessage(msg);
                             }
                             catch {
                                 /* ignore */
@@ -1614,6 +1733,8 @@ export async function runChimphands(opts) {
         queue.push(content);
         lastUserActivity = Date.now();
         idle = false;
+        const preview = content.length > 120 ? `${content.slice(0, 117)}...` : content;
+        console.error(`ChimpHands queued user message (turnActive=${agentTurnInProgress}, depth=${queue.length}): ${JSON.stringify(preview)}`);
     };
     const pollPendingUserMessages = async () => {
         try {
@@ -1674,33 +1795,56 @@ export async function runChimphands(opts) {
     };
     if (userId)
         childEnv.TESTCHIMP_USER_ID = userId;
+    const handleCancelTurn = () => {
+        console.error(`ChimpHands cancel_turn received for session ${sessionId}`);
+        cancelTurnRequested = true;
+        const sessionToAbort = opencodeSessionId?.trim();
+        if (attachUrl && sessionToAbort) {
+            void abortOpencodeSession(attachUrl, sessionToAbort);
+        }
+        const ch = activeOpencodeChild;
+        if (ch && !ch.killed) {
+            try {
+                ch.kill("SIGTERM");
+                setTimeout(() => {
+                    try {
+                        if (!ch.killed)
+                            ch.kill("SIGKILL");
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }, 2000);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    };
     const stopInbound = connectInboundStream(backend, apiKey, sessionId, {
         onUserMessage: enqueueUserMessage,
         onIdle: () => {
             idle = true;
         },
-        onCancelTurn: () => {
-            cancelTurnRequested = true;
-            const ch = activeOpencodeChild;
-            if (ch && !ch.killed) {
-                try {
-                    ch.kill("SIGTERM");
-                }
-                catch {
-                    /* ignore */
-                }
-            }
-        },
+        onCancelTurn: handleCancelTurn,
         onUserFileEdit: handleUserFileEdit,
         shouldRun: () => sessionActive,
     });
+    const inboundPollTimer = setInterval(() => {
+        if (!sessionActive)
+            return;
+        void pollPendingUserMessages();
+    }, 1500);
     if (runtimeId && attachUrl) {
         stopTunnel = startTunnelWorker(backend, apiKey, runtimeId, attachUrl, sessionId, {
             onUserFileEdit: handleUserFileEdit,
+            onCancelTurn: handleCancelTurn,
+            onUserMessage: enqueueUserMessage,
         });
     }
     const shutdownRuntime = async () => {
         sessionActive = false;
+        clearInterval(inboundPollTimer);
         stopInbound();
         stopTunnel();
         stopHeartbeat();
@@ -2109,6 +2253,27 @@ function startTunnelWorker(backend, apiKey, runtimeId, attachUrl, sessionId, han
                     socket.send(JSON.stringify({ type: "pong" }));
                     return;
                 }
+                if (frame.type === "inbound_event" && frame.event === "cancel_turn") {
+                    const payload = frame.data;
+                    if (payload?.sessionId && payload.sessionId !== sessionId) {
+                        return;
+                    }
+                    console.error(`ChimpHands tunnel cancel_turn for session ${sessionId}`);
+                    handlers?.onCancelTurn?.();
+                    return;
+                }
+                if (frame.type === "inbound_event" && frame.event === "user_message" && frame.data) {
+                    const payload = frame.data;
+                    if (payload?.sessionId && payload.sessionId !== sessionId) {
+                        return;
+                    }
+                    const msg = parseInboundUserMessage(frame.data);
+                    if (msg) {
+                        console.error(`ChimpHands tunnel user_message for session ${sessionId}`);
+                        handlers?.onUserMessage?.(msg);
+                    }
+                    return;
+                }
                 if (frame.type === "inbound_event" && frame.event === "user_file_edit" && frame.data) {
                     const edit = frame.data;
                     if (edit.sessionId && edit.sessionId !== sessionId) {

package/package.json

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