@testchimp/cli 0.1.61 → 0.1.63

package/dist/chimphands/run.d.ts

@@ -19,6 +19,8 @@ type RunOptions = {
     runtimeId?: string;
 };
 export declare function runChimphands(opts: RunOptions): Promise<void>;
+/** OpenCode workspace-scoped APIs require directory routing (header + query). */
+export declare function appendOpencodeDirectoryRouting(path: string, query: string | undefined, headers: Record<string, string>, directory: string): string;
 /** Runtime-aware entry: register + attach to local OpenCode server (Phase 1+). */
 export declare function serveChimphands(opts: RunOptions & {
     attachUrl: string;

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.
@@ -1228,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) {
@@ -1409,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") {
@@ -1432,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 */
@@ -1643,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 {
@@ -1704,7 +1796,12 @@ 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 {
@@ -1733,14 +1830,21 @@ export async function runChimphands(opts) {
         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();
@@ -2018,9 +2122,32 @@ async function commitAndPushDirtyWorktree(message) {
         console.error(`ChimpHands commit-before-idle failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+function opencodeProxyNeedsDirectory(path) {
+    const p = path.startsWith("/") ? path : `/${path}`;
+    return (p.startsWith("/vcs") ||
+        p.startsWith("/file") ||
+        p.startsWith("/path") ||
+        p.startsWith("/session") ||
+        p.startsWith("/instance") ||
+        p.startsWith("/event") ||
+        p.startsWith("/global/event"));
+}
+/** OpenCode workspace-scoped APIs require directory routing (header + query). */
+export function appendOpencodeDirectoryRouting(path, query, headers, directory) {
+    if (!opencodeProxyNeedsDirectory(path)) {
+        return query || "";
+    }
+    headers["x-opencode-directory"] = directory;
+    if (query?.includes("directory=")) {
+        return query;
+    }
+    const dirParam = `directory=${encodeURIComponent(directory)}`;
+    return query ? `${query}&${dirParam}` : dirParam;
+}
 function startTunnelWorker(backend, apiKey, runtimeId, attachUrl, sessionId, handlers) {
     let stopped = false;
     const base = attachUrl.replace(/\/$/, "");
+    const workDirectory = process.cwd();
     let ws = null;
     let reconnectTimer = null;
     let backoffMs = 1000;
@@ -2036,8 +2163,10 @@ function startTunnelWorker(backend, apiKey, runtimeId, attachUrl, sessionId, han
         if (!req.requestId || socket.readyState !== 1)
             return;
         const requestId = req.requestId;
-        const target = base + (req.path || "/") + (req.query ? `?${req.query}` : "");
+        const pathPart = req.path || "/";
         const headers = { ...(req.headers || {}) };
+        const query = appendOpencodeDirectoryRouting(pathPart, req.query, headers, workDirectory);
+        const target = base + pathPart + (query ? `?${query}` : "");
         const init = { method: req.method || "GET", headers };
         if (req.bodyBase64) {
             init.body = Buffer.from(req.bodyBase64, "base64");
@@ -2154,9 +2283,22 @@ function startTunnelWorker(backend, apiKey, runtimeId, attachUrl, sessionId, han
                     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.61",
+  "version": "0.1.63",
   "description": "TestChimp CLI and MCP server — coverage, plans, EaaS, TrueCoverage, API operations (calls /api/mcp/*)",
   "type": "module",
   "main": "dist/bin/testchimp.js",