@adhdev/daemon-core 0.8.25 → 0.8.28

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

@@ -25,6 +25,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
     private currentStatus: string = 'idle';
     private agentStreams: any[] = [];
     private messages: any[] = [];
+    private prevMessageHashes = new Map<string, number>();
     private activeModal: any = null;
     private currentModel: string = '';
     private currentMode: string = '';
@@ -104,7 +105,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
         if (event === 'stream_update') {
  // Reflect data collected from agent-stream-manager
             if (data?.streams) this.agentStreams = data.streams;
-            if (data?.messages) this.messages = data.messages;
+            if (data?.messages) this.messages = this.assignReceivedAt(data.messages);
             if (data?.activeModal !== undefined) this.activeModal = data.activeModal;
             if (data?.model) this.currentModel = data.model;
             if (data?.mode) this.currentMode = data.mode;
@@ -132,6 +133,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
     dispose(): void {
         this.agentStreams = [];
         this.messages = [];
+        this.prevMessageHashes.clear();
         this.monitor.reset();
         this.appliedEffectKeys.clear();
         this.runtimeMessages = [];
@@ -315,6 +317,26 @@ export class ExtensionProviderInstance implements ProviderInstance {
         );
     }
 
+    /**
+     * Assign stable receivedAt to extension messages.
+     * Same pattern as IdeProviderInstance.readChat() prevByHash —
+     * preserves first-seen timestamp across polling cycles.
+     */
+    private assignReceivedAt(messages: any[]): any[] {
+        const now = Date.now();
+        const nextHashes = new Map<string, number>();
+
+        for (const msg of messages) {
+            const hash = `${msg.role}:${(msg.content || '').slice(0, 100)}`;
+            const prevTime = this.prevMessageHashes.get(hash);
+            msg.receivedAt = prevTime || now;
+            nextHashes.set(hash, msg.receivedAt);
+        }
+
+        this.prevMessageHashes = nextHashes;
+        return messages;
+    }
+
     private mergeConversationMessages(messages: any[]): ChatMessage[] {
         if (this.runtimeMessages.length === 0) return messages;
         return [...messages, ...this.runtimeMessages.map((entry) => entry.message)]
@@ -382,6 +404,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
         }
         this.agentStreams = [];
         this.messages = [];
+        this.prevMessageHashes.clear();
         this.activeModal = null;
         this.currentModel = '';
         this.currentMode = '';

package/src/providers/provider-loader.ts

@@ -24,12 +24,19 @@ import type {
   ProviderModule,
   ProviderCategory,
   ProviderScripts,
+  ProviderSettingDef,
   ProviderSettingSchema,
   ResolvedProvider,
 } from './contracts.js';
 
+interface ProviderAvailabilityState {
+  installed: boolean;
+  detectedPath: string | null;
+}
+
 export class ProviderLoader {
   private providers = new Map<string, ProviderModule>();
+  private providerAvailability = new Map<string, ProviderAvailabilityState>();
   private userDir: string;
   private upstreamDir: string;
   private disableUpstream: boolean;
@@ -152,6 +159,7 @@ export class ProviderLoader {
  */
   loadAll(): void {
     this.providers.clear();
+    this.providerAvailability.clear();
 
  // 1. Load upstream (GitHub auto-download — primary source)
     let upstreamCount = 0;
@@ -236,11 +244,12 @@ export class ProviderLoader {
         const versionCommand = typeof verCmdConfig === 'object' && verCmdConfig !== null
           ? verCmdConfig[process.platform]
           : verCmdConfig;
+        const command = this.getSpawnCommand(p.type, p.spawn.command);
         result.push({
           id: p.type,
           displayName: p.displayName || p.name,
           icon: p.icon || '🔧',
-          command: p.spawn.command,
+          command,
           category: p.category,
           ...(typeof versionCommand === 'string' && versionCommand.trim()
             ? { versionCommand: versionCommand.trim() }
@@ -386,6 +395,80 @@ export class ProviderLoader {
       .map(p => p.type);
   }
 
+  getSpawnCommand(type: string, fallback?: string): string {
+    const override = this.getOptionalStringSetting(type, 'executablePath');
+    if (override) return override;
+    return fallback || this.providers.get(type)?.spawn?.command || type;
+  }
+
+  getIdeCliCommand(type: string, fallback?: string | null): string | null {
+    const override = this.getOptionalStringSetting(type, 'cliPathOverride');
+    if (override) return override;
+    return fallback || this.providers.get(type)?.cli || null;
+  }
+
+  getIdePathCandidates(type: string, fallback?: string[]): string[] {
+    const override = this.getOptionalStringSetting(type, 'appPathOverride');
+    if (override) return [override];
+    if (fallback && fallback.length > 0) return fallback;
+    const osPaths = this.providers.get(type)?.paths?.[process.platform];
+    return Array.isArray(osPaths) ? [...osPaths] : [];
+  }
+
+  setProviderAvailability(type: string, state: { installed: boolean; detectedPath?: string | null }): void {
+    this.providerAvailability.set(type, {
+      installed: !!state.installed,
+      detectedPath: state.detectedPath ?? null,
+    });
+  }
+
+  setCliDetectionResults(results: Array<{ id: string; installed: boolean; path?: string }>, replace: boolean = true): void {
+    if (replace) {
+      for (const provider of this.providers.values()) {
+        if (provider.category === 'cli' || provider.category === 'acp') {
+          this.providerAvailability.set(provider.type, { installed: false, detectedPath: null });
+        }
+      }
+    }
+    for (const result of results) {
+      this.setProviderAvailability(result.id, {
+        installed: !!result.installed,
+        detectedPath: result.path || null,
+      });
+    }
+  }
+
+  setIdeDetectionResults(results: Array<{ id: string; installed: boolean; path?: string | null; cliCommand?: string | null }>, replace: boolean = true): void {
+    if (replace) {
+      for (const provider of this.providers.values()) {
+        if (provider.category === 'ide') {
+          this.providerAvailability.set(provider.type, { installed: false, detectedPath: null });
+        }
+      }
+    }
+    for (const result of results) {
+      this.setProviderAvailability(result.id, {
+        installed: !!result.installed,
+        detectedPath: result.cliCommand || result.path || null,
+      });
+    }
+  }
+
+  getAvailableProviderInfos(): Array<ProviderModule & { installed?: boolean; detectedPath?: string | null }> {
+    return this.getAll().map((provider) => {
+      const availability = this.providerAvailability.get(provider.type);
+      return {
+        ...provider,
+        ...(availability
+          ? {
+              installed: availability.installed,
+              detectedPath: availability.detectedPath,
+            }
+          : {}),
+      };
+    });
+  }
+
  /**
  * Register IDE providers to core/detector registry
  * → Enables detectIDEs() to detect provider.js-based IDEs
@@ -888,9 +971,8 @@ export class ProviderLoader {
  * Get public settings schema for a provider (for dashboard UI rendering)
  */
   getPublicSettings(type: string): ProviderSettingSchema[] {
-    const provider = this.providers.get(type);
-    if (!provider?.settings) return [];
-    return Object.entries(provider.settings)
+    const settings = this.getSettingsSchema(type);
+    return Object.entries(settings)
       .filter(([, def]) => (def as any).public === true)
       .map(([key, def]) => ({ key, ...(def as any) }));
   }
@@ -911,8 +993,7 @@ export class ProviderLoader {
  * Resolved setting value for a provider (default + user override)
  */
   getSettingValue(type: string, key: string): any {
-    const provider = this.providers.get(type);
-    const schemaDef = provider?.settings?.[key];
+    const schemaDef = this.getSettingsSchema(type)[key];
     const defaultVal = schemaDef ? (schemaDef as any).default : undefined;
 
  // Load user-saved value
@@ -930,10 +1011,9 @@ export class ProviderLoader {
  * All resolved settings for a provider (default + user override)
  */
   getSettings(type: string): Record<string, any> {
-    const provider = this.providers.get(type);
-    if (!provider?.settings) return {};
+    const settings = this.getSettingsSchema(type);
     const result: Record<string, any> = {};
-    for (const [key, def] of Object.entries(provider.settings)) {
+    for (const [key] of Object.entries(settings)) {
       result[key] = this.getSettingValue(type, key);
     }
     return result;
@@ -943,8 +1023,7 @@ export class ProviderLoader {
  * Save provider setting value (writes to config.json)
  */
   setSetting(type: string, key: string, value: any): boolean {
-    const provider = this.providers.get(type);
-    const schemaDef = provider?.settings?.[key] as any;
+    const schemaDef = this.getSettingsSchema(type)[key] as any;
     if (!schemaDef) return false;
 
  // Non-public settings cannot be modified externally
@@ -952,6 +1031,7 @@ export class ProviderLoader {
 
  // Type validation
     if (schemaDef.type === 'boolean' && typeof value !== 'boolean') return false;
+    if (schemaDef.type === 'string' && typeof value !== 'string') return false;
     if (schemaDef.type === 'number') {
       if (typeof value !== 'number') return false;
       if (schemaDef.min !== undefined && value < schemaDef.min) return false;
@@ -974,6 +1054,59 @@ export class ProviderLoader {
     }
   }
 
+  private getOptionalStringSetting(type: string, key: string): string | null {
+    const value = this.getSettingValue(type, key);
+    if (typeof value !== 'string') return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+  }
+
+  private getSettingsSchema(type: string): Record<string, ProviderSettingDef> {
+    const provider = this.providers.get(type);
+    if (!provider) return {};
+    return {
+      ...this.getSyntheticSettings(type, provider),
+      ...(provider.settings || {}),
+    };
+  }
+
+  private getSyntheticSettings(type: string, provider: ProviderModule): Record<string, ProviderSettingDef> {
+    const result: Record<string, ProviderSettingDef> = {};
+
+    if ((provider.category === 'cli' || provider.category === 'acp') && provider.spawn?.command && !provider.settings?.executablePath) {
+      result.executablePath = {
+        type: 'string',
+        default: '',
+        public: true,
+        label: 'Executable path',
+        description: 'Optional absolute path for this provider binary. Leave blank to use the default PATH lookup.',
+      };
+    }
+
+    if (provider.category === 'ide') {
+      if (provider.cli && !provider.settings?.cliPathOverride) {
+        result.cliPathOverride = {
+          type: 'string',
+          default: '',
+          public: true,
+          label: 'CLI path override',
+          description: 'Optional absolute path for the IDE CLI launcher. Leave blank to use the detected default.',
+        };
+      }
+      if (provider.paths && !provider.settings?.appPathOverride) {
+        result.appPathOverride = {
+          type: 'string',
+          default: '',
+          public: true,
+          label: 'App path override',
+          description: 'Optional absolute path for the IDE app bundle or executable. Leave blank to use the default install locations.',
+        };
+      }
+    }
+
+    return result;
+  }
+
  // ─── Private ───────────────────────────────────
 
   /**

package/src/shared-types.ts

@@ -136,6 +136,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) */

package/src/status/normalize.ts

@@ -64,6 +64,23 @@ function trimMessageForStatus(message: unknown, stringLimit: number): unknown {
     return trimStructuredStrings(message, stringLimit);
 }
 
+/**
+ * Collapse timestamp / createdAt into receivedAt so downstream consumers
+ * only ever need to read a single canonical time field.
+ */
+function normalizeMessageTime(message: unknown): unknown {
+    if (!message || typeof message !== 'object') return message;
+    const msg = message as Record<string, unknown>;
+    if (msg.receivedAt == null) {
+        const fallback = msg.timestamp ?? msg.createdAt;
+        if (fallback != null) {
+            const ts = typeof fallback === 'string' ? Date.parse(fallback as string) : Number(fallback);
+            if (Number.isFinite(ts) && ts > 0) msg.receivedAt = ts;
+        }
+    }
+    return msg;
+}
+
 function trimMessagesForStatus(messages: unknown[] | null | undefined): unknown[] {
     if (!Array.isArray(messages) || messages.length === 0) return [];
 
@@ -72,11 +89,11 @@ function trimMessagesForStatus(messages: unknown[] | null | undefined): unknown[
     let totalBytes = 0;
 
     for (let i = recent.length - 1; i >= 0; i -= 1) {
-        let normalized = trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_STRING_LIMIT);
+        let normalized = normalizeMessageTime(trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_STRING_LIMIT));
         let size = estimateBytes(normalized);
 
         if (size > STATUS_ACTIVE_CHAT_TOTAL_BYTES_LIMIT) {
-            normalized = trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT);
+            normalized = normalizeMessageTime(trimMessageForStatus(recent[i], STATUS_ACTIVE_CHAT_FALLBACK_STRING_LIMIT));
             size = estimateBytes(normalized);
         }
 

package/src/status/snapshot.ts

@@ -35,6 +35,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;
@@ -75,12 +83,22 @@ function buildDetectedIdeInfos(
 function buildAvailableProviders(
     providerLoader: StatusSnapshotOptions['providerLoader'],
 ): AvailableProviderInfo[] {
-    return providerLoader.getAll().map((provider) => ({
+    const providers: Array<{
+        type: string;
+        icon?: string;
+        displayName?: string;
+        category: 'ide' | 'extension' | 'cli' | 'acp';
+        installed?: boolean;
+        detectedPath?: string | null;
+    }> = providerLoader.getAvailableProviderInfos?.() || providerLoader.getAll();
+    return providers.map((provider) => ({
         type: provider.type,
         name: provider.displayName || provider.type,
         displayName: provider.displayName || provider.type,
         icon: provider.icon || '💻',
         category: provider.category,
+        ...(provider.installed !== undefined ? { installed: provider.installed } : {}),
+        ...(provider.detectedPath !== undefined ? { detectedPath: provider.detectedPath } : {}),
     }));
 }
 
@@ -95,17 +113,12 @@ function parseMessageTime(value: unknown): number {
 
 function getSessionMessageUpdatedAt(session: {
     activeChat?: {
-        messages?: Array<{ timestamp?: number | string; receivedAt?: number | string; createdAt?: number | string }> | null
+        messages?: Array<{ receivedAt?: number | string }> | null
     } | null
 }) {
     const lastMessage = session.activeChat?.messages?.at?.(-1);
     if (!lastMessage) return 0;
-    return (
-        parseMessageTime(lastMessage.timestamp)
-        || parseMessageTime(lastMessage.receivedAt)
-        || parseMessageTime(lastMessage.createdAt)
-        || 0
-    );
+    return parseMessageTime(lastMessage.receivedAt) || 0;
 }
 
 export function getSessionCompletionMarker(session: {
@@ -114,9 +127,7 @@ export function getSessionCompletionMarker(session: {
             role?: string;
             id?: string;
             index?: number;
-            timestamp?: number | string;
             receivedAt?: number | string;
-            createdAt?: number | string;
             _turnKey?: string;
         }> | null
     } | null
@@ -124,17 +135,17 @@ export function getSessionCompletionMarker(session: {
     const lastMessage = session.activeChat?.messages?.at?.(-1) as any;
     if (!lastMessage) return '';
     const role = typeof lastMessage.role === 'string' ? lastMessage.role : '';
-    if (role === 'user' || role === 'human') return '';
+    if (role === 'user' || role === 'human' || role === 'system') return '';
     if (typeof lastMessage._turnKey === 'string' && lastMessage._turnKey) return `turn:${lastMessage._turnKey}`;
     if (typeof lastMessage.id === 'string' && lastMessage.id) return `id:${lastMessage.id}`;
     if (typeof lastMessage.index === 'number' && Number.isFinite(lastMessage.index)) return `idx:${lastMessage.index}`;
-    const timestamp = parseMessageTime(lastMessage.timestamp) || parseMessageTime(lastMessage.receivedAt) || parseMessageTime(lastMessage.createdAt);
+    const timestamp = parseMessageTime(lastMessage.receivedAt);
     return timestamp > 0 ? `ts:${timestamp}` : '';
 }
 
 function getSessionLastUsedAt(session: {
     activeChat?: {
-        messages?: Array<{ timestamp?: number | string; receivedAt?: number | string; createdAt?: number | string }> | null
+        messages?: Array<{ receivedAt?: number | string }> | null
     } | null
     lastUpdated?: number
 }) {
@@ -171,7 +182,7 @@ function getUnreadState(
     }
     const unread = completionMarker
         ? completionMarker !== seenCompletionMarker
-        : hasContentChange && lastUsedAt > lastSeenAt && lastRole !== 'user' && lastRole !== 'human';
+        : hasContentChange && lastUsedAt > lastSeenAt && lastRole !== 'user' && lastRole !== 'human' && lastRole !== 'system';
     return { unread, inboxBucket: unread ? 'task_complete' : 'idle' };
 }