@adhdev/daemon-core 0.8.34 → 0.8.35

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

@@ -0,0 +1,140 @@
+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/exercise — launch/send/approve/wait helper for provider-fix loops */
+    private handleCliExercise;
+    private handleCliFixtureCapture;
+    private handleCliFixtureReplay;
+    /** 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;
+    /** GET /api/cli/trace/:type — recent CLI trace timeline plus current debug snapshot */
+    private handleCliTrace;
+    private handleCliFixtureList;
+    /** 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/src/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/src/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/src/detection/cli-detector.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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, options?: {
+    includeVersion?: boolean;
+}): Promise<CLIInfo[]>;
+/** Detect specific CLI — only probes the one requested provider */
+export declare function detectCLI(cliId: string, providerLoader?: ProviderLoader, options?: {
+    includeVersion?: boolean;
+}): Promise<CLIInfo | null>;

package/src/detection/ide-detector.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 type { ProviderLoader } from '../providers/provider-loader.js';
+export interface IDEInfo {
+    id: string;
+    name: string;
+    displayName: string;
+    installed: boolean;
+    path: string | null;
+    cliCommand: string | null;
+    version: string | null;
+    icon: string;
+    notes?: string;
+}
+export interface IDEDefinition {
+    id: string;
+    name: string;
+    displayName: string;
+    icon: string;
+    cli: string;
+    paths: {
+        darwin?: string[];
+        win32?: string[];
+        linux?: string[];
+        [key: string]: string[] | undefined;
+    };
+}
+export declare function registerIDEDefinition(def: IDEDefinition): void;
+export declare function detectIDEs(providerLoader?: ProviderLoader): Promise<IDEInfo[]>;

package/src/index.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @adhdev/daemon-core — Public API
+ *
+ * Core logic for daemon: CDP, Provider, IDE detection, CLI/ACP adapters and more.
+ */
+export type { ChatMessage, ExtensionInfo, CommandResult as CoreCommandResult, ProviderConfig, DaemonEvent, StatusResponse, SystemInfo, DetectedIde, ProviderInfo, AgentEntry, } from './types.js';
+export type { SessionEntry, CompactSessionEntry, CompactDaemonEntry, SessionTransport, SessionKind, SessionCapability, AgentSessionStream, AvailableProviderInfo, AcpConfigOption, AcpMode, ProviderControlSchema, StatusReportPayload, MachineInfo, DetectedIdeInfo, WorkspaceEntry, ProviderStatus, ProviderErrorReason, ActiveChatData, IdeProviderState, CliProviderState, AcpProviderState, ExtensionProviderState, } from './shared-types.js';
+import type { RuntimeWriteOwner as _RuntimeWriteOwner } from './shared-types-extra.js';
+import type { RuntimeAttachedClient as _RuntimeAttachedClient } from './shared-types-extra.js';
+import type { RecentLaunchEntry as _RecentLaunchEntry } from './shared-types.js';
+import type { TerminalBackendStatus as _TerminalBackendStatus } from './shared-types-extra.js';
+export type RuntimeWriteOwner = _RuntimeWriteOwner;
+export type RuntimeAttachedClient = _RuntimeAttachedClient;
+export type RecentLaunchEntry = _RecentLaunchEntry;
+export type TerminalBackendStatus = _TerminalBackendStatus;
+export type SessionStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
+export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete' | 'idle';
+export type { IDaemonCore, DaemonCoreOptions } from './daemon-core.js';
+export { loadConfig, saveConfig, resetConfig, isSetupComplete, markSetupComplete, updateConfig } from './config/config.js';
+export { getWorkspaceState } from './config/workspaces.js';
+export { appendRecentActivity, getRecentActivity } from './config/recent-activity.js';
+export type { RecentActivityEntry } from './config/recent-activity.js';
+export { getSavedProviderSessions, upsertSavedProviderSession } from './config/saved-sessions.js';
+export type { SavedProviderSessionEntry } from './config/saved-sessions.js';
+export { loadState, saveState, resetState } from './config/state-store.js';
+export type { DaemonState } from './config/state-store.js';
+export { detectIDEs } from './detection/ide-detector.js';
+export type { IDEInfo } from './detection/ide-detector.js';
+export { detectCLIs } from './detection/cli-detector.js';
+export { getHostMemorySnapshot } from './system/host-memory.js';
+export type { HostMemorySnapshot } from './system/host-memory.js';
+export { DaemonCdpManager } from './cdp/manager.js';
+export { CdpDomHandlers } from './cdp/devtools.js';
+export { setupIdeInstance, registerExtensionProviders, connectCdpManager, probeCdpPort } from './cdp/setup.js';
+export type { CdpSetupContext, SetupIdeInstanceOptions } from './cdp/setup.js';
+export { DaemonCdpScanner } from './cdp/scanner.js';
+export type { CdpScannerOptions } from './cdp/scanner.js';
+export { DaemonCdpInitializer } from './cdp/initializer.js';
+export type { CdpInitializerConfig } from './cdp/initializer.js';
+export { DaemonCommandHandler } from './commands/handler.js';
+export type { CommandResult, CommandContext } from './commands/handler.js';
+export { DaemonCommandRouter } from './commands/router.js';
+export type { CommandRouterDeps, CommandRouterResult } from './commands/router.js';
+export { maybeRunDaemonUpgradeHelperFromEnv, spawnDetachedDaemonUpgradeHelper } from './commands/upgrade-helper.js';
+export type { DaemonUpgradeHelperPayload } from './commands/upgrade-helper.js';
+export { DaemonStatusReporter } from './status/reporter.js';
+export { buildSessionEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
+export { buildStatusSnapshot } from './status/snapshot.js';
+export { normalizeManagedStatus, isManagedStatusWorking, isManagedStatusWaiting, normalizeActiveChatData } from './status/normalize.js';
+export type { ManagedStatus } from './status/normalize.js';
+export type { StatusSnapshotOptions, StatusSnapshot } from './status/snapshot.js';
+export { LOG, installGlobalInterceptor, setLogLevel, getLogLevel, getRecentLogs, getDaemonLogDir, getCurrentDaemonLogPath, } from './logging/logger.js';
+export type { ScopedLogger, LogLevel, LogEntry } from './logging/logger.js';
+export { logCommand, getRecentCommands } from './logging/command-log.js';
+export { DaemonCliManager } from './commands/cli-manager.js';
+export { launchWithCdp, getAvailableIdeIds, killIdeProcess, isIdeRunning } from './launch.js';
+export { DEFAULT_DAEMON_PORT, DAEMON_WS_PATH } from './ipc-protocol.js';
+export { readChatHistory } from './config/chat-history.js';
+export { DaemonAgentStreamManager } from './agent-stream/index.js';
+export { AgentStreamPoller } from './agent-stream/index.js';
+export type { AgentStreamPollerDeps } from './agent-stream/index.js';
+export { forwardAgentStreamsToIdeInstance } from './agent-stream/forward.js';
+export { ProviderLoader } from './providers/provider-loader.js';
+export { ProviderInstanceManager } from './providers/provider-instance-manager.js';
+export { IdeProviderInstance } from './providers/ide-provider-instance.js';
+export { CliProviderInstance } from './providers/cli-provider-instance.js';
+export { AcpProviderInstance } from './providers/acp-provider-instance.js';
+export type { ProviderModule, CdpTargetFilter, ProviderResumeCapability } from './providers/contracts.js';
+export { VersionArchive, detectAllVersions } from './providers/version-archive.js';
+export type { ProviderVersionInfo, VersionHistory } from './providers/version-archive.js';
+export { DevServer } from './daemon/dev-server.js';
+export { ProviderCliAdapter } from './cli-adapters/provider-cli-adapter.js';
+export type { CliAdapter } from './cli-adapter-types.js';
+export { NodePtyTransportFactory } from './cli-adapters/pty-transport.js';
+export type { PtyRuntimeTransport, PtyTransportFactory, PtySpawnOptions } from './cli-adapters/pty-transport.js';
+export { SessionHostPtyTransportFactory } from './cli-adapters/session-host-transport.js';
+export type { HostedCliRuntimeDescriptor, CliTransportFactoryParams } from './commands/cli-manager.js';
+export { ensureSessionHostReady, listHostedCliRuntimes } from './session-host/runtime-support.js';
+export type { SessionHostEndpoint } from '@adhdev/session-host-core';
+export { getAIExtensions, installExtensions, launchIDE, isExtensionInstalled } from './installer.js';
+export type { ExtensionInfo as InstallerExtensionInfo } from './installer.js';
+export { initDaemonComponents, startDaemonDevSupport, shutdownDaemonComponents } from './boot/daemon-lifecycle.js';
+export type { DaemonInitConfig, DaemonComponents, DaemonDevSupportOptions } from './boot/daemon-lifecycle.js';

package/src/index.ts

@@ -21,6 +21,8 @@ export type {
 // ── Shared Types (cross-package) ──
 export type {
   SessionEntry,
+  CompactSessionEntry,
+  CompactDaemonEntry,
   SessionTransport,
   SessionKind,
   SessionCapability,

package/src/installer.d.ts

@@ -0,0 +1,50 @@
+/**
+ * ADHDev Launcher — Extension Installer
+ *
+ * Installs VS Code extensions via CLI commands.
+ * Supports installing user-selected AI extensions.
+ */
+import { IDEInfo } from './detection/ide-detector.js';
+export interface ExtensionInfo {
+    id: string;
+    name: string;
+    displayName: string;
+    marketplaceId: string;
+    description: string;
+    category: 'ai-agent' | 'utility';
+    icon: string;
+    recommended: boolean;
+    requiresApiKey?: boolean;
+    apiKeyName?: string;
+    website?: string;
+    vsixUrl?: string;
+}
+/** Available extensions catalog */
+export declare const EXTENSION_CATALOG: ExtensionInfo[];
+export interface InstallResult {
+    extensionId: string;
+    marketplaceId: string;
+    success: boolean;
+    alreadyInstalled: boolean;
+    error?: string;
+}
+/**
+ * Check if an extension is already installed
+ */
+export declare function isExtensionInstalled(ide: IDEInfo, marketplaceId: string): boolean;
+/**
+ * Install a single extension
+ */
+export declare function installExtension(ide: IDEInfo, extension: ExtensionInfo): Promise<InstallResult>;
+/**
+ * Install multiple extensions sequentially
+ */
+export declare function installExtensions(ide: IDEInfo, extensions: ExtensionInfo[], onProgress?: (current: number, total: number, ext: ExtensionInfo, result: InstallResult) => void): Promise<InstallResult[]>;
+/**
+ * Get AI agent extensions
+ */
+export declare function getAIExtensions(): ExtensionInfo[];
+/**
+ * Launch IDE after installation
+ */
+export declare function launchIDE(ide: IDEInfo, workspacePath?: string): boolean;

package/src/ipc-protocol.d.ts

@@ -0,0 +1,111 @@
+/**
+ * ADHDev IPC Protocol — Extension ↔ Daemon communication protocol
+ *
+ * Message types used when Extension and Daemon communicate via localhost WS.
+ * Defined in core package for import from both sides.
+ */
+/** Extension registers itself with Daemon on first connection */
+export interface IpcExtRegister {
+    type: 'ext:register';
+    payload: {
+        ideType: string;
+        ideVersion: string;
+        extensionVersion: string;
+        instanceId: string;
+        machineId: string;
+        workspaceFolders: {
+            name: string;
+            path: string;
+        }[];
+    };
+}
+/** Extension periodically send vscode status data */
+export interface IpcExtStatus {
+    type: 'ext:status';
+    payload: {
+        activeFile: string | null;
+        workspaceFolders: {
+            name: string;
+            path: string;
+        }[];
+        terminals: number;
+        aiAgents: {
+            id: string;
+            name: string;
+            status: string;
+            version?: string;
+        }[];
+    };
+}
+/** Return Extension vscode command execution result */
+export interface IpcExtCommandResult {
+    type: 'ext:command_result';
+    payload: {
+        requestId: string;
+        success: boolean;
+        result?: unknown;
+        error?: string;
+    };
+}
+/** VSCode event occurring from Extension */
+export interface IpcExtEvent {
+    type: 'ext:event';
+    payload: {
+        event: 'file_changed' | 'terminal_opened' | 'terminal_closed' | 'agent_status_changed';
+        data: Record<string, unknown>;
+    };
+}
+/** Welcome message on Daemon-Extension connection */
+export interface IpcDaemonWelcome {
+    type: 'daemon:welcome';
+    payload: {
+        daemonVersion: string;
+        serverConnected: boolean;
+        cdpConnected: boolean;
+        localPort: number;
+        cliAgents: string[];
+    };
+}
+/** Daemon to Extension vscode Request command execution */
+export interface IpcDaemonExecuteVscode {
+    type: 'daemon:execute_vscode';
+    payload: {
+        requestId: string;
+        command: string;
+        args?: unknown[];
+    };
+}
+/** Daemon to Extension status data request */
+export interface IpcDaemonRequestStatus {
+    type: 'daemon:request_status';
+    payload: {};
+}
+/** Daemon notifies Extension about server connection status */
+export interface IpcDaemonServerState {
+    type: 'daemon:server_state';
+    payload: {
+        connected: boolean;
+        serverUrl: string;
+    };
+}
+/** Daemon to Extension notification display request */
+export interface IpcDaemonNotify {
+    type: 'daemon:notify';
+    payload: {
+        level: 'info' | 'warning' | 'error';
+        message: string;
+    };
+}
+/** Extension requests Daemon to execute command (e.g. CLI launch) */
+export interface IpcExtCommand {
+    type: 'ext:command';
+    payload: {
+        command: string;
+        args?: any;
+    };
+}
+export type ExtToDaemonMessage = IpcExtRegister | IpcExtStatus | IpcExtCommandResult | IpcExtEvent | IpcExtCommand;
+export type DaemonToExtMessage = IpcDaemonWelcome | IpcDaemonExecuteVscode | IpcDaemonRequestStatus | IpcDaemonServerState | IpcDaemonNotify;
+export type IpcMessage = ExtToDaemonMessage | DaemonToExtMessage;
+export declare const DEFAULT_DAEMON_PORT = 19222;
+export declare const DAEMON_WS_PATH = "/ipc";

package/src/launch.d.ts

@@ -0,0 +1,46 @@
+/**
+ * ADHDev Launcher — IDE Launch/Relaunch with CDP
+ *
+ * Launches IDE with Chrome DevTools Protocol (remote-debugging-port).
+ * If IDE is already running, terminates it and restarts with CDP option.
+ *
+ * Pipeline:
+ * 1. IDE process detection (already running?)
+ * 2. If already running with CDP → reuse as-is
+ * 3. If running without CDP → kill process → wait → restart with CDP
+ * 4. Not running → start fresh with CDP
+ *
+ * Usage:
+ * adhdev launch — Launch configured IDE with CDP port
+ * adhdev launch cursor — Launch Cursor with CDP port
+ * adhdev launch --workspace /path — Open specific workspace
+ */
+/** Kill IDE process (graceful → force) */
+export declare function killIdeProcess(ideId: string): Promise<boolean>;
+/** Check if IDE process is running */
+export declare function isIdeRunning(ideId: string): boolean;
+export interface LaunchOptions {
+    ideId?: string;
+    workspace?: string;
+    newWindow?: boolean;
+}
+export interface LaunchResult {
+    success: boolean;
+    ideId: string;
+    ideName: string;
+    port: number;
+    action: 'started' | 'restarted' | 'reused' | 'failed';
+    message: string;
+    error?: string;
+}
+/**
+ * Execute IDE with CDP port (relaunch pipeline)
+ *
+ * 1. IDE detect
+ * 2. per-fixed IDE CDP port determine
+ * 3. CDP not active → reuse
+ * 4. IDE execute during but CDP none → terminate → restart with CDP
+ * 5. IDE not running → start fresh with CDP
+ */
+export declare function launchWithCdp(options?: LaunchOptions): Promise<LaunchResult>;
+export declare function getAvailableIdeIds(): string[];

package/src/logging/command-log.d.ts

@@ -0,0 +1,31 @@
+/**
+ * ADHDev Daemon — Command History Logger
+ *
+ * Record all commands from dashboard/WS/P2P/Extension/API to local file.
+ * Per-date JSONL file, 7-day retention, 5MB limit.
+ *
+ * Purpose:
+ * - Debugging: track what command came and when
+ * - Audit: record all commands executed from remote
+ * - Stats: identify frequently used features
+ */
+export interface CommandLogEntry {
+    ts: string;
+    cmd: string;
+    source: 'ws' | 'p2p' | 'ext' | 'api' | 'standalone' | 'unknown';
+    args?: Record<string, unknown>;
+    success?: boolean;
+    error?: string;
+    durationMs?: number;
+}
+/**
+ * Log a command received from the dashboard/WS/P2P/extension/API.
+ * Call this at the entry point of command handling.
+ */
+export declare function logCommand(entry: CommandLogEntry): void;
+/**
+ * Read recent command history (for dashboard display / debugging)
+ */
+export declare function getRecentCommands(count?: number): CommandLogEntry[];
+/** Current command log file path */
+export declare function getCommandLogPath(): string;