@adhdev/daemon-core 0.7.38 → 0.7.40

package/dist/commands/stream-commands.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Stream Commands — Agent Stream, PTY I/O, Provider Settings,
+ *                   IDE Extension Settings, Extension Script Execution
+ */
+import type { CommandResult, CommandHelpers } from './handler.js';
+export declare function handleFocusSession(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handlePtyInput(h: CommandHelpers, args: any): CommandResult;
+export declare function handlePtyResize(h: CommandHelpers, args: any): CommandResult;
+export declare function handleGetProviderSettings(h: CommandHelpers, args: any): CommandResult;
+export declare function handleSetProviderSetting(h: CommandHelpers, args: any): CommandResult;
+export declare function handleExtensionScript(h: CommandHelpers, args: any, scriptName: string): Promise<CommandResult>;
+export declare function handleGetIdeExtensions(h: CommandHelpers, args: any): CommandResult;
+export declare function handleSetIdeExtension(h: CommandHelpers, args: any): CommandResult;

package/dist/commands/workspace-commands.d.ts

@@ -0,0 +1,11 @@
+/**
+ * workspace_* commands — list/add/remove/default (config.json)
+ */
+export type WorkspaceCommandResult = {
+    success: boolean;
+    [key: string]: unknown;
+};
+export declare function handleWorkspaceList(): WorkspaceCommandResult;
+export declare function handleWorkspaceAdd(args: any): WorkspaceCommandResult;
+export declare function handleWorkspaceRemove(args: any): WorkspaceCommandResult;
+export declare function handleWorkspaceSetDefault(args: any): WorkspaceCommandResult;

package/dist/config/chat-history.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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;
+}
+export declare class ChatHistoryWriter {
+    /** Last seen message count per agent (deduplication) */
+    private lastSeenCounts;
+    /** Last seen message hash per agent (deduplication) */
+    private lastSeenHashes;
+    /** Last seen append-only terminal transcript per agent */
+    private lastSeenTerminal;
+    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;
+    appendTerminalHistory(agentType: string, terminalHistory: string, 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.
+ */
+export declare function readChatHistory(agentType: string, offset?: number, limit?: number, instanceId?: string): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+};
+export {};

package/dist/config/config.d.ts

@@ -0,0 +1,103 @@
+/**
+ * ADHDev Launcher — Configuration
+ *
+ * Manages launcher config, server connection tokens, and user preferences.
+ */
+import type { WorkspaceEntry } from './workspaces.js';
+import type { RecentActivityEntry } from './recent-activity.js';
+export type { WorkspaceEntry } from './workspaces.js';
+export type { RecentActivityEntry } from './recent-activity.js';
+export interface ADHDevConfig {
+    serverUrl: string;
+    apiToken: string | null;
+    connectionToken: string | null;
+    selectedIde: string | null;
+    configuredIdes: string[];
+    installedExtensions: string[];
+    autoConnect: boolean;
+    /**
+     * @deprecated Not read at runtime. Notification preferences are now managed by:
+     * - Web UI layer: useNotificationPrefs (localStorage)
+     * - Daemon layer: per-provider settings (approvalAlert, longGeneratingAlert)
+     * Kept for backward config compat — will be removed in v0.7+.
+     */
+    notifications: boolean;
+    userEmail: string | null;
+    userName: string | null;
+    setupCompleted: boolean;
+    setupDate: string | null;
+    configuredCLIs: string[];
+    enabledIdes: string[];
+    /** Saved workspaces for IDE/CLI/ACP launch (daemon-local) */
+    workspaces?: WorkspaceEntry[];
+    /** Default workspace id (from workspaces[]) — never used implicitly for launch */
+    defaultWorkspaceId?: string | null;
+    /** Unified recent activity across IDE / CLI / ACP launch flows */
+    recentActivity?: RecentActivityEntry[];
+    /** Last seen timestamps for live sessions, keyed by sessionId */
+    sessionReads?: Record<string, number>;
+    /** Last seen completion marker for live sessions, keyed by sessionId */
+    sessionReadMarkers?: Record<string, string>;
+    machineNickname: string | null;
+    /**
+     * Stable local machine ID (prefix: `mach_`) — generated locally on first run.
+     * Used as daemon instance key (`daemon_<machineId>`) and in status reports.
+     * NOT the same as the server-side D1 `machines.id` — see `registeredMachineId`.
+     */
+    machineId?: string;
+    machineSecret?: string | null;
+    /**
+     * Server-side D1 `machines.id` — the row ID assigned when daemon registers via
+     * `POST /cli/complete`. Corresponds to `machineId` in server DO context
+     * (`DaemonConnection.machineId`, `StatusContext.machineId`).
+     *
+     * Naming differs from server-side `machineId` to avoid confusion with the local
+     * `config.machineId` (mach_ prefix) which is a different value.
+     *
+     * @deprecated Legacy bridge field — will be removed after 2026-04-06.
+     * Modern auth flow uses `machineSecret` (adm_) to identify machines.
+     */
+    registeredMachineId?: string;
+    providerSettings: Record<string, Record<string, any>>;
+    ideSettings: Record<string, {
+        extensions?: Record<string, {
+            enabled: boolean;
+        }>;
+    }>;
+    disableUpstream?: boolean;
+    providerDir?: string;
+}
+export declare function generateMachineId(): string;
+export declare function isStableMachineId(machineId?: string | null): boolean;
+/**
+ * Get the config directory path
+ */
+export declare function getConfigDir(): string;
+/**
+ * Load configuration from disk
+ */
+export declare function loadConfig(): ADHDevConfig;
+/**
+ * Save configuration to disk
+ */
+export declare function saveConfig(config: ADHDevConfig): void;
+/**
+ * Update specific config fields
+ */
+export declare function updateConfig(updates: Partial<ADHDevConfig>): ADHDevConfig;
+/**
+ * Mark setup as completed
+ */
+export declare function markSetupComplete(ideId: string | string[], extensions: string[]): ADHDevConfig;
+/**
+ * Check if setup has been completed before
+ */
+export declare function isSetupComplete(): boolean;
+/**
+ * Reset configuration
+ */
+export declare function resetConfig(): void;
+/**
+ * Generate a connection token for server authentication
+ */
+export declare function generateConnectionToken(): string;

package/dist/config/recent-activity.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Unified recent activity — launcher-facing "pick up where you launched".
+ *
+ * Unlike live session state, this is launch oriented:
+ * - one normalized row shape for IDE / CLI / ACP
+ * - deduped by kind + providerType + workspace
+ * - used only for quick-launch shortcuts
+ */
+import type { ADHDevConfig } from './config.js';
+export interface RecentActivityEntry {
+    id: string;
+    kind: 'ide' | 'cli' | 'acp';
+    providerType: string;
+    providerName: string;
+    workspace?: string | null;
+    currentModel?: string;
+    title?: string;
+    lastUsedAt: number;
+}
+export declare function buildRecentActivityKey(entry: Pick<RecentActivityEntry, 'kind' | 'providerType' | 'workspace'>): string;
+export declare function appendRecentActivity(config: ADHDevConfig, entry: Omit<RecentActivityEntry, 'id' | 'lastUsedAt'> & {
+    lastUsedAt?: number;
+}): ADHDevConfig;
+export declare function getRecentActivity(config: ADHDevConfig, limit?: number): RecentActivityEntry[];
+export declare function getSessionSeenAt(config: ADHDevConfig, sessionId: string): number;
+export declare function getSessionSeenMarker(config: ADHDevConfig, sessionId: string): string;
+export declare function markSessionSeen(config: ADHDevConfig, sessionId: string, seenAt?: number, completionMarker?: string | null): ADHDevConfig;

package/dist/config/workspaces.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Saved workspaces — shared by IDE launch, CLI, ACP (daemon-local).
+ */
+import type { ADHDevConfig } from './config.js';
+export interface WorkspaceEntry {
+    id: string;
+    path: string;
+    label?: string;
+    addedAt: number;
+}
+export declare function expandPath(p: string): string;
+export declare function validateWorkspacePath(absPath: string): {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/** Default workspace label from path */
+export declare function defaultWorkspaceLabel(absPath: string): string;
+export declare function getDefaultWorkspacePath(config: ADHDevConfig): string | null;
+export declare function getWorkspaceState(config: ADHDevConfig): {
+    workspaces: WorkspaceEntry[];
+    defaultWorkspaceId: string | null;
+    defaultWorkspacePath: string | null;
+};
+export type LaunchDirectorySource = 'dir' | 'workspaceId' | 'defaultWorkspace' | 'home';
+export type ResolveLaunchDirectoryResult = {
+    ok: true;
+    path: string;
+    source: LaunchDirectorySource;
+} | {
+    ok: false;
+    code: 'WORKSPACE_LAUNCH_CONTEXT_REQUIRED';
+    message: string;
+};
+/**
+ * Resolve cwd for CLI/ACP. No implicit default workspace or home — caller must pass
+ * useDefaultWorkspace or useHome (or an explicit dir / workspaceId).
+ */
+export declare function resolveLaunchDirectory(args: {
+    dir?: string;
+    workspaceId?: string;
+    useDefaultWorkspace?: boolean;
+    useHome?: boolean;
+} | undefined, config: ADHDevConfig): ResolveLaunchDirectoryResult;
+/**
+ * IDE folder from explicit args only (`workspace`, `workspaceId`, or `useDefaultWorkspace: true`).
+ */
+export declare function resolveIdeWorkspaceFromArgs(args: {
+    workspace?: string;
+    workspaceId?: string;
+    useDefaultWorkspace?: boolean;
+} | undefined, config: ADHDevConfig): string | undefined;
+/**
+ * IDE launch folder — same saved workspaces + default as CLI/ACP.
+ * After explicit `workspace` / `workspaceId` / `useDefaultWorkspace: true`, falls back to
+ * config default workspace when set. Pass `useDefaultWorkspace: false` to open IDE without that folder.
+ */
+export declare function resolveIdeLaunchWorkspace(args: {
+    workspace?: string;
+    workspaceId?: string;
+    useDefaultWorkspace?: boolean;
+} | undefined, config: ADHDevConfig): string | undefined;
+export declare function findWorkspaceByPath(config: ADHDevConfig, rawPath: string): WorkspaceEntry | undefined;
+export declare function addWorkspaceEntry(config: ADHDevConfig, rawPath: string, label?: string, options?: {
+    createIfMissing?: boolean;
+}): {
+    config: ADHDevConfig;
+    entry: WorkspaceEntry;
+} | {
+    error: string;
+};
+export declare function removeWorkspaceEntry(config: ADHDevConfig, id: string): {
+    config: ADHDevConfig;
+} | {
+    error: string;
+};
+export declare function setDefaultWorkspaceId(config: ADHDevConfig, id: string | null): {
+    config: ADHDevConfig;
+} | {
+    error: string;
+};

package/dist/daemon/dev-auto-implement.d.ts

@@ -0,0 +1,26 @@
+/**
+ * DevServer — Auto-Implement Handlers
+ *
+ * Extracted from dev-server.ts for maintainability.
+ * Contains prompt builders (IDE + CLI), agent spawn logic,
+ * SSE streaming, and provider directory resolution for auto-implement.
+ */
+import type * as http from 'http';
+import type { DevServerContext, ProviderCategory } from './dev-server-types.js';
+export declare function getDefaultAutoImplReference(ctx: DevServerContext, category: string, type: string): string;
+export declare function resolveAutoImplReference(ctx: DevServerContext, category: string, requestedReference: string | undefined, targetType: string): string | null;
+export declare function getLatestScriptVersionDir(scriptsDir: string): string | null;
+export declare function resolveAutoImplWritableProviderDir(ctx: DevServerContext, category: ProviderCategory, type: string, requestedDir?: string): {
+    dir: string | null;
+    reason?: string;
+};
+export declare function loadAutoImplReferenceScripts(ctx: DevServerContext, referenceType: string | null): Record<string, string>;
+export declare function handleAutoImplement(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function buildAutoImplPrompt(ctx: DevServerContext, type: string, provider: any, providerDir: string, functions: string[], domContext: any, referenceScripts: Record<string, string>, userComment?: string, referenceType?: string | null): string;
+export declare function buildCliAutoImplPrompt(ctx: DevServerContext, type: string, provider: any, providerDir: string, functions: string[], referenceScripts: Record<string, string>, userComment?: string, referenceType?: string | null): string;
+export declare function handleAutoImplSSE(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): void;
+export declare function handleAutoImplCancel(ctx: DevServerContext, _type: string, _req: http.IncomingMessage, res: http.ServerResponse): void;
+export declare function sendAutoImplSSE(ctx: DevServerContext, msg: {
+    event: string;
+    data: any;
+}): void;

package/dist/daemon/dev-cdp-handlers.d.ts

@@ -0,0 +1,22 @@
+/**
+ * DevServer — CDP & DOM Handlers
+ *
+ * Extracted from dev-server.ts for maintainability.
+ */
+import type * as http from 'http';
+import type { DevServerContext } from './dev-server-types.js';
+export declare function handleCdpEvaluate(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleCdpClick(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleCdpDomQuery(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleScreenshot(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleScriptsRun(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleTypeAndSend(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleTypeAndSendAt(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleScriptHints(ctx: DevServerContext, type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleCdpTargets(ctx: DevServerContext, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleDomInspect(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleDomChildren(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleDomAnalyze(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleFindCommon(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleFindByText(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleDomContext(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;

package/dist/daemon/dev-cli-debug.d.ts

@@ -0,0 +1,24 @@
+/**
+ * DevServer — CLI Debug Handlers
+ *
+ * Extracted from dev-server.ts for maintainability.
+ * All functions take a DevServerContext as their first argument.
+ */
+import type * as http from 'http';
+import type { DevServerContext } from './dev-server-types.js';
+/** GET /api/cli/status — list all running CLI/ACP instances with state */
+export declare function handleCliStatus(ctx: DevServerContext, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/launch — launch a CLI agent { type, workingDir?, args? } */
+export declare function handleCliLaunch(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/send — send message to a running CLI { type, text } */
+export declare function handleCliSend(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/stop — stop a running CLI { type } */
+export declare function handleCliStop(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** GET /api/cli/events — SSE stream of CLI status events */
+export declare function handleCliSSE(ctx: DevServerContext, cliSSEClients: http.ServerResponse[], _req: http.IncomingMessage, res: http.ServerResponse): void;
+/** GET /api/cli/debug/:type — full internal debug state of a CLI adapter */
+export declare function handleCliDebug(ctx: DevServerContext, type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/resolve — resolve an approval modal { type, buttonIndex } */
+export declare function handleCliResolve(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/raw — send raw keystrokes to PTY { type, keys } */
+export declare function handleCliRaw(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;

package/dist/daemon/dev-server-types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared types & context interface for DevServer handler modules.
+ *
+ * Each handler module (cdp, cli-debug, auto-implement) imports DevServerContext
+ * to access shared state and utilities without circular references.
+ */
+import type * as http from 'http';
+import type { ProviderLoader } from '../providers/provider-loader.js';
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import type { DaemonCliManager } from '../commands/cli-manager.js';
+import type { ProviderCategory } from '../providers/contracts.js';
+/**
+ * Context passed from the main DevServer to handler modules.
+ * Provides access to shared dependencies and utility methods.
+ */
+export interface DevServerContext {
+    readonly providerLoader: ProviderLoader;
+    readonly cdpManagers: Map<string, DaemonCdpManager>;
+    readonly instanceManager: ProviderInstanceManager | null;
+    readonly cliManager: DaemonCliManager | null;
+    getCdp(ideType?: string): DaemonCdpManager | null;
+    json(res: http.ServerResponse, status: number, data: any): void;
+    readBody(req: http.IncomingMessage): Promise<any>;
+    log(msg: string): void;
+    autoImplSSEClients: http.ServerResponse[];
+    sendAutoImplSSE(msg: {
+        event: string;
+        data: any;
+    }): void;
+    autoImplStatus: {
+        running: boolean;
+        type: string | null;
+        progress: any[];
+    };
+    autoImplProcess: import('child_process').ChildProcess | null;
+    sendCliSSE(data: any): void;
+    handleRunScript(type: string, req: http.IncomingMessage, res: http.ServerResponse, parsedBody?: any): Promise<void>;
+    findProviderDir(type: string): string | null;
+    getLatestScriptVersionDir(scriptsDir: string): string | null;
+}
+/** Re-export for convenience */
+export type { ProviderCategory };

package/dist/daemon/dev-server.d.ts

@@ -0,0 +1,133 @@
+import type { DevServerContext } from './dev-server-types.js';
+/**
+ * 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)
+ */
+import * as http from 'http';
+import type { ProviderLoader } from '../providers/provider-loader.js';
+import type { ChildProcess } from 'child_process';
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import type { DaemonCliManager } from '../commands/cli-manager.js';
+export declare const DEV_SERVER_PORT = 19280;
+export declare class DevServer implements DevServerContext {
+    private server;
+    providerLoader: ProviderLoader;
+    cdpManagers: Map<string, DaemonCdpManager>;
+    instanceManager: ProviderInstanceManager | null;
+    cliManager: DaemonCliManager | null;
+    private logFn;
+    private sseClients;
+    private watchScriptPath;
+    private watchScriptName;
+    private watchTimer;
+    autoImplProcess: ChildProcess | null;
+    autoImplSSEClients: http.ServerResponse[];
+    autoImplStatus: {
+        running: boolean;
+        type: string | null;
+        progress: any[];
+    };
+    private cliSSEClients;
+    constructor(options: {
+        providerLoader: ProviderLoader;
+        cdpManagers: Map<string, DaemonCdpManager>;
+        instanceManager?: ProviderInstanceManager;
+        cliManager?: DaemonCliManager;
+        logFn?: (msg: string) => void;
+    });
+    log(msg: string): void;
+    private readonly routes;
+    private matchRoute;
+    private getEndpointList;
+    start(port?: number): Promise<void>;
+    stop(): void;
+    private handleListProviders;
+    private handleProviderConfig;
+    private handleSpawnTest;
+    handleRunScript(type: string, req: http.IncomingMessage, res: http.ServerResponse, parsedBody?: any): Promise<void>;
+    private handleCdpEvaluate;
+    private handleCdpClick;
+    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 */
+    findProviderDir(type: string): string | null;
+    /** 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 handleTypeAndSend;
+    private handleTypeAndSendAt;
+    private handleScriptHints;
+    private handleValidate;
+    private handleAcpChat;
+    private handleCdpTargets;
+    private handleScaffold;
+    private handleDetectVersions;
+    private handleDomInspect;
+    private handleDomChildren;
+    private handleDomAnalyze;
+    private handleFindCommon;
+    private handleFindByText;
+    private handleDomContext;
+    getLatestScriptVersionDir(scriptsDir: string): string | null;
+    private resolveAutoImplWritableProviderDir;
+    private handleAutoImplement;
+    private buildAutoImplPrompt;
+    private buildCliAutoImplPrompt;
+    private handleAutoImplSSE;
+    private handleAutoImplCancel;
+    sendAutoImplSSE(msg: {
+        event: string;
+        data: any;
+    }): void;
+    /** Get CDP manager — matching IDE when ideType specified, first connected one otherwise.
+     *  DevServer is a debugging tool so first-connected fallback is acceptable,
+     *  but callers should pass ideType when possible. */
+    getCdp(ideType?: string): DaemonCdpManager | null;
+    json(res: http.ServerResponse, status: number, data: any): void;
+    readBody(req: http.IncomingMessage): Promise<any>;
+    /** GET /api/cli/status — list all running CLI/ACP instances with state */
+    private handleCliStatus;
+    /** POST /api/cli/launch — launch a CLI agent { type, workingDir?, args? } */
+    private handleCliLaunch;
+    /** POST /api/cli/send — send message to a running CLI { type, text } */
+    private handleCliSend;
+    /** POST /api/cli/stop — stop a running CLI { type } */
+    private handleCliStop;
+    /** GET /api/cli/events — SSE stream of CLI status events */
+    private handleCliSSE;
+    sendCliSSE(data: any): void;
+    /** GET /api/cli/debug/:type — full internal debug state of a CLI adapter */
+    private handleCliDebug;
+    /** POST /api/cli/resolve — resolve an approval modal { type, buttonIndex } */
+    private handleCliResolve;
+    /** POST /api/cli/raw — send raw keystrokes to PTY { type, keys } */
+    private handleCliRaw;
+}

package/dist/daemon/scaffold-template.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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;
+    osPaths?: Record<string, string[]>;
+    processNames?: Record<string, string>;
+}
+export interface ScaffoldResult {
+    'provider.json': string;
+    files?: Record<string, string>;
+}
+export declare function generateTemplate(type: string, name: string, category: string, opts?: ScaffoldOptions): string;
+/**
+ * Generate provider.json + per-function script files.
+ * Returns a map of relative paths -> file contents.
+ */
+export declare function generateFiles(type: string, name: string, category: string, opts?: ScaffoldOptions): ScaffoldResult;

package/dist/daemon-core.d.ts

@@ -0,0 +1,36 @@
+/**
+ * DaemonCore — Core daemon orchestrator interface
+ *
+ * Provides the core daemon orchestrator interface consumed by daemon-standalone.
+ * Actual implementation extracted from launcher and placed in this package.
+ */
+import type { StatusResponse, CommandResult, DaemonEvent } from './types.js';
+import type { SessionEntry } from './shared-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(): StatusResponse;
+    /** Subscribe to status changes. Returns unsubscribe function. */
+    onStatusChange(callback: (status: StatusResponse) => 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 current canonical runtime sessions */
+    getSessions(): SessionEntry[];
+}

package/dist/detection/cli-detector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 type { ProviderLoader } from '../providers/provider-loader.js';
+export interface CLIInfo {
+    id: string;
+    displayName: string;
+    icon: string;
+    command: string;
+    versionCommand?: string;
+    installed: boolean;
+    version?: string;
+    path?: string;
+    category?: string;
+}
+/**
+ * Detect all CLI/ACP agents (parallel)
+ * @param providerLoader ProviderLoader instance (dynamic list creation)
+ */
+export declare function detectCLIs(providerLoader?: ProviderLoader): Promise<CLIInfo[]>;
+/** Detect specific CLI */
+export declare function detectCLI(cliId: string, providerLoader?: ProviderLoader): Promise<CLIInfo | null>;