@adhdev/daemon-core 0.5.3

package/src/cdp/scanner.ts

@@ -0,0 +1,185 @@
+/**
+ * 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)
+ */
+
+import { DaemonCdpManager } from './manager.js';
+import { ProviderLoader } from '../providers/provider-loader.js';
+import { connectCdpManager, probeCdpPort, registerExtensionProviders, setupIdeInstance, type CdpSetupContext } from './setup.js';
+import { LOG } from '../logging/logger.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 class DaemonCdpScanner {
+  private ctx: CdpSetupContext;
+  private opts: CdpScannerOptions;
+  private scanTimer: NodeJS.Timeout | null = null;
+  private discoveryTimer: NodeJS.Timeout | null = null;
+
+  constructor(opts: CdpScannerOptions) {
+    this.ctx = opts.ctx;
+    this.opts = opts;
+  }
+
+  /**
+   * Initial CDP discovery — connect to all available IDEs.
+   * Supports both single-window and multi-window modes.
+   */
+  async initialScan(enabledIdes?: string[]): Promise<void> {
+    const portMap = this.ctx.providerLoader.getCdpPortMap();
+    const portsToTry: { port: number; ide: string }[] = [];
+
+    for (const [ide, ports] of Object.entries(portMap)) {
+      portsToTry.push({ port: ports[0], ide });
+    }
+
+    // Apply enabledIdes filter if provided
+    const filtered = enabledIdes?.length
+      ? portsToTry.filter(p => enabledIdes.includes(p.ide))
+      : portsToTry;
+
+    for (const { port, ide } of filtered) {
+      if (this.opts.multiWindow) {
+        await this.connectMultiWindow(port, ide);
+      } else {
+        await this.connectSingleWindow(port, ide);
+      }
+    }
+  }
+
+  /**
+   * Start periodic scanning for newly launched IDEs.
+   */
+  startPeriodicScan(): void {
+    if (this.scanTimer) return;
+    const interval = this.opts.scanIntervalMs || 30_000;
+
+    this.scanTimer = setInterval(async () => {
+      const portMap = this.ctx.providerLoader.getCdpPortMap();
+      for (const [ide, ports] of Object.entries(portMap)) {
+        const primaryPort = ports[0];
+        // Skip if already connected
+        const alreadyConnected = [...this.ctx.cdpManagers.entries()].some(([key, m]) =>
+          m.isConnected && (key === ide || key.startsWith(ide + '_'))
+        );
+        if (alreadyConnected) continue;
+
+        if (this.opts.multiWindow) {
+          await this.connectMultiWindow(primaryPort, ide);
+        } else {
+          await this.connectSingleWindow(primaryPort, ide);
+        }
+      }
+    }, interval);
+  }
+
+  /**
+   * Start periodic agent webview discovery on all connected CDPs.
+   */
+  startWebviewDiscovery(intervalMs = 30_000): void {
+    if (this.discoveryTimer) return;
+    this.discoveryTimer = setInterval(async () => {
+      for (const m of this.ctx.cdpManagers.values()) {
+        if (m.isConnected) {
+          await m.discoverAgentWebviews();
+        }
+      }
+    }, intervalMs);
+  }
+
+  /**
+   * Stop all timers.
+   */
+  stop(): void {
+    if (this.scanTimer) { clearInterval(this.scanTimer); this.scanTimer = null; }
+    if (this.discoveryTimer) { clearInterval(this.discoveryTimer); this.discoveryTimer = null; }
+  }
+
+  // ── Internal ────────────────────────────
+
+  private getLogFn(ideType: string): (msg: string) => void {
+    if (this.opts.logFn) return this.opts.logFn(ideType);
+    return (msg: string) => LOG.info(`CDP:${ideType}`, msg);
+  }
+
+  /**
+   * Single-window connection (standalone mode).
+   * One CDP manager per IDE, first working port wins.
+   */
+  private async connectSingleWindow(port: number, ide: string): Promise<void> {
+    if (this.ctx.cdpManagers.has(ide)) return;
+    const available = await probeCdpPort(port);
+    if (!available) return;
+
+    const manager = await connectCdpManager(
+      port, ide, this.getLogFn(ide), this.ctx.providerLoader,
+    );
+    if (!manager) return;
+
+    registerExtensionProviders(this.ctx.providerLoader, manager, ide);
+    this.ctx.cdpManagers.set(ide, manager);
+    LOG.info('CDP', `Connected: ${ide} (port ${port})`);
+
+    // Setup IDE instance
+    await setupIdeInstance(this.ctx, { ideType: ide, manager });
+    this.opts.onConnected?.(ide, ide, manager);
+  }
+
+  /**
+   * Multi-window connection (cloud mode).
+   * Multiple CDP managers per IDE — one per workbench page.
+   */
+  private async connectMultiWindow(port: number, ide: string): Promise<void> {
+    const allTargets = await DaemonCdpManager.listAllTargets(port);
+
+    if (allTargets.length === 0) {
+      // Fallback: single-window approach
+      await this.connectSingleWindow(port, ide);
+      return;
+    }
+
+    for (let i = 0; i < allTargets.length; i++) {
+      const target = allTargets[i];
+      let managerKey: string;
+      if (allTargets.length === 1) {
+        managerKey = ide;
+      } else {
+        const workspaceName = (target.title || '').split(' — ')[0].trim() || `window_${i}`;
+        managerKey = `${ide}_${workspaceName}`;
+      }
+
+      if (this.ctx.cdpManagers.has(managerKey)) continue;
+
+      const manager = await connectCdpManager(
+        port, ide, this.getLogFn(managerKey), this.ctx.providerLoader, target.id,
+      );
+      if (!manager) continue;
+
+      this.ctx.cdpManagers.set(managerKey, manager);
+      LOG.info('CDP', `Connected: ${managerKey} (port ${port}, page "${target.title}")`);
+
+      await setupIdeInstance(this.ctx, {
+        ideType: ide,
+        manager,
+        managerKey,
+      });
+      this.opts.onConnected?.(ide, managerKey, manager);
+    }
+  }
+}

package/src/cdp/setup.ts

@@ -0,0 +1,150 @@
+/**
+ * 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.
+ */
+
+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 type { ProviderModule } from '../providers/contracts.js';
+
+export 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;
+}
+
+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 function registerExtensionProviders(
+  providerLoader: ProviderLoader,
+  manager: DaemonCdpManager,
+  ideType: string,
+): void {
+  const enabledExtProviders = providerLoader.getEnabledExtensionProviders(ideType)
+    .map((p: any) => ({
+      agentType: p.type,
+      extensionId: p.extensionId || '',
+      extensionIdPattern: p.extensionIdPattern!,
+    }));
+  manager.setExtensionProviders(enabledExtProviders);
+}
+
+/**
+ * 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
+ */
+export async function setupIdeInstance(
+  ctx: CdpSetupContext,
+  opts: SetupIdeInstanceOptions,
+): Promise<IdeProviderInstance | null> {
+  const { providerLoader, instanceManager, instanceIdMap } = ctx;
+  const { ideType, manager, settings } = opts;
+  const managerKey = opts.managerKey || ideType;
+
+  // 1. Register extension providers on CDP manager
+  registerExtensionProviders(providerLoader, manager, ideType);
+
+  // 2. Resolve provider with scripts
+  const ideProvider = providerLoader.resolve(ideType);
+  if (!ideProvider) return null;
+
+  // 3. Create IdeProviderInstance
+  const ideInstance = new IdeProviderInstance(
+    ideProvider,
+    managerKey !== ideType ? managerKey : undefined,
+  );
+
+  // 4. Register in InstanceManager
+  const resolvedSettings = settings || providerLoader.getSettings(ideType);
+  await instanceManager.addInstance(`ide:${managerKey}`, ideInstance, {
+    cdp: manager,
+    serverConn: ctx.serverConn,
+    settings: resolvedSettings,
+  });
+
+  // 5. Map IDE instance UUID → manager key
+  instanceIdMap.set(ideInstance.getInstanceId(), managerKey);
+
+  // 6. Register enabled extensions
+  const extensionProviders = providerLoader.getEnabledByCategory('extension', ideType);
+  for (const extProvider of extensionProviders) {
+    const extSettings = providerLoader.getSettings(extProvider.type);
+    await ideInstance.addExtension(extProvider, extSettings);
+    // Map extension UUIDs too (CDP uses parent IDE)
+    for (const ext of ideInstance.getExtensionInstances()) {
+      instanceIdMap.set(ext.getInstanceId(), managerKey);
+    }
+  }
+
+  return ideInstance;
+}
+
+/**
+ * Create and connect a DaemonCdpManager for a given port.
+ *
+ * @returns Connected manager or null if connection failed
+ */
+export async function connectCdpManager(
+  port: number,
+  ideType: string,
+  logFn: (msg: string) => void,
+  providerLoader: ProviderLoader,
+  targetId?: string,
+): Promise<DaemonCdpManager | null> {
+  const provider = providerLoader.getMeta(ideType);
+  const manager = new DaemonCdpManager(
+    port,
+    logFn,
+    targetId,
+    (provider as any)?.targetFilter,
+  );
+  const connected = await manager.connect();
+  return connected ? manager : null;
+}
+
+/**
+ * Probe a CDP port to check if it's listening.
+ * @returns true if CDP is available on this port
+ */
+export async function probeCdpPort(port: number, timeoutMs = 1000): Promise<boolean> {
+  try {
+    const probe = await fetch(`http://localhost:${port}/json/version`, {
+      signal: AbortSignal.timeout(timeoutMs),
+    }).then(r => r.json()).catch(() => null);
+    return !!probe;
+  } catch {
+    return false;
+  }
+}

package/src/cli-adapter-types.ts

@@ -0,0 +1,25 @@
+/**
+ * CliAdapter — common interface for CLI agents
+ *
+ * Contract implemented by all CLI adapters (ProviderCliAdapter etc).
+ */
+
+export 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;
+ // Raw PTY I/O (for terminal view)
+    setOnPtyData?(callback: (data: string) => void): void;
+    writeRaw?(data: string): void;
+    resize?(cols: number, rows: number): void;
+}