@testchimp/cli 0.1.36 → 0.1.38

package/dist/chimphands/run.js

@@ -47,9 +47,14 @@ function postJsonFireAndForget(backend, apiKey, path, body) {
         console.error(`ChimpHands API telemetry failed ${path}: ${detail}`);
     });
 }
-function resolveOpencodeModel(boot) {
+const TESTCHIMP_PROVIDER_ID = "testchimp";
+function resolveOpencodeModelId(boot) {
     const raw = (boot.llm_model || "gpt-4o-mini").trim();
-    return raw.includes("/") ? raw : `openai/${raw}`;
+    const modelId = raw.includes("/") ? raw.split("/").pop() || "gpt-4o-mini" : raw;
+    return modelId;
+}
+function resolveOpencodeModel(boot) {
+    return `${TESTCHIMP_PROVIDER_ID}/${resolveOpencodeModelId(boot)}`;
 }
 function extractOpencodeFatalError(raw) {
     const line = raw.trim();
@@ -58,7 +63,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}`;
         }
@@ -69,12 +78,61 @@ function extractOpencodeFatalError(raw) {
     if (line.includes("Unexpected server error") && line.includes("UnknownError")) {
         return line;
     }
+    const errorLine = line.match(/^Error:\s*(.+)$/i);
+    if (errorLine?.[1]?.trim()) {
+        return errorLine[1].trim();
+    }
+    if (/not found/i.test(line) && line.length < 240) {
+        return line.trim();
+    }
     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")) {
+            const fatal = extractOpencodeFatalError(line);
+            if (fatal)
+                return fatal;
+        }
+    }
+    const merged = `${stderr}\n${stdout}`.trim();
+    if (merged) {
+        const errorLines = merged
+            .split("\n")
+            .map((l) => l.trim())
+            .filter((l) => /^error:/i.test(l) || /not found/i.test(l));
+        if (errorLines.length)
+            return errorLines[errorLines.length - 1].replace(/^error:\s*/i, "").trim();
+        return merged.slice(0, 1200);
+    }
+    return exitCode ? `opencode exited with code ${exitCode}` : "opencode failed";
+}
 function writeOpencodeConfig(backend, apiKey, boot) {
     const llmBase = (boot.llm_base_url || `${backend}/v1`).replace(/\/$/, "");
     const llmKey = apiKey || boot.llm_api_key || "";
-    const model = resolveOpencodeModel(boot);
+    const modelId = resolveOpencodeModelId(boot);
+    const model = `${TESTCHIMP_PROVIDER_ID}/${modelId}`;
     const mcpEnv = {
         TESTCHIMP_API_KEY: apiKey,
         TESTCHIMP_BACKEND_URL: backend,
@@ -87,13 +145,19 @@ function writeOpencodeConfig(backend, apiKey, boot) {
         $schema: "https://opencode.ai/config.json",
         model,
         autoupdate: false,
-        enabled_providers: ["openai"],
         provider: {
-            openai: {
+            [TESTCHIMP_PROVIDER_ID]: {
+                npm: "@ai-sdk/openai-compatible",
+                name: "TestChimp",
                 options: {
                     apiKey: llmKey,
                     baseURL: llmBase,
                 },
+                models: {
+                    [modelId]: {
+                        name: modelId,
+                    },
+                },
             },
         },
         mcp: {
@@ -130,41 +194,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)
@@ -173,6 +261,10 @@ function runOpencode(prompt, model, childEnv, postEvent) {
                     resolve({ code: 1, err: fatalError });
                     return;
                 }
+                if (code != null && code !== 0) {
+                    resolve({ code, err: summarizeOpencodeFailure(err, buf, code) });
+                    return;
+                }
                 resolve({ code: code == null ? 1 : code, err });
             });
         });
@@ -195,11 +287,7 @@ function runOpencode(prompt, model, childEnv, postEvent) {
         const errObj = e;
         const stderr = errObj.stderr?.toString() || "";
         const stdout = errObj.stdout?.toString() || "";
-        const fatal = extractOpencodeFatalError(stderr) ||
-            extractOpencodeFatalError(stdout) ||
-            stderr ||
-            errObj.message ||
-            "opencode failed";
+        const fatal = summarizeOpencodeFailure(stderr, stdout, errObj.status ?? 1);
         return Promise.resolve({ code: errObj.status || 1, err: fatal });
     }
 }
@@ -288,12 +376,14 @@ export async function runChimphands(opts) {
     let idle = false;
     let closed = false;
     let lastUserActivity = Date.now();
-    const postEvent = (role, content, status) => {
+    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);
@@ -347,10 +437,29 @@ export async function runChimphands(opts) {
     while (prompt) {
         const result = await runOpencode(ensureTestchimpPrompt(prompt), opencodeModel, childEnv, postEvent);
         if (result.code !== 0) {
-            const errMsg = result.err || "opencode failed";
+            const errMsg = (result.err || "opencode failed").trim() || "opencode failed";
             console.error(`ChimpHands OpenCode failed: ${errMsg}`);
-            postEvent(ROLE_STATUS, errMsg, STATUS_FAILED);
-            complete(STATUS_FAILED, errMsg);
+            try {
+                await postJson(backend, apiKey, "/api/chimphands/post_agent_event", {
+                    sessionId,
+                    role: ROLE_STATUS,
+                    content: errMsg,
+                    status: STATUS_FAILED,
+                    githubRunId: githubRunId || undefined,
+                });
+                await postJson(backend, apiKey, "/api/chimphands/complete_session", {
+                    sessionId,
+                    status: STATUS_FAILED,
+                    errorMessage: errMsg,
+                    githubRunId: githubRunId || undefined,
+                });
+            }
+            catch (reportErr) {
+                const detail = reportErr instanceof Error ? reportErr.message : String(reportErr);
+                console.error(`ChimpHands failed to report OpenCode error to backend: ${detail}`);
+                postEvent(ROLE_STATUS, errMsg, STATUS_FAILED);
+                complete(STATUS_FAILED, errMsg);
+            }
             process.exit(result.code || 1);
         }
         postEvent(ROLE_STATUS, "Waiting for user input", STATUS_WAITING_USER);

package/package.json

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