@adhdev/daemon-core 0.9.82-rc.32 → 0.9.82-rc.320

package/src/cli-adapters/session-host-transport.ts

@@ -6,6 +6,7 @@ import {
     type SessionHostRecord,
 } from '@adhdev/session-host-core';
 import { LOG } from '../logging/logger.js';
+import { resolveWin32Executable } from './resolve-executable.js';
 import type { PtyRuntimeMetadata, PtyRuntimeTransport, PtySpawnOptions, PtyTransportFactory } from './pty-transport.js';
 
 interface SessionHostPtyTransportFactoryOptions {
@@ -435,7 +436,7 @@ export class SessionHostPtyTransportFactory implements PtyTransportFactory {
     spawn(command: string, args: string[], spawnOptions: PtySpawnOptions): PtyRuntimeTransport {
         return new SessionHostRuntimeTransport({
             ...this.options,
-            command,
+            command: resolveWin32Executable(command),
             args,
             spawnOptions,
         });

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

@@ -1,7 +1,6 @@
 import type {
     TerminalViewportBackend,
     TerminalViewportBackendOptions,
-    TerminalViewportBackendPreference,
 } from './types.js';
 
 type GhosttyVtTerminal = {
@@ -49,12 +48,10 @@ function getBindingCandidates(): string[] {
     return explicit ? [explicit] : DEFAULT_BINDING_CANDIDATES;
 }
 
-function loadGhosttyVtBinding(required: boolean): GhosttyVtBinding | null {
+function loadGhosttyVtBinding(): GhosttyVtBinding {
     if (cachedBinding !== undefined) {
-        if (!cachedBinding && required && cachedBindingError) {
-            throw cachedBindingError;
-        }
-        return cachedBinding;
+        if (!cachedBinding && cachedBindingError) throw cachedBindingError;
+        return cachedBinding!;
     }
 
     const errors: string[] = [];
@@ -65,7 +62,7 @@ function loadGhosttyVtBinding(required: boolean): GhosttyVtBinding | null {
             const mod = require(ref);
             cachedBinding = normalizeBinding(mod, ref);
             cachedBindingError = null;
-            return cachedBinding;
+            return cachedBinding!;
         } catch (error) {
             if (isModuleNotFoundError(error, ref)) {
                 errors.push(`${ref}: module not found`);
@@ -78,57 +75,84 @@ function loadGhosttyVtBinding(required: boolean): GhosttyVtBinding | null {
 
     cachedBinding = null;
     cachedBindingError = new Error(
-        `ghostty-vt backend requested but no binding is available (${errors.join('; ') || 'no candidates tried'})`,
+        `ghostty-vt binding unavailable (${errors.join('; ') || 'no candidates tried'})`,
     );
-
-    if (required) throw cachedBindingError;
-    return null;
-}
-
-export function resolveTerminalBackendPreference(): TerminalViewportBackendPreference {
-    const raw = process.env.ADHDEV_TERMINAL_BACKEND?.trim().toLowerCase();
-    if (raw === 'ghostty-vt' || raw === 'xterm' || raw === 'auto') return raw;
-    return 'auto';
-}
-
-export function isGhosttyVtBackendAvailable(): boolean {
-    return !!loadGhosttyVtBinding(false);
+    throw cachedBindingError;
 }
 
 export class GhosttyVtTerminalBackend implements TerminalViewportBackend {
     readonly kind = 'ghostty-vt' as const;
     private terminal: GhosttyVtTerminal;
+    private rows: number;
+    private disposed = false;
 
     constructor(options: TerminalViewportBackendOptions) {
-        const binding = loadGhosttyVtBinding(true);
-        if (!binding) {
-            throw new Error('ghostty-vt backend requested but no binding is available');
-        }
+        const binding = loadGhosttyVtBinding();
+        this.rows = Math.max(1, options.rows | 0);
         this.terminal = binding.createTerminal({
             cols: Math.max(1, options.cols | 0),
-            rows: Math.max(1, options.rows | 0),
+            rows: this.rows,
             scrollback: Math.max(0, options.scrollback | 0),
         });
     }
 
     resize(rows: number, cols: number): void {
-        this.terminal.resize(Math.max(1, cols | 0), Math.max(1, rows | 0));
+        this.rows = Math.max(1, rows | 0);
+        this.terminal.resize(Math.max(1, cols | 0), this.rows);
     }
 
     write(data: string): void {
-        if (!data) return;
+        if (!data || this.disposed) return;
         this.terminal.write(data);
     }
 
+    private formatLines(): string[] {
+        // ghostty's `trim:true` collapses CUF-advanced cells — many TUIs including
+        // Claude Code render spaces via cursor-forward rather than literal spaces,
+        // which would break downstream regex matching. Keep per-row padding and
+        // trim trailing whitespace ourselves.
+        //
+        // formatPlainText uses a .screen pin which includes scrollback history.
+        const raw = this.terminal.formatPlainText({ trim: false }) || '';
+        if (!raw) return [];
+        return raw.split('\n').map((row) => row.replace(/\s+$/, ''));
+    }
+
+    private static trimBlankEnds(lines: string[]): string {
+        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');
+    }
+
     getText(): string {
-        return this.terminal.formatPlainText({ trim: true }) || '';
+        if (this.disposed) return '';
+        const lines = this.formatLines();
+        if (lines.length === 0) return '';
+        // Take only the viewport (last `rows` lines) to exclude scrollback history.
+        const viewport = lines.length > this.rows ? lines.slice(-this.rows) : lines;
+        return GhosttyVtTerminalBackend.trimBlankEnds(viewport);
+    }
+
+    getTextWithScrollback(): string {
+        if (this.disposed) return '';
+        const lines = this.formatLines();
+        if (lines.length === 0) return '';
+        // Full buffer including scrollback — does NOT slice to the viewport, so a
+        // tall prompt whose top has scrolled above the visible rows is still
+        // matchable by content patterns.
+        return GhosttyVtTerminalBackend.trimBlankEnds(lines);
     }
 
     getCursorPosition(): { col: number; row: number } {
+        if (this.disposed) return { col: 0, row: 0 };
         return this.terminal.getCursorPosition();
     }
 
     dispose(): void {
+        if (this.disposed) return;
+        this.disposed = true;
         this.terminal.dispose();
     }
 }

package/src/cli-adapters/terminal-backends/types.ts

@@ -1,6 +1,4 @@
-export type TerminalViewportBackendKind = 'xterm' | 'ghostty-vt';
-
-export type TerminalViewportBackendPreference = TerminalViewportBackendKind | 'auto';
+export type TerminalViewportBackendKind = 'ghostty-vt';
 
 export type TerminalViewportBackendOptions = {
     rows: number;
@@ -13,6 +11,15 @@ export interface TerminalViewportBackend {
     resize(rows: number, cols: number): void;
     write(data: string): void;
     getText(): string;
+    /**
+     * Like getText() but includes scrollback history (the lines that have
+     * scrolled above the visible viewport). Used by content-pattern matching
+     * (e.g. approval/modal button extraction) that must stay correct when a
+     * tall prompt — a big diff or long explanation — pushes part of the
+     * prompt box above the viewport. NOT for cursor-relative / stable_ms
+     * conditions, whose row indices are viewport-relative.
+     */
+    getTextWithScrollback(): string;
     getCursorPosition(): { col: number; row: number };
     dispose(): void;
 }

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

@@ -1,99 +1,29 @@
 /**
- * PTY screen snapshot abstraction.
- *
- * Terminal viewport backend selection.
- *
- * Runtime preference is backend-agnostic:
- * - prefer ghostty-vt when available (or when explicitly requested)
- * - fall back to xterm when ghostty-vt is unavailable
+ * PTY screen snapshot abstraction — ghostty-vt backend.
  */
 
-import { LOG } from '../logging/logger.js';
-import { GhosttyVtTerminalBackend, isGhosttyVtBackendAvailable, resolveTerminalBackendPreference } from './terminal-backends/ghostty-vt-backend.js';
-import type {
-    TerminalViewportBackend,
-    TerminalViewportBackendKind,
-    TerminalViewportBackendOptions,
-    TerminalViewportBackendPreference,
-} from './terminal-backends/types.js';
-import { XtermTerminalBackend } from './terminal-backends/xterm-backend.js';
+import { GhosttyVtTerminalBackend } from './terminal-backends/ghostty-vt-backend.js';
+import type { TerminalViewportBackendKind } from './terminal-backends/types.js';
+import { DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS } from '@adhdev/session-host-core';
 
 const DEFAULT_SCROLLBACK = 2000;
-const loggedTerminalBackends = new Set<string>();
 
 export function getTerminalBackendRuntimeStatus(): {
     backend: TerminalViewportBackendKind;
-    preference: TerminalViewportBackendPreference;
-    ghosttyAvailable: boolean;
 } {
-    const preference = resolveTerminalBackendPreference();
-    const ghosttyAvailable = isGhosttyVtBackendAvailable();
-    const backend: TerminalViewportBackendKind = (
-        preference === 'ghostty-vt' || (preference === 'auto' && ghosttyAvailable)
-            ? 'ghostty-vt'
-            : 'xterm'
-    );
-    return { backend, preference, ghosttyAvailable };
-}
-
-function createTerminalBackend(
-    options: TerminalViewportBackendOptions,
-    preference: TerminalViewportBackendPreference,
-): TerminalViewportBackend {
-    const ghosttyAvailable = isGhosttyVtBackendAvailable();
-    if (preference === 'ghostty-vt') {
-        const backend = new GhosttyVtTerminalBackend(options);
-        logTerminalBackendSelection(preference, ghosttyAvailable, backend.kind);
-        return backend;
-    }
-
-    if (preference === 'auto' && ghosttyAvailable) {
-        const backend = new GhosttyVtTerminalBackend(options);
-        logTerminalBackendSelection(preference, ghosttyAvailable, backend.kind);
-        return backend;
-    }
-
-    const backend = new XtermTerminalBackend(options);
-    logTerminalBackendSelection(preference, ghosttyAvailable, backend.kind);
-    return backend;
-}
-
-function logTerminalBackendSelection(
-    preference: TerminalViewportBackendPreference,
-    ghosttyAvailable: boolean,
-    backendKind: TerminalViewportBackendKind,
-): void {
-    const key = `${preference}:${ghosttyAvailable}:${backendKind}`;
-    if (loggedTerminalBackends.has(key)) return;
-    loggedTerminalBackends.add(key);
-    if (backendKind === 'xterm' && preference !== 'xterm' && !ghosttyAvailable) {
-        const message = `[terminal-screen] ghostty-vt unavailable; using xterm fallback (preference=${preference})`;
-        if (preference === 'auto') {
-            LOG.info('Terminal', message);
-        } else {
-            LOG.warn('Terminal', message);
-        }
-        return;
-    }
-    LOG.info(
-        'Terminal',
-        `[terminal-screen] backend=${backendKind} preference=${preference} ghosttyAvailable=${ghosttyAvailable}`,
-    );
+    return { backend: 'ghostty-vt' };
 }
 
 export class TerminalScreen {
-    readonly backendKind: TerminalViewportBackendKind;
+    readonly backendKind: TerminalViewportBackendKind = 'ghostty-vt';
     private rows: number;
     private cols: number;
-    private readonly preference: TerminalViewportBackendPreference;
-    private terminal: TerminalViewportBackend;
+    private terminal: GhosttyVtTerminalBackend;
 
-    constructor(rows = 40, cols = 120) {
+    constructor(rows = DEFAULT_SESSION_HOST_ROWS, cols = DEFAULT_SESSION_HOST_COLS) {
         this.rows = Math.max(1, rows | 0);
         this.cols = Math.max(1, cols | 0);
-        this.preference = resolveTerminalBackendPreference();
         this.terminal = this.createBackend();
-        this.backendKind = this.terminal.kind;
     }
 
     reset(rows = this.rows, cols = this.cols): void {
@@ -117,6 +47,11 @@ export class TerminalScreen {
         return this.terminal.getText();
     }
 
+    /** Full buffer including scrollback history (see backend doc). */
+    getTextWithScrollback(): string {
+        return this.terminal.getTextWithScrollback();
+    }
+
     getCursorPosition(): { col: number; row: number } {
         return this.terminal.getCursorPosition();
     }
@@ -125,11 +60,11 @@ export class TerminalScreen {
         this.terminal.dispose();
     }
 
-    private createBackend(): TerminalViewportBackend {
-        return createTerminalBackend({
+    private createBackend(): GhosttyVtTerminalBackend {
+        return new GhosttyVtTerminalBackend({
             cols: this.cols,
             rows: this.rows,
             scrollback: DEFAULT_SCROLLBACK,
-        }, this.preference);
+        });
     }
 }