@poncho-ai/cli 0.20.2 → 0.20.3

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @poncho-ai/cli@0.20.2 build /home/runner/work/poncho-ai/poncho-ai/packages/cli
+> @poncho-ai/cli@0.20.3 build /home/runner/work/poncho-ai/poncho-ai/packages/cli
 > tsup src/index.ts src/cli.ts --format esm --dts
 
 CLI Building entry: src/cli.ts, src/index.ts
@@ -8,11 +8,11 @@
 CLI Target: es2022
 ESM Build start
 ESM dist/cli.js                          94.00 B
+ESM dist/run-interactive-ink-JJDTHPM5.js 55.30 KB
 ESM dist/index.js                        857.00 B
-ESM dist/run-interactive-ink-2YFB7AEJ.js 55.30 KB
-ESM dist/chunk-VRLHV23J.js               384.02 KB
-ESM ⚡️ Build success in 62ms
+ESM dist/chunk-F4SLLHSH.js               384.50 KB
+ESM ⚡️ Build success in 50ms
 DTS Build start
-DTS ⚡️ Build success in 3793ms
+DTS ⚡️ Build success in 3455ms
 DTS dist/cli.d.ts   20.00 B
 DTS dist/index.d.ts 3.59 KB

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @poncho-ai/cli
 
+## 0.20.3
+
+### Patch Changes
+
+- [`9b38474`](https://github.com/cesr/poncho-ai/commit/9b38474a25bfb54cec108d1d3eae664aaed37ccf) Thanks [@cesr](https://github.com/cesr)! - Make approval resume robust: wrap in try/catch to always clear runStatus, and await the work when waitUntil is unavailable so the resume completes before the response is sent.
+
 ## 0.20.2
 
 ### Patch Changes

package/dist/{chunk-VRLHV23J.js → chunk-F4SLLHSH.js}

@@ -8608,48 +8608,60 @@ data: ${JSON.stringify(data)}
       await conversationStore.update(foundConversation);
       const checkpointRef = allApprovals[0];
       const resumeWork = (async () => {
-        const toolContext = {
-          runId: checkpointRef.runId,
-          agentId: identity.id,
-          step: 0,
-          workingDir,
-          parameters: {}
-        };
-        const approvalToolCallIds = new Set(allApprovals.map((a) => a.toolCallId));
-        const callsToExecute = [];
-        const deniedResults = [];
-        for (const a of allApprovals) {
-          if (a.decision === "approved" && a.toolCallId) {
-            callsToExecute.push({ id: a.toolCallId, name: a.tool, input: a.input });
-          } else if (a.decision === "denied" && a.toolCallId) {
-            deniedResults.push({ callId: a.toolCallId, toolName: a.tool, error: "Tool execution denied by user" });
-          }
-        }
-        const pendingToolCalls = checkpointRef.pendingToolCalls ?? [];
-        for (const tc of pendingToolCalls) {
-          if (!approvalToolCallIds.has(tc.id)) {
-            callsToExecute.push(tc);
-          }
-        }
-        let toolResults = [...deniedResults];
-        if (callsToExecute.length > 0) {
-          const execResults = await harness.executeTools(callsToExecute, toolContext);
-          toolResults.push(...execResults.map((r) => ({
-            callId: r.callId,
-            toolName: r.tool,
-            result: r.output,
-            error: r.error
-          })));
-        }
-        await resumeRunFromCheckpoint(
-          conversationId,
-          foundConversation,
-          checkpointRef,
-          toolResults
-        );
+        try {
+          const toolContext = {
+            runId: checkpointRef.runId,
+            agentId: identity.id,
+            step: 0,
+            workingDir,
+            parameters: {}
+          };
+          const approvalToolCallIds = new Set(allApprovals.map((a) => a.toolCallId));
+          const callsToExecute = [];
+          const deniedResults = [];
+          for (const a of allApprovals) {
+            if (a.decision === "approved" && a.toolCallId) {
+              callsToExecute.push({ id: a.toolCallId, name: a.tool, input: a.input });
+            } else if (a.decision === "denied" && a.toolCallId) {
+              deniedResults.push({ callId: a.toolCallId, toolName: a.tool, error: "Tool execution denied by user" });
+            }
+          }
+          const pendingToolCalls = checkpointRef.pendingToolCalls ?? [];
+          for (const tc of pendingToolCalls) {
+            if (!approvalToolCallIds.has(tc.id)) {
+              callsToExecute.push(tc);
+            }
+          }
+          let toolResults = [...deniedResults];
+          if (callsToExecute.length > 0) {
+            const execResults = await harness.executeTools(callsToExecute, toolContext);
+            toolResults.push(...execResults.map((r) => ({
+              callId: r.callId,
+              toolName: r.tool,
+              result: r.output,
+              error: r.error
+            })));
+          }
+          await resumeRunFromCheckpoint(
+            conversationId,
+            foundConversation,
+            checkpointRef,
+            toolResults
+          );
+        } catch (err) {
+          console.error("[approval-resume] failed:", err instanceof Error ? err.message : err);
+          const conv = await conversationStore.get(conversationId);
+          if (conv) {
+            conv.runStatus = "idle";
+            conv.updatedAt = Date.now();
+            await conversationStore.update(conv);
+          }
+        }
       })();
       if (waitUntilHook) {
         waitUntilHook(resumeWork);
+      } else {
+        await resumeWork;
       }
       writeJson(response, 200, { ok: true, approvalId, approved, batchComplete: true });
       return;
@@ -9679,7 +9691,7 @@ var runInteractive = async (workingDir, params) => {
   await harness.initialize();
   const identity = await ensureAgentIdentity2(workingDir);
   try {
-    const { runInteractiveInk } = await import("./run-interactive-ink-2YFB7AEJ.js");
+    const { runInteractiveInk } = await import("./run-interactive-ink-JJDTHPM5.js");
     await runInteractiveInk({
       harness,
       params,

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   main
-} from "./chunk-VRLHV23J.js";
+} from "./chunk-F4SLLHSH.js";
 
 // src/cli.ts
 void main();

package/dist/index.js

@@ -23,7 +23,7 @@ import {
   runTests,
   startDevServer,
   updateAgentGuidance
-} from "./chunk-VRLHV23J.js";
+} from "./chunk-F4SLLHSH.js";
 export {
   addSkill,
   buildCli,

package/dist/{run-interactive-ink-2YFB7AEJ.js → run-interactive-ink-JJDTHPM5.js}

@@ -2,7 +2,7 @@ import {
   consumeFirstRunIntro,
   inferConversationTitle,
   resolveHarnessEnvironment
-} from "./chunk-VRLHV23J.js";
+} from "./chunk-F4SLLHSH.js";
 
 // src/run-interactive-ink.ts
 import * as readline from "readline";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/cli",
-  "version": "0.20.2",
+  "version": "0.20.3",
   "description": "CLI for building and deploying AI agents",
   "repository": {
     "type": "git",
@@ -27,9 +27,9 @@
     "react": "^19.2.4",
     "react-devtools-core": "^6.1.5",
     "yaml": "^2.8.1",
-    "@poncho-ai/harness": "0.20.0",
+    "@poncho-ai/sdk": "1.4.0",
     "@poncho-ai/messaging": "0.2.7",
-    "@poncho-ai/sdk": "1.4.0"
+    "@poncho-ai/harness": "0.20.0"
   },
   "devDependencies": {
     "@types/busboy": "^1.5.4",

package/src/index.ts

@@ -2909,55 +2909,67 @@ export const createRequestHandler = async (options?: {
       const checkpointRef = allApprovals[0]!;
 
       const resumeWork = (async () => {
-        const toolContext = {
-          runId: checkpointRef.runId,
-          agentId: identity.id,
-          step: 0,
-          workingDir,
-          parameters: {},
-        };
+        try {
+          const toolContext = {
+            runId: checkpointRef.runId,
+            agentId: identity.id,
+            step: 0,
+            workingDir,
+            parameters: {},
+          };
 
-        // Collect tool calls to execute: approved approval-gated tools + auto-approved deferred tools
-        const approvalToolCallIds = new Set(allApprovals.map(a => a.toolCallId));
-        const callsToExecute: Array<{ id: string; name: string; input: Record<string, unknown> }> = [];
-        const deniedResults: Array<{ callId: string; toolName: string; error: string }> = [];
+          // Collect tool calls to execute: approved approval-gated tools + auto-approved deferred tools
+          const approvalToolCallIds = new Set(allApprovals.map(a => a.toolCallId));
+          const callsToExecute: Array<{ id: string; name: string; input: Record<string, unknown> }> = [];
+          const deniedResults: Array<{ callId: string; toolName: string; error: string }> = [];
 
-        for (const a of allApprovals) {
-          if (a.decision === "approved" && a.toolCallId) {
-            callsToExecute.push({ id: a.toolCallId, name: a.tool, input: a.input });
-          } else if (a.decision === "denied" && a.toolCallId) {
-            deniedResults.push({ callId: a.toolCallId, toolName: a.tool, error: "Tool execution denied by user" });
+          for (const a of allApprovals) {
+            if (a.decision === "approved" && a.toolCallId) {
+              callsToExecute.push({ id: a.toolCallId, name: a.tool, input: a.input });
+            } else if (a.decision === "denied" && a.toolCallId) {
+              deniedResults.push({ callId: a.toolCallId, toolName: a.tool, error: "Tool execution denied by user" });
+            }
           }
-        }
 
-        // Auto-approved tools that were deferred alongside the approval-needing ones
-        const pendingToolCalls = checkpointRef.pendingToolCalls ?? [];
-        for (const tc of pendingToolCalls) {
-          if (!approvalToolCallIds.has(tc.id)) {
-            callsToExecute.push(tc);
+          // Auto-approved tools that were deferred alongside the approval-needing ones
+          const pendingToolCalls = checkpointRef.pendingToolCalls ?? [];
+          for (const tc of pendingToolCalls) {
+            if (!approvalToolCallIds.has(tc.id)) {
+              callsToExecute.push(tc);
+            }
           }
-        }
 
-        let toolResults: Array<{ callId: string; toolName: string; result?: unknown; error?: string }> = [...deniedResults];
-        if (callsToExecute.length > 0) {
-          const execResults = await harness.executeTools(callsToExecute, toolContext);
-          toolResults.push(...execResults.map(r => ({
-            callId: r.callId,
-            toolName: r.tool,
-            result: r.output,
-            error: r.error,
-          })));
-        }
+          let toolResults: Array<{ callId: string; toolName: string; result?: unknown; error?: string }> = [...deniedResults];
+          if (callsToExecute.length > 0) {
+            const execResults = await harness.executeTools(callsToExecute, toolContext);
+            toolResults.push(...execResults.map(r => ({
+              callId: r.callId,
+              toolName: r.tool,
+              result: r.output,
+              error: r.error,
+            })));
+          }
 
-        await resumeRunFromCheckpoint(
-          conversationId,
-          foundConversation!,
-          checkpointRef,
-          toolResults,
-        );
+          await resumeRunFromCheckpoint(
+            conversationId,
+            foundConversation!,
+            checkpointRef,
+            toolResults,
+          );
+        } catch (err) {
+          console.error("[approval-resume] failed:", err instanceof Error ? err.message : err);
+          const conv = await conversationStore.get(conversationId);
+          if (conv) {
+            conv.runStatus = "idle";
+            conv.updatedAt = Date.now();
+            await conversationStore.update(conv);
+          }
+        }
       })();
       if (waitUntilHook) {
         waitUntilHook(resumeWork);
+      } else {
+        await resumeWork;
       }
 
       writeJson(response, 200, { ok: true, approvalId, approved, batchComplete: true });