@adhdev/daemon-core 0.6.53 → 0.6.55

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

@@ -0,0 +1,268 @@
+/**
+ * Minimal VT screen model for PTY parsing.
+ *
+ * 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.
+ */
+
+function clamp(value: number, min: number, max: number): number {
+    return Math.max(min, Math.min(max, value));
+}
+
+export class TerminalScreen {
+    private rows: number;
+    private cols: number;
+    private cursorRow = 0;
+    private cursorCol = 0;
+    private savedRow = 0;
+    private savedCol = 0;
+    private lines: string[][];
+
+    constructor(rows = 40, cols = 120) {
+        this.rows = rows;
+        this.cols = cols;
+        this.lines = this.makeLines(rows, cols);
+    }
+
+    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);
+    }
+
+    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);
+    }
+
+    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++;
+        }
+    }
+
+    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;
+        }
+
+        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);
+    }
+
+    private makeLines(rows: number, cols: number): string[][] {
+        return Array.from({ length: rows }, () => Array.from({ length: cols }, () => ' '));
+    }
+}

package/src/commands/chat-commands.ts

@@ -7,6 +7,10 @@ import type { CommandResult, CommandHelpers } from './handler.js';
 import { readChatHistory } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
 
+function getTargetedCliAdapter(h: CommandHelpers, args: any, providerType?: string) {
+    return h.getCliAdapter(args?._targetInstance || h.currentIdeType || providerType);
+}
+
 export async function handleChatHistory(h: CommandHelpers, args: any): Promise<CommandResult> {
     const { agentType, offset, limit, instanceId } = args;
     try {
@@ -20,13 +24,13 @@ export async function handleChatHistory(h: CommandHelpers, args: any): Promise<C
 }
 
 export async function handleReadChat(h: CommandHelpers, args: any): Promise<CommandResult> {
-    const provider = h.getProvider();
+    const provider = h.getProvider(args?.agentType);
 
     const _log = (msg: string) => LOG.debug('Command', `[read_chat] ${msg}`);
 
     // CLI / ACP category: read from adapter
     if (provider?.category === 'cli' || provider?.category === 'acp') {
-        const adapter = h.getCliAdapter(provider.type);
+        const adapter = getTargetedCliAdapter(h, args, provider.type);
         if (adapter) {
             _log(`${provider.category} adapter: ${(adapter as any).cliType}`);
             const status = (adapter as any).getStatus?.();
@@ -140,7 +144,7 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
     const text = args?.text || args?.message;
     if (!text) return { success: false, error: 'text required' };
     const _log = (msg: string) => LOG.debug('Command', `[send_chat] ${msg}`);
-    const provider = h.getProvider();
+    const provider = h.getProvider(args?.agentType);
 
     const _logSendSuccess = (method: string, targetAgent?: string) => {
         h.historyWriter.appendNewMessages(
@@ -154,7 +158,7 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
 
     // CLI / ACP category: transmit via adapter
     if (provider?.category === 'cli' || provider?.category === 'acp') {
-        const adapter = h.getCliAdapter(provider.type);
+        const adapter = getTargetedCliAdapter(h, args, provider.type);
         if (adapter) {
             _log(`${provider.category} adapter: ${(adapter as any).cliType}`);
             try {
@@ -305,7 +309,7 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
 }
 
 export async function handleListChats(h: CommandHelpers, args: any): Promise<CommandResult> {
-    const provider = h.getProvider();
+    const provider = h.getProvider(args?.agentType);
 
     // Extension: via AgentStreamManager
     if (provider?.category === 'extension' && h.agentStream && h.getCdp()) {
@@ -355,7 +359,17 @@ export async function handleListChats(h: CommandHelpers, args: any): Promise<Com
 }
 
 export async function handleNewChat(h: CommandHelpers, args: any): Promise<CommandResult> {
-    const provider = h.getProvider();
+    const provider = h.getProvider(args?.agentType);
+
+    if (provider?.category === 'cli') {
+        const adapter = getTargetedCliAdapter(h, args, provider.type);
+        if (!adapter) return { success: false, error: 'CLI adapter not running' };
+        if (typeof (adapter as any).clearHistory === 'function') {
+            (adapter as any).clearHistory();
+            return { success: true, cleared: true };
+        }
+        return { success: false, error: 'new_chat not supported by this CLI provider' };
+    }
 
     if (provider?.category === 'extension' && h.agentStream && h.getCdp()) {
         const ok = await h.agentStream.newAgentSession(h.getCdp()!, provider.type, h.currentIdeType);
@@ -386,7 +400,7 @@ export async function handleNewChat(h: CommandHelpers, args: any): Promise<Comma
 }
 
 export async function handleSwitchChat(h: CommandHelpers, args: any): Promise<CommandResult> {
-    const provider = h.getProvider();
+    const provider = h.getProvider(args?.agentType);
     const ideType = h.currentIdeType;
     const sessionId = args?.sessionId || args?.id || args?.chatId;
     if (!sessionId) return { success: false, error: 'sessionId required' };
@@ -473,12 +487,12 @@ export async function handleSwitchChat(h: CommandHelpers, args: any): Promise<Co
 }
 
 export async function handleSetMode(h: CommandHelpers, args: any): Promise<CommandResult> {
-    const provider = h.getProvider();
+    const provider = h.getProvider(args?.agentType);
     const mode = args?.mode || 'agent';
 
     // ACP provider
     if (provider?.category === 'acp') {
-        const adapter = h.getCliAdapter(provider.type);
+        const adapter = getTargetedCliAdapter(h, args, provider.type);
         if (adapter) {
             const acpInstance = (adapter as any)._acpInstance;
             if (acpInstance && typeof acpInstance.onEvent === 'function') {
@@ -526,14 +540,14 @@ export async function handleSetMode(h: CommandHelpers, args: any): Promise<Comma
 }
 
 export async function handleChangeModel(h: CommandHelpers, args: any): Promise<CommandResult> {
-    const provider = h.getProvider();
+    const provider = h.getProvider(args?.agentType);
     const model = args?.model;
 
     LOG.info('Command', `[change_model] model=${model} provider=${provider?.type} category=${provider?.category} ideType=${h.currentIdeType} providerType=${h.currentProviderType}`);
 
     // ACP provider
     if (provider?.category === 'acp') {
-        const adapter = h.getCliAdapter(provider.type);
+        const adapter = getTargetedCliAdapter(h, args, provider.type);
         LOG.info('Command', `[change_model] ACP adapter found: ${!!adapter}, type=${(adapter as any)?.cliType}, hasAcpInstance=${!!(adapter as any)?._acpInstance}`);
         if (adapter) {
             const acpInstance = (adapter as any)._acpInstance;
@@ -587,11 +601,11 @@ export async function handleSetThoughtLevel(h: CommandHelpers, args: any): Promi
     const value = args?.value;
     if (!configId || !value) return { success: false, error: 'configId and value required' };
 
-    const provider = h.getProvider();
+    const provider = h.getProvider(args?.agentType);
     if (!provider || provider.category !== 'acp') {
         return { success: false, error: 'set_thought_level only for ACP providers' };
     }
-    const adapter = h.getCliAdapter(provider.type);
+    const adapter = getTargetedCliAdapter(h, args, provider.type);
     const acpInstance = adapter?._acpInstance;
     if (!acpInstance) return { success: false, error: 'ACP instance not found' };
 
@@ -605,7 +619,7 @@ export async function handleSetThoughtLevel(h: CommandHelpers, args: any): Promi
 }
 
 export async function handleResolveAction(h: CommandHelpers, args: any): Promise<CommandResult> {
-    const provider = h.getProvider();
+    const provider = h.getProvider(args?.agentType);
     const action = args?.action || 'approve';
     const button = args?.button || args?.buttonText
         || (action === 'approve' ? 'Accept' : action === 'reject' ? 'Reject' : 'Accept');
@@ -614,8 +628,20 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
 
     // 0. CLI / ACP category: navigate approval dialog via PTY arrow keys + Enter
     if (provider?.category === 'cli') {
-        const adapter = h.getCliAdapter(provider.type);
+        const adapter = getTargetedCliAdapter(h, args, provider.type);
         if (!adapter) return { success: false, error: 'CLI adapter not running' };
+
+        // Handle data-driven resolve actions (like from the dashboard 'Fix' button)
+        if (args?.data && typeof (adapter as any).resolveAction === 'function') {
+            try {
+                await (adapter as any).resolveAction(args.data);
+                LOG.info('Command', `[resolveAction] CLI PTY → resolveAction triggered with data payload`);
+                return { success: true, method: 'cli-resolve-action' };
+            } catch (e: any) {
+                return { success: false, error: `CLI resolveAction failed: ${e.message}` };
+            }
+        }
+
         const status = (adapter as any).getStatus?.();
         if (status?.status !== 'waiting_approval') {
             return { success: false, error: 'Not in approval state' };

package/src/commands/cli-manager.ts

@@ -83,7 +83,8 @@ export class DaemonCliManager {
         const provider = this.providerLoader.getMeta(normalizedType);
         if (provider && provider.category === 'cli' && provider.patterns && provider.spawn) {
             console.log(chalk.cyan(`  📦 Using provider: ${provider.name} (${provider.type})`));
-            return new ProviderCliAdapter(provider as any, workingDir, cliArgs);
+            const resolvedProvider = this.providerLoader.resolve(normalizedType) || provider;
+            return new ProviderCliAdapter(resolvedProvider as any, workingDir, cliArgs);
         }
 
         throw new Error(`No CLI provider found for '${cliType}'. Create a provider.js in providers/cli/${cliType}/`);
@@ -182,7 +183,8 @@ export class DaemonCliManager {
  // If InstanceManager exists, manage as CliProviderInstance unified
         const instanceManager = this.deps.getInstanceManager();
         if (provider && instanceManager) {
-            const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key);
+            const resolvedProvider = this.providerLoader.resolve(cliType, { version: cliInfo.version }) || provider;
+            const cliInstance = new CliProviderInstance(resolvedProvider, resolvedDir, cliArgs, key);
             try {
                 await instanceManager.addInstance(key, cliInstance, {
                     serverConn: this.deps.getServerConn(),