@adhdev/daemon-core 0.9.82-rc.2 → 0.9.82-rc.200

package/src/cli-adapters/provider-cli-parse.d.ts

@@ -15,6 +15,7 @@ export declare function buildCliParseInput(options: {
     accumulatedRawBuffer: string;
     recentOutputBuffer: string;
     terminalScreenText: string;
+    workingDir?: string;
     baseMessages: CliChatMessage[];
     partialResponse: string;
     isWaitingForResponse?: boolean;

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

@@ -35,22 +35,30 @@ export function buildCliParseInput(options: {
     accumulatedRawBuffer: string;
     recentOutputBuffer: string;
     terminalScreenText: string;
+    workingDir?: string;
+    providerSessionId?: string;
+    historySessionId?: string;
     baseMessages: CliChatMessage[];
     partialResponse: string;
     isWaitingForResponse?: boolean;
     scope?: TurnParseScope | null;
     runtimeSettings: Record<string, any>;
+    spawnAt?: number;
 }): CliScriptInput {
     const {
         accumulatedBuffer,
         accumulatedRawBuffer,
         recentOutputBuffer,
         terminalScreenText,
+        workingDir,
+        providerSessionId,
+        historySessionId,
         baseMessages,
         partialResponse,
         isWaitingForResponse,
         scope,
         runtimeSettings,
+        spawnAt,
     } = options;
     const buffer = scope
         ? sliceFromOffset(accumulatedBuffer, scope.bufferStart)
@@ -66,6 +74,10 @@ export function buildCliParseInput(options: {
         rawBuffer,
         recentBuffer,
         screenText,
+        workspace: workingDir,
+        workingDir,
+        providerSessionId,
+        historySessionId,
         screen: buildCliScreenSnapshot(screenText),
         bufferScreen: buildCliScreenSnapshot(buffer),
         recentScreen: buildCliScreenSnapshot(recentBuffer),
@@ -74,6 +86,7 @@ export function buildCliParseInput(options: {
         isWaitingForResponse,
         promptText: scope?.prompt || '',
         settings: { ...runtimeSettings },
+        ...(typeof spawnAt === 'number' && spawnAt > 0 ? { spawnAt } : {}),
     };
 }
 

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

@@ -36,7 +36,9 @@ export function resolveCliSpawnPlan(options: {
         : spawnConfig.command;
     const binaryPath = findBinary(configuredCommand);
     const isWin = os.platform() === 'win32';
-    const allArgs = [...spawnConfig.args, ...extraArgs];
+    const allArgs = [...spawnConfig.args, ...extraArgs].map((arg) =>
+        typeof arg === 'string' ? arg.replace(/\{\{workingDir\}\}/g, workingDir) : arg,
+    );
 
     let shellCmd: string;
     let shellArgs: string[];

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

@@ -55,6 +55,8 @@ export interface CliScriptInput {
     rawBuffer: string;
     recentBuffer: string;
     screenText: string;
+    workspace?: string;
+    workingDir?: string;
     screen: CliScreenSnapshot;
     bufferScreen: CliScreenSnapshot;
     recentScreen: CliScreenSnapshot;

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

@@ -4,6 +4,7 @@ import { execSync } from 'child_process';
 import type { ProviderResumeCapability } from '../providers/contracts.js';
 import type { ChatMessageKind } from '../providers/chat-message-normalization.js';
 import type { ChatBubbleState } from '../types.js';
+import type { InteractivePrompt } from '../providers/types/interactive-prompt.js';
 import { sanitizeSpawnEnv } from './spawn-env.js';
 
 export interface CliChatMessage {
@@ -28,8 +29,18 @@ export interface CliSessionStatus {
     messages: CliChatMessage[];
     workingDir: string;
     activeModal: { message: string; buttons: string[] } | null;
+    activeInteractivePrompt?: InteractivePrompt | null;
+    pendingOutboundCount?: number;
+    pendingOutboundMessages?: Array<{
+        id: string;
+        role: 'user';
+        content: string;
+        queuedAt: number;
+        source: string;
+    }>;
     errorMessage?: string;
     errorReason?: string;
+    providerSessionId?: string;
     bufferState?: {
         responseBuffer?: { truncated: boolean; droppedChars: number; maxChars: number };
         recentOutputBuffer?: { truncated: boolean; droppedChars: number; maxChars: number };
@@ -43,6 +54,9 @@ export interface ParsedSession {
     messages: any[];
     modal: { message: string; buttons: string[] } | null;
     parsedStatus: string | null;
+    errorMessage?: string;
+    errorReason?: string;
+    providerSessionId?: string;
     transcriptAuthority?: 'provider' | 'daemon';
     coverage?: 'full' | 'tail' | 'current-turn';
 }
@@ -94,6 +108,10 @@ export interface CliScriptInput {
     rawBuffer: string;
     recentBuffer: string;
     screenText: string;
+    workspace?: string;
+    workingDir?: string;
+    providerSessionId?: string;
+    historySessionId?: string;
     screen: CliScreenSnapshot;
     bufferScreen: CliScreenSnapshot;
     recentScreen: CliScreenSnapshot;
@@ -103,6 +121,7 @@ export interface CliScriptInput {
     promptText?: string;
     settings?: Record<string, any>;
     args?: Record<string, any>;
+    spawnAt?: number;
 }
 
 export interface CliStatusInput {
@@ -141,16 +160,26 @@ export interface CliProviderModule {
     binary: string;
     approvalKeys?: Record<number, string>;
     sendDelayMs?: number;
+    /** Wall-clock budget (ms) for a single provider script invocation. Default 50. Range 1..5000.
+     *  Exceeding the budget records `timedOut: true` on the invocation trace and emits a
+     *  throttled WARN — it does NOT abort the script (Node CJS can't interrupt sync code). */
+    scriptCallBudgetMs?: number;
     sendKey?: string;
     submitStrategy?: 'wait_for_echo' | 'immediate';
     /** Require the typed prompt to be visible on the PTY screen before sending Enter. */
     requirePromptEchoBeforeSubmit?: boolean;
     /** Allow sending another prompt while the CLI is still generating so users can intervene mid-turn. */
     allowInputDuringGeneration?: boolean;
+    /** When true, only transition to idle after the parsed transcript includes a final standard assistant message. */
+    requiresFinalAssistantBeforeIdle?: boolean;
+    /** When true, allow providers to augment stale snapshot data before parse. Reserved for future use. */
+    augmentStaleSnapshot?: boolean;
     /** When provider-owned, daemon treats provider parser output as canonical transcript authority. */
     transcriptAuthority?: 'provider' | 'daemon';
     /** Full context lets provider-owned parsers canonicalize retained history instead of daemon prefix stitching. */
     transcriptContext?: 'full' | 'tail';
+    /** v1 declarative tui block — used by CliScriptRunner to synthesize SDK helpers (declarativeDetectStatus, declarativeParseApproval). */
+    tui?: Record<string, unknown>;
     scripts?: CliScripts;
     spawn: {
         command: string;
@@ -342,7 +371,18 @@ export class TerminalTranscriptAccumulator {
         this.ensureRow();
         if (final === 'A') this.row = Math.max(0, this.row - count);
         else if (final === 'B') this.row += count;
-        else if (final === 'C') this.col += count;
+        else if (final === 'C') {
+            // (fix) Cursor-forward must materialize spaces in the cells it
+            // skips, otherwise rendered transcripts collapse "Do you" written
+            // as "Do\x1b[1Cyou" into "Doyou". That mis-rendering broke
+            // Claude Code's approval-prompt and prompt-line detection
+            // (parseApproval saw "Doyouwanttoproceed?" and returned null).
+            const line = this.lines[this.row];
+            for (let c = this.col; c < this.col + count; c += 1) {
+                if (line[c] === undefined) line[c] = ' ';
+            }
+            this.col += count;
+        }
         else if (final === 'D') this.col = Math.max(0, this.col - count);
         else if (final === 'G') this.col = Math.max(0, count - 1);
         else if (final === 'H' || final === 'f') {
@@ -484,17 +524,25 @@ export function findBinary(name: string): string {
         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'],
-            ...(isWin ? { windowsHide: true } : {}),
-        }).trim().split('\n')[0].trim();
-    } catch {
-        return isWin ? `${trimmed}.cmd` : trimmed;
+    const paths = (process.env.PATH || '').split(path.delimiter);
+    const exes = isWin ? ['.exe', '.cmd', '.bat', ''] : [''];
+    
+    for (const p of paths) {
+        if (!p) continue;
+        for (const ext of exes) {
+            const fullPath = path.join(p, trimmed + ext);
+            try {
+                const fs = require('fs');
+                if (fs.existsSync(fullPath)) {
+                    const stat = fs.statSync(fullPath);
+                    if (stat.isFile() && (isWin || (stat.mode & 0o111))) {
+                        return fullPath;
+                    }
+                }
+            } catch { }
+        }
     }
+    return isWin ? `${trimmed}.cmd` : trimmed;
 }
 
 export function isScriptBinary(binaryPath: string): boolean {

package/src/cli-adapters/raw-terminal-io.ts

@@ -0,0 +1,252 @@
+import { randomUUID } from 'crypto';
+import {
+    SessionHostClient,
+    type SessionHostEndpoint,
+    type SessionHostRequest,
+    type SessionHostResponse,
+    type SessionTerminalSnapshot,
+    type SessionTerminalState,
+} from '@adhdev/session-host-core';
+
+type LowercaseLetter =
+    | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm'
+    | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+
+type FunctionKey = 'f1' | 'f2' | 'f3' | 'f4' | 'f5' | 'f6' | 'f7' | 'f8' | 'f9' | 'f10' | 'f11' | 'f12';
+type BaseNamedKey =
+    | 'enter' | 'escape' | 'tab' | 'backspace'
+    | 'up' | 'down' | 'left' | 'right'
+    | 'home' | 'end' | 'pageup' | 'pagedown' | 'space'
+    | FunctionKey;
+type ShiftNamedKey = BaseNamedKey | LowercaseLetter | `ctrl+${LowercaseLetter}` | `alt+${LowercaseLetter}`;
+
+export type NamedKey =
+    | BaseNamedKey
+    | `ctrl+${LowercaseLetter}`
+    | `alt+${LowercaseLetter}`
+    | `shift+${ShiftNamedKey}`;
+
+const BASE_KEY_SEQUENCES: Record<BaseNamedKey, string> = {
+    enter: '\r',
+    escape: '\x1b',
+    tab: '\t',
+    backspace: '\x7f',
+    up: '\x1b[A',
+    down: '\x1b[B',
+    right: '\x1b[C',
+    left: '\x1b[D',
+    home: '\x1b[H',
+    end: '\x1b[F',
+    pageup: '\x1b[5~',
+    pagedown: '\x1b[6~',
+    space: ' ',
+    f1: '\x1bOP',
+    f2: '\x1bOQ',
+    f3: '\x1bOR',
+    f4: '\x1bOS',
+    f5: '\x1b[15~',
+    f6: '\x1b[17~',
+    f7: '\x1b[18~',
+    f8: '\x1b[19~',
+    f9: '\x1b[20~',
+    f10: '\x1b[21~',
+    f11: '\x1b[23~',
+    f12: '\x1b[24~',
+};
+
+const SHIFTED_CSI_KEYS: Partial<Record<BaseNamedKey, string>> = {
+    up: '\x1b[1;2A',
+    down: '\x1b[1;2B',
+    right: '\x1b[1;2C',
+    left: '\x1b[1;2D',
+    home: '\x1b[1;2H',
+    end: '\x1b[1;2F',
+    pageup: '\x1b[5;2~',
+    pagedown: '\x1b[6;2~',
+    f1: '\x1b[1;2P',
+    f2: '\x1b[1;2Q',
+    f3: '\x1b[1;2R',
+    f4: '\x1b[1;2S',
+    f5: '\x1b[15;2~',
+    f6: '\x1b[17;2~',
+    f7: '\x1b[18;2~',
+    f8: '\x1b[19;2~',
+    f9: '\x1b[20;2~',
+    f10: '\x1b[21;2~',
+    f11: '\x1b[23;2~',
+    f12: '\x1b[24;2~',
+};
+
+function isLowercaseLetter(value: string): value is LowercaseLetter {
+    return /^[a-z]$/.test(value);
+}
+
+function encodeControlLetter(letter: LowercaseLetter): string {
+    return String.fromCharCode(letter.charCodeAt(0) - 96);
+}
+
+function encodeShiftedKey(key: string): string {
+    if (isLowercaseLetter(key)) return key.toUpperCase();
+    if (key.startsWith('ctrl+') && isLowercaseLetter(key.slice(5))) {
+        return encodeControlLetter(key.slice(5) as LowercaseLetter);
+    }
+    if (key.startsWith('alt+') && isLowercaseLetter(key.slice(4))) {
+        return `\x1b${key.slice(4).toUpperCase()}`;
+    }
+    if (key === 'tab') return '\x1b[Z';
+    if (key in SHIFTED_CSI_KEYS) return SHIFTED_CSI_KEYS[key as BaseNamedKey]!;
+    if (key in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[key as BaseNamedKey];
+    throw new Error(`Unsupported named key: shift+${key}`);
+}
+
+export function namedKeyToAnsi(key: NamedKey | string): string {
+    const normalized = String(key || '').trim().toLowerCase();
+    if (normalized in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[normalized as BaseNamedKey];
+    if (normalized.startsWith('ctrl+') && isLowercaseLetter(normalized.slice(5))) {
+        return encodeControlLetter(normalized.slice(5) as LowercaseLetter);
+    }
+    if (normalized.startsWith('alt+') && isLowercaseLetter(normalized.slice(4))) {
+        return `\x1b${normalized.slice(4)}`;
+    }
+    if (normalized.startsWith('shift+')) return encodeShiftedKey(normalized.slice(6));
+    throw new Error(`Unsupported named key: ${key}`);
+}
+
+export function namedKeysToAnsi(keys: readonly (NamedKey | string)[]): string {
+    if (!Array.isArray(keys)) throw new Error('keys must be an array');
+    return keys.map(namedKeyToAnsi).join('');
+}
+
+export interface RawTerminalSessionHostClient {
+    connect(): Promise<void>;
+    request<T = unknown>(request: SessionHostRequest): Promise<SessionHostResponse<T>>;
+    close(): Promise<void>;
+}
+
+export interface RawTerminalAttachmentOptions {
+    endpoint?: SessionHostEndpoint;
+    sessionId: string;
+    mode?: 'read' | 'write';
+    clientId?: string;
+    client?: RawTerminalSessionHostClient;
+}
+
+export class RawTerminalAttachment {
+    private closed = false;
+
+    private constructor(
+        readonly sessionId: string,
+        private readonly clientId: string,
+        private readonly mode: 'read' | 'write',
+        private readonly client: RawTerminalSessionHostClient,
+    ) {}
+
+    static async attach(options: RawTerminalAttachmentOptions): Promise<RawTerminalAttachment> {
+        const sessionId = String(options.sessionId || '').trim();
+        if (!sessionId) throw new Error('sessionId is required');
+        const mode = options.mode || 'read';
+        const clientId = options.clientId || `raw-terminal-${process.pid}-${randomUUID().slice(0, 8)}`;
+        const client = options.client || new SessionHostClient({ endpoint: options.endpoint });
+        await client.connect();
+
+        const attachResponse = await client.request({
+            type: 'attach_session',
+            payload: {
+                sessionId,
+                clientId,
+                clientType: 'web',
+                readOnly: mode === 'read',
+            },
+        });
+        if (!attachResponse.success) {
+            await client.close().catch(() => {});
+            throw new Error(attachResponse.error || `Failed to attach terminal session ${sessionId}`);
+        }
+
+        if (mode === 'write') {
+            const ownerResponse = await client.request({
+                type: 'acquire_write',
+                payload: {
+                    sessionId,
+                    clientId,
+                    ownerType: 'user',
+                    force: true,
+                },
+            });
+            if (!ownerResponse.success) {
+                await client.request({
+                    type: 'detach_session',
+                    payload: { sessionId, clientId },
+                }).catch(() => ({ success: false }));
+                await client.close().catch(() => {});
+                throw new Error(ownerResponse.error || `Failed to acquire terminal session ${sessionId}`);
+            }
+        }
+
+        return new RawTerminalAttachment(sessionId, clientId, mode, client);
+    }
+
+    async readSnapshot(): Promise<SessionTerminalSnapshot> {
+        const response = await this.client.request<SessionTerminalSnapshot>({
+            type: 'get_terminal_snapshot',
+            payload: { sessionId: this.sessionId },
+        });
+        if (!response.success || !response.result) {
+            throw new Error(response.error || `Terminal screen unavailable for ${this.sessionId}`);
+        }
+        return response.result;
+    }
+
+    async readScreenText(): Promise<string> {
+        return (await this.readSnapshot()).text;
+    }
+
+    async readState(): Promise<SessionTerminalState> {
+        return (await this.readSnapshot()).state;
+    }
+
+    async writeInput(text: string): Promise<void> {
+        if (this.mode !== 'write') throw new Error('Raw terminal attachment is read-only');
+        const response = await this.client.request({
+            type: 'send_input',
+            payload: {
+                sessionId: this.sessionId,
+                clientId: this.clientId,
+                data: text,
+            },
+        });
+        if (!response.success) throw new Error(response.error || `Failed to write terminal input to ${this.sessionId}`);
+    }
+
+    async writeKeys(keys: readonly (NamedKey | string)[]): Promise<void> {
+        await this.writeInput(namedKeysToAnsi(keys));
+    }
+
+    async close(): Promise<void> {
+        if (this.closed) return;
+        this.closed = true;
+        if (this.mode === 'write') {
+            await this.client.request({
+                type: 'release_write',
+                payload: { sessionId: this.sessionId, clientId: this.clientId },
+            }).catch(() => ({ success: false }));
+        }
+        await this.client.request({
+            type: 'detach_session',
+            payload: { sessionId: this.sessionId, clientId: this.clientId },
+        }).catch(() => ({ success: false }));
+        await this.client.close().catch(() => {});
+    }
+}
+
+export async function withRawTerminalAttachment<T>(
+    options: RawTerminalAttachmentOptions,
+    operation: (attachment: RawTerminalAttachment) => Promise<T>,
+): Promise<T> {
+    const attachment = await RawTerminalAttachment.attach(options);
+    try {
+        return await operation(attachment);
+    } finally {
+        await attachment.close();
+    }
+}

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

@@ -121,7 +121,23 @@ export class GhosttyVtTerminalBackend implements TerminalViewportBackend {
     }
 
     getText(): string {
-        return this.terminal.formatPlainText({ trim: true }) || '';
+        // (fix) ghostty's `trim:true` mode strips trailing whitespace per row
+        // AND collapses cells that were touched only by cursor-forward (ESC[<n>C)
+        // without a printable glyph. Many TUIs (Claude Code most prominently)
+        // render inter-word spaces via CUF rather than literal spaces, so
+        // trim:true would smash "Do you want to proceed?" into
+        // "Doyouwanttoproceed?" and break every downstream regex
+        // (approval detection, prompt-line discovery, etc.). Keep the per-row
+        // padding, then trim each row's trailing whitespace ourselves so the
+        // serialized text matches what the user sees in the terminal.
+        const raw = this.terminal.formatPlainText({ trim: false }) || '';
+        if (!raw) return '';
+        const lines = raw.split('\n').map((row) => row.replace(/\s+$/, ''));
+        let first = 0;
+        let last = lines.length;
+        while (first < last && !lines[first]) first += 1;
+        while (last > first && !lines[last - 1]) last -= 1;
+        return lines.slice(first, last).join('\n');
     }
 
     getCursorPosition(): { col: number; row: number } {

package/src/cli-adapters/terminal-backends/xterm-backend.ts

@@ -64,7 +64,14 @@ export class XtermTerminalBackend implements TerminalViewportBackend {
 
         for (let i = start; i < end; i++) {
             const line = buffer.getLine(i);
-            lines.push(line ? line.translateToString(true) : '');
+            // (fix) translateToString(true) strips trailing whitespace per row
+            // AND collapses cells touched only by cursor-forward (ESC[<n>C),
+            // so Claude Code's "Do you want to proceed?" arrives as
+            // "Doyouwanttoproceed?" — every downstream approval/prompt regex
+            // misses. Use false to preserve inter-word padding; we trim each
+            // row's trailing whitespace ourselves below.
+            const raw = line ? line.translateToString(false) : '';
+            lines.push(raw.replace(/\s+$/, ''));
         }
 
         let first = 0;