@adhdev/daemon-core 0.6.55 → 0.6.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.6.55",
+  "version": "0.6.56",
   "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[];
@@ -270,6 +272,7 @@ 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;
 
  // Resize redraw suppression
     private resizeSuppressUntil: number = 0;
@@ -302,6 +305,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 +330,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 || {};
@@ -460,6 +469,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);
 
@@ -519,11 +533,17 @@ export class ProviderCliAdapter implements CliAdapter {
 
     private scheduleSettle(): void {
         if (this.settleTimer) clearTimeout(this.settleTimer);
+        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;
             this.settledBuffer = this.recentOutputBuffer;
             this.evaluateSettled();
-        }, this.timeouts.outputSettle);
+        }, delay);
     }
 
     private evaluateSettled(): void {
@@ -612,7 +632,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;
@@ -729,12 +753,22 @@ export class ProviderCliAdapter implements CliAdapter {
         this.responseBuffer = '';
         this.setStatus('generating', 'sendMessage');
         this.onStatusChange?.();
+        this.ptyProcess.write(text);
 
-        this.ptyProcess.write(text + '\r');
-
-        this.responseTimeout = setTimeout(() => {
-            if (this.isWaitingForResponse) this.finishResponse();
-        }, this.timeouts.maxResponse);
+        const submit = () => {
+            if (!this.ptyProcess) return;
+            this.submitPendingUntil = 0;
+            this.ptyProcess.write(this.sendKey);
+            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();
+        }
     }
 
     getPartialResponse(): string {
@@ -810,10 +844,14 @@ 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,

package/src/cli-adapters/terminal-screen.ts

@@ -1,268 +1,95 @@
 /**
- * Minimal VT screen model for PTY parsing.
+ * PTY screen snapshot backed by xterm's parser.
  *
- * This is not a full terminal emulator. It exists to turn raw PTY output into a
- * stable "current screen" snapshot so provider parsers can inspect visible UI
- * state instead of reparsing the full accumulated log stream.
+ * Claude Code and similar CLIs use a real terminal UI. A handwritten ANSI
+ * parser quickly drifts from reality, so we reuse xterm's terminal model and
+ * expose only the current visible viewport as plain text for provider scripts.
  */
 
-function clamp(value: number, min: number, max: number): number {
-    return Math.max(min, Math.min(max, value));
+type XtermBufferLine = {
+    translateToString(trimRight?: boolean): string;
+};
+
+type XtermBuffer = {
+    length: number;
+    viewportY: number;
+    getLine(index: number): XtermBufferLine | undefined;
+};
+
+type XtermTerminal = {
+    buffer: { active: XtermBuffer };
+    write(data: string, callback?: () => void): void;
+    resize(cols: number, rows: number): void;
+    dispose(): void;
+};
+
+let TerminalCtor: (new (options: { cols: number; rows: number; scrollback: number }) => XtermTerminal) | null = null;
+
+function loadTerminalCtor(): new (options: { cols: number; rows: number; scrollback: number }) => XtermTerminal {
+    if (!TerminalCtor) {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const mod = require('@xterm/xterm');
+        TerminalCtor = mod.Terminal || mod.default?.Terminal || mod.default;
+        if (!TerminalCtor) {
+            throw new Error('@xterm/xterm Terminal export not found');
+        }
+    }
+    return TerminalCtor;
 }
 
 export class TerminalScreen {
     private rows: number;
     private cols: number;
-    private cursorRow = 0;
-    private cursorCol = 0;
-    private savedRow = 0;
-    private savedCol = 0;
-    private lines: string[][];
+    private terminal: XtermTerminal;
 
     constructor(rows = 40, cols = 120) {
-        this.rows = rows;
-        this.cols = cols;
-        this.lines = this.makeLines(rows, cols);
+        this.rows = Math.max(1, rows | 0);
+        this.cols = Math.max(1, cols | 0);
+        this.terminal = this.createTerminal();
     }
 
     reset(rows = this.rows, cols = this.cols): void {
-        this.rows = rows;
-        this.cols = cols;
-        this.cursorRow = 0;
-        this.cursorCol = 0;
-        this.savedRow = 0;
-        this.savedCol = 0;
-        this.lines = this.makeLines(rows, cols);
+        this.rows = Math.max(1, rows | 0);
+        this.cols = Math.max(1, cols | 0);
+        this.terminal.dispose();
+        this.terminal = this.createTerminal();
     }
 
     resize(rows: number, cols: number): void {
-        const nextRows = Math.max(1, rows | 0);
-        const nextCols = Math.max(1, cols | 0);
-        const next = this.makeLines(nextRows, nextCols);
-        const copyRows = Math.min(this.rows, nextRows);
-        const copyCols = Math.min(this.cols, nextCols);
-        for (let r = 0; r < copyRows; r++) {
-            for (let c = 0; c < copyCols; c++) {
-                next[r][c] = this.lines[r][c];
-            }
-        }
-        this.rows = nextRows;
-        this.cols = nextCols;
-        this.lines = next;
-        this.cursorRow = clamp(this.cursorRow, 0, this.rows - 1);
-        this.cursorCol = clamp(this.cursorCol, 0, this.cols - 1);
-        this.savedRow = clamp(this.savedRow, 0, this.rows - 1);
-        this.savedCol = clamp(this.savedCol, 0, this.cols - 1);
+        this.rows = Math.max(1, rows | 0);
+        this.cols = Math.max(1, cols | 0);
+        this.terminal.resize(this.cols, this.rows);
     }
 
     write(data: string): void {
-        let i = 0;
-        while (i < data.length) {
-            const ch = data[i];
-
-            if (ch === '\x1b') {
-                const consumed = this.consumeEscape(data, i);
-                i = consumed > i ? consumed : i + 1;
-                continue;
-            }
-
-            if (ch === '\r') {
-                this.cursorCol = 0;
-                i++;
-                continue;
-            }
-
-            if (ch === '\n') {
-                this.newLine();
-                i++;
-                continue;
-            }
-
-            if (ch === '\b') {
-                this.cursorCol = Math.max(0, this.cursorCol - 1);
-                i++;
-                continue;
-            }
-
-            if (ch === '\t') {
-                const nextStop = Math.min(this.cols - 1, this.cursorCol + (8 - (this.cursorCol % 8 || 8)));
-                while (this.cursorCol < nextStop) this.putChar(' ');
-                i++;
-                continue;
-            }
-
-            if (ch >= ' ' && ch !== '\x7f') {
-                this.putChar(ch);
-            }
-
-            i++;
-        }
+        if (!data) return;
+        this.terminal.write(data);
     }
 
     getText(): string {
-        const raw = this.lines.map(line => line.join('').replace(/\s+$/, ''));
-        let start = 0;
-        let end = raw.length;
-        while (start < end && raw[start] === '') start++;
-        while (end > start && raw[end - 1] === '') end--;
-        return raw.slice(start, end).join('\n');
-    }
-
-    private consumeEscape(data: string, start: number): number {
-        const next = data[start + 1];
-        if (!next) return start + 1;
-
-        if (next === '[') {
-            let end = start + 2;
-            while (end < data.length && !/[@-~]/.test(data[end])) end++;
-            if (end >= data.length) return data.length;
-            this.applyCsi(data.slice(start + 2, end), data[end]);
-            return end + 1;
-        }
-
-        if (next === ']') {
-            let end = start + 2;
-            while (end < data.length) {
-                if (data[end] === '\x07') return end + 1;
-                if (data[end] === '\x1b' && data[end + 1] === '\\') return end + 2;
-                end++;
-            }
-            return data.length;
-        }
-
-        if (next === '7') {
-            this.savedRow = this.cursorRow;
-            this.savedCol = this.cursorCol;
-            return start + 2;
-        }
-        if (next === '8') {
-            this.cursorRow = this.savedRow;
-            this.cursorCol = this.savedCol;
-            return start + 2;
+        const buffer = this.terminal.buffer.active;
+        const start = Math.max(0, buffer.viewportY || 0);
+        const end = Math.max(start, Math.min(buffer.length || 0, start + this.rows));
+        const lines: string[] = [];
+
+        for (let i = start; i < end; i++) {
+            const line = buffer.getLine(i);
+            lines.push(line ? line.translateToString(true) : '');
         }
 
-        return start + 2;
-    }
-
-    private applyCsi(paramText: string, finalChar: string): void {
-        const privateMode = paramText.startsWith('?');
-        const normalized = privateMode ? paramText.slice(1) : paramText;
-        const params = normalized.length > 0
-            ? normalized.split(';').map(p => parseInt(p || '0', 10) || 0)
-            : [0];
-
-        switch (finalChar) {
-            case 'A':
-                this.cursorRow = clamp(this.cursorRow - (params[0] || 1), 0, this.rows - 1);
-                return;
-            case 'B':
-                this.cursorRow = clamp(this.cursorRow + (params[0] || 1), 0, this.rows - 1);
-                return;
-            case 'C':
-                this.cursorCol = clamp(this.cursorCol + (params[0] || 1), 0, this.cols - 1);
-                return;
-            case 'D':
-                this.cursorCol = clamp(this.cursorCol - (params[0] || 1), 0, this.cols - 1);
-                return;
-            case 'E':
-                this.cursorRow = clamp(this.cursorRow + (params[0] || 1), 0, this.rows - 1);
-                this.cursorCol = 0;
-                return;
-            case 'F':
-                this.cursorRow = clamp(this.cursorRow - (params[0] || 1), 0, this.rows - 1);
-                this.cursorCol = 0;
-                return;
-            case 'G':
-                this.cursorCol = clamp((params[0] || 1) - 1, 0, this.cols - 1);
-                return;
-            case 'H':
-            case 'f': {
-                const row = (params[0] || 1) - 1;
-                const col = (params[1] || 1) - 1;
-                this.cursorRow = clamp(row, 0, this.rows - 1);
-                this.cursorCol = clamp(col, 0, this.cols - 1);
-                return;
-            }
-            case 'J': {
-                const mode = params[0] || 0;
-                if (mode === 2 || mode === 3) {
-                    this.reset(this.rows, this.cols);
-                } else if (mode === 0) {
-                    this.clearToEndOfScreen();
-                } else if (mode === 1) {
-                    this.clearToStartOfScreen();
-                }
-                return;
-            }
-            case 'K': {
-                const mode = params[0] || 0;
-                if (mode === 2) this.clearLine(this.cursorRow, 0, this.cols - 1);
-                else if (mode === 1) this.clearLine(this.cursorRow, 0, this.cursorCol);
-                else this.clearLine(this.cursorRow, this.cursorCol, this.cols - 1);
-                return;
-            }
-            case 'm':
-                return;
-            case 's':
-                this.savedRow = this.cursorRow;
-                this.savedCol = this.cursorCol;
-                return;
-            case 'u':
-                this.cursorRow = this.savedRow;
-                this.cursorCol = this.savedCol;
-                return;
-            case 'h':
-            case 'l':
-                if (privateMode && (normalized === '1049' || normalized === '47')) {
-                    this.reset(this.rows, this.cols);
-                }
-                return;
-            default:
-                return;
-        }
-    }
-
-    private putChar(ch: string): void {
-        if (this.cursorRow < 0 || this.cursorRow >= this.rows) return;
-        if (this.cursorCol < 0) this.cursorCol = 0;
-        if (this.cursorCol >= this.cols) this.newLine();
-        this.lines[this.cursorRow][this.cursorCol] = ch;
-        this.cursorCol++;
-        if (this.cursorCol >= this.cols) this.newLine();
-    }
-
-    private newLine(): void {
-        this.cursorCol = 0;
-        if (this.cursorRow >= this.rows - 1) {
-            this.lines.shift();
-            this.lines.push(Array.from({ length: this.cols }, () => ' '));
-        } else {
-            this.cursorRow++;
-        }
-    }
-
-    private clearLine(row: number, start: number, end: number): void {
-        if (row < 0 || row >= this.rows) return;
-        for (let c = clamp(start, 0, this.cols - 1); c <= clamp(end, 0, this.cols - 1); c++) {
-            this.lines[row][c] = ' ';
-        }
-    }
-
-    private clearToEndOfScreen(): void {
-        this.clearLine(this.cursorRow, this.cursorCol, this.cols - 1);
-        for (let r = this.cursorRow + 1; r < this.rows; r++) {
-            this.clearLine(r, 0, this.cols - 1);
-        }
-    }
-
-    private clearToStartOfScreen(): void {
-        for (let r = 0; r < this.cursorRow; r++) {
-            this.clearLine(r, 0, this.cols - 1);
-        }
-        this.clearLine(this.cursorRow, 0, this.cursorCol);
+        let first = 0;
+        let last = lines.length;
+        while (first < last && !lines[first]?.trim()) first++;
+        while (last > first && !lines[last - 1]?.trim()) last--;
+        return lines.slice(first, last).join('\n');
     }
 
-    private makeLines(rows: number, cols: number): string[][] {
-        return Array.from({ length: rows }, () => Array.from({ length: cols }, () => ' '));
+    private createTerminal(): XtermTerminal {
+        const Terminal = loadTerminalCtor();
+        return new Terminal({
+            cols: this.cols,
+            rows: this.rows,
+            scrollback: 2000,
+        });
     }
 }