@adhdev/daemon-core 0.9.82-rc.8 → 0.9.82-rc.81

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/repo-mesh-types.ts

@@ -23,11 +23,42 @@ export interface RepoMesh {
     defaultBranch?: string;
     policy: RepoMeshPolicy;
     coordinator: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
     projectContext: ProjectContextSnapshot;
     nodes: RepoMeshNode[];
     status: 'active' | 'archived' | 'deleted';
 }
 
+export type RepoMeshDaemonRole = 'host' | 'member';
+
+export interface RepoMeshHostPairingMetadata {
+    status: 'not_configured' | 'pairing' | 'paired' | 'rejected' | 'revoked';
+    tokenId?: string;
+    joinedAt?: string;
+    lastPairedAt?: string;
+    lastRejectedAt?: string;
+    expiresAt?: string;
+}
+
+export interface RepoMeshHostMetadata {
+    /** Local daemon role for this mesh. Missing metadata defaults to host for standalone compatibility. */
+    role: RepoMeshDaemonRole;
+    /** Daemon that owns mesh truth/status/git/queue/session/ledger/coordinator ownership. */
+    hostDaemonId?: string;
+    /** Mesh node that represents the host daemon, when known. */
+    hostNodeId?: string;
+    /** Future standalone manual pairing endpoint entered by member daemons. */
+    hostAddress?: string;
+    /** Redacted pairing state only; raw join tokens must not be persisted here. */
+    pairing?: RepoMeshHostPairingMetadata;
+}
+
+export interface RepoMeshHostStatus extends RepoMeshHostMetadata {
+    canOwnCoordinator: boolean;
+    canOwnQueue: boolean;
+    defaulted: boolean;
+}
+
 export interface RepoMeshNode {
     id: string;
     daemonId: string;
@@ -42,6 +73,7 @@ export interface RepoMeshNode {
     effectiveCapabilities: RepoMeshNodeCapabilities;
     policy: RepoMeshNodePolicy;
     health: RepoMeshNodeHealth;
+    role?: RepoMeshDaemonRole;
     status: 'enabled' | 'disabled' | 'removed';
 }
 
@@ -229,6 +261,7 @@ export interface LocalMeshEntry {
     defaultBranch?: string;
     policy: RepoMeshPolicy;
     coordinator: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
     nodes: LocalMeshNodeEntry[];
     createdAt: string;
     updatedAt: string;
@@ -251,6 +284,7 @@ export interface LocalMeshNodeEntry {
     clonedFromNodeId?: string;
     /** Optional associated/external repos configured as node metadata. */
     relatedRepos?: RepoMeshRelatedRepo[];
+    role?: RepoMeshDaemonRole;
 }
 
 // ─── Mesh Status (runtime, not persisted) ───────
@@ -259,7 +293,9 @@ export interface RepoMeshStatus {
     meshId: string;
     meshName: string;
     repoIdentity: string;
+    defaultBranch?: string;
     refreshedAt: string;
+    meshHost?: RepoMeshHostStatus;
     nodes: RepoMeshNodeStatus[];
     queue?: RepoMeshQueueStatus;
     ledger?: RepoMeshLedgerStatus;
@@ -300,11 +336,18 @@ export interface RepoMeshNodeStatus {
     repoRoot?: string;
     daemonId?: string;
     machineId?: string;
+    role?: RepoMeshDaemonRole;
     machineStatus?: string;
     isLocalWorktree?: boolean;
     worktreeBranch?: string;
     health: RepoMeshNodeHealth;
     git?: GitRepoStatus;
+    /**
+     * True when the selected coordinator has evidence that a peer git probe is still
+     * in flight or just timed out during initial mesh handshake, so callers should
+     * treat missing git data as pending instead of authoritative absence.
+     */
+    gitProbePending?: boolean;
     providers: string[];
     activeSessions: string[];
     activeSessionDetails?: RepoMeshSessionStatus[];

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,
+    };
 }