@adhdev/daemon-core 0.7.6 → 0.7.7

package/src/index.ts

@@ -110,7 +110,7 @@ export { ProviderInstanceManager } from './providers/provider-instance-manager.j
 export { IdeProviderInstance } from './providers/ide-provider-instance.js';
 export { CliProviderInstance } from './providers/cli-provider-instance.js';
 export { AcpProviderInstance } from './providers/acp-provider-instance.js';
-export type { ProviderModule, CdpTargetFilter } from './providers/contracts.js';
+export type { ProviderModule, CdpTargetFilter, ProviderResumeCapability } from './providers/contracts.js';
 export { VersionArchive, detectAllVersions } from './providers/version-archive.js';
 export type { ProviderVersionInfo, VersionHistory } from './providers/version-archive.js';
 
@@ -120,6 +120,10 @@ export { DevServer } from './daemon/dev-server.js';
 // ── CLI Adapters ──
 export { ProviderCliAdapter } from './cli-adapters/provider-cli-adapter.js';
 export type { CliAdapter } from './cli-adapter-types.js';
+export { NodePtyTransportFactory } from './cli-adapters/pty-transport.js';
+export type { PtyRuntimeTransport, PtyTransportFactory, PtySpawnOptions } from './cli-adapters/pty-transport.js';
+export { SessionHostPtyTransportFactory } from './cli-adapters/session-host-transport.js';
+export type { HostedCliRuntimeDescriptor, CliTransportFactoryParams } from './commands/cli-manager.js';
 
 // ── Installer ──
 export { getAIExtensions, installExtensions, launchIDE, isExtensionInstalled } from './installer.js';

package/src/providers/cli-provider-instance.ts

@@ -11,6 +11,7 @@ import type { ProviderModule } from './contracts.js';
 import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
+import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import { StatusMonitor } from './status-monitor.js';
 import { ChatHistoryWriter } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
@@ -37,10 +38,11 @@ export class CliProviderInstance implements ProviderInstance {
         private workingDir: string,
         private cliArgs: string[] = [],
         instanceId?: string,
+        transportFactory?: PtyTransportFactory,
     ) {
         this.type = provider.type;
         this.instanceId = instanceId || crypto.randomUUID();
-        this.adapter = new ProviderCliAdapter(provider as any as CliProviderModule, workingDir, cliArgs);
+        this.adapter = new ProviderCliAdapter(provider as any as CliProviderModule, workingDir, cliArgs, transportFactory);
         this.monitor = new StatusMonitor();
         this.historyWriter = new ChatHistoryWriter();
     }
@@ -82,6 +84,7 @@ export class CliProviderInstance implements ProviderInstance {
 
     getState(): ProviderState {
         const adapterStatus = this.adapter.getStatus();
+        const runtime = this.adapter.getRuntimeMetadata();
 
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
 
@@ -114,6 +117,15 @@ export class CliProviderInstance implements ProviderInstance {
             lastUpdated: Date.now(),
             settings: this.settings,
             pendingEvents: this.flushEvents(),
+            runtime: runtime ? {
+                runtimeId: runtime.runtimeId,
+                runtimeKey: runtime.runtimeKey,
+                displayName: runtime.displayName,
+                workspaceLabel: runtime.workspaceLabel,
+                writeOwner: runtime.writeOwner || null,
+                attachedClients: runtime.attachedClients || [],
+            } : undefined,
+            resume: this.provider.resume,
         };
     }
 

package/src/providers/contracts.d.ts

@@ -0,0 +1,408 @@
+/**
+ * Provider Output Contracts — Output contracts all providers must conform to
+ *
+ * Design principles:
+ * - Only output format is standardized; implementation is free
+ * - Common across all categories (cli, ide, extension)
+ * - User custom providers use the same contracts
+ */
+export interface ReadChatResult {
+    messages: ChatMessage[];
+    status: AgentStatus;
+    activeModal?: ModalInfo | null;
+    /** IDE/Extension only: session info */
+    id?: string;
+    title?: string;
+    /** Extension only: additional metadata */
+    agentType?: string;
+    agentName?: string;
+    extensionId?: string;
+    /** Status metadata */
+    isVisible?: boolean;
+    isWelcomeScreen?: boolean;
+    inputContent?: string;
+    model?: string;
+    autoApprove?: string;
+}
+import type { ChatMessage } from '../types.js';
+export type { ChatMessage };
+export type AgentStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'panel_hidden' | 'streaming';
+export interface ModalInfo {
+    message: string;
+    buttons: string[];
+    width?: number;
+    height?: number;
+}
+/**
+ * ContentBlock — ACP ContentBlock union type
+ * Represents displayable content in messages, tool call results, etc.
+ */
+export type ContentBlock = TextBlock | ImageBlock | AudioBlock | ResourceLinkBlock | ResourceBlock;
+/** Text content — ACP TextContent */
+export interface TextBlock {
+    type: 'text';
+    text: string;
+    annotations?: ContentAnnotations;
+}
+/** Image content — ACP ImageContent */
+export interface ImageBlock {
+    type: 'image';
+    data: string;
+    mimeType: string;
+    uri?: string;
+    annotations?: ContentAnnotations;
+}
+/** Audio content — ACP AudioContent */
+export interface AudioBlock {
+    type: 'audio';
+    data: string;
+    mimeType: string;
+    annotations?: ContentAnnotations;
+}
+/** Resource link (file reference) — ACP ResourceLink */
+export interface ResourceLinkBlock {
+    type: 'resource_link';
+    uri: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    size?: number;
+    annotations?: ContentAnnotations;
+}
+/** Embedded resource (inline file) — ACP EmbeddedResource */
+export interface ResourceBlock {
+    type: 'resource';
+    resource: TextResourceContents | BlobResourceContents;
+    annotations?: ContentAnnotations;
+}
+export interface TextResourceContents {
+    uri: string;
+    text: string;
+    mimeType?: string | null;
+}
+export interface BlobResourceContents {
+    uri: string;
+    blob: string;
+    mimeType?: string | null;
+}
+export interface ContentAnnotations {
+    audience?: ('user' | 'assistant')[];
+    priority?: number;
+}
+/** Tool call info — ACP ToolCall */
+export interface ToolCallInfo {
+    toolCallId: string;
+    title: string;
+    kind?: ToolKind;
+    status?: ToolCallStatus;
+    rawInput?: unknown;
+    rawOutput?: unknown;
+    content?: ToolCallContent[];
+    locations?: ToolCallLocation[];
+}
+export type ToolKind = 'read' | 'edit' | 'delete' | 'move' | 'search' | 'execute' | 'think' | 'fetch' | 'switch_mode' | 'other';
+export type ToolCallStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+/** Content produced by a tool call — ACP ToolCallContent */
+export type ToolCallContent = {
+    type: 'content';
+    content: ContentBlock;
+} | {
+    type: 'diff';
+    path: string;
+    oldText?: string;
+    newText: string;
+} | {
+    type: 'terminal';
+    terminalId: string;
+};
+export interface ToolCallLocation {
+    path: string;
+    line?: number | null;
+}
+/** Normalize content: string → ContentBlock[] */
+export declare function normalizeContent(content: string | ContentBlock[]): ContentBlock[];
+/** Flatten ContentBlock[] → string (backward compat / plain-text extraction) */
+export declare function flattenContent(content: string | ContentBlock[]): string;
+/** SendMessage params — supports rich content (ACP PromptRequest compatible) */
+export interface SendMessageParams {
+    /** Shortcut: text-only message */
+    text?: string;
+    /** Rich content blocks (ACP ContentBlock[]) */
+    prompt?: ContentBlock[];
+}
+export interface SendMessageResult {
+    sent: boolean;
+    error?: string;
+    /** When CDP Input API is needed (Lexical editor etc) */
+    needsTypeAndSend?: boolean;
+    selector?: string;
+}
+export interface ListSessionsResult {
+    sessions: SessionInfo[];
+}
+export interface SessionInfo {
+    id: string;
+    title: string;
+    time?: string;
+}
+export interface SwitchSessionResult {
+    switched: boolean;
+    /** When CDP click coordinates are needed (Antigravity QuickInput etc) */
+    action?: 'click';
+    clickX?: number;
+    clickY?: number;
+    error?: string;
+}
+/**
+ * Method 1: Script-Click — script calls el.click() directly
+ * Cursor Suitable for IDEs using div.cursor-pointer elements.
+ */
+export interface ResolveActionScriptClick {
+    resolved: boolean;
+    clicked?: string;
+    available?: string[];
+    error?: string;
+}
+/**
+ * Method 2: Coordinate-Click — returns coordinates, daemon performs CDP mouse click
+ * Antigravity Suitable for IDEs where el.click() does not work.
+ */
+export interface ResolveActionCoordinateClick {
+    found: boolean;
+    text?: string;
+    x?: number;
+    y?: number;
+    w?: number;
+    h?: number;
+}
+export type ResolveActionResult = ResolveActionScriptClick | ResolveActionCoordinateClick;
+export type ProviderCategory = 'cli' | 'ide' | 'extension' | 'acp';
+/**
+ * Type of object exported by module.exports in provider.js.
+ *
+ * Each provider.js is fully independent and does not import other providers.
+ * Helpers (_helpers/) can be optionally used.
+ */
+/**
+ * Provider-configurable CDP target filter.
+ * Used by DaemonCdpManager to select the correct page/tab to connect to.
+ * Without this, the manager uses a hardcoded default filter.
+ */
+export interface CdpTargetFilter {
+    /** URL must include this string (e.g. 'workbench.html') */
+    urlIncludes?: string;
+    /** URL must NOT include any of these strings */
+    urlExcludes?: string[];
+    /** Page title regex pattern for titles to EXCLUDE (e.g. 'Debug Console|Output') */
+    titleExcludes?: string;
+}
+export interface ProviderModule {
+    /** Unique identifier (e.g. 'cline', 'cursor', 'gemini-cli') */
+    type: string;
+    /** Display name (e.g. 'Cline', 'Cursor') */
+    name: string;
+    /** Category: determines execution method */
+    category: ProviderCategory;
+    /** Alias list — allows users to invoke by alternate names (e.g. ['claude', 'claude-code']) */
+    aliases?: string[];
+    /** CDP ports [primary, secondary] (IDE category only) */
+    cdpPorts?: [number, number];
+    /** CDP target filter — controls which page/tab to connect to (IDE category only) */
+    targetFilter?: CdpTargetFilter;
+    /** CLI command (e.g. 'cursor', 'code') */
+    cli?: string;
+    /** Display icon */
+    icon?: string;
+    /** Display name (short name) */
+    displayName?: string;
+    /** Install instructions (shown when command is missing) */
+    install?: string;
+    /** Custom version detection command (e.g. 'cursor --version', 'claude -v') */
+    versionCommand?: string;
+    /** Versions tested by provider maintainer (informational) */
+    testedVersions?: string[];
+    /** Per-OS process names — used by launch.ts to detect/kill IDE processes */
+    processNames?: {
+        darwin?: string;
+        win32?: string[];
+        linux?: string[];
+        [key: string]: string | string[] | undefined;
+    };
+    /** Per-OS install paths — used by detector.ts to detect IDE installation */
+    paths?: {
+        darwin?: string[];
+        win32?: string[];
+        linux?: string[];
+        [key: string]: string[] | undefined;
+    };
+    extensionId?: string;
+    extensionIdPattern?: RegExp;
+    binary?: string;
+    spawn?: {
+        command: string;
+        args?: string[];
+        shell?: boolean;
+        env?: Record<string, string>;
+    };
+    patterns?: {
+        prompt?: RegExp[];
+        generating?: RegExp[];
+        approval?: RegExp[];
+        ready?: RegExp[];
+    };
+    cleanOutput?: (raw: string, lastUserInput?: string) => string;
+    resume?: ProviderResumeCapability;
+    scripts?: ProviderScripts;
+    vscodeCommands?: {
+        focusPanel?: string;
+        openPanel?: string;
+        [key: string]: string | undefined;
+    };
+    inputMethod?: 'cdp-type-and-send' | 'script';
+    inputSelector?: string;
+    /** webview iframe match text (must be contained in body) */
+    webviewMatchText?: string;
+    os?: {
+        [platform: string]: Partial<Pick<ProviderModule, 'scripts' | 'inputMethod' | 'inputSelector'>>;
+    };
+    /** Key: semver range string (e.g. '< 1.107.0', '>= 2.0.0') */
+    versions?: {
+        [versionRange: string]: Partial<Pick<ProviderModule, 'scripts'>> & {
+            /**
+             * Load scripts from a subdirectory instead of scripts.js root.
+             * Path is relative to the provider directory (e.g. 'scripts/legacy').
+             * The subdirectory should contain its own scripts.js or individual .js files.
+             */
+            __dir?: string;
+        };
+    };
+    overrides?: Array<{
+        when: {
+            os?: string;
+            version?: string;
+        };
+        scripts?: Partial<ProviderScripts>;
+        /** Load scripts from a subdirectory for this OS+version combination */
+        __dir?: string;
+    }>;
+    settings?: Record<string, ProviderSettingDef>;
+    /** Static options used when agent does not provide configOptions */
+    staticConfigOptions?: Array<{
+        category: 'model' | 'mode' | 'thought_level' | 'other';
+        configId: string;
+        defaultValue?: string;
+        options: Array<{
+            value: string;
+            name: string;
+            description?: string;
+            group?: string;
+        }>;
+    }>;
+    /** Function to convert selected config values to spawn args (applied via process restart when config/* not supported) */
+    spawnArgBuilder?: (config: Record<string, string>) => string[];
+    /** ACP agent auth methods (multiple supported — in priority order) */
+    auth?: AcpAuthMethod[];
+}
+export interface ProviderResumeCapability {
+    supported: boolean;
+    stopStrategy?: 'command' | 'ctrl_c';
+    stopCommand?: string;
+    shutdownGraceMs?: number;
+    resumeArgs?: string[];
+}
+/** ACP auth method — based on ACP official spec */
+export type AcpAuthMethod = AcpAuthEnvVar | AcpAuthAgent | AcpAuthTerminal;
+/** Environment variable-based auth (API keys etc) */
+export interface AcpAuthEnvVar {
+    type: 'env_var';
+    id: string;
+    name: string;
+    vars: Array<{
+        name: string;
+        label?: string;
+        secret?: boolean;
+        optional?: boolean;
+    }>;
+    link?: string;
+}
+/** Agent self-auth (OAuth, browser-based etc) */
+export interface AcpAuthAgent {
+    type: 'agent';
+    id: string;
+    name: string;
+    description?: string;
+}
+/** Terminal command-based auth (runs setup command) */
+export interface AcpAuthTerminal {
+    type: 'terminal';
+    id: string;
+    name: string;
+    description?: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+/**
+ * CDP script functions.
+ * Each function takes a params object and returns a JS code string for CDP evaluate.
+ * The JS execution result must conform to the Output Contract.
+ *
+ * Custom scripts can be added via index signature in addition to built-in scripts.
+ * All scripts can receive params: Record<string, any>,
+ * backward compatible with legacy single-argument style (e.g. sendMessage(text)).
+ */
+export interface ProviderScripts {
+    readChat?: (params?: Record<string, any>) => string;
+    sendMessage?: (params?: Record<string, any>) => string;
+    listSessions?: (params?: Record<string, any>) => string;
+    switchSession?: (params?: Record<string, any>) => string;
+    newSession?: (params?: Record<string, any>) => string;
+    focusEditor?: (params?: Record<string, any>) => string;
+    openPanel?: (params?: Record<string, any>) => string;
+    /** List available models → { models: string[], current: string } */
+    listModels?: (params?: Record<string, any>) => string;
+    /** Change model → { success: boolean } */
+    setModel?: (params?: Record<string, any>) => string;
+    /** List available modes → { modes: string[], current: string } */
+    listModes?: (params?: Record<string, any>) => string;
+    /** Change mode → { success: boolean } */
+    setMode?: (params?: Record<string, any>) => string;
+    /** params: { action: 'approve'|'reject'|'custom', button?: string } */
+    resolveAction?: (params?: Record<string, any>) => string;
+    webviewResolveAction?: (params?: Record<string, any>) => string;
+    listNotifications?: (params?: Record<string, any>) => string;
+    dismissNotification?: (params?: Record<string, any>) => string;
+    [scriptName: string]: ((params?: Record<string, any>) => string) | undefined;
+}
+/**
+ * ProviderLoader.resolve() result: Final provider with OS/version overrides applied
+ */
+export interface ResolvedProvider extends ProviderModule {
+    /** OS applied during resolve */
+    _resolvedOs?: string;
+    /** Version applied during resolve */
+    _resolvedVersion?: string;
+    /** Warning when detected version is not in compatibility matrix */
+    _versionWarning?: string;
+}
+/** Setting variable definition declared by provider */
+export interface ProviderSettingDef {
+    type: 'boolean' | 'number' | 'string' | 'select';
+    default: any;
+    /** true = controllable from dashboard UI */
+    public: boolean;
+    /** UI label */
+    label?: string;
+    /** UI description */
+    description?: string;
+    /** Minimum value for number type */
+    min?: number;
+    /** Maximum value for number type */
+    max?: number;
+    /** Options for select type */
+    options?: string[];
+}
+/** Public settings schema (for dashboard transmission) */
+export interface ProviderSettingSchema extends ProviderSettingDef {
+    key: string;
+}

package/src/providers/contracts.ts

@@ -324,6 +324,7 @@ export interface ProviderModule {
     ready?: RegExp[];
   };
   cleanOutput?: (raw: string, lastUserInput?: string) => string;
+  resume?: ProviderResumeCapability;
 
  // ─── CDP scripts (ide/extension category) ───
   scripts?: ProviderScripts;
@@ -388,6 +389,14 @@ export interface ProviderModule {
   auth?: AcpAuthMethod[];
 }
 
+export interface ProviderResumeCapability {
+  supported: boolean;
+  stopStrategy?: 'command' | 'ctrl_c';
+  stopCommand?: string;
+  shutdownGraceMs?: number;
+  resumeArgs?: string[];
+}
+
 // ─── ACP Auth Types ─────────────────────────────────
 
 /** ACP auth method — based on ACP official spec */

package/src/providers/provider-instance-manager.ts

@@ -42,6 +42,27 @@ export class ProviderInstanceManager {
         }
     }
 
+    removeByCategory(
+        category: 'cli' | 'ide' | 'extension' | 'acp',
+        options: { dispose?: boolean } = {},
+    ): number {
+        const dispose = options.dispose !== false;
+        let removed = 0;
+        for (const [id, instance] of this.instances) {
+            if (instance.category !== category) continue;
+            if (dispose) {
+                try {
+                    instance.dispose();
+                } catch {
+                    // noop
+                }
+            }
+            this.instances.delete(id);
+            removed += 1;
+        }
+        return removed;
+    }
+
  /**
  * Import by Instance ID
  */

package/src/providers/provider-instance.d.ts

@@ -0,0 +1,142 @@
+/**
+ * ProviderInstance — Provider runtime lifecycle
+ *
+ * provider.js = static config/scripts
+ * ProviderInstance = runtime status management + lifecycle
+ *
+ * Daemon only collects via ProviderInstance.getState(),
+ * Each Instance manages its own status.
+ */
+import type { ProviderResumeCapability } from './contracts.js';
+import type { AcpConfigOption, AcpMode } from '../shared-types.js';
+import type { ChatMessage } from '../types.js';
+export type ProviderStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting';
+export interface ProviderRuntimeWriteOwner {
+    clientId: string;
+    ownerType: 'agent' | 'user';
+}
+export interface ProviderRuntimeClient {
+    clientId: string;
+    type: 'daemon' | 'web' | 'local-terminal';
+    readOnly: boolean;
+}
+export interface ProviderRuntimeInfo {
+    runtimeId: string;
+    runtimeKey?: string;
+    displayName?: string;
+    workspaceLabel?: string;
+    writeOwner?: ProviderRuntimeWriteOwner | null;
+    attachedClients?: ProviderRuntimeClient[];
+}
+export interface ActiveChatData {
+    id: string;
+    title: string;
+    status: string;
+    messages: ChatMessage[];
+    activeModal: {
+        message: string;
+        buttons: string[];
+    } | null;
+    terminalHistory?: string;
+    inputContent?: string;
+}
+/** Standardized error reasons across all provider categories */
+export type ProviderErrorReason = 'not_installed' | 'auth_failed' | 'spawn_error' | 'init_failed' | 'crash' | 'timeout' | 'cdp_error' | 'disconnected';
+/** Common fields shared by all provider categories */
+interface ProviderStateBase {
+    /** Provider type (e.g. 'gemini-cli', 'cursor', 'cline') */
+    type: string;
+    /** Provider Display name */
+    name: string;
+    /** current status */
+    status: ProviderStatus;
+    /** chat data */
+    activeChat: ActiveChatData | null;
+    /** Workspace — project path or name (all categories) */
+    workspace?: string | null;
+    /** Runtime info (real-time detection) */
+    currentModel?: string;
+    currentPlan?: string;
+    /** Error details (when status === 'error') */
+    errorMessage?: string;
+    errorReason?: ProviderErrorReason;
+    /** meta */
+    instanceId: string;
+    lastUpdated: number;
+    settings: Record<string, any>;
+    /** Event queue (cleared after daemon collects) */
+    pendingEvents: ProviderEvent[];
+    runtime?: ProviderRuntimeInfo;
+    resume?: ProviderResumeCapability;
+}
+/** IDE provider state */
+export interface IdeProviderState extends ProviderStateBase {
+    category: 'ide';
+    cdpConnected: boolean;
+    /** IDE child Extension Instance status */
+    extensions: ProviderState[];
+    currentAutoApprove?: string;
+}
+/** CLI provider state */
+export interface CliProviderState extends ProviderStateBase {
+    category: 'cli';
+    /** terminal = PTY stream, chat = parsed conversation */
+    mode: 'terminal' | 'chat';
+}
+/** ACP provider state */
+export interface AcpProviderState extends ProviderStateBase {
+    category: 'acp';
+    mode: 'chat';
+    /** ACP config options (model/mode selection) */
+    acpConfigOptions?: AcpConfigOption[];
+    /** ACP available modes */
+    acpModes?: AcpMode[];
+}
+/** Extension provider state */
+export interface ExtensionProviderState extends ProviderStateBase {
+    category: 'extension';
+    agentStreams?: any[];
+}
+/** Discriminated union — switch on `.category` */
+export type ProviderState = IdeProviderState | CliProviderState | AcpProviderState | ExtensionProviderState;
+export interface ProviderEvent {
+    event: string;
+    timestamp: number;
+    [key: string]: any;
+}
+export interface InstanceContext {
+    /** CDP connection (IDE/Extension) */
+    cdp?: {
+        isConnected: boolean;
+        evaluate(script: string, timeout?: number): Promise<unknown>;
+        evaluateInWebviewFrame?(expression: string, matchFn?: (bodyPreview: string) => boolean): Promise<string | null>;
+        discoverAgentWebviews?(): Promise<any[]>;
+    };
+    /** Server log transmit */
+    serverConn?: {
+        sendMessage(type: string, data: any): void;
+    };
+    /** P2P PTY output transmit */
+    onPtyData?: (data: string) => void;
+    /** Provider configvalue (resolved) */
+    settings: Record<string, any>;
+}
+export interface ProviderInstance {
+    /** Provider type */
+    readonly type: string;
+    /** Provider category */
+    readonly category: 'cli' | 'ide' | 'extension' | 'acp';
+    /** initialize */
+    init(context: InstanceContext): Promise<void>;
+    /** Tick — periodic status refresh (IDE: readChat, Extension: stream collection) */
+    onTick(): Promise<void>;
+    /** Return current status */
+    getState(): ProviderState;
+    /** Receive event (external → Instance) */
+    onEvent(event: string, data?: any): void;
+    /** Update settings at runtime (called when user changes settings from dashboard) */
+    updateSettings?(newSettings: Record<string, any>): void;
+    /** cleanup */
+    dispose(): void;
+}
+export {};