@danielblomma/cortex-mcp 2.2.5 → 2.4.1

package/scaffold/mcp/tests/govern-install.test.mjs

@@ -289,7 +289,12 @@ test("uninstall removes managed file and updates state", async () => {
     });
     assert.equal(fs.existsSync(target), true);
 
-    const result = await runGovernUninstall({ cli: "claude", cwd: root, skipRoot: true });
+    const result = await runGovernUninstall({
+      cli: "claude",
+      cwd: root,
+      skipRoot: true,
+      pathOverride: { claude: target },
+    });
     assert.equal(result.ok, true, result.message);
     assert.equal(fs.existsSync(target), false);
 
@@ -329,7 +334,12 @@ test("uninstall in enforced mode requires --break-glass + --reason", async () =>
       skipRoot: true,
     });
 
-    const blocked = await runGovernUninstall({ cli: "claude", cwd: root, skipRoot: true });
+    const blocked = await runGovernUninstall({
+      cli: "claude",
+      cwd: root,
+      skipRoot: true,
+      pathOverride: { claude: target },
+    });
     assert.equal(blocked.ok, false);
     assert.match(blocked.message, /enforced mode/);
     assert.equal(fs.existsSync(target), true);
@@ -339,6 +349,7 @@ test("uninstall in enforced mode requires --break-glass + --reason", async () =>
       cwd: root,
       breakGlass: true,
       skipRoot: true,
+      pathOverride: { claude: target },
     });
     assert.equal(noReason.ok, false);
     assert.match(noReason.message, /requires --reason/);
@@ -349,6 +360,7 @@ test("uninstall in enforced mode requires --break-glass + --reason", async () =>
       breakGlass: true,
       reason: "Incident response",
       skipRoot: true,
+      pathOverride: { claude: target },
     });
     assert.equal(allowed.ok, true, allowed.message);
     assert.equal(fs.existsSync(target), false);
@@ -358,6 +370,87 @@ test("uninstall in enforced mode requires --break-glass + --reason", async () =>
   }
 });
 
+test("uninstall ignores a persisted managed path and removes only the derived target", async () => {
+  const { root, ctx } = makeProject({
+    apiKey: "ent_test_key_12345678",
+    baseUrl: "https://example.com",
+  });
+  const victim = path.join(root, "victim.txt");
+  const derived = path.join(root, "derived-managed.json");
+  fs.writeFileSync(victim, "do not delete");
+  fs.writeFileSync(derived, "managed");
+  fs.writeFileSync(
+    path.join(ctx, "govern.local.json"),
+    JSON.stringify({
+      installs: {
+        claude: {
+          path: victim,
+          version: "attacker-controlled",
+          frameworks: [],
+          installed_at: new Date().toISOString(),
+          mode: "advisory",
+        },
+      },
+    }),
+  );
+  try {
+    const result = await runGovernUninstall({
+      cli: "claude",
+      cwd: root,
+      skipRoot: true,
+      pathOverride: { claude: derived },
+    });
+    assert.equal(result.ok, true, result.message);
+    assert.equal(fs.readFileSync(victim, "utf8"), "do not delete");
+    assert.equal(fs.existsSync(derived), false);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("govern state replacement does not follow a dangling project-state symlink", async () => {
+  const { server, baseUrl } = await startMockServer({
+    "GET /api/v1/govern/config": (_req, res) => {
+      res.setHeader("ETag", '"v1"');
+      res.end(JSON.stringify({
+        cli: "claude",
+        managed_settings: { allowManagedHooksOnly: true },
+        deny_rules: [],
+        tamper_config: {
+          heartbeat_interval_seconds: 60,
+          missing_threshold_seconds: 300,
+        },
+        frameworks: [{ id: "iso27001", version: "1" }],
+      }));
+    },
+    "POST /api/v1/govern/applied": (_req, res) =>
+      res.end(JSON.stringify({ ok: true })),
+  });
+  const { root, ctx } = makeProject({
+    apiKey: "ent_state_symlink_12345678",
+    baseUrl,
+  });
+  const victim = path.join(root, "must-not-be-created");
+  const statePath = path.join(ctx, "govern.local.json");
+  const managedPath = path.join(root, "managed.json");
+  fs.symlinkSync(victim, statePath);
+  try {
+    const result = await runGovernInstall({
+      cli: "claude",
+      cwd: root,
+      skipRoot: true,
+      pathOverride: { claude: managedPath },
+    });
+    assert.equal(result.ok, true, result.message);
+    assert.equal(fs.existsSync(victim), false);
+    assert.equal(fs.lstatSync(statePath).isSymbolicLink(), false);
+    assert.equal(fs.statSync(statePath).mode & 0o777, 0o600);
+  } finally {
+    server.close();
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test("install with no api_key returns helpful error", async () => {
   const { root } = makeProject({ apiKey: "", baseUrl: "http://example.com" });
   try {

package/scaffold/mcp/tests/govern-repair.test.mjs

@@ -42,8 +42,16 @@ test("repair: errors when managed file is missing", async () => {
       },
     },
   });
+  const expectedPath = path.join(
+    os.tmpdir(),
+    "definitely-not-here-derived-claude-managed.json",
+  );
   try {
-    const result = await runGovernRepair({ cwd: root, skipRoot: true });
+    const result = await runGovernRepair({
+      cwd: root,
+      skipRoot: true,
+      pathOverride: { claude: expectedPath },
+    });
     assert.equal(result.ok, false);
     assert.match(result.message, /missing/);
   } finally {
@@ -72,7 +80,11 @@ test("repair: errors when copilot shim has been replaced", async () => {
     }),
   );
   try {
-    const result = await runGovernRepair({ cwd: root, skipRoot: true });
+    const result = await runGovernRepair({
+      cwd: root,
+      skipRoot: true,
+      pathOverride: { copilot: fakeShim },
+    });
     assert.equal(result.ok, false);
     assert.match(result.message, /no longer a cortex shim/);
   } finally {
@@ -116,6 +128,7 @@ test("repair: clears tamper lock when managed paths verify clean", async () => {
       cwd: root,
       skipRoot: true,
       reason: "Operator reviewed and cleared",
+      pathOverride: { claude: claudeManaged },
     });
     assert.equal(result.ok, true, result.message);
     assert.equal(result.removed_lock, true);
@@ -147,7 +160,11 @@ test("repair: success even when there is no lock — paths still verified", asyn
     }),
   );
   try {
-    const result = await runGovernRepair({ cwd: root, skipRoot: true });
+    const result = await runGovernRepair({
+      cwd: root,
+      skipRoot: true,
+      pathOverride: { claude: claudeManaged },
+    });
     assert.equal(result.ok, true, result.message);
     assert.equal(result.removed_lock, false);
     assert.match(result.message, /No tamper lock present/);

package/scaffold/mcp/tests/heartbeat-tracker.test.mjs

@@ -148,6 +148,32 @@ test("detectTamper: ended session is not flagged", () => {
   assert.equal(findings.length, 0);
 });
 
+test("detectTamper: only evaluates project roots registered by the daemon", () => {
+  const tracker = new HeartbeatTracker();
+  for (const cwd of ["/first", "/second"]) {
+    tracker.recordHeartbeat({
+      cli: "claude",
+      hook: "SessionStart",
+      session_id: `session-${cwd}`,
+      cwd,
+      ts: ts(-10 * 60 * 1000),
+    });
+    tracker.recordHeartbeat({
+      cli: "claude",
+      hook: "PreToolUse",
+      session_id: `session-${cwd}`,
+      cwd,
+      ts: ts(-9 * 60 * 1000),
+    });
+  }
+
+  const findings = tracker.detectTamper({
+    cwds: ["/second"],
+    missingThresholdSeconds: 60,
+  });
+  assert.deepEqual(findings.map((finding) => finding.cwd), ["/second"]);
+});
+
 test("detectTamper: stale session beyond cleanupAfterMs is auto-removed", () => {
   const tracker = new HeartbeatTracker({ cleanupAfterMs: 1000 });
   tracker.recordHeartbeat({

package/scaffold/mcp/tests/license.test.mjs

@@ -0,0 +1,367 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { verifyLicense } from "../dist/core/license.js";
+
+function makeContextDir() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-license-"));
+  const contextDir = path.join(root, ".context");
+  fs.mkdirSync(contextDir, { recursive: true });
+  return { root, contextDir };
+}
+
+function validResponse() {
+  return {
+    ok: true,
+    status: 200,
+    json: async () => ({
+      valid: true,
+      edition: "enterprise",
+      features: ["govern"],
+      expires_at: "2099-01-01T00:00:00.000Z",
+      max_repos: 10,
+    }),
+  };
+}
+
+function cachePath(contextDir) {
+  return path.join(contextDir, "telemetry", "license_cache.json");
+}
+
+test.afterEach(() => {
+  globalThis.fetch = undefined;
+});
+
+test("verifyLicense: reuses a fresh cache only for the same endpoint and API key", async () => {
+  const { root, contextDir } = makeContextDir();
+  let calls = 0;
+  globalThis.fetch = async () => {
+    calls += 1;
+    return validResponse();
+  };
+
+  try {
+    const first = await verifyLicense(
+      contextDir,
+      "https://licenses.example.com/",
+      "ent_first_12345678",
+    );
+    const second = await verifyLicense(
+      contextDir,
+      "https://licenses.example.com",
+      "ent_first_12345678",
+    );
+
+    assert.equal(first.valid, true);
+    assert.equal(first.source, "remote");
+    assert.equal(second.valid, true);
+    assert.equal(second.source, "cache");
+    assert.equal(calls, 1);
+
+    const rawCache = fs.readFileSync(cachePath(contextDir), "utf8");
+    assert.doesNotMatch(rawCache, /ent_first_12345678/);
+    const parsedCache = JSON.parse(rawCache);
+    assert.equal(parsedCache.version, 2);
+    assert.equal(parsedCache.endpoint, "https://licenses.example.com");
+    assert.match(parsedCache.api_key_sha256, /^[a-f0-9]{64}$/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("verifyLicense: atomic cache replacement does not follow a dangling cache symlink", async () => {
+  const { root, contextDir } = makeContextDir();
+  const victim = path.join(root, "must-not-be-created");
+  fs.mkdirSync(path.dirname(cachePath(contextDir)), { recursive: true });
+  fs.symlinkSync(victim, cachePath(contextDir));
+  globalThis.fetch = async () => validResponse();
+
+  try {
+    const result = await verifyLicense(
+      contextDir,
+      "https://licenses.example.com",
+      "ent_symlink_cache_12345678",
+    );
+    assert.equal(result.valid, true);
+    assert.equal(fs.existsSync(victim), false);
+    assert.equal(fs.lstatSync(cachePath(contextDir)).isSymbolicLink(), false);
+    assert.equal(fs.statSync(cachePath(contextDir)).mode & 0o777, 0o600);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("verifyLicense: does not reuse a cache for another key or endpoint", async () => {
+  const { root, contextDir } = makeContextDir();
+  let calls = 0;
+  globalThis.fetch = async () => {
+    calls += 1;
+    if (calls === 1) return validResponse();
+    throw new Error("offline");
+  };
+
+  try {
+    const first = await verifyLicense(
+      contextDir,
+      "https://licenses.example.com",
+      "ent_first_12345678",
+    );
+    assert.equal(first.valid, true);
+
+    const otherKey = await verifyLicense(
+      contextDir,
+      "https://licenses.example.com",
+      "ent_second_12345678",
+    );
+    assert.deepEqual(
+      {
+        valid: otherKey.valid,
+        source: otherKey.source,
+        reason: otherKey.valid ? undefined : otherKey.reason,
+      },
+      {
+        valid: false,
+        source: "grace_expired",
+        reason: "endpoint_unreachable_grace_expired",
+      },
+    );
+
+    const otherEndpoint = await verifyLicense(
+      contextDir,
+      "https://other.example.com",
+      "ent_first_12345678",
+    );
+    assert.equal(otherEndpoint.valid, false);
+    assert.equal(otherEndpoint.source, "grace_expired");
+    assert.equal(calls, 3);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("verifyLicense: 401 and 403 are authoritative and never use grace", async () => {
+  for (const status of [401, 403]) {
+    const { root, contextDir } = makeContextDir();
+    let calls = 0;
+    globalThis.fetch = async () => {
+      calls += 1;
+      if (calls === 1) return validResponse();
+      return {
+        ok: false,
+        status,
+        statusText: "Rejected",
+      };
+    };
+
+    try {
+      await verifyLicense(
+        contextDir,
+        "https://licenses.example.com",
+        "ent_first_12345678",
+      );
+      const cache = JSON.parse(fs.readFileSync(cachePath(contextDir), "utf8"));
+      cache.cached_at = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000).toISOString();
+      fs.writeFileSync(cachePath(contextDir), JSON.stringify(cache), "utf8");
+
+      const rejected = await verifyLicense(
+        contextDir,
+        "https://licenses.example.com",
+        "ent_first_12345678",
+      );
+      assert.equal(rejected.valid, false);
+      assert.equal(rejected.source, "remote");
+      assert.equal(rejected.reason, "authentication_rejected");
+      assert.equal(fs.existsSync(cachePath(contextDir)), false);
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  }
+});
+
+test("verifyLicense: an identity-matched positive cache remains available for transient grace", async () => {
+  const { root, contextDir } = makeContextDir();
+  let calls = 0;
+  globalThis.fetch = async () => {
+    calls += 1;
+    if (calls === 1) return validResponse();
+    throw new Error("offline");
+  };
+
+  try {
+    await verifyLicense(
+      contextDir,
+      "https://licenses.example.com",
+      "ent_first_12345678",
+    );
+    const cache = JSON.parse(fs.readFileSync(cachePath(contextDir), "utf8"));
+    cache.cached_at = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000).toISOString();
+    fs.writeFileSync(cachePath(contextDir), JSON.stringify(cache), "utf8");
+
+    const grace = await verifyLicense(
+      contextDir,
+      "https://licenses.example.com",
+      "ent_first_12345678",
+    );
+    assert.equal(grace.valid, true);
+    assert.equal(grace.source, "cache");
+    assert.equal(calls, 2);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("verifyLicense: legacy unbound cache entries are never trusted", async () => {
+  const { root, contextDir } = makeContextDir();
+  fs.mkdirSync(path.dirname(cachePath(contextDir)), { recursive: true });
+  fs.writeFileSync(
+    cachePath(contextDir),
+    JSON.stringify({
+      cached_at: new Date().toISOString(),
+      result: {
+        valid: true,
+        edition: "enterprise",
+        features: [],
+        expires_at: "2099-01-01T00:00:00.000Z",
+        max_repos: 10,
+        verified_at: new Date().toISOString(),
+        source: "remote",
+      },
+    }),
+    "utf8",
+  );
+  globalThis.fetch = async () => {
+    throw new Error("offline");
+  };
+
+  try {
+    const result = await verifyLicense(
+      contextDir,
+      "https://licenses.example.com",
+      "ent_first_12345678",
+    );
+    assert.equal(result.valid, false);
+    assert.equal(result.source, "grace_expired");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("verifyLicense: malformed cache shapes fail closed instead of throwing", async () => {
+  const { root, contextDir } = makeContextDir();
+  fs.mkdirSync(path.dirname(cachePath(contextDir)), { recursive: true });
+  fs.writeFileSync(
+    cachePath(contextDir),
+    JSON.stringify({ cached_at: new Date().toISOString() }),
+    "utf8",
+  );
+  globalThis.fetch = async () => {
+    throw new Error("offline");
+  };
+
+  try {
+    const result = await verifyLicense(
+      contextDir,
+      "https://licenses.example.com",
+      "ent_first_12345678",
+    );
+    assert.equal(result.valid, false);
+    assert.equal(result.source, "grace_expired");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("verifyLicense: structurally partial v2 cache entries are never trusted", async () => {
+  const { root, contextDir } = makeContextDir();
+  fs.mkdirSync(path.dirname(cachePath(contextDir)), { recursive: true });
+  fs.writeFileSync(
+    cachePath(contextDir),
+    JSON.stringify({
+      version: 2,
+      endpoint: "https://licenses.example.com",
+      api_key_sha256: "a".repeat(64),
+      cached_at: new Date(Date.now() + 60_000).toISOString(),
+      result: {
+        valid: true,
+        expires_at: null,
+      },
+    }),
+    "utf8",
+  );
+  let calls = 0;
+  globalThis.fetch = async () => {
+    calls += 1;
+    throw new Error("offline");
+  };
+
+  try {
+    const result = await verifyLicense(
+      contextDir,
+      "https://licenses.example.com",
+      "ent_first_12345678",
+    );
+    assert.equal(result.valid, false);
+    assert.equal(result.source, "grace_expired");
+    assert.equal(calls, 1);
+    assert.equal(fs.existsSync(cachePath(contextDir)), false);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("verifyLicense: a future-dated otherwise valid cache fails closed and is removed", async () => {
+  const { root, contextDir } = makeContextDir();
+  let calls = 0;
+  globalThis.fetch = async () => {
+    calls += 1;
+    if (calls === 1) return validResponse();
+    throw new Error("offline");
+  };
+
+  try {
+    await verifyLicense(
+      contextDir,
+      "https://licenses.example.com",
+      "ent_first_12345678",
+    );
+    const cache = JSON.parse(fs.readFileSync(cachePath(contextDir), "utf8"));
+    cache.cached_at = new Date(Date.now() + 60_000).toISOString();
+    fs.writeFileSync(cachePath(contextDir), JSON.stringify(cache), "utf8");
+
+    const result = await verifyLicense(
+      contextDir,
+      "https://licenses.example.com",
+      "ent_first_12345678",
+    );
+    assert.equal(result.valid, false);
+    assert.equal(result.source, "grace_expired");
+    assert.equal(calls, 2);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("verifyLicense: refuses cleartext non-loopback endpoints before sending a bearer key", async () => {
+  const { root, contextDir } = makeContextDir();
+  let calls = 0;
+  globalThis.fetch = async () => {
+    calls += 1;
+    return validResponse();
+  };
+
+  try {
+    const result = await verifyLicense(
+      contextDir,
+      "http://licenses.example.com",
+      "ent_first_12345678",
+    );
+    assert.equal(result.valid, false);
+    assert.equal(result.reason, "insecure_or_invalid_endpoint");
+    assert.equal(calls, 0);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

package/scaffold/mcp/tests/paths.test.mjs

@@ -4,13 +4,15 @@ import { mkdtempSync, mkdirSync, realpathSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 test("paths resolve the project root from cwd without duplicating .context", () => {
   const projectRoot = mkdtempSync(path.join(tmpdir(), "cortex-paths-"));
   const contextDir = path.join(projectRoot, ".context");
   const mcpDir = path.join(contextDir, "mcp");
-  const pathsModuleUrl = pathToFileURL(path.resolve("dist/paths.js")).href;
+  const pathsModuleUrl = pathToFileURL(path.resolve(__dirname, "..", "dist", "paths.js")).href;
 
   mkdirSync(mcpDir, { recursive: true });
   writeFileSync(path.join(contextDir, "config.yaml"), "source_paths:\n  - src\n");
@@ -20,7 +22,7 @@ test("paths resolve the project root from cwd without duplicating .context", ()
     [
       "--input-type=module",
       "-e",
-      `import { REPO_ROOT, CONTEXT_DIR, CACHE_DIR } from ${JSON.stringify(pathsModuleUrl)}; console.log(JSON.stringify({ REPO_ROOT, CONTEXT_DIR, CACHE_DIR }));`
+      `import { REPO_ROOT, CONTEXT_DIR, CACHE_DIR, DEFAULT_RANKING } from ${JSON.stringify(pathsModuleUrl)}; console.log(JSON.stringify({ REPO_ROOT, CONTEXT_DIR, CACHE_DIR, DEFAULT_RANKING }));`
     ],
     {
       cwd: mcpDir,
@@ -35,4 +37,10 @@ test("paths resolve the project root from cwd without duplicating .context", ()
   assert.equal(parsed.REPO_ROOT, resolvedProjectRoot);
   assert.equal(parsed.CONTEXT_DIR, path.join(resolvedProjectRoot, ".context"));
   assert.equal(parsed.CACHE_DIR, path.join(resolvedProjectRoot, ".context", "cache"));
+  assert.deepEqual(parsed.DEFAULT_RANKING, {
+    semantic: 0.4,
+    graph: 0.25,
+    trust: 0.2,
+    recency: 0.15
+  });
 });