@adhdev/daemon-core 0.8.34 → 0.8.35

package/src/providers/ide-provider-instance.d.ts

@@ -0,0 +1,70 @@
+/**
+ * IdeProviderInstance — Runtime instance for IDE Provider
+ *
+ * Within a single IDE:
+ * 1. Native chat (readChat via CDP)
+ * 2. Extension agents (Cline, Roo Code etc)
+ *
+ * IDE Instance manages child Extension Instances.
+ * Daemon collects all via a single IDE Instance.getState() call.
+ */
+import type { ProviderModule } from './contracts.js';
+import type { ProviderInstance, ProviderState, InstanceContext } from './provider-instance.js';
+import { ExtensionProviderInstance } from './extension-provider-instance.js';
+export declare class IdeProviderInstance implements ProviderInstance {
+    readonly type: string;
+    readonly category: "ide";
+    private provider;
+    private context;
+    private settings;
+    private events;
+    private tickErrorCount;
+    private cachedChat;
+    private currentStatus;
+    private lastAgentStatuses;
+    private generatingStartedAt;
+    private tickBusy;
+    private monitor;
+    private historyWriter;
+    private autoApproveBusy;
+    private appliedEffectKeys;
+    private runtimeMessages;
+    private ideVersion;
+    private instanceId;
+    private workspace;
+    private extensions;
+    constructor(provider: ProviderModule, instanceKey?: string);
+    init(context: InstanceContext): Promise<void>;
+    onTick(): Promise<void>;
+    getState(): ProviderState;
+    onEvent(event: string, data?: any): void;
+    dispose(): void;
+    updateSettings(newSettings: Record<string, any>): void;
+    /** Extension Instance add */
+    addExtension(provider: ProviderModule, settings?: Record<string, any>): Promise<void>;
+    /** Extension Instance remove */
+    removeExtension(type: string): void;
+    /** Extension Instance Import */
+    getExtension(type: string): ExtensionProviderInstance | undefined;
+    /** Child Extension list */
+    getExtensionTypes(): string[];
+    /** Query UUID instanceId */
+    getInstanceId(): string;
+    /** all Extension Instance list */
+    getExtensionInstances(): ExtensionProviderInstance[];
+    /** Set workspace from daemon launch context */
+    setWorkspace(workspace: string): void;
+    private readChat;
+    private getReadChatScript;
+    private detectAgentTransitions;
+    private pushEvent;
+    private applyProviderResponse;
+    private appendRuntimeSystemMessage;
+    private mergeConversationMessages;
+    private getPersistedEffectContent;
+    private getEffectDedupKey;
+    private flushEvents;
+    updateCdp(cdp: InstanceContext['cdp']): void;
+    private canAutoApprove;
+    private autoApproveViaScript;
+}

package/src/providers/provider-instance-manager.d.ts

@@ -0,0 +1,84 @@
+/**
+ * ProviderInstanceManager — lifecycle management for all ProviderInstances
+ *
+ * Role:
+ * 1. Instance create/delete
+ * 2. Tick engine (periodic onTick calls)
+ * 3. Collect overall state
+ * 4. Event collection and propagation
+ */
+import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
+export declare class ProviderInstanceManager {
+    private instances;
+    private tickTimer;
+    private tickInterval;
+    private eventListeners;
+    /**
+    * Instance add and initialize
+    */
+    addInstance(id: string, instance: ProviderInstance, context: InstanceContext): Promise<void>;
+    /**
+    * Instance remove
+    */
+    removeInstance(id: string): void;
+    removeByCategory(category: 'cli' | 'ide' | 'extension' | 'acp', options?: {
+        dispose?: boolean;
+    }): number;
+    /**
+    * Import by Instance ID
+    */
+    getInstance(id: string): ProviderInstance | undefined;
+    /**
+    * Per-category Instance list
+    */
+    getByCategory(category: 'cli' | 'ide' | 'extension' | 'acp'): ProviderInstance[];
+    /**
+    * All Instance count
+    */
+    get size(): number;
+    /**
+    * All Instance IDs (for iteration without exposing the private Map)
+    */
+    listInstanceIds(): string[];
+    /**
+    * all Instance's current status collect
+    * + Propagate pending events to event listeners
+    */
+    collectAllStates(): ProviderState[];
+    /**
+    * Per-category status collect
+    */
+    collectStatesByCategory(category: 'cli' | 'ide' | 'extension' | 'acp'): ProviderState[];
+    /**
+    * Start tick — periodically call all Instance.onTick() call
+    */
+    startTicking(intervalMs?: number): void;
+    /**
+    * Stop tick
+    */
+    stopTicking(): void;
+    /**
+    * Register event listener (used for daemon status_event transmission)
+    */
+    onEvent(listener: (event: ProviderEvent & {
+        providerType: string;
+    }) => void): void;
+    private emitPendingEvents;
+    /**
+    * Forward event to specific Instance
+    */
+    sendEvent(id: string, event: string, data?: any): void;
+    /**
+    * Broadcast event to all Instances
+    */
+    broadcast(event: string, data?: any): void;
+    /**
+     * Update settings for all instances of a given provider type.
+     * Called when user changes settings from dashboard.
+     */
+    updateInstanceSettings(providerType: string, settings: Record<string, any>): number;
+    /**
+    * All terminate
+    */
+    disposeAll(): void;
+}

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

@@ -8,7 +8,7 @@
  * Each Instance manages its own status.
  */
 import type { ProviderResumeCapability } from './contracts.js';
-import type { AcpConfigOption, AcpMode } from '../shared-types.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 {
@@ -68,6 +68,10 @@ interface ProviderStateBase {
     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 {
@@ -111,6 +115,8 @@ export interface InstanceContext {
         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?: {

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

@@ -0,0 +1,299 @@
+/**
+ * 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 providerAvailability;
+    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[];
+    getSpawnCommand(type: string, fallback?: string): string;
+    getIdeCliCommand(type: string, fallback?: string | null): string | null;
+    getIdePathCandidates(type: string, fallback?: string[]): string[];
+    setProviderAvailability(type: string, state: {
+        installed: boolean;
+        detectedPath?: string | null;
+    }): void;
+    setCliDetectionResults(results: Array<{
+        id: string;
+        installed: boolean;
+        path?: string;
+    }>, replace?: boolean): void;
+    setIdeDetectionResults(results: Array<{
+        id: string;
+        installed: boolean;
+        path?: string | null;
+        cliCommand?: string | null;
+    }>, replace?: boolean): void;
+    getAvailableProviderInfos(): Array<ProviderModule & {
+        installed?: boolean;
+        detectedPath?: string | null;
+    }>;
+    /**
+    * 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;
+    private getOptionalStringSetting;
+    protected readConfig(): any | null;
+    protected writeConfig(config: any): void;
+    private getPlatformVersionCommand;
+    private getSettingsSchema;
+    private getSyntheticSettings;
+    /**
+     * 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/src/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/src/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/src/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/src/sessions/reconcile.d.ts

@@ -0,0 +1,22 @@
+import type { SessionRegistry } from './registry.js';
+interface IdeLikeInstance {
+    category?: string;
+    type?: string;
+    getInstanceId?: () => string;
+    getExtensionInstances?: () => Array<{
+        type?: string;
+        getInstanceId?: () => string;
+    }>;
+}
+interface InstanceManagerLike {
+    listInstanceIds(): string[];
+    getInstance(id: string): IdeLikeInstance | undefined;
+}
+/**
+ * Rebuild missing IDE/runtime session registry entries from live ProviderInstance objects.
+ *
+ * This is a defensive repair path for cases where an IDE extension instance still exists
+ * in InstanceManager/status, but its runtime session entry has been dropped from SessionRegistry.
+ */
+export declare function reconcileIdeRuntimeSessions(instanceManager: InstanceManagerLike | undefined, sessionRegistry: SessionRegistry | undefined): void;
+export {};

package/src/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/src/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;
+}