@adhdev/daemon-core 0.7.38 → 0.7.40

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

@@ -0,0 +1,148 @@
+/**
+ * ProviderInstance — Provider runtime lifecycle
+ *
+ * provider.js = static config/scripts
+ * ProviderInstance = runtime status management + lifecycle
+ *
+ * Daemon only collects via ProviderInstance.getState(),
+ * Each Instance manages its own status.
+ */
+import type { ProviderResumeCapability } from './contracts.js';
+import type { AcpConfigOption, AcpMode, ProviderControlSchema } from '../shared-types.js';
+import type { ChatMessage } from '../types.js';
+export type ProviderStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting';
+export interface ProviderRuntimeWriteOwner {
+    clientId: string;
+    ownerType: 'agent' | 'user';
+}
+export interface ProviderRuntimeClient {
+    clientId: string;
+    type: 'daemon' | 'web' | 'local-terminal';
+    readOnly: boolean;
+}
+export interface ProviderRuntimeInfo {
+    runtimeId: string;
+    runtimeKey?: string;
+    displayName?: string;
+    workspaceLabel?: string;
+    writeOwner?: ProviderRuntimeWriteOwner | null;
+    attachedClients?: ProviderRuntimeClient[];
+}
+export interface ActiveChatData {
+    id: string;
+    title: string;
+    status: string;
+    messages: ChatMessage[];
+    activeModal: {
+        message: string;
+        buttons: string[];
+    } | null;
+    terminalHistory?: string;
+    inputContent?: string;
+}
+/** Standardized error reasons across all provider categories */
+export type ProviderErrorReason = 'not_installed' | 'auth_failed' | 'spawn_error' | 'init_failed' | 'crash' | 'timeout' | 'cdp_error' | 'disconnected';
+/** Common fields shared by all provider categories */
+interface ProviderStateBase {
+    /** Provider type (e.g. 'gemini-cli', 'cursor', 'cline') */
+    type: string;
+    /** Provider Display name */
+    name: string;
+    /** current status */
+    status: ProviderStatus;
+    /** chat data */
+    activeChat: ActiveChatData | null;
+    /** Workspace — project path or name (all categories) */
+    workspace?: string | null;
+    /** Runtime info (real-time detection) */
+    currentModel?: string;
+    currentPlan?: string;
+    /** Error details (when status === 'error') */
+    errorMessage?: string;
+    errorReason?: ProviderErrorReason;
+    /** meta */
+    instanceId: string;
+    lastUpdated: number;
+    settings: Record<string, any>;
+    /** Event queue (cleared after daemon collects) */
+    pendingEvents: ProviderEvent[];
+    runtime?: ProviderRuntimeInfo;
+    resume?: ProviderResumeCapability;
+    /** Dynamic control current values */
+    controlValues?: Record<string, string | number | boolean>;
+    /** Provider-declared controls schema (from provider.controls) */
+    providerControls?: ProviderControlSchema[];
+}
+/** IDE provider state */
+export interface IdeProviderState extends ProviderStateBase {
+    category: 'ide';
+    cdpConnected: boolean;
+    /** IDE child Extension Instance status */
+    extensions: ProviderState[];
+    currentAutoApprove?: string;
+}
+/** CLI provider state */
+export interface CliProviderState extends ProviderStateBase {
+    category: 'cli';
+    /** terminal = PTY stream, chat = parsed conversation */
+    mode: 'terminal' | 'chat';
+}
+/** ACP provider state */
+export interface AcpProviderState extends ProviderStateBase {
+    category: 'acp';
+    mode: 'chat';
+    /** ACP config options (model/mode selection) */
+    acpConfigOptions?: AcpConfigOption[];
+    /** ACP available modes */
+    acpModes?: AcpMode[];
+}
+/** Extension provider state */
+export interface ExtensionProviderState extends ProviderStateBase {
+    category: 'extension';
+    agentStreams?: any[];
+}
+/** Discriminated union — switch on `.category` */
+export type ProviderState = IdeProviderState | CliProviderState | AcpProviderState | ExtensionProviderState;
+export interface ProviderEvent {
+    event: string;
+    timestamp: number;
+    [key: string]: any;
+}
+export interface InstanceContext {
+    /** CDP connection (IDE/Extension) */
+    cdp?: {
+        isConnected: boolean;
+        evaluate(script: string, timeout?: number): Promise<unknown>;
+        evaluateInWebviewFrame?(expression: string, matchFn?: (bodyPreview: string) => boolean): Promise<string | null>;
+        discoverAgentWebviews?(): Promise<any[]>;
+        /** Low-level CDP protocol method (e.g. Input.dispatchMouseEvent) */
+        send?(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    };
+    /** Server log transmit */
+    serverConn?: {
+        sendMessage(type: string, data: any): void;
+    };
+    /** P2P PTY output transmit */
+    onPtyData?: (data: string) => void;
+    /** Provider configvalue (resolved) */
+    settings: Record<string, any>;
+}
+export interface ProviderInstance {
+    /** Provider type */
+    readonly type: string;
+    /** Provider category */
+    readonly category: 'cli' | 'ide' | 'extension' | 'acp';
+    /** initialize */
+    init(context: InstanceContext): Promise<void>;
+    /** Tick — periodic status refresh (IDE: readChat, Extension: stream collection) */
+    onTick(): Promise<void>;
+    /** Return current status */
+    getState(): ProviderState;
+    /** Receive event (external → Instance) */
+    onEvent(event: string, data?: any): void;
+    /** Update settings at runtime (called when user changes settings from dashboard) */
+    updateSettings?(newSettings: Record<string, any>): void;
+    /** cleanup */
+    dispose(): void;
+}
+export {};

package/dist/providers/provider-loader.d.ts

@@ -0,0 +1,270 @@
+/**
+ * ProviderLoader — Provider discovery + OS/version override resolution
+ *
+ * Role:
+ * 1. Load providers from upstream auto-download (~/.adhdev/providers/.upstream/)
+ * 2. Load user custom from ~/.adhdev/providers/ (overrides)
+ * 3. Apply OS/version overrides (process.platform + detected IDE version)
+ * 4. Hot-reload support (fs.watch)
+ *
+ * Design principles:
+ * - Load JS files via require() (CJS compatible)
+ * - User custom can override builtin
+ * - provider.js files are independent, so load order doesn't matter
+ */
+import { VersionArchive } from './version-archive.js';
+import type { ProviderModule, ProviderCategory, ProviderSettingSchema, ResolvedProvider } from './contracts.js';
+export declare class ProviderLoader {
+    private providers;
+    private userDir;
+    private upstreamDir;
+    private disableUpstream;
+    private watchers;
+    private logFn;
+    private versionArchive;
+    private scriptsCache;
+    /** Inject VersionArchive so resolve() can auto-detect installed versions */
+    setVersionArchive(archive: VersionArchive): void;
+    private static readonly GITHUB_TARBALL_URL;
+    private static readonly META_FILE;
+    constructor(options?: {
+        userDir?: string;
+        logFn?: (msg: string) => void;
+        /** Disable upstream auto-download (for dev/testing/OSS) */
+        disableUpstream?: boolean;
+    });
+    private log;
+    /**
+     * User override root (~/.adhdev/providers by default).
+     */
+    getUserDir(): string;
+    /**
+    * Auto-updated upstream root (~/.adhdev/providers/.upstream by default).
+    */
+    getUpstreamDir(): string;
+    /**
+     * Provider search order for on-disk lookups.
+     * Highest-priority editable overrides come first.
+     */
+    getProviderRoots(): string[];
+    /**
+    * Canonical provider directory shape for a given root.
+    */
+    getProviderDir(root: string, category: ProviderCategory, type: string): string;
+    /**
+    * Canonical user override directory for a provider.
+    */
+    getUserProviderDir(category: ProviderCategory, type: string): string;
+    /**
+    * Canonical upstream directory for a provider.
+    */
+    getUpstreamProviderDir(category: ProviderCategory, type: string): string;
+    /**
+     * Find the on-disk directory for a provider by type.
+     * Search order: user override → upstream.
+     */
+    findProviderDir(type: string): string | null;
+    /**
+    * Resolve a file within a provider directory.
+    */
+    resolveProviderFile(type: string, ...segments: string[]): string | null;
+    /**
+    * Load all providers (3-tier priority)
+    * 1. .upstream/ (GitHub auto-download — primary source)
+    * 2. User custom (~/.adhdev/providers/ excluding .upstream)
+    * User custom always wins (highest priority).
+    * If .upstream/ is empty, call fetchLatest() before loadAll().
+    */
+    loadAll(): void;
+    /**
+     * Check if upstream directory exists and has providers.
+     */
+    hasUpstream(): boolean;
+    /**
+    * Get raw provider metadata by type (NO scripts loaded).
+    * Safe for: category checks, icon, displayName, targetFilter, cdpPorts.
+    * NOT safe for: script execution (readChat, listModels, sendMessage).
+    * Use resolve() when scripts are needed.
+    */
+    getMeta(type: string): ProviderModule | undefined;
+    /**
+    * Resolve provider type by alias
+    * 'claude' → 'claude-cli', 'codex' → 'codex-cli' etc
+    * Returns input as-is if no match found.
+    */
+    resolveAlias(input: string): string;
+    /**
+    * Get provider with alias resolution (get + alias fallback)
+    */
+    getByAlias(input: string): ProviderModule | undefined;
+    /**
+    * Build CLI/ACP detection list (replaces cli-detector)
+    * Dynamically generated from provider.js spawn.command.
+    */
+    getCliDetectionList(): {
+        id: string;
+        displayName: string;
+        icon: string;
+        command: string;
+        category: string;
+        versionCommand?: string;
+    }[];
+    /**
+    * List providers by category
+    */
+    getByCategory(cat: ProviderCategory): ProviderModule[];
+    /**
+    * Extension Extension providers with extensionIdPattern only
+    * (used by discoverAgentWebviews in daemon-cdp.ts)
+    */
+    getExtensionProviders(): ProviderModule[];
+    /**
+    * All loaded providers
+    */
+    getAll(): ProviderModule[];
+    /**
+    * Check if a provider is enabled (per-IDE)
+    * Checks ideSettings[ideType].extensions[type].enabled.
+    * Default false (disabled) — user must explicitly enable.
+    * Always returns true when called without ideType.
+    */
+    isEnabled(type: string, ideType?: string): boolean;
+    /**
+    * Resolve per-IDE extension enabled state using the same normalization
+    * that runtime attach/remove uses.
+    */
+    getIdeExtensionEnabledState(ideType: string, extensionType: string): boolean;
+    /**
+    * Save IDE extension enabled setting
+    */
+    setIdeExtensionEnabled(ideType: string, extensionType: string, enabled: boolean): boolean;
+    /**
+    * Return only enabled providers by category (per-IDE)
+    */
+    getEnabledByCategory(cat: ProviderCategory, ideType?: string): ProviderModule[];
+    /**
+    * Extension Enabled extension providers with extensionIdPattern only (per-IDE)
+    */
+    getEnabledExtensionProviders(ideType?: string): ProviderModule[];
+    /**
+    * Return CDP port map for IDE providers
+    * Used by launch.ts, adhdev-daemon.ts
+    */
+    getCdpPortMap(): Record<string, [number, number]>;
+    /**
+    * Return IDE process name map (macOS)
+    */
+    getMacAppIdentifiers(): Record<string, string>;
+    /**
+    * Return IDE process name map (Windows)
+    */
+    getWinProcessNames(): Record<string, string[]>;
+    /**
+    * Available IDE types (only those with cdpPorts)
+    */
+    getAvailableIdeTypes(): string[];
+    /**
+    * Register IDE providers to core/detector registry
+    * → Enables detectIDEs() to detect provider.js-based IDEs
+    */
+    registerToDetector(): number;
+    /**
+    * Return final provider with OS/version overrides applied.
+    *
+    * Script resolution order:
+    *   1. compatibility array (new format — preferred)
+    *      Provider.json defines: "compatibility": [{ "ideVersion": ">=1.107.0", "scriptDir": "scripts/1.107" }]
+    *      First matching range wins. Fallback: defaultScriptDir.
+    *   2. versions field (legacy format — backward compat)
+    *      "versions": { "< 1.107.0": { "__dir": "scripts/legacy" } }
+    *   3. Root scripts.js (original format — no versioning)
+    *
+    * Version source: context.version → VersionArchive → undefined
+    */
+    resolve(type: string, context?: {
+        os?: string;
+        version?: string;
+    }): ResolvedProvider | undefined;
+    /**
+     * Load scripts from a scriptDir within a provider directory.
+     * Tries scripts.js first, then individual .js files.
+     */
+    private loadScriptsFromDir;
+    /**
+     * Hot-reload: start watching for file changes
+     */
+    watch(): void;
+    /**
+    * Stop hot-reload
+    */
+    stopWatch(): void;
+    /**
+    * Full reload
+    */
+    reload(): void;
+    /**
+    * Download latest providers tarball from GitHub → extract to .upstream/
+    * - ETag-based change detection (skip if unchanged)
+    * - Never touches user custom files in ~/.adhdev/providers/
+    * - Runs in background; existing providers are kept on failure
+    *
+    * @returns Whether an update occurred
+    */
+    fetchLatest(): Promise<{
+        updated: boolean;
+        error?: string;
+    }>;
+    /** HTTP(S) file download (follows redirects) */
+    private downloadFile;
+    /** Recursive directory copy */
+    private copyDirRecursive;
+    /** .meta.json save */
+    private writeMeta;
+    /** Count provider files (provider.js or provider.json) */
+    private countProviders;
+    /**
+    * Get public settings schema for a provider (for dashboard UI rendering)
+    */
+    getPublicSettings(type: string): ProviderSettingSchema[];
+    /**
+    * Get public settings schema for all providers
+    */
+    getAllPublicSettings(): Record<string, ProviderSettingSchema[]>;
+    /**
+    * Resolved setting value for a provider (default + user override)
+    */
+    getSettingValue(type: string, key: string): any;
+    /**
+    * All resolved settings for a provider (default + user override)
+    */
+    getSettings(type: string): Record<string, any>;
+    /**
+    * Save provider setting value (writes to config.json)
+    */
+    setSetting(type: string, key: string, value: any): boolean;
+    /**
+     * Find the on-disk directory for a provider by type.
+     * Canonical shape: root/category/type.
+     */
+    private findProviderDirInternal;
+    /**
+     * Build a scripts function map from individual .js files in a directory.
+     * Each file is wrapped as: (params?) => fs.readFileSync(filePath, 'utf-8')
+     * (template substitution is NOT applied here — scripts.js handles that)
+     */
+    private buildScriptWrappersFromDir;
+    /**
+     * Recursively scan directory to load provider files
+     * Supports two formats:
+     *   1. provider.json (metadata) + scripts.js (optional CDP scripts)
+     *   2. provider.js (legacy — everything in one file)
+     * Structure: dir/category/agent-name/provider.{json,js}
+     */
+    private loadDir;
+    /**
+    * Simple semver range matching
+    * Supported formats: '>=4.0.0', '<3.0.0', '>=2.1.0'
+    */
+    private matchesVersion;
+    private compareVersions;
+}

package/dist/providers/status-monitor.d.ts

@@ -0,0 +1,48 @@
+/**
+ * StatusMonitor — Status monitoring notification system
+ *
+ * Common across all Provider categories (IDE/Extension/CLI/ACP).
+ * - Approval waiting (waiting_approval) notification
+ * - Notification when generating persists for extended duration
+ * - All config toggleable via Provider Settings
+ */
+export interface MonitorConfig {
+    /** Enable awaiting-approval notification */
+    approvalAlert: boolean;
+    /** Prolonged generating notification enabled */
+    longGeneratingAlert: boolean;
+    /** Prolonged threshold (seconds) */
+    longGeneratingThresholdSec: number;
+    /** Repeat notification cooldown (seconds) */
+    alertCooldownSec: number;
+}
+export declare const DEFAULT_MONITOR_CONFIG: MonitorConfig;
+export interface MonitorEvent {
+    type: string;
+    agentKey: string;
+    timestamp: number;
+    elapsedSec?: number;
+    message?: string;
+}
+export declare class StatusMonitor {
+    private config;
+    private lastAlertTime;
+    private generatingStartTimes;
+    private longGeneratingAlerted;
+    private lastProgressFingerprint;
+    private lastProgressChangeAt;
+    constructor(config?: Partial<MonitorConfig>);
+    /** Update config (called from Provider Settings) */
+    updateConfig(partial: Partial<MonitorConfig>): void;
+    /** Return current config */
+    getConfig(): MonitorConfig;
+    /**
+     * Check status transition → return notification event array.
+     * Called from each onTick() or detectStatusTransition().
+     */
+    check(agentKey: string, status: string, now: number, progressFingerprint?: string): MonitorEvent[];
+    /** Cooldown check — prevent sending the same notification too frequently */
+    private shouldAlert;
+    /** Reset (on agent terminate/restart) */
+    reset(agentKey?: string): void;
+}

package/dist/providers/version-archive.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Provider Version Detection & Archiving
+ *
+ * Detects installed versions for all provider categories (IDE, CLI, ACP, Extension).
+ * Archives version history to ~/.adhdev/version-history.json for compatibility tracking.
+ *
+ * Usage:
+ *   const archive = new VersionArchive();
+ *   const results = await detectAllVersions(providerLoader, archive);
+ */
+import type { ProviderLoader } from './provider-loader.js';
+export interface ProviderVersionInfo {
+    type: string;
+    name: string;
+    category: string;
+    installed: boolean;
+    version: string | null;
+    path: string | null;
+    binary: string | null;
+    detectedAt: string;
+    /**
+     * Set when the detected version is NOT listed in provider.json testedVersions.
+     * Means scripts may not work correctly with this version.
+     */
+    warning?: string;
+}
+export interface VersionHistoryEntry {
+    version: string;
+    detectedAt: string;
+    os: string;
+}
+export interface VersionHistory {
+    [providerType: string]: VersionHistoryEntry[];
+}
+export declare class VersionArchive {
+    private history;
+    constructor();
+    private load;
+    /** Record a detected version (deduplicates same version) */
+    record(type: string, version: string): void;
+    /** Get version history for a provider */
+    getHistory(type: string): VersionHistoryEntry[];
+    /** Get latest known version for a provider */
+    getLatest(type: string): string | null;
+    /** Get full archive */
+    getAll(): VersionHistory;
+    private save;
+}
+/**
+ * Detect versions for all loaded providers
+ */
+export declare function detectAllVersions(loader: ProviderLoader, archive?: VersionArchive): Promise<ProviderVersionInfo[]>;

package/dist/session-host/runtime-support.d.ts

@@ -0,0 +1,8 @@
+import { type SessionHostEndpoint } from '@adhdev/session-host-core';
+import type { HostedCliRuntimeDescriptor } from '../commands/cli-manager.js';
+export declare function ensureSessionHostReady(options: {
+    appName?: string;
+    spawnHost: () => void;
+    timeoutMs?: number;
+}): Promise<SessionHostEndpoint>;
+export declare function listHostedCliRuntimes(endpoint: SessionHostEndpoint): Promise<HostedCliRuntimeDescriptor[]>;

package/dist/sessions/registry.d.ts

@@ -0,0 +1,24 @@
+import type { SessionTransport } from '../shared-types.js';
+export interface SessionRuntimeTarget {
+    sessionId: string;
+    parentSessionId: string | null;
+    providerType: string;
+    transport: SessionTransport;
+    cdpManagerKey?: string;
+    adapterKey?: string;
+    instanceKey?: string;
+}
+export declare class SessionRegistry {
+    private readonly bySessionId;
+    private readonly byManagerKey;
+    private readonly byInstanceKey;
+    private readonly byParentSessionId;
+    register(target: SessionRuntimeTarget): void;
+    get(sessionId: string | undefined | null): SessionRuntimeTarget | undefined;
+    unregister(sessionId: string | undefined | null): void;
+    unregisterByManagerKey(managerKey: string): void;
+    unregisterByInstanceKey(instanceKey: string): void;
+    listChildren(parentSessionId: string): SessionRuntimeTarget[];
+    private addIndex;
+    private removeIndex;
+}

package/dist/shared-types-extra.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ADHDev Shared Types — Additional cross-package type definitions
+ *
+ * Extracted common sub-types previously inlined across multiple packages.
+ * Separated from shared-types.ts due to rollup-dts bundling constraints.
+ *
+ * IMPORTANT: This file must remain runtime-free (types only).
+ */
+/** Runtime terminal write-owner descriptor */
+export interface RuntimeWriteOwner {
+    clientId: string;
+    ownerType: 'agent' | 'user';
+}
+/** Runtime attached client descriptor */
+export interface RuntimeAttachedClient {
+    clientId: string;
+    type: 'daemon' | 'web' | 'local-terminal';
+    readOnly: boolean;
+}
+/** Session status union (used by SessionEntry.status, legacy recent-launch metadata, etc.) */
+export type SessionStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
+/** Inbox bucket categories for recent sessions */
+export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete' | 'idle';
+/** Terminal backend status */
+export interface TerminalBackendStatus {
+    backend: 'xterm' | 'ghostty-vt';
+    preference: 'auto' | 'xterm' | 'ghostty-vt';
+    ghosttyAvailable: boolean;
+}