context-mode 1.0.125 → 1.0.127

package/build/util/plugin-cache-integrity.js

@@ -0,0 +1,105 @@
+/**
+ * TypeScript surface for the start.mjs plugin-cache integrity helper.
+ *
+ * The actual logic lives in `scripts/plugin-cache-integrity.mjs` (raw
+ * `.mjs` so start.mjs can import it without a TS toolchain at boot —
+ * #550 fail-fast happens BEFORE any bundle is loaded). This module is
+ * the bridge that lets TS consumers (claude-code adapter's
+ * getHealthChecks for Algo-D5, the cli doctor surface) call the same
+ * function without duplicating the implementation.
+ *
+ * Single source of truth: scripts/plugin-cache-integrity.mjs. Boot
+ * fail-fast (Algo-D4) and doctor diagnostic (Algo-D5) agree
+ * byte-for-byte because they call the same exported function.
+ *
+ * Top-level dynamic import is used (not a static `import` from `.mjs`)
+ * because the project is ESM and `import` of a sibling `.mjs` from a
+ * `.ts` file relies on the bundler / loader resolving `.mjs`
+ * extensions, which esbuild can do but tsc-only typecheck cannot. The
+ * dynamic import is resolved by the runtime (Node ESM) regardless of
+ * how the consumer was bundled. Errors are caught and surfaced as a
+ * FAIL detail — the helper is required to ship in the npm tarball
+ * (package.json files[]); a missing helper means the install is
+ * fundamentally broken.
+ */
+let cached = null;
+let cachedError = null;
+async function loadHelper() {
+    if (cached)
+        return cached;
+    if (cachedError)
+        return null;
+    try {
+        // Resolve relative to this compiled file. After tsc emits to
+        // build/util/plugin-cache-integrity.js, the helper sits at
+        // ../../scripts/plugin-cache-integrity.mjs. After esbuild bundles
+        // src/cli.ts to cli.bundle.mjs at the repo root, the same relative
+        // path resolves to ./scripts/plugin-cache-integrity.mjs. Both
+        // shapes are walked here.
+        const candidates = [
+            new URL("../../scripts/plugin-cache-integrity.mjs", import.meta.url),
+            new URL("./scripts/plugin-cache-integrity.mjs", import.meta.url),
+        ];
+        let lastErr = null;
+        for (const url of candidates) {
+            try {
+                const mod = (await import(url.href));
+                if (typeof mod?.assertPluginCacheIntegrity === "function") {
+                    cached = mod;
+                    return cached;
+                }
+            }
+            catch (err) {
+                lastErr = err;
+            }
+        }
+        cachedError =
+            lastErr instanceof Error ? lastErr.message : String(lastErr ?? "not found");
+        return null;
+    }
+    catch (err) {
+        cachedError = err instanceof Error ? err.message : String(err);
+        return null;
+    }
+}
+// Eagerly start the load on module init so the first synchronous
+// check() call can hit the cache. The promise is unawaited
+// intentionally — by the time any HealthCheck.check() runs (doctor
+// command, well after MCP server boot), the import has resolved.
+void loadHelper();
+/**
+ * Run the integrity check synchronously. If the helper module is
+ * still loading (not yet cached) returns a FAIL with detail
+ * "integrity helper not yet loaded" — caller should retry once the
+ * doctor command's IO is complete. In practice the doctor is invoked
+ * many MS after module load so this fallback is defensive only.
+ */
+export function checkPluginCacheIntegritySync(pluginRoot) {
+    if (cached) {
+        const result = cached.assertPluginCacheIntegrity({ pluginRoot });
+        if (result.ok) {
+            return {
+                status: "OK",
+                detail: `${pluginRoot} (all required runtime siblings present)`,
+            };
+        }
+        return {
+            status: "FAIL",
+            detail: `missing: ${result.missing.join(", ")}`,
+        };
+    }
+    if (cachedError) {
+        return {
+            status: "FAIL",
+            detail: `integrity helper unavailable: ${cachedError}`,
+        };
+    }
+    return {
+        status: "FAIL",
+        detail: "integrity helper not yet loaded",
+    };
+}
+/** Force-await the helper load. Tests use this to deflake the eager fire-and-forget. */
+export async function ensurePluginCacheIntegrityLoaded() {
+    await loadHelper();
+}

package/build/util/project-dir.d.ts

@@ -50,6 +50,15 @@ export declare function isPluginInstallPath(p: string): boolean;
  */
 export declare function resolveProjectDirFromTranscript(opts: {
     projectsRoot: string;
+    /**
+     * Optional freshness guard. Claude Code updates the active transcript while
+     * the session is being used; stale transcripts from previous days must not
+     * become a global project-dir signal for other hosts that merely have
+     * ~/.claude on disk.
+     */
+    maxAgeMs?: number;
+    /** Test seam for maxAgeMs. Defaults to Date.now(). */
+    nowMs?: number;
 }): string | undefined;
 /**
  * Pure project-dir resolver. Mirror of the env-var chain inside
@@ -77,6 +86,10 @@ export declare function resolveProjectDir(opts: {
     pwd: string | undefined;
     /** Optional override; production code passes `~/.claude/projects`. */
     transcriptsRoot?: string;
+    /** Optional freshness guard for Claude Code transcript project recovery. */
+    transcriptMaxAgeMs?: number;
+    /** Test seam for transcriptMaxAgeMs. Defaults to Date.now(). */
+    nowMs?: number;
     /**
      * Issue #545 — opt-in tightening. When set, the candidate list is built
      * algorithmically from `workspaceEnvVarsFor(strictPlatform)` plus the

package/build/util/project-dir.js

@@ -124,6 +124,11 @@ export function resolveProjectDirFromTranscript(opts) {
     }
     if (!bestPath)
         return undefined;
+    if (typeof opts.maxAgeMs === "number") {
+        const nowMs = opts.nowMs ?? Date.now();
+        if (nowMs - bestMtime > opts.maxAgeMs)
+            return undefined;
+    }
     // Read first ~10 lines until we find a cwd field. The jsonl is
     // append-only and can be huge (60+ MB on long sessions) — never load it
     // into memory; stream a small head buffer.
@@ -172,7 +177,7 @@ export function resolveProjectDirFromTranscript(opts) {
  *      operation of project-independent tools (sandbox execute, fetch).
  */
 export function resolveProjectDir(opts) {
-    const { env, cwd, pwd, transcriptsRoot, strictPlatform } = opts;
+    const { env, cwd, pwd, transcriptsRoot, transcriptMaxAgeMs, nowMs, strictPlatform } = opts;
     // Build candidate list. Strict path: own workspace vars + universal escape
     // hatch — NO foreign workspace vars, in any order, can win. Non-strict
     // path: frozen legacy literal order for backwards compatibility.
@@ -185,7 +190,11 @@ export function resolveProjectDir(opts) {
             return v;
     }
     if (transcriptsRoot) {
-        const fromTranscript = resolveProjectDirFromTranscript({ projectsRoot: transcriptsRoot });
+        const fromTranscript = resolveProjectDirFromTranscript({
+            projectsRoot: transcriptsRoot,
+            maxAgeMs: transcriptMaxAgeMs,
+            nowMs,
+        });
         if (fromTranscript && !isPluginInstallPath(fromTranscript))
             return fromTranscript;
     }