adhdev 0.8.56 → 0.8.57

package/dist/cli/index.js

@@ -83381,7 +83381,7 @@ var init_adhdev_daemon = __esm({
     import_ws3 = require("ws");
     init_source();
     init_version();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.8.56" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.8.57" });
     ACTIVE_CHAT_POLL_STATUSES = /* @__PURE__ */ new Set([
       "generating",
       "waiting_approval",
@@ -86442,6 +86442,12 @@ async function getDiagnosticsRuntimeGroups(diagnostics) {
   }
   return partitionRuntimeRecords(Array.isArray(diagnostics?.sessions) ? diagnostics.sessions : []);
 }
+function getRuntimeGroupsHint(groups) {
+  if (groups.liveRuntimes.length === 0 && groups.recoverySnapshots.length > 0) {
+    return "  No live attach targets right now. The records below are recovery snapshots, so recover or restart them instead of trying to attach.";
+  }
+  return null;
+}
 function getRuntimeNextAction(record2, options) {
   const lifecycle = String(record2?.lifecycle || "").trim();
   if (["starting", "running", "stopping", "interrupted"].includes(lifecycle)) {
@@ -86467,6 +86473,7 @@ function formatRuntimeRecordLine(record2, options) {
 async function printRuntimeGroups(records, options) {
   const groups = options?.diagnostics ? await getDiagnosticsRuntimeGroups(options.diagnostics) : await partitionRuntimeRecords(records || []);
   const includeInactive = options?.includeInactive === true;
+  const groupsHint = getRuntimeGroupsHint(groups);
   const sections = [
     { title: "  Live Runtimes:", records: groups.liveRuntimes },
     { title: "  Recovery Snapshots:", records: groups.recoverySnapshots, recoveryLabels: true }
@@ -86475,6 +86482,10 @@ async function printRuntimeGroups(records, options) {
     sections.push({ title: "  Inactive Records:", records: groups.inactiveRecords });
   }
   let printedSection = false;
+  if (groupsHint) {
+    console.log(source_default.yellow(groupsHint));
+    console.log();
+  }
   for (const section of sections) {
     if (section.records.length === 0) continue;
     printedSection = true;
@@ -87152,6 +87163,95 @@ var os29 = __toESM(require("os"));
 var path33 = __toESM(require("path"));
 init_src();
 init_session_host();
+
+// src/cli/doctor-runtime-surface.ts
+function normalizeVersion(version2) {
+  return String(version2 || "").trim().replace(/^v/i, "");
+}
+function extractNvmNodeVersion(pathValue) {
+  const match = String(pathValue || "").match(/[\\/]\.nvm[\\/]versions[\\/]node[\\/](v[^\\/]+)[\\/]/i);
+  return match?.[1] || null;
+}
+function evaluateCliDriftCheck(probe) {
+  const parts = [probe.commandPath];
+  if (probe.versionError || probe.helpError) {
+    const error48 = probe.versionError || probe.helpError || "unknown failure";
+    parts.push(`broken (${error48})`);
+    return { ok: false, detail: parts.join(" \u2014 ") };
+  }
+  const detectedVersion = normalizeVersion(probe.version);
+  const currentVersion = normalizeVersion(probe.currentVersion);
+  const hasRuntimeSurface = /(^|\s)runtime(\s|$)/m.test(probe.helpText || "");
+  let ok = true;
+  if (detectedVersion) {
+    parts.push(`v${detectedVersion}`);
+  } else {
+    parts.push("version unknown");
+    ok = false;
+  }
+  if (detectedVersion && currentVersion && detectedVersion !== currentVersion) {
+    parts.push(`stale vs current v${currentVersion}`);
+    ok = false;
+  }
+  if (hasRuntimeSurface) {
+    parts.push("runtime surface ok");
+  } else {
+    parts.push("missing runtime surface");
+    ok = false;
+  }
+  return { ok, detail: parts.join(" \u2014 ") };
+}
+function evaluateAdhmuxHelpCheck(probe) {
+  const parts = [probe.commandPath];
+  if (probe.helpError) {
+    parts.push(`broken (${probe.helpError})`);
+    return { ok: false, detail: parts.join(" \u2014 ") };
+  }
+  const helpText = probe.helpText || "";
+  const mentionsPowerUser = /power-user/i.test(helpText);
+  const mentionsRuntimeSurface = /adhdev runtime/i.test(helpText);
+  const ok = mentionsPowerUser && mentionsRuntimeSurface;
+  parts.push(ok ? "help surface ok" : "missing runtime guidance");
+  return { ok, detail: parts.join(" \u2014 ") };
+}
+function evaluateNodeInstallDrift(probe) {
+  const currentNodeVersion = extractNvmNodeVersion(probe.currentExecPath);
+  const commandNodeVersion = extractNvmNodeVersion(probe.commandPath);
+  if (!currentNodeVersion || !commandNodeVersion) {
+    return {
+      ok: true,
+      detail: "no obvious node install drift"
+    };
+  }
+  if (currentNodeVersion === commandNodeVersion) {
+    return {
+      ok: true,
+      detail: `node install roots aligned (${currentNodeVersion})`
+    };
+  }
+  return {
+    ok: false,
+    detail: `node install drift: current runtime ${currentNodeVersion} vs resolved binary ${commandNodeVersion}`
+  };
+}
+function buildDoctorAdvice(input) {
+  const advice = [];
+  if (input.adhdevCheck && !input.adhdevCheck.ok) {
+    advice.push(`Refresh the PATH adhdev binary${input.adhdevPath ? ` at ${input.adhdevPath}` : ""} so it matches v${input.currentVersion}. Example: npm install -g adhdev@${input.currentVersion}`);
+    if (input.sourceCliExample) {
+      advice.push(`Until the PATH binary is fixed, use the source CLI directly: ${input.sourceCliExample}`);
+    }
+  }
+  if (input.adhmuxCheck && !input.adhmuxCheck.ok) {
+    advice.push(`Refresh the PATH adhmux binary${input.adhmuxPath ? ` at ${input.adhmuxPath}` : ""} by reinstalling the current adhdev package so the mux help/runtime guidance matches the current surface.`);
+  }
+  if (input.nodeDriftCheck && !input.nodeDriftCheck.ok) {
+    advice.push("Align the Node version that launches adhdev with the Node install root that owns the PATH binary (for nvm users: run `nvm use <version>` and reopen the shell).");
+  }
+  return advice;
+}
+
+// src/cli/doctor-commands.ts
 function resolvePackageRoot() {
   return path33.resolve(__dirname, "..", "..");
 }
@@ -87318,6 +87418,36 @@ function findCommandPaths(command) {
     return [];
   }
 }
+function probeCliBinary(commandPath, currentVersion) {
+  const probe = {
+    commandPath,
+    currentVersion
+  };
+  try {
+    probe.version = (0, import_child_process13.execFileSync)(commandPath, ["--version"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  } catch (error48) {
+    probe.versionError = error48?.stderr?.toString?.().trim() || error48?.message || "version probe failed";
+  }
+  try {
+    probe.helpText = (0, import_child_process13.execFileSync)(commandPath, ["--help"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (error48) {
+    const stdout = error48?.stdout?.toString?.().trim() || "";
+    const stderr = error48?.stderr?.toString?.().trim() || "";
+    const combined = [stdout, stderr].filter(Boolean).join("\n");
+    if (combined) {
+      probe.helpText = combined;
+    } else {
+      probe.helpError = error48?.message || "help probe failed";
+    }
+  }
+  return probe;
+}
 function readLogHints(logPath) {
   if (!fs25.existsSync(logPath)) return [];
   try {
@@ -87363,6 +87493,8 @@ function registerDoctorCommands(program2, pkgVersion3) {
     const linked = isLinkedInstall(packageRoot);
     const logPath = getCurrentDaemonLogPath();
     const claudePaths = findCommandPaths("claude");
+    const adhdevPaths = findCommandPaths("adhdev");
+    const adhmuxPaths = findCommandPaths("adhmux");
     const nativeSharpPackage = process.platform === "win32" ? "@img/sharp-win32-x64" : process.platform === "darwin" ? process.arch === "arm64" ? "@img/sharp-darwin-arm64" : "@img/sharp-darwin-x64" : process.arch === "arm64" ? "@img/sharp-linux-arm64" : "@img/sharp-linux-x64";
     const checks = [
       {
@@ -87375,6 +87507,16 @@ function registerDoctorCommands(program2, pkgVersion3) {
         ok: true,
         detail: cliPath
       },
+      {
+        label: "adhdev on PATH",
+        ok: adhdevPaths.length > 0,
+        detail: adhdevPaths.length > 0 ? adhdevPaths.join(", ") : "not found on PATH"
+      },
+      {
+        label: "adhmux on PATH",
+        ok: adhmuxPaths.length > 0,
+        detail: adhmuxPaths.length > 0 ? adhmuxPaths.join(", ") : "not found on PATH"
+      },
       {
         label: "Claude CLI",
         ok: claudePaths.length > 0,
@@ -87392,6 +87534,40 @@ function registerDoctorCommands(program2, pkgVersion3) {
       ...probeConfigAccess(),
       ...buildBrowseProbeChecks()
     ];
+    let runtimeSurfaceCheck = null;
+    let nodeDriftCheck = null;
+    let adhmuxHelpCheck = null;
+    if (adhdevPaths.length > 0) {
+      const runtimeSurfaceProbe = probeCliBinary(adhdevPaths[0], pkgVersion3);
+      runtimeSurfaceCheck = evaluateCliDriftCheck(runtimeSurfaceProbe);
+      checks.push({
+        label: "adhdev runtime surface",
+        ok: runtimeSurfaceCheck.ok,
+        detail: runtimeSurfaceCheck.detail
+      });
+      nodeDriftCheck = evaluateNodeInstallDrift({
+        currentExecPath: process.execPath,
+        commandPath: adhdevPaths[0]
+      });
+      checks.push({
+        label: "Node install drift",
+        ok: nodeDriftCheck.ok,
+        detail: nodeDriftCheck.detail
+      });
+    }
+    if (adhmuxPaths.length > 0) {
+      const adhmuxHelpProbe = probeCliBinary(adhmuxPaths[0], pkgVersion3);
+      adhmuxHelpCheck = evaluateAdhmuxHelpCheck({
+        commandPath: adhmuxPaths[0],
+        helpText: adhmuxHelpProbe.helpText,
+        helpError: adhmuxHelpProbe.helpError
+      });
+      checks.push({
+        label: "adhmux help surface",
+        ok: adhmuxHelpCheck.ok,
+        detail: adhmuxHelpCheck.detail
+      });
+    }
     try {
       const sessionHostPid = getSessionHostPid();
       const probe = await probeSessionHostStatus();
@@ -87439,6 +87615,15 @@ function registerDoctorCommands(program2, pkgVersion3) {
     const failures = checks.filter((check2) => !check2.ok && check2.fatal);
     const warnings = checks.filter((check2) => !check2.ok && !check2.fatal);
     const logHints = readLogHints(logPath);
+    const advice = buildDoctorAdvice({
+      currentVersion: pkgVersion3,
+      adhdevPath: adhdevPaths[0],
+      adhdevCheck: runtimeSurfaceCheck || void 0,
+      adhmuxPath: adhmuxPaths[0],
+      adhmuxCheck: adhmuxHelpCheck || void 0,
+      nodeDriftCheck: nodeDriftCheck || void 0,
+      sourceCliExample: "node --import tsx packages/daemon-cloud/src/cli/index.ts doctor"
+    });
     const sessionHostLogPath = path33.join(os29.homedir(), ".adhdev", "logs", "session-host.log");
     console.log(source_default.bold("\n\u{1FA7A} ADHDev Doctor\n"));
     console.log(source_default.gray(`  Version:   ${pkgVersion3}`));
@@ -87462,6 +87647,13 @@ function registerDoctorCommands(program2, pkgVersion3) {
       console.log();
       console.log(source_default.yellow(`  Warning: ${warnings.length} optional check failed.`));
     }
+    if (advice.length > 0) {
+      console.log();
+      console.log(source_default.bold("  Suggested actions:"));
+      for (const line of advice) {
+        console.log(source_default.gray(`    - ${line}`));
+      }
+    }
     if (failures.length > 0) {
       console.log();
       console.log(source_default.red(`  Doctor found ${failures.length} blocking issue(s).`));