@adhdev/daemon-core 0.9.82-rc.66 → 0.9.82-rc.68

package/src/providers/version-archive.ts

@@ -12,7 +12,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { execSync } from 'child_process';
+// Removed execSync import
 import { platform } from 'os';
 import type { ProviderLoader } from './provider-loader.js';
 import type { ProviderModule } from './contracts.js';
@@ -117,22 +117,40 @@ export class VersionArchive {
 
 // ─── Version Detection ──────────────────────────────
 
-function runCommand(cmd: string, timeout = 10000): string | null {
-  try {
-    return execSync(cmd, {
+import { exec } from 'child_process';
+
+async function runCommand(cmd: string, timeout = 10000): Promise<string | null> {
+  return new Promise((resolve) => {
+    exec(cmd, {
       encoding: 'utf-8',
       timeout,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim();
-  } catch {
-    return null;
-  }
+    }, (error, stdout) => {
+      if (error) return resolve(null);
+      resolve(stdout.trim());
+    });
+  });
 }
 
 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;
+  const isWin = platform() === 'win32';
+  const paths = (process.env.PATH || '').split(isWin ? ';' : ':');
+  const exes = isWin ? ['.exe', '.cmd', '.bat', ''] : [''];
+  
+  for (const p of paths) {
+    if (!p) continue;
+    for (const ext of exes) {
+      const fullPath = path.join(p, name + ext);
+      try {
+        if (fs.existsSync(fullPath)) {
+          const stat = fs.statSync(fullPath);
+          if (stat.isFile() && (isWin || (stat.mode & 0o111))) {
+            return fullPath;
+          }
+        }
+      } catch { }
+    }
+  }
+  return null;
 }
 
 /** Extract version string from CLI output */
@@ -162,16 +180,16 @@ function getPlatformVersionCommand(
   return undefined;
 }
 
-function getVersion(binary: string, versionCommand?: string): string | null {
+async function getVersion(binary: string, versionCommand?: string): Promise<string | null> {
   // Custom version command from provider.json
   if (versionCommand) {
-    const raw = runCommand(versionCommand);
+    const raw = await 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}`);
+    const raw = await runCommand(`"${binary}" ${flag}`);
     if (raw && raw.length < 500) return parseVersion(raw);
   }
   return null;
@@ -191,11 +209,11 @@ function checkPathExists(paths: string[]): string | null {
 }
 
 /** macOS: Get app version from Info.plist */
-function getMacAppVersion(appPath: string): string | null {
+async function getMacAppVersion(appPath: string): Promise<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}"`);
+  const raw = await runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
 }
 
@@ -242,10 +260,10 @@ export async function detectAllVersions(
 
       // Version: try CLI first, then plist
       if (resolvedBin) {
-        info.version = getVersion(resolvedBin, versionCommand);
+        info.version = await getVersion(resolvedBin, versionCommand);
       }
       if (!info.version && appPath) {
-        info.version = getMacAppVersion(appPath);
+        info.version = await getMacAppVersion(appPath);
       }
 
     } else if (provider.category === 'cli' || provider.category === 'acp') {
@@ -256,7 +274,7 @@ export async function detectAllVersions(
       info.binary = binPath || null;
 
       if (binPath) {
-        info.version = getVersion(binPath, versionCommand);
+        info.version = await getVersion(binPath, versionCommand);
       }
 
     } else if (provider.category === 'extension') {

package/src/status/reporter.ts

@@ -51,6 +51,8 @@ export class DaemonStatusReporter {
     private lastStatusSentAt = 0;
     private statusPendingThrottle = false;
     private lastP2PStatusHash = '';
+    private lastP2PStatusSentAt: number = 0;
+    private p2pDebounceTimer: ReturnType<typeof setTimeout> | null = null;
     private lastServerStatusHash = '';
     private lastStatusSummary = '';
 
@@ -355,7 +357,20 @@ export class DaemonStatusReporter {
             : { ...hashTarget, sessions };
         const h = this.simpleHash(JSON.stringify(hashPayload));
         if (h !== this.lastP2PStatusHash) {
+            const now = Date.now();
+            // Rate limit: max 1 per 500ms
+            if (this.lastP2PStatusSentAt && now - this.lastP2PStatusSentAt < 500) {
+                if (!this.p2pDebounceTimer) {
+                    this.p2pDebounceTimer = setTimeout(() => {
+                        this.p2pDebounceTimer = null;
+                        this.sendUnifiedStatusReport({ reason: 'p2p_debounce' });
+                    }, 500);
+                }
+                return false; // Dropped for now, but will trigger later
+            }
+            
             this.lastP2PStatusHash = h;
+            this.lastP2PStatusSentAt = now;
             this.deps.p2p?.sendStatus(payload);
             return true;
         }

package/src/system/host-memory.ts

@@ -11,7 +11,10 @@
  */
 
 import * as os from 'os';
-import { execSync } from 'child_process';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
 
 export interface HostMemorySnapshot {
     totalMem: number;
@@ -21,19 +24,22 @@ export interface HostMemorySnapshot {
     availableMem: number;
 }
 
-function parseDarwinAvailableBytes(totalMem: number): number | null {
-    if (os.platform() !== 'darwin') return null;
+let cachedDarwinAvail: number | null = null;
+let darwinMemoryInterval: NodeJS.Timeout | null = null;
+
+async function updateDarwinMemoryCache() {
+    if (os.platform() !== 'darwin') return;
     try {
-        const out = execSync('vm_stat', {
+        const { stdout } = await execAsync('vm_stat', {
             encoding: 'utf-8',
             timeout: 4000,
             maxBuffer: 256 * 1024,
         });
-        const pageSizeMatch = out.match(/page size of (\d+)\s*bytes/i);
+        const pageSizeMatch = stdout.match(/page size of (\d+)\s*bytes/i);
         const pageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : 4096;
 
         const counts: Record<string, number> = {};
-        for (const line of out.split('\n')) {
+        for (const line of stdout.split('\n')) {
             const m = line.match(/^\s*Pages\s+([^:]+):\s+([\d,]+)\s*\.?/);
             if (!m) continue;
             const key = m[1].trim().toLowerCase().replace(/\s+/g, '_');
@@ -49,17 +55,28 @@ function parseDarwinAvailableBytes(totalMem: number): number | null {
 
         const availPages = free + inactive + speculative + purgeable + fileBacked;
         const bytes = availPages * pageSize;
-        if (!Number.isFinite(bytes) || bytes < 0) return null;
-        return Math.min(bytes, totalMem);
+        cachedDarwinAvail = Number.isFinite(bytes) && bytes >= 0 ? Math.min(bytes, os.totalmem()) : null;
     } catch {
-        return null;
+        // silently fallback
     }
 }
 
 export function getHostMemorySnapshot(): HostMemorySnapshot {
+    if (os.platform() === 'darwin' && !darwinMemoryInterval) {
+        updateDarwinMemoryCache();
+        darwinMemoryInterval = setInterval(updateDarwinMemoryCache, 3000);
+        darwinMemoryInterval.unref();
+    }
+
     const totalMem = os.totalmem();
     const freeMem = os.freemem();
-    const darwinAvail = parseDarwinAvailableBytes(totalMem);
-    const availableMem = darwinAvail != null ? darwinAvail : freeMem;
-    return { totalMem, freeMem, availableMem };
+    const availableMem = os.platform() === 'darwin'
+        ? (cachedDarwinAvail ?? freeMem)
+        : freeMem;
+
+    return {
+        totalMem,
+        freeMem,
+        availableMem,
+    };
 }