@adhdev/daemon-core 0.7.38 → 0.7.39

package/dist/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/dist/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/dist/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/dist/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;

package/dist/logging/logger.d.ts

@@ -0,0 +1,87 @@
+/**
+ * ADHDev Daemon — unified logger (v2)
+ *
+ * log level: DEBUG < INFO < WARN < ERROR
+ *
+ * Features:
+ * 1. daemonLog(category, msg, level) — explicit per-category logging
+ * 2. installGlobalInterceptor() — Auto-intercept console.log (once on daemon start)
+ * 3. Recent log ring buffer — for remote transmission via P2P/WS
+ * 4. File logging — ~/Library/Logs/adhdev/daemon.log (10MB rolling)
+ *
+ * use:
+ * import { daemonLog, LOG } from './daemon-logger';
+ * LOG.info('CDP', 'Connected to cursor on port 9333');
+ * LOG.debug('StatusReport', 'P2P heartbeat sent');
+ * LOG.warn('IdeInstance', 'onTick error: ...');
+ * LOG.error('Server', 'WebSocket disconnected');
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export declare function setLogLevel(level: LogLevel): void;
+export declare function getLogLevel(): LogLevel;
+export interface LogEntry {
+    ts: number;
+    level: LogLevel;
+    category: string;
+    message: string;
+}
+/** Get recent N logs (for remote transmission) */
+export declare function getRecentLogs(count?: number, minLevel?: LogLevel): LogEntry[];
+/** Ring buffer current size */
+export declare function getLogBufferSize(): number;
+/**
+ * Explicit per-category logging
+ * level filter apply, File logging, Ring buffer save
+ */
+export declare function daemonLog(category: string, msg: string, level?: LogLevel): void;
+/**
+ * Scoped logger instance for a specific component.
+ * Created via LOG.forComponent('CDP:cursor').
+ */
+export interface ScopedLogger {
+    debug: (msg: string) => void;
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    /** Returns a plain (msg: string) => void function at the given level.
+     *  Useful as logFn callback for ProviderLoader, DaemonStatusReporter, etc. */
+    asLogFn: (level?: LogLevel) => (msg: string) => void;
+}
+/**
+ * LOG — unified logging API
+ *
+ * Usage:
+ *   LOG.info('CDP', 'Connected to cursor on port 9333');
+ *   LOG.debug('StatusReport', 'P2P heartbeat sent');
+ *
+ * Component-scoped logger:
+ *   const log = LOG.forComponent('ACP:cursor');
+ *   log.info('Session created');
+ *   log.debug('Heartbeat');
+ *
+ * As callback for external components:
+ *   new ProviderLoader({ logFn: LOG.forComponent('Provider').asLogFn() });
+ *   new DaemonStatusReporter({ logFn: LOG.forComponent('Status').asLogFn() });
+ */
+export declare const LOG: {
+    debug: (category: string, msg: string) => void;
+    info: (category: string, msg: string) => void;
+    warn: (category: string, msg: string) => void;
+    error: (category: string, msg: string) => void;
+    /**
+     * Create a scoped logger for a specific component.
+     * Category is baked in so callers only pass the message.
+     */
+    forComponent(category: string): ScopedLogger;
+};
+/**
+ * console.log/warn/error global interceptor install
+ * Prevent recording in places not using daemonLog.
+ * daemon start when 1time call.
+ */
+export declare function installGlobalInterceptor(): void;
+/** current log file path (dateper) */
+export declare function getLogPath(): string;
+/** LOG_PATH — backward compat (current date file) */
+export declare const LOG_PATH: string;
+export declare const LOG_DIR_PATH: string;

package/dist/providers/acp-provider-instance.d.ts

@@ -0,0 +1,101 @@
+/**
+ * AcpProviderInstance — ACP (Agent Client Protocol) Provider runtime instance
+ *
+ * Spawns ACP agent process and communicates via the official ACP SDK.
+ * Uses ClientSideConnection + ndJsonStream for structured protocol communication.
+ *
+ * ACP spec: https://agentclientprotocol.com
+ * ACP SDK: @agentclientprotocol/sdk@0.16.1
+ *
+ * lifecycle:
+ * 1. init() → Spawn agent process + ACP initialize handshake
+ * 2. onTick() → no-op (ACP event based)
+ * 3. getState() → ProviderState return (dashboard for display)
+ * 4. onEvent('send_message') → session/prompt transmit
+ * 5. dispose() → kill process
+ */
+import type { ProviderModule, ContentBlock } from './contracts.js';
+import type { ProviderInstance, AcpProviderState, InstanceContext } from './provider-instance.js';
+export declare class AcpProviderInstance implements ProviderInstance {
+    private cliArgs;
+    readonly type: string;
+    readonly category: "acp";
+    private readonly log;
+    private provider;
+    private context;
+    private settings;
+    private events;
+    private monitor;
+    private process;
+    private connection;
+    private sessionId;
+    private messages;
+    private currentStatus;
+    private lastStatus;
+    private generatingStartedAt;
+    private agentCapabilities;
+    private currentModel;
+    private currentMode;
+    private activeToolCalls;
+    private stopReason;
+    private partialContent;
+    /** Rich content blocks accumulated during streaming */
+    private partialBlocks;
+    /** Tool calls collected during current turn */
+    private turnToolCalls;
+    private errorMessage;
+    private errorReason;
+    private stderrBuffer;
+    private spawnedAt;
+    private configOptions;
+    private availableModes;
+    /** Static config mode — agent doesn't support config/* methods */
+    private useStaticConfig;
+    /** Current config selections (for spawnArgBuilder) */
+    private selectedConfig;
+    private workingDir;
+    private instanceId;
+    constructor(provider: ProviderModule, workingDir: string, cliArgs?: string[]);
+    init(context: InstanceContext): Promise<void>;
+    onTick(): Promise<void>;
+    getState(): AcpProviderState;
+    onEvent(event: string, data?: any): void;
+    getInstanceId(): string;
+    private parseConfigOptions;
+    private parseModes;
+    setConfigOption(category: string, value: string): Promise<void>;
+    setMode(modeId: string): Promise<void>;
+    /** Static config: kill process and restart with new args */
+    private restartWithNewConfig;
+    /** Update settings at runtime (called when user changes settings from dashboard) */
+    updateSettings(newSettings: Record<string, any>): void;
+    dispose(): void;
+    private spawnAgent;
+    private createClient;
+    private initialize;
+    private createSession;
+    sendPrompt(text: string, contentBlocks?: ContentBlock[]): Promise<void>;
+    private cancelSession;
+    private permissionResolvers;
+    private resolvePermission;
+    private handleSessionUpdate;
+    /** Handle legacy session/update formats (pre-standardization compat) */
+    private handleLegacyUpdate;
+    /** Map SDK ToolCallStatus to internal status */
+    private mapToolCallStatus;
+    /** Truncate content for transport (text: 2000 chars, images preserved) */
+    private truncateContent;
+    /** Build ContentBlock[] from current partial state */
+    private buildPartialBlocks;
+    /** Finalize streaming content into an assistant message */
+    private finalizeAssistantMessage;
+    /** Convert ACP ToolCallContent[] to our ToolCallContent[] */
+    private convertToolCallContent;
+    private detectStatusTransition;
+    private pushEvent;
+    private flushEvents;
+    get cliType(): string;
+    get cliName(): string;
+    /** ACP Agent capabilities (available after initialize) */
+    getCapabilities(): Record<string, any>;
+}

package/dist/providers/cli-provider-instance.d.ts

@@ -0,0 +1,43 @@
+/**
+ * CliProviderInstance — Runtime instance for CLI Provider
+ *
+ * Lifecycle layer on top of ProviderCliAdapter.
+ * collectCliData() + status transition logic from daemon-status.ts moved here.
+ */
+import type { ProviderModule } from './contracts.js';
+import type { ProviderInstance, ProviderState, InstanceContext } from './provider-instance.js';
+import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
+import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
+export declare class CliProviderInstance implements ProviderInstance {
+    private provider;
+    private workingDir;
+    private cliArgs;
+    readonly type: string;
+    readonly category: "cli";
+    private adapter;
+    private context;
+    private events;
+    private lastStatus;
+    private generatingStartedAt;
+    private settings;
+    private monitor;
+    private generatingDebounceTimer;
+    private generatingDebouncePending;
+    private lastApprovalEventAt;
+    private historyWriter;
+    readonly instanceId: string;
+    constructor(provider: ProviderModule, workingDir: string, cliArgs?: string[], instanceId?: string, transportFactory?: PtyTransportFactory);
+    init(context: InstanceContext): Promise<void>;
+    onTick(): Promise<void>;
+    getState(): ProviderState;
+    onEvent(event: string, data?: any): void;
+    dispose(): void;
+    private completedDebounceTimer;
+    private completedDebouncePending;
+    private detectStatusTransition;
+    private pushEvent;
+    private flushEvents;
+    getAdapter(): ProviderCliAdapter;
+    get cliType(): string;
+    get cliName(): string;
+}