@adhdev/daemon-core 0.7.38 → 0.7.39

package/dist/agent-stream/forward.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shared helper for forwarding agent stream snapshots into the IDE instance.
+ *
+ * Both cloud and standalone daemons use the same InstanceManager wiring.
+ */
+export declare function forwardAgentStreamsToIdeInstance(instanceManager: {
+    getInstance: (key: string) => any;
+}, ideType: string, streams: any[]): void;

package/dist/agent-stream/index.d.ts

@@ -0,0 +1,6 @@
+export { DaemonAgentStreamManager } from './manager.js';
+export type { ManagedAgent } from './manager.js';
+export { ProviderStreamAdapter } from './provider-adapter.js';
+export * from './types.js';
+export { AgentStreamPoller } from './poller.js';
+export type { AgentStreamPollerDeps } from './poller.js';

package/dist/agent-stream/manager.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+import { DaemonCdpManager, AgentWebviewTarget } from '../cdp/manager.js';
+import { ProviderLoader } from '../providers/provider-loader.js';
+import { SessionRegistry } from '../sessions/registry.js';
+import type { IAgentStreamAdapter, AgentStreamState, AgentChatListItem } from './types.js';
+export interface ManagedAgent {
+    adapter: IAgentStreamAdapter;
+    runtimeSessionId: string;
+    parentSessionId: string;
+    cdpSessionId: string;
+    target: AgentWebviewTarget;
+    lastState: AgentStreamState | null;
+    lastError: string | null;
+    lastHiddenCheckTime: number;
+}
+export declare class DaemonAgentStreamManager {
+    private readonly sessionRegistry?;
+    private adaptersByType;
+    private managedBySessionId;
+    private enabled;
+    private logFn;
+    private lastDiscoveryTimeByParent;
+    private discoveryIntervalMsByParent;
+    private activeSessionIdByParent;
+    constructor(logFn?: (msg: string) => void, providerLoader?: ProviderLoader, sessionRegistry?: SessionRegistry | undefined);
+    setEnabled(enabled: boolean): void;
+    get isEnabled(): boolean;
+    getActiveSessionId(parentSessionId: string): string | null;
+    private isRecoverableSessionError;
+    private getSessionTarget;
+    resetParentSession(parentSessionId: string): void;
+    /** Panel focus based on provider.js focusPanel or extensionId (currently no-op) */
+    ensureSessionPanelOpen(_sessionId: string): Promise<void>;
+    setActiveSession(cdp: DaemonCdpManager, parentSessionId: string, sessionId: string | null): Promise<void>;
+    private resolveSessionIdForTarget;
+    private connectManagedSession;
+    /** Agent webview discovery + session connection */
+    syncActiveSession(cdp: DaemonCdpManager, parentSessionId: string): Promise<void>;
+    /** Collect active extension session state */
+    collectActiveSession(cdp: DaemonCdpManager, parentSessionId: string): Promise<AgentStreamState | null>;
+    sendToSession(cdp: DaemonCdpManager, sessionId: string, text: string): Promise<boolean>;
+    resolveSessionAction(cdp: DaemonCdpManager, sessionId: string, action: 'approve' | 'reject'): Promise<boolean>;
+    newSession(cdp: DaemonCdpManager, sessionId: string): Promise<boolean>;
+    listSessionChats(cdp: DaemonCdpManager, sessionId: string): Promise<AgentChatListItem[]>;
+    switchConversation(cdp: DaemonCdpManager, sessionId: string, conversationId: string): Promise<boolean>;
+    focusSession(cdp: DaemonCdpManager, sessionId: string): Promise<boolean>;
+    getConnectedSessions(parentSessionId?: string): string[];
+    getManagedSession(sessionId: string): ManagedAgent | undefined;
+    dispose(cdpManagers: Map<string, DaemonCdpManager>): Promise<void>;
+    resolveSessionForAgent(parentSessionId: string, agentType: string): string | null;
+}

package/dist/agent-stream/poller.d.ts

@@ -0,0 +1,41 @@
+/**
+ * AgentStreamPoller — Periodic agent stream polling + extension dynamic management
+ *
+ * Handles periodic agent stream polling and extension dynamic management.
+ *
+ * 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
+ */
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { DaemonAgentStreamManager } from './manager.js';
+import type { ProviderLoader } from '../providers/provider-loader.js';
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import type { SessionRegistry } from '../sessions/registry.js';
+import type { AgentStreamState } from './types.js';
+export interface AgentStreamPollerDeps {
+    agentStreamManager: DaemonAgentStreamManager;
+    providerLoader: ProviderLoader;
+    instanceManager: ProviderInstanceManager;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    sessionRegistry: SessionRegistry;
+    /** Callback when agent streams are updated */
+    onStreamsUpdated?: (ideType: string, streams: AgentStreamState[]) => void;
+}
+export declare class AgentStreamPoller {
+    private deps;
+    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(parentSessionId: 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;
+}

package/dist/agent-stream/provider-adapter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ProviderStreamAdapter — generic Extension adapter based on provider.js
+ *
+ * Consolidates ClineAdapter, RooCodeAdapter, ContinueAdapter.
+ * Auto-configured using provider.js scripts + metadata.
+ */
+import type { IAgentStreamAdapter, AgentStreamState, AgentChatListItem, AgentEvaluateFn } from './types.js';
+import type { ProviderModule } from '../providers/contracts.js';
+export declare class ProviderStreamAdapter implements IAgentStreamAdapter {
+    readonly agentType: string;
+    readonly agentName: string;
+    readonly extensionId: string;
+    readonly extensionIdPattern: RegExp;
+    private provider;
+    private lastSuccessState;
+    constructor(provider: ProviderModule);
+    private callScript;
+    private hasScript;
+    private summarizeRaw;
+    private isTransportError;
+    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>;
+    private errorState;
+}

package/dist/agent-stream/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Agent Stream Types — ported for Daemon (identical to original)
+ *
+ * Agent stream types.
+ * No vscode dependency — can be used as-is.
+ */
+/** Agent chat message */
+export interface AgentChatMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp?: number;
+}
+/** Agent chat history item */
+export interface AgentChatListItem {
+    title: string;
+    id: string;
+    status?: string;
+    time?: string;
+    cost?: string;
+}
+/** Agent stream status */
+export interface AgentStreamState {
+    agentType: string;
+    agentName: string;
+    extensionId: string;
+    status: 'idle' | 'streaming' | 'waiting_approval' | 'error' | 'disconnected' | 'panel_hidden' | 'not_monitored';
+    messages: AgentChatMessage[];
+    inputContent: string;
+    /** @deprecated Use controlValues['model'] — kept for backward compatibility */
+    model?: string;
+    /** @deprecated Use controlValues['mode'] — kept for backward compatibility */
+    mode?: string;
+    activeModal?: {
+        message: string;
+        buttons: string[];
+    };
+    /** Dynamic control current values (populated from readChat + provider controls schema) */
+    controlValues?: Record<string, string | number | boolean>;
+}
+/** Agent webview target info */
+export interface AgentWebviewTarget {
+    targetId: string;
+    extensionId: string;
+    agentType: string;
+    url: string;
+}
+/** Agent stream adapter interface */
+export 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;
+}
+export type AgentEvaluateFn = (expression: string, timeoutMs?: number) => Promise<unknown>;

package/dist/boot/daemon-lifecycle.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Daemon Lifecycle — Shared init + shutdown logic
+ *
+ * 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.
+ */
+import { DaemonCdpManager } from '../cdp/manager.js';
+import { DaemonCdpInitializer } from '../cdp/initializer.js';
+import { DaemonCommandHandler } from '../commands/handler.js';
+import { DaemonCommandRouter } from '../commands/router.js';
+import { DaemonCliManager, type CliTransportFactoryParams, type HostedCliRuntimeDescriptor } from '../commands/cli-manager.js';
+import { DaemonAgentStreamManager } from '../agent-stream/manager.js';
+import { AgentStreamPoller } from '../agent-stream/poller.js';
+import { ProviderLoader } from '../providers/provider-loader.js';
+import { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import { DevServer } from '../daemon/dev-server.js';
+import { SessionRegistry } from '../sessions/registry.js';
+import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
+export 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;
+        createPtyTransportFactory?: (params: CliTransportFactoryParams) => PtyTransportFactory | null;
+        listHostedCliRuntimes?: () => Promise<HostedCliRuntimeDescriptor[]>;
+    };
+    /** 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;
+}
+export interface DaemonComponents {
+    providerLoader: ProviderLoader;
+    instanceManager: ProviderInstanceManager;
+    cliManager: DaemonCliManager;
+    commandHandler: DaemonCommandHandler;
+    agentStreamManager: DaemonAgentStreamManager;
+    router: DaemonCommandRouter;
+    poller: AgentStreamPoller;
+    cdpInitializer: DaemonCdpInitializer;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    sessionRegistry: SessionRegistry;
+    detectedIdes: {
+        value: any[];
+    };
+}
+export interface DaemonDevSupportOptions {
+    components: DaemonComponents;
+    logFn?: (msg: string) => void;
+}
+/**
+ * Initialize all daemon core components.
+ *
+ * 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
+ */
+export declare function initDaemonComponents(config: DaemonInitConfig): Promise<DaemonComponents>;
+/**
+ * Start shared dev-only helpers:
+ * - DevServer on port 19280
+ * - Provider hot-reload watcher
+ */
+export declare function startDaemonDevSupport(options: DaemonDevSupportOptions): Promise<DevServer>;
+/**
+ * Graceful shutdown of all daemon components.
+ *
+ * Order:
+ *   1. Stop timers (poller, cdpInitializer)
+ *   2. Dispose agent stream
+ *   3. Shutdown CLIs
+ *   4. Dispose instances
+ *   5. Disconnect CDPs
+ */
+export declare function shutdownDaemonComponents(components: DaemonComponents): Promise<void>;

package/dist/cdp/devtools.d.ts

@@ -0,0 +1,51 @@
+/**
+ * CDP DOM Analysis Tools — DOM dump, query, debug
+ *
+ * Separated from daemon-commands.ts.
+ * Tools for analyzing DOM structure when developing new IDE scripts.
+ */
+import type { DaemonCdpManager } from './manager.js';
+import type { CommandResult } from '../commands/handler.js';
+type CdpGetter = (ideType?: string) => DaemonCdpManager | null;
+/**
+ * CDP DOM analysis handler
+ *
+ * Uses getCdp from DaemonCommandHandler.
+ */
+export 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>;
+    /**
+    * 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>;
+    /**
+    * 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>;
+}
+export {};

package/dist/cdp/initializer.d.ts

@@ -0,0 +1,50 @@
+/**
+ * DaemonCdpInitializer — Unified CDP initialization + periodic scanning
+ *
+ * Unified CDP initialization + periodic scanning.
+ *
+ * Features:
+ *   1. Initial connection: connectAll() — multi-window aware
+ *   2. Periodic scan: startPeriodicScan() — auto-detect newly opened IDEs
+ *   3. Discovery: startDiscovery() — periodic agent webview discovery
+ */
+import { DaemonCdpManager } from './manager.js';
+import type { ProviderLoader } from '../providers/provider-loader.js';
+export 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>;
+    /** Callback when a stale/disconnected CDP manager is removed */
+    onDisconnected?: (ideType: string, manager: DaemonCdpManager, managerKey: string, reason: 'ide_closed' | 'target_closed' | 'target_rekeyed') => void | Promise<void>;
+}
+export 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;
+    private pruneStaleManagers;
+    /**
+     * 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;
+}

package/dist/cdp/manager.d.ts

@@ -0,0 +1,145 @@
+/**
+ * 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
+ */
+import type { CdpTargetFilter } from '../providers/contracts.js';
+interface CdpTarget {
+    id: string;
+    type: string;
+    title: string;
+    url: string;
+    webSocketDebuggerUrl: string;
+}
+export interface AgentWebviewTarget {
+    targetId: string;
+    extensionId: string;
+    agentType: string;
+    url: string;
+}
+export 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;
+    private _lastDiscoveredTargets?;
+    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;
+    /** Connected target ID */
+    get targetId(): string | null;
+    /**
+    * 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>;
+    /**
+     * Evaluate inside the child frame of an attached session.
+     * Extension webviews have a nested iframe structure:
+     *   outer (vscode-webview://) → inner (extension React app)
+     * This method navigates into the inner frame using CDP Page.getFrameTree.
+     * Falls back to evaluateInSession if no child frame is found.
+     */
+    evaluateInSessionFrame(sessionId: string, expression: string, timeoutMs?: number): Promise<unknown>;
+    detachAgent(sessionId: string): Promise<void>;
+    detachAllAgents(): Promise<void>;
+    getAgentSessions(): Map<string, AgentWebviewTarget>;
+    private getCurrentPageWebviewUrls;
+    captureScreenshot(opts?: {
+        quality?: number;
+    }): Promise<Buffer | null>;
+}
+export {};

package/dist/cdp/scanner.d.ts

@@ -0,0 +1,58 @@
+/**
+ * DaemonCdpScanner — Periodic CDP port scanning & auto-connect
+ *
+ * Periodic CDP port scanning and auto-connect for IDE discovery.
+ * 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)
+ */
+import { DaemonCdpManager } from './manager.js';
+import { type CdpSetupContext } from './setup.js';
+export 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;
+}
+export 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.
+     * Multiple CDP managers per IDE — one per workbench page.
+     */
+    private connectMultiWindow;
+}

package/dist/cdp/setup.d.ts

@@ -0,0 +1,58 @@
+/**
+ * DaemonCdpSetup — Shared CDP initialization helpers
+ *
+ * Common CDP setup logic for consistent
+ * CDP → ProviderInstance registration.
+ */
+import { DaemonCdpManager } from './manager.js';
+import { ProviderLoader } from '../providers/provider-loader.js';
+import { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import { IdeProviderInstance } from '../providers/ide-provider-instance.js';
+import { SessionRegistry } from '../sessions/registry.js';
+export interface CdpSetupContext {
+    providerLoader: ProviderLoader;
+    instanceManager: ProviderInstanceManager;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    sessionRegistry: SessionRegistry;
+    /** Server connection (optional) */
+    serverConn?: any;
+}
+export 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.
+ */
+export 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. Register runtime sessions (workspace + extension children)
+ *
+ * @returns The created IdeProviderInstance, or null if provider not found
+ */
+export 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
+ */
+export 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
+ */
+export declare function probeCdpPort(port: number, timeoutMs?: number): Promise<boolean>;