@adhdev/daemon-core 0.8.27 → 0.8.28

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

@@ -77,7 +77,7 @@ export declare class AcpProviderInstance implements ProviderInstance {
     sendPrompt(text: string, contentBlocks?: ContentBlock[]): Promise<void>;
     private cancelSession;
     private permissionResolvers;
-    private resolvePermission;
+    resolvePermission(approved: boolean): Promise<void>;
     private handleSessionUpdate;
     /** Handle legacy session/update formats (pre-standardization compat) */
     private handleLegacyUpdate;

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

@@ -16,6 +16,7 @@ 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;
@@ -163,6 +164,28 @@ export declare class ProviderLoader {
     * 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
@@ -242,6 +265,9 @@ export declare class ProviderLoader {
     * Save provider setting value (writes to config.json)
     */
     setSetting(type: string, key: string, value: any): boolean;
+    private getOptionalStringSetting;
+    private getSettingsSchema;
+    private getSyntheticSettings;
     /**
      * Find the on-disk directory for a provider by type.
      * Canonical shape: root/category/type.

package/dist/shared-types.d.ts

@@ -84,6 +84,8 @@ export interface AvailableProviderInfo {
     category: 'ide' | 'extension' | 'cli' | 'acp';
     displayName: string;
     icon: string;
+    installed?: boolean;
+    detectedPath?: string | null;
 }
 /** ACP config option (model/mode/thought_level selection) */
 export interface AcpConfigOption {

package/dist/status/snapshot.d.ts

@@ -17,6 +17,14 @@ export interface StatusSnapshotOptions {
             displayName?: string;
             category: 'ide' | 'extension' | 'cli' | 'acp';
         }>;
+        getAvailableProviderInfos?: () => Array<{
+            type: string;
+            icon?: string;
+            displayName?: string;
+            category: 'ide' | 'extension' | 'cli' | 'acp';
+            installed?: boolean;
+            detectedPath?: string | null;
+        }>;
     };
     detectedIdes: Array<{
         id: string;

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

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.27",
+  "version": "0.8.28",
   "description": "ADHDev local session host core — 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.8.27",
+  "version": "0.8.28",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/agent-stream/provider-adapter.ts

@@ -171,14 +171,27 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
             const raw = await evaluate(script, 10000) as string;
             const data = typeof raw === 'string' ? JSON.parse(raw) : raw;
             if (data?.error) return [];
-            return Array.isArray(data) ? data : [];
+            if (Array.isArray(data)) return data;
+            if (Array.isArray(data?.sessions)) return data.sessions;
+            if (Array.isArray(data?.chats)) return data.chats;
+            return [];
         } catch { return []; }
     }
 
     async switchSession(evaluate: AgentEvaluateFn, sessionId: string): Promise<boolean> {
         const script = this.callScript('switchSession', sessionId);
         if (!script) return false;
-        return (await evaluate(script, 10000)) === true;
+        const raw = await evaluate(script, 10000);
+        const data = this.parseMaybeJson(raw);
+        if (data === true) return true;
+        if (typeof data === 'string') {
+            const normalized = data.trim().toLowerCase();
+            return normalized === 'true' || normalized === 'ok' || normalized === 'switched' || normalized === 'success';
+        }
+        if (data && typeof data === 'object') {
+            return data.switched === true || data.success === true || data.ok === true;
+        }
+        return false;
     }
 
     async focusEditor(evaluate: AgentEvaluateFn): Promise<void> {

package/src/boot/daemon-lifecycle.ts

@@ -25,6 +25,7 @@ import { VersionArchive, detectAllVersions } from '../providers/version-archive.
 import { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { DevServer } from '../daemon/dev-server.js';
 import { detectIDEs } from '../detection/ide-detector.js';
+import { detectCLI, detectCLIs } from '../detection/cli-detector.js';
 import { SessionRegistry } from '../sessions/registry.js';
 import { installGlobalInterceptor, LOG } from '../logging/logger.js';
 import { loadConfig } from '../config/config.js';
@@ -160,6 +161,28 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
     let agentStreamManager: DaemonAgentStreamManager | null = null;
     let poller: AgentStreamPoller | null = null;
 
+    const refreshProviderAvailability = async (providerType?: string) => {
+        const targetProvider = providerType ? providerLoader.getMeta(providerLoader.resolveAlias(providerType)) : null;
+        const targetCategory = targetProvider?.category;
+
+        if (!providerType || targetCategory === 'cli' || targetCategory === 'acp') {
+            if (providerType && targetProvider) {
+                const detected = await detectCLI(targetProvider.type, providerLoader, { includeVersion: false });
+                providerLoader.setProviderAvailability(targetProvider.type, {
+                    installed: !!detected,
+                    detectedPath: detected?.path || null,
+                });
+            } else {
+                providerLoader.setCliDetectionResults(await detectCLIs(providerLoader, { includeVersion: false }), true);
+            }
+        }
+
+        if (!providerType || targetCategory === 'ide') {
+            detectedIdesRef.value = await detectIDEs(providerLoader);
+            providerLoader.setIdeDetectionResults(detectedIdesRef.value, true);
+        }
+    };
+
     // 4. CLI Manager
     const cliManager = new DaemonCliManager({
         ...config.cliManagerDeps,
@@ -169,7 +192,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
 
     // 5. Detect IDEs
     LOG.info('Init', 'Detecting IDEs...');
-    detectedIdesRef.value = await detectIDEs();
+    await refreshProviderAvailability();
     const installed = detectedIdesRef.value.filter((i: any) => i.installed);
     LOG.info('Init', `Found ${installed.length} IDE(s): ${installed.map((i: any) => i.id).join(', ') || 'none'}`);
 
@@ -219,6 +242,10 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         providerLoader,
         instanceManager,
         sessionRegistry,
+        onProviderSettingChanged: async (providerType) => {
+            await refreshProviderAvailability(providerType);
+            config.onStatusChange?.();
+        },
     });
 
     // 8. AgentStreamManager

package/src/cli-adapters/provider-cli-adapter.ts

@@ -304,12 +304,20 @@ function computeTerminalQueryTail(buffer: string): string {
 }
 
 function findBinary(name: string): string {
+    const trimmed = String(name || '').trim();
+    if (!trimmed) return trimmed;
+    const expanded = trimmed.startsWith('~')
+        ? path.join(os.homedir(), trimmed.slice(1))
+        : trimmed;
+    if (path.isAbsolute(expanded) || expanded.includes('/') || expanded.includes('\\')) {
+        return path.isAbsolute(expanded) ? expanded : path.resolve(expanded);
+    }
     const isWin = os.platform() === 'win32';
     try {
-        const cmd = isWin ? `where ${name}` : `which ${name}`;
+        const cmd = isWin ? `where ${trimmed}` : `which ${trimmed}`;
         return execSync(cmd, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim().split('\n')[0].trim();
     } catch {
-        return isWin ? `${name}.cmd` : name;
+        return isWin ? `${trimmed}.cmd` : trimmed;
     }
 }
 
@@ -928,7 +936,10 @@ export class ProviderCliAdapter implements CliAdapter {
         if (this.ptyProcess) return;
 
         const { spawn: spawnConfig } = this.provider;
-        const binaryPath = findBinary(spawnConfig.command);
+        const configuredCommand = typeof this.runtimeSettings.executablePath === 'string' && this.runtimeSettings.executablePath.trim()
+            ? this.runtimeSettings.executablePath.trim()
+            : spawnConfig.command;
+        const binaryPath = findBinary(configuredCommand);
         const isWin = os.platform() === 'win32';
         const allArgs = [...spawnConfig.args, ...this.extraArgs];
 

package/src/commands/chat-commands.ts

@@ -478,6 +478,14 @@ export async function handleListChats(h: CommandHelpers, args: any): Promise<Com
         if (evalResult) {
             let parsed = evalResult.result;
             if (typeof parsed === 'string') { try { parsed = JSON.parse(parsed); } catch { } }
+            if (parsed?.sessions && Array.isArray(parsed.sessions)) {
+                LOG.info('Command', `[list_chats] OK: ${parsed.sessions.length} chats`);
+                return { success: true, chats: parsed.sessions };
+            }
+            if (parsed?.chats && Array.isArray(parsed.chats)) {
+                LOG.info('Command', `[list_chats] OK: ${parsed.chats.length} chats`);
+                return { success: true, chats: parsed.chats };
+            }
             if (Array.isArray(parsed)) {
                 LOG.info('Command', `[list_chats] OK: ${parsed.length} chats`);
                 return { success: true, chats: parsed };
@@ -561,8 +569,14 @@ export async function handleSwitchChat(h: CommandHelpers, args: any): Promise<Co
         return { success: false, error: `webviewSwitchSession failed: ${e.message}` };
     }
 
-    const script = h.getProviderScript('switchSession', { SESSION_ID: JSON.stringify(sessionId) })
-        || h.getProviderScript('switch_session', { SESSION_ID: JSON.stringify(sessionId) });
+    const switchParams = {
+        sessionId,
+        title: sessionId,
+        id: sessionId,
+        SESSION_ID: JSON.stringify(sessionId),
+    };
+    const script = h.getProviderScript('switchSession', switchParams)
+        || h.getProviderScript('switch_session', switchParams);
     if (!script) return { success: false, error: 'switch_session script not available' };
 
     try {
@@ -630,8 +644,8 @@ export async function handleSetMode(h: CommandHelpers, args: any): Promise<Comma
         const adapter = getTargetedCliAdapter(h, args, provider?.type);
         if (adapter) {
             const acpInstance = (adapter as any)._acpInstance;
-            if (acpInstance && typeof acpInstance.onEvent === 'function') {
-                acpInstance.onEvent('set_mode', { mode });
+            if (acpInstance && typeof acpInstance.setMode === 'function') {
+                await acpInstance.setMode(mode);
                 return { success: true, mode };
             }
         }
@@ -687,9 +701,9 @@ export async function handleChangeModel(h: CommandHelpers, args: any): Promise<C
         LOG.info('Command', `[change_model] ACP adapter found: ${!!adapter}, type=${(adapter as any)?.cliType}, hasAcpInstance=${!!(adapter as any)?._acpInstance}`);
         if (adapter) {
             const acpInstance = (adapter as any)._acpInstance;
-            if (acpInstance && typeof acpInstance.onEvent === 'function') {
-                acpInstance.onEvent('change_model', { model });
-                LOG.info('Command', `[change_model] Dispatched change_model event to ACP instance`);
+            if (acpInstance && typeof acpInstance.setConfigOption === 'function') {
+                await acpInstance.setConfigOption('model', model);
+                LOG.info('Command', `[change_model] Updated ACP model to ${model}`);
                 return { success: true, model };
             }
         }
@@ -819,6 +833,21 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
         return { success: ok };
     }
 
+    // 1.5 ACP transport: resolve protocol permission request directly
+    if (transport === 'acp') {
+        const adapter = getTargetedCliAdapter(h, args, provider?.type);
+        const acpInstance = adapter?._acpInstance;
+        if (!acpInstance) return { success: false, error: 'ACP instance not found' };
+
+        try {
+            await acpInstance.resolvePermission(action === 'approve' || action === 'accept' || action === 'always');
+            LOG.info('Command', `[resolveAction] ACP → ${action}`);
+            return { success: true, action };
+        } catch (e: any) {
+            return { success: false, error: e?.message || 'ACP resolve action failed' };
+        }
+    }
+
     // 2. Webview Provider script
     if (provider?.scripts?.webviewResolveAction || provider?.scripts?.webview_resolve_action) {
         const script = h.getProviderScript('webviewResolveAction', { action, button, buttonText: button })

package/src/commands/cli-manager.ts

@@ -522,10 +522,10 @@ export class DaemonCliManager {
         if (!cliInfo) {
             const installHint = provider?.install || '';
             const displayName = provider?.displayName || provider?.name || cliType;
-            const spawnCmd = provider?.spawn?.command || cliType;
+            const spawnCmd = this.providerLoader.getSpawnCommand(normalizedType, provider?.spawn?.command || cliType);
             throw new Error(
                 `${displayName} is not installed.\n` +
-                `Command '${spawnCmd}' not found on PATH.\n` +
+                `Command '${spawnCmd}' is not available.\n` +
                 (installHint ? `\n${installHint}\n` : '') +
                 `\nRun 'adhdev doctor' for detailed diagnostics.`
             );

package/src/commands/handler.ts

@@ -44,6 +44,7 @@ export interface CommandContext {
     /** ProviderInstanceManager — for runtime settings propagation */
     instanceManager?: ProviderInstanceManager;
     sessionRegistry?: SessionRegistry;
+    onProviderSettingChanged?: (providerType: string, key: string, value: any) => Promise<void> | void;
 }
 
 /**

package/src/commands/router.ts

@@ -365,6 +365,11 @@ export class DaemonCommandRouter {
                 if (!ideType) throw new Error('ideType required');
                 const killProcess = args?.killProcess !== false; // default true
                 await this.stopIde(ideType, killProcess);
+                try {
+                    const results = await detectIDEs(this.deps.providerLoader);
+                    this.deps.detectedIdes.value = results;
+                    this.deps.providerLoader.setIdeDetectionResults(results, true);
+                } catch { /* ignore detection refresh errors */ }
                 return { success: true, ideType, stopped: true, processKilled: killProcess };
             }
 
@@ -415,6 +420,11 @@ export class DaemonCommandRouter {
                     }
                 }
                 this.deps.onIdeConnected?.();
+                try {
+                    const results = await detectIDEs(this.deps.providerLoader);
+                    this.deps.detectedIdes.value = results;
+                    this.deps.providerLoader.setIdeDetectionResults(results, true);
+                } catch { /* ignore detection refresh errors */ }
                 if (result.success && resolvedWorkspace) {
                     try {
                         const next = appendRecentActivity(loadState(), {
@@ -441,8 +451,9 @@ export class DaemonCommandRouter {
 
             // ─── Detect IDEs ───
             case 'detect_ides': {
-                const results = await detectIDEs();
+                const results = await detectIDEs(this.deps.providerLoader);
                 this.deps.detectedIdes.value = results;
+                this.deps.providerLoader.setIdeDetectionResults(results, true);
                 return { success: true, detectedInfo: results };
             }
 

package/src/commands/stream-commands.ts

@@ -76,7 +76,7 @@ export function handleGetProviderSettings(h: CommandHelpers, args: any): Command
     return { success: true, settings: allSettings, values: allValues };
 }
 
-export function handleSetProviderSetting(h: CommandHelpers, args: any): CommandResult {
+export async function handleSetProviderSetting(h: CommandHelpers, args: any): Promise<CommandResult> {
     const loader = h.ctx.providerLoader as ProviderLoader | undefined;
     const { providerType, key, value } = args || {};
     if (!providerType || !key || value === undefined) {
@@ -89,6 +89,7 @@ export function handleSetProviderSetting(h: CommandHelpers, args: any): CommandR
             const updated = h.ctx.instanceManager.updateInstanceSettings(providerType, allSettings);
             LOG.info('Command', `[set_provider_setting] ${providerType}.${key}=${JSON.stringify(value)} → ${updated} instance(s) updated`);
         }
+        await h.ctx.onProviderSettingChanged?.(providerType, key, value);
         return { success: true, providerType, key, value };
     }
     return { success: false, error: `Failed to set ${providerType}.${key} — invalid key, value, or not a public setting` };
@@ -133,7 +134,7 @@ function getCliScriptCommand(payload: any): { type: string; text?: string } | nu
 
     const command = payload.command;
     if (!command || typeof command !== 'object') return null;
-    if (command.type !== 'send_message') return null;
+    if (command.type !== 'send_message' && command.type !== 'pty_write') return null;
 
     const text = typeof command.text === 'string'
         ? command.text.trim()
@@ -141,7 +142,7 @@ function getCliScriptCommand(payload: any): { type: string; text?: string } | nu
             ? command.message.trim()
             : '';
     if (!text) return null;
-    return { type: 'send_message', text };
+    return { type: command.type, text };
 }
 
 function applyProviderPatch(h: CommandHelpers, args: any, payload: any): void {
@@ -191,6 +192,8 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
             const cliCommand = getCliScriptCommand(parsed.payload);
             if (cliCommand?.type === 'send_message' && cliCommand.text) {
                 await adapter.sendMessage(cliCommand.text);
+            } else if (cliCommand?.type === 'pty_write' && cliCommand.text && adapter.writeRaw) {
+                adapter.writeRaw(cliCommand.text + '\r');
             }
             applyProviderPatch(h, args, parsed.payload);
             return { success: true, ...(parsed.payload && typeof parsed.payload === 'object' ? parsed.payload : { result: parsed.payload }) };

package/src/detection/cli-detector.ts

@@ -9,6 +9,8 @@
 
 import { exec } from 'child_process';
 import * as os from 'os';
+import * as path from 'path';
+import { existsSync } from 'fs';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 
 export interface CLIInfo {
@@ -28,6 +30,33 @@ function parseVersion(raw: string): string {
     return match ? match[1] : raw.split('\n')[0].slice(0, 100);
 }
 
+function shellQuote(value: string): string {
+    if (/^[a-zA-Z0-9_./:@%+=,-]+$/.test(value)) return value;
+    return `"${value.replace(/(["\\$`])/g, '\\$1')}"`;
+}
+
+function expandHome(value: string): string {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('~')) return trimmed;
+    return path.join(os.homedir(), trimmed.slice(1));
+}
+
+function isExplicitCommandPath(command: string): boolean {
+    const trimmed = command.trim();
+    return path.isAbsolute(trimmed) || trimmed.includes('/') || trimmed.includes('\\') || trimmed.startsWith('~');
+}
+
+function resolveCommandPath(command: string): string | null {
+    const trimmed = command.trim();
+    if (!trimmed) return null;
+    if (isExplicitCommandPath(trimmed)) {
+        const expanded = expandHome(trimmed);
+        const candidate = path.isAbsolute(expanded) ? expanded : path.resolve(expanded);
+        return existsSync(candidate) ? candidate : null;
+    }
+    return null;
+}
+
 /** Run a shell command with timeout, returning stdout or null on failure */
 function execAsync(cmd: string, timeoutMs = 5000): Promise<string | null> {
     return new Promise((resolve) => {
@@ -47,9 +76,13 @@ function execAsync(cmd: string, timeoutMs = 5000): Promise<string | null> {
  * Detect all CLI/ACP agents (parallel)
  * @param providerLoader ProviderLoader instance (dynamic list creation)
  */
-export async function detectCLIs(providerLoader?: ProviderLoader): Promise<CLIInfo[]> {
+export async function detectCLIs(
+    providerLoader?: ProviderLoader,
+    options?: { includeVersion?: boolean },
+): Promise<CLIInfo[]> {
     const platform = os.platform();
     const whichCmd = platform === 'win32' ? 'where' : 'which';
+    const includeVersion = options?.includeVersion !== false;
 
     // Provider-based dynamic list creation, fallback is empty array
     const cliList = providerLoader
@@ -60,28 +93,31 @@ export async function detectCLIs(providerLoader?: ProviderLoader): Promise<CLIIn
     const results = await Promise.all(
         cliList.map(async (cli): Promise<CLIInfo> => {
             try {
-                const pathResult = await execAsync(`${whichCmd} ${cli.command}`);
+                const explicitPath = resolveCommandPath(cli.command);
+                const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(cli.command)}`);
                 if (!pathResult) return { ...cli, installed: false };
 
-                const firstPath = pathResult.split('\n')[0];
+                const firstPath = explicitPath || pathResult.split('\n')[0];
 
                 // Get version (parallel with other checks)
                 let version: string | undefined;
-                try {
+                if (includeVersion) {
                     const versionCommands = [
+                        `"${firstPath}" --version`,
+                        `"${firstPath}" -V`,
+                        `"${firstPath}" -v`,
                         cli.versionCommand,
-                        `${cli.command} --version`,
-                        `${cli.command} -V`,
-                        `${cli.command} -v`,
                     ].filter((v): v is string => !!v);
-                    for (const versionCommand of versionCommands) {
-                        const versionResult = await execAsync(versionCommand, 3000);
-                        if (versionResult) {
-                            version = parseVersion(versionResult);
-                            break;
+                    try {
+                        for (const versionCommand of versionCommands) {
+                            const versionResult = await execAsync(versionCommand, 3000);
+                            if (versionResult) {
+                                version = parseVersion(versionResult);
+                                break;
+                            }
                         }
-                    }
-                } catch { }
+                    } catch { }
+                }
 
                 return { ...cli, installed: true, version, path: firstPath };
             } catch {
@@ -94,7 +130,11 @@ export async function detectCLIs(providerLoader?: ProviderLoader): Promise<CLIIn
 }
 
 /** Detect specific CLI — only probes the one requested provider */
-export async function detectCLI(cliId: string, providerLoader?: ProviderLoader): Promise<CLIInfo | null> {
+export async function detectCLI(
+    cliId: string,
+    providerLoader?: ProviderLoader,
+    options?: { includeVersion?: boolean },
+): Promise<CLIInfo | null> {
     const resolvedId = providerLoader ? providerLoader.resolveAlias(cliId) : cliId;
 
     if (providerLoader) {
@@ -104,25 +144,28 @@ export async function detectCLI(cliId: string, providerLoader?: ProviderLoader):
             const platform = os.platform();
             const whichCmd = platform === 'win32' ? 'where' : 'which';
             try {
-                const pathResult = await execAsync(`${whichCmd} ${target.command}`);
+                const explicitPath = resolveCommandPath(target.command);
+                const pathResult = explicitPath || await execAsync(`${whichCmd} ${shellQuote(target.command)}`);
                 if (!pathResult) return null;
-                const firstPath = pathResult.split('\n')[0];
+                const firstPath = explicitPath || pathResult.split('\n')[0];
                 let version: string | undefined;
-                try {
+                if (options?.includeVersion !== false) {
                     const versionCommands = [
+                        `"${firstPath}" --version`,
+                        `"${firstPath}" -V`,
+                        `"${firstPath}" -v`,
                         target.versionCommand,
-                        `${target.command} --version`,
-                        `${target.command} -V`,
-                        `${target.command} -v`,
                     ].filter((v): v is string => !!v);
-                    for (const versionCommand of versionCommands) {
-                        const versionResult = await execAsync(versionCommand, 3000);
-                        if (versionResult) {
-                            version = parseVersion(versionResult);
-                            break;
+                    try {
+                        for (const versionCommand of versionCommands) {
+                            const versionResult = await execAsync(versionCommand, 3000);
+                            if (versionResult) {
+                                version = parseVersion(versionResult);
+                                break;
+                            }
                         }
-                    }
-                } catch { }
+                    } catch { }
+                }
                 return { ...target, installed: true, version, path: firstPath };
             } catch {
                 return null;
@@ -131,6 +174,6 @@ export async function detectCLI(cliId: string, providerLoader?: ProviderLoader):
     }
 
     // Fallback: full scan for unknown provider IDs
-    const all = await detectCLIs(providerLoader);
+    const all = await detectCLIs(providerLoader, options);
     return all.find((c) => c.id === resolvedId && c.installed) || null;
 }

package/src/detection/ide-detector.ts

@@ -10,6 +10,8 @@
 import { execSync } from 'child_process';
 import { existsSync } from 'fs';
 import { platform, homedir } from 'os';
+import * as path from 'path';
+import type { ProviderLoader } from '../providers/provider-loader.js';
 
 // ─── Types ──────────────────────────────────────
 
@@ -62,9 +64,18 @@ function getMergedDefinitions(): IDEDefinition[] {
 }
 
 function findCliCommand(command: string): string | null {
+    const trimmed = String(command || '').trim();
+    if (!trimmed) return null;
+    if (path.isAbsolute(trimmed) || trimmed.includes('/') || trimmed.includes('\\') || trimmed.startsWith('~')) {
+        const candidate = trimmed.startsWith('~')
+            ? path.join(homedir(), trimmed.slice(1))
+            : trimmed;
+        const resolved = path.isAbsolute(candidate) ? candidate : path.resolve(candidate);
+        return existsSync(resolved) ? resolved : null;
+    }
     try {
         const result = execSync(
-            platform() === 'win32' ? `where ${command}` : `which ${command}`,
+            platform() === 'win32' ? `where ${trimmed}` : `which ${trimmed}`,
             { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
         ).trim();
         return result.split('\n')[0] || null;
@@ -89,27 +100,29 @@ function getIdeVersion(cliCommand: string): string | null {
 function checkPathExists(paths: string[]): string | null {
     const home = homedir();
     for (const p of paths) {
-        if (p.includes('*')) {
+        const normalized = p.startsWith('~')
+            ? path.join(home, p.slice(1))
+            : p;
+        if (normalized.includes('*')) {
             // Wildcard expansion: replace `*` with the current user's home folder name
             // e.g. "C:\Users\*\AppData\..." → "C:\Users\vilmi\AppData\..."
             const username = home.split(/[\\/]/).pop() || '';
-            const resolved = p.replace('*', username);
+            const resolved = normalized.replace('*', username);
             if (existsSync(resolved)) return resolved;
         } else {
-            if (existsSync(p)) return p;
+            if (existsSync(normalized)) return normalized;
         }
     }
     return null;
 }
 
-export async function detectIDEs(): Promise<IDEInfo[]> {
+export async function detectIDEs(providerLoader?: ProviderLoader): Promise<IDEInfo[]> {
     const os = platform() as 'darwin' | 'win32' | 'linux';
     const results: IDEInfo[] = [];
 
     for (const def of getMergedDefinitions()) {
-        const cliPath = findCliCommand(def.cli);
-        const appPath = checkPathExists(def.paths[os] || []);
-        const installed = !!(cliPath || appPath);
+        const cliPath = findCliCommand(providerLoader?.getIdeCliCommand(def.id, def.cli) || def.cli);
+        const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os] || []) || []);
 
         let resolvedCli = cliPath;
 
@@ -136,6 +149,9 @@ export async function detectIDEs(): Promise<IDEInfo[]> {
             }
         }
 
+        const installed = os === 'darwin'
+            ? !!(resolvedCli || appPath)
+            : !!resolvedCli;
         const version = resolvedCli ? getIdeVersion(resolvedCli) : null;
 
         results.push({

package/src/launch.ts

@@ -310,7 +310,7 @@ export async function launchWithCdp(options: LaunchOptions = {}): Promise<Launch
 
  // 1. IDE determine
     let targetIde: IDEInfo | undefined;
-    const ides = await detectIDEs();
+    const ides = await detectIDEs(getProviderLoader());
 
     if (options.ideId) {
         targetIde = ides.find(i => i.id === options.ideId && i.installed);