very-happy-cli 0.2.176 → 0.2.177

package/dist/{AcpBackend-9_ZI1Bv3.cjs → AcpBackend-B-ny68XM.cjs}

@@ -3,10 +3,11 @@
 var node_child_process = require('node:child_process');
 var sdk = require('@agentclientprotocol/sdk');
 var node_crypto = require('node:crypto');
-var logger = require('./logger-zoO54Zsy.cjs');
-var time = require('./time-s8CaneqW.cjs');
+var logger = require('./logger-LvwVeATU.cjs');
+var time = require('./time-Dg5tVB8S.cjs');
 var contentLogMetadata = require('./contentLogMetadata-ZSFk_NjQ.cjs');
-var _package = require('./package-A7zOGx8B.cjs');
+var processTree = require('./processTree-CMHWlVse.cjs');
+var _package = require('./package-Ch9WGDV_.cjs');
 
 function acpImageBlocks(attachments, supportsImages) {
   return attachments.filter((file) => ["image/jpeg", "image/png", "image/gif", "image/webp"].includes(file.mimeType)).map((file) => {
@@ -15,6 +16,19 @@ function acpImageBlocks(attachments, supportsImages) {
   });
 }
 
+function isAgentExitError(error) {
+  return error instanceof Error && error.agentExited === true;
+}
+function agentExitError(agentName, code, signal, tail) {
+  const exited = `${agentName} process exited (code=${code ?? "null"}${signal ? `, signal=${signal}` : ""})`;
+  return Object.assign(new Error(tail ? `${exited}: ${tail}` : exited), {
+    agentExited: true,
+    agentExitCode: code,
+    agentExitSignal: signal,
+    agentStderrTail: tail
+  });
+}
+
 const DEFAULT_TIMEOUTS = {
   /** Default initialization timeout: 60 seconds */
   init: 6e4,
@@ -187,6 +201,48 @@ function buildAcpPermissionMeta(toolCall) {
   return meta;
 }
 
+const PI_ACP_RETRY = /^Retrying(?: \(attempt \d+\/\d+, waiting \d+s\))?\.\.\.$/;
+const PI_ACP_RETRY_END = "Retry finished, resuming.";
+const PI_ACP_COMPACTION = "Context nearing limit, running automatic compaction...";
+const PI_ACP_COMPACTION_END = "Automatic compaction finished; context was summarized to continue the session.";
+const PI_ACP_UNSUPPORTED = /^Pi (input|editor) UI request is not supported in ACP yet; cancelling it\.$/;
+function notifyMeta(meta) {
+  if (!meta || typeof meta !== "object") return null;
+  const piAcp = meta.piAcp;
+  if (!piAcp || typeof piAcp !== "object") return null;
+  const notify = piAcp.notify;
+  if (!notify || typeof notify !== "object") return null;
+  const level = notify.level;
+  return { ...typeof level === "string" ? { level } : {} };
+}
+function classifyPiAcpNotice(text, meta) {
+  const notify = notifyMeta(meta);
+  if (notify) return { kind: "notify", text: text.trim(), ...notify.level ? { level: notify.level } : {} };
+  const trimmed = text.trim();
+  if (PI_ACP_RETRY.test(trimmed)) return { kind: "retry", text: trimmed };
+  if (trimmed === PI_ACP_RETRY_END) return { kind: "retry-end", text: trimmed };
+  if (trimmed === PI_ACP_COMPACTION) return { kind: "compaction", text: trimmed };
+  if (trimmed === PI_ACP_COMPACTION_END) return { kind: "compaction-end", text: trimmed };
+  if (PI_ACP_UNSUPPORTED.test(trimmed)) return { kind: "unsupported", text: trimmed };
+  return null;
+}
+function acpNoticeMessage(agentName, notice) {
+  switch (notice.kind) {
+    case "retry":
+      return `${agentName} is retrying the model request${notice.text.startsWith("Retrying (") ? ` ${notice.text.slice("Retrying ".length).replace(/\.\.\.$/, "")}` : ""}`;
+    case "retry-end":
+      return `${agentName} retry finished, resuming`;
+    case "compaction":
+      return `${agentName} is compacting its context (nearing the limit)`;
+    case "compaction-end":
+      return `${agentName} compacted its context; the session continues on a summary`;
+    case "unsupported":
+      return `${agentName}: ${notice.text}`;
+    case "notify":
+      return `${agentName}${notice.level && notice.level !== "info" ? ` ${notice.level}` : ""}: ${notice.text}`;
+  }
+}
+
 const DEFAULT_IDLE_TIMEOUT_MS = 500;
 const DEFAULT_TOOL_CALL_TIMEOUT_MS = 12e4;
 function parseArgsFromContent(content) {
@@ -240,6 +296,13 @@ function handleAgentMessageChunk(update, ctx) {
   if (typeof text !== "string") {
     return { handled: false };
   }
+  if (ctx.transport.agentName === "pi") {
+    const notice = classifyPiAcpNotice(text, update._meta);
+    if (notice) {
+      ctx.emit({ type: "event", name: "notice", payload: notice });
+      return { handled: true };
+    }
+  }
   const isThinking = /^\*\*[^*]+\*\*\n/.test(text);
   if (isThinking) {
     ctx.emit({
@@ -302,25 +365,6 @@ function startToolCall(toolCallId, toolKind, update, ctx, source) {
   if (isInvestigation) {
     logger.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool detected - extended timeout (10min) will be used`);
   }
-  const timeoutMs = ctx.transport.getToolCallTimeout?.(toolCallId, toolKindStr) ?? DEFAULT_TOOL_CALL_TIMEOUT_MS;
-  if (!ctx.toolCallTimeouts.has(toolCallId)) {
-    const timeout = setTimeout(() => {
-      const duration = formatDuration(ctx.toolCallStartTimes.get(toolCallId));
-      logger.logger.debug(`[AcpBackend] Tool call TIMEOUT (from ${source}): ${toolCallId} after ${(timeoutMs / 1e3).toFixed(0)}s - Duration: ${duration}, removing from active set`);
-      ctx.activeToolCalls.delete(toolCallId);
-      ctx.toolCallStartTimes.delete(toolCallId);
-      ctx.toolCallTimeouts.delete(toolCallId);
-      ctx.toolCallOutputs.delete(toolCallId);
-      if (ctx.activeToolCalls.size === 0) {
-        logger.logger.debug("[AcpBackend] No more active tool calls after timeout, emitting idle status");
-        ctx.emitIdleStatus();
-      }
-    }, timeoutMs);
-    ctx.toolCallTimeouts.set(toolCallId, timeout);
-    logger.logger.debug(`[AcpBackend] \u23F1\uFE0F Set timeout for ${toolCallId}: ${(timeoutMs / 1e3).toFixed(0)}s${isInvestigation ? " (investigation tool)" : ""}`);
-  } else {
-    logger.logger.debug(`[AcpBackend] Timeout already set for ${toolCallId}, skipping`);
-  }
   ctx.clearIdleTimeout();
   ctx.emit({ type: "status", status: "running" });
   const args = parseArgsFromContent(update.content);
@@ -633,6 +677,23 @@ class AcpBackend {
   toolCallCountSincePrompt = 0;
   /** Timeout for emitting 'idle' status after last message chunk */
   idleTimeout = null;
+  // B-629 (approach from Orca, src/main/acp/acp-agent-connection.ts): the agent process is
+  // part of the turn. Its last stderr lines are kept so its death can be explained, any exit
+  // (code or signal) is announced as `stopped`, and a request in flight when it dies rejects
+  // at once instead of waiting forever on a stream that will never answer.
+  /** Last stderr output of the agent process, bounded. */
+  stderrRing = "";
+  static STDERR_TAIL_CHARS = 2e3;
+  /** Set when the current agent process exited; the backend takes no further prompt. */
+  exited = null;
+  /** Rejects with the exit error when the current agent process exits (one per spawn). */
+  processGone = null;
+  /** Fails the request in flight (an oversized frame that was its answer, see MAX_FRAME_CHARS). */
+  inflightReject = null;
+  /** A single JSON-RPC line longer than this is dropped rather than buffered (Orca: 16 MiB). */
+  static MAX_FRAME_CHARS = 16 * 1024 * 1024;
+  /** How long the graceful stop gets on dispose before the process tree is killed. */
+  static DISPOSE_GRACE_MS = 4e3;
   /** Transport handler for agent-specific behavior */
   transport;
   onMessage(handler) {
@@ -644,6 +705,23 @@ class AcpBackend {
       this.listeners.splice(index, 1);
     }
   }
+  /** B-629: the agent's last stderr lines, one line, for a message a person reads. */
+  stderrTail() {
+    return processTree.readableStderrTail(this.stderrRing);
+  }
+  /** B-629: the agent process exited; this backend cannot take another prompt. */
+  get hasExited() {
+    return this.exited !== null;
+  }
+  /** B-629: a frame that cannot be read in full. One that answers a request fails that request. */
+  onOversizedFrame(head, chars) {
+    const looksLikeResponse = /"id"\s*:\s*\d+/.test(head) && /"(result|error)"\s*:/.test(head);
+    logger.logger.debug(`[AcpBackend] Dropped an oversized ${this.transport.agentName} frame (${Math.round(chars / 1024 / 1024)} MiB${looksLikeResponse ? ", a response" : ""})`);
+    if (!looksLikeResponse) return;
+    const error = new Error(`${this.transport.agentName} sent a ${Math.round(chars / 1024 / 1024)} MiB response frame that cannot be read; the turn was given up`);
+    this.inflightReject?.(error);
+    this.emit({ type: "status", status: "error", detail: error.message });
+  }
   emit(msg) {
     if (this.disposed) return;
     for (const listener of this.listeners) {
@@ -686,6 +764,15 @@ class AcpBackend {
       if (!this.process.stdin || !this.process.stdout || !this.process.stderr) {
         throw new Error("Failed to create stdio pipes");
       }
+      const child = this.process;
+      let rejectGone;
+      const processGone = new Promise((_, reject) => {
+        rejectGone = reject;
+      });
+      processGone.catch(() => void 0);
+      this.processGone = processGone;
+      this.exited = null;
+      this.stderrRing = "";
       let startupFailure = null;
       let startupFailureSettled = false;
       let rejectStartupFailure = null;
@@ -705,6 +792,9 @@ class AcpBackend {
       this.process.stderr.on("data", (data) => {
         const text = data.toString();
         if (!text.trim()) return;
+        if (this.process === child) {
+          this.stderrRing = processTree.appendStderrRing(this.stderrRing, text, AcpBackend.STDERR_TAIL_CHARS);
+        }
         const hasActiveInvestigation = this.transport.isInvestigationTool ? Array.from(this.activeToolCalls).some((id) => this.transport.isInvestigationTool(id)) : false;
         const context = {
           activeToolCalls: this.activeToolCalls,
@@ -728,10 +818,14 @@ class AcpBackend {
         this.emit({ type: "status", status: "error", detail: err.message });
       });
       this.process.on("exit", (code, signal) => {
-        if (!this.disposed && code !== 0 && code !== null) {
-          signalStartupFailure(new Error(`Exit code: ${code}`));
-          logger.logger.debug(`[AcpBackend] Process exited with code ${code}, signal ${signal}`);
-          this.emit({ type: "status", status: "stopped", detail: `Exit code: ${code}` });
+        const error = agentExitError(this.transport.agentName, code, signal, this.stderrTail());
+        setTimeout(() => rejectGone(error), 50);
+        if (this.process !== child) return;
+        this.exited = { code, signal, error };
+        signalStartupFailure(error);
+        logger.logger.debug(`[AcpBackend] Process exited with code ${code}, signal ${signal}`);
+        if (!this.disposed) {
+          this.emit({ type: "status", status: "stopped", detail: error.message });
         }
       });
       const streams = nodeToWebStreams(
@@ -741,6 +835,7 @@ class AcpBackend {
       const writable = streams.writable;
       const readable = streams.readable;
       const transport = this.transport;
+      const backend = this;
       const filteredReadable = new ReadableStream({
         async start(controller) {
           const reader = readable.getReader();
@@ -771,8 +866,18 @@ class AcpBackend {
               buffer += decoder.decode(value, { stream: true });
               const lines = buffer.split("\n");
               buffer = lines.pop() || "";
+              if (buffer.length > AcpBackend.MAX_FRAME_CHARS) {
+                backend.onOversizedFrame(buffer.slice(0, 200), buffer.length);
+                buffer = "";
+                filteredCount++;
+              }
               for (const line of lines) {
                 if (!line.trim()) continue;
+                if (line.length > AcpBackend.MAX_FRAME_CHARS) {
+                  backend.onOversizedFrame(line.slice(0, 200), line.length);
+                  filteredCount++;
+                  continue;
+                }
                 const filtered = transport.filterStdoutLine?.(line);
                 if (filtered === void 0) {
                   controller.enqueue(encoder.encode(line + "\n"));
@@ -1182,6 +1287,11 @@ class AcpBackend {
   get supportsImageAttachments() {
     return this.supportsImagePrompt;
   }
+  /**
+   * B-629: the turn is over when ACP's `prompt` answers (the agent sends every update before
+   * its response on the same ordered stream), never when the text goes quiet — the idle
+   * heuristic below is only a status hint now. Resolves with the agent's `stopReason`.
+   */
   async sendPrompt(sessionId, prompt, attachments = []) {
     const promptHasChangeTitle = this.options.hasChangeTitleInstruction?.(prompt) ?? false;
     this.toolCallCountSincePrompt = 0;
@@ -1192,11 +1302,18 @@ class AcpBackend {
     if (this.disposed) {
       throw new Error("Backend has been disposed");
     }
+    if (this.exited) {
+      throw this.exited.error;
+    }
     if (!this.connection || !this.acpSessionId) {
       throw new Error("Session not started");
     }
     this.emit({ type: "status", status: "running" });
     this.waitingForResponse = true;
+    const inflight = new Promise((_, reject) => {
+      this.inflightReject = reject;
+    });
+    inflight.catch(() => void 0);
     try {
       logger.logger.debug("[AcpBackend] Sending prompt:", {
         sessionId,
@@ -1214,14 +1331,21 @@ class AcpBackend {
         sessionId: this.acpSessionId,
         blockCount: promptRequest.prompt.length
       });
-      const response = await this.connection.prompt(promptRequest);
+      const response = await Promise.race([
+        this.connection.prompt(promptRequest),
+        this.processGone ?? new Promise(() => void 0),
+        inflight
+      ]);
       if (response.usage) {
         this.emit({ type: "token-count", ...response.usage });
       }
-      logger.logger.debug("[AcpBackend] Prompt request sent to ACP connection");
+      const stopReason = typeof response.stopReason === "string" ? response.stopReason : void 0;
+      logger.logger.debug(`[AcpBackend] Prompt answered (stopReason=${stopReason ?? "none"})`);
+      this.finishTurn();
+      return stopReason ? { stopReason } : {};
     } catch (error) {
       logger.logger.debug("[AcpBackend] Error sending prompt:", contentLogMetadata.errorLogMetadata(error));
-      this.waitingForResponse = false;
+      this.finishTurn(false);
       let errorDetail;
       if (error instanceof Error) {
         errorDetail = error.message;
@@ -1244,7 +1368,29 @@ class AcpBackend {
         detail: errorDetail
       });
       throw error;
+    } finally {
+      this.inflightReject = null;
+    }
+  }
+  /**
+   * B-629: the turn's bookkeeping ends with the prompt answer: no response is awaited any
+   * more, the idle timer and per-call timers are dropped, and the calls still marked active
+   * belong to a turn that is over. `idle` is emitted once for status listeners.
+   */
+  finishTurn(announceIdle = true) {
+    this.waitingForResponse = false;
+    if (this.idleTimeout) {
+      clearTimeout(this.idleTimeout);
+      this.idleTimeout = null;
+    }
+    for (const timeout of this.toolCallTimeouts.values()) {
+      clearTimeout(timeout);
     }
+    this.toolCallTimeouts.clear();
+    this.activeToolCalls.clear();
+    this.toolCallStartTimes.clear();
+    this.toolCallOutputs.clear();
+    if (announceIdle) this.emitIdleStatus();
   }
   /**
    * Set a session config option value.
@@ -1389,7 +1535,7 @@ class AcpBackend {
     if (this.disposed) return;
     logger.logger.debug("[AcpBackend] Disposing backend");
     this.disposed = true;
-    if (this.connection && this.acpSessionId) {
+    if (this.connection && this.acpSessionId && !this.exited) {
       try {
         await Promise.race([
           this.connection.cancel({ sessionId: this.acpSessionId }),
@@ -1401,16 +1547,19 @@ class AcpBackend {
       }
     }
     if (this.process) {
-      this.process.kill("SIGTERM");
+      const proc = this.process;
+      processTree.stopProcessGracefully(proc);
       await new Promise((resolve) => {
+        if (proc.exitCode != null || proc.signalCode != null) {
+          resolve();
+          return;
+        }
         const timeout = setTimeout(() => {
-          if (this.process) {
-            logger.logger.debug("[AcpBackend] Force killing process");
-            this.process.kill("SIGKILL");
-          }
+          logger.logger.debug("[AcpBackend] Force killing process tree");
+          processTree.killProcessTree(proc);
           resolve();
-        }, 1e3);
-        this.process?.once("exit", () => {
+        }, AcpBackend.DISPOSE_GRACE_MS);
+        proc.once("exit", () => {
           clearTimeout(timeout);
           resolve();
         });
@@ -1439,6 +1588,7 @@ exports.AcpBackend = AcpBackend;
 exports.DEFAULT_IDLE_TIMEOUT_MS = DEFAULT_IDLE_TIMEOUT_MS;
 exports.DEFAULT_TOOL_CALL_TIMEOUT_MS = DEFAULT_TOOL_CALL_TIMEOUT_MS;
 exports.DefaultTransport = DefaultTransport;
+exports.acpNoticeMessage = acpNoticeMessage;
 exports.extractErrorDetail = extractErrorDetail;
 exports.formatDuration = formatDuration;
 exports.formatDurationMinutes = formatDurationMinutes;
@@ -1449,4 +1599,5 @@ exports.handlePlanUpdate = handlePlanUpdate;
 exports.handleThinkingUpdate = handleThinkingUpdate;
 exports.handleToolCall = handleToolCall;
 exports.handleToolCallUpdate = handleToolCallUpdate;
+exports.isAgentExitError = isAgentExitError;
 exports.parseArgsFromContent = parseArgsFromContent;