@adhdev/daemon-core 0.8.30 → 0.8.32

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 }));
   }
 
  /**
@@ -995,20 +994,14 @@ export class ProviderLoader {
   getSettingValue(type: string, key: string): any {
     const schemaDef = this.getSettingsSchema(type)[key];
     const defaultVal = schemaDef
-      ? (key === 'autoApprove' && (schemaDef as any).type === 'boolean'
+      ? (key === 'autoApprove' && schemaDef.type === 'boolean'
         ? true
-        : (schemaDef as any).default)
+        : schemaDef.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 config = this.readConfig();
+    const userVal = config?.providerSettings?.[type]?.[key];
+    return userVal !== undefined ? userVal : defaultVal;
   }
 
  /**
@@ -1027,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
@@ -1043,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) {
@@ -1065,6 +1059,37 @@ 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 {};
@@ -1192,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') {
@@ -1259,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.`;
       }

package/src/status/reporter.ts

@@ -6,6 +6,8 @@
  */
 
 import { LOG } from '../logging/logger.js';
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { MachineInfo } from '../shared-types.js';
 import { buildSessionEntries } from './builders.js';
 import { buildStatusSnapshot } from './snapshot.js';
 import type {
@@ -19,7 +21,7 @@ import type {
 
 export interface StatusReporterDeps {
     serverConn: { isConnected(): boolean; sendMessage(type: string, data: any): void; getUserPlan(): string } | null;
-    cdpManagers: Map<string, { isConnected: boolean }>;
+    cdpManagers: Map<string, DaemonCdpManager>;
     p2p: { isConnected: boolean; isAvailable: boolean; connectionState: string; connectedPeerCount: number; screenshotActive: boolean; sendStatus(data: any): void } | null;
     providerLoader: { resolve(type: string): any; getAll(): any[] };
     detectedIdes: any[];
@@ -65,7 +67,7 @@ export class DaemonStatusReporter {
             if (this.deps.p2p?.isConnected) {
                 this.sendUnifiedStatusReport({ p2pOnly: true }).catch(e => LOG.warn('Status', `P2P status send failed: ${e?.message}`));
             }
-        }, 5_000) as any;
+        }, 5_000);
     }
 
     stopReporting(): void {
@@ -174,14 +176,14 @@ export class DaemonStatusReporter {
  // IDE/CLI/ACP states → managed entries (shared builder)
         const sessions = buildSessionEntries(
             allStates,
-            this.deps.cdpManagers as Map<string, any>,
+            this.deps.cdpManagers,
         );
 
  // ═══ Assemble payload (P2P — required data only) ═══
         const payload: Record<string, any> = {
             ...buildStatusSnapshot({
                 allStates,
-                cdpManagers: this.deps.cdpManagers as Map<string, unknown>,
+                cdpManagers: this.deps.cdpManagers,
                 providerLoader: this.deps.providerLoader,
                 detectedIdes: this.deps.detectedIdes || [],
                 instanceId: this.deps.instanceId,
@@ -231,10 +233,10 @@ export class DaemonStatusReporter {
                 currentPlan: session.currentPlan,
                 currentAutoApprove: session.currentAutoApprove,
                 lastUpdated: session.lastUpdated,
-                unread: (session as any).unread,
-                lastSeenAt: (session as any).lastSeenAt,
-                inboxBucket: (session as any).inboxBucket,
-                surfaceHidden: (session as any).surfaceHidden,
+                unread: session.unread,
+                lastSeenAt: session.lastSeenAt,
+                inboxBucket: session.inboxBucket,
+                surfaceHidden: session.surfaceHidden,
                 controlValues: session.controlValues,
                 providerControls: session.providerControls,
                 acpConfigOptions: session.acpConfigOptions,
@@ -251,13 +253,15 @@ export class DaemonStatusReporter {
 
  // ─── P2P ─────────────────────────────────────────
 
-    private sendP2PPayload(payload: Record<string, any>): boolean {
+    private sendP2PPayload(payload: { timestamp?: number; system?: unknown; machine?: MachineInfo; [key: string]: unknown }): boolean {
         const { timestamp: _ts, system: _sys, ...hashTarget } = payload;
-        if (hashTarget.machine) {
-            const { freeMem: _f, availableMem: _a, loadavg: _l, uptime: _u, ...stableMachine } = hashTarget.machine as any;
-            hashTarget.machine = stableMachine;
-        }
-        const h = this.simpleHash(JSON.stringify(hashTarget));
+        const hashPayload = hashTarget.machine
+            ? (() => {
+                const { freeMem: _f, availableMem: _a, loadavg: _l, uptime: _u, ...stableMachine } = hashTarget.machine;
+                return { ...hashTarget, machine: stableMachine };
+            })()
+            : hashTarget;
+        const h = this.simpleHash(JSON.stringify(hashPayload));
         if (h !== this.lastP2PStatusHash) {
             this.lastP2PStatusHash = h;
             this.deps.p2p?.sendStatus(payload);

package/src/status/snapshot.ts

@@ -14,6 +14,7 @@ import { getWorkspaceState } from '../config/workspaces.js';
 import { getHostMemorySnapshot } from '../system/host-memory.js';
 import { getTerminalBackendRuntimeStatus } from '../cli-adapters/terminal-screen.js';
 import { LOG } from '../logging/logger.js';
+import type { DaemonCdpManager } from '../cdp/manager.js';
 import { buildSessionEntries, isCdpConnected } from './builders.js';
 import type { ProviderState } from '../providers/provider-instance.js';
 import type {
@@ -27,7 +28,7 @@ import type {
 
 export interface StatusSnapshotOptions {
     allStates: ProviderState[];
-    cdpManagers: Map<string, unknown>;
+    cdpManagers: Map<string, DaemonCdpManager>;
     providerLoader: {
         getAll(): Array<{
             type: string;
@@ -75,7 +76,7 @@ function buildDetectedIdeInfos(
             id: ide.id,
             type: ide.id,
             name: ide.displayName || ide.name || ide.id,
-            running: isCdpConnected(cdpManagers as Map<string, any>, ide.id),
+            running: isCdpConnected(cdpManagers, ide.id),
             ...(ide.path ? { path: ide.path } : {}),
         }));
 }
@@ -132,7 +133,7 @@ export function getSessionCompletionMarker(session: {
         }> | null
     } | null
 }) {
-    const lastMessage = session.activeChat?.messages?.at?.(-1) as any;
+    const lastMessage = session.activeChat?.messages?.at?.(-1);
     if (!lastMessage) return '';
     const role = typeof lastMessage.role === 'string' ? lastMessage.role : '';
     if (role === 'user' || role === 'human' || role === 'system') return '';
@@ -213,7 +214,7 @@ export function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnaps
     const recentActivity = getRecentActivity(state, 20);
     const sessions = buildSessionEntries(
         options.allStates,
-        options.cdpManagers as Map<string, any>,
+        options.cdpManagers,
     );
     for (const session of sessions) {
         const lastSeenAt = getSessionSeenAt(state, session.id);