@adhdev/daemon-core 0.6.56 → 0.6.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.6.56",
+  "version": "0.6.57",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cli-adapters/provider-cli-adapter.ts

@@ -193,6 +193,56 @@ function shSingleQuote(arg: string): string {
     return `'${arg.replace(/'/g, `'\\''`)}'`;
 }
 
+function estimatePromptDisplayLines(text: string, cols = 100): number {
+    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: string): string {
+    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: string): string {
+    return String(text || '').replace(/\s+/g, ' ').trim();
+}
+
+function compactPromptText(text: string): string {
+    return String(text || '').replace(/\s+/g, '').trim();
+}
+
+function promptLikelyVisible(screenText: string, promptSnippet: string): boolean {
+    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;
+}
+
 /**
  * Normalize provider.json for auto-implement approval detection.
  * Kept for backward compat with dev-server auto-impl pipeline only.
@@ -273,6 +323,11 @@ export class ProviderCliAdapter implements CliAdapter {
     private settleTimer: NodeJS.Timeout | null = null;
     private settledBuffer: string = '';
     private submitPendingUntil = 0;
+    private responseSettleIgnoreUntil = 0;
+    private responseEpoch = 0;
+    private submitRetryTimer: NodeJS.Timeout | null = null;
+    private submitRetryUsed = false;
+    private submitRetryPromptSnippet = '';
 
  // Resize redraw suppression
     private resizeSuppressUntil: number = 0;
@@ -459,7 +514,7 @@ export class ProviderCliAdapter implements CliAdapter {
         this.startupParseGate = true;
         this.startupBuffer = '';
         this.terminalScreen.reset(40, 120);
-        this.ready = true;
+        this.ready = false;
         this.setStatus('idle', 'pty_ready');
         this.onStatusChange?.();
     }
@@ -521,7 +576,9 @@ export class ProviderCliAdapter implements CliAdapter {
 
             if (isReady) {
                 this.startupParseGate = false;
+                this.ready = true;
                 LOG.info('CLI', `[${this.cliType}] Startup gate end (${elapsed}ms, scriptStatus=${scriptStatus})`);
+                this.onStatusChange?.();
             } else {
                 return;
             }
@@ -533,6 +590,7 @@ export class ProviderCliAdapter implements CliAdapter {
 
     private scheduleSettle(): void {
         if (this.settleTimer) clearTimeout(this.settleTimer);
+        const settleEpoch = this.responseEpoch;
         const delay = Math.max(
             this.timeouts.outputSettle,
             this.submitPendingUntil > Date.now()
@@ -541,14 +599,40 @@ export class ProviderCliAdapter implements CliAdapter {
         );
         this.settleTimer = setTimeout(() => {
             this.settleTimer = null;
+            if (settleEpoch !== this.responseEpoch) return;
             this.settledBuffer = this.recentOutputBuffer;
             this.evaluateSettled();
         }, delay);
     }
 
+    private armApprovalExitTimeout(): void {
+        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 — auto-clearing`);
+            this.activeModal = null;
+            this.lastApprovalResolvedAt = Date.now();
+            this.setStatus('idle', 'approval_timeout');
+            this.onStatusChange?.();
+        }, 60000);
+    }
+
     private evaluateSettled(): void {
+        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;
@@ -560,20 +644,10 @@ export class ProviderCliAdapter implements CliAdapter {
                 this.setStatus('waiting_approval', 'script_detect');
 
                 // Use parseApproval script for modal info
-                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 — auto-clearing`);
-                        this.activeModal = null;
-                        this.lastApprovalResolvedAt = Date.now();
-                        this.setStatus('idle', 'approval_timeout');
-                        this.onStatusChange?.();
-                    }
-                }, 60000);
+                this.armApprovalExitTimeout();
                 this.onStatusChange?.();
                 return;
             }
@@ -607,7 +681,12 @@ export class ProviderCliAdapter implements CliAdapter {
                 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?.();
@@ -616,12 +695,18 @@ export class ProviderCliAdapter implements CliAdapter {
     }
 
     private finishResponse(): void {
+        if (this.submitPendingUntil > Date.now()) return;
+        if (this.responseSettleIgnoreUntil > Date.now()) return;
         if (this.responseTimeout) { clearTimeout(this.responseTimeout); this.responseTimeout = null; }
         if (this.idleTimeout) { clearTimeout(this.idleTimeout); this.idleTimeout = null; }
         if (this.approvalExitTimeout) { 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?.();
@@ -744,6 +829,12 @@ export class ProviderCliAdapter implements CliAdapter {
 
     async sendMessage(text: string): Promise<void> {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
+        if (this.startupParseGate) {
+            const deadline = Date.now() + 10000;
+            while (this.startupParseGate && Date.now() < deadline) {
+                await new Promise(resolve => setTimeout(resolve, 50));
+            }
+        }
         if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.currentStatus})`);
         if (this.isWaitingForResponse) return;
 
@@ -751,24 +842,87 @@ export class ProviderCliAdapter implements CliAdapter {
         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(2000, Math.max(0, estimatedLines - 1) * 350);
+        const maxEchoWaitMs = submitDelayMs + Math.max(1500, Math.min(5000, 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: number) => {
+                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(): string {
@@ -781,6 +935,7 @@ export class ProviderCliAdapter implements CliAdapter {
     shutdown(): void {
         if (this.settleTimer) { clearTimeout(this.settleTimer); this.settleTimer = null; }
         if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
+        if (this.submitRetryTimer) { clearTimeout(this.submitRetryTimer); this.submitRetryTimer = null; }
         if (this.ptyProcess) {
             this.ptyProcess.write('\x03');
             setTimeout(() => {
@@ -800,6 +955,8 @@ export class ProviderCliAdapter implements CliAdapter {
         this.structuredMessages = [];
         this.accumulatedBuffer = '';
         this.accumulatedRawBuffer = '';
+        this.submitRetryUsed = false;
+        this.submitRetryPromptSnippet = '';
         this.terminalScreen.reset();
         this.onStatusChange?.();
     }
@@ -812,7 +969,16 @@ export class ProviderCliAdapter implements CliAdapter {
     }
 
     resolveModal(buttonIndex: number): void {
-        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 {
@@ -855,6 +1021,10 @@ export class ProviderCliAdapter implements CliAdapter {
             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 as any)[k] === 'function'),