@adhdev/daemon-core 0.9.28 → 0.9.30

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

@@ -16,6 +16,32 @@ import { VersionArchive } from './version-archive.js';
 import type { ProviderModule, ProviderCategory, ProviderSettingSchema, ResolvedProvider } from './contracts.js';
 import type { ProviderSourceMode } from '../config/config.js';
 import type { ProviderSourceConfigSnapshot } from '../config/provider-source-config.js';
+export type ProviderMachineStatus = 'disabled' | 'enabled_unchecked' | 'not_detected' | 'detected';
+export interface MachineProviderCheckResult {
+    ok: boolean;
+    stage?: 'detection' | 'runnable' | 'verification';
+    checkedAt?: string;
+    message?: string;
+    command?: string;
+    path?: string | null;
+}
+export interface MachineProviderConfig {
+    enabled?: boolean;
+    executable?: string;
+    args?: string[];
+    lastDetection?: MachineProviderCheckResult;
+    lastVerification?: MachineProviderCheckResult;
+}
+type CliDetectionEntry = {
+    id: string;
+    displayName: string;
+    icon: string;
+    command: string;
+    args?: string[];
+    category: string;
+    enabled: boolean;
+    versionCommand?: string;
+};
 export declare class ProviderLoader {
     private providers;
     private providerAvailability;
@@ -132,14 +158,7 @@ export declare class ProviderLoader {
     * 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;
-    }[];
+    getCliDetectionList(): CliDetectionEntry[];
     /**
     * List providers by category
     */
@@ -197,6 +216,13 @@ export declare class ProviderLoader {
     getSpawnCommand(type: string, fallback?: string): string;
     getIdeCliCommand(type: string, fallback?: string | null): string | null;
     getIdePathCandidates(type: string, fallback?: string[]): string[];
+    isMachineProviderEnabled(type: string): boolean;
+    getMachineProviderConfig(type: string): MachineProviderConfig;
+    setMachineProviderConfig(type: string, patch: Partial<MachineProviderConfig>): boolean;
+    setMachineProviderEnabled(type: string, enabled: boolean): boolean;
+    getMachineProviderStatus(type: string): ProviderMachineStatus;
+    getSpawnArgs(type: string, fallback?: string[]): string[];
+    private parseArgsSetting;
     setProviderAvailability(type: string, state: {
         installed: boolean;
         detectedPath?: string | null;
@@ -215,6 +241,10 @@ export declare class ProviderLoader {
     getAvailableProviderInfos(): Array<ProviderModule & {
         installed?: boolean;
         detectedPath?: string | null;
+        enabled: boolean;
+        machineStatus: ProviderMachineStatus;
+        lastDetection?: MachineProviderCheckResult;
+        lastVerification?: MachineProviderCheckResult;
     }>;
     /**
     * Register IDE providers to core/detector registry
@@ -327,3 +357,4 @@ export declare class ProviderLoader {
     private matchesVersion;
     private compareVersions;
 }
+export {};

package/dist/shared-types.d.ts

@@ -299,12 +299,31 @@ export interface CompactSessionEntry {
     parentId: string | null;
     providerType: string;
     providerName: string;
+    providerSessionId?: string;
     kind: SessionKind;
     transport: SessionTransport;
     status: SessionStatus;
     title: string;
     workspace: string | null;
     cdpConnected?: boolean;
+    runtimeKey?: string;
+    runtimeDisplayName?: string;
+    runtimeWorkspaceLabel?: string;
+    runtimeWriteOwner?: RuntimeWriteOwner | null;
+    runtimeAttachedClients?: RuntimeAttachedClient[];
+    lastMessagePreview?: string;
+    lastMessageRole?: string;
+    lastMessageAt?: number;
+    lastMessageHash?: string;
+    lastUpdated?: number;
+    unread?: boolean;
+    lastSeenAt?: number;
+    inboxBucket?: RecentSessionBucket;
+    completionMarker?: string;
+    seenCompletionMarker?: string;
+    surfaceHidden?: boolean;
+    controlValues?: Record<string, string | number | boolean>;
+    providerControls?: ProviderControlSchema[];
     summaryMetadata?: ProviderSummaryMetadata;
 }
 export type VersionUpdateReason = 'force_update_below' | 'major_minor_mismatch' | 'patch_mismatch' | 'daemon_ahead';
@@ -317,6 +336,22 @@ export interface AvailableProviderInfo {
     icon: string;
     installed?: boolean;
     detectedPath?: string | null;
+    /** Machine-local opt-in activation state. Undefined means older daemon payload. */
+    enabled?: boolean;
+    /** Machine-local readiness state for opt-in providers. */
+    machineStatus?: 'disabled' | 'enabled_unchecked' | 'not_detected' | 'detected';
+    /** Last machine-local command detection/runnable check result. */
+    lastDetection?: MachineProviderCheckResult;
+    /** Last end-to-end ADHDev verification result, when available. */
+    lastVerification?: MachineProviderCheckResult;
+}
+export interface MachineProviderCheckResult {
+    ok: boolean;
+    stage?: 'detection' | 'runnable' | 'verification';
+    checkedAt?: string;
+    message?: string;
+    command?: string;
+    path?: string | null;
 }
 /** ACP config option (model/mode/thought_level selection) */
 export interface AcpConfigOption {

package/dist/status/snapshot.d.ts

@@ -8,7 +8,7 @@
 import type { DaemonCdpManager } from '../cdp/manager.js';
 import { type SessionEntryProfile } from './builders.js';
 import type { ProviderState } from '../providers/provider-instance.js';
-import type { MachineInfo, RecentSessionBucket, StatusReportPayload } from '../shared-types.js';
+import type { AvailableProviderInfo, MachineInfo, RecentSessionBucket, StatusReportPayload } from '../shared-types.js';
 export interface StatusSnapshotOptions {
     allStates: ProviderState[];
     cdpManagers: Map<string, DaemonCdpManager>;
@@ -26,6 +26,10 @@ export interface StatusSnapshotOptions {
             category: 'ide' | 'extension' | 'cli' | 'acp';
             installed?: boolean;
             detectedPath?: string | null;
+            enabled?: boolean;
+            machineStatus?: 'disabled' | 'enabled_unchecked' | 'not_detected' | 'detected';
+            lastDetection?: AvailableProviderInfo['lastDetection'];
+            lastVerification?: AvailableProviderInfo['lastVerification'];
         }>;
     };
     detectedIdes: Array<{

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.9.28",
+  "version": "0.9.30",
   "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.28",
+  "version": "0.9.30",
   "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/boot/daemon-lifecycle.ts

@@ -181,10 +181,11 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         if (!providerType || targetCategory === 'cli' || targetCategory === 'acp') {
             if (providerType && targetProvider) {
                 const detected = await detectCLI(targetProvider.type, providerLoader, { includeVersion: false });
-                providerLoader.setProviderAvailability(targetProvider.type, {
+                providerLoader.setCliDetectionResults([{
+                    id: targetProvider.type,
                     installed: !!detected,
-                    detectedPath: detected?.path || null,
-                });
+                    path: detected?.path,
+                }], false);
             } else {
                 providerLoader.setCliDetectionResults(await detectCLIs(providerLoader, { includeVersion: false }), true);
             }

package/src/commands/cli-manager.ts

@@ -8,6 +8,8 @@
 import * as os from 'os';
 import * as path from 'path';
 import * as crypto from 'crypto';
+import { existsSync } from 'fs';
+import { execFileSync } from 'child_process';
 import chalk from 'chalk';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
@@ -33,6 +35,30 @@ import { shouldRestoreHostedRuntime } from './hosted-runtime-restore.js';
 
 // ─── external dependency interface ──────────────────────────
 
+function isExplicitCommand(command: string): boolean {
+    const trimmed = command.trim();
+    return path.isAbsolute(trimmed) || trimmed.includes('/') || trimmed.includes('\\') || trimmed.startsWith('~');
+}
+
+function expandExecutable(command: string): string {
+    const trimmed = command.trim();
+    return trimmed.startsWith('~') ? path.join(os.homedir(), trimmed.slice(1)) : trimmed;
+}
+
+function commandExists(command: string): boolean {
+    const trimmed = command.trim();
+    if (!trimmed) return false;
+    if (isExplicitCommand(trimmed)) {
+        return existsSync(expandExecutable(trimmed));
+    }
+    try {
+        execFileSync(process.platform === 'win32' ? 'where' : 'which', [trimmed], { stdio: 'ignore' });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
 export interface CliManagerDeps {
  /** Server connection — injected into adapter */
     getServerConn(): any | null;
@@ -461,7 +487,15 @@ export class DaemonCliManager {
 
  // cliType normalize (Resolve alias)
         const normalizedType = this.providerLoader.resolveAlias(cliType);
-        const provider = this.providerLoader.getByAlias(cliType);
+        const rawProvider = this.providerLoader.getByAlias(cliType);
+        const provider = rawProvider ? (this.providerLoader.resolve(normalizedType) || rawProvider) : undefined;
+        if (provider && (provider.category === 'cli' || provider.category === 'acp') && !this.providerLoader.isMachineProviderEnabled(normalizedType)) {
+            const displayName = provider.displayName || provider.name || normalizedType;
+            throw new Error(
+                `${displayName} is disabled on this machine.\n` +
+                `Enable and detect this provider from the Machine Providers page before starting a runtime.`
+            );
+        }
 
  // Create UUID-based key (allows separate instances even for same type+dir)
         const key = crypto.randomUUID();
@@ -471,26 +505,22 @@ export class DaemonCliManager {
         if (provider && provider.category === 'acp') {
             const instanceManager = this.deps.getInstanceManager();
             if (!instanceManager) throw new Error('InstanceManager not available');
+            const resolvedProvider = this.providerLoader.resolve(normalizedType) || provider;
 
  // Check if command is installed
-            const spawnCmd = provider.spawn?.command;
-            if (spawnCmd) {
-                try {
-                    const { execSync } = require('child_process');
-                    execSync(`which ${spawnCmd}`, { stdio: 'ignore' });
-                } catch {
-                    const installInfo = provider.install || `Install: check ${provider.displayName || provider.name} documentation`;
-                    throw new Error(
-                        `${provider.displayName || provider.name} is not installed.\n` +
-                        `Command '${spawnCmd}' not found in PATH.\n\n` +
-                        `${installInfo}`
-                    );
-                }
+            const spawnCmd = resolvedProvider.spawn?.command;
+            if (spawnCmd && !commandExists(spawnCmd)) {
+                const installInfo = provider.install || `Install: check ${provider.displayName || provider.name} documentation`;
+                throw new Error(
+                    `${provider.displayName || provider.name} is not installed.\n` +
+                    `Command '${spawnCmd}' not found.\n\n` +
+                    `${installInfo}`
+                );
             }
 
             console.log(colorize('cyan', `  🔌 Starting ACP agent: ${provider.name} (${provider.type}) in ${resolvedDir}`));
 
-            const acpInstance = new AcpProviderInstance(provider, resolvedDir, cliArgs);
+            const acpInstance = new AcpProviderInstance(resolvedProvider, resolvedDir, cliArgs);
             await instanceManager.addInstance(key, acpInstance, {
                 settings: this.providerLoader.getSettings(normalizedType),
             });

package/src/commands/router.ts

@@ -25,6 +25,7 @@ import { appendRecentActivity, getRecentActivity, markSessionSeen, dismissSessio
 import { getSavedProviderSessions } from '../config/saved-sessions.js';
 import { listSavedHistorySessions } from '../config/chat-history.js';
 import { detectIDEs } from '../detection/ide-detector.js';
+import { detectCLI } from '../detection/cli-detector.js';
 import { SessionRegistry } from '../sessions/registry.js';
 import { LOG } from '../logging/logger.js';
 import { logCommand } from '../logging/command-log.js';
@@ -669,6 +670,34 @@ export class DaemonCommandRouter {
                 return { ...result };
             }
 
+            // ─── Detect providers ───
+            case 'detect_provider': {
+                const providerType = typeof args?.providerType === 'string' ? args.providerType.trim() : '';
+                if (!providerType) return { success: false, error: 'providerType is required' };
+                const normalizedType = this.deps.providerLoader.resolveAlias(providerType);
+                const provider = this.deps.providerLoader.getByAlias(providerType);
+                if (!provider) return { success: false, error: `Provider not found: ${providerType}` };
+                if (provider.category !== 'cli' && provider.category !== 'acp') {
+                    return { success: false, error: `Provider detection is only supported for CLI/ACP providers: ${providerType}` };
+                }
+                if (!this.deps.providerLoader.isMachineProviderEnabled(normalizedType)) {
+                    return { success: false, error: `Provider is disabled on this machine: ${providerType}` };
+                }
+                const detected = await detectCLI(normalizedType, this.deps.providerLoader, { includeVersion: false });
+                this.deps.providerLoader.setCliDetectionResults([{
+                    id: normalizedType,
+                    installed: !!detected,
+                    path: detected?.path,
+                }], false);
+                this.deps.onStatusChange?.();
+                return {
+                    success: true,
+                    providerType: normalizedType,
+                    detected: !!detected,
+                    path: detected?.path || null,
+                };
+            }
+
             // ─── Detect IDEs ───
             case 'detect_ides': {
                 const results = await detectIDEs(this.deps.providerLoader);
@@ -718,13 +747,20 @@ export class DaemonCommandRouter {
                     this.deps.cdpManagers,
                 );
                 const targetSession = sessionEntries.find((entry) => entry.id === sessionId);
-                const completionMarker = targetSession ? getSessionCompletionMarker(targetSession) : '';
+                const requestedCompletionMarker = typeof args?.completionMarker === 'string'
+                    ? args.completionMarker.trim()
+                    : '';
+                const completionMarker = requestedCompletionMarker || (targetSession ? getSessionCompletionMarker(targetSession) : '');
+                const requestedProviderSessionId = typeof args?.providerSessionId === 'string'
+                    ? args.providerSessionId.trim()
+                    : '';
+                const providerSessionId = requestedProviderSessionId || targetSession?.providerSessionId;
                 const next = markSessionSeen(
                     currentState,
                     sessionId,
                     typeof args?.seenAt === 'number' ? args.seenAt : Date.now(),
                     completionMarker,
-                    targetSession?.providerSessionId,
+                    providerSessionId,
                 );
                 if (READ_DEBUG_ENABLED) {
                     LOG.info('RecentRead', `mark_session_seen sessionId=${sessionId} seenAt=${String(args?.seenAt || '')} prevSeenAt=${String(prevSeenAt)} nextSeenAt=${String(next.sessionReads?.[sessionId] || 0)} marker=${completionMarker || '-'}`);

package/src/config/config.ts

@@ -26,6 +26,23 @@ export function resolveProviderSourceMode(
     return legacyDisableUpstream === true ? 'no-upstream' : 'normal';
 }
 
+export interface MachineProviderCheckResult {
+    ok: boolean;
+    stage?: 'detection' | 'runnable' | 'verification';
+    checkedAt?: string;
+    message?: string;
+    command?: string;
+    path?: string | null;
+}
+
+export interface MachineProviderConfig {
+    enabled?: boolean;
+    executable?: string;
+    args?: string[];
+    lastDetection?: MachineProviderCheckResult;
+    lastVerification?: MachineProviderCheckResult;
+}
+
 export interface ADHDevConfig {
  // Server connection
     serverUrl: string;
@@ -86,6 +103,9 @@ export interface ADHDevConfig {
  // Per-provider user config (public setting values)
     providerSettings: Record<string, Record<string, any>>;
 
+ // Machine-local provider activation/config. Providers default disabled until explicitly enabled.
+    machineProviders: Record<string, MachineProviderConfig>;
+
  // Per-IDE extension config (per-IDE on/off control)
     ideSettings: Record<string, {
         extensions?: Record<string, { enabled: boolean }>;
@@ -128,6 +148,7 @@ const DEFAULT_CONFIG: ADHDevConfig = {
     machineSecret: null,
     registeredMachineId: undefined,
     providerSettings: {},
+    machineProviders: {},
     ideSettings: {},
     providerSourceMode: 'normal',
     terminalSizingMode: 'measured',
@@ -156,6 +177,30 @@ function asBoolean(value: unknown, fallback: boolean): boolean {
     return typeof value === 'boolean' ? value : fallback;
 }
 
+function normalizeMachineProviders(value: unknown): Record<string, MachineProviderConfig> {
+    if (!isPlainObject(value)) return {};
+    const result: Record<string, MachineProviderConfig> = {};
+    for (const [providerType, raw] of Object.entries(value)) {
+        if (!isPlainObject(raw)) continue;
+        const entry: MachineProviderConfig = {};
+        if (raw.enabled === true) entry.enabled = true;
+        if (typeof raw.executable === 'string' && raw.executable.trim()) {
+            entry.executable = raw.executable.trim();
+        }
+        if (Array.isArray(raw.args)) {
+            entry.args = raw.args.filter((arg): arg is string => typeof arg === 'string');
+        }
+        if (isPlainObject(raw.lastDetection)) {
+            entry.lastDetection = raw.lastDetection as MachineProviderCheckResult;
+        }
+        if (isPlainObject(raw.lastVerification)) {
+            entry.lastVerification = raw.lastVerification as MachineProviderCheckResult;
+        }
+        result[providerType] = entry;
+    }
+    return result;
+}
+
 function normalizeConfig(raw: unknown): ADHDevConfig & { activeWorkspaceId?: string | null } {
     const parsed = isPlainObject(raw) ? raw : {};
 
@@ -179,6 +224,7 @@ function normalizeConfig(raw: unknown): ADHDevConfig & { activeWorkspaceId?: str
         machineSecret: parsed.machineSecret === null ? null : asOptionalString(parsed.machineSecret),
         registeredMachineId: asOptionalString(parsed.registeredMachineId),
         providerSettings: isPlainObject(parsed.providerSettings) ? parsed.providerSettings : {},
+        machineProviders: normalizeMachineProviders(parsed.machineProviders),
         ideSettings: isPlainObject(parsed.ideSettings) ? parsed.ideSettings : {},
         providerSourceMode: resolveProviderSourceMode(parsed.providerSourceMode, parsed.disableUpstream),
         providerDir: asOptionalString(parsed.providerDir),

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

@@ -15,6 +15,22 @@
 import { VersionArchive } from './version-archive.js';
 import type { ProviderModule, ProviderCategory, ProviderSettingSchema, ResolvedProvider } from './contracts.js';
 import type { ProviderSourceMode } from '../config/config.js';
+export type ProviderMachineStatus = 'disabled' | 'enabled_unchecked' | 'not_detected' | 'detected';
+export interface MachineProviderCheckResult {
+    ok: boolean;
+    stage?: 'detection' | 'runnable' | 'verification';
+    checkedAt?: string;
+    message?: string;
+    command?: string;
+    path?: string | null;
+}
+export interface MachineProviderConfig {
+    enabled?: boolean;
+    executable?: string;
+    args?: string[];
+    lastDetection?: MachineProviderCheckResult;
+    lastVerification?: MachineProviderCheckResult;
+}
 export declare class ProviderLoader {
     private providers;
     private providerAvailability;
@@ -110,7 +126,9 @@ export declare class ProviderLoader {
         displayName: string;
         icon: string;
         command: string;
+        args?: string[];
         category: string;
+        enabled: boolean;
         versionCommand?: string;
     }[];
     /**
@@ -168,6 +186,7 @@ export declare class ProviderLoader {
     */
     getAvailableIdeTypes(): string[];
     getSpawnCommand(type: string, fallback?: string): string;
+    getSpawnArgs(type: string, fallback?: string[]): string[];
     getIdeCliCommand(type: string, fallback?: string | null): string | null;
     getIdePathCandidates(type: string, fallback?: string[]): string[];
     setProviderAvailability(type: string, state: {
@@ -188,6 +207,10 @@ export declare class ProviderLoader {
     getAvailableProviderInfos(): Array<ProviderModule & {
         installed?: boolean;
         detectedPath?: string | null;
+        enabled: boolean;
+        machineStatus: ProviderMachineStatus;
+        lastDetection?: MachineProviderCheckResult;
+        lastVerification?: MachineProviderCheckResult;
     }>;
     /**
     * Register IDE providers to core/detector registry