codiedev 0.9.24 → 0.9.25

package/dist/commands/doctor.js

@@ -165,6 +165,9 @@ async function runDoctor(_args) {
     catch {
         // malformed backendUrl in config — keep the generic placeholder
     }
+    // Live tracked-repo list fetched from validateToken below. Null until (and
+    // unless) the backend answers; the checks fall back to `config.repos`.
+    let liveRepos = null;
     try {
         const res = await fetch(`${config.backendUrl}/api/cli/validateToken`, {
             method: "POST",
@@ -180,6 +183,21 @@ async function runDoctor(_args) {
                 status: "pass",
                 detail: backendHost,
             });
+            // validateToken returns the company's CURRENT tracked repos. Capture
+            // them: the repo-resolution checks below must reflect what the SERVER
+            // will resolve at capture time (repoResolver.ts resolves against the
+            // live list), not the possibly-stale `config.repos` frozen at the last
+            // `connect`. A repo linked in the portal after that connect otherwise
+            // reports a false "isn't a tracked repo — link it in the portal" here
+            // even though sessions/MRs for it attribute fine server-side.
+            try {
+                const data = (await res.json());
+                if (Array.isArray(data.repos))
+                    liveRepos = data.repos;
+            }
+            catch {
+                liveRepos = null; // malformed body → fall back to the cached list
+            }
         }
         else {
             checks.push({
@@ -219,13 +237,46 @@ async function runDoctor(_args) {
             detail: err.message,
         });
     }
-    // 4. Tracked repos
-    const repoCount = config.repos?.length ?? 0;
+    // 4. Tracked repos. Prefer the live list from validateToken over the cache:
+    // a repo linked after the last `connect` is tracked server-side but absent
+    // from `config.repos`, and resolving against the stale cache is exactly what
+    // produced the false "isn't a tracked repo — link it in the portal" warning.
+    // Treat an EMPTY live list as "no usable live data", NOT an authoritative
+    // zero: a transient permission glitch / backend hiccup can return `repos: []`,
+    // and both driving the checks from it AND healing the cache to empty would be
+    // wrong — the write would durably break every offline doctor run (and the
+    // capture hook's providedRepoId) until the next successful connect. So when
+    // live is empty, fall back to the cache and skip the write, exactly like
+    // backend-unreachable. A genuinely repo-less company also has an empty cache,
+    // so it still reports "0 repos" correctly.
+    const trackedRepos = liveRepos !== null && liveRepos.length > 0 ? liveRepos : (config.repos ?? []);
+    // Detect drift by CONTENT, not count: a same-size swap (one repo removed +
+    // another added between connects) or a repo whose path/URL changed while its
+    // id stayed stable (GitLab move/rename — exactly the SONIFI migration case)
+    // both leave the count unchanged. A length-only check would skip the heal and
+    // leave the capture hook's cache — and its advisory providedRepoId — stale.
+    const canonRepos = (rs) => JSON.stringify([...rs].map((r) => [r.repoId, r.url, r.fullName]).sort());
+    const cacheRefreshed = liveRepos !== null &&
+        liveRepos.length > 0 &&
+        canonRepos(liveRepos) !== canonRepos(config.repos ?? []);
+    // Heal the on-disk cache so the capture hook (which reads `config.repos` for
+    // the advisory providedRepoId) stops trailing the portal too. Best-effort:
+    // doctor must never fail because the config couldn't be rewritten.
+    if (cacheRefreshed && liveRepos) {
+        try {
+            (0, utils_1.writeConfig)({ ...config, repos: liveRepos, lastSynced: new Date().toISOString() });
+        }
+        catch {
+            // read-only home / permission issue — the in-memory list still drives
+            // the checks below; the user just re-syncs on the next `connect`.
+        }
+    }
+    const repoCount = trackedRepos.length;
     checks.push({
         name: "Tracked repos",
         status: repoCount > 0 ? "pass" : "warn",
         detail: repoCount > 0
-            ? `${repoCount} repo${repoCount === 1 ? "" : "s"}`
+            ? `${repoCount} repo${repoCount === 1 ? "" : "s"}${cacheRefreshed ? " (refreshed from portal)" : ""}`
             : "0 — link repos in the portal so sessions get captured",
     });
     // 4b. Capture readiness — the part that actually decides whether a session
@@ -234,7 +285,7 @@ async function runDoctor(_args) {
     // last one?" — the blind spot behind lean-container / submodule / no-remote
     // zeros.
     const cwd = process.cwd();
-    const readiness = (0, captureReadiness_1.assessCaptureReadiness)(cwd, config.repos ?? [], {
+    const readiness = (0, captureReadiness_1.assessCaptureReadiness)(cwd, trackedRepos, {
         exec: (cmd, dir) => (0, child_process_1.execSync)(cmd, { cwd: dir, stdio: ["pipe", "pipe", "pipe"] }).toString(),
         getRemoteUrl: utils_1.getGitRemoteUrl,
         matchRepo: utils_1.matchRepo,
@@ -247,7 +298,7 @@ async function runDoctor(_args) {
     // instead of flatly warning "not a work tree / no remote" — the exact output
     // that made working workspace-root setups read as broken.
     const workspaceScan = readiness.gitOnPath && !readiness.insideWorkTree
-        ? (0, captureReadiness_1.assessWorkspaceRepos)(cwd, config.repos ?? [], {
+        ? (0, captureReadiness_1.assessWorkspaceRepos)(cwd, trackedRepos, {
             listChildDirs: (dir) => fs
                 .readdirSync(dir, { withFileTypes: true })
                 .filter((e) => e.isDirectory())

package/dist/utils.d.ts

@@ -67,6 +67,8 @@ export interface CapturePayloadInput {
 }
 export declare function buildCapturePayload(input: CapturePayloadInput): Record<string, unknown>;
 export declare function hashToken(token: string): string;
+export declare function extractHookNodePath(cmd: string | undefined): string | undefined;
+export declare function resetStableNodeCacheForTests(): void;
 export declare function claudeCodeInstalled(): boolean;
 export declare function codexInstalled(): boolean;
 export declare function cursorInstalled(): boolean;

package/dist/utils.js

@@ -52,6 +52,8 @@ exports.getGitBranch = getGitBranch;
 exports.getGitHeadSha = getGitHeadSha;
 exports.buildCapturePayload = buildCapturePayload;
 exports.hashToken = hashToken;
+exports.extractHookNodePath = extractHookNodePath;
+exports.resetStableNodeCacheForTests = resetStableNodeCacheForTests;
 exports.claudeCodeInstalled = claudeCodeInstalled;
 exports.codexInstalled = codexInstalled;
 exports.cursorInstalled = cursorInstalled;
@@ -733,7 +735,94 @@ const VSCODE_USER_MCP_PATH = path.join(VSCODE_USER_DIR, "mcp.json");
 function shellQuote(s) {
     return `'${s.replace(/'/g, `'\\''`)}'`;
 }
-function resolveHookCommand(subcommand) {
+// Pull the `<node>` prefix out of a codiedev hook command we previously wrote.
+// Commands take the form `'<node>' '<hookScript>' <subcommand>` (each path
+// single-quoted by shellQuote). Returns undefined for the legacy
+// `npx codiedev-hook <subcommand>` form (no explicit node path) or if the
+// command doesn't start with a quoted token. Exported for unit testing.
+function extractHookNodePath(cmd) {
+    if (!cmd)
+        return undefined;
+    // Match the first single-quoted token, honoring shellQuote's `'\''` escape.
+    const m = cmd.match(/^'((?:[^']|'\\'')*)'/);
+    if (!m)
+        return undefined;
+    return m[1].replace(/'\\''/g, "'");
+}
+// `process.execPath` is the *resolved* path to the running node binary, so under
+// Homebrew it's the version-specific Cellar path (e.g.
+// /opt/homebrew/Cellar/node/26.4.0/bin/node). Baking that into the hook means a
+// later `brew upgrade node` moves the Cellar dir and the hook path 404s. Prefer
+// a stable alias for the *same* binary:
+//   1. A node path from a hook we previously wrote that still resolves — usually
+//      a symlink the user deliberately pinned (e.g. /opt/homebrew/bin/node). A
+//      re-`connect`/self-heal then honors it instead of clobbering it.
+//   2. Otherwise, `node` as found on PATH when it points at the binary we're
+//      running (the Homebrew symlink, an nvm `current` alias, etc.).
+//   3. Last resort: the resolved `process.execPath`. Always valid right now, and
+//      still an absolute path a GUI-launched agent can execute without PATH.
+function realpathOrSelf(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+}
+// A stable `node` alias on PATH (Homebrew symlink, nvm `current`, …) that points
+// at the very binary we're running, or undefined if none. `installHook` writes
+// five hooks per run, so memoize: `command -v node` is a synchronous subprocess
+// spawn and its result can't change within a process. `null` = "looked, none".
+let cachedStableNodeOnPath;
+// Test-only: the memo lives for the process lifetime, so suites that stage
+// their own PATH/symlink fixtures must clear it between tests.
+function resetStableNodeCacheForTests() {
+    cachedStableNodeOnPath = undefined;
+}
+function stableNodeOnPath() {
+    if (cachedStableNodeOnPath !== undefined) {
+        return cachedStableNodeOnPath ?? undefined;
+    }
+    const execReal = realpathOrSelf(process.execPath);
+    try {
+        const onPath = (0, child_process_1.execSync)("command -v node", {
+            stdio: ["pipe", "pipe", "pipe"],
+        })
+            .toString()
+            .trim();
+        if (onPath && onPath !== process.execPath && realpathOrSelf(onPath) === execReal) {
+            cachedStableNodeOnPath = onPath;
+            return onPath;
+        }
+    }
+    catch {
+        // No node on PATH (e.g. GUI-launched agent) — fall through.
+    }
+    cachedStableNodeOnPath = null;
+    return undefined;
+}
+function resolveHookNodePath(preferredNodePath) {
+    const execReal = realpathOrSelf(process.execPath);
+    // 1. Honor a still-working node path from the existing hook — but only when
+    //    it's a *different* string than the resolved realpath. If the existing
+    //    path already IS `process.execPath` it's the version-specific realpath we
+    //    want to upgrade away from (that's the Homebrew bug), so fall through to
+    //    hunt for a stable alias in step 2.
+    if (preferredNodePath &&
+        preferredNodePath !== process.execPath &&
+        fs.existsSync(preferredNodePath) &&
+        realpathOrSelf(preferredNodePath) === execReal) {
+        return preferredNodePath;
+    }
+    // 2. Prefer a stable `node` on PATH over the version-specific realpath.
+    const onPath = stableNodeOnPath();
+    if (onPath)
+        return onPath;
+    // 3. Last resort: the resolved absolute path. Always valid right now, and
+    //    still an absolute path a GUI-launched agent can execute without PATH.
+    return process.execPath;
+}
+function resolveHookCommand(subcommand, preferredNodePath) {
     try {
         const cliEntry = process.argv[1];
         if (cliEntry) {
@@ -741,7 +830,8 @@ function resolveHookCommand(subcommand) {
             const distDir = path.dirname(realCli);
             const hookScript = path.join(distDir, "hook.js");
             if (fs.existsSync(hookScript)) {
-                return `${shellQuote(process.execPath)} ${shellQuote(hookScript)} ${subcommand}`;
+                const nodePath = resolveHookNodePath(preferredNodePath);
+                return `${shellQuote(nodePath)} ${shellQuote(hookScript)} ${subcommand}`;
             }
         }
     }
@@ -798,6 +888,22 @@ function upsertCodiedevHook(hooks, eventName, subcommand, matcher = ".*") {
     if (!hooks[eventName])
         hooks[eventName] = [];
     const existing = hooks[eventName];
+    // Before stripping the old codiedev entry, remember the node path it used so a
+    // re-run/upgrade can honor a stable symlink the user pinned instead of
+    // overwriting it with the version-specific `process.execPath` (see
+    // resolveHookNodePath). Done in an explicit scan rather than as a side effect
+    // of the filter predicate below, which stays a pure predicate.
+    let preservedNodePath;
+    for (const hook of existing) {
+        const inner = hook.hooks;
+        if (!Array.isArray(inner))
+            continue;
+        const codiedevInner = inner.find((h) => (0, detection_1.isCodiedevHookCommand)(h.command));
+        if (codiedevInner) {
+            preservedNodePath = extractHookNodePath(codiedevInner.command);
+            break;
+        }
+    }
     const filtered = existing.filter((hook) => {
         const inner = hook.hooks;
         if (Array.isArray(inner)) {
@@ -807,7 +913,7 @@ function upsertCodiedevHook(hooks, eventName, subcommand, matcher = ".*") {
     });
     filtered.push({
         matcher,
-        hooks: [{ type: "command", command: resolveHookCommand(subcommand) }],
+        hooks: [{ type: "command", command: resolveHookCommand(subcommand, preservedNodePath) }],
     });
     hooks[eventName] = filtered;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.24",
+  "version": "0.9.25",
   "description": "Connect Claude Code, Codex, Cursor, or VS Code Copilot to Codiedev for org-wide session capture and artifact collaboration",
   "bin": {
     "codiedev": "dist/cli.js",