@adhdev/daemon-core 0.7.5 → 0.7.7

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

@@ -0,0 +1,392 @@
+import {
+    SessionHostClient,
+    type SessionHostEndpoint,
+    type SessionHostEvent,
+    type SessionHostCategory,
+    type SessionHostRecord,
+} from '@adhdev/session-host-core';
+import { LOG } from '../logging/logger.js';
+import type { PtyRuntimeMetadata, PtyRuntimeTransport, PtySpawnOptions, PtyTransportFactory } from './pty-transport.js';
+
+interface SessionHostPtyTransportFactoryOptions {
+    endpoint?: SessionHostEndpoint;
+    appName?: string;
+    clientId: string;
+    runtimeId: string;
+    providerType: string;
+    category?: SessionHostCategory;
+    workspace: string;
+    meta?: Record<string, unknown>;
+    attachExisting?: boolean;
+}
+
+interface SessionHostRuntimeOptions extends SessionHostPtyTransportFactoryOptions {
+    command: string;
+    args: string[];
+    spawnOptions: PtySpawnOptions;
+}
+
+class SessionHostRuntimeTransport implements PtyRuntimeTransport {
+    readonly ready: Promise<void>;
+
+    private readonly client: SessionHostClient;
+    private readonly dataCallbacks = new Set<(data: string) => void>();
+    private readonly exitCallbacks = new Set<(info: { exitCode: number }) => void>();
+    private readonly pendingOutput: string[] = [];
+    private operationChain = Promise.resolve();
+    private unsubscribe: (() => void) | null = null;
+    private currentPid = 0;
+    private closed = false;
+    private metadata: PtyRuntimeMetadata | null = null;
+
+    constructor(private readonly options: SessionHostRuntimeOptions) {
+        this.client = new SessionHostClient({
+            endpoint: options.endpoint,
+            appName: options.appName,
+        });
+        this.ready = this.boot();
+    }
+
+    get pid(): number {
+        return this.currentPid;
+    }
+
+    getMetadata(): PtyRuntimeMetadata | null {
+        return this.metadata ? {
+            ...this.metadata,
+            writeOwner: this.metadata.writeOwner ? { ...this.metadata.writeOwner } : null,
+            attachedClients: this.metadata.attachedClients?.map((client) => ({ ...client })) || [],
+        } : null;
+    }
+
+    onData(callback: (data: string) => void): void {
+        this.dataCallbacks.add(callback);
+        if (this.pendingOutput.length > 0) {
+            for (const chunk of this.pendingOutput.splice(0)) {
+                callback(chunk);
+            }
+        }
+    }
+
+    onExit(callback: (info: { exitCode: number }) => void): void {
+        this.exitCallbacks.add(callback);
+    }
+
+    write(data: string): void {
+        this.enqueue(async () => {
+            let response = await this.client.request({
+                type: 'send_input',
+                payload: {
+                    sessionId: this.options.runtimeId,
+                    clientId: this.options.clientId,
+                    data,
+                },
+            });
+            if (!response.success && response.error?.startsWith('Write owned by ')) {
+                const ownerResponse = await this.client.request<SessionHostRecord>({
+                    type: 'acquire_write',
+                    payload: {
+                        sessionId: this.options.runtimeId,
+                        clientId: this.options.clientId,
+                        ownerType: 'user',
+                        force: true,
+                    },
+                });
+                if (ownerResponse.success && ownerResponse.result) {
+                    this.updateMetadata(ownerResponse.result);
+                    response = await this.client.request({
+                        type: 'send_input',
+                        payload: {
+                            sessionId: this.options.runtimeId,
+                            clientId: this.options.clientId,
+                            data,
+                        },
+                    });
+                }
+            }
+            if (!response.success) {
+                throw new Error(response.error || `Failed to write to runtime ${this.options.runtimeId}`);
+            }
+        });
+    }
+
+    resize(cols: number, rows: number): void {
+        this.enqueue(async () => {
+            await this.client.request({
+                type: 'resize_session',
+                payload: {
+                    sessionId: this.options.runtimeId,
+                    cols,
+                    rows,
+                },
+            });
+        });
+    }
+
+    kill(): void {
+        this.enqueue(async () => {
+            await this.client.request({
+                type: 'stop_session',
+                payload: { sessionId: this.options.runtimeId },
+            });
+            await this.closeClient(false);
+        });
+    }
+
+    clearBuffer(): void {
+        this.enqueue(async () => {
+            const response = await this.client.request<SessionHostRecord>({
+                type: 'clear_session_buffer',
+                payload: {
+                    sessionId: this.options.runtimeId,
+                },
+            });
+            if (!response.success) {
+                throw new Error(response.error || `Failed to clear runtime buffer ${this.options.runtimeId}`);
+            }
+            if (response.result) {
+                this.updateMetadata(response.result);
+            }
+        });
+    }
+
+    detach(): void {
+        this.enqueue(async () => {
+            await this.client.request({
+                type: 'release_write',
+                payload: {
+                    sessionId: this.options.runtimeId,
+                    clientId: this.options.clientId,
+                },
+            }).catch(() => ({ success: false }));
+            await this.client.request({
+                type: 'detach_session',
+                payload: {
+                    sessionId: this.options.runtimeId,
+                    clientId: this.options.clientId,
+                },
+            }).catch(() => ({ success: false }));
+            await this.closeClient(false);
+        });
+    }
+
+    private async boot(): Promise<void> {
+        await this.client.connect();
+        this.unsubscribe = this.client.onEvent((event: SessionHostEvent) => this.handleEvent(event));
+
+        let record: SessionHostRecord | null = null;
+        if (this.options.attachExisting) {
+            const existingRecords = await this.client.request<SessionHostRecord[]>({
+                type: 'list_sessions',
+                payload: {},
+            });
+            const existingRecord = existingRecords.success && existingRecords.result
+                ? existingRecords.result.find((item) => item.sessionId === this.options.runtimeId) || null
+                : null;
+            if (existingRecord?.lifecycle === 'interrupted') {
+                const resumeResponse = await this.client.request<SessionHostRecord>({
+                    type: 'resume_session',
+                    payload: {
+                        sessionId: this.options.runtimeId,
+                    },
+                });
+                if (!resumeResponse.success) {
+                    LOG.warn('CLI', `[session-host:${this.options.runtimeId}] resume failed: ${resumeResponse.error || 'unknown error'}`);
+                }
+            }
+            const attachResponse = await this.client.request<SessionHostRecord>({
+                type: 'attach_session',
+                payload: {
+                    sessionId: this.options.runtimeId,
+                    clientId: this.options.clientId,
+                    clientType: 'daemon',
+                    readOnly: false,
+                },
+            });
+            if (!attachResponse.success || !attachResponse.result) {
+                throw new Error(attachResponse.error || `Failed to attach runtime ${this.options.runtimeId}`);
+            }
+            record = attachResponse.result;
+        } else {
+            const createResponse = await this.client.request<SessionHostRecord>({
+                type: 'create_session',
+                payload: {
+                    sessionId: this.options.runtimeId,
+                    providerType: this.options.providerType,
+                    category: this.options.category || 'cli',
+                    workspace: this.options.workspace,
+                    launchCommand: {
+                        command: this.options.command,
+                        args: this.options.args,
+                        env: this.options.spawnOptions.env,
+                    },
+                    cols: this.options.spawnOptions.cols,
+                    rows: this.options.spawnOptions.rows,
+                    clientId: this.options.clientId,
+                    clientType: 'daemon',
+                    meta: this.options.meta,
+                },
+            });
+            if (!createResponse.success || !createResponse.result) {
+                throw new Error(createResponse.error || `Failed to create runtime ${this.options.runtimeId}`);
+            }
+            record = createResponse.result;
+        }
+
+        this.currentPid = record.osPid || 0;
+        this.updateMetadata(record);
+
+        const ownerResponse = await this.client.request<SessionHostRecord>({
+            type: 'acquire_write',
+            payload: {
+                sessionId: this.options.runtimeId,
+                clientId: this.options.clientId,
+                ownerType: 'agent',
+                force: !this.options.attachExisting,
+            },
+        });
+        if (!ownerResponse.success) {
+            if (this.options.attachExisting && ownerResponse.error?.startsWith('Write owned by ')) {
+                LOG.info('CLI', `[session-host:${this.options.runtimeId}] attached without write ownership (${ownerResponse.error})`);
+            } else {
+                throw new Error(ownerResponse.error || `Failed to acquire write owner for ${this.options.runtimeId}`);
+            }
+        } else if (ownerResponse.result) {
+            this.updateMetadata(ownerResponse.result);
+        }
+
+        if (this.options.attachExisting) {
+            const snapshotResponse = await this.client.request<{ seq: number; text: string; truncated: boolean }>({
+                type: 'get_snapshot',
+                payload: {
+                    sessionId: this.options.runtimeId,
+                },
+            });
+            if (!snapshotResponse.success) {
+                throw new Error(snapshotResponse.error || `Failed to load snapshot for ${this.options.runtimeId}`);
+            }
+            const text = snapshotResponse.result?.text || '';
+            if (text) {
+                this.emitData(text);
+            }
+        }
+    }
+
+    private handleEvent(event: SessionHostEvent): void {
+        if (event.sessionId !== this.options.runtimeId) return;
+        if ((event.type === 'session_started' || event.type === 'session_resumed') && typeof event.pid === 'number') {
+            this.currentPid = event.pid;
+            return;
+        }
+        if (event.type === 'write_owner_changed') {
+            this.metadata = {
+                ...(this.metadata || { runtimeId: this.options.runtimeId }),
+                writeOwner: event.owner ? {
+                    clientId: event.owner.clientId,
+                    ownerType: event.owner.ownerType,
+                } : null,
+            };
+            return;
+        }
+        if (event.type === 'client_attached') {
+            const nextClients = new Map(
+                (this.metadata?.attachedClients || []).map((client) => [client.clientId, client] as const),
+            );
+            nextClients.set(event.client.clientId, {
+                clientId: event.client.clientId,
+                type: event.client.type,
+                readOnly: event.client.readOnly,
+            });
+            this.metadata = {
+                ...(this.metadata || { runtimeId: this.options.runtimeId }),
+                attachedClients: Array.from(nextClients.values()),
+            };
+            return;
+        }
+        if (event.type === 'client_detached') {
+            this.metadata = {
+                ...(this.metadata || { runtimeId: this.options.runtimeId }),
+                attachedClients: (this.metadata?.attachedClients || []).filter((client) => client.clientId !== event.clientId),
+            };
+            return;
+        }
+        if (event.type === 'session_output') {
+            this.emitData(event.data);
+            return;
+        }
+        if (event.type === 'session_cleared') {
+            this.pendingOutput.length = 0;
+            return;
+        }
+        if (event.type === 'session_exit') {
+            for (const callback of this.exitCallbacks) {
+                callback({ exitCode: event.exitCode ?? 0 });
+            }
+            void this.closeClient(false);
+        }
+    }
+
+    private emitData(data: string): void {
+        if (this.dataCallbacks.size === 0) {
+            this.pendingOutput.push(data);
+            return;
+        }
+        for (const callback of this.dataCallbacks) {
+            callback(data);
+        }
+    }
+
+    private updateMetadata(record: SessionHostRecord): void {
+        this.metadata = {
+            runtimeId: record.sessionId,
+            runtimeKey: record.runtimeKey,
+            displayName: record.displayName,
+            workspaceLabel: record.workspaceLabel,
+            writeOwner: record.writeOwner ? {
+                clientId: record.writeOwner.clientId,
+                ownerType: record.writeOwner.ownerType,
+            } : null,
+            attachedClients: record.attachedClients.map((client: SessionHostRecord['attachedClients'][number]) => ({
+                clientId: client.clientId,
+                type: client.type,
+                readOnly: client.readOnly,
+            })),
+        };
+    }
+
+    private enqueue(action: () => Promise<void>): void {
+        this.operationChain = this.operationChain
+            .then(() => this.ready)
+            .then(action)
+            .catch((error) => {
+                LOG.warn('CLI', `[session-host:${this.options.runtimeId}] ${error?.message || error}`);
+            });
+    }
+
+    private async closeClient(destroy = false): Promise<void> {
+        if (this.closed) return;
+        this.closed = true;
+        try {
+            this.unsubscribe?.();
+            this.unsubscribe = null;
+        } catch { /* noop */ }
+        try {
+            await this.client.close();
+        } catch {
+            if (destroy) throw new Error(`Failed to close session host client: ${this.options.runtimeId}`);
+        }
+    }
+}
+
+export class SessionHostPtyTransportFactory implements PtyTransportFactory {
+    constructor(private readonly options: SessionHostPtyTransportFactoryOptions) {}
+
+    spawn(command: string, args: string[], spawnOptions: PtySpawnOptions): PtyRuntimeTransport {
+        return new SessionHostRuntimeTransport({
+            ...this.options,
+            command,
+            args,
+            spawnOptions,
+        });
+    }
+}

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

@@ -0,0 +1,126 @@
+import type {
+    TerminalViewportBackend,
+    TerminalViewportBackendOptions,
+    TerminalViewportBackendPreference,
+} from './types.js';
+
+type GhosttyVtTerminal = {
+    write(data: string | Uint8Array): void;
+    resize(cols: number, rows: number): void;
+    formatPlainText(options?: { trim?: boolean }): string;
+    dispose(): void;
+};
+
+type GhosttyVtBinding = {
+    createTerminal(options: { cols: number; rows: number; scrollback: number }): GhosttyVtTerminal;
+};
+
+const DEFAULT_BINDING_CANDIDATES = [
+    '@adhdev/ghostty-vt-node',
+];
+
+let cachedBinding: GhosttyVtBinding | null | undefined;
+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;
+    return code === 'MODULE_NOT_FOUND' && message.includes(ref);
+}
+
+function normalizeBinding(mod: any, ref: string): GhosttyVtBinding {
+    const binding = mod?.default?.createTerminal
+        ? mod.default
+        : mod?.createTerminal
+            ? mod
+            : null;
+
+    if (!binding) {
+        throw new Error(`Ghostty VT binding "${ref}" does not export createTerminal()`);
+    }
+
+    return binding as GhosttyVtBinding;
+}
+
+function getBindingCandidates(): string[] {
+    const explicit = process.env.ADHDEV_GHOSTTY_VT_BINDING?.trim();
+    return explicit ? [explicit] : DEFAULT_BINDING_CANDIDATES;
+}
+
+function loadGhosttyVtBinding(required: boolean): GhosttyVtBinding | null {
+    if (cachedBinding !== undefined) {
+        if (!cachedBinding && required && cachedBindingError) {
+            throw cachedBindingError;
+        }
+        return cachedBinding;
+    }
+
+    const errors: string[] = [];
+
+    for (const ref of getBindingCandidates()) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const mod = require(ref);
+            cachedBinding = normalizeBinding(mod, ref);
+            cachedBindingError = null;
+            return cachedBinding;
+        } catch (error) {
+            if (isModuleNotFoundError(error, ref)) {
+                errors.push(`${ref}: module not found`);
+                continue;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            errors.push(`${ref}: ${message}`);
+        }
+    }
+
+    cachedBinding = null;
+    cachedBindingError = new Error(
+        `ghostty-vt backend requested but no binding is available (${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);
+}
+
+export class GhosttyVtTerminalBackend implements TerminalViewportBackend {
+    readonly kind = 'ghostty-vt' as const;
+    private terminal: GhosttyVtTerminal;
+
+    constructor(options: TerminalViewportBackendOptions) {
+        const binding = loadGhosttyVtBinding(true);
+        this.terminal = binding.createTerminal({
+            cols: Math.max(1, options.cols | 0),
+            rows: Math.max(1, options.rows | 0),
+            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));
+    }
+
+    write(data: string): void {
+        if (!data) return;
+        this.terminal.write(data);
+    }
+
+    getText(): string {
+        return this.terminal.formatPlainText({ trim: true }) || '';
+    }
+
+    dispose(): void {
+        this.terminal.dispose();
+    }
+}

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

@@ -0,0 +1,17 @@
+export type TerminalViewportBackendKind = 'xterm' | 'ghostty-vt';
+
+export type TerminalViewportBackendPreference = TerminalViewportBackendKind | 'auto';
+
+export type TerminalViewportBackendOptions = {
+    rows: number;
+    cols: number;
+    scrollback: number;
+};
+
+export interface TerminalViewportBackend {
+    readonly kind: TerminalViewportBackendKind;
+    resize(rows: number, cols: number): void;
+    write(data: string): void;
+    getText(): string;
+    dispose(): void;
+}

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

@@ -0,0 +1,87 @@
+import type { TerminalViewportBackend, TerminalViewportBackendOptions } from './types.js';
+
+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 XtermTerminalBackend implements TerminalViewportBackend {
+    readonly kind = 'xterm' as const;
+    private rows: number;
+    private cols: number;
+    private terminal: XtermTerminal;
+
+    constructor(options: TerminalViewportBackendOptions) {
+        this.rows = Math.max(1, options.rows | 0);
+        this.cols = Math.max(1, options.cols | 0);
+        this.terminal = this.createTerminal(options.scrollback);
+    }
+
+    resize(rows: number, cols: number): void {
+        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 {
+        if (!data) return;
+        this.terminal.write(data);
+    }
+
+    getText(): string {
+        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) : '');
+        }
+
+        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');
+    }
+
+    dispose(): void {
+        this.terminal.dispose();
+    }
+
+    private createTerminal(scrollback: number): XtermTerminal {
+        const Terminal = loadTerminalCtor();
+        return new Terminal({
+            cols: this.cols,
+            rows: this.rows,
+            scrollback,
+        });
+    }
+}