@adhdev/daemon-core 0.8.30 → 0.8.32

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

@@ -0,0 +1,439 @@
+import * as os from 'os';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import type { ProviderResumeCapability } from '../providers/contracts.js';
+import { sanitizeSpawnEnv } from './spawn-env.js';
+
+export interface CliChatMessage {
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp?: number;
+    receivedAt?: number;
+    kind?: string;
+    id?: string;
+    index?: number;
+    meta?: Record<string, any>;
+    senderName?: string;
+}
+
+export interface CliSessionStatus {
+    status: 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting';
+    messages: CliChatMessage[];
+    workingDir: string;
+    activeModal: { message: string; buttons: string[] } | null;
+}
+
+export interface CliScripts {
+    parseOutput?: (input: CliScriptInput) => any;
+    detectStatus?: (input: CliStatusInput) => string | null;
+    parseApproval?: (input: CliApprovalInput) => { message: string; buttons: string[] } | null;
+    resolveAction?: (data: any) => string;
+    [name: string]: ((input: any) => any) | undefined;
+}
+
+export interface CliScreenLine {
+    index: number;
+    fromTop: number;
+    fromBottom: number;
+    text: string;
+    trimmed: string;
+    isEmpty: boolean;
+}
+
+export interface CliScreenSnapshot {
+    text: string;
+    lineCount: number;
+    lines: CliScreenLine[];
+    nonEmptyLines: CliScreenLine[];
+    firstNonEmptyLineIndex: number;
+    lastNonEmptyLineIndex: number;
+    firstNonEmptyLine: CliScreenLine | null;
+    lastNonEmptyLine: CliScreenLine | null;
+    promptLineIndex: number;
+    promptLine: CliScreenLine | null;
+    linesAbovePrompt: CliScreenLine[];
+    linesBelowPrompt: CliScreenLine[];
+}
+
+export interface CliScriptInput {
+    buffer: string;
+    rawBuffer: string;
+    recentBuffer: string;
+    screenText: string;
+    screen: CliScreenSnapshot;
+    bufferScreen: CliScreenSnapshot;
+    recentScreen: CliScreenSnapshot;
+    messages: CliChatMessage[];
+    partialResponse: string;
+    promptText?: string;
+    settings?: Record<string, any>;
+    args?: Record<string, any>;
+}
+
+export interface CliStatusInput {
+    tail: string;
+    screenText?: string;
+    rawBuffer?: string;
+    screen: CliScreenSnapshot;
+    tailScreen: CliScreenSnapshot;
+}
+
+export interface CliApprovalInput {
+    buffer: string;
+    screenText?: string;
+    rawBuffer?: string;
+    tail: string;
+    screen: CliScreenSnapshot;
+    bufferScreen: CliScreenSnapshot;
+    tailScreen: CliScreenSnapshot;
+}
+
+export interface CliTraceEntry {
+    id: number;
+    at: number;
+    type: string;
+    status: CliSessionStatus['status'];
+    isWaitingForResponse: boolean;
+    activeModal: { message: string; buttons: string[] } | null;
+    payload: Record<string, any>;
+}
+
+export interface CliProviderModule {
+    type: string;
+    name: string;
+    category: 'cli';
+    binary: string;
+    approvalKeys?: Record<number, string>;
+    sendDelayMs?: number;
+    sendKey?: string;
+    submitStrategy?: 'wait_for_echo' | 'immediate';
+    scripts?: CliScripts;
+    spawn: {
+        command: string;
+        args: string[];
+        shell: boolean;
+        env: Record<string, string>;
+    };
+    timeouts?: {
+        ptyFlush?: number;
+        dialogAccept?: number;
+        approvalCooldown?: number;
+        generatingIdle?: number;
+        idleFinish?: number;
+        maxResponse?: number;
+        shutdownGrace?: number;
+        outputSettle?: number;
+    };
+    resume?: ProviderResumeCapability;
+    _resolvedVersion?: string | null;
+    _resolvedOs?: string | null;
+    _resolvedProviderDir?: string | null;
+    _resolvedScriptDir?: string | null;
+    _resolvedScriptsPath?: string | null;
+    _resolvedScriptsSource?: string | null;
+    _versionWarning?: string | null;
+}
+
+function stripAnsi(str: string): string {
+    // eslint-disable-next-line no-control-regex
+    return str
+        .replace(/\x1B\][^\x07]*\x07/g, '')
+        .replace(/\x1B\][\s\S]*?\x1B\\/g, '')
+        .replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, '')
+        .replace(/\x1B\[\d*[A-HJKSTfG]/g, ' ')
+        .replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '')
+        .replace(/  +/g, ' ');
+}
+
+function stripTerminalNoise(str: string): string {
+    return String(str || '')
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, '')
+        .replace(/(^|[\s([])(?:\??\d{1,4}(?:;\d{1,4})*[A-Za-z])(?=$|[\s)\]])/g, '$1')
+        .replace(/(^|[\s([])(?:\[\??\d{1,4}(?:;\d{1,4})*[A-Za-z])(?=$|[\s)\]])/g, '$1')
+        .replace(/(^|[\s([])(?:\d{1,4};\?)(?=$|[\s)\]])/g, '$1')
+        .replace(/(^|[\s([])(?:\d+\$r[0-9;\" ]*[A-Za-z]?)(?=$|[\s)\]])/g, '$1')
+        .replace(/(^|[\s([])(?:>\|[A-Za-z0-9_.:-]+(?:\([^)]*\))?)(?=$|[\s)\]])/g, '$1')
+        .replace(/(^|[\s([])(?:[A-Z]\d(?:\s+[A-Z]\d)+)(?=$|[\s)\]])/g, '$1')
+        .replace(/(^|[\s([])(?:\d+;[^\s)\]]+)(?=$|[\s)\]])/g, '$1')
+        .replace(/\r+/g, '\n')
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/ {2,}/g, ' ');
+}
+
+export function sanitizeTerminalText(str: string): string {
+    return stripTerminalNoise(stripAnsi(str));
+}
+
+export function listCliScriptNames(scripts: CliScripts | undefined): string[] {
+    if (!scripts) return [];
+    return Object.entries(scripts)
+        .filter(([, fn]) => typeof fn === 'function')
+        .map(([name]) => name);
+}
+
+function splitCliScreenLines(text: string): string[] {
+    return String(text || '')
+        .replace(/\u0007/g, '')
+        .replace(/\r\n/g, '\n')
+        .replace(/\r/g, '\n')
+        .split('\n')
+        .map((line) => line.replace(/\s+$/, ''));
+}
+
+function isPromptLikeCliLine(line: string): boolean {
+    const trimmed = String(line || '').trim();
+    if (!trimmed) return false;
+    return /^[❯›>]\s*(?:$|\S.*)$/.test(trimmed);
+}
+
+export function buildCliScreenSnapshot(text: string): CliScreenSnapshot {
+    const normalizedText = String(text || '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    const rawLines = splitCliScreenLines(normalizedText);
+    const lines = rawLines.map((line, index, arr) => {
+        const trimmed = String(line || '').trim();
+        return {
+            index,
+            fromTop: index,
+            fromBottom: arr.length - index - 1,
+            text: line,
+            trimmed,
+            isEmpty: trimmed.length === 0,
+        };
+    });
+    const nonEmptyLines = lines.filter((line) => !line.isEmpty);
+    const firstNonEmptyLine = nonEmptyLines[0] ?? null;
+    const lastNonEmptyLine = nonEmptyLines[nonEmptyLines.length - 1] ?? null;
+    let promptLineIndex = -1;
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        if (isPromptLikeCliLine(lines[i].text)) {
+            promptLineIndex = i;
+            break;
+        }
+    }
+    return {
+        text: normalizedText,
+        lineCount: lines.length,
+        lines,
+        nonEmptyLines,
+        firstNonEmptyLineIndex: firstNonEmptyLine?.index ?? -1,
+        lastNonEmptyLineIndex: lastNonEmptyLine?.index ?? -1,
+        firstNonEmptyLine,
+        lastNonEmptyLine,
+        promptLineIndex,
+        promptLine: promptLineIndex >= 0 ? lines[promptLineIndex] : null,
+        linesAbovePrompt: promptLineIndex >= 0 ? lines.slice(0, promptLineIndex) : [...lines],
+        linesBelowPrompt: promptLineIndex >= 0 ? lines.slice(promptLineIndex + 1) : [],
+    };
+}
+
+export const buildCliSpawnEnv = sanitizeSpawnEnv;
+
+export function computeTerminalQueryTail(buffer: string): string {
+    const prefixes = ['\x1b[6n', '\x1b[?6n'];
+    const maxLength = prefixes.reduce((n, value) => Math.max(n, value.length), 0) - 1;
+    const start = Math.max(0, buffer.length - maxLength);
+    for (let i = start; i < buffer.length; i++) {
+        const suffix = buffer.slice(i);
+        if (prefixes.some((pattern) => suffix.length < pattern.length && pattern.startsWith(suffix))) {
+            return suffix;
+        }
+    }
+    return '';
+}
+
+export function findBinary(name: string): string {
+    const trimmed = String(name || '').trim();
+    if (!trimmed) return trimmed;
+    const expanded = trimmed.startsWith('~')
+        ? path.join(os.homedir(), trimmed.slice(1))
+        : trimmed;
+    if (path.isAbsolute(expanded) || expanded.includes('/') || expanded.includes('\\')) {
+        return path.isAbsolute(expanded) ? expanded : path.resolve(expanded);
+    }
+    const isWin = os.platform() === 'win32';
+    try {
+        const cmd = isWin ? `where ${trimmed}` : `which ${trimmed}`;
+        return execSync(cmd, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim().split('\n')[0].trim();
+    } catch {
+        return isWin ? `${trimmed}.cmd` : trimmed;
+    }
+}
+
+export function isScriptBinary(binaryPath: string): boolean {
+    if (!path.isAbsolute(binaryPath)) return false;
+    try {
+        const fs = require('fs');
+        const resolved = fs.realpathSync(binaryPath);
+        const head = Buffer.alloc(8);
+        const fd = fs.openSync(resolved, 'r');
+        fs.readSync(fd, head, 0, 8, 0);
+        fs.closeSync(fd);
+        let i = 0;
+        if (head[0] === 0xef && head[1] === 0xbb && head[2] === 0xbf) i = 3;
+        return head[i] === 0x23 && head[i + 1] === 0x21;
+    } catch {
+        return false;
+    }
+}
+
+export function looksLikeMachOOrElf(filePath: string): boolean {
+    if (!path.isAbsolute(filePath)) return false;
+    try {
+        const fs = require('fs');
+        const resolved = fs.realpathSync(filePath);
+        const buf = Buffer.alloc(8);
+        const fd = fs.openSync(resolved, 'r');
+        fs.readSync(fd, buf, 0, 8, 0);
+        fs.closeSync(fd);
+        let i = 0;
+        if (buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) i = 3;
+        const b = buf.subarray(i);
+        if (b.length < 4) return false;
+        if (b[0] === 0x7f && b[1] === 0x45 && b[2] === 0x4c && b[3] === 0x46) return true;
+        const le = b.readUInt32LE(0);
+        const be = b.readUInt32BE(0);
+        const magics = [0xfeedface, 0xfeedfacf, 0xcafebabe, 0xbebafeca];
+        return magics.some(m => m === le || m === be);
+    } catch {
+        return false;
+    }
+}
+
+export function shSingleQuote(arg: string): string {
+    if (/^[a-zA-Z0-9@%_+=:,./-]+$/.test(arg)) return arg;
+    if (os.platform() === 'win32') {
+        return `"${arg.replace(/"/g, '""')}"`;
+    }
+    return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+
+export function estimatePromptDisplayLines(text: string, cols = 80): 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);
+}
+
+export 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);
+}
+
+export function normalizePromptText(text: string): string {
+    return String(text || '').replace(/\s+/g, ' ').trim();
+}
+
+export function compactPromptText(text: string): string {
+    return String(text || '').replace(/\s+/g, '').trim();
+}
+
+export 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;
+}
+
+export function normalizeScreenSnapshot(text: string): string {
+    return sanitizeTerminalText(String(text || ''))
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+
+export function normalizeComparableMessageContent(text: string): string {
+    return String(text || '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+
+export function trimPromptEchoPrefix(text: string, promptText?: string | null): string {
+    const prompt = normalizeComparableMessageContent(String(promptText || ''));
+    if (!prompt) return String(text || '');
+
+    const lines = String(text || '').split(/\r\n|\n|\r/g);
+    let dropCount = 0;
+    for (let index = 0; index < Math.min(lines.length, 6); index += 1) {
+        const fragment = normalizeComparableMessageContent(lines[index].replace(/^[.…]+\s*/, ''));
+        if (!fragment) {
+            if (dropCount === index) dropCount = index + 1;
+            continue;
+        }
+        const fragmentWordCount = fragment ? fragment.split(/\s+/).filter(Boolean).length : 0;
+        const canBePromptEcho = fragment.length >= 16 || fragmentWordCount >= 4;
+        if (canBePromptEcho && prompt.includes(fragment)) {
+            dropCount = index + 1;
+            continue;
+        }
+        break;
+    }
+
+    return lines.slice(dropCount).join('\n').trim();
+}
+
+export function getLastUserPromptText(messages: Array<{ role?: string; content?: string }> | null | undefined): string {
+    const items = Array.isArray(messages) ? messages : [];
+    for (let index = items.length - 1; index >= 0; index -= 1) {
+        const message = items[index];
+        if (message?.role === 'user' && typeof message.content === 'string' && message.content.trim()) {
+            return message.content;
+        }
+    }
+    return '';
+}
+
+export function looksLikeConfirmOnlyLabel(label: string): boolean {
+    return /^(?:continue|confirm|ok|yes|trust|proceed|enter)$/i.test(String(label || '').trim());
+}
+
+function parsePatternEntry(x: unknown): RegExp | null {
+    if (x instanceof RegExp) return x;
+    if (x && typeof x === 'object' && typeof (x as { source?: string }).source === 'string') {
+        try {
+            const s = x as { source: string; flags?: string };
+            return new RegExp(s.source, s.flags || '');
+        } catch {
+            return null;
+        }
+    }
+    return null;
+}
+
+function coercePatternArray(raw: unknown): RegExp[] {
+    if (!Array.isArray(raw)) return [];
+    return raw.map(parsePatternEntry).filter((r): r is RegExp => r != null);
+}
+
+export function normalizeCliProviderForRuntime(raw: unknown): { patterns: { approval: RegExp[] } } {
+    const patterns = raw && typeof raw === 'object' ? (raw as { patterns?: unknown }).patterns : undefined;
+    return {
+        patterns: {
+            approval: coercePatternArray(
+                patterns && typeof patterns === 'object' ? (patterns as { approval?: unknown }).approval : undefined,
+            ),
+        },
+    };
+}

package/src/cli-adapters/terminal-backends/ghostty-vt-backend.ts

@@ -26,7 +26,7 @@ let cachedBindingError: Error | null = null;
 function isModuleNotFoundError(error: unknown, ref: string): boolean {
     if (!(error instanceof Error)) return false;
     const message = error.message || '';
-    const code = (error as any).code;
+    const code = 'code' in error ? error.code : undefined;
     return code === 'MODULE_NOT_FOUND' && message.includes(ref);
 }
 

package/src/commands/cdp-commands.ts

@@ -62,12 +62,17 @@ export async function handleCdpCommand(h: CommandHelpers, args: any): Promise<Co
 
 export async function handleCdpBatch(h: CommandHelpers, args: any): Promise<CommandResult> {
     if (!h.getCdp()?.isConnected) return { success: false, error: 'CDP not connected' };
-    const commands = args?.commands as any[];
+    const commands = Array.isArray(args?.commands) ? args.commands : null;
     const stopOnError = args?.stopOnError !== false;
     if (!commands?.length) return { success: false, error: 'commands array required' };
 
     const results: any[] = [];
     for (const cmd of commands) {
+        if (!cmd || typeof cmd !== 'object' || typeof cmd.method !== 'string') {
+            results.push({ method: null, success: false, error: 'Invalid command entry' });
+            if (stopOnError) break;
+            continue;
+        }
         try {
             const result = await h.getCdp()!.sendCdpCommand(cmd.method, cmd.params || {});
             results.push({ method: cmd.method, success: true, result });

package/src/commands/chat-commands.ts

@@ -4,6 +4,9 @@
  */
 
 import type { CommandResult, CommandHelpers } from './handler.js';
+import type { CliAdapter } from '../cli-adapter-types.js';
+import type { ProviderModule, ProviderScripts } from '../providers/contracts.js';
+import type { ProviderInstance } from '../providers/provider-instance.js';
 import { readChatHistory } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
 import type { SessionTransport } from '../shared-types.js';
@@ -11,6 +14,12 @@ import type { SessionTransport } from '../shared-types.js';
 const RECENT_SEND_WINDOW_MS = 1200;
 const recentSendByTarget = new Map<string, number>();
 
+interface ApprovalSelectableInstance extends ProviderInstance {
+    recordApprovalSelection?(buttonText: string): void;
+}
+
+type LegacyStringScript = (params?: Record<string, unknown> | string) => string;
+
 function getCurrentProviderType(h: CommandHelpers, fallback = ''): string {
     return h.currentSession?.providerType || h.currentProviderType || fallback;
 }
@@ -19,18 +28,18 @@ function getCurrentManagerKey(h: CommandHelpers): string {
     return h.currentSession?.cdpManagerKey || h.currentManagerKey || '';
 }
 
-function getTargetedCliAdapter(h: CommandHelpers, args: any, providerType?: string) {
+function getTargetedCliAdapter(h: CommandHelpers, args: any, providerType?: string): CliAdapter | null {
     return h.getCliAdapter(args?.targetSessionId || providerType || h.currentSession?.providerType || h.currentManagerKey);
 }
 
-function getTargetInstance(h: CommandHelpers, args: any) {
+function getTargetInstance(h: CommandHelpers, args: any): ApprovalSelectableInstance | null {
     const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
     const sessionId = targetSessionId || h.currentSession?.sessionId || '';
     if (!sessionId) return null;
-    return h.ctx.instanceManager?.getInstance(sessionId) as any;
+    return (h.ctx.instanceManager?.getInstance(sessionId) as ApprovalSelectableInstance | undefined) || null;
 }
 
-function getTargetTransport(h: CommandHelpers, provider?: any): SessionTransport | null {
+function getTargetTransport(h: CommandHelpers, provider?: ProviderModule): SessionTransport | null {
     if (h.currentSession?.transport) return h.currentSession.transport;
     switch (provider?.category) {
         case 'cli':
@@ -54,7 +63,7 @@ function isExtensionTransport(transport: SessionTransport | null): boolean {
     return transport === 'cdp-webview';
 }
 
-function buildRecentSendKey(h: CommandHelpers, args: any, provider: any, text: string): string {
+function buildRecentSendKey(h: CommandHelpers, args: any, provider: ProviderModule | undefined, text: string): string {
     const transport = getTargetTransport(h, provider) || 'unknown';
     const target =
         args?.targetSessionId
@@ -73,12 +82,17 @@ function getHistorySessionId(h: CommandHelpers, args: any): string | undefined {
     const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
     if (!targetSessionId) return undefined;
 
-    const instance = h.ctx.instanceManager?.getInstance(targetSessionId) as any;
+    const instance = h.ctx.instanceManager?.getInstance(targetSessionId);
     const state = instance?.getState?.();
     const providerSessionId = typeof state?.providerSessionId === 'string' ? state.providerSessionId.trim() : '';
     return providerSessionId || targetSessionId;
 }
 
+function callLegacyTextScript(script: ProviderScripts[keyof ProviderScripts] | undefined, text: string): string | null {
+    if (typeof script !== 'function') return null;
+    return (script as LegacyStringScript)(text);
+}
+
 function isRecentDuplicateSend(key: string): boolean {
     const now = Date.now();
     for (const [candidate, ts] of recentSendByTarget.entries()) {
@@ -184,8 +198,8 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
     if (isCliLikeTransport(transport)) {
         const adapter = getTargetedCliAdapter(h, args, provider?.type);
         if (adapter) {
-            _log(`${transport} adapter: ${(adapter as any).cliType}`);
-            const status = (adapter as any).getStatus?.();
+            _log(`${transport} adapter: ${adapter.cliType}`);
+            const status = adapter.getStatus();
             if (status) {
                 return {
                     success: true,
@@ -333,10 +347,10 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
     if (isCliLikeTransport(transport)) {
         const adapter = getTargetedCliAdapter(h, args, provider?.type);
         if (adapter) {
-            _log(`${transport} adapter: ${(adapter as any).cliType}`);
+            _log(`${transport} adapter: ${adapter.cliType}`);
             try {
                 await adapter.sendMessage(text);
-                return _logSendSuccess(`${transport}-adapter`, (adapter as any).cliType);
+                return _logSendSuccess(`${transport}-adapter`, adapter.cliType);
             } catch (e: any) {
                 return { success: false, error: `${transport} send failed: ${e.message}` };
             }
@@ -433,7 +447,7 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
             }
             if (parsed?.needsTypeAndSend && provider?.webviewMatchText && provider?.scripts?.webviewSendMessage) {
                 try {
-                    const webviewScript = (provider.scripts as any).webviewSendMessage(text);
+                    const webviewScript = callLegacyTextScript(provider.scripts.webviewSendMessage, text);
                     if (webviewScript && targetCdp.evaluateInWebviewFrame) {
                         const matchText = provider.webviewMatchText;
                         const matchFn = matchText ? (body: string) => body.includes(matchText) : undefined;
@@ -457,7 +471,7 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
 
     if (provider?.webviewMatchText && provider?.scripts?.webviewSendMessage) {
         try {
-            const webviewScript = (provider.scripts as any).webviewSendMessage(text);
+            const webviewScript = callLegacyTextScript(provider.scripts.webviewSendMessage, text);
             if (webviewScript && targetCdp.evaluateInWebviewFrame) {
                 const matchText = provider.webviewMatchText;
                 const matchFn = matchText ? (body: string) => body.includes(matchText) : undefined;
@@ -555,8 +569,8 @@ export async function handleNewChat(h: CommandHelpers, args: any): Promise<Comma
     if (transport === 'pty') {
         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();
+        if (typeof adapter.clearHistory === 'function') {
+            adapter.clearHistory();
             return { success: true, cleared: true };
         }
         return { success: false, error: 'new_chat not supported by this CLI provider' };
@@ -692,12 +706,10 @@ export async function handleSetMode(h: CommandHelpers, args: any): Promise<Comma
     // ACP transport
     if (transport === 'acp') {
         const adapter = getTargetedCliAdapter(h, args, provider?.type);
-        if (adapter) {
-            const acpInstance = (adapter as any)._acpInstance;
-            if (acpInstance && typeof acpInstance.setMode === 'function') {
+        const acpInstance = adapter?._acpInstance;
+        if (acpInstance && typeof acpInstance.setMode === 'function') {
                 await acpInstance.setMode(mode);
                 return { success: true, mode };
-            }
         }
         return { success: false, error: 'ACP adapter not found' };
     }
@@ -748,14 +760,12 @@ export async function handleChangeModel(h: CommandHelpers, args: any): Promise<C
     // ACP transport
     if (transport === 'acp') {
         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;
-            if (acpInstance && typeof acpInstance.setConfigOption === 'function') {
+        LOG.info('Command', `[change_model] ACP adapter found: ${!!adapter}, type=${adapter?.cliType}, hasAcpInstance=${!!adapter?._acpInstance}`);
+        const acpInstance = adapter?._acpInstance;
+        if (acpInstance && typeof acpInstance.setConfigOption === 'function') {
                 await acpInstance.setConfigOption('model', model);
                 LOG.info('Command', `[change_model] Updated ACP model to ${model}`);
                 return { success: true, model };
-            }
         }
         return { success: false, error: 'ACP adapter not found' };
     }
@@ -809,6 +819,9 @@ export async function handleSetThoughtLevel(h: CommandHelpers, args: any): Promi
     const adapter = getTargetedCliAdapter(h, args, provider?.type);
     const acpInstance = adapter?._acpInstance;
     if (!acpInstance) return { success: false, error: 'ACP instance not found' };
+    if (typeof acpInstance.setConfigOption !== 'function') {
+        return { success: false, error: 'ACP setConfigOption not available' };
+    }
 
     try {
         await acpInstance.setConfigOption(configId, value);
@@ -834,9 +847,9 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
         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') {
+        if (args?.data && typeof adapter.resolveAction === 'function') {
             try {
-                await (adapter as any).resolveAction(args.data);
+                await adapter.resolveAction(args.data);
                 LOG.info('Command', `[resolveAction] CLI PTY → resolveAction triggered with data payload`);
                 return { success: true, method: 'cli-resolve-action' };
             } catch (e: any) {
@@ -844,7 +857,7 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
             }
         }
 
-        const status = (adapter as any).getStatus?.();
+        const status = adapter.getStatus();
         if (status?.status !== 'waiting_approval') {
             return { success: false, error: 'Not in approval state' };
         }
@@ -866,11 +879,11 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
                 buttonIndex = 0; // approve → first option (default selected)
             }
         }
-        if (typeof (adapter as any).resolveModal === 'function') {
-            (adapter as any).resolveModal(buttonIndex);
+        if (typeof adapter.resolveModal === 'function') {
+            adapter.resolveModal(buttonIndex);
         } else {
             const keys = '\x1B[B'.repeat(Math.max(0, buttonIndex)) + '\r';
-            (adapter as any).writeRaw?.(keys);
+            adapter.writeRaw?.(keys);
         }
         LOG.info('Command', `[resolveAction] CLI PTY → buttonIndex=${buttonIndex} "${buttons[buttonIndex] ?? '?'}"`);
         getTargetInstance(h, args)?.recordApprovalSelection?.(buttons[buttonIndex] ?? button);
@@ -888,6 +901,9 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
         const adapter = getTargetedCliAdapter(h, args, provider?.type);
         const acpInstance = adapter?._acpInstance;
         if (!acpInstance) return { success: false, error: 'ACP instance not found' };
+        if (typeof acpInstance.resolvePermission !== 'function') {
+            return { success: false, error: 'ACP resolvePermission not available' };
+        }
 
         try {
             await acpInstance.resolvePermission(action === 'approve' || action === 'accept' || action === 'always');