@adhdev/daemon-core 0.8.34 → 0.8.36

package/src/cdp/manager.d.ts

@@ -0,0 +1,147 @@
+/**
+ * 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;
+    /** Clear a previously pinned target so the next connect can reselect a page. */
+    clearTargetId(): 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/src/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/src/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>;

package/src/cli-adapter-types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * CliAdapter — common interface for CLI agents
+ *
+ * Contract implemented by all CLI adapters (ProviderCliAdapter etc).
+ */
+import type { ChatMessage } from './types.js';
+export interface CliAdapterStatus {
+    status?: string;
+    messages?: ChatMessage[];
+    activeModal?: {
+        message: string;
+        buttons: string[];
+    } | null;
+}
+export interface AcpAdapterHandle {
+    onEvent(event: string, data?: unknown): void;
+    getState(): {
+        status: string;
+        activeChat?: {
+            messages?: ChatMessage[];
+            activeModal?: {
+                message: string;
+                buttons: string[];
+            } | null;
+        } | null;
+    };
+    setMode?(mode: string): Promise<void>;
+    setConfigOption?(configId: string, value: string): Promise<void>;
+    resolvePermission?(approved: boolean): Promise<void>;
+}
+export interface CliAdapter {
+    cliType: string;
+    cliName: string;
+    workingDir: string;
+    _acpInstance?: AcpAdapterHandle;
+    spawn(): Promise<void>;
+    sendMessage(text: string): Promise<void>;
+    getStatus(): CliAdapterStatus;
+    getScriptParsedStatus?(): unknown;
+    invokeScript?(scriptName: string, args?: Record<string, unknown>): Promise<unknown>;
+    getPartialResponse(): string;
+    saveAndStop?(): Promise<void>;
+    shutdown(): void;
+    detach?(): void;
+    cancel(): void;
+    isProcessing(): boolean;
+    isReady(): boolean;
+    setOnStatusChange(callback: () => void): void;
+    updateRuntimeSettings?(settings: Record<string, unknown>): void;
+    setServerConn?(serverConn: unknown): void;
+    clearHistory?(): void;
+    resolveAction?(data: unknown): Promise<void>;
+    resolveModal?(buttonIndex: number): void;
+    setOnPtyData?(callback: (data: string) => void): void;
+    writeRaw?(data: string): void;
+    resize?(cols: number, rows: number): void;
+}

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

@@ -0,0 +1,177 @@
+/**
+ * ProviderCliAdapter — Script-based CLI Adapter
+ *
+ * All CLI providers use versioned scripts (like IDE providers).
+ * Scripts are Node.js functions that receive PTY buffer data and return structured results.
+ *
+ * Required scripts in scripts/{version}/scripts.js:
+ *   - detectStatus(input)  → AgentStatus string ('idle' | 'generating' | 'waiting_approval')
+ *   - parseOutput(input)   → ReadChatResult { messages, status, activeModal, ... }
+ *   - parseApproval(input) → ModalInfo | null
+ *
+ * provider.json contract:
+ *   type, name, category: 'cli', binary, spawn, approvalKeys
+ *   compatibility: [{ ideVersion, scriptDir }]  ← versioned scripts
+ */
+import type { CliAdapter } from '../cli-adapter-types.js';
+import { type PtyRuntimeMetadata, type PtyTransportFactory } from './pty-transport.js';
+import { type CliChatMessage, type CliProviderModule, type CliScripts, type CliSessionStatus } from './provider-cli-shared.js';
+import { type ProviderResolutionMeta } from './provider-cli-config.js';
+export { normalizeCliProviderForRuntime, type CliApprovalInput, type CliChatMessage, type CliProviderModule, type CliScreenLine, type CliScreenSnapshot, type CliScriptInput, type CliScripts, type CliSessionStatus, type CliStatusInput, type CliTraceEntry, } from './provider-cli-shared.js';
+type SeedCliChatMessage = Omit<Partial<CliChatMessage>, 'role'> & {
+    role?: string;
+    content?: string;
+};
+export declare class ProviderCliAdapter implements CliAdapter {
+    private extraArgs;
+    readonly cliType: string;
+    readonly cliName: string;
+    workingDir: string;
+    private provider;
+    private ptyProcess;
+    private transportFactory;
+    private messages;
+    private committedMessages;
+    private structuredMessages;
+    private currentStatus;
+    private onStatusChange;
+    private responseBuffer;
+    private recentOutputBuffer;
+    private isWaitingForResponse;
+    private activeModal;
+    private responseTimeout;
+    private idleTimeout;
+    private ready;
+    private startupBuffer;
+    private startupParseGate;
+    private startupSettleTimer;
+    private spawnAt;
+    private startupFirstOutputAt;
+    private onPtyDataCallback;
+    private pendingOutputParseBuffer;
+    private pendingOutputParseTimer;
+    private ptyOutputBuffer;
+    private ptyOutputFlushTimer;
+    private pendingTerminalQueryTail;
+    private lastOutputAt;
+    private lastNonEmptyOutputAt;
+    private lastScreenChangeAt;
+    private lastScreenSnapshot;
+    private serverConn;
+    private logBuffer;
+    private lastApprovalResolvedAt;
+    private approvalTransitionBuffer;
+    private approvalExitTimeout;
+    private pendingScriptStatus;
+    private pendingScriptStatusSince;
+    private pendingScriptStatusTimer;
+    private settleTimer;
+    private settledBuffer;
+    private submitPendingUntil;
+    private responseSettleIgnoreUntil;
+    private responseEpoch;
+    private submitRetryTimer;
+    private submitRetryUsed;
+    private submitRetryPromptSnippet;
+    private idleFinishCandidate;
+    private finishRetryTimer;
+    private finishRetryCount;
+    private resizeSuppressUntil;
+    private statusHistory;
+    private cliScripts;
+    private runtimeSettings;
+    /** Full accumulated ANSI-stripped PTY output */
+    private accumulatedBuffer;
+    /** Full accumulated raw PTY output (with ANSI) */
+    private accumulatedRawBuffer;
+    /** Current visible terminal screen snapshot */
+    private terminalScreen;
+    /** Max accumulated buffer size (last 50KB) */
+    private static readonly MAX_ACCUMULATED_BUFFER;
+    private currentTurnScope;
+    private traceEntries;
+    private traceSeq;
+    private traceSessionId;
+    private static readonly MAX_TRACE_ENTRIES;
+    private readonly providerResolutionMeta;
+    private static readonly IDLE_FINISH_CONFIRM_MS;
+    private static readonly STATUS_ACTIVITY_HOLD_MS;
+    private static readonly FINISH_RETRY_DELAY_MS;
+    private static readonly MAX_FINISH_RETRIES;
+    private syncMessageViews;
+    private setStatus;
+    private clearIdleFinishCandidate;
+    private armIdleFinishCandidate;
+    private recordTrace;
+    private resetTraceSession;
+    private readonly timeouts;
+    private readonly approvalKeys;
+    private readonly sendDelayMs;
+    private readonly sendKey;
+    private readonly submitStrategy;
+    private static readonly SCRIPT_STATUS_DEBOUNCE_MS;
+    constructor(provider: CliProviderModule, workingDir: string, extraArgs?: string[], transportFactory?: PtyTransportFactory);
+    /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
+    setCliScripts(scripts: CliScripts): void;
+    updateRuntimeSettings(settings: Record<string, any>): void;
+    setServerConn(serverConn: any): void;
+    setOnStatusChange(callback: () => void): void;
+    setOnPtyData(callback: (data: string) => void): void;
+    private flushPendingOutputParse;
+    spawn(): Promise<void>;
+    private handleOutput;
+    private resolveStartupState;
+    private scheduleStartupSettleCheck;
+    private scheduleSettle;
+    private armApprovalExitTimeout;
+    private looksLikeVisibleIdlePrompt;
+    private findLastMatchingLineIndex;
+    private looksLikeClaudeGeneratingLine;
+    private detectClaudeGeneratingOverride;
+    private refineDetectedStatus;
+    private looksLikeVisibleAssistantCandidate;
+    private shouldRetryFinishResponse;
+    private hasRecentInteractiveActivity;
+    private getStartupConfirmationModal;
+    private shouldResolveModalWithEnter;
+    private waitForInteractivePrompt;
+    private evaluateSettled;
+    private finishResponse;
+    private commitCurrentTranscript;
+    private runDetectStatus;
+    private runParseApproval;
+    getStatus(): CliSessionStatus;
+    seedCommittedMessages(messages: SeedCliChatMessage[]): void;
+    /**
+     * Script-based full parse — returns ReadChatResult.
+     * Called by command handler / dashboard for rich content rendering.
+     */
+    getScriptParsedStatus(): any;
+    invokeScript(scriptName: string, args?: Record<string, any>): Promise<any>;
+    private parseCurrentTranscript;
+    /** Whether this adapter has CLI scripts loaded */
+    hasCliScripts(): boolean;
+    /**
+     * Resolves an action (like 'fix' lint error) from the dashboard.
+     * Uses resolveAction script if available, otherwise falls back to standard text.
+     */
+    resolveAction(data: any): Promise<void>;
+    sendMessage(text: string): Promise<void>;
+    getPartialResponse(): string;
+    getRuntimeMetadata(): PtyRuntimeMetadata | null;
+    updateRuntimeMeta(meta: Record<string, unknown>, replace?: boolean): void;
+    cancel(): void;
+    saveAndStop(): Promise<void>;
+    private waitForStopped;
+    shutdown(): void;
+    detach(): void;
+    clearHistory(): void;
+    isProcessing(): boolean;
+    isReady(): boolean;
+    writeRaw(data: string): void;
+    resolveModal(buttonIndex: number): void;
+    resize(cols: number, rows: number): void;
+    getDebugState(): Record<string, any>;
+    getTraceState(limit?: number): Record<string, any>;
+    getProviderResolutionMeta(): ProviderResolutionMeta;
+}