@adhdev/daemon-core 0.6.55 → 0.6.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.6.55",
+  "version": "0.6.57",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -31,6 +31,7 @@
   "license": "AGPL-3.0-or-later",
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.16.1",
+    "@xterm/xterm": "^6.0.0",
     "chalk": "^5.3.0",
     "conf": "^13.0.0",
     "ws": "^8.19.0"

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

@@ -68,7 +68,7 @@ export interface CliScripts {
     /** Full PTY buffer → ReadChatResult (messages, status, activeModal) */
     parseOutput?: (input: CliScriptInput) => any;
     /** Lightweight status detection (high-frequency polling) → AgentStatus string */
-    detectStatus?: (input: { tail: string }) => string | null;
+    detectStatus?: (input: { tail: string; screenText?: string; rawBuffer?: string }) => string | null;
     /** Parse approval modal from PTY output → ModalInfo | null */
     parseApproval?: (input: { buffer: string; rawBuffer?: string; tail: string }) => { message: string; buttons: string[] } | null;
     /** Produce a cli-specific prompt from a dashboard action payload */
@@ -91,6 +91,8 @@ export interface CliProviderModule {
     name: string;
     category: 'cli';
     binary: string;
+    sendDelayMs?: number;
+    sendKey?: string;
     spawn: {
         command: string;
         args: string[];
@@ -191,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.
@@ -270,6 +322,12 @@ export class ProviderCliAdapter implements CliAdapter {
  // Output settle debounce — fires after PTY output goes quiet
     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;
@@ -302,6 +360,8 @@ export class ProviderCliAdapter implements CliAdapter {
 
  // Provider approval key mapping
     private readonly approvalKeys: Record<number, string>;
+    private readonly sendDelayMs: number;
+    private readonly sendKey: string;
 
     constructor(provider: CliProviderModule, workingDir: string, private extraArgs: string[] = []) {
         this.provider = provider;
@@ -325,6 +385,10 @@ export class ProviderCliAdapter implements CliAdapter {
 
         const rawKeys = (provider as any).approvalKeys;
         this.approvalKeys = (rawKeys && typeof rawKeys === 'object') ? rawKeys : {};
+        this.sendDelayMs = typeof (provider as any).sendDelayMs === 'number' ? Math.max(0, (provider as any).sendDelayMs) : 0;
+        this.sendKey = typeof (provider as any).sendKey === 'string' && (provider as any).sendKey.length > 0
+            ? (provider as any).sendKey
+            : '\r';
 
         // Scripts are required — loaded by ProviderLoader via compatibility array
         this.cliScripts = (provider as any).scripts || {};
@@ -450,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?.();
     }
@@ -460,6 +524,11 @@ export class ProviderCliAdapter implements CliAdapter {
     private handleOutput(rawData: string): void {
         if (Date.now() < this.resizeSuppressUntil) return;
 
+        if (rawData.includes('\x1b[6n') || rawData.includes('\x1b[?6n')) {
+            // Some TUIs probe cursor position during startup; node-pty does not answer automatically.
+            this.ptyProcess?.write('\x1b[1;1R');
+        }
+
         this.terminalScreen.write(rawData);
         const cleanData = stripAnsi(rawData);
 
@@ -507,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;
             }
@@ -519,16 +590,49 @@ 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()
+                ? (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();
-        }, this.timeouts.outputSettle);
+        }, 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;
@@ -540,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;
             }
@@ -587,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?.();
@@ -596,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?.();
@@ -612,7 +717,11 @@ export class ProviderCliAdapter implements CliAdapter {
     private runDetectStatus(text: string): string | null {
         if (!this.cliScripts?.detectStatus) return null;
         try {
-            return this.cliScripts.detectStatus({ tail: text.slice(-500) });
+            return this.cliScripts.detectStatus({
+                tail: text.slice(-500),
+                screenText: this.terminalScreen.getText(),
+                rawBuffer: this.accumulatedRawBuffer,
+            });
         } catch (e: any) {
             LOG.warn('CLI', `[${this.cliType}] detectStatus error: ${e.message}`);
             return null;
@@ -720,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;
 
@@ -727,14 +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);
+        };
+        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;
+                }
+            }
 
-        this.ptyProcess.write(text + '\r');
+            if (elapsed >= maxEchoWaitMs) {
+                submit();
+                return;
+            }
 
-        this.responseTimeout = setTimeout(() => {
-            if (this.isWaitingForResponse) this.finishResponse();
-        }, this.timeouts.maxResponse);
+            setTimeout(waitForEchoAndSubmit, 50);
+        };
+        waitForEchoAndSubmit();
     }
 
     getPartialResponse(): string {
@@ -747,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(() => {
@@ -766,6 +955,8 @@ export class ProviderCliAdapter implements CliAdapter {
         this.structuredMessages = [];
         this.accumulatedBuffer = '';
         this.accumulatedRawBuffer = '';
+        this.submitRetryUsed = false;
+        this.submitRetryPromptSnippet = '';
         this.terminalScreen.reset();
         this.onStatusChange?.();
     }
@@ -778,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 {
@@ -810,13 +1010,21 @@ export class ProviderCliAdapter implements CliAdapter {
             messages: this.messages.slice(-20),
             structuredMessages: this.structuredMessages.slice(-20),
             messageCount: this.messages.length,
+            screenText: this.terminalScreen.getText().slice(-4000),
             startupBuffer: this.startupBuffer.slice(-4000),
             recentOutputBuffer: this.recentOutputBuffer.slice(-500),
             settledBuffer: this.settledBuffer.slice(-500),
             accumulatedBufferLength: this.accumulatedBuffer.length,
+            accumulatedRawBufferLength: this.accumulatedRawBuffer.length,
+            rawBufferPreview: this.accumulatedRawBuffer.slice(-1000),
+            responseBuffer: this.responseBuffer.slice(-1000),
             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'),