@adhdev/daemon-core 0.5.3

package/src/daemon/scaffold-template.ts

@@ -0,0 +1,394 @@
+/**
+ * Provider scaffold template generator
+ * Generates provider.json + scripts/ directory structure (Antigravity pattern).
+ *
+ * New pattern:
+ *   - Scripts WITHOUT params: self-invoking IIFE — (() => { ... })()
+ *   - Scripts WITH params: function expression — (params) => { ... }
+ *     Router invokes: `(${script})(${JSON.stringify(params)})`
+ *   - Each function is a separate .js file in scripts/<version>/
+ *   - scripts.js router loads + invokes individual files
+ */
+
+export interface ScaffoldOptions {
+  cdpPorts?: [number, number];
+  cli?: string;
+  processName?: string;
+  installPath?: string;
+  binary?: string;
+  extensionId?: string;
+  version?: string;
+}
+
+export interface ScaffoldResult {
+  'provider.json': string;
+  files?: Record<string, string>;
+}
+
+export function generateTemplate(type: string, name: string, category: string, opts: ScaffoldOptions = {}): string {
+  const result = generateFiles(type, name, category, opts);
+  return result['provider.json'];
+}
+
+/**
+ * Generate provider.json + per-function script files.
+ * Returns a map of relative paths -> file contents.
+ */
+export function generateFiles(type: string, name: string, category: string, opts: ScaffoldOptions = {}): ScaffoldResult {
+  const { cdpPorts, cli, processName, installPath, binary, extensionId, version = '0.1' } = opts;
+
+  // ─── CLI / ACP: provider.json only ───
+  if (category === 'cli' || category === 'acp') {
+    const bin = binary || type;
+    const meta: Record<string, any> = {
+      type,
+      name,
+      category,
+      icon: '💻',
+      binary: bin,
+      spawn: {
+        command: bin,
+        args: [],
+        shell: true,
+      },
+      patterns: {
+        prompt: ['^[>$#] '],
+        generating: ['\\.{3}$', 'thinking'],
+        approval: ['\\(y\\/n\\)', 'approve', 'allow'],
+        ready: ['ready'],
+      },
+    };
+    return { 'provider.json': JSON.stringify(meta, null, 2) + '\n' };
+  }
+
+  // ─── IDE / Extension: provider.json + scripts/ directory ───
+  const isExtension = category === 'extension';
+  const scriptDir = `scripts/${version}`;
+
+  const meta: Record<string, any> = {
+    type,
+    name,
+    category,
+    displayName: name,
+    icon: isExtension ? '🧩' : '💻',
+  };
+  if (cli) meta.cli = cli;
+  if (cdpPorts) meta.cdpPorts = cdpPorts;
+  else if (!isExtension) meta.cdpPorts = [9222, 9223];
+  if (processName) meta.processNames = { darwin: processName };
+  if (installPath) meta.paths = { darwin: [installPath] };
+  if (isExtension) {
+    meta.extensionId = extensionId || `publisher.${type}`;
+    meta.extensionIdPattern = `${extensionId || type}`;
+  } else {
+    meta.inputMethod = 'cdp-type-and-send';
+    meta.inputSelector = '[contenteditable="true"][role="textbox"]';
+    meta.providerVersion = '1.0.0';
+    meta.compatibility = [
+      { ideVersion: `>=${version}.0`, scriptDir },
+    ];
+    meta.defaultScriptDir = scriptDir;
+  }
+
+  // ─── Individual script files ───
+  const files: Record<string, string> = {};
+
+  // Router (scripts.js)
+  files[`${scriptDir}/scripts.js`] = `/**
+ * ${name} CDP Scripts — Router
+ *
+ * Loads individual .js files and invokes with params.
+ * Pattern:
+ *   - No-params scripts: loaded as-is (IIFE)
+ *   - With-params scripts: \`(\${script})(\${JSON.stringify(params)})\`
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+function load(name) {
+    try { return fs.readFileSync(path.join(__dirname, name), 'utf-8'); }
+    catch { return null; }
+}
+
+function withParams(name, params) {
+    const script = load(name);
+    if (!script) return null;
+    return \`(\${script})(\${JSON.stringify(params)})\`;
+}
+
+// ─── Core (no params — IIFE) ───
+
+module.exports.readChat       = () => load('read_chat.js');
+module.exports.sendMessage    = () => load('send_message.js');
+module.exports.listSessions   = () => load('list_sessions.js');
+module.exports.newSession     = () => load('new_session.js');
+module.exports.focusEditor    = () => load('focus_editor.js');
+module.exports.openPanel      = () => load('open_panel.js');
+module.exports.listModels     = () => load('list_models.js');
+module.exports.listModes      = () => load('list_modes.js');
+
+// ─── With params (function expression) ───
+
+module.exports.switchSession = (params) => {
+    const index = typeof params === 'number' ? params : params?.index ?? 0;
+    const title = typeof params === 'string' ? params : params?.title || null;
+    return withParams('switch_session.js', { index, title });
+};
+
+module.exports.resolveAction = (params) => {
+    const action = typeof params === 'string' ? params : params?.action || 'approve';
+    const buttonText = params?.button || params?.buttonText
+        || (action === 'approve' ? 'Accept' : action === 'reject' ? 'Reject' : action);
+    return withParams('resolve_action.js', { buttonText });
+};
+
+module.exports.setModel = (params) => {
+    const model = typeof params === 'string' ? params : params?.model;
+    return withParams('set_model.js', { model });
+};
+
+module.exports.setMode = (params) => {
+    const mode = typeof params === 'string' ? params : params?.mode;
+    return withParams('set_mode.js', { mode });
+};
+`;
+
+  // read_chat.js — most complex, stub with detailed TODO
+  files[`${scriptDir}/read_chat.js`] = `/**
+ * ${name} — read_chat
+ *
+ * Extract chat messages, status, and approval state from DOM.
+ *
+ * TODO: Identify via CDP/DevConsole:
+ *   1. Chat container selector
+ *   2. User message selector + class pattern
+ *   3. Assistant message selector + class pattern
+ *   4. Status detection (generating/idle/waiting_approval)
+ *   5. Approval dialog detection (buttons, modal)
+ *   6. Input field selector
+ *
+ * → { id, status, title, messages[], inputContent, activeModal }
+ */
+(() => {
+  try {
+    const messages = [];
+    let status = 'idle';
+    let activeModal = null;
+
+    // TODO: Query chat container and extract messages
+    // Example:
+    //   document.querySelectorAll('.chat-message').forEach(el => {
+    //     const role = el.classList.contains('user') ? 'user' : 'assistant';
+    //     messages.push({ role, content: el.innerText.trim(), index: messages.length });
+    //   });
+
+    // TODO: Detect generating state
+    // TODO: Detect approval dialogs -> status = 'waiting_approval'
+
+    const inputEl = document.querySelector('[contenteditable="true"]');
+    const inputContent = inputEl?.innerText?.trim() || '';
+
+    return JSON.stringify({
+      id: 'active',
+      status,
+      title: document.title,
+      messages,
+      inputContent,
+      activeModal,
+    });
+  } catch(e) {
+    return JSON.stringify({ id: '', status: 'error', messages: [], error: e.message });
+  }
+})()
+`;
+
+  // send_message.js
+  files[`${scriptDir}/send_message.js`] = `/**
+ * ${name} — send_message
+ *
+ * For cdp-type-and-send IDEs: returns selector for daemon to type into.
+ * → { sent: false, needsTypeAndSend: true, selector }
+ */
+(() => {
+  try {
+    const input = document.querySelector('${meta.inputSelector || '[contenteditable="true"]'}');
+    if (!input) return JSON.stringify({ sent: false, error: 'Input not found' });
+    return JSON.stringify({
+      sent: false,
+      needsTypeAndSend: true,
+      selector: '${meta.inputSelector || '[contenteditable="true"]'}',
+    });
+  } catch(e) {
+    return JSON.stringify({ sent: false, error: e.message });
+  }
+})()
+`;
+
+  // list_sessions.js
+  files[`${scriptDir}/list_sessions.js`] = `/**
+ * ${name} — list_sessions
+ *
+ * TODO: Query session/chat list from sidebar.
+ * → { sessions: [{ id, title, active, index }] }
+ */
+(() => {
+  try {
+    const sessions = [];
+    // TODO: Find session list container and parse items
+    return JSON.stringify({ sessions });
+  } catch(e) {
+    return JSON.stringify({ sessions: [], error: e.message });
+  }
+})()
+`;
+
+  // switch_session.js
+  files[`${scriptDir}/switch_session.js`] = `/**
+ * ${name} — switch_session
+ *
+ * params.index: number, params.title: string|null
+ * TODO: Click on session in sidebar by title or index.
+ * → { switched: true/false }
+ */
+(params) => {
+  try {
+    // TODO: Find session list and click target
+    return JSON.stringify({ switched: false, error: 'Not implemented' });
+  } catch(e) {
+    return JSON.stringify({ switched: false, error: e.message });
+  }
+}
+`;
+
+  // new_session.js
+  files[`${scriptDir}/new_session.js`] = `/**
+ * ${name} — new_session
+ *
+ * TODO: Click "New Chat" button.
+ * → { created: true/false }
+ */
+(() => {
+  try {
+    const btn = document.querySelector('[aria-label*="New Chat"], [aria-label*="New Composer"]');
+    if (btn) { btn.click(); return JSON.stringify({ created: true }); }
+    return JSON.stringify({ created: false, error: 'New Chat button not found' });
+  } catch(e) {
+    return JSON.stringify({ created: false, error: e.message });
+  }
+})()
+`;
+
+  // focus_editor.js
+  files[`${scriptDir}/focus_editor.js`] = `/**
+ * ${name} — focus_editor
+ */
+(() => {
+  try {
+    const input = document.querySelector('${meta.inputSelector || '[contenteditable="true"]'}');
+    if (input) { input.focus(); return 'focused'; }
+    return 'not_found';
+  } catch(e) { return 'error'; }
+})()
+`;
+
+  // open_panel.js
+  files[`${scriptDir}/open_panel.js`] = `/**
+ * ${name} — open_panel
+ *
+ * TODO: Open chat/AI panel if not visible.
+ */
+(() => {
+  try {
+    // TODO: Check if panel visible, if not find toggle button
+    return 'not_found';
+  } catch(e) { return 'error'; }
+})()
+`;
+
+  // resolve_action.js
+  files[`${scriptDir}/resolve_action.js`] = `/**
+ * ${name} — resolve_action
+ *
+ * params.buttonText: string — button text to find and click.
+ * → { resolved: true/false, clicked? }
+ */
+(params) => {
+  try {
+    const btns = [...document.querySelectorAll('button, [role="button"]')].filter(b => b.offsetWidth > 0);
+    const searchText = (params.buttonText || '').toLowerCase();
+    const target = btns.find(b => (b.textContent||'').trim().toLowerCase().includes(searchText));
+    if (target) {
+      target.click();
+      return JSON.stringify({ resolved: true, clicked: target.textContent.trim() });
+    }
+    return JSON.stringify({ resolved: false, available: btns.map(b => b.textContent.trim()).filter(Boolean).slice(0, 10) });
+  } catch(e) { return JSON.stringify({ resolved: false, error: e.message }); }
+}
+`;
+
+  // list_models.js
+  files[`${scriptDir}/list_models.js`] = `/**
+ * ${name} — list_models
+ *
+ * TODO: Open model dropdown and extract model list.
+ * → { models[], current }
+ */
+(() => {
+  try {
+    return JSON.stringify({ models: [], current: '' });
+  } catch(e) { return JSON.stringify({ models: [], current: '', error: e.message }); }
+})()
+`;
+
+  // list_modes.js
+  files[`${scriptDir}/list_modes.js`] = `/**
+ * ${name} — list_modes
+ *
+ * TODO: Open mode dropdown and extract mode list.
+ * → { modes[], current }
+ */
+(() => {
+  try {
+    return JSON.stringify({ modes: [], current: '' });
+  } catch(e) { return JSON.stringify({ modes: [], current: '', error: e.message }); }
+})()
+`;
+
+  // set_model.js
+  files[`${scriptDir}/set_model.js`] = `/**
+ * ${name} — set_model
+ *
+ * params.model: string
+ * TODO: Open model dropdown and select target model.
+ * → { success: true/false }
+ */
+async (params) => {
+  try {
+    return JSON.stringify({ success: false, error: 'Not implemented' });
+  } catch(e) { return JSON.stringify({ success: false, error: e.message }); }
+}
+`;
+
+  // set_mode.js
+  files[`${scriptDir}/set_mode.js`] = `/**
+ * ${name} — set_mode
+ *
+ * params.mode: string
+ * TODO: Open mode dropdown and select target mode.
+ * → { success: true/false }
+ */
+async (params) => {
+  try {
+    return JSON.stringify({ success: false, error: 'Not implemented' });
+  } catch(e) { return JSON.stringify({ success: false, error: e.message }); }
+}
+`;
+
+  return {
+    'provider.json': JSON.stringify(meta, null, 2) + '\n',
+    files,
+  };
+}

package/src/daemon-core.ts

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+
+import type { DaemonStatus, CommandResult, DaemonEvent, IdeEntry, CliEntry, AcpEntry } from './types.js';
+
+export 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;
+}
+
+export 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>;
+
+ /** Get currently detected/managed IDEs */
+  getManagedIdes(): IdeEntry[];
+
+ /** Get currently detected/managed CLIs */
+  getManagedClis(): CliEntry[];
+
+ /** Get currently detected/managed ACP agents */
+  getManagedAcps(): AcpEntry[];
+}

package/src/detection/cli-detector.ts

@@ -0,0 +1,89 @@
+/**
+ * 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.
+ */
+
+import { exec } from 'child_process';
+import * as os from 'os';
+import type { ProviderLoader } from '../providers/provider-loader.js';
+
+export interface CLIInfo {
+    id: string;
+    displayName: string;
+    icon: string;
+    command: string;
+    installed: boolean;
+    version?: string;
+    path?: string;
+    category?: string;
+}
+
+/** Run a shell command with timeout, returning stdout or null on failure */
+function execAsync(cmd: string, timeoutMs = 5000): Promise<string | null> {
+    return new Promise((resolve) => {
+        const child = exec(cmd, { encoding: 'utf-8', timeout: timeoutMs }, (err, stdout) => {
+            if (err || !stdout?.trim()) {
+                resolve(null);
+            } else {
+                resolve(stdout.trim());
+            }
+        });
+        // Safety: kill on timeout
+        child.on('error', () => resolve(null));
+    });
+}
+
+/**
+ * Detect all CLI/ACP agents (parallel)
+ * @param providerLoader ProviderLoader instance (dynamic list creation)
+ */
+export async function detectCLIs(providerLoader?: ProviderLoader): Promise<CLIInfo[]> {
+    const platform = os.platform();
+    const whichCmd = platform === 'win32' ? 'where' : 'which';
+
+    // Provider-based dynamic list creation, fallback is empty array
+    const cliList = providerLoader
+        ? providerLoader.getCliDetectionList()
+        : [];
+
+    // Run all `which` checks in parallel
+    const results = await Promise.all(
+        cliList.map(async (cli): Promise<CLIInfo> => {
+            try {
+                const pathResult = await execAsync(`${whichCmd} ${cli.command} 2>/dev/null`);
+                if (!pathResult) return { ...cli, installed: false };
+
+                const firstPath = pathResult.split('\n')[0];
+
+                // Get version (parallel with other checks)
+                let version: string | undefined;
+                try {
+                    const versionResult = await execAsync(`${cli.command} --version 2>/dev/null`, 3000);
+                    if (versionResult) {
+                        // Extract version number (e.g. "gemini v1.2.3" → "1.2.3")
+                        const match = versionResult.match(/(\d+\.\d+[\.\d]*)/);
+                        version = match ? match[1] : versionResult.split('\n')[0].slice(0, 30);
+                    }
+                } catch { }
+
+                return { ...cli, installed: true, version, path: firstPath };
+            } catch {
+                return { ...cli, installed: false };
+            }
+        })
+    );
+
+    return results;
+}
+
+/** Detect specific CLI */
+export async function detectCLI(cliId: string, providerLoader?: ProviderLoader): Promise<CLIInfo | null> {
+    // Resolve alias
+    const resolvedId = providerLoader ? providerLoader.resolveAlias(cliId) : cliId;
+    const all = await detectCLIs(providerLoader);
+    return all.find((c) => c.id === resolvedId && c.installed) || null;
+}

package/src/detection/ide-detector.ts

@@ -0,0 +1,157 @@
+/**
+ * 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.
+ */
+
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { platform, homedir } from 'os';
+
+// ─── Types ──────────────────────────────────────
+
+export 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;
+}
+
+export interface IDEDefinition {
+    id: string;
+    name: string;
+    displayName: string;
+    icon: string;
+    extensionSupport: 'full' | 'partial' | 'none';
+    cli: string;
+    paths: {
+        darwin?: string[];
+        win32?: string[];
+        linux?: string[];
+        [key: string]: string[] | undefined;
+    };
+}
+
+// No builtin IDE definitions — provider.js registered via registerToDetector() is the single source of truth
+// To add new IDE: create providers/_builtin/ide/{name}/provider.js then define paths/cli
+const BUILTIN_IDE_DEFINITIONS: IDEDefinition[] = [];
+
+// ─── Runtime Registry ───────────────────────────
+const registeredIDEs = new Map<string, IDEDefinition>();
+
+export function registerIDEDefinition(def: IDEDefinition): void {
+    registeredIDEs.set(def.id, def);
+}
+
+function getMergedDefinitions(): IDEDefinition[] {
+    const merged = new Map<string, IDEDefinition>();
+    for (const def of BUILTIN_IDE_DEFINITIONS) {
+        merged.set(def.id, def);
+    }
+    for (const [id, def] of registeredIDEs) {
+        merged.set(id, def);
+    }
+    return [...merged.values()];
+}
+
+function findCliCommand(command: string): string | null {
+    try {
+        const result = execSync(
+            platform() === 'win32' ? `where ${command}` : `which ${command}`,
+            { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
+        ).trim();
+        return result.split('\n')[0] || null;
+    } catch {
+        return null;
+    }
+}
+
+function getIdeVersion(cliCommand: string): string | null {
+    try {
+        const result = execSync(`"${cliCommand}" --version`, {
+            encoding: 'utf-8',
+            timeout: 10000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return result.split('\n')[0] || null;
+    } catch {
+        return null;
+    }
+}
+
+function checkPathExists(paths: string[]): string | null {
+    for (const p of paths) {
+        if (p.includes('*')) {
+            const home = homedir();
+            const starIdx = p.indexOf('*');
+            const suffix = p.substring(starIdx + 1);
+            const homeNormalized = home.replace(/\//g, '\\\\');
+            const resolved = homeNormalized + suffix;
+            if (existsSync(resolved)) return resolved;
+        } else {
+            if (existsSync(p)) return p;
+        }
+    }
+    return null;
+}
+
+export async function detectIDEs(): Promise<IDEInfo[]> {
+    const os = platform() as 'darwin' | 'win32' | 'linux';
+    const results: IDEInfo[] = [];
+
+    for (const def of getMergedDefinitions()) {
+        const cliPath = findCliCommand(def.cli);
+        const appPath = checkPathExists(def.paths[os] || []);
+        const installed = !!(cliPath || appPath);
+
+        let resolvedCli = cliPath;
+
+        if (!resolvedCli && appPath && os === 'darwin') {
+            const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
+            if (existsSync(bundledCli)) resolvedCli = bundledCli;
+        }
+
+        if (!resolvedCli && appPath && os === 'win32') {
+            const { dirname } = await import('path');
+            const appDir = dirname(appPath);
+            const candidates = [
+                `${appDir}\\\\bin\\\\${def.cli}.cmd`,
+                `${appDir}\\\\bin\\\\${def.cli}`,
+                `${appDir}\\\\${def.cli}.cmd`,
+                `${appDir}\\\\${def.cli}.exe`,
+                `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`,
+            ];
+            for (const c of candidates) {
+                if (existsSync(c)) {
+                    resolvedCli = c;
+                    break;
+                }
+            }
+        }
+
+        const version = resolvedCli ? getIdeVersion(resolvedCli) : null;
+
+        results.push({
+            id: def.id,
+            name: def.name,
+            displayName: def.displayName,
+            installed,
+            path: appPath || cliPath,
+            cliCommand: resolvedCli || null,
+            version,
+            icon: def.icon,
+            extensionSupport: def.extensionSupport,
+        });
+    }
+
+    return results;
+}