@adhdev/daemon-core 0.8.29 → 0.8.31

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

@@ -19,6 +19,25 @@ import { ChatHistoryWriter } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
 import { extractProviderControlValues, normalizeProviderEffects } from './control-effects.js';
 import type { ChatMessage } from '../types.js';
+import { formatAutoApprovalMessage, pickApprovalButton } from './approval-utils.js';
+
+type ReadChatModal = {
+    message?: string;
+    buttons?: string[];
+    width?: number;
+    height?: number;
+};
+
+type ReadChatMessage = ChatMessage & { content: string };
+
+type ReadChatPayload = {
+    activeModal?: ReadChatModal;
+    messages?: ReadChatMessage[];
+    controlValues?: Record<string, string | number | boolean>;
+    status?: string;
+    title?: string;
+    [key: string]: unknown;
+};
 
 export class IdeProviderInstance implements ProviderInstance {
     readonly type: string;
@@ -103,6 +122,11 @@ export class IdeProviderInstance implements ProviderInstance {
 
     getState(): ProviderState {
         const cdp = this.context?.cdp;
+        const autoApproveActive = (
+            this.currentStatus === 'waiting_approval'
+            || this.cachedChat?.status === 'waiting_approval'
+        ) && this.canAutoApprove();
+        const visibleStatus = (autoApproveActive ? 'generating' : this.currentStatus) as ProviderState['status'];
 
  // Collect extension status
         const extensionStates: ProviderState[] = [];
@@ -114,13 +138,15 @@ export class IdeProviderInstance implements ProviderInstance {
             type: this.type,
             name: this.provider.name,
             category: 'ide',
-            status: this.currentStatus as ProviderState['status'],
+            status: visibleStatus,
             activeChat: this.cachedChat ? {
                 id: this.cachedChat.id || 'active_session',
                 title: this.cachedChat.title || this.type,
-                status: this.cachedChat.status || this.currentStatus,
+                status: autoApproveActive && this.cachedChat.status === 'waiting_approval'
+                    ? 'generating'
+                    : (this.cachedChat.status || visibleStatus),
                 messages: this.mergeConversationMessages(this.cachedChat.messages || []),
-                activeModal: this.cachedChat.activeModal || null,
+                activeModal: autoApproveActive ? null : (this.cachedChat.activeModal || null),
                 inputContent: this.cachedChat.inputContent || '',
             } : null,
             workspace: this.workspace || null,
@@ -130,7 +156,7 @@ export class IdeProviderInstance implements ProviderInstance {
             currentPlan: this.cachedChat?.mode || undefined,
             currentAutoApprove: this.cachedChat?.autoApprove || undefined,
             controlValues: this.cachedChat?.controlValues || undefined,
-            providerControls: this.provider.controls as any,
+            providerControls: this.provider.controls,
             instanceId: this.instanceId,
             lastUpdated: Date.now(),
             settings: this.settings,
@@ -253,14 +279,14 @@ export class IdeProviderInstance implements ProviderInstance {
         if (!cdp?.isConnected) return;
 
         try {
-            let raw: any = null;
+            let raw: unknown = null;
 
  // path 1: webview iframe internal (Kiro, PearAI etc)
-            const webviewFn = (this.provider.scripts as any)?.webviewReadChat;
+            const webviewFn = this.provider.scripts?.webviewReadChat;
             if (typeof webviewFn === 'function' && cdp.evaluateInWebviewFrame) {
                 const webviewScript = webviewFn();
                 if (webviewScript) {
-                    const matchText = (this.provider as any).webviewMatchText;
+                    const matchText = this.provider.webviewMatchText;
                     const matchFn = matchText ? (body: string) => body.includes(matchText) : undefined;
                     const webviewRaw = await cdp.evaluateInWebviewFrame(webviewScript, matchFn);
                     if (webviewRaw) {
@@ -273,16 +299,17 @@ export class IdeProviderInstance implements ProviderInstance {
             if (!raw) {
                 const readChatScript = this.getReadChatScript();
                 if (!readChatScript) return;
-                raw = await cdp.evaluate(readChatScript, 30000) as any;
+                raw = await cdp.evaluate(readChatScript, 30000);
                 if (typeof raw === 'string') {
                     try { raw = JSON.parse(raw); } catch { return; }
                 }
             }
 
             if (!raw || typeof raw !== 'object') return;
+            const chat = raw as ReadChatPayload;
 
  // Modal filter
-            let { activeModal } = raw;
+            let { activeModal } = chat;
             if (activeModal) {
                 const w = activeModal.width ?? Infinity;
                 const h = activeModal.height ?? Infinity;
@@ -304,33 +331,35 @@ export class IdeProviderInstance implements ProviderInstance {
                 if (pm.receivedAt) prevByHash.set(h, pm.receivedAt);
             }
             const now = Date.now();
-            for (const msg of (raw.messages || [])) {
+            const messages = chat.messages || [];
+            for (const msg of messages) {
                 const h = `${msg.role}:${(msg.content || '').slice(0, 100)}`;
                 msg.receivedAt = prevByHash.get(h) || now;
             }
 
             // Filter messages by provider settings (showThinking, showToolCalls, showTerminal)
-            if (raw.messages?.length > 0) {
+            if (messages.length > 0) {
                 const hiddenKinds = new Set<string>();
                 if (this.settings.showThinking === false) hiddenKinds.add('thought');
                 if (this.settings.showToolCalls === false) hiddenKinds.add('tool');
                 if (this.settings.showTerminal === false) hiddenKinds.add('terminal');
                 if (hiddenKinds.size > 0) {
-                    raw.messages = raw.messages.filter((m: any) => !hiddenKinds.has(m.kind));
+                    chat.messages = messages.filter((m) => !hiddenKinds.has(m.kind || ''));
                 }
             }
 
-            const controlValues = extractProviderControlValues(this.provider.controls, raw);
-            if (controlValues) raw.controlValues = controlValues;
+            const controlValues = extractProviderControlValues(this.provider.controls, chat);
+            if (controlValues) chat.controlValues = controlValues;
 
-            this.cachedChat = { ...raw, activeModal };
-            this.detectAgentTransitions(raw, now);
+            this.cachedChat = { ...chat, activeModal };
+            this.detectAgentTransitions(chat, now);
 
  // Save history (new messageonly append)
  // Exclude last incomplete assistant message during generating status
-            if (raw.messages?.length > 0) {
-                let toSave = raw.messages;
-                if (raw.status === 'generating' || raw.status === 'long_generating') {
+            const persistedMessages = chat.messages || messages;
+            if (persistedMessages.length > 0) {
+                let toSave = persistedMessages;
+                if (chat.status === 'generating' || chat.status === 'long_generating') {
  // Find and exclude last assistant message
                     const lastIdx = toSave.length - 1;
                     if (lastIdx >= 0 && toSave[lastIdx].role === 'assistant') {
@@ -341,7 +370,7 @@ export class IdeProviderInstance implements ProviderInstance {
                     this.historyWriter.appendNewMessages(
                         this.type,
                         toSave,
-                        raw.title,
+                        chat.title,
                         this.instanceId,
                     );
                 }
@@ -360,7 +389,7 @@ export class IdeProviderInstance implements ProviderInstance {
     private getReadChatScript(): string | null {
         const scripts = this.provider.scripts;
         if (!scripts?.readChat) return null;
-        return typeof scripts.readChat === 'function' ? scripts.readChat({}) : scripts.readChat as any;
+        return scripts.readChat({});
     }
 
  // ─── status transition detect ─────────────────────────────
@@ -370,9 +399,11 @@ export class IdeProviderInstance implements ProviderInstance {
         if (!chatStatus) return;
 
         const agentKey = `${this.type}:native`;
-        const agentStatus = (chatStatus === 'streaming' || chatStatus === 'generating') ? 'generating'
+        const rawAgentStatus = (chatStatus === 'streaming' || chatStatus === 'generating') ? 'generating'
             : chatStatus === 'waiting_approval' ? 'waiting_approval'
             : 'idle';
+        const autoApproveActive = rawAgentStatus === 'waiting_approval' && this.canAutoApprove();
+        const agentStatus = autoApproveActive ? 'generating' : rawAgentStatus;
         const lastMsg = Array.isArray(chatData?.messages) && chatData.messages.length > 0
             ? chatData.messages[chatData.messages.length - 1]
             : null;
@@ -414,7 +445,7 @@ export class IdeProviderInstance implements ProviderInstance {
         });
 
  // Auto-approve: when waiting_approval + settings.autoApprove → auto-click approve via CDP
-        if (agentStatus === 'waiting_approval' && this.settings.autoApprove && !this.autoApproveBusy) {
+        if (rawAgentStatus === 'waiting_approval' && autoApproveActive && !this.autoApproveBusy) {
             this.autoApproveViaScript(chatData);
         }
 
@@ -590,6 +621,12 @@ export class IdeProviderInstance implements ProviderInstance {
         if (this.context) this.context.cdp = cdp;
     }
 
+    private canAutoApprove(): boolean {
+        return this.settings.autoApprove !== false
+            && typeof this.provider.scripts?.resolveAction === 'function'
+            && !!this.context?.cdp?.isConnected;
+    }
+
  // ─── Auto-approve via CDP script ────────────────────
 
     private async autoApproveViaScript(_chatData: any): Promise<void> {
@@ -605,20 +642,16 @@ export class IdeProviderInstance implements ProviderInstance {
 
         this.autoApproveBusy = true;
         try {
-            let targetButton = _chatData?.activeModal?.buttons?.[0] || 'Run';
-            const buttons = _chatData?.activeModal?.buttons || [];
-            
-            // Prefer buttons like 'Run', 'Approve', 'Yes'
-            for (const b of buttons) {
-                const lower = String(b).toLowerCase().replace(/[^\w]/g, '');
-                if (/^(run|approve|accept|yes|allow|always|proceed|save)/.test(lower)) {
-                    targetButton = b;
-                    break;
-                }
-            }
+            const { label: targetButton } = pickApprovalButton(_chatData?.activeModal?.buttons, this.provider);
 
             const script = scriptFn({ action: 'approve', button: targetButton, buttonText: targetButton });
             if (!script) return;
+            const now = Date.now();
+            this.appendRuntimeSystemMessage(
+                formatAutoApprovalMessage(_chatData?.activeModal?.message, targetButton),
+                `auto_approval:${now}:${targetButton}`,
+                now,
+            );
 
             LOG.info('IdeInstance', `[IdeInstance:${this.type}] autoApprove: executing resolveAction for "${targetButton}"`);
             let rawResult = await cdp.evaluate(script, 10000);
@@ -641,13 +674,6 @@ export class IdeProviderInstance implements ProviderInstance {
                     LOG.warn('IdeInstance', `[IdeInstance:${this.type}] autoApprove: cdp.send() not available for coordinate click`);
                 }
             }
-
-            this.pushEvent({
-                event: 'agent:auto_approved',
-                chatTitle: _chatData?.title || this.provider.name,
-                timestamp: Date.now(),
-                ideType: this.type,
-            });
         } catch (e: any) {
             LOG.warn('IdeInstance', `[IdeInstance:${this.type}] autoApprove error: ${e?.message}`);
         } finally {

package/src/providers/provider-loader.ts

@@ -21,6 +21,7 @@ import { registerIDEDefinition } from '../detection/ide-detector.js';
 import { LOG } from '../logging/logger.js';
 import { VersionArchive } from './version-archive.js';
 import type {
+  ProviderCompatibilityEntry,
   ProviderModule,
   ProviderCategory,
   ProviderScripts,
@@ -43,7 +44,7 @@ export class ProviderLoader {
   private watchers: any[] = [];
   private logFn: (msg: string) => void;
   private versionArchive: VersionArchive | null = null;
-  private scriptsCache = new Map<string, Record<string, any>>();
+  private scriptsCache = new Map<string, Partial<ProviderScripts>>();
 
   /** Inject VersionArchive so resolve() can auto-detect installed versions */
   setVersionArchive(archive: VersionArchive): void {
@@ -240,10 +241,7 @@ export class ProviderLoader {
     const result: { id: string; displayName: string; icon: string; command: string; category: string; versionCommand?: string }[] = [];
     for (const p of this.providers.values()) {
       if ((p.category === 'cli' || p.category === 'acp') && p.spawn?.command) {
-        const verCmdConfig = (p as any).versionCommand;
-        const versionCommand = typeof verCmdConfig === 'object' && verCmdConfig !== null
-          ? verCmdConfig[process.platform]
-          : verCmdConfig;
+        const versionCommand = this.getPlatformVersionCommand(p.versionCommand);
         const command = this.getSpawnCommand(p.type, p.spawn.command);
         result.push({
           id: p.type,
@@ -304,8 +302,8 @@ export class ProviderLoader {
  * that runtime attach/remove uses.
  */
   getIdeExtensionEnabledState(ideType: string, extensionType: string): boolean {
-    const { loadConfig } = require('../config/config.js');
-    const config = loadConfig();
+    const config = this.readConfig();
+    if (!config) return false;
     const baseIdeType = ideType.split('_')[0];
     const val = config.ideSettings?.[baseIdeType]?.extensions?.[extensionType]?.enabled;
     return val === true;
@@ -315,15 +313,16 @@ export class ProviderLoader {
  * Save IDE extension enabled setting
  */
   setIdeExtensionEnabled(ideType: string, extensionType: string, enabled: boolean): boolean {
+    const config = this.readConfig();
+    if (!config) return false;
+
     try {
-      const { loadConfig, saveConfig } = require('../config/config.js');
-      const config = loadConfig();
       const baseIdeType = ideType.split('_')[0];
       if (!config.ideSettings) config.ideSettings = {};
       if (!config.ideSettings[baseIdeType]) config.ideSettings[baseIdeType] = {};
       if (!config.ideSettings[baseIdeType].extensions) config.ideSettings[baseIdeType].extensions = {};
       config.ideSettings[baseIdeType].extensions[extensionType] = { enabled };
-      saveConfig(config);
+      this.writeConfig(config);
       this.log(`IDE extension setting: ${ideType}.${extensionType}.enabled = ${enabled}`);
       return true;
     } catch (e) {
@@ -545,8 +544,8 @@ export class ProviderLoader {
       resolved._resolvedVersion = currentVersion;
 
       // --- New format: compatibility array ---
-      if (Array.isArray((base as any).compatibility)) {
-        const compat = (base as any).compatibility as { ideVersion: string; scriptDir: string }[];
+      if (base.compatibility) {
+        const compat = base.compatibility;
         let matched = false;
 
         for (const entry of compat) {
@@ -570,15 +569,15 @@ export class ProviderLoader {
         }
 
         // No compatibility match → defaultScriptDir
-        if (!matched && (base as any).defaultScriptDir) {
-          const loaded = this.loadScriptsFromDir(type, (base as any).defaultScriptDir);
+        if (!matched && base.defaultScriptDir) {
+          const loaded = this.loadScriptsFromDir(type, base.defaultScriptDir);
           if (loaded) {
             resolved.scripts = loaded;
-            this.log(`  [compatibility] ${type} v${currentVersion} → default: ${(base as any).defaultScriptDir}`);
-            resolved._resolvedScriptDir = (base as any).defaultScriptDir;
+            this.log(`  [compatibility] ${type} v${currentVersion} → default: ${base.defaultScriptDir}`);
+            resolved._resolvedScriptDir = base.defaultScriptDir;
             resolved._resolvedScriptsSource = 'defaultScriptDir:version_miss';
             if (providerDir) {
-              const fullDir = path.join(providerDir, (base as any).defaultScriptDir);
+              const fullDir = path.join(providerDir, base.defaultScriptDir);
               resolved._resolvedScriptsPath = fs.existsSync(path.join(fullDir, 'scripts.js'))
                 ? path.join(fullDir, 'scripts.js')
                 : fullDir;
@@ -592,7 +591,7 @@ export class ProviderLoader {
         for (const [range, override] of Object.entries(base.versions)) {
           if (!this.matchesVersion(currentVersion, range)) continue;
 
-          const dirOverride = (override as any).__dir as string | undefined;
+          const dirOverride = override.__dir;
           if (dirOverride) {
             const loaded = this.loadScriptsFromDir(type, dirOverride);
             if (loaded) {
@@ -612,16 +611,16 @@ export class ProviderLoader {
           }
         }
       }
-    } else if (Array.isArray((base as any).compatibility) && (base as any).defaultScriptDir) {
+    } else if (base.compatibility && base.defaultScriptDir) {
       // No version detected but compatibility format → use defaultScriptDir
-      const loaded = this.loadScriptsFromDir(type, (base as any).defaultScriptDir);
+      const loaded = this.loadScriptsFromDir(type, base.defaultScriptDir);
       if (loaded) {
         resolved.scripts = loaded;
-        this.log(`  [compatibility] ${type} no version detected → default: ${(base as any).defaultScriptDir}`);
-        resolved._resolvedScriptDir = (base as any).defaultScriptDir;
+        this.log(`  [compatibility] ${type} no version detected → default: ${base.defaultScriptDir}`);
+        resolved._resolvedScriptDir = base.defaultScriptDir;
         resolved._resolvedScriptsSource = 'defaultScriptDir:no_version';
         if (providerDir) {
-          const fullDir = path.join(providerDir, (base as any).defaultScriptDir);
+          const fullDir = path.join(providerDir, base.defaultScriptDir);
           resolved._resolvedScriptsPath = fs.existsSync(path.join(fullDir, 'scripts.js'))
             ? path.join(fullDir, 'scripts.js')
             : fullDir;
@@ -647,7 +646,7 @@ export class ProviderLoader {
   * Load scripts from a scriptDir within a provider directory.
   * Tries scripts.js first, then individual .js files.
   */
-  private loadScriptsFromDir(type: string, scriptDir: string): Record<string, any> | null {
+  private loadScriptsFromDir(type: string, scriptDir: string): Partial<ProviderScripts> | null {
     const providerDir = this.findProviderDirInternal(type);
     if (!providerDir) {
       this.log(`  [loadScriptsFromDir] ${type}: providerDir not found`);
@@ -679,7 +678,7 @@ export class ProviderLoader {
     }
 
     // Fallback: build from individual .js files
-    const result = this.buildScriptWrappersFromDir(dir) as Record<string, any>;
+    const result = this.buildScriptWrappersFromDir(dir);
     this.scriptsCache.set(dir, result);
     return result;
   }
@@ -973,8 +972,8 @@ export class ProviderLoader {
   getPublicSettings(type: string): ProviderSettingSchema[] {
     const settings = this.getSettingsSchema(type);
     return Object.entries(settings)
-      .filter(([, def]) => (def as any).public === true)
-      .map(([key, def]) => ({ key, ...(def as any) }));
+      .filter(([, def]) => def.public === true)
+      .map(([key, def]) => ({ key, ...def }));
   }
 
  /**
@@ -994,17 +993,15 @@ export class ProviderLoader {
  */
   getSettingValue(type: string, key: string): any {
     const schemaDef = this.getSettingsSchema(type)[key];
-    const defaultVal = schemaDef ? (schemaDef as any).default : undefined;
-
- // Load user-saved value
-    try {
-      const { loadConfig } = require('../config/config.js');
-      const config = loadConfig();
-      const userVal = config.providerSettings?.[type]?.[key];
-      return userVal !== undefined ? userVal : defaultVal;
-    } catch {
-      return defaultVal;
-    }
+    const defaultVal = schemaDef
+      ? (key === 'autoApprove' && schemaDef.type === 'boolean'
+        ? true
+        : schemaDef.default)
+      : undefined;
+
+    const config = this.readConfig();
+    const userVal = config?.providerSettings?.[type]?.[key];
+    return userVal !== undefined ? userVal : defaultVal;
   }
 
  /**
@@ -1023,7 +1020,7 @@ export class ProviderLoader {
  * Save provider setting value (writes to config.json)
  */
   setSetting(type: string, key: string, value: any): boolean {
-    const schemaDef = this.getSettingsSchema(type)[key] as any;
+    const schemaDef = this.getSettingsSchema(type)[key];
     if (!schemaDef) return false;
 
  // Non-public settings cannot be modified externally
@@ -1039,13 +1036,14 @@ export class ProviderLoader {
     }
     if (schemaDef.type === 'select' && schemaDef.options && !schemaDef.options.includes(value)) return false;
 
+    const config = this.readConfig();
+    if (!config) return false;
+
     try {
-      const { loadConfig, saveConfig } = require('../config/config.js');
-      const config = loadConfig();
       if (!config.providerSettings) config.providerSettings = {};
       if (!config.providerSettings[type]) config.providerSettings[type] = {};
       config.providerSettings[type][key] = value;
-      saveConfig(config);
+      this.writeConfig(config);
       this.log(`Setting updated: ${type}.${key} = ${JSON.stringify(value)}`);
       return true;
     } catch (e) {
@@ -1061,18 +1059,69 @@ export class ProviderLoader {
     return trimmed ? trimmed : null;
   }
 
+  protected readConfig(): any | null {
+    try {
+      const { loadConfig } = require('../config/config.js');
+      return loadConfig();
+    } catch {
+      return null;
+    }
+  }
+
+  protected writeConfig(config: any): void {
+    const { saveConfig } = require('../config/config.js');
+    saveConfig(config);
+  }
+
+  private getPlatformVersionCommand(versionCommand?: ProviderModule['versionCommand']): string | undefined {
+    if (!versionCommand) return undefined;
+    if (typeof versionCommand === 'string') {
+      const trimmed = versionCommand.trim();
+      return trimmed || undefined;
+    }
+    const platformValue = versionCommand[process.platform];
+    if (typeof platformValue === 'string' && platformValue.trim()) {
+      return platformValue.trim();
+    }
+    const defaultValue = versionCommand.default;
+    if (typeof defaultValue === 'string' && defaultValue.trim()) {
+      return defaultValue.trim();
+    }
+    return undefined;
+  }
+
   private getSettingsSchema(type: string): Record<string, ProviderSettingDef> {
     const provider = this.providers.get(type);
     if (!provider) return {};
-    return {
+    const result = {
       ...this.getSyntheticSettings(type, provider),
       ...(provider.settings || {}),
     };
+    if (result.autoApprove?.type === 'boolean') {
+      result.autoApprove = {
+        ...result.autoApprove,
+        default: true,
+        public: true,
+        label: result.autoApprove.label || 'Auto Approve',
+        description: result.autoApprove.description || 'Automatically approve actionable prompts without sending approval alerts.',
+      };
+    }
+    return result;
   }
 
   private getSyntheticSettings(type: string, provider: ProviderModule): Record<string, ProviderSettingDef> {
     const result: Record<string, ProviderSettingDef> = {};
 
+    if (!provider.settings?.autoApprove) {
+      result.autoApprove = {
+        type: 'boolean',
+        default: true,
+        public: true,
+        label: 'Auto Approve',
+        description: 'Automatically approve actionable prompts without sending approval alerts.',
+      };
+    }
+
     if ((provider.category === 'cli' || provider.category === 'acp') && provider.spawn?.command && !provider.settings?.executablePath) {
       result.executablePath = {
         type: 'string',
@@ -1168,7 +1217,7 @@ export class ProviderLoader {
         if (!file.endsWith('.js')) continue;
         const scriptName = toCamel(file.replace('.js', ''));
         const filePath = path.join(dir, file);
-        (result as any)[scriptName] = (...args: any[]): string => {
+        result[scriptName] = (...args: any[]): string => {
           try {
             let content = fs.readFileSync(filePath, 'utf-8');
             if (args[0] && typeof args[0] === 'object') {
@@ -1235,40 +1284,46 @@ export class ProviderLoader {
         const jsonPath = path.join(d, 'provider.json');
         try {
           const raw = fs.readFileSync(jsonPath, 'utf-8');
-          const mod = JSON.parse(raw) as ProviderModule;
+          const mod = JSON.parse(raw) as Omit<ProviderModule, 'extensionIdPattern'> & {
+            extensionIdPattern?: RegExp | string;
+          };
 
           if (!mod.type || !mod.name || !mod.category) {
             this.log(`⚠ Invalid provider at ${jsonPath}: missing type/name/category`);
           } else {
             // Restore RegExp fields from JSON (extensionIdPattern)
-            if ((mod as any).extensionIdPattern && typeof (mod as any).extensionIdPattern === 'string') {
-              const flags = (mod as any).extensionIdPattern_flags || '';
-              (mod as any).extensionIdPattern = new RegExp((mod as any).extensionIdPattern, flags);
-              delete (mod as any).extensionIdPattern_flags;
+            if (typeof mod.extensionIdPattern === 'string') {
+              const flags = mod.extensionIdPattern_flags || '';
+              mod.extensionIdPattern = new RegExp(mod.extensionIdPattern, flags);
             }
+            const { extensionIdPattern_flags, extensionIdPattern, ...providerFields } = mod;
+            const normalizedProvider: ProviderModule = {
+              ...providerFields,
+              ...(extensionIdPattern instanceof RegExp ? { extensionIdPattern } : {}),
+            };
 
             // Load scripts.js if exists (IDE/Extension)
             // Skip for compatibility-format providers — scripts loaded lazily in resolve()
-            const hasCompatibility = Array.isArray((mod as any).compatibility);
+            const hasCompatibility = Array.isArray(normalizedProvider.compatibility);
             const scriptsPath = path.join(d, 'scripts.js');
             if (!hasCompatibility && fs.existsSync(scriptsPath)) {
               try {
                 delete require.cache[require.resolve(scriptsPath)];
-                const scripts = require(scriptsPath);
-                mod.scripts = scripts;
+                const scripts = require(scriptsPath) as Partial<ProviderScripts>;
+                normalizedProvider.scripts = scripts;
               } catch (e) {
                 this.log(`⚠ Failed to load scripts: ${scriptsPath}: ${(e as Error).message}`);
               }
             }
 
-            const existed = this.providers.has(mod.type);
-            this.providers.set(mod.type, mod);
+            const existed = this.providers.has(normalizedProvider.type);
+            this.providers.set(normalizedProvider.type, normalizedProvider);
             count++;
             // Identify source tier for debugging
             const source = d.startsWith(this.userDir) && !d.includes('.upstream')
               ? 'user' : 'upstream';
             const overrideWarning = existed && source === 'user' ? ' ⚠ OVERRIDES upstream' : '';
-            this.log(`  ${existed ? '🔄' : '✅'} ${mod.type} (${mod.category}) — ${mod.name} [${source}]${overrideWarning}`);
+            this.log(`  ${existed ? '🔄' : '✅'} ${normalizedProvider.type} (${normalizedProvider.category}) — ${normalizedProvider.name} [${source}]${overrideWarning}`);
           }
         } catch (e) {
           this.log(`⚠ Failed to load ${jsonPath}: ${(e as Error).message}`);

package/src/providers/version-archive.ts

@@ -15,6 +15,7 @@ import * as os from 'os';
 import { execSync } from 'child_process';
 import { platform } from 'os';
 import type { ProviderLoader } from './provider-loader.js';
+import type { ProviderModule } from './contracts.js';
 
 // ─── Types ──────────────────────────────────────
 
@@ -141,6 +142,26 @@ function parseVersion(raw: string): string {
   return match ? match[1] : raw.split('\n')[0].substring(0, 100);
 }
 
+function getPlatformVersionCommand(
+  versionCommand: ProviderModule['versionCommand'],
+  currentOs: string,
+): string | undefined {
+  if (!versionCommand) return undefined;
+  if (typeof versionCommand === 'string') {
+    const trimmed = versionCommand.trim();
+    return trimmed || undefined;
+  }
+  const platformValue = versionCommand[currentOs];
+  if (typeof platformValue === 'string' && platformValue.trim()) {
+    return platformValue.trim();
+  }
+  const defaultValue = versionCommand.default;
+  if (typeof defaultValue === 'string' && defaultValue.trim()) {
+    return defaultValue.trim();
+  }
+  return undefined;
+}
+
 function getVersion(binary: string, versionCommand?: string): string | null {
   // Custom version command from provider.json
   if (versionCommand) {
@@ -200,10 +221,7 @@ export async function detectAllVersions(
       detectedAt: new Date().toISOString(),
     };
 
-    const verCmdConfig = (provider as any).versionCommand;
-    const versionCommand = typeof verCmdConfig === 'object' && verCmdConfig !== null 
-      ? verCmdConfig[currentOs] 
-      : verCmdConfig;
+    const versionCommand = getPlatformVersionCommand(provider.versionCommand, currentOs);
 
     if (provider.category === 'ide') {
       // IDE: check app path + CLI
@@ -256,7 +274,7 @@ export async function detectAllVersions(
 
     // Check testedVersions — warn if installed version is not documented
     if (info.version && info.installed) {
-      const testedVersions: string[] = (provider as any).testedVersions || [];
+      const testedVersions = provider.testedVersions || [];
       if (testedVersions.length > 0 && !testedVersions.includes(info.version)) {
         info.warning = `Version ${info.version} is not in testedVersions [${testedVersions.join(', ')}]. Scripts may not work correctly.`;
       }