@adhdev/daemon-core 0.5.3

package/dist/index.d.ts

@@ -0,0 +1,2662 @@
+/**
+ * ContentBlock — ACP ContentBlock union type
+ * Represents displayable content in messages, tool call results, etc.
+ */
+type ContentBlock = TextBlock | ImageBlock | AudioBlock | ResourceLinkBlock | ResourceBlock;
+/** Text content — ACP TextContent */
+interface TextBlock {
+    type: 'text';
+    text: string;
+    annotations?: ContentAnnotations;
+}
+/** Image content — ACP ImageContent */
+interface ImageBlock {
+    type: 'image';
+    data: string;
+    mimeType: string;
+    uri?: string;
+    annotations?: ContentAnnotations;
+}
+/** Audio content — ACP AudioContent */
+interface AudioBlock {
+    type: 'audio';
+    data: string;
+    mimeType: string;
+    annotations?: ContentAnnotations;
+}
+/** Resource link (file reference) — ACP ResourceLink */
+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 */
+interface ResourceBlock {
+    type: 'resource';
+    resource: TextResourceContents | BlobResourceContents;
+    annotations?: ContentAnnotations;
+}
+interface TextResourceContents {
+    uri: string;
+    text: string;
+    mimeType?: string;
+}
+interface BlobResourceContents {
+    uri: string;
+    blob: string;
+    mimeType?: string;
+}
+interface ContentAnnotations {
+    audience?: ('user' | 'assistant')[];
+    priority?: number;
+}
+/** Tool call info — ACP ToolCall */
+interface ToolCallInfo {
+    toolCallId: string;
+    title: string;
+    kind?: ToolKind;
+    status?: ToolCallStatus;
+    rawInput?: unknown;
+    rawOutput?: unknown;
+    content?: ToolCallContent[];
+    locations?: ToolCallLocation[];
+}
+type ToolKind = 'read' | 'edit' | 'delete' | 'move' | 'search' | 'execute' | 'think' | 'fetch' | 'switch_mode' | 'other';
+type ToolCallStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+/** Content produced by a tool call — ACP ToolCallContent */
+type ToolCallContent = {
+    type: 'content';
+    content: ContentBlock;
+} | {
+    type: 'diff';
+    path: string;
+    oldText?: string;
+    newText: string;
+} | {
+    type: 'terminal';
+    terminalId: string;
+};
+interface ToolCallLocation {
+    path: string;
+    line?: number;
+}
+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.
+ */
+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;
+}
+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;
+    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[];
+}
+/** ACP auth method — based on ACP official spec */
+type AcpAuthMethod = AcpAuthEnvVar | AcpAuthAgent | AcpAuthTerminal;
+/** Environment variable-based auth (API keys etc) */
+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) */
+interface AcpAuthAgent {
+    type: 'agent';
+    id: string;
+    name: string;
+    description?: string;
+}
+/** Terminal command-based auth (runs setup command) */
+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)).
+ */
+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;
+    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
+ */
+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 */
+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) */
+interface ProviderSettingSchema extends ProviderSettingDef {
+    key: string;
+}
+
+/**
+ * ADHDev Daemon Core — Shared Types
+ *
+ * Shared types referenced by daemon-core, daemon-standalone, daemon-cloud, web-core.
+ * When modifying this file, also update interface contracts in AGENT_PROTOCOL.md.
+ */
+interface DaemonStatus {
+    id: string;
+    type: string;
+    platform?: string;
+    hostname?: string;
+    nickname?: string;
+    cdpConnected?: boolean;
+    timestamp: number;
+    ides: IdeEntry[];
+    clis: CliEntry[];
+    acps?: AcpEntry[];
+}
+interface IdeEntry {
+    /** Format: "{daemonId}:ide:{instanceId}" */
+    id: string;
+    instanceId: string;
+    /** IDE type: "cursor", "windsurf", "vscode", etc. */
+    type: string;
+    name?: string;
+    cdpConnected?: boolean;
+    cdpPort?: number;
+    /** Current chat messages (live) */
+    chats?: ChatMessage[];
+    /** Active chat session */
+    activeChat?: Record<string, unknown> | null;
+    /** Chat history (legacy) */
+    chatHistory?: unknown[];
+    /** Agent status: 'idle' | 'working' */
+    agentStatus?: string;
+    /** Agent streams from extensions */
+    agentStreams?: AgentStreamEntry[];
+    /** Extension agents monitored via CDP */
+    extensions?: ExtensionInfo$1[];
+    /** Workspace folders */
+    workspaceFolders?: {
+        name: string;
+        path: string;
+    }[];
+    /** Active file path */
+    activeFile?: string | null;
+    /** Current AI model */
+    currentModel?: string;
+    /** Current AI mode/plan */
+    currentPlan?: string;
+    /** Managed agents list */
+    agents?: unknown[];
+}
+interface CliEntry {
+    /** Format: "{daemonId}:cli:{cliId}" */
+    id: string;
+    cliId: string;
+    /** CLI type: "gemini-cli", "claude-code", "codex-cli", etc. */
+    type: string;
+    name?: string;
+    /** Whether the CLI process is running */
+    isRunning?: boolean;
+    /** Active session info */
+    sessionId?: string;
+}
+interface AcpEntry {
+    /** Format: "{daemonId}:acp:{acpId}" */
+    id: string;
+    acpId: string;
+    /** Agent type: "gemini-acp", "cline-acp", etc. */
+    type: string;
+    name?: string;
+    /** Process running state */
+    isRunning?: boolean;
+    /** Error state */
+    errorReason?: string;
+    errorMessage?: string;
+}
+interface ChatMessage {
+    role: string;
+    /** Plain text (legacy) or rich content blocks (ACP standard) */
+    content: string | ContentBlock[];
+    kind?: string;
+    id?: string;
+    timestamp?: number;
+    /** Tool calls associated with this message */
+    toolCalls?: ToolCallInfo[];
+}
+
+interface ExtensionInfo$1 {
+    id: string;
+    type: string;
+    name: string;
+    isMonitored?: boolean;
+    agentStatus?: string;
+}
+interface CommandResult$2 {
+    success: boolean;
+    data?: any;
+    error?: string;
+}
+interface ProviderConfig {
+    id: string;
+    type: 'ide' | 'extension' | 'cli' | 'acp';
+    name: string;
+    /** CDP port detection */
+    cdpDetect?: {
+        processName?: string;
+        portFlag?: string;
+    };
+    /** Capabilities */
+    capabilities?: string[];
+}
+type DaemonEvent = {
+    type: 'status';
+    data: DaemonStatus;
+} | {
+    type: 'chat_update';
+    data: {
+        ideId: string;
+        messages: ChatMessage[];
+    };
+} | {
+    type: 'screenshot';
+    data: {
+        ideId: string;
+        base64: string;
+    };
+} | {
+    type: 'action_log';
+    data: {
+        ideId: string;
+        text: string;
+        timestamp: number;
+    };
+} | {
+    type: 'error';
+    data: {
+        message: string;
+    };
+};
+interface SystemInfo {
+    cpus: number;
+    totalMem: number;
+    freeMem: number;
+    loadavg: number[];
+    uptime: number;
+    arch: string;
+}
+interface DetectedIde {
+    id: string;
+    type: string;
+    name: string;
+    installed: boolean;
+    running: boolean;
+}
+interface ProviderInfo {
+    type: string;
+    icon: string;
+    displayName: string;
+    category: string;
+}
+/** Full status response from /api/v1/status */
+interface StatusResponse {
+    id: string;
+    type: string;
+    platform: string;
+    hostname: string;
+    timestamp: number;
+    ides: IdeEntry[];
+    clis: CliEntry[];
+    cdpConnected: boolean;
+    detectedIdes: DetectedIde[];
+    availableProviders: ProviderInfo[];
+    system: SystemInfo;
+}
+/** Agent stream entry within an IDE */
+interface AgentStreamEntry {
+    agentType: string;
+    agentName: string;
+    extensionId: string;
+    status: string;
+    messages: unknown[];
+    inputContent: string;
+    activeModal: {
+        message: string;
+        buttons: string[];
+    } | null;
+}
+/** Flattened agent entry from /api/v1/agents */
+interface AgentEntry {
+    ideId: string;
+    type: string;
+    name: string;
+    status: string;
+    source: 'native' | 'extension';
+}
+
+/**
+ * DaemonCore — Core daemon orchestrator interface
+ *
+ * Both daemon-standalone and daemon-cloud use this interface via daemon-core.
+ * Actual implementation extracted from launcher and placed in this package.
+ */
+
+interface DaemonCoreOptions {
+    /** Data directory for config, logs */
+    dataDir?: string;
+    /** Custom provider directories */
+    providerDirs?: string[];
+    /** Enable/disable specific detectors */
+    enableIdeDetection?: boolean;
+    enableCliDetection?: boolean;
+    enableAcpDetection?: boolean;
+    /** Status report interval (ms) */
+    statusInterval?: number;
+}
+interface IDaemonCore {
+    /** Initialize and start the daemon core */
+    start(): Promise<void>;
+    /** Gracefully stop the daemon */
+    stop(): Promise<void>;
+    /** Get current daemon status snapshot */
+    getStatus(): DaemonStatus;
+    /** Subscribe to status changes. Returns unsubscribe function. */
+    onStatusChange(callback: (status: DaemonStatus) => void): () => void;
+    /** Subscribe to all daemon events. Returns unsubscribe function. */
+    onEvent(callback: (event: DaemonEvent) => void): () => void;
+    /** Execute a command (send_chat, new_session, etc.) */
+    executeCommand(type: string, payload: any, target?: string): Promise<CommandResult$2>;
+    /** Get currently detected/managed IDEs */
+    getManagedIdes(): IdeEntry[];
+    /** Get currently detected/managed CLIs */
+    getManagedClis(): CliEntry[];
+    /** Get currently detected/managed ACP agents */
+    getManagedAcps(): AcpEntry[];
+}
+
+/**
+ * ADHDev Launcher — Configuration
+ *
+ * Manages launcher config, server connection tokens, and user preferences.
+ */
+interface ADHDevConfig {
+    serverUrl: string;
+    apiToken: string | null;
+    connectionToken: string | null;
+    selectedIde: string | null;
+    configuredIdes: string[];
+    installedExtensions: string[];
+    autoConnect: boolean;
+    notifications: boolean;
+    userEmail: string | null;
+    userName: string | null;
+    setupCompleted: boolean;
+    setupDate: string | null;
+    configuredCLIs: string[];
+    enabledIdes: string[];
+    recentCliWorkspaces: string[];
+    machineNickname: string | null;
+    cliHistory: CliHistoryEntry[];
+    providerSettings: Record<string, Record<string, any>>;
+    ideSettings: Record<string, {
+        extensions?: Record<string, {
+            enabled: boolean;
+        }>;
+    }>;
+}
+interface CliHistoryEntry {
+    cliType: string;
+    dir: string;
+    cliArgs?: string[];
+    timestamp: number;
+    label?: string;
+}
+/**
+ * Load configuration from disk
+ */
+declare function loadConfig(): ADHDevConfig;
+/**
+ * Save configuration to disk
+ */
+declare function saveConfig(config: ADHDevConfig): void;
+/**
+ * Update specific config fields
+ */
+declare function updateConfig(updates: Partial<ADHDevConfig>): ADHDevConfig;
+/**
+ * Mark setup as completed
+ */
+declare function markSetupComplete(ideId: string | string[], extensions: string[]): ADHDevConfig;
+/**
+ * Check if setup has been completed before
+ */
+declare function isSetupComplete(): boolean;
+/**
+ * Reset configuration
+ */
+declare function resetConfig(): void;
+/**
+ * Add CLI launch to history (max 20, dedup by cliType+dir+args)
+ */
+declare function addCliHistory(entry: Omit<CliHistoryEntry, 'timestamp'>): void;
+
+/**
+ * ADHDev — IDE Detector (canonical implementation)
+ *
+ * Detects installed IDEs on the user's local machine.
+ * Supports macOS, Windows, and Linux.
+ *
+ * Migrated from @adhdev/core — this is now the single source of truth.
+ */
+interface IDEInfo {
+    id: string;
+    name: string;
+    displayName: string;
+    installed: boolean;
+    path: string | null;
+    cliCommand: string | null;
+    version: string | null;
+    icon: string;
+    extensionSupport: 'full' | 'partial' | 'none';
+    notes?: string;
+}
+declare function detectIDEs(): Promise<IDEInfo[]>;
+
+/**
+ * Provider Version Detection & Archiving
+ *
+ * Detects installed versions for all provider categories (IDE, CLI, ACP, Extension).
+ * Archives version history to ~/.adhdev/version-history.json for compatibility tracking.
+ *
+ * Usage:
+ *   const archive = new VersionArchive();
+ *   const results = await detectAllVersions(providerLoader, archive);
+ */
+
+interface ProviderVersionInfo {
+    type: string;
+    name: string;
+    category: string;
+    installed: boolean;
+    version: string | null;
+    path: string | null;
+    binary: string | null;
+    detectedAt: string;
+    /**
+     * Set when the detected version is NOT listed in provider.json testedVersions.
+     * Means scripts may not work correctly with this version.
+     */
+    warning?: string;
+}
+interface VersionHistoryEntry {
+    version: string;
+    detectedAt: string;
+    os: string;
+}
+interface VersionHistory {
+    [providerType: string]: VersionHistoryEntry[];
+}
+declare class VersionArchive {
+    private history;
+    constructor();
+    private load;
+    /** Record a detected version (deduplicates same version) */
+    record(type: string, version: string): void;
+    /** Get version history for a provider */
+    getHistory(type: string): VersionHistoryEntry[];
+    /** Get latest known version for a provider */
+    getLatest(type: string): string | null;
+    /** Get full archive */
+    getAll(): VersionHistory;
+    private save;
+}
+/**
+ * Detect versions for all loaded providers
+ */
+declare function detectAllVersions(loader: ProviderLoader, archive?: VersionArchive): Promise<ProviderVersionInfo[]>;
+
+/**
+ * ProviderLoader — Provider discovery + OS/version override resolution
+ *
+ * Role:
+ * 1. Load provider.js from _builtin/ directory
+ * 2. Load user custom from ~/.adhdev/providers/ (overrides)
+ * 3. Apply OS/version overrides (process.platform + detected IDE version)
+ * 4. Hot-reload support (fs.watch)
+ *
+ * Design principles:
+ * - Load JS files via require() (CJS compatible)
+ * - User custom can override builtin
+ * - provider.js files are independent, so load order doesn't matter
+ */
+
+declare class ProviderLoader {
+    private providers;
+    private builtinDirs;
+    private userDir;
+    private upstreamDir;
+    private watchers;
+    private logFn;
+    private versionArchive;
+    private scriptsCache;
+    /** Inject VersionArchive so resolve() can auto-detect installed versions */
+    setVersionArchive(archive: VersionArchive): void;
+    private static readonly GITHUB_TARBALL_URL;
+    private static readonly META_FILE;
+    constructor(options?: {
+        builtinDir?: string | string[];
+        userDir?: string;
+        logFn?: (msg: string) => void;
+    });
+    private log;
+    /**
+    * Load all providers (3-tier priority)
+    * 1. _builtin/ (bundled fallback, or multiple array dirs)
+    * 2. .upstream/ (GitHub auto-download)
+    * 3. User custom (~/.adhdev/providers/ excluding _upstream)
+    * Later loads override earlier ones, so user custom always wins.
+    */
+    loadAll(): void;
+    /**
+    * Get raw provider metadata by type (NO scripts loaded).
+    * Use resolve() when you need scripts (readChat, listModels, etc).
+    * @deprecated Use getMeta() for metadata or resolve() for scripts.
+    */
+    get(type: string): ProviderModule | undefined;
+    /**
+    * Get raw provider metadata by type (NO scripts loaded).
+    * Safe for: category checks, icon, displayName, targetFilter, cdpPorts.
+    * NOT safe for: script execution (readChat, listModels, sendMessage).
+    * Use resolve() when scripts are needed.
+    */
+    getMeta(type: string): ProviderModule | undefined;
+    /**
+    * Resolve provider type by alias
+    * 'claude' → 'claude-cli', 'codex' → 'codex-cli' etc
+    * Returns input as-is if no match found.
+    */
+    resolveAlias(input: string): string;
+    /**
+    * Get provider with alias resolution (get + alias fallback)
+    */
+    getByAlias(input: string): ProviderModule | undefined;
+    /**
+    * Build CLI/ACP detection list (replaces cli-detector)
+    * Dynamically generated from provider.js spawn.command.
+    */
+    getCliDetectionList(): {
+        id: string;
+        displayName: string;
+        icon: string;
+        command: string;
+        category: string;
+    }[];
+    /**
+    * List providers by category
+    */
+    getByCategory(cat: ProviderCategory): ProviderModule[];
+    /**
+    * Extension Extension providers with extensionIdPattern only
+    * (used by discoverAgentWebviews in daemon-cdp.ts)
+    */
+    getExtensionProviders(): ProviderModule[];
+    /**
+    * All loaded providers
+    */
+    getAll(): ProviderModule[];
+    /**
+    * Check if a provider is enabled (per-IDE)
+    * Checks ideSettings[ideType].extensions[type].enabled.
+    * Default false (disabled) — user must explicitly enable.
+    * Always returns true when called without ideType.
+    */
+    isEnabled(type: string, ideType?: string): boolean;
+    /**
+    * Save IDE extension enabled setting
+    */
+    setIdeExtensionEnabled(ideType: string, extensionType: string, enabled: boolean): boolean;
+    /**
+    * Return only enabled providers by category (per-IDE)
+    */
+    getEnabledByCategory(cat: ProviderCategory, ideType?: string): ProviderModule[];
+    /**
+    * Extension Enabled extension providers with extensionIdPattern only (per-IDE)
+    */
+    getEnabledExtensionProviders(ideType?: string): ProviderModule[];
+    /**
+    * Return CDP port map for IDE providers
+    * Used by launch.ts, adhdev-daemon.ts
+    */
+    getCdpPortMap(): Record<string, [number, number]>;
+    /**
+    * Return IDE process name map (macOS)
+    */
+    getMacAppIdentifiers(): Record<string, string>;
+    /**
+    * Return IDE process name map (Windows)
+    */
+    getWinProcessNames(): Record<string, string[]>;
+    /**
+    * Available IDE types (only those with cdpPorts)
+    */
+    getAvailableIdeTypes(): string[];
+    /**
+    * Register IDE providers to core/detector registry
+    * → Enables detectIDEs() to detect provider.js-based IDEs
+    */
+    registerToDetector(): number;
+    /**
+    * Return final provider with OS/version overrides applied.
+    *
+    * Script resolution order:
+    *   1. compatibility array (new format — preferred)
+    *      Provider.json defines: "compatibility": [{ "ideVersion": ">=1.107.0", "scriptDir": "scripts/1.107" }]
+    *      First matching range wins. Fallback: defaultScriptDir.
+    *   2. versions field (legacy format — backward compat)
+    *      "versions": { "< 1.107.0": { "__dir": "scripts/legacy" } }
+    *   3. Root scripts.js (original format — no versioning)
+    *
+    * Version source: context.version → VersionArchive → undefined
+    */
+    resolve(type: string, context?: {
+        os?: string;
+        version?: string;
+    }): ResolvedProvider | undefined;
+    /**
+     * Load scripts from a scriptDir within a provider directory.
+     * Tries scripts.js first, then individual .js files.
+     */
+    private loadScriptsFromDir;
+    /**
+    * Hot-reload: start watching for file changes
+    */
+    watch(): void;
+    /**
+    * Stop hot-reload
+    */
+    stopWatch(): void;
+    /**
+    * Full reload
+    */
+    reload(): void;
+    /**
+    * Download latest providers tarball from GitHub → extract to .upstream/
+    * - ETag-based change detection (skip if unchanged)
+    * - Never touches user custom files in ~/.adhdev/providers/
+    * - Runs in background; existing providers are kept on failure
+    *
+    * @returns Whether an update occurred
+    */
+    fetchLatest(): Promise<{
+        updated: boolean;
+        error?: string;
+    }>;
+    /** HTTP(S) file download (follows redirects) */
+    private downloadFile;
+    /** Recursive directory copy */
+    private copyDirRecursive;
+    /** .meta.json save */
+    private writeMeta;
+    /** Count provider files (provider.js or provider.json) */
+    private countProviders;
+    /**
+    * Get public settings schema for a provider (for dashboard UI rendering)
+    */
+    getPublicSettings(type: string): ProviderSettingSchema[];
+    /**
+    * Get public settings schema for all providers
+    */
+    getAllPublicSettings(): Record<string, ProviderSettingSchema[]>;
+    /**
+    * Resolved setting value for a provider (default + user override)
+    */
+    getSettingValue(type: string, key: string): any;
+    /**
+    * All resolved settings for a provider (default + user override)
+    */
+    getSettings(type: string): Record<string, any>;
+    /**
+    * Save provider setting value (writes to config.json)
+    */
+    setSetting(type: string, key: string, value: any): boolean;
+    /**
+     * Find the on-disk directory for a provider by type.
+     * Checks builtinDir, upstreamDir, userDir in order.
+     */
+    private findProviderDir;
+    /**
+     * Build a scripts function map from individual .js files in a directory.
+     * Each file is wrapped as: (params?) => fs.readFileSync(filePath, 'utf-8')
+     * (template substitution is NOT applied here — scripts.js handles that)
+     */
+    private buildScriptWrappersFromDir;
+    /**
+     * Recursively scan directory to load provider files
+     * Supports two formats:
+     *   1. provider.json (metadata) + scripts.js (optional CDP scripts)
+     *   2. provider.js (legacy — everything in one file)
+     * Structure: dir/category/agent-name/provider.{json,js}
+     */
+    private loadDir;
+    /**
+    * Simple semver range matching
+    * Supported formats: '>=4.0.0', '<3.0.0', '>=2.1.0'
+    */
+    private matchesVersion;
+    private compareVersions;
+}
+
+/**
+ * CLI AI Agent Detector
+ *
+ * Dynamic CLI detection based on Provider.
+ * Reads spawn.command from cli/acp categories via ProviderLoader to check installation.
+ *
+ * Uses parallel execution for fast detection across many providers.
+ */
+
+interface CLIInfo {
+    id: string;
+    displayName: string;
+    icon: string;
+    command: string;
+    installed: boolean;
+    version?: string;
+    path?: string;
+    category?: string;
+}
+/**
+ * Detect all CLI/ACP agents (parallel)
+ * @param providerLoader ProviderLoader instance (dynamic list creation)
+ */
+declare function detectCLIs(providerLoader?: ProviderLoader): Promise<CLIInfo[]>;
+
+/**
+ * CDP Manager for ADHDev Daemon
+ *
+ * Ported cdp.ts from Extension for Daemon use.
+ * vscode dependencies removed — works in pure Node.js environment.
+ *
+ * Connects to IDE CDP port (9222, 9333 etc) to:
+ * - Execute JS via Runtime.evaluate
+ * - Agent webview iframe search & session connection
+ * - DOM query
+ */
+
+interface CdpTarget {
+    id: string;
+    type: string;
+    title: string;
+    url: string;
+    webSocketDebuggerUrl: string;
+}
+interface AgentWebviewTarget {
+    targetId: string;
+    extensionId: string;
+    agentType: string;
+    url: string;
+}
+declare class DaemonCdpManager {
+    private ws;
+    private browserWs;
+    private browserMsgId;
+    private browserPending;
+    private msgId;
+    private pending;
+    private port;
+    private _connected;
+    private _browserConnected;
+    private targetUrl;
+    private reconnectTimer;
+    private contexts;
+    private connectPromise;
+    private failureCount;
+    private readonly MAX_FAILURES;
+    private agentSessions;
+    private logFn;
+    private extensionProviders;
+    private _lastDiscoverSig;
+    private _targetId;
+    private _pageTitle;
+    private _targetFilter;
+    constructor(port?: number, logFn?: (msg: string) => void, targetId?: string, targetFilter?: CdpTargetFilter);
+    /** Set target filter (can be updated after construction) */
+    setTargetFilter(filter: CdpTargetFilter): void;
+    /**
+     * Check if a page title should be excluded (non-main page).
+     * Uses provider-configured titleExcludes, falls back to default pattern.
+     */
+    private isNonMainTitle;
+    /**
+     * Check if a page URL matches the main window criteria.
+     * Uses provider-configured urlIncludes/urlExcludes.
+     */
+    private isMainPageUrl;
+    /** Connected page title (includes workspace name) */
+    get pageTitle(): string;
+    /**
+    * Query all workbench pages on port (static)
+    * Returns multiple entries if multiple IDE windows are open on same port
+    */
+    static listAllTargets(port: number): Promise<CdpTarget[]>;
+    setPort(port: number): void;
+    getPort(): number;
+    private log;
+    connect(): Promise<boolean>;
+    private doConnect;
+    private findTargetOnPort;
+    private findTarget;
+    setExtensionProviders(providers: {
+        agentType: string;
+        extensionId: string;
+        extensionIdPattern: RegExp;
+    }[]): void;
+    private connectToTarget;
+    /** Browser-level CDP connection — needed for Target discovery */
+    private connectBrowserWs;
+    private getBrowserWsUrl;
+    private sendBrowser;
+    private scheduleReconnect;
+    disconnect(): void;
+    get isConnected(): boolean;
+    private sendInternal;
+    send(method: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<any>;
+    sendCdpCommand(method: string, params?: Record<string, unknown>): Promise<any>;
+    evaluate(expression: string, timeoutMs?: number): Promise<unknown>;
+    querySelector(selector: string): Promise<string | null>;
+    /**
+    * Input text via CDP protocol then send Enter
+    * Used for editors where execCommand does not work (e.g. Lexical).
+    *
+    * 1. Find editor by selector, focus + click
+    * 2. Insert text via Input.insertText
+    * 3. Send Enter via Input.dispatchKeyEvent
+    */
+    typeAndSend(selector: string, text: string): Promise<boolean>;
+    /**
+    * Coordinate-based typeAndSend — for input fields inside webview iframe
+    * Receives coordinates directly instead of selector for click+input+Enter
+    */
+    typeAndSendAt(x: number, y: number, text: string): Promise<boolean>;
+    /**
+    * Evaluate JS from inside Webview iframe
+    * Kiro, PearAI etc Used for IDEs where chat UI is inside webview iframe.
+    *
+    * 1. Query Target.getTargets via browser WS → find vscode-webview iframes
+    * 2. Target.attachToTarget → session acquire
+    * 3. Page.getFrameTree → nested iframe find
+    * 4. Page.createIsolatedWorld → contextId acquire
+    * 5. Runtime.evaluate → result return
+    *
+    * @param expression JS expression to execute
+    * @param matchFn webview iframe URL match function (optional, all webview attempt)
+    * @returns evaluate result or null
+    */
+    evaluateInWebviewFrame(expression: string, matchFn?: (bodyPreview: string) => boolean): Promise<string | null>;
+    discoverAgentWebviews(): Promise<AgentWebviewTarget[]>;
+    attachToAgent(target: AgentWebviewTarget): Promise<string | null>;
+    evaluateInSession(sessionId: string, expression: string, timeoutMs?: number): Promise<unknown>;
+    detachAgent(sessionId: string): Promise<void>;
+    detachAllAgents(): Promise<void>;
+    getAgentSessions(): Map<string, AgentWebviewTarget>;
+    captureScreenshot(opts?: {
+        quality?: number;
+    }): Promise<Buffer | null>;
+}
+
+/**
+ * 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.
+ */
+interface ProviderState {
+    /** Provider type (e.g. 'gemini-cli', 'cursor', 'cline') */
+    type: string;
+    /** Provider Display name */
+    name: string;
+    /** category */
+    category: 'cli' | 'ide' | 'extension' | 'acp';
+    /** current status */
+    status: 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting';
+    /** CLI mode: terminal = PTY stream, chat = parsed conversation */
+    mode?: 'terminal' | 'chat';
+    /** chat data */
+    activeChat: {
+        id: string;
+        title: string;
+        status: string;
+        messages: {
+            role: string;
+            content: string;
+            timestamp?: number;
+        }[];
+        activeModal: {
+            message: string;
+            buttons: string[];
+        } | null;
+        inputContent?: string;
+    } | null;
+    /** IDE/Extension -only */
+    workspaceFolders?: {
+        name: string;
+        path: string;
+    }[];
+    activeFile?: string | null;
+    agentStreams?: any[];
+    cdpConnected?: boolean;
+    /** IDE child Extension Instance status */
+    extensions?: ProviderState[];
+    /** CLI -only */
+    workingDir?: string;
+    /** Runtime info (real-time detection from IDE/CLI) */
+    currentModel?: string;
+    currentPlan?: string;
+    currentAutoApprove?: string;
+    /** meta */
+    instanceId: string;
+    lastUpdated: number;
+    settings: Record<string, any>;
+    /** Event queue (cleared after daemon collects) */
+    pendingEvents: ProviderEvent[];
+}
+interface ProviderEvent {
+    event: string;
+    timestamp: number;
+    [key: string]: any;
+}
+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>;
+}
+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;
+}
+
+/**
+ * ProviderInstanceManager — lifecycle management for all ProviderInstances
+ *
+ * Role:
+ * 1. Instance create/delete
+ * 2. Tick engine (periodic onTick calls)
+ * 3. Collect overall state
+ * 4. Event collection and propagation
+ */
+
+declare class ProviderInstanceManager {
+    private instances;
+    private tickTimer;
+    private tickInterval;
+    private eventListeners;
+    /**
+    * Instance add and initialize
+    */
+    addInstance(id: string, instance: ProviderInstance, context: InstanceContext): Promise<void>;
+    /**
+    * Instance remove
+    */
+    removeInstance(id: string): void;
+    /**
+    * Import by Instance ID
+    */
+    getInstance(id: string): ProviderInstance | undefined;
+    /**
+    * Per-category Instance list
+    */
+    getByCategory(category: 'cli' | 'ide' | 'extension' | 'acp'): ProviderInstance[];
+    /**
+    * All Instance count
+    */
+    get size(): number;
+    /**
+    * all Instance's current status collect
+    * + Propagate pending events to event listeners
+    */
+    collectAllStates(): ProviderState[];
+    /**
+    * Per-category status collect
+    */
+    collectStatesByCategory(category: 'cli' | 'ide' | 'extension' | 'acp'): ProviderState[];
+    /**
+    * Start tick — periodically call all Instance.onTick() call
+    */
+    startTicking(intervalMs?: number): void;
+    /**
+    * Stop tick
+    */
+    stopTicking(): void;
+    /**
+    * Register event listener (used for daemon status_event transmission)
+    */
+    onEvent(listener: (event: ProviderEvent & {
+        providerType: string;
+    }) => void): void;
+    /**
+    * Forward event to specific Instance
+    */
+    sendEvent(id: string, event: string, data?: any): void;
+    /**
+    * Broadcast event to all Instances
+    */
+    broadcast(event: string, data?: any): void;
+    /**
+     * Update settings for all instances of a given provider type.
+     * Called when user changes settings from dashboard.
+     */
+    updateInstanceSettings(providerType: string, settings: Record<string, any>): number;
+    /**
+    * All terminate
+    */
+    disposeAll(): void;
+}
+
+/**
+ * Agent Stream Types — ported for Daemon (identical to original)
+ *
+ * Agent stream types.
+ * No vscode dependency — can be used as-is.
+ */
+/** Agent chat message */
+interface AgentChatMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp?: number;
+}
+/** Agent chat history item */
+interface AgentChatListItem {
+    title: string;
+    id: string;
+    status?: string;
+    time?: string;
+    cost?: string;
+}
+/** Agent stream status */
+interface AgentStreamState {
+    agentType: string;
+    agentName: string;
+    extensionId: string;
+    status: 'idle' | 'streaming' | 'waiting_approval' | 'error' | 'disconnected' | 'panel_hidden' | 'not_monitored';
+    messages: AgentChatMessage[];
+    inputContent: string;
+    model?: string;
+    activeModal?: {
+        message: string;
+        buttons: string[];
+    };
+}
+/** Agent stream adapter interface */
+interface IAgentStreamAdapter {
+    readonly agentType: string;
+    readonly agentName: string;
+    readonly extensionId: string;
+    readonly extensionIdPattern: RegExp;
+    readChat(evaluate: AgentEvaluateFn): Promise<AgentStreamState>;
+    sendMessage(evaluate: AgentEvaluateFn, text: string): Promise<void>;
+    resolveAction(evaluate: AgentEvaluateFn, action: string, button?: string): Promise<boolean>;
+    newSession(evaluate: AgentEvaluateFn): Promise<void>;
+    listChats?(evaluate: AgentEvaluateFn): Promise<AgentChatListItem[]>;
+    switchSession?(evaluate: AgentEvaluateFn, sessionId: string): Promise<boolean>;
+    focusEditor?(evaluate: AgentEvaluateFn): Promise<void>;
+    setProvider?(provider: any): void;
+}
+type AgentEvaluateFn = (expression: string, timeoutMs?: number) => Promise<unknown>;
+
+/**
+ * DaemonAgentStreamManager — manage agent streams (ported for Daemon)
+ *
+ * Agent stream manager for extension data collection.
+ * All vscode dependencies removed — pure Node.js environment.
+ *
+ * Panel focus is delegated to Extension via IPC.
+ * CDP session management uses DaemonCdpManager directly.
+ */
+
+interface ManagedAgent {
+    adapter: IAgentStreamAdapter;
+    sessionId: string;
+    target: AgentWebviewTarget;
+    lastState: AgentStreamState | null;
+    lastError: string | null;
+    lastHiddenCheckTime: number;
+}
+declare class DaemonAgentStreamManager {
+    private allAdapters;
+    private managed;
+    private enabled;
+    private logFn;
+    private lastDiscoveryTime;
+    private discoveryIntervalMs;
+    private _activeAgentType;
+    constructor(logFn?: (msg: string) => void, providerLoader?: ProviderLoader);
+    setEnabled(enabled: boolean): void;
+    get isEnabled(): boolean;
+    get activeAgentType(): string | null;
+    /** Panel focus based on provider.js focusPanel or extensionId (currently no-op) */
+    ensureAgentPanelOpen(agentType: string, targetIdeType?: string): Promise<void>;
+    switchActiveAgent(cdp: DaemonCdpManager, agentType: string | null): Promise<void>;
+    /** Agent webview discovery + session connection */
+    syncAgentSessions(cdp: DaemonCdpManager): Promise<void>;
+    /** Collect active agent status */
+    collectAgentStreams(cdp: DaemonCdpManager): Promise<AgentStreamState[]>;
+    sendToAgent(cdp: DaemonCdpManager, agentType: string, text: string, targetIdeType?: string): Promise<boolean>;
+    resolveAgentAction(cdp: DaemonCdpManager, agentType: string, action: 'approve' | 'reject', targetIdeType?: string): Promise<boolean>;
+    newAgentSession(cdp: DaemonCdpManager, agentType: string, targetIdeType?: string): Promise<boolean>;
+    listAgentChats(cdp: DaemonCdpManager, agentType: string): Promise<AgentChatListItem[]>;
+    switchAgentSession(cdp: DaemonCdpManager, agentType: string, sessionId: string): Promise<boolean>;
+    focusAgentEditor(cdp: DaemonCdpManager, agentType: string): Promise<boolean>;
+    getConnectedAgents(): string[];
+    getManagedAgent(agentType: string): ManagedAgent | undefined;
+    dispose(cdp: DaemonCdpManager): Promise<void>;
+}
+
+/**
+ * AgentStreamPoller — Periodic agent stream polling + extension dynamic management
+ *
+ * Extracted from cloud daemon's startAgentStreamPolling() logic.
+ * Used by both daemon-cloud and daemon-standalone.
+ *
+ * Responsibilities:
+ *   1. Refresh extension providers in CDP managers (config changes take effect immediately)
+ *   2. Dynamically add/remove IDE instance extensions based on enabled state
+ *   3. Sync agent sessions + collect agent streams
+ *   4. Auto-discover agents in connected IDEs
+ */
+
+interface AgentStreamPollerDeps {
+    agentStreamManager: DaemonAgentStreamManager;
+    providerLoader: ProviderLoader;
+    instanceManager: ProviderInstanceManager;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    /** Callback when agent streams are updated */
+    onStreamsUpdated?: (ideType: string, streams: AgentStreamState[]) => void;
+}
+declare class AgentStreamPoller {
+    private deps;
+    private _activeIdeType;
+    private timer;
+    constructor(deps: AgentStreamPollerDeps);
+    /** Currently active IDE type for agent streaming */
+    get activeIde(): string | null;
+    /** Reset active IDE tracking (e.g., when IDE is stopped) */
+    resetActiveIde(ideType: string): void;
+    /** Start polling (idempotent — ignored if already started) */
+    start(intervalMs?: number): void;
+    /** Stop polling */
+    stop(): void;
+    /** Single poll tick — can also be called manually */
+    private tick;
+}
+
+/**
+ * Chat History Persistence — Persist completed chat messages to local disk
+ *
+ * Design:
+ * - ~/.adhdev/history/{agentType}/YYYY-MM-DD.jsonl
+ * - JSONL format (one line = one message, append-friendly)
+ * - Track only new messages (hash comparison with previous)
+ * - Auto-rotation (delete files older than 30 days)
+ * - Async/non-blocking (no impact on chat collection)
+ */
+interface HistoryMessage {
+    ts: string;
+    receivedAt: number;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    agent: string;
+    instanceId?: string;
+    sessionTitle?: string;
+}
+declare class ChatHistoryWriter {
+    /** Last seen message count per agent (deduplication) */
+    private lastSeenCounts;
+    /** Last seen message hash per agent (deduplication) */
+    private lastSeenHashes;
+    private rotated;
+    /**
+    * Append new messages to history
+    *
+    * @param agentType agent type (e.g. 'antigravity', 'cursor')
+    * @param messages Message array received from readChat
+    * @param sessionTitle Current session title
+    * @param instanceId IDE instance UUID (distinguishes windows of the same agent)
+    */
+    appendNewMessages(agentType: string, messages: Array<{
+        role: string;
+        content: string;
+        receivedAt?: number;
+    }>, sessionTitle?: string, instanceId?: string): void;
+    /** Called when agent session is explicitly changed */
+    onSessionChange(agentType: string): void;
+    /** Delete history files older than 30 days */
+    private rotateOldFiles;
+    /** Allow only filename-safe characters */
+    private sanitize;
+}
+/**
+ * Read history (static — called from P2P commands)
+ *
+ * Read JSONL files in reverse order, returning most recent messages first.
+ * When instanceId is specified, reads only that instance file.
+ * Offset/limit-based paging.
+ */
+declare function readChatHistory(agentType: string, offset?: number, limit?: number, instanceId?: string): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+};
+
+/**
+ * Daemon Commands — unified command handler
+ *
+ * Routes all functionality from legacy Extension commands.ts to Daemon.
+ *
+ * Command implementations are split into sub-modules:
+ * - chat-commands.ts    — Chat I/O, session management, mode/model control
+ * - cdp-commands.ts     — CDP eval, screenshot, batch, remote actions, file ops
+ * - stream-commands.ts  — Agent stream, PTY I/O, provider settings, extension scripts
+ */
+
+interface CommandResult$1 {
+    success: boolean;
+    [key: string]: unknown;
+}
+interface CommandContext {
+    cdpManagers: Map<string, DaemonCdpManager>;
+    ideType: string;
+    adapters: Map<string, any>;
+    providerLoader?: ProviderLoader;
+    /** ProviderInstanceManager — for runtime settings propagation */
+    instanceManager?: ProviderInstanceManager;
+    /** UUID instanceId → CDP manager key (ideType) mapping */
+    instanceIdMap?: Map<string, string>;
+}
+/**
+ * Shared helpers interface — passed to sub-module command functions
+ * for accessing CDP, providers, agent streams, and other handler-owned state.
+ */
+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): any | null;
+    readonly currentIdeType: string | undefined;
+    readonly currentProviderType: string | undefined;
+    readonly agentStream: DaemonAgentStreamManager | null;
+    readonly ctx: CommandContext;
+    readonly historyWriter: ChatHistoryWriter;
+}
+declare class DaemonCommandHandler implements CommandHelpers {
+    private _ctx;
+    private _agentStream;
+    private domHandlers;
+    private _historyWriter;
+    /** Current IDE type extracted from command args (per-request) */
+    private _currentIdeType;
+    /** Current provider type — agentType priority, ideType use */
+    private _currentProviderType;
+    constructor(ctx: CommandContext);
+    get ctx(): CommandContext;
+    get agentStream(): DaemonAgentStreamManager | null;
+    get historyWriter(): ChatHistoryWriter;
+    get currentIdeType(): string | undefined;
+    get currentProviderType(): string | undefined;
+    /** Get CDP manager for a specific ideType.
+     * Returns null if no match — never falls back to another IDE. */
+    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): any | null;
+    private getExtensionSessionId;
+    /** Extract ideType from _targetInstance */
+    private extractIdeType;
+    setAgentStreamManager(manager: DaemonAgentStreamManager): void;
+    handle(cmd: string, args: any): Promise<CommandResult$1>;
+    private dispatch;
+    private handleGetRecentWorkspaces;
+    private handleRefreshScripts;
+}
+
+/**
+ * CDP DOM Analysis Tools — DOM dump, query, debug
+ *
+ * Separated from daemon-commands.ts.
+ * Tools for analyzing DOM structure when developing new IDE scripts.
+ */
+
+type CdpGetter = (ideType?: string) => DaemonCdpManager | null;
+/**
+ * CDP DOM analysis handler
+ *
+ * Uses getCdp from DaemonCommandHandler.
+ */
+declare class CdpDomHandlers {
+    private getCdp;
+    constructor(getCdp: CdpGetter);
+    /**
+    * CDP DOM Dump — IDE's DOM tree retrieve
+    *
+    * args:
+    * selector?: string — CSS selector to dump specific area only (default: All)
+    * depth?: number — Dump depth limit (default: 10)
+    * attrs?: boolean — Whether to include properties (default: true)
+    * maxLength?: number — Max character count (default: 200000)
+    * format?: 'html' | 'tree' | 'summary' — Output format (default: 'html')
+    * sessionId?: string — Agent webview session ID (if provided, match webview DOM)
+    */
+    handleDomDump(args: any): Promise<CommandResult$1>;
+    /**
+    * CDP DOM Query — CSS Test selector
+    * Check how many elements match selector and what elements they are
+    *
+    * args:
+    * selector: string — CSS selector
+    * limit?: number — Max element count to return (default: 20)
+    * content?: boolean — Whether to include text content (default: true)
+    * sessionId?: string — agent webview session ID
+    */
+    handleDomQuery(args: any): Promise<CommandResult$1>;
+    /**
+    * CDP DOM Debug — IDE AI panel specialized analysis
+    * Collect all essential info at once when supporting new IDE
+    *
+    * args:
+    * ideType?: string — IDE type hint
+    * sessionId?: string — agent webview session ID
+    */
+    handleDomDebug(args: any): Promise<CommandResult$1>;
+}
+
+/**
+ * ExtensionProviderInstance — Runtime instance for Extension Provider
+ *
+ * Manages IDE extensions (Cline, Roo Code, etc).
+ * CDP webview discovery + agent stream collection moved here.
+ */
+
+declare class ExtensionProviderInstance implements ProviderInstance {
+    readonly type: string;
+    readonly category: "extension";
+    private provider;
+    private context;
+    private settings;
+    private events;
+    private currentStatus;
+    private agentStreams;
+    private messages;
+    private activeModal;
+    private lastAgentStatus;
+    private generatingStartedAt;
+    private monitor;
+    private instanceId;
+    private ideType;
+    constructor(provider: ProviderModule);
+    init(context: InstanceContext): Promise<void>;
+    onTick(): Promise<void>;
+    getState(): ProviderState;
+    onEvent(event: string, data?: any): void;
+    dispose(): void;
+    /** Query UUID instanceId */
+    getInstanceId(): string;
+    private detectTransition;
+    private pushEvent;
+    private flushEvents;
+}
+
+/**
+ * IdeProviderInstance — Runtime instance for IDE Provider
+ *
+ * Within a single IDE:
+ * 1. Native chat (readChat via CDP)
+ * 2. Extension agents (Cline, Roo Code etc)
+ *
+ * IDE Instance manages child Extension Instances.
+ * Daemon collects all via a single IDE Instance.getState() call.
+ */
+
+declare class IdeProviderInstance implements ProviderInstance {
+    readonly type: string;
+    readonly category: "ide";
+    private provider;
+    private context;
+    private settings;
+    private events;
+    private tickErrorCount;
+    private cachedChat;
+    private currentStatus;
+    private lastAgentStatuses;
+    private generatingStartedAt;
+    private tickBusy;
+    private monitor;
+    private historyWriter;
+    private ideVersion;
+    private instanceId;
+    private workspaceFolders;
+    private activeFile;
+    private extensions;
+    constructor(provider: ProviderModule, instanceKey?: string);
+    init(context: InstanceContext): Promise<void>;
+    onTick(): Promise<void>;
+    getState(): ProviderState;
+    onEvent(event: string, data?: any): void;
+    dispose(): void;
+    /** Extension Instance add */
+    addExtension(provider: ProviderModule, settings?: Record<string, any>): Promise<void>;
+    /** Extension Instance remove */
+    removeExtension(type: string): void;
+    /** Extension Instance Import */
+    getExtension(type: string): ExtensionProviderInstance | undefined;
+    /** Child Extension list */
+    getExtensionTypes(): string[];
+    /** Query UUID instanceId */
+    getInstanceId(): string;
+    /** all Extension Instance list */
+    getExtensionInstances(): ExtensionProviderInstance[];
+    private readChat;
+    private getReadChatScript;
+    private detectAgentTransitions;
+    private pushEvent;
+    private flushEvents;
+    updateCdp(cdp: InstanceContext['cdp']): void;
+}
+
+/**
+ * DaemonCdpSetup — Shared CDP initialization helpers
+ *
+ * Extracted from daemon-cloud/adhdev-daemon.ts setupCdpManager()
+ * and daemon-standalone/index.ts inline CDP setup logic.
+ *
+ * Used by both daemon-cloud and daemon-standalone to ensure
+ * consistent CDP → ProviderInstance registration.
+ */
+
+interface CdpSetupContext {
+    providerLoader: ProviderLoader;
+    instanceManager: ProviderInstanceManager;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    /** UUID instanceId → CDP manager key mapping */
+    instanceIdMap: Map<string, string>;
+    /** Server connection (optional, cloud-only) */
+    serverConn?: any;
+}
+interface SetupIdeInstanceOptions {
+    /** Provider-based IDE type (e.g., 'antigravity', 'cursor') */
+    ideType: string;
+    /** Connected CDP manager */
+    manager: DaemonCdpManager;
+    /** CDP manager key (for multi-window: 'antigravity_remote_vs', single: 'antigravity') */
+    managerKey?: string;
+    /** Provider settings override */
+    settings?: Record<string, any>;
+}
+/**
+ * Register extension providers on a CDP manager.
+ * Common pattern used during CDP init and periodic scans.
+ */
+declare function registerExtensionProviders(providerLoader: ProviderLoader, manager: DaemonCdpManager, ideType: string): void;
+/**
+ * Setup a CDP-connected IDE as a ProviderInstance.
+ *
+ * Performs:
+ * 1. providerLoader.resolve() to get scripts
+ * 2. Create IdeProviderInstance
+ * 3. Register in InstanceManager
+ * 4. Register enabled extensions
+ * 5. Update instanceIdMap (IDE + extension UUIDs)
+ *
+ * @returns The created IdeProviderInstance, or null if provider not found
+ */
+declare function setupIdeInstance(ctx: CdpSetupContext, opts: SetupIdeInstanceOptions): Promise<IdeProviderInstance | null>;
+/**
+ * Create and connect a DaemonCdpManager for a given port.
+ *
+ * @returns Connected manager or null if connection failed
+ */
+declare function connectCdpManager(port: number, ideType: string, logFn: (msg: string) => void, providerLoader: ProviderLoader, targetId?: string): Promise<DaemonCdpManager | null>;
+/**
+ * Probe a CDP port to check if it's listening.
+ * @returns true if CDP is available on this port
+ */
+declare function probeCdpPort(port: number, timeoutMs?: number): Promise<boolean>;
+
+/**
+ * DaemonCdpScanner — Periodic CDP port scanning & auto-connect
+ *
+ * Extracted from daemon-cloud initCdp() and daemon-standalone initCdp().
+ * Provides a unified approach to:
+ * 1. Initial CDP port discovery
+ * 2. Periodic scanning for newly launched IDEs
+ * 3. Multi-window support (multiple pages on same port)
+ */
+
+interface CdpScannerOptions {
+    /** Context for setup operations */
+    ctx: CdpSetupContext;
+    /** Log function for per-IDE CDP logs */
+    logFn?: (ideType: string) => (msg: string) => void;
+    /** Whether to support multi-window (multiple pages per port) */
+    multiWindow?: boolean;
+    /** Scan interval in ms (default: 30000) */
+    scanIntervalMs?: number;
+    /** Callback when a new CDP connection is established */
+    onConnected?: (ideType: string, managerKey: string, manager: DaemonCdpManager) => void;
+}
+declare class DaemonCdpScanner {
+    private ctx;
+    private opts;
+    private scanTimer;
+    private discoveryTimer;
+    constructor(opts: CdpScannerOptions);
+    /**
+     * Initial CDP discovery — connect to all available IDEs.
+     * Supports both single-window and multi-window modes.
+     */
+    initialScan(enabledIdes?: string[]): Promise<void>;
+    /**
+     * Start periodic scanning for newly launched IDEs.
+     */
+    startPeriodicScan(): void;
+    /**
+     * Start periodic agent webview discovery on all connected CDPs.
+     */
+    startWebviewDiscovery(intervalMs?: number): void;
+    /**
+     * Stop all timers.
+     */
+    stop(): void;
+    private getLogFn;
+    /**
+     * Single-window connection (standalone mode).
+     * One CDP manager per IDE, first working port wins.
+     */
+    private connectSingleWindow;
+    /**
+     * Multi-window connection (cloud mode).
+     * Multiple CDP managers per IDE — one per workbench page.
+     */
+    private connectMultiWindow;
+}
+
+/**
+ * DaemonCdpInitializer — Unified CDP initialization + periodic scanning
+ *
+ * Replaces initCdp() in both cloud and standalone daemons.
+ *
+ * Features:
+ *   1. Initial connection: connectAll() — multi-window aware
+ *   2. Periodic scan: startPeriodicScan() — auto-detect newly opened IDEs
+ *   3. Discovery: startDiscovery() — periodic agent webview discovery
+ */
+
+interface CdpInitializerConfig {
+    providerLoader: ProviderLoader;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    /** Filter: only connect these IDEs (empty/undefined = all) */
+    enabledIdes?: string[];
+    /** Callback when a new CDP manager is connected */
+    onConnected?: (ideType: string, manager: DaemonCdpManager, managerKey: string) => void | Promise<void>;
+}
+declare class DaemonCdpInitializer {
+    private config;
+    private scanTimer;
+    private discoveryTimer;
+    constructor(config: CdpInitializerConfig);
+    /**
+     * Connect to all detected IDEs.
+     * Multi-window aware: creates separate CdpManager per workbench page.
+     */
+    connectAll(detectedIdes: any[]): Promise<void>;
+    /**
+     * Connect to a single IDE port.
+     * Tries multi-window first (listAllTargets), falls back to direct connect.
+     */
+    private connectIdePort;
+    /**
+     * Start periodic scanning for newly opened IDEs.
+     * Idempotent — ignored if already started.
+     */
+    startPeriodicScan(intervalMs?: number): void;
+    /**
+     * Start periodic agent webview discovery.
+     */
+    startDiscovery(intervalMs?: number): void;
+    /** Stop all timers */
+    stop(): void;
+}
+
+/**
+ * CliAdapter — common interface for CLI agents
+ *
+ * Contract implemented by all CLI adapters (ProviderCliAdapter etc).
+ */
+interface CliAdapter {
+    cliType: string;
+    cliName: string;
+    workingDir: string;
+    spawn(): Promise<void>;
+    sendMessage(text: string): Promise<void>;
+    getStatus(): any;
+    getPartialResponse(): string;
+    shutdown(): void;
+    cancel(): void;
+    isProcessing(): boolean;
+    isReady(): boolean;
+    setOnStatusChange(callback: () => void): void;
+    setServerConn?(serverConn: any): void;
+    setOnPtyData?(callback: (data: string) => void): void;
+    writeRaw?(data: string): void;
+    resize?(cols: number, rows: number): void;
+}
+
+/**
+ * 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.
+ */
+
+interface CliManagerDeps {
+    /** Server connection — injected into adapter */
+    getServerConn(): any | null;
+    /** P2P — PTY output transmit */
+    getP2p(): {
+        broadcastPtyOutput(key: string, data: string): void;
+    } | null;
+    /** StatusReporter callback */
+    onStatusChange(): void;
+    removeAgentTracking(key: string): void;
+    /** InstanceManager — register in CLI unified status */
+    getInstanceManager(): ProviderInstanceManager | null;
+}
+type CommandResult = {
+    success: boolean;
+    [key: string]: unknown;
+};
+declare class DaemonCliManager {
+    readonly adapters: Map<string, CliAdapter>;
+    private deps;
+    private providerLoader;
+    constructor(deps: CliManagerDeps, providerLoader: ProviderLoader);
+    getCliKey(cliType: string, dir: string): string;
+    private createAdapter;
+    startSession(cliType: string, workingDir: string, cliArgs?: string[], initialModel?: string): Promise<void>;
+    stopSession(key: string): Promise<void>;
+    shutdownAll(): void;
+    /**
+    * Search for CLI adapter. Priority order:
+    * 0. instanceKey (UUID direct match) — extracted from _targetInstance / composite ID
+    * 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;
+    handleCliCommand(cmd: string, args: any): Promise<CommandResult | null>;
+}
+
+/**
+ * DaemonCommandRouter — Unified command routing for daemon-level commands
+ *
+ * Extracted from cloud daemon's executeDaemonCommand() logic.
+ * Used by both daemon-cloud and daemon-standalone.
+ *
+ * Routing flow:
+ *   1. Daemon-level commands (launch_ide, stop_ide, restart_ide, etc.) → handled here
+ *   2. CLI/ACP commands → delegated to cliManager
+ *   3. Everything else → delegated to commandHandler.handle()
+ */
+
+interface CommandRouterDeps {
+    commandHandler: DaemonCommandHandler;
+    cliManager: DaemonCliManager;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    providerLoader: ProviderLoader;
+    instanceManager: ProviderInstanceManager;
+    /** Reference to detected IDEs array (mutable — router updates it) */
+    detectedIdes: {
+        value: any[];
+    };
+    /** UUID instanceId → CDP manager key mapping */
+    instanceIdMap: Map<string, string>;
+    /** Callback for CDP manager creation after launch_ide (cloud: setupCdpManager, standalone: no-op) */
+    onCdpManagerCreated?: (ideType: string, manager: DaemonCdpManager) => void;
+    /** Callback after IDE connected (e.g., startAgentStreamPolling) */
+    onIdeConnected?: () => void;
+    /** Callback after status change (stop_ide, restart) */
+    onStatusChange?: () => void;
+    /** Callback after chat-related commands (cloud: throttled report) */
+    onPostChatCommand?: () => void;
+    /** Get a connected CDP manager (for agent stream reset check) */
+    getCdpLogFn?: (ideType: string) => (msg: string) => void;
+}
+interface CommandRouterResult {
+    success: boolean;
+    [key: string]: unknown;
+}
+declare class DaemonCommandRouter {
+    private deps;
+    constructor(deps: CommandRouterDeps);
+    /**
+     * Unified command routing.
+     * Returns result for all commands:
+     *   1. Daemon-level commands (launch_ide, stop_ide, etc.)
+     *   2. CLI commands (launch_cli, stop_cli, agent_command)
+     *   3. DaemonCommandHandler delegation (CDP/agent-stream/file commands)
+     *
+     * @param cmd Command name
+     * @param args Command arguments
+     * @param source Log source ('ws' | 'p2p' | 'standalone' | etc.)
+     */
+    execute(cmd: string, args: any, source?: string): Promise<CommandRouterResult>;
+    /**
+     * Daemon-level command execution (IDE start/stop/restart, CLI, detect, logs).
+     * Returns null if not handled at this level → caller delegates to CommandHandler.
+     */
+    private executeDaemonCommand;
+    /**
+     * IDE stop: CDP disconnect + remove from InstanceManager + clean instanceIdMap
+     */
+    private stopIde;
+}
+
+/**
+ * DaemonStatusReporter — status collect & transmit (StatusReport / P2P / StatusEvent)
+ *
+ * Collect status from ProviderInstanceManager → assemble payload → transmit
+ * Each Instance manages its own status/transition. This module only assembles + transmits.
+ */
+interface StatusReporterDeps {
+    serverConn: {
+        isConnected(): boolean;
+        sendMessage(type: string, data: any): void;
+        getUserPlan(): string;
+    } | null;
+    cdpManagers: Map<string, {
+        isConnected: boolean;
+    }>;
+    p2p: {
+        isConnected: boolean;
+        isAvailable: boolean;
+        connectionState: string;
+        connectedPeerCount: number;
+        screenshotActive: boolean;
+        sendStatus(data: any): void;
+    } | null;
+    providerLoader: {
+        resolve(type: string): any;
+        getAll(): any[];
+    };
+    adapters: Map<string, {
+        cliType: string;
+        cliName: string;
+        workingDir: string;
+        getStatus(): any;
+        getPartialResponse(): string;
+    }>;
+    detectedIdes: any[];
+    ideType: string;
+    instanceManager: {
+        collectAllStates(): any[];
+        collectStatesByCategory(cat: string): any[];
+    };
+}
+declare class DaemonStatusReporter {
+    private deps;
+    private log;
+    private lastStatusSentAt;
+    private statusPendingThrottle;
+    private lastP2PStatusHash;
+    private lastStatusSummary;
+    private statusTimer;
+    private p2pTimer;
+    constructor(deps: StatusReporterDeps, opts?: {
+        logFn?: (msg: string) => void;
+    });
+    startReporting(): void;
+    stopReporting(): void;
+    onStatusChange(): void;
+    throttledReport(): void;
+    emitStatusEvent(event: Record<string, unknown>): void;
+    removeAgentTracking(_key: string): void;
+    updateAgentStreams(_ideType: string, _streams: any[]): void;
+    private ts;
+    sendUnifiedStatusReport(opts?: {
+        p2pOnly?: boolean;
+    }): Promise<void>;
+    private sendP2PPayload;
+    private simpleHash;
+}
+
+/**
+ * ADHDev Daemon — unified logger (v2)
+ *
+ * log level: DEBUG < INFO < WARN < ERROR
+ *
+ * Features:
+ * 1. daemonLog(category, msg, level) — explicit per-category logging
+ * 2. installGlobalInterceptor() — Auto-intercept console.log (once on daemon start)
+ * 3. Recent log ring buffer — for remote transmission via P2P/WS
+ * 4. File logging — ~/Library/Logs/adhdev/daemon.log (10MB rolling)
+ *
+ * use:
+ * import { daemonLog, LOG } from './daemon-logger';
+ * LOG.info('CDP', 'Connected to cursor on port 9333');
+ * LOG.debug('StatusReport', 'P2P heartbeat sent');
+ * LOG.warn('IdeInstance', 'onTick error: ...');
+ * LOG.error('Server', 'WebSocket disconnected');
+ */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+declare function setLogLevel(level: LogLevel): void;
+declare function getLogLevel(): LogLevel;
+interface LogEntry {
+    ts: number;
+    level: LogLevel;
+    category: string;
+    message: string;
+}
+/** Get recent N logs (for remote transmission) */
+declare function getRecentLogs(count?: number, minLevel?: LogLevel): LogEntry[];
+/**
+ * Scoped logger instance for a specific component.
+ * Created via LOG.forComponent('CDP:cursor').
+ */
+interface ScopedLogger {
+    debug: (msg: string) => void;
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    /** Returns a plain (msg: string) => void function at the given level.
+     *  Useful as logFn callback for ProviderLoader, DaemonStatusReporter, etc. */
+    asLogFn: (level?: LogLevel) => (msg: string) => void;
+}
+/**
+ * LOG — unified logging API
+ *
+ * Usage:
+ *   LOG.info('CDP', 'Connected to cursor on port 9333');
+ *   LOG.debug('StatusReport', 'P2P heartbeat sent');
+ *
+ * Component-scoped logger:
+ *   const log = LOG.forComponent('ACP:cursor');
+ *   log.info('Session created');
+ *   log.debug('Heartbeat');
+ *
+ * As callback for external components:
+ *   new ProviderLoader({ logFn: LOG.forComponent('Provider').asLogFn() });
+ *   new DaemonStatusReporter({ logFn: LOG.forComponent('Status').asLogFn() });
+ */
+declare const LOG: {
+    debug: (category: string, msg: string) => void;
+    info: (category: string, msg: string) => void;
+    warn: (category: string, msg: string) => void;
+    error: (category: string, msg: string) => void;
+    /**
+     * Create a scoped logger for a specific component.
+     * Category is baked in so callers only pass the message.
+     */
+    forComponent(category: string): ScopedLogger;
+};
+/**
+ * console.log/warn/error global interceptor install
+ * Prevent recording in places not using daemonLog.
+ * daemon start when 1time call.
+ */
+declare function installGlobalInterceptor(): void;
+
+/**
+ * ADHDev Daemon — Command History Logger
+ *
+ * Record all commands from dashboard/WS/P2P/Extension/API to local file.
+ * Per-date JSONL file, 7-day retention, 5MB limit.
+ *
+ * Purpose:
+ * - Debugging: track what command came and when
+ * - Audit: record all commands executed from remote
+ * - Stats: identify frequently used features
+ */
+interface CommandLogEntry {
+    ts: string;
+    cmd: string;
+    source: 'ws' | 'p2p' | 'ext' | 'api' | 'standalone' | 'unknown';
+    args?: Record<string, unknown>;
+    success?: boolean;
+    error?: string;
+    durationMs?: number;
+}
+/**
+ * Log a command received from the dashboard/WS/P2P/extension/API.
+ * Call this at the entry point of command handling.
+ */
+declare function logCommand(entry: CommandLogEntry): void;
+/**
+ * Read recent command history (for dashboard display / debugging)
+ */
+declare function getRecentCommands(count?: number): CommandLogEntry[];
+
+/**
+ * ADHDev Launcher — IDE Launch/Relaunch with CDP
+ *
+ * Launches IDE with Chrome DevTools Protocol (remote-debugging-port).
+ * If IDE is already running, terminates it and restarts with CDP option.
+ *
+ * Pipeline:
+ * 1. IDE process detection (already running?)
+ * 2. If already running with CDP → reuse as-is
+ * 3. If running without CDP → kill process → wait → restart with CDP
+ * 4. Not running → start fresh with CDP
+ *
+ * Usage:
+ * adhdev launch — Launch configured IDE with CDP port
+ * adhdev launch cursor — Launch Cursor with CDP port
+ * adhdev launch --workspace /path — Open specific workspace
+ */
+interface LaunchOptions {
+    ideId?: string;
+    workspace?: string;
+    newWindow?: boolean;
+}
+interface LaunchResult {
+    success: boolean;
+    ideId: string;
+    ideName: string;
+    port: number;
+    action: 'started' | 'restarted' | 'reused' | 'failed';
+    message: string;
+    error?: string;
+}
+/**
+ * Execute IDE with CDP port (relaunch pipeline)
+ *
+ * 1. IDE detect
+ * 2. per-fixed IDE CDP port determine
+ * 3. CDP not active → reuse
+ * 4. IDE execute during but CDP none → terminate → restart with CDP
+ * 5. IDE not running → start fresh with CDP
+ */
+declare function launchWithCdp(options?: LaunchOptions): Promise<LaunchResult>;
+declare function getAvailableIdeIds(): string[];
+
+declare const DEFAULT_DAEMON_PORT = 19222;
+declare const DAEMON_WS_PATH = "/ipc";
+
+/**
+ * ProviderCliAdapter — generic CLI Adapter based on provider.js
+ *
+ * Replaces individual adapters (gemini-cli.ts, claude-cli.ts, codex-cli.ts).
+ * Single engine driven by provider.js patterns, spawn, and cleanOutput.
+ *
+ * provider.js contract:
+ * type: string — 'gemini-cli', 'claude-cli', 'codex-cli', ...
+ * name: string — 'Gemini CLI', 'Claude Code', ...
+ * category: 'cli'
+ * binary: string — binary name
+ * spawn: { command, args, shell, env }
+ * patterns: { prompt, generating, approval, ready }
+ * timeouts?: { idleFinish, generatingIdle, maxResponse, approvalCooldown, ... }
+ * cleanOutput(raw, lastUserInput): string
+ */
+
+interface CliChatMessage {
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp?: number;
+}
+interface CliSessionStatus {
+    status: 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting';
+    messages: CliChatMessage[];
+    workingDir: string;
+    activeModal: {
+        message: string;
+        buttons: string[];
+    } | null;
+}
+interface CliProviderModule {
+    type: string;
+    name: string;
+    category: 'cli';
+    binary: string;
+    spawn: {
+        command: string;
+        args: string[];
+        shell: boolean;
+        env: Record<string, string>;
+    };
+    patterns: {
+        prompt: RegExp[];
+        generating: RegExp[];
+        approval: RegExp[];
+        ready: RegExp[];
+    };
+    timeouts?: {
+        /** PTY output batch transmit interval (default 50ms) */
+        ptyFlush?: number;
+        /** Wait for startup dialog auto-proceed (default 300ms) */
+        dialogAccept?: number;
+        /** Approval detect cooldown (default 2000ms) */
+        approvalCooldown?: number;
+        /** Check for completion on no-response during generating (default 6000ms) */
+        generatingIdle?: number;
+        /** Check for completion on no-response (default 5000ms) */
+        idleFinish?: number;
+        /** Max response wait (default 300000ms = 5min) */
+        maxResponse?: number;
+        /** shutdown after kill wait (default 1000ms) */
+        shutdownGrace?: number;
+    };
+    cleanOutput(raw: string, lastUserInput?: string): string;
+}
+declare class ProviderCliAdapter implements CliAdapter {
+    private extraArgs;
+    readonly cliType: string;
+    readonly cliName: string;
+    workingDir: string;
+    private provider;
+    private ptyProcess;
+    private messages;
+    private currentStatus;
+    private onStatusChange;
+    private responseBuffer;
+    private recentOutputBuffer;
+    private isWaitingForResponse;
+    private activeModal;
+    private responseTimeout;
+    private idleTimeout;
+    private ready;
+    private startupBuffer;
+    private onPtyDataCallback;
+    private ptyOutputBuffer;
+    private ptyOutputFlushTimer;
+    private serverConn;
+    private logBuffer;
+    private lastApprovalResolvedAt;
+    private readonly timeouts;
+    constructor(provider: CliProviderModule, workingDir: string, extraArgs?: string[]);
+    setServerConn(serverConn: any): void;
+    setOnStatusChange(callback: () => void): void;
+    setOnPtyData(callback: (data: string) => void): void;
+    spawn(): Promise<void>;
+    private handleOutput;
+    private finishResponse;
+    getStatus(): CliSessionStatus;
+    sendMessage(text: string): Promise<void>;
+    getPartialResponse(): string;
+    cancel(): void;
+    shutdown(): void;
+    clearHistory(): void;
+    isProcessing(): boolean;
+    isReady(): boolean;
+    writeRaw(data: string): void;
+    resize(cols: number, rows: number): void;
+}
+
+/**
+ * CliProviderInstance — Runtime instance for CLI Provider
+ *
+ * Lifecycle layer on top of ProviderCliAdapter.
+ * collectCliData() + status transition logic from daemon-status.ts moved here.
+ */
+
+declare class CliProviderInstance implements ProviderInstance {
+    private provider;
+    private workingDir;
+    private cliArgs;
+    readonly type: string;
+    readonly category: "cli";
+    private adapter;
+    private context;
+    private events;
+    private lastStatus;
+    private generatingStartedAt;
+    private settings;
+    private monitor;
+    private historyWriter;
+    readonly instanceId: string;
+    constructor(provider: ProviderModule, workingDir: string, cliArgs?: string[], instanceId?: string);
+    init(context: InstanceContext): Promise<void>;
+    onTick(): Promise<void>;
+    getState(): ProviderState;
+    onEvent(event: string, data?: any): void;
+    dispose(): void;
+    private detectStatusTransition;
+    private pushEvent;
+    private flushEvents;
+    getAdapter(): ProviderCliAdapter;
+    get cliType(): string;
+    get cliName(): string;
+}
+
+/**
+ * AcpProviderInstance — ACP (Agent Client Protocol) Provider runtime instance
+ *
+ * Spawns ACP agent process and communicates via the official ACP SDK.
+ * Uses ClientSideConnection + ndJsonStream for structured protocol communication.
+ *
+ * ACP spec: https://agentclientprotocol.com
+ * ACP SDK: @agentclientprotocol/sdk@0.16.1
+ *
+ * lifecycle:
+ * 1. init() → Spawn agent process + ACP initialize handshake
+ * 2. onTick() → no-op (ACP event based)
+ * 3. getState() → ProviderState return (dashboard for display)
+ * 4. onEvent('send_message') → session/prompt transmit
+ * 5. dispose() → kill process
+ */
+
+declare class AcpProviderInstance implements ProviderInstance {
+    private cliArgs;
+    readonly type: string;
+    readonly category: "acp";
+    private readonly log;
+    private provider;
+    private context;
+    private settings;
+    private events;
+    private monitor;
+    private process;
+    private connection;
+    private sessionId;
+    private messages;
+    private currentStatus;
+    private lastStatus;
+    private generatingStartedAt;
+    private agentCapabilities;
+    private currentModel;
+    private currentMode;
+    private activeToolCalls;
+    private stopReason;
+    private partialContent;
+    /** Rich content blocks accumulated during streaming */
+    private partialBlocks;
+    /** Tool calls collected during current turn */
+    private turnToolCalls;
+    private errorMessage;
+    private errorReason;
+    private stderrBuffer;
+    private spawnedAt;
+    private configOptions;
+    private availableModes;
+    /** Static config mode — agent doesn't support config/* methods */
+    private useStaticConfig;
+    /** Current config selections (for spawnArgBuilder) */
+    private selectedConfig;
+    private workingDir;
+    private instanceId;
+    constructor(provider: ProviderModule, workingDir: string, cliArgs?: string[]);
+    init(context: InstanceContext): Promise<void>;
+    onTick(): Promise<void>;
+    getState(): ProviderState;
+    onEvent(event: string, data?: any): void;
+    private parseConfigOptions;
+    private parseModes;
+    setConfigOption(category: string, value: string): Promise<void>;
+    setMode(modeId: string): Promise<void>;
+    /** Static config: kill process and restart with new args */
+    private restartWithNewConfig;
+    /** Update settings at runtime (called when user changes settings from dashboard) */
+    updateSettings(newSettings: Record<string, any>): void;
+    dispose(): void;
+    private spawnAgent;
+    private createClient;
+    private initialize;
+    private createSession;
+    sendPrompt(text: string, contentBlocks?: ContentBlock[]): Promise<void>;
+    private cancelSession;
+    private permissionResolvers;
+    private resolvePermission;
+    private handleSessionUpdate;
+    /** Handle legacy session/update formats (pre-standardization compat) */
+    private handleLegacyUpdate;
+    /** Map SDK ToolCallStatus to internal status */
+    private mapToolCallStatus;
+    /** Truncate content for transport (text: 2000 chars, images preserved) */
+    private truncateContent;
+    /** Build ContentBlock[] from current partial state */
+    private buildPartialBlocks;
+    /** Finalize streaming content into an assistant message */
+    private finalizeAssistantMessage;
+    /** Convert ACP ToolCallContent[] to our ToolCallContent[] */
+    private convertToolCallContent;
+    private detectStatusTransition;
+    private pushEvent;
+    private flushEvents;
+    get cliType(): string;
+    get cliName(): string;
+    /** ACP Agent capabilities (available after initialize) */
+    getCapabilities(): Record<string, any>;
+}
+
+/**
+ * Dev Server — HTTP API for Provider debugging + script development
+ *
+ * Enabled with `adhdev daemon --dev`
+ * Port: 19280 (fixed)
+ *
+ * API list:
+ * GET /api/providers — loaded provider list
+ * POST /api/providers/:type/script — specific script execute
+ * POST /api/cdp/evaluate — Execute JS expression
+ * POST /api/cdp/dom/query — Test selector
+ * GET /api/cdp/screenshot — screenshot
+ * POST /api/scripts/run — Execute provider script (name + params)
+ * GET /api/status — All status (CDP connection, provider etc)
+ */
+
+declare class DevServer {
+    private server;
+    private providerLoader;
+    private cdpManagers;
+    private logFn;
+    private sseClients;
+    private watchScriptPath;
+    private watchScriptName;
+    private watchTimer;
+    private autoImplProcess;
+    private autoImplSSEClients;
+    private autoImplStatus;
+    constructor(options: {
+        providerLoader: ProviderLoader;
+        cdpManagers: Map<string, DaemonCdpManager>;
+        logFn?: (msg: string) => void;
+    });
+    private log;
+    private readonly routes;
+    private matchRoute;
+    private getEndpointList;
+    start(port?: number): Promise<void>;
+    stop(): void;
+    private handleListProviders;
+    private handleProviderConfig;
+    private handleSpawnTest;
+    private handleRunScript;
+    private handleCdpEvaluate;
+    private handleCdpDomQuery;
+    private handleScreenshot;
+    private handleScriptsRun;
+    private handleStatus;
+    private handleReload;
+    private getConsoleDistDir;
+    private serveConsole;
+    private static MIME_MAP;
+    private serveStaticAsset;
+    private handleSSE;
+    private sendSSE;
+    private handleWatchStart;
+    private handleWatchStop;
+    /** Find the provider directory on disk */
+    private findProviderDir;
+    /** GET /api/providers/:type/files — list all files in provider directory */
+    private handleListFiles;
+    /** GET /api/providers/:type/file?path=scripts.js — read a file */
+    private handleReadFile;
+    /** POST /api/providers/:type/file — write a file { path, content } */
+    private handleWriteFile;
+    private handleSource;
+    private handleSave;
+    private handleScriptHints;
+    private handleValidate;
+    private handleAcpChat;
+    private handleCdpTargets;
+    private handleScaffold;
+    private handleDetectVersions;
+    private handleDomInspect;
+    private handleDomChildren;
+    private handleDomAnalyze;
+    private handleFindCommon;
+    private handleFindByText;
+    private handleDomContext;
+    private handleAutoImplement;
+    private buildAutoImplPrompt;
+    private handleAutoImplSSE;
+    private handleAutoImplCancel;
+    private sendAutoImplSSE;
+    /** Get CDP manager — matching IDE when ideType specified, first connected one otherwise */
+    private getCdp;
+    private getAnyCdp;
+    private json;
+    private readBody;
+}
+
+/**
+ * ADHDev Launcher — Extension Installer
+ *
+ * Installs VS Code extensions via CLI commands.
+ * Supports installing user-selected AI extensions.
+ */
+
+interface ExtensionInfo {
+    id: string;
+    name: string;
+    displayName: string;
+    marketplaceId: string;
+    description: string;
+    category: 'ai-agent' | 'utility';
+    icon: string;
+    recommended: boolean;
+    requiresApiKey?: boolean;
+    apiKeyName?: string;
+    website?: string;
+    vsixUrl?: string;
+}
+interface InstallResult {
+    extensionId: string;
+    marketplaceId: string;
+    success: boolean;
+    alreadyInstalled: boolean;
+    error?: string;
+}
+/**
+ * Check if an extension is already installed
+ */
+declare function isExtensionInstalled(ide: IDEInfo, marketplaceId: string): boolean;
+/**
+ * Install multiple extensions sequentially
+ */
+declare function installExtensions(ide: IDEInfo, extensions: ExtensionInfo[], onProgress?: (current: number, total: number, ext: ExtensionInfo, result: InstallResult) => void): Promise<InstallResult[]>;
+/**
+ * Get AI agent extensions
+ */
+declare function getAIExtensions(): ExtensionInfo[];
+/**
+ * Launch IDE after installation
+ */
+declare function launchIDE(ide: IDEInfo, workspacePath?: string): boolean;
+
+/**
+ * Daemon Lifecycle — Shared init + shutdown for cloud/standalone
+ *
+ * initDaemonComponents(): Creates all core daemon components in correct order.
+ * shutdownDaemonComponents(): Graceful shutdown of all components.
+ *
+ * Transport-specific setup (ServerConnection, P2P, HTTP/WS) remains in each daemon.
+ */
+
+interface DaemonInitConfig {
+    /** ProviderLoader log function */
+    providerLogFn?: (msg: string) => void;
+    /** CLI Manager deps (transport-specific) */
+    cliManagerDeps: {
+        getServerConn: () => any;
+        getP2p: () => any;
+        onStatusChange: () => void;
+        removeAgentTracking: (key: string) => void;
+    };
+    /** CDP config */
+    enabledIdes?: string[];
+    /** Router transport-specific callbacks */
+    onStatusChange?: () => void;
+    onPostChatCommand?: () => void;
+    getCdpLogFn?: (ideType: string) => (msg: string) => void;
+    /** Additional callback after CDP manager created (transport-specific extras) */
+    onCdpManagerSetup?: (ideType: string, manager: DaemonCdpManager, managerKey: string) => void | Promise<void>;
+    /** Poller callback (transport-specific) */
+    onStreamsUpdated?: (ideType: string, streams: any[]) => void;
+    /** Instance ticking interval (ms), default 5000 */
+    tickIntervalMs?: number;
+    /** CDP scan interval (ms), default 30000 */
+    cdpScanIntervalMs?: number;
+}
+interface DaemonComponents {
+    providerLoader: ProviderLoader;
+    instanceManager: ProviderInstanceManager;
+    cliManager: DaemonCliManager;
+    commandHandler: DaemonCommandHandler;
+    agentStreamManager: DaemonAgentStreamManager;
+    router: DaemonCommandRouter;
+    poller: AgentStreamPoller;
+    cdpInitializer: DaemonCdpInitializer;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    instanceIdMap: Map<string, string>;
+    detectedIdes: {
+        value: any[];
+    };
+}
+/**
+ * Initialize all daemon core components.
+ * Shared by both cloud and standalone daemons.
+ *
+ * Order:
+ *   1. Global log interceptor
+ *   2. ProviderLoader
+ *   3. InstanceManager + CliManager
+ *   4. Detect IDEs
+ *   5. CdpInitializer → connectAll + periodic scan + discovery
+ *   6. CommandHandler + AgentStreamManager
+ *   7. Router + Poller
+ *   8. Start instance ticking
+ */
+declare function initDaemonComponents(config: DaemonInitConfig): Promise<DaemonComponents>;
+/**
+ * Graceful shutdown of all daemon components.
+ * Shared by both cloud and standalone daemons.
+ *
+ * Order:
+ *   1. Stop timers (poller, cdpInitializer)
+ *   2. Dispose agent stream
+ *   3. Shutdown CLIs
+ *   4. Dispose instances
+ *   5. Disconnect CDPs
+ */
+declare function shutdownDaemonComponents(components: DaemonComponents): Promise<void>;
+
+export { type AcpEntry, AcpProviderInstance, type AgentEntry, type AgentStreamEntry, AgentStreamPoller, type AgentStreamPollerDeps, CdpDomHandlers, type CdpInitializerConfig, type CdpScannerOptions, type CdpSetupContext, type CdpTargetFilter, type ChatMessage, type CliAdapter, type CliEntry, CliProviderInstance, type CommandContext, type CommandResult$1 as CommandResult, type CommandRouterDeps, type CommandRouterResult, type CommandResult$2 as CoreCommandResult, DAEMON_WS_PATH, DEFAULT_DAEMON_PORT, DaemonAgentStreamManager, DaemonCdpInitializer, DaemonCdpManager, DaemonCdpScanner, DaemonCliManager, DaemonCommandHandler, DaemonCommandRouter, type DaemonComponents, type DaemonCoreOptions, type DaemonEvent, type DaemonInitConfig, type DaemonStatus, DaemonStatusReporter, type DetectedIde, DevServer, type ExtensionInfo$1 as ExtensionInfo, type IDEInfo, type IDaemonCore, type IdeEntry, IdeProviderInstance, type ExtensionInfo as InstallerExtensionInfo, LOG, type LogEntry, type LogLevel, ProviderCliAdapter, type ProviderConfig, type ProviderInfo, ProviderInstanceManager, ProviderLoader, type ProviderModule, type ProviderVersionInfo, type ScopedLogger, type SetupIdeInstanceOptions, type StatusResponse, type SystemInfo, VersionArchive, type VersionHistory, addCliHistory, connectCdpManager, detectAllVersions, detectCLIs, detectIDEs, getAIExtensions, getAvailableIdeIds, getLogLevel, getRecentCommands, getRecentLogs, initDaemonComponents, installExtensions, installGlobalInterceptor, isExtensionInstalled, isSetupComplete, launchIDE, launchWithCdp, loadConfig, logCommand, markSetupComplete, probeCdpPort, readChatHistory, registerExtensionProviders, resetConfig, saveConfig, setLogLevel, setupIdeInstance, shutdownDaemonComponents, updateConfig };