@adhdev/daemon-core 0.6.56 → 0.6.57

package/dist/index.d.ts

@@ -2664,6 +2664,11 @@ declare class ProviderCliAdapter implements CliAdapter {
     private settleTimer;
     private settledBuffer;
     private submitPendingUntil;
+    private responseSettleIgnoreUntil;
+    private responseEpoch;
+    private submitRetryTimer;
+    private submitRetryUsed;
+    private submitRetryPromptSnippet;
     private resizeSuppressUntil;
     private statusHistory;
     private cliScripts;
@@ -2689,6 +2694,7 @@ declare class ProviderCliAdapter implements CliAdapter {
     spawn(): Promise<void>;
     private handleOutput;
     private scheduleSettle;
+    private armApprovalExitTimeout;
     private evaluateSettled;
     private finishResponse;
     private runDetectStatus;

package/dist/index.js

@@ -718,6 +718,38 @@ function shSingleQuote(arg) {
   if (/^[a-zA-Z0-9@%_+=:,./-]+$/.test(arg)) return arg;
   return `'${arg.replace(/'/g, `'\\''`)}'`;
 }
+function estimatePromptDisplayLines(text, cols = 100) {
+  const normalized = String(text || "").replace(/\r/g, "");
+  if (!normalized) return 1;
+  return normalized.split("\n").reduce((sum, line) => sum + Math.max(1, Math.ceil(Math.max(1, line.length) / cols)), 0);
+}
+function extractPromptRetrySnippet(text) {
+  const lines = String(text || "").replace(/\r/g, "").split("\n").map((line) => line.trim()).filter(Boolean);
+  const candidate = lines[lines.length - 1] || lines[0] || "";
+  return candidate.slice(-120);
+}
+function normalizePromptText(text) {
+  return String(text || "").replace(/\s+/g, " ").trim();
+}
+function compactPromptText(text) {
+  return String(text || "").replace(/\s+/g, "").trim();
+}
+function promptLikelyVisible(screenText, promptSnippet) {
+  const snippet = normalizePromptText(promptSnippet);
+  if (!snippet) return false;
+  const normalizedScreen = normalizePromptText(screenText);
+  if (normalizedScreen.includes(snippet)) return true;
+  const compactScreen = compactPromptText(screenText);
+  const compactSnippet = compactPromptText(promptSnippet);
+  if (compactSnippet && compactScreen.includes(compactSnippet)) return true;
+  const tokens = snippet.split(/[^A-Za-z0-9_.:/-]+/).map((token) => token.trim()).filter((token) => token.length >= 4);
+  if (tokens.length === 0) return false;
+  const required = Math.min(tokens.length, 3);
+  const matched = tokens.filter(
+    (token) => normalizedScreen.includes(token) || compactScreen.includes(compactPromptText(token))
+  ).length;
+  return matched >= required;
+}
 function parsePatternEntry(x) {
   if (x instanceof RegExp) return x;
   if (x && typeof x === "object" && typeof x.source === "string") {
@@ -837,6 +869,11 @@ var init_provider_cli_adapter = __esm({
       settleTimer = null;
       settledBuffer = "";
       submitPendingUntil = 0;
+      responseSettleIgnoreUntil = 0;
+      responseEpoch = 0;
+      submitRetryTimer = null;
+      submitRetryUsed = false;
+      submitRetryPromptSnippet = "";
       // Resize redraw suppression
       resizeSuppressUntil = 0;
       // Debug: status transition history
@@ -960,7 +997,7 @@ var init_provider_cli_adapter = __esm({
         this.startupParseGate = true;
         this.startupBuffer = "";
         this.terminalScreen.reset(40, 120);
-        this.ready = true;
+        this.ready = false;
         this.setStatus("idle", "pty_ready");
         this.onStatusChange?.();
       }
@@ -1005,7 +1042,9 @@ var init_provider_cli_adapter = __esm({
           const isReady = scriptStatus === "idle" || elapsed > 8e3 || bufCap;
           if (isReady) {
             this.startupParseGate = false;
+            this.ready = true;
             LOG.info("CLI", `[${this.cliType}] Startup gate end (${elapsed}ms, scriptStatus=${scriptStatus})`);
+            this.onStatusChange?.();
           } else {
             return;
           }
@@ -1014,19 +1053,45 @@ var init_provider_cli_adapter = __esm({
       }
       scheduleSettle() {
         if (this.settleTimer) clearTimeout(this.settleTimer);
+        const settleEpoch = this.responseEpoch;
         const delay = Math.max(
           this.timeouts.outputSettle,
           this.submitPendingUntil > Date.now() ? this.submitPendingUntil - Date.now() + this.timeouts.outputSettle : 0
         );
         this.settleTimer = setTimeout(() => {
           this.settleTimer = null;
+          if (settleEpoch !== this.responseEpoch) return;
           this.settledBuffer = this.recentOutputBuffer;
           this.evaluateSettled();
         }, delay);
       }
+      armApprovalExitTimeout() {
+        if (this.approvalExitTimeout) clearTimeout(this.approvalExitTimeout);
+        this.approvalExitTimeout = setTimeout(() => {
+          if (this.currentStatus !== "waiting_approval") return;
+          const tail = this.recentOutputBuffer;
+          const modal = this.runParseApproval(tail);
+          const stillWaiting = this.runDetectStatus(tail) === "waiting_approval" || !!modal;
+          if (stillWaiting) {
+            this.activeModal = modal || this.activeModal || { message: "Approval required", buttons: ["Allow", "Deny"] };
+            this.onStatusChange?.();
+            this.armApprovalExitTimeout();
+            return;
+          }
+          LOG.warn("CLI", `[${this.cliType}] Approval timeout \u2014 auto-clearing`);
+          this.activeModal = null;
+          this.lastApprovalResolvedAt = Date.now();
+          this.setStatus("idle", "approval_timeout");
+          this.onStatusChange?.();
+        }, 6e4);
+      }
       evaluateSettled() {
+        if (this.submitPendingUntil > Date.now()) return;
+        if (this.responseSettleIgnoreUntil > Date.now()) return;
         const tail = this.settledBuffer;
-        const scriptStatus = this.runDetectStatus(tail);
+        const modal = this.runParseApproval(tail);
+        const rawScriptStatus = this.runDetectStatus(tail);
+        const scriptStatus = rawScriptStatus === "waiting_approval" || modal ? "waiting_approval" : rawScriptStatus;
         if (!scriptStatus) return;
         const prevStatus = this.currentStatus;
         if (scriptStatus === "waiting_approval") {
@@ -1034,19 +1099,9 @@ var init_provider_cli_adapter = __esm({
           if (!inCooldown) {
             this.isWaitingForResponse = true;
             this.setStatus("waiting_approval", "script_detect");
-            const modal = this.runParseApproval(tail);
             this.activeModal = modal || { message: "Approval required", buttons: ["Allow", "Deny"] };
             if (this.idleTimeout) clearTimeout(this.idleTimeout);
-            if (this.approvalExitTimeout) clearTimeout(this.approvalExitTimeout);
-            this.approvalExitTimeout = setTimeout(() => {
-              if (this.currentStatus === "waiting_approval") {
-                LOG.warn("CLI", `[${this.cliType}] Approval timeout \u2014 auto-clearing`);
-                this.activeModal = null;
-                this.lastApprovalResolvedAt = Date.now();
-                this.setStatus("idle", "approval_timeout");
-                this.onStatusChange?.();
-              }
-            }, 6e4);
+            this.armApprovalExitTimeout();
             this.onStatusChange?.();
             return;
           }
@@ -1082,7 +1137,12 @@ var init_provider_cli_adapter = __esm({
             this.lastApprovalResolvedAt = Date.now();
           }
           if (this.isWaitingForResponse) {
-            this.finishResponse();
+            if (this.idleTimeout) clearTimeout(this.idleTimeout);
+            this.idleTimeout = setTimeout(() => {
+              if (this.isWaitingForResponse && this.currentStatus !== "waiting_approval") {
+                this.finishResponse();
+              }
+            }, this.timeouts.idleFinish);
           } else if (prevStatus !== "idle") {
             this.setStatus("idle", "script_detect");
             this.onStatusChange?.();
@@ -1090,6 +1150,8 @@ var init_provider_cli_adapter = __esm({
         }
       }
       finishResponse() {
+        if (this.submitPendingUntil > Date.now()) return;
+        if (this.responseSettleIgnoreUntil > Date.now()) return;
         if (this.responseTimeout) {
           clearTimeout(this.responseTimeout);
           this.responseTimeout = null;
@@ -1102,8 +1164,15 @@ var init_provider_cli_adapter = __esm({
           clearTimeout(this.approvalExitTimeout);
           this.approvalExitTimeout = null;
         }
+        if (this.submitRetryTimer) {
+          clearTimeout(this.submitRetryTimer);
+          this.submitRetryTimer = null;
+        }
         this.responseBuffer = "";
         this.isWaitingForResponse = false;
+        this.responseSettleIgnoreUntil = 0;
+        this.submitRetryUsed = false;
+        this.submitRetryPromptSnippet = "";
         this.activeModal = null;
         this.setStatus("idle", "response_finished");
         this.onStatusChange?.();
@@ -1218,29 +1287,95 @@ ${data.message || ""}`.trim();
       }
       async sendMessage(text) {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
+        if (this.startupParseGate) {
+          const deadline = Date.now() + 1e4;
+          while (this.startupParseGate && Date.now() < deadline) {
+            await new Promise((resolve8) => setTimeout(resolve8, 50));
+          }
+        }
         if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.currentStatus})`);
         if (this.isWaitingForResponse) return;
         this.messages.push({ role: "user", content: text, timestamp: Date.now() });
         this.structuredMessages.push({ role: "user", content: text, timestamp: Date.now() });
         this.isWaitingForResponse = true;
         this.responseBuffer = "";
+        this.submitRetryUsed = false;
+        this.submitRetryPromptSnippet = extractPromptRetrySnippet(text);
+        const normalizedPromptSnippet = normalizePromptText(this.submitRetryPromptSnippet);
+        if (this.submitRetryTimer) {
+          clearTimeout(this.submitRetryTimer);
+          this.submitRetryTimer = null;
+        }
+        const estimatedLines = estimatePromptDisplayLines(text);
+        const submitDelayMs = this.sendDelayMs + Math.min(2e3, Math.max(0, estimatedLines - 1) * 350);
+        const maxEchoWaitMs = submitDelayMs + Math.max(1500, Math.min(5e3, estimatedLines * 500));
+        const retryDelayMs = Math.max(350, Math.min(1500, Math.max(this.sendDelayMs, submitDelayMs)));
+        if (this.settleTimer) {
+          clearTimeout(this.settleTimer);
+          this.settleTimer = null;
+        }
+        this.responseEpoch += 1;
+        this.responseSettleIgnoreUntil = Date.now() + submitDelayMs + this.timeouts.outputSettle + 250;
         this.setStatus("generating", "sendMessage");
         this.onStatusChange?.();
+        if (submitDelayMs > 0) {
+          this.submitPendingUntil = Date.now() + submitDelayMs;
+        }
         this.ptyProcess.write(text);
         const submit = () => {
           if (!this.ptyProcess) return;
           this.submitPendingUntil = 0;
           this.ptyProcess.write(this.sendKey);
+          const retrySubmitIfStuck = (attempt) => {
+            this.submitRetryTimer = null;
+            if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
+            if (this.currentStatus !== "generating") return;
+            if ((this.responseBuffer || "").trim()) return;
+            const screenText = this.terminalScreen.getText();
+            if (!promptLikelyVisible(screenText, normalizedPromptSnippet)) return;
+            if (/Esc to interrupt|Do you want to proceed|This command requires approval|Allow Codex to|Approve and run now|Always approve this session|Running…|Running\.\.\./i.test(screenText)) return;
+            this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
+            LOG.info("CLI", `[${this.cliType}] Retrying submit key for stuck prompt (attempt ${attempt})`);
+            this.ptyProcess.write(this.sendKey);
+            if (attempt >= 3) {
+              this.submitRetryUsed = true;
+              return;
+            }
+            this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(attempt + 1), retryDelayMs);
+          };
+          this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(1), retryDelayMs);
           this.responseTimeout = setTimeout(() => {
             if (this.isWaitingForResponse) this.finishResponse();
           }, this.timeouts.maxResponse);
         };
-        if (this.sendDelayMs > 0) {
-          this.submitPendingUntil = Date.now() + this.sendDelayMs;
-          setTimeout(submit, this.sendDelayMs);
-        } else {
-          submit();
-        }
+        const submitStartedAt = Date.now();
+        let lastNormalizedScreen = "";
+        let lastScreenChangeAt = submitStartedAt;
+        const waitForEchoAndSubmit = () => {
+          if (!this.ptyProcess) return;
+          const now = Date.now();
+          const elapsed = now - submitStartedAt;
+          const screenText = this.terminalScreen.getText();
+          const normalizedScreen = normalizePromptText(screenText);
+          if (normalizedScreen !== lastNormalizedScreen) {
+            lastNormalizedScreen = normalizedScreen;
+            lastScreenChangeAt = now;
+          }
+          const echoVisible = !normalizedPromptSnippet || promptLikelyVisible(screenText, normalizedPromptSnippet);
+          if (echoVisible) {
+            const screenSettled = now - lastScreenChangeAt >= 500;
+            if (elapsed >= submitDelayMs && screenSettled) {
+              submit();
+              return;
+            }
+          }
+          if (elapsed >= maxEchoWaitMs) {
+            submit();
+            return;
+          }
+          setTimeout(waitForEchoAndSubmit, 50);
+        };
+        waitForEchoAndSubmit();
       }
       getPartialResponse() {
         if (!this.isWaitingForResponse) return "";
@@ -1258,6 +1393,10 @@ ${data.message || ""}`.trim();
           clearTimeout(this.approvalExitTimeout);
           this.approvalExitTimeout = null;
         }
+        if (this.submitRetryTimer) {
+          clearTimeout(this.submitRetryTimer);
+          this.submitRetryTimer = null;
+        }
         if (this.ptyProcess) {
           this.ptyProcess.write("");
           setTimeout(() => {
@@ -1279,6 +1418,8 @@ ${data.message || ""}`.trim();
         this.structuredMessages = [];
         this.accumulatedBuffer = "";
         this.accumulatedRawBuffer = "";
+        this.submitRetryUsed = false;
+        this.submitRetryPromptSnippet = "";
         this.terminalScreen.reset();
         this.onStatusChange?.();
       }
@@ -1292,7 +1433,16 @@ ${data.message || ""}`.trim();
         this.ptyProcess?.write(data);
       }
       resolveModal(buttonIndex) {
-        if (!this.ptyProcess || this.currentStatus !== "waiting_approval") return;
+        if (!this.ptyProcess || this.currentStatus !== "waiting_approval" && !this.activeModal) return;
+        this.activeModal = null;
+        this.lastApprovalResolvedAt = Date.now();
+        this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
+        if (this.approvalExitTimeout) {
+          clearTimeout(this.approvalExitTimeout);
+          this.approvalExitTimeout = null;
+        }
+        this.setStatus("generating", "approval_resolved");
+        this.onStatusChange?.();
         if (buttonIndex in this.approvalKeys) {
           this.ptyProcess.write(this.approvalKeys[buttonIndex]);
         } else {
@@ -1334,6 +1484,10 @@ ${data.message || ""}`.trim();
           isWaitingForResponse: this.isWaitingForResponse,
           activeModal: this.activeModal,
           lastApprovalResolvedAt: this.lastApprovalResolvedAt,
+          sendDelayMs: this.sendDelayMs,
+          sendKey: this.sendKey,
+          submitPendingUntil: this.submitPendingUntil,
+          responseSettleIgnoreUntil: this.responseSettleIgnoreUntil,
           resizeSuppressUntil: this.resizeSuppressUntil,
           hasCliScripts: this.hasCliScripts(),
           scriptNames: Object.keys(this.cliScripts).filter((k) => typeof this.cliScripts[k] === "function"),