@adhdev/daemon-core 0.9.82-rc.302 → 0.9.82-rc.304

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.302",
+  "version": "0.9.82-rc.304",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.302",
+    "@adhdev/mesh-shared": "0.9.82-rc.304",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/router.ts

@@ -966,6 +966,26 @@ function finalizeMeshNodeStatus(args: {
     );
 }
 
+// Reads a positive integer timeout (ms) from an env var, clamped to [1s, 120s];
+// falls back to the default when unset or out of range. Lets slow cross-machine
+// peers (e.g. a TURN-relayed Windows daemon whose git_status RTT is 10-18s) be
+// tuned without a rebuild.
+function readMeshTimeoutEnvMs(name: string, defaultMs: number): number {
+    const raw = process.env[name]?.trim();
+    if (!raw) return defaultMs;
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed >= 1_000 && parsed <= 120_000) return parsed;
+    return defaultMs;
+}
+
+// Direct-peer git_status probe timeout for the dashboard's requireDirectPeerTruth
+// bootstrap. The previous hard-coded 8s/12s were shorter than the real P2P
+// round-trip to slow (often TURN-relayed) peers, so such a node was permanently
+// marked unavailable and blocked the whole mesh graph. Default raised to 25s
+// (still under the P2P REQUEST_TIMEOUT of 30s) and made env-overridable.
+const MESH_DIRECT_PROBE_TIMEOUT_MS = readMeshTimeoutEnvMs('MESH_DIRECT_PROBE_TIMEOUT_MS', 25_000);
+const MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS = readMeshTimeoutEnvMs('MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS', 25_000);
+
 async function probeRemoteMeshGitStatus(args: {
     dispatchMeshCommand?: (daemonId: string, cmd: string, args: Record<string, unknown>) => Promise<unknown>;
     daemonId: string;
@@ -1057,7 +1077,7 @@ async function hydrateInlineMeshDirectTruth(args: {
                 dispatchMeshCommand: args.dispatchMeshCommand,
                 daemonId,
                 workspace,
-                timeoutMs: 8_000,
+                timeoutMs: MESH_DIRECT_PROBE_TIMEOUT_MS,
             });
             if (remoteGit) {
                 recordInlineMeshDirectGitTruth(node, remoteGit, 'selected_coordinator_mesh_p2p_git');
@@ -8574,7 +8594,7 @@ export class DaemonCommandRouter {
                                             dispatchMeshCommand: this.deps.dispatchMeshCommand,
                                             daemonId,
                                             workspace,
-                                            timeoutMs: 8000,
+                                            timeoutMs: MESH_DIRECT_PROBE_TIMEOUT_MS,
                                         });
                                         if (remoteGit) {
                                             status.git = remoteGit;
@@ -8600,7 +8620,7 @@ export class DaemonCommandRouter {
                                                     dispatchMeshCommand: this.deps.dispatchMeshCommand,
                                                     daemonId,
                                                     workspace,
-                                                    timeoutMs: 12000,
+                                                    timeoutMs: MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS,
                                                 });
                                                 if (remoteGit) {
                                                     status.git = remoteGit;

package/src/git/git-executor.ts

@@ -10,6 +10,18 @@ const execFileAsync = promisify(execFile);
 const DEFAULT_TIMEOUT_MS = 5_000;
 const DEFAULT_MAX_BUFFER = 1024 * 1024;
 
+/**
+ * Timeout for status-collection git commands (status/log/submodule/stash/fetch).
+ * The default 5s is fine for porcelain status, but on Windows the `git` subprocess
+ * spawn itself is pathologically slow (measured: `submodule status` ~3.5s, cold
+ * `log -1` ~4.2s) and overlaps with refreshUpstream fetches — a single command
+ * routinely exceeds 5s, which previously collapsed the whole status to all-null and
+ * dropped the node from the mesh graph. Give the collection path a much larger
+ * budget so a slow-but-healthy repo never reads as "not a git repo". Windows gets a
+ * larger budget than POSIX because the spawn cost is OS-specific, not repo-specific.
+ */
+export const GIT_STATUS_TIMEOUT_MS = process.platform === 'win32' ? 30_000 : 20_000;
+
 export interface GitExecutorOptions {
   timeoutMs?: number;
   maxBuffer?: number;

package/src/git/git-status.ts

@@ -1,9 +1,31 @@
 import type { DaemonBuildBehind, GitRepoStatus, GitSubmoduleStatus, GitUpstreamFreshness } from './git-types.js';
-import { GitCommandError, resolveGitRepository, runGit } from './git-executor.js';
+import { GIT_STATUS_TIMEOUT_MS, GitCommandError, resolveGitRepository, runGit } from './git-executor.js';
 import { getDaemonBuildInfo, type DaemonBuildInfo } from '../build-info.js';
 
 type ResolvedGitRepo = { workspace: string; repoRoot: string | null; isGitRepo: boolean };
 
+/**
+ * Last successfully-collected status per workspace, used to survive a transient git
+ * failure (timeout, slow Windows spawn under load, a momentary lock) WITHOUT dropping
+ * the node out of the mesh graph. A genuine "not a git repository" answer is NOT a
+ * transient failure — it never populates this cache and always reports isGitRepo:false.
+ */
+const lastKnownGoodStatus = new Map<string, GitRepoStatus>();
+
+/** Test seam: clear the last-known-good status cache between cases. */
+export function __resetGitStatusCacheForTests(): void {
+  lastKnownGoodStatus.clear();
+}
+
+/**
+ * git failure reasons that are transient/environmental rather than a real statement
+ * that the workspace is not a repo. On these we prefer the last-known-good status so a
+ * single slow git call cannot make a healthy node vanish from the graph.
+ */
+function isTransientGitFailure(error: GitCommandError): boolean {
+  return error.reason === 'timeout' || error.reason === 'git_command_failed';
+}
+
 export interface GitStatusOptions {
   timeoutMs?: number;
   /** When true, include submodule status in the result. Defaults to true. */
@@ -35,9 +57,50 @@ export async function getGitRepoStatus(
 ): Promise<GitRepoStatus> {
   const lastCheckedAt = Date.now();
   const includeSubmodules = options.includeSubmodules !== false;
+  // Status collection fans out into several git subprocesses (status, head, stash,
+  // submodule, optionally fetch). On Windows the per-spawn cost alone can exceed the
+  // 5s default, so unless the caller pinned a timeout, give the whole collection path
+  // the larger status budget. A caller that explicitly sets timeoutMs (e.g. a test
+  // injecting 1ms to exercise the transient-failure path) is respected.
+  const effectiveOptions: GitStatusOptions =
+    options.timeoutMs === undefined ? { ...options, timeoutMs: GIT_STATUS_TIMEOUT_MS } : options;
 
   try {
-    const repo = await resolveGitRepository(workspace, options);
+    const repo = await resolveGitRepository(workspace, effectiveOptions);
+    const status = await collectGitRepoStatus(repo, includeSubmodules, lastCheckedAt, effectiveOptions);
+    lastKnownGoodStatus.set(workspace, status);
+    return status;
+  } catch (error) {
+    const gitError = error instanceof GitCommandError
+      ? error
+      : new GitCommandError('git_command_failed', 'Failed to read Git status', { cause: error });
+
+    // A transient/environmental failure (timeout, slow-spawn-under-load) must NOT make
+    // a healthy node lose its repo identity and drop out of the mesh graph. Prefer the
+    // last status we successfully collected for this workspace, re-stamped as stale.
+    if (isTransientGitFailure(gitError)) {
+      const cached = lastKnownGoodStatus.get(workspace);
+      if (cached) {
+        return {
+          ...cached,
+          lastCheckedAt,
+          upstreamStatus: 'unavailable',
+          error: gitError.stderr || gitError.message,
+          reason: gitError.reason,
+        };
+      }
+    }
+
+    return emptyStatus(workspace, lastCheckedAt, gitError);
+  }
+}
+
+async function collectGitRepoStatus(
+  repo: ResolvedGitRepo,
+  includeSubmodules: boolean,
+  lastCheckedAt: number,
+  options: GitStatusOptions,
+): Promise<GitRepoStatus> {
     let parsed = await readPorcelainStatus(repo, options);
     let upstreamProbe: GitUpstreamProbe = getInitialUpstreamProbe(parsed);
 
@@ -89,16 +152,6 @@ export async function getGitRepoStatus(
       submodules,
       ...(daemonBuildBehind ? { daemonBuildBehind } : {}),
     };
-  } catch (error) {
-    if (error instanceof GitCommandError) {
-      return emptyStatus(workspace, lastCheckedAt, error);
-    }
-    return emptyStatus(
-      workspace,
-      lastCheckedAt,
-      new GitCommandError('git_command_failed', 'Failed to read Git status', { cause: error }),
-    );
-  }
 }
 
 /**
@@ -507,7 +560,12 @@ async function getSubmoduleStatuses(
   if (!repo.repoRoot) return [];
 
   try {
-    const result = await runGit(repo, ['submodule', 'status', '--recursive'], options);
+    // No `--recursive`: this superproject's submodules (oss, adhdev-providers) are
+    // leaf repos with no nested submodules, so `--recursive` doubles the (already
+    // slow on Windows) submodule-status spawn time for zero additional rows. If a
+    // nested submodule is ever introduced, restore --recursive WITH its own longer
+    // per-command timeout rather than reverting this wholesale.
+    const result = await runGit(repo, ['submodule', 'status'], options);
     const submodules = parseSubmoduleStatusOutput(result.stdout, repo.repoRoot, options.submoduleIgnorePaths);
     await Promise.all(submodules.map(submodule => enrichSubmoduleWorktreeStatus(repo, submodule, options)));
     return submodules;