@adhdev/daemon-core 0.8.33 → 0.8.35

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

@@ -0,0 +1,29 @@
+import type { PtySpawnOptions, PtyRuntimeTransport } from './pty-transport.js';
+import type { TerminalScreen } from './terminal-screen.js';
+import { type CliProviderModule } from './provider-cli-shared.js';
+export interface CliSpawnPlan {
+    binaryPath: string;
+    allArgs: string[];
+    shellCmd: string;
+    shellArgs: string[];
+    ptyOptions: PtySpawnOptions;
+    isWin: boolean;
+    useShell: boolean;
+}
+export declare function resolveCliSpawnPlan(options: {
+    provider: CliProviderModule;
+    runtimeSettings: Record<string, any>;
+    workingDir: string;
+    extraArgs: string[];
+}): CliSpawnPlan;
+export declare function buildCliLoginShellRetry(plan: Pick<CliSpawnPlan, 'binaryPath' | 'allArgs'>): {
+    shellCmd: string;
+    shellArgs: string[];
+};
+export declare function getCliSpawnErrorHint(message: string, shellCmd: string, isWin: boolean): string | null;
+export declare function respondToCliTerminalQueries(options: {
+    ptyProcess: PtyRuntimeTransport | null;
+    pendingTail: string;
+    data: string;
+    terminalScreen: TerminalScreen;
+}): string;

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

@@ -0,0 +1,158 @@
+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;
+}
+export declare function sanitizeTerminalText(str: string): string;
+export declare function listCliScriptNames(scripts: CliScripts | undefined): string[];
+export declare function buildCliScreenSnapshot(text: string): CliScreenSnapshot;
+export declare const buildCliSpawnEnv: typeof sanitizeSpawnEnv;
+export declare function computeTerminalQueryTail(buffer: string): string;
+export declare function findBinary(name: string): string;
+export declare function isScriptBinary(binaryPath: string): boolean;
+export declare function looksLikeMachOOrElf(filePath: string): boolean;
+export declare function shSingleQuote(arg: string): string;
+export declare function estimatePromptDisplayLines(text: string, cols?: number): number;
+export declare function extractPromptRetrySnippet(text: string): string;
+export declare function normalizePromptText(text: string): string;
+export declare function compactPromptText(text: string): string;
+export declare function promptLikelyVisible(screenText: string, promptSnippet: string): boolean;
+export declare function normalizeScreenSnapshot(text: string): string;
+export declare function normalizeComparableMessageContent(text: string): string;
+export declare function trimPromptEchoPrefix(text: string, promptText?: string | null): string;
+export declare function getLastUserPromptText(messages: Array<{
+    role?: string;
+    content?: string;
+}> | null | undefined): string;
+export declare function looksLikeConfirmOnlyLabel(label: string): boolean;
+export declare function normalizeCliProviderForRuntime(raw: unknown): {
+    patterns: {
+        approval: RegExp[];
+    };
+};

package/src/cli-adapters/pty-transport.d.ts

@@ -0,0 +1,48 @@
+export interface PtySpawnOptions {
+    cwd: string;
+    env: Record<string, string>;
+    cols: number;
+    rows: number;
+}
+export interface PtyRuntimeWriteOwner {
+    clientId: string;
+    ownerType: 'agent' | 'user';
+}
+export interface PtyRuntimeClientInfo {
+    clientId: string;
+    type: 'daemon' | 'web' | 'local-terminal';
+    readOnly: boolean;
+}
+export interface PtyRuntimeMetadata {
+    runtimeId: string;
+    runtimeKey?: string;
+    displayName?: string;
+    workspaceLabel?: string;
+    writeOwner?: PtyRuntimeWriteOwner | null;
+    attachedClients?: PtyRuntimeClientInfo[];
+    restoredFromStorage?: boolean;
+    recoveryState?: string | null;
+    recoveryError?: string | null;
+}
+export interface PtyRuntimeTransport {
+    readonly pid: number;
+    readonly ready: Promise<void>;
+    readonly terminalQueriesHandled?: boolean;
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    kill(): void;
+    clearBuffer?(): void;
+    detach?(): void;
+    updateMeta?(meta: Record<string, unknown>, replace?: boolean): void;
+    getMetadata?(): PtyRuntimeMetadata | null;
+    onData(callback: (data: string) => void): void;
+    onExit(callback: (info: {
+        exitCode: number;
+    }) => void): void;
+}
+export interface PtyTransportFactory {
+    spawn(command: string, args: string[], options: PtySpawnOptions): PtyRuntimeTransport;
+}
+export declare class NodePtyTransportFactory implements PtyTransportFactory {
+    spawn(command: string, args: string[], options: PtySpawnOptions): PtyRuntimeTransport;
+}

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

@@ -0,0 +1,20 @@
+import { type SessionHostEndpoint, type SessionHostCategory } from '@adhdev/session-host-core';
+import type { PtyRuntimeTransport, PtySpawnOptions, PtyTransportFactory } from './pty-transport.js';
+interface SessionHostPtyTransportFactoryOptions {
+    endpoint?: SessionHostEndpoint;
+    appName?: string;
+    ensureReady?: () => Promise<void>;
+    clientId: string;
+    runtimeId: string;
+    providerType: string;
+    category?: SessionHostCategory;
+    workspace: string;
+    meta?: Record<string, unknown>;
+    attachExisting?: boolean;
+}
+export declare class SessionHostPtyTransportFactory implements PtyTransportFactory {
+    private readonly options;
+    constructor(options: SessionHostPtyTransportFactoryOptions);
+    spawn(command: string, args: string[], spawnOptions: PtySpawnOptions): PtyRuntimeTransport;
+}
+export {};

package/src/cli-adapters/spawn-env.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Re-export spawn environment utilities from @adhdev/session-host-core.
+ *
+ * The canonical implementation lives in session-host-core so that both
+ * daemon-core and session-host-daemon can share it. This file exists
+ * to keep the import path short within daemon-core consumers.
+ */
+export { sanitizeSpawnEnv, applyTerminalColorEnv, ensureNodePtySpawnHelperPermissions, } from '@adhdev/session-host-core';

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

@@ -0,0 +1,16 @@
+import type { TerminalViewportBackend, TerminalViewportBackendOptions, TerminalViewportBackendPreference } from './types.js';
+export declare function resolveTerminalBackendPreference(): TerminalViewportBackendPreference;
+export declare function isGhosttyVtBackendAvailable(): boolean;
+export declare class GhosttyVtTerminalBackend implements TerminalViewportBackend {
+    readonly kind: "ghostty-vt";
+    private terminal;
+    constructor(options: TerminalViewportBackendOptions);
+    resize(rows: number, cols: number): void;
+    write(data: string): void;
+    getText(): string;
+    getCursorPosition(): {
+        col: number;
+        row: number;
+    };
+    dispose(): void;
+}

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

@@ -0,0 +1,18 @@
+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;
+    getCursorPosition(): {
+        col: number;
+        row: number;
+    };
+    dispose(): void;
+}

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

@@ -0,0 +1,17 @@
+import type { TerminalViewportBackend, TerminalViewportBackendOptions } from './types.js';
+export declare class XtermTerminalBackend implements TerminalViewportBackend {
+    readonly kind: "xterm";
+    private rows;
+    private cols;
+    private terminal;
+    constructor(options: TerminalViewportBackendOptions);
+    resize(rows: number, cols: number): void;
+    write(data: string): void;
+    getText(): string;
+    getCursorPosition(): {
+        col: number;
+        row: number;
+    };
+    dispose(): void;
+    private createTerminal;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * 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
+ */
+import type { TerminalViewportBackendKind, TerminalViewportBackendPreference } from './terminal-backends/types.js';
+export declare function getTerminalBackendRuntimeStatus(): {
+    backend: TerminalViewportBackendKind;
+    preference: TerminalViewportBackendPreference;
+    ghosttyAvailable: boolean;
+};
+export declare class TerminalScreen {
+    readonly backendKind: TerminalViewportBackendKind;
+    private rows;
+    private cols;
+    private readonly preference;
+    private terminal;
+    constructor(rows?: number, cols?: number);
+    reset(rows?: number, cols?: number): void;
+    resize(rows: number, cols: number): void;
+    write(data: string): void;
+    getText(): string;
+    getCursorPosition(): {
+        col: number;
+        row: number;
+    };
+    dispose(): void;
+    private createBackend;
+}

package/src/commands/cdp-commands.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CDP Commands — cdpEval, screenshot, cdpCommand, cdpBatch, cdpRemoteAction,
+ *                discoverAgents, file operations
+ */
+import type { CommandResult, CommandHelpers } from './handler.js';
+export declare function handleCdpEval(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleScreenshot(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleCdpCommand(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleCdpBatch(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleCdpRemoteAction(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleDiscoverAgents(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleFileRead(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleFileWrite(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleFileList(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleFileListBrowse(h: CommandHelpers, args: any): Promise<CommandResult>;

package/src/commands/chat-commands.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Chat Commands — readChat, sendChat, listChats, newChat, switchChat,
+ *                 setMode, changeModel, setThoughtLevel, resolveAction, chatHistory
+ */
+import type { CommandResult, CommandHelpers } from './handler.js';
+export declare function handleChatHistory(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleReadChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSendChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleListChats(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleNewChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSwitchChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSetMode(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleChangeModel(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSetThoughtLevel(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleResolveAction(h: CommandHelpers, args: any): Promise<CommandResult>;

package/src/commands/cli-manager.d.ts

@@ -0,0 +1,94 @@
+/**
+ * DaemonCliManager — CLI session creation, management, and command handling
+ *
+ * Separated from adhdev-daemon.ts.
+ * CLI cases of createAdapter, startCliSession, stopCliSession, executeDaemonCommand extracted to independent module extract.
+ */
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import { ProviderLoader } from '../providers/provider-loader.js';
+import type { ProviderResumeCapability } from '../providers/contracts.js';
+import type { CliAdapter } from '../cli-adapter-types.js';
+import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
+import type { SessionRegistry } from '../sessions/registry.js';
+export interface CliManagerDeps {
+    /** Server connection — injected into adapter */
+    getServerConn(): any | null;
+    /** P2P — PTY output transmit */
+    getP2p(): {
+        broadcastSessionOutput(key: string, data: string): void;
+    } | null;
+    /** StatusReporter callback */
+    onStatusChange(): void;
+    removeAgentTracking(key: string): void;
+    /** InstanceManager — register in CLI unified status */
+    getInstanceManager(): ProviderInstanceManager | null;
+    getSessionRegistry?(): SessionRegistry | null;
+    createPtyTransportFactory?: (params: CliTransportFactoryParams) => PtyTransportFactory | null;
+    listHostedCliRuntimes?: () => Promise<HostedCliRuntimeDescriptor[]>;
+}
+type CommandResult = {
+    success: boolean;
+    [key: string]: unknown;
+};
+export interface CliTransportFactoryParams {
+    runtimeId: string;
+    providerType: string;
+    workspace: string;
+    cliArgs?: string[];
+    providerSessionId?: string;
+    attachExisting?: boolean;
+}
+export interface HostedCliRuntimeDescriptor {
+    runtimeId: string;
+    runtimeKey?: string;
+    displayName?: string;
+    workspaceLabel?: string;
+    lifecycle?: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed' | 'interrupted';
+    recoveryState?: string | null;
+    cliType: string;
+    workspace: string;
+    cliArgs?: string[];
+    providerSessionId?: string;
+}
+export declare function supportsExplicitSessionResume(resume?: ProviderResumeCapability): boolean;
+export declare class DaemonCliManager {
+    readonly adapters: Map<string, CliAdapter>;
+    private deps;
+    private providerLoader;
+    constructor(deps: CliManagerDeps, providerLoader: ProviderLoader);
+    getCliKey(cliType: string, dir: string): string;
+    getSessionPresentationMode(sessionId: string): 'terminal' | 'chat' | null;
+    isTerminalSession(sessionId: string): boolean;
+    private persistRecentActivity;
+    private getTransportFactory;
+    private createAdapter;
+    private startCliExitMonitor;
+    private registerCliInstance;
+    startSession(cliType: string, workingDir: string, cliArgs?: string[], initialModel?: string, options?: {
+        resumeSessionId?: string;
+    }): Promise<{
+        runtimeSessionId: string;
+        providerSessionId?: string;
+    }>;
+    stopSession(key: string): Promise<void>;
+    stopSessionWithMode(key: string, mode: 'hard' | 'save'): Promise<void>;
+    shutdownAll(): void;
+    detachAll(): void;
+    restoreHostedSessions(records?: HostedCliRuntimeDescriptor[]): Promise<number>;
+    /**
+    * Search for CLI adapter. Priority order:
+    * 0. sessionId (UUID direct match)
+    * 1. agentType + dir (iteration match)
+    * 2. agentType fuzzy match (⚠ returns first match when multiple sessions exist)
+    */
+    findAdapter(agentType: string, opts?: {
+        dir?: string;
+        instanceKey?: string;
+    }): {
+        adapter: CliAdapter;
+        key: string;
+    } | null;
+    private findAdapterBySessionId;
+    handleCliCommand(cmd: string, args: any): Promise<CommandResult | null>;
+}
+export {};

package/src/commands/handler.d.ts

@@ -0,0 +1,103 @@
+/**
+ * DaemonCommandHandler — unified command routing for CDP & CLI
+ *
+ * Routes incoming commands (from server WS, P2P, or local WS) to
+ * the correct CDP manager or CLI adapter.
+ *
+ * Key concepts:
+ *   - extractIdeType(): determines target IDE from targetSessionId or ideType
+ *   - getCdp(): returns the DaemonCdpManager for current command
+ *   - getProvider(): returns the ProviderModule for current command
+ *   - handle(): main entry point, sets context then dispatches
+ */
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import { ProviderLoader } from '../providers/provider-loader.js';
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import type { ProviderModule } from '../providers/contracts.js';
+import type { DaemonAgentStreamManager } from '../agent-stream/index.js';
+import type { CliAdapter } from '../cli-adapter-types.js';
+import { ChatHistoryWriter } from '../config/chat-history.js';
+import type { SessionRegistry, SessionRuntimeTarget } from '../sessions/registry.js';
+export interface CommandResult {
+    success: boolean;
+    [key: string]: unknown;
+}
+export interface CommandContext {
+    cdpManagers: Map<string, DaemonCdpManager>;
+    ideType: string;
+    adapters: Map<string, CliAdapter>;
+    providerLoader?: ProviderLoader;
+    /** ProviderInstanceManager — for runtime settings propagation */
+    instanceManager?: ProviderInstanceManager;
+    sessionRegistry?: SessionRegistry;
+    onProviderSettingChanged?: (providerType: string, key: string, value: any) => Promise<void> | void;
+}
+/**
+ * Shared helpers interface — passed to sub-module command functions
+ * for accessing CDP, providers, agent streams, and other handler-owned state.
+ */
+export interface CommandHelpers {
+    getCdp(ideType?: string): DaemonCdpManager | null;
+    getProvider(overrideType?: string): ProviderModule | undefined;
+    getProviderScript(scriptName: string, params?: Record<string, string>, ideType?: string): string | null;
+    evaluateProviderScript(scriptName: string, params?: Record<string, string>, timeout?: number): Promise<{
+        result: any;
+        category: string;
+    } | null>;
+    getCliAdapter(type?: string): CliAdapter | null;
+    readonly currentManagerKey: string | undefined;
+    readonly currentIdeType: string | undefined;
+    readonly currentProviderType: string | undefined;
+    readonly currentSession: SessionRuntimeTarget | undefined;
+    readonly agentStream: DaemonAgentStreamManager | null;
+    readonly ctx: CommandContext;
+    readonly historyWriter: ChatHistoryWriter;
+}
+export declare class DaemonCommandHandler implements CommandHelpers {
+    private _ctx;
+    private _agentStream;
+    private domHandlers;
+    private _historyWriter;
+    /** Current request route context */
+    private _currentRoute;
+    constructor(ctx: CommandContext);
+    get ctx(): CommandContext;
+    get agentStream(): DaemonAgentStreamManager | null;
+    get historyWriter(): ChatHistoryWriter;
+    get currentManagerKey(): string | undefined;
+    get currentIdeType(): string | undefined;
+    get currentProviderType(): string | undefined;
+    get currentSession(): SessionRuntimeTarget | undefined;
+    /** Get CDP manager for a specific session or manager key. */
+    getCdp(ideType?: string): DaemonCdpManager | null;
+    /**
+     * Get provider module — _currentProviderType (agentType priority) use.
+     */
+    getProvider(overrideType?: string): ProviderModule | undefined;
+    /** Get a provider script by name from ProviderLoader. */
+    getProviderScript(scriptName: string, params?: Record<string, string>, ideType?: string): string | null;
+    /**
+     * per-category CDP script execute:
+     * IDE → cdp.evaluate(script) (main window)
+     * Extension → cdp.evaluateInSession(sessionId, script) (webview)
+     */
+    evaluateProviderScript(scriptName: string, params?: Record<string, string>, timeout?: number): Promise<{
+        result: any;
+        category: string;
+    } | null>;
+    /** CLI adapter search */
+    getCliAdapter(type?: string): CliAdapter | null;
+    private inferProviderType;
+    private resolveRoute;
+    /** Extract CDP scope key from target session or explicit ideType */
+    private extractIdeType;
+    private logCommandStart;
+    private logCommandEnd;
+    setAgentStreamManager(manager: DaemonAgentStreamManager): void;
+    handle(cmd: string, args: any): Promise<CommandResult>;
+    private dispatch;
+    private handleRefreshScripts;
+    private proxyDevServerPost;
+    private proxyDevServerGet;
+    private proxyDevServerScaffold;
+}