@adhdev/daemon-core 0.5.3

package/src/providers/status-monitor.ts

@@ -0,0 +1,125 @@
+/**
+ * StatusMonitor — status monitoring notification system
+ *
+ * Common across all Provider categories (IDE/Extension/CLI).
+ * - approval wait(waiting_approval) occur when notification
+ * - Notification when generating persists for extended duration
+ * - all config Provider Settingstoggle possible
+ */
+
+export interface MonitorConfig {
+ /** Enable awaiting-approval notification */
+    approvalAlert: boolean;
+ /** prolonged generating notification enabled */
+    longGeneratingAlert: boolean;
+ /** Prolonged threshold (seconds) */
+    longGeneratingThresholdSec: number;
+ /** repeat notification cooldown (seconds) */
+    alertCooldownSec: number;
+}
+
+export const DEFAULT_MONITOR_CONFIG: MonitorConfig = {
+    approvalAlert: true,
+    longGeneratingAlert: true,
+    longGeneratingThresholdSec: 180,   // 3minutes
+    alertCooldownSec: 60,              // 1minutes cooldown
+};
+
+export interface MonitorEvent {
+    type: string;
+    agentKey: string;
+    timestamp: number;
+    elapsedSec?: number;
+    message?: string;
+}
+
+export class StatusMonitor {
+    private config: MonitorConfig;
+    private lastAlertTime = new Map<string, number>();
+    private generatingStartTimes = new Map<string, number>();
+
+    constructor(config?: Partial<MonitorConfig>) {
+        this.config = { ...DEFAULT_MONITOR_CONFIG, ...config };
+    }
+
+ /** Config update (called from Provider Settings) */
+    updateConfig(partial: Partial<MonitorConfig>): void {
+        Object.assign(this.config, partial);
+    }
+
+ /** current config return */
+    getConfig(): MonitorConfig {
+        return { ...this.config };
+    }
+
+ /**
+ * Check status transition → return notification event array
+ * each onTick()from call.
+ */
+    check(agentKey: string, status: string, now: number): MonitorEvent[] {
+        const events: MonitorEvent[] = [];
+
+ // 1. approval wait notification
+        if (this.config.approvalAlert && status === 'waiting_approval') {
+            if (this.shouldAlert(agentKey + ':approval', now)) {
+                events.push({
+                    type: 'monitor:approval_waiting',
+                    agentKey,
+                    timestamp: now,
+                    message: `${agentKey} is waiting for approval`,
+                });
+            }
+        }
+
+ // 2. Detect prolonged generating (identical for IDE/Extension/CLI)
+        if (status === 'generating' || status === 'streaming') {
+            if (!this.generatingStartTimes.has(agentKey)) {
+                this.generatingStartTimes.set(agentKey, now);
+            }
+            if (this.config.longGeneratingAlert) {
+                const startedAt = this.generatingStartTimes.get(agentKey)!;
+                const elapsedSec = Math.round((now - startedAt) / 1000);
+                if (elapsedSec > this.config.longGeneratingThresholdSec) {
+                    if (this.shouldAlert(agentKey + ':long_gen', now)) {
+                        events.push({
+                            type: 'monitor:long_generating',
+                            agentKey,
+                            elapsedSec,
+                            timestamp: now,
+                            message: `${agentKey} has been generating for ${Math.round(elapsedSec / 60)}min`,
+                        });
+                    }
+                }
+            }
+        } else {
+ // Reset timer when switching to non-generating status
+            this.generatingStartTimes.delete(agentKey);
+        }
+
+        return events;
+    }
+
+ /** Cooldown check — prevent sending the same notification too frequently */
+    private shouldAlert(key: string, now: number): boolean {
+        const last = this.lastAlertTime.get(key) || 0;
+        if (now - last > this.config.alertCooldownSec * 1000) {
+            this.lastAlertTime.set(key, now);
+            return true;
+        }
+        return false;
+    }
+
+ /** Reset (on agent terminate/restart) */
+    reset(agentKey?: string): void {
+        if (agentKey) {
+            this.generatingStartTimes.delete(agentKey);
+ // Delete all cooldowns for this key
+            for (const k of this.lastAlertTime.keys()) {
+                if (k.startsWith(agentKey)) this.lastAlertTime.delete(k);
+            }
+        } else {
+            this.generatingStartTimes.clear();
+            this.lastAlertTime.clear();
+        }
+    }
+}

package/src/providers/version-archive.ts

@@ -0,0 +1,266 @@
+/**
+ * Provider Version Detection & Archiving
+ *
+ * Detects installed versions for all provider categories (IDE, CLI, ACP, Extension).
+ * Archives version history to ~/.adhdev/version-history.json for compatibility tracking.
+ *
+ * Usage:
+ *   const archive = new VersionArchive();
+ *   const results = await detectAllVersions(providerLoader, archive);
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { execSync } from 'child_process';
+import { platform } from 'os';
+import type { ProviderLoader } from './provider-loader.js';
+
+// ─── Types ──────────────────────────────────────
+
+export interface ProviderVersionInfo {
+  type: string;
+  name: string;
+  category: string;
+  installed: boolean;
+  version: string | null;
+  path: string | null;
+  binary: string | null;
+  detectedAt: string;  // ISO timestamp
+  /**
+   * Set when the detected version is NOT listed in provider.json testedVersions.
+   * Means scripts may not work correctly with this version.
+   */
+  warning?: string;
+}
+
+export interface VersionHistoryEntry {
+  version: string;
+  detectedAt: string;
+  os: string;
+}
+
+export interface VersionHistory {
+  [providerType: string]: VersionHistoryEntry[];
+}
+
+// ─── Version Archive ──────────────────────────────
+
+const ARCHIVE_PATH = path.join(os.homedir(), '.adhdev', 'version-history.json');
+const MAX_ENTRIES_PER_PROVIDER = 20;
+
+export class VersionArchive {
+  private history: VersionHistory = {};
+
+  constructor() {
+    this.load();
+  }
+
+  private load(): void {
+    try {
+      if (fs.existsSync(ARCHIVE_PATH)) {
+        this.history = JSON.parse(fs.readFileSync(ARCHIVE_PATH, 'utf-8'));
+      }
+    } catch {
+      this.history = {};
+    }
+  }
+
+  /** Record a detected version (deduplicates same version) */
+  record(type: string, version: string): void {
+    if (!this.history[type]) this.history[type] = [];
+
+    const entries = this.history[type];
+    const last = entries[entries.length - 1];
+
+    // Skip if same version as last entry
+    if (last && last.version === version) return;
+
+    entries.push({
+      version,
+      detectedAt: new Date().toISOString(),
+      os: platform(),
+    });
+
+    // Trim old entries
+    if (entries.length > MAX_ENTRIES_PER_PROVIDER) {
+      this.history[type] = entries.slice(-MAX_ENTRIES_PER_PROVIDER);
+    }
+
+    this.save();
+  }
+
+  /** Get version history for a provider */
+  getHistory(type: string): VersionHistoryEntry[] {
+    return this.history[type] || [];
+  }
+
+  /** Get latest known version for a provider */
+  getLatest(type: string): string | null {
+    const entries = this.history[type];
+    return entries?.length ? entries[entries.length - 1].version : null;
+  }
+
+  /** Get full archive */
+  getAll(): VersionHistory {
+    return { ...this.history };
+  }
+
+  private save(): void {
+    try {
+      fs.mkdirSync(path.dirname(ARCHIVE_PATH), { recursive: true });
+      fs.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
+    } catch { /* ignore write errors */ }
+  }
+}
+
+// ─── Version Detection ──────────────────────────────
+
+function runCommand(cmd: string, timeout = 10000): string | null {
+  try {
+    return execSync(cmd, {
+      encoding: 'utf-8',
+      timeout,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function findBinary(name: string): string | null {
+  const cmd = platform() === 'win32' ? `where ${name}` : `which ${name}`;
+  const result = runCommand(cmd, 5000);
+  return result ? result.split('\n')[0] : null;
+}
+
+/** Extract version string from CLI output */
+function parseVersion(raw: string): string {
+  // Common patterns: "1.2.3", "v1.2.3", "tool 1.2.3", "tool version 1.2.3"
+  const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
+  return match ? match[1] : raw.split('\n')[0].substring(0, 100);
+}
+
+function getVersion(binary: string, versionCommand?: string): string | null {
+  // Custom version command from provider.json
+  if (versionCommand) {
+    const raw = runCommand(versionCommand);
+    return raw ? parseVersion(raw) : null;
+  }
+
+  // Default: try --version, then -V, then -v
+  for (const flag of ['--version', '-V', '-v']) {
+    const raw = runCommand(`"${binary}" ${flag}`);
+    if (raw && raw.length < 500) return parseVersion(raw);
+  }
+  return null;
+}
+
+function checkPathExists(paths: string[]): string | null {
+  for (const p of paths) {
+    if (p.includes('*')) {
+      const home = os.homedir();
+      const resolved = p.replace(/\*/g, home.split(path.sep).pop() || '');
+      if (fs.existsSync(resolved)) return resolved;
+    } else {
+      if (fs.existsSync(p)) return p;
+    }
+  }
+  return null;
+}
+
+/** macOS: Get app version from Info.plist */
+function getMacAppVersion(appPath: string): string | null {
+  if (platform() !== 'darwin' || !appPath.endsWith('.app')) return null;
+  const plistPath = path.join(appPath, 'Contents', 'Info.plist');
+  if (!fs.existsSync(plistPath)) return null;
+  const raw = runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
+  return raw || null;
+}
+
+/**
+ * Detect versions for all loaded providers
+ */
+export async function detectAllVersions(
+  loader: ProviderLoader,
+  archive?: VersionArchive,
+): Promise<ProviderVersionInfo[]> {
+  const results: ProviderVersionInfo[] = [];
+  const currentOs = platform() as string;
+
+  for (const provider of loader.getAll()) {
+    const info: ProviderVersionInfo = {
+      type: provider.type,
+      name: provider.name,
+      category: provider.category,
+      installed: false,
+      version: null,
+      path: null,
+      binary: null,
+      detectedAt: new Date().toISOString(),
+    };
+
+    const versionCommand = (provider as any).versionCommand;
+
+    if (provider.category === 'ide') {
+      // IDE: check app path + CLI
+      const osPaths = provider.paths?.[currentOs] || [];
+      const appPath = checkPathExists(osPaths);
+      const cliBin = provider.cli ? findBinary(provider.cli) : null;
+
+      // Also check bundled CLI inside .app for macOS
+      let resolvedBin = cliBin;
+      if (!resolvedBin && appPath && currentOs === 'darwin') {
+        const bundled = path.join(appPath, 'Contents', 'Resources', 'app', 'bin', provider.cli || '');
+        if (provider.cli && fs.existsSync(bundled)) resolvedBin = bundled;
+      }
+
+      info.installed = !!(appPath || resolvedBin);
+      info.path = appPath || null;
+      info.binary = resolvedBin || null;
+
+      // Version: try CLI first, then plist
+      if (resolvedBin) {
+        info.version = getVersion(resolvedBin, versionCommand);
+      }
+      if (!info.version && appPath) {
+        info.version = getMacAppVersion(appPath);
+      }
+
+    } else if (provider.category === 'cli' || provider.category === 'acp') {
+      // CLI/ACP: check binary
+      const bin = provider.binary || provider.spawn?.command || provider.cli || provider.type;
+      const binPath = findBinary(bin);
+      info.installed = !!binPath;
+      info.binary = binPath || null;
+
+      if (binPath) {
+        info.version = getVersion(binPath, versionCommand);
+      }
+
+    } else if (provider.category === 'extension') {
+      // Extension: version detection via `code --list-extensions --show-versions`
+      // This is more complex and depends on the host IDE — skip for now
+      // Could be detected at runtime via CDP
+      info.installed = false; // Cannot reliably detect without IDE context
+      info.version = null;
+    }
+
+    // Archive the version if detected
+    if (info.version && archive) {
+      archive.record(provider.type, info.version);
+    }
+
+    // Check testedVersions — warn if installed version is not documented
+    if (info.version && info.installed) {
+      const testedVersions: string[] = (provider as any).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.`;
+      }
+    }
+
+    results.push(info);
+  }
+
+  return results;
+}

package/src/status/reporter.ts

@@ -0,0 +1,294 @@
+/**
+ * DaemonStatusReporter — status collect & transmit (StatusReport / P2P / StatusEvent)
+ *
+ * Collect status from ProviderInstanceManager → assemble payload → transmit
+ * Each Instance manages its own status/transition. This module only assembles + transmits.
+ */
+
+import * as os from 'os';
+import * as path from 'path';
+import { loadConfig } from '../config/config.js';
+import { LOG } from '../logging/logger.js';
+
+// ─── Daemon dependency interface ──────────────────────
+
+export interface StatusReporterDeps {
+    serverConn: { isConnected(): boolean; sendMessage(type: string, data: any): void; getUserPlan(): string } | null;
+    cdpManagers: Map<string, { isConnected: boolean }>;
+    p2p: { isConnected: boolean; isAvailable: boolean; connectionState: string; connectedPeerCount: number; screenshotActive: boolean; sendStatus(data: any): void } | null;
+    providerLoader: { resolve(type: string): any; getAll(): any[] };
+    adapters: Map<string, { cliType: string; cliName: string; workingDir: string; getStatus(): any; getPartialResponse(): string }>;
+    detectedIdes: any[];
+    ideType: string;
+    instanceManager: { collectAllStates(): any[]; collectStatesByCategory(cat: string): any[] };
+}
+
+export class DaemonStatusReporter {
+    private deps: StatusReporterDeps;
+    private log: (msg: string) => void;
+
+    private lastStatusSentAt = 0;
+    private statusPendingThrottle = false;
+    private lastP2PStatusHash = '';
+    private lastStatusSummary = '';
+
+    private statusTimer: NodeJS.Timeout | null = null;
+    private p2pTimer: NodeJS.Timeout | null = null;
+
+    constructor(deps: StatusReporterDeps, opts?: { logFn?: (msg: string) => void }) {
+        this.deps = deps;
+        this.log = opts?.logFn || LOG.forComponent('Status').asLogFn();
+    }
+
+ // ─── Lifecycle ───────────────────────────────────
+
+    startReporting(): void {
+        setTimeout(() => {
+            this.sendUnifiedStatusReport().catch(e => LOG.warn('Status', `Initial report failed: ${e?.message}`));
+        }, 2000);
+
+        const scheduleServerReport = () => {
+            this.statusTimer = setTimeout(() => {
+                this.sendUnifiedStatusReport().catch(e => LOG.warn('Status', `Periodic report failed: ${e?.message}`));
+                scheduleServerReport();
+            }, 30_000);
+        };
+        scheduleServerReport();
+
+        this.p2pTimer = setInterval(() => {
+            if (this.deps.p2p?.isConnected) {
+                this.sendUnifiedStatusReport({ p2pOnly: true }).catch(e => LOG.warn('Status', `P2P status send failed: ${e?.message}`));
+            }
+        }, 5_000) as any;
+    }
+
+    stopReporting(): void {
+        if (this.statusTimer) { clearTimeout(this.statusTimer); this.statusTimer = null; }
+        if (this.p2pTimer) { clearInterval(this.p2pTimer); this.p2pTimer = null; }
+    }
+
+    onStatusChange(): void {
+        this.throttledReport();
+    }
+
+    throttledReport(): void {
+        const now = Date.now();
+        const elapsed = now - this.lastStatusSentAt;
+        if (elapsed >= 5_000) {
+            this.sendUnifiedStatusReport().catch(e => LOG.warn('Status', `Throttled report failed: ${e?.message}`));
+        } else if (!this.statusPendingThrottle) {
+            this.statusPendingThrottle = true;
+            setTimeout(() => {
+                this.statusPendingThrottle = false;
+                this.sendUnifiedStatusReport().catch(e => LOG.warn('Status', `Deferred report failed: ${e?.message}`));
+            }, 5_000 - elapsed);
+        }
+    }
+
+    emitStatusEvent(event: Record<string, unknown>): void {
+        LOG.info('StatusEvent', `${event.event} (${event.providerType || event.ideType || ''})`);
+        this.deps.serverConn?.sendMessage('status_event', event);
+    }
+
+    removeAgentTracking(_key: string): void { /* Managed by Instance itself */ }
+
+ // (agent-stream polling backward compat)
+    updateAgentStreams(_ideType: string, _streams: any[]): void { /* Managed by Instance itself */ }
+
+ // ─── Core ────────────────────────────────────────
+
+    private ts(): string {
+        return new Date().toISOString().slice(11, 23); // HH:mm:ss.SSS
+    }
+
+    async sendUnifiedStatusReport(opts?: { p2pOnly?: boolean }): Promise<void> {
+        const { serverConn, cdpManagers, p2p, providerLoader, adapters } = this.deps;
+        if (!serverConn?.isConnected()) return;
+        this.lastStatusSentAt = Date.now();
+        const now = this.lastStatusSentAt;
+        const target = opts?.p2pOnly ? 'P2P' : 'P2P+Server';
+
+        const allStates = this.deps.instanceManager.collectAllStates();
+        const ideStates = allStates.filter((s: any) => s.category === 'ide');
+        const cliStates = allStates.filter((s: any) => s.category === 'cli');
+        const acpStates = allStates.filter((s: any) => s.category === 'acp');
+
+ // IDE summary
+        const ideSummary = ideStates.map((s: any) => {
+            const msgs = s.activeChat?.messages?.length || 0;
+            const exts = (s.extensions || []).length;
+            return `${s.type}(${s.status},${msgs}msg,${exts}ext${s.currentModel ? ',model=' + s.currentModel : ''})`;
+        }).join(', ');
+
+ // CLI summary
+        const cliSummary = cliStates.map((s: any) => `${s.type}(${s.status})`).join(', ');
+ // ACP summary
+        const acpSummary = acpStates.map((s: any) => `${s.type}(${s.status})`).join(', ');
+
+ // P2P-only = 5s heartbeat → DEBUG, P2P+Server = 30s interval → INFO
+        const logLevel = opts?.p2pOnly ? 'debug' : 'info';
+        const summary = `→${target} IDE: ${ideStates.length} [${ideSummary}] CLI: ${cliStates.length} [${cliSummary}] ACP: ${acpStates.length} [${acpSummary}]`;
+ // Skip identical repeats at any level to reduce log noise
+        const summaryChanged = summary !== this.lastStatusSummary;
+        if (summaryChanged) {
+            this.lastStatusSummary = summary;
+            if (logLevel === 'debug') {
+                LOG.debug('StatusReport', summary);
+            } else {
+                LOG.info('StatusReport', summary);
+            }
+        }
+
+ // IDE states → managedIdes
+        const managedIdes: any[] = ideStates.map((s: any) => ({
+            ideType: s.type,
+            ideVersion: '',
+            instanceId: s.instanceId,
+            workspaceFolders: s.workspaceFolders || [],
+            activeFile: s.activeFile || null,
+            terminals: 0,
+            aiAgents: [],
+            activeChat: s.activeChat,
+            chats: [],
+            agentStreams: (s.extensions || []).map((ext: any) => ({
+                agentType: ext.type,
+                agentName: ext.name,
+                extensionId: ext.type,
+                status: ext.status || 'idle',
+                messages: ext.activeChat?.messages || [],
+                inputContent: ext.activeChat?.inputContent || '',
+                activeModal: ext.activeChat?.activeModal || null,
+            })),
+            cdpConnected: s.cdpConnected || false,
+            currentModel: s.currentModel,
+            currentPlan: s.currentPlan,
+            currentAutoApprove: s.currentAutoApprove,
+        }));
+
+ // Merge/add Extension data
+
+
+ // CLI states → managedClis
+        const managedClis: any[] = cliStates.map((s: any) => ({
+            id: s.instanceId,
+            instanceId: s.instanceId,
+            cliType: s.type,
+            cliName: s.name,
+            status: s.status,
+            mode: s.mode || 'terminal',
+            workingDir: s.workingDir || '',
+            activeChat: s.activeChat,
+        }));
+
+ // ACP states → managedAcps (separated into per-type arrays)
+        const managedAcps: any[] = acpStates.map((s: any) => ({
+            id: s.instanceId,
+            acpType: s.type,
+            acpName: s.name,
+            status: s.status,
+            mode: 'chat',
+            workingDir: s.workingDir || '',
+            activeChat: s.activeChat,
+            currentModel: s.currentModel,
+            currentPlan: s.currentPlan,
+            acpConfigOptions: s.acpConfigOptions,
+            acpModes: s.acpModes,
+        }));
+
+
+
+ // ═══ Assemble payload (P2P — required data only) ═══
+        const payload: Record<string, any> = {
+            daemonMode: true,
+            machineNickname: loadConfig().machineNickname || null,
+            machine: {
+                hostname: os.hostname(),
+                platform: os.platform(),
+                arch: os.arch(),
+                cpus: os.cpus().length,
+                totalMem: os.totalmem(),
+                freeMem: os.freemem(),
+                loadavg: os.loadavg(),
+                uptime: os.uptime(),
+            },
+            managedIdes,
+            managedClis,
+            managedAcps,
+            p2p: {
+                available: p2p?.isAvailable || false,
+                state: p2p?.connectionState || 'unavailable',
+                peers: p2p?.connectedPeerCount || 0,
+                screenshotActive: p2p?.screenshotActive || false,
+            },
+            cdpConnected: [...cdpManagers.values()].some(c => c.isConnected),
+            connectedExtensions: [],
+            detectedIdes: this.deps.detectedIdes || [],
+            availableProviders: this.deps.providerLoader.getAll().map((p: any) => ({
+                type: p.type, icon: p.icon || '💻', displayName: p.displayName || p.type,
+                category: p.category,
+            })),
+            timestamp: now,
+        };
+
+ // ═══ P2P transmit ═══
+        const p2pSent = this.sendP2PPayload(payload);
+        if (p2pSent) {
+            LOG.debug('P2P', `sent (${JSON.stringify(payload).length} bytes)`);
+        }
+
+ // ═══ Server transmit (minimal routing meta only — sanitizeForRelay removes everything else) ═══
+        if (opts?.p2pOnly) return;
+        const plan = serverConn.getUserPlan();
+        if (plan !== 'free') {
+            const wsPayload = {
+                daemonMode: true,
+                machineNickname: payload.machineNickname,
+ // managedIdes: server only saves id, type, cdpConnected
+                managedIdes: managedIdes.map(ide => ({
+                    ideType: ide.ideType,
+                    instanceId: ide.instanceId,
+                    cdpConnected: ide.cdpConnected,
+                })),
+ // managedClis: server only saves id, type, name
+                managedClis: managedClis.map(c => ({
+                    id: c.id, cliType: c.cliType, cliName: c.cliName,
+                })),
+ // managedAcps: server only saves id, type, name
+                managedAcps: managedAcps?.map((a: any) => ({
+                    id: a.id, acpType: a.acpType, acpName: a.acpName,
+                })),
+                p2p: payload.p2p,
+                cdpConnected: payload.cdpConnected,
+                timestamp: now,
+            };
+            serverConn.sendMessage('status_report', wsPayload);
+            LOG.debug('Server', `sent status_report (${JSON.stringify(wsPayload).length} bytes)`);
+        }
+    }
+
+ // ─── P2P ─────────────────────────────────────────
+
+    private sendP2PPayload(payload: Record<string, any>): boolean {
+        const { timestamp: _ts, system: _sys, ...hashTarget } = payload;
+        if (hashTarget.machine) {
+            const { freeMem: _f, loadavg: _l, uptime: _u, ...stableMachine } = hashTarget.machine as any;
+            hashTarget.machine = stableMachine;
+        }
+        const h = this.simpleHash(JSON.stringify(hashTarget));
+        if (h !== this.lastP2PStatusHash) {
+            this.lastP2PStatusHash = h;
+            this.deps.p2p?.sendStatus(payload);
+            return true;
+        }
+        return false;
+    }
+
+    private simpleHash(s: string): string {
+        let h = 0x811c9dc5;
+        for (let i = 0; i < s.length; i++) {
+            h ^= s.charCodeAt(i);
+            h = (h * 0x01000193) >>> 0;
+        }
+        return h.toString(36);
+    }
+}