@danielblomma/cortex-mcp 2.4.0 → 2.4.1

package/scaffold/mcp/tests/skill-sync-checker.test.mjs

@@ -6,9 +6,34 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 import {
-  runSkillSyncForCli,
-  runSkillSyncOnce,
+  runSkillSyncForCli as runSkillSyncForCliImpl,
+  runSkillSyncOnce as runSkillSyncOnceImpl,
 } from "../dist/daemon/skill-sync-checker.js";
+import { enterpriseCredentialId } from "../dist/core/license.js";
+import { claimEnterpriseHostIdentity } from "../dist/core/enterprise-host-identity.js";
+
+const TEST_ENDPOINT = "https://example.com";
+const TEST_API_KEY = "ent_test_12345678";
+
+function enrollTestIdentity() {
+  assert.equal(
+    claimEnterpriseHostIdentity(
+      enterpriseCredentialId(TEST_ENDPOINT, TEST_API_KEY),
+      TEST_ENDPOINT,
+    ),
+    true,
+  );
+}
+
+async function runSkillSyncForCli(cwd, cli) {
+  enrollTestIdentity();
+  return runSkillSyncForCliImpl(cwd, cli);
+}
+
+async function runSkillSyncOnce(cwd, clis) {
+  enrollTestIdentity();
+  return runSkillSyncOnceImpl(cwd, clis);
+}
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const skillFixture = JSON.parse(
@@ -76,6 +101,7 @@ function createFetchStub(state) {
     }
 
     if (url.pathname.startsWith("/api/v1/govern/skills/")) {
+      if (typeof state.bodyFetches === "number") state.bodyFetches += 1;
       const name = decodeURIComponent(url.pathname.split("/").pop() ?? "");
       if (!(name in state.bodies)) {
         return {
@@ -275,3 +301,421 @@ test("runSkillSyncOnce: consumes the shared org-skillz contract fixture end-to-e
   );
   assert.ok(!fs.existsSync(skillPath(homeDir, "claude", "alpha-codex")));
 });
+
+test("runSkillSyncForCli: rejects unsafe remote names before fetching or writing skill bodies", async () => {
+  const { cwd } = makeWorkspace();
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-skill-home-"));
+  process.env.HOME = homeDir;
+  const victimDir = path.join(homeDir, "Documents");
+  fs.mkdirSync(victimDir);
+  fs.writeFileSync(path.join(victimDir, "sentinel.txt"), "keep", "utf8");
+  let bodyFetches = 0;
+
+  globalThis.fetch = async (input) => {
+    const url = input instanceof URL ? input : new URL(input);
+    if (url.pathname.endsWith("/manifest")) {
+      return {
+        ok: true,
+        json: async () => ({
+          skills: [{
+            name: "../../Documents",
+            scope: "global",
+            updated_at: "2026-07-28T00:00:00.000Z",
+          }],
+        }),
+      };
+    }
+    bodyFetches += 1;
+    throw new Error("body fetch must not occur");
+  };
+
+  const outcome = await runSkillSyncForCli(cwd, "codex");
+  assert.equal(outcome.kind, "failed");
+  assert.match(outcome.error, /invalid skill name/);
+  assert.equal(bodyFetches, 0);
+  assert.equal(
+    fs.readFileSync(path.join(victimDir, "sentinel.txt"), "utf8"),
+    "keep",
+  );
+});
+
+test("runSkillSyncForCli: ignores persisted absolute paths when removing legacy state", async () => {
+  const { cwd } = makeWorkspace();
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-skill-home-"));
+  process.env.HOME = homeDir;
+  const victimDir = path.join(homeDir, "Documents");
+  fs.mkdirSync(victimDir);
+  fs.writeFileSync(path.join(victimDir, "SKILL.md"), "not managed", "utf8");
+  fs.writeFileSync(path.join(victimDir, "sentinel.txt"), "keep", "utf8");
+  fs.mkdirSync(path.dirname(daemonStatePath(homeDir)), { recursive: true });
+  fs.writeFileSync(
+    daemonStatePath(homeDir),
+    JSON.stringify({
+      skills: {
+        "codex:safe-skill": {
+          cli: "codex",
+          scope: "global",
+          updated_at: "2026-07-27T00:00:00.000Z",
+          path: path.join(victimDir, "SKILL.md"),
+        },
+      },
+    }),
+    "utf8",
+  );
+  globalThis.fetch = createFetchStub({
+    manifests: { codex: [] },
+    bodies: {},
+  });
+
+  const outcome = await runSkillSyncForCli(cwd, "codex");
+  assert.equal(outcome.kind, "synced");
+  assert.deepEqual(outcome.removed, ["safe-skill"]);
+  assert.equal(
+    fs.readFileSync(path.join(victimDir, "sentinel.txt"), "utf8"),
+    "keep",
+  );
+  assert.equal(fs.existsSync(path.join(victimDir, "SKILL.md")), true);
+});
+
+test("runSkillSyncForCli: refuses to write through a managed skill directory symlink", {
+  skip: process.platform === "win32",
+}, async () => {
+  const { cwd } = makeWorkspace();
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-skill-home-"));
+  process.env.HOME = homeDir;
+  const victimDir = path.join(homeDir, "victim");
+  const skillsRoot = path.join(homeDir, ".codex", "skills");
+  fs.mkdirSync(victimDir);
+  fs.mkdirSync(skillsRoot, { recursive: true });
+  fs.writeFileSync(path.join(victimDir, "SKILL.md"), "keep", "utf8");
+  fs.symlinkSync(victimDir, path.join(skillsRoot, "global-skill"), "dir");
+  const remote = {
+    bodyFetches: 0,
+    manifests: {
+      codex: [{
+        name: "global-skill",
+        scope: "global",
+        updated_at: "2026-07-28T00:00:00.000Z",
+      }],
+    },
+    bodies: {
+      "global-skill": "remote replacement",
+    },
+  };
+  globalThis.fetch = createFetchStub(remote);
+
+  const outcome = await runSkillSyncForCli(cwd, "codex");
+  assert.equal(outcome.kind, "failed");
+  assert.match(outcome.error, /symbolic link/);
+  assert.equal(remote.bodyFetches, 0);
+  assert.equal(
+    fs.readFileSync(path.join(victimDir, "SKILL.md"), "utf8"),
+    "keep",
+  );
+});
+
+test("runSkillSyncForCli: refuses to overwrite an unmanaged personal skill collision", async () => {
+  const { cwd } = makeWorkspace();
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-skill-home-"));
+  process.env.HOME = homeDir;
+  const personalDir = path.dirname(
+    skillPath(homeDir, "codex", "global-skill"),
+  );
+  fs.mkdirSync(personalDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(personalDir, "SKILL.md"),
+    "personal content",
+    "utf8",
+  );
+  fs.writeFileSync(path.join(personalDir, "notes.txt"), "keep", "utf8");
+  const remote = {
+    bodyFetches: 0,
+    manifests: {
+      codex: [{
+        name: "global-skill",
+        scope: "global",
+        updated_at: "2026-07-28T00:00:00.000Z",
+      }],
+    },
+    bodies: { "global-skill": "remote replacement" },
+  };
+  globalThis.fetch = createFetchStub(remote);
+
+  const outcome = await runSkillSyncForCli(cwd, "codex");
+  assert.equal(outcome.kind, "failed");
+  assert.match(outcome.error, /not owned by Cortex/);
+  assert.equal(remote.bodyFetches, 0);
+  assert.equal(
+    fs.readFileSync(path.join(personalDir, "SKILL.md"), "utf8"),
+    "personal content",
+  );
+  assert.equal(
+    fs.readFileSync(path.join(personalDir, "notes.txt"), "utf8"),
+    "keep",
+  );
+});
+
+test("runSkillSyncForCli: refuses a symlinked CLI skills root", {
+  skip: process.platform === "win32",
+}, async () => {
+  const { cwd } = makeWorkspace();
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-skill-home-"));
+  process.env.HOME = homeDir;
+  const victimDir = path.join(homeDir, "outside");
+  const cliDir = path.join(homeDir, ".codex");
+  fs.mkdirSync(victimDir);
+  fs.mkdirSync(cliDir);
+  fs.symlinkSync(victimDir, path.join(cliDir, "skills"), "dir");
+  const remote = {
+    bodyFetches: 0,
+    manifests: {
+      codex: [{
+        name: "global-skill",
+        scope: "global",
+        updated_at: "2026-07-28T00:00:00.000Z",
+      }],
+    },
+    bodies: { "global-skill": "remote replacement" },
+  };
+  globalThis.fetch = createFetchStub(remote);
+
+  const outcome = await runSkillSyncForCli(cwd, "codex");
+  assert.equal(outcome.kind, "failed");
+  assert.match(outcome.error, /skills root must not be a symbolic link/);
+  assert.equal(remote.bodyFetches, 0);
+  assert.deepEqual(fs.readdirSync(victimDir), []);
+});
+
+test("runSkillSyncForCli: a second credential cannot mutate the first credential's managed skills", async () => {
+  const { cwd, contextDir } = makeWorkspace();
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-skill-home-"));
+  process.env.HOME = homeDir;
+  const remote = {
+    manifests: {
+      codex: [{
+        name: "global-skill",
+        scope: "global",
+        updated_at: "2026-07-28T00:00:00.000Z",
+      }],
+    },
+    bodies: { "global-skill": "identity A" },
+  };
+  globalThis.fetch = createFetchStub(remote);
+
+  const first = await runSkillSyncForCli(cwd, "codex");
+  assert.equal(first.kind, "synced");
+  const installed = skillPath(homeDir, "codex", "global-skill");
+  assert.equal(fs.readFileSync(installed, "utf8"), "identity A");
+  assert.ok(
+    fs.existsSync(path.join(path.dirname(installed), ".cortex-managed.json")),
+  );
+
+  fs.writeFileSync(
+    path.join(contextDir, "enterprise.yml"),
+    [
+      "enterprise:",
+      "  api_key: ent_other_12345678",
+      "  endpoint: https://other.example.com",
+      "",
+    ].join("\n"),
+    "utf8",
+  );
+  remote.manifests.codex = [];
+
+  const second = await runSkillSyncForCli(cwd, "codex");
+  assert.equal(second.kind, "failed");
+  assert.match(second.error, /identity conflict/);
+  assert.equal(fs.readFileSync(installed, "utf8"), "identity A");
+});
+
+test("runSkillSyncForCli: removal refuses unowned files added to a managed directory", async () => {
+  const { cwd } = makeWorkspace();
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-skill-home-"));
+  process.env.HOME = homeDir;
+  const remote = {
+    manifests: {
+      codex: [{
+        name: "global-skill",
+        scope: "global",
+        updated_at: "2026-07-28T00:00:00.000Z",
+      }],
+    },
+    bodies: { "global-skill": "managed" },
+  };
+  globalThis.fetch = createFetchStub(remote);
+  assert.equal((await runSkillSyncForCli(cwd, "codex")).kind, "synced");
+
+  const installedDir = path.dirname(
+    skillPath(homeDir, "codex", "global-skill"),
+  );
+  fs.writeFileSync(path.join(installedDir, "personal-note.txt"), "keep", "utf8");
+  remote.manifests.codex = [];
+
+  const outcome = await runSkillSyncForCli(cwd, "codex");
+  assert.equal(outcome.kind, "failed");
+  assert.match(outcome.error, /contains unowned files/);
+  assert.equal(
+    fs.readFileSync(path.join(installedDir, "personal-note.txt"), "utf8"),
+    "keep",
+  );
+});
+
+test("runSkillSyncForCli: refuses a managed SKILL.md symlink before fetching replacement content", {
+  skip: process.platform === "win32",
+}, async () => {
+  const { cwd } = makeWorkspace();
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-skill-home-"));
+  process.env.HOME = homeDir;
+  const remote = {
+    bodyFetches: 0,
+    manifests: {
+      codex: [{
+        name: "global-skill",
+        scope: "global",
+        updated_at: "2026-07-28T00:00:00.000Z",
+      }],
+    },
+    bodies: { "global-skill": "managed v1" },
+  };
+  globalThis.fetch = createFetchStub(remote);
+  assert.equal((await runSkillSyncForCli(cwd, "codex")).kind, "synced");
+  assert.equal(remote.bodyFetches, 1);
+
+  const installed = skillPath(homeDir, "codex", "global-skill");
+  const victim = path.join(homeDir, "victim.txt");
+  fs.writeFileSync(victim, "keep", "utf8");
+  fs.unlinkSync(installed);
+  fs.symlinkSync(victim, installed);
+  remote.manifests.codex[0].updated_at = "2026-07-28T01:00:00.000Z";
+  remote.bodies["global-skill"] = "managed v2";
+
+  const outcome = await runSkillSyncForCli(cwd, "codex");
+  assert.equal(outcome.kind, "failed");
+  assert.match(outcome.error, /skill file must not be a symbolic link/);
+  assert.equal(remote.bodyFetches, 1);
+  assert.equal(fs.readFileSync(victim, "utf8"), "keep");
+});
+
+test("runSkillSyncForCli: rejects malformed manifest variants before any body fetch", async () => {
+  const variants = [
+    {
+      label: "absolute name",
+      manifest: [{
+        name: "/tmp/owned",
+        scope: "global",
+        updated_at: "2026-07-28T00:00:00.000Z",
+      }],
+    },
+    {
+      label: "separator-only name",
+      manifest: [{
+        name: "../",
+        scope: "global",
+        updated_at: "2026-07-28T00:00:00.000Z",
+      }],
+    },
+    {
+      label: "dot name",
+      manifest: [{
+        name: ".",
+        scope: "global",
+        updated_at: "2026-07-28T00:00:00.000Z",
+      }],
+    },
+    {
+      label: "malformed entry",
+      manifest: [null],
+    },
+    {
+      label: "invalid scope",
+      manifest: [{
+        name: "safe-name",
+        scope: "project",
+        updated_at: "2026-07-28T00:00:00.000Z",
+      }],
+    },
+    {
+      label: "missing timestamp",
+      manifest: [{
+        name: "safe-name",
+        scope: "global",
+        updated_at: "",
+      }],
+    },
+    {
+      label: "duplicate name",
+      manifest: [
+        {
+          name: "safe-name",
+          scope: "global",
+          updated_at: "2026-07-28T00:00:00.000Z",
+        },
+        {
+          name: "safe-name",
+          scope: "global",
+          updated_at: "2026-07-28T00:00:00.000Z",
+        },
+      ],
+    },
+  ];
+
+  for (const variant of variants) {
+    const { cwd } = makeWorkspace();
+    const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-skill-home-"));
+    process.env.HOME = homeDir;
+    let bodyFetches = 0;
+    globalThis.fetch = async (input) => {
+      const url = input instanceof URL ? input : new URL(input);
+      if (url.pathname.endsWith("/manifest")) {
+        return {
+          ok: true,
+          status: 200,
+          statusText: "OK",
+          json: async () => ({ skills: variant.manifest }),
+        };
+      }
+      bodyFetches += 1;
+      throw new Error("body fetch must not occur");
+    };
+    const outcome = await runSkillSyncForCli(cwd, "codex");
+    assert.equal(outcome.kind, "failed", variant.label);
+    assert.equal(bodyFetches, 0, variant.label);
+  }
+});
+
+test("runSkillSyncForCli: sanitizes an unsafe legacy state key without filesystem mutation", async () => {
+  const { cwd } = makeWorkspace();
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-skill-home-"));
+  process.env.HOME = homeDir;
+  const victimDir = path.join(homeDir, "Documents");
+  fs.mkdirSync(victimDir);
+  fs.writeFileSync(path.join(victimDir, "sentinel.txt"), "keep", "utf8");
+  fs.mkdirSync(path.dirname(daemonStatePath(homeDir)), { recursive: true });
+  fs.writeFileSync(
+    daemonStatePath(homeDir),
+    JSON.stringify({
+      skills: {
+        "codex:../../Documents": {
+          cli: "codex",
+          scope: "global",
+          updated_at: "2026-07-27T00:00:00.000Z",
+          path: victimDir,
+        },
+      },
+    }),
+    "utf8",
+  );
+  globalThis.fetch = createFetchStub({
+    manifests: { codex: [] },
+    bodies: {},
+  });
+
+  const outcome = await runSkillSyncForCli(cwd, "codex");
+  assert.equal(outcome.kind, "unchanged");
+  assert.equal(
+    fs.readFileSync(path.join(victimDir, "sentinel.txt"), "utf8"),
+    "keep",
+  );
+  const state = JSON.parse(fs.readFileSync(daemonStatePath(homeDir), "utf8"));
+  assert.deepEqual(state.skills, {});
+});

package/scaffold/mcp/tests/ungoverned-scanner.test.mjs

@@ -5,6 +5,8 @@ import os from "node:os";
 import path from "node:path";
 
 import { runScanOnce, writeHostAuditEvent, startUngovernedScanner } from "../dist/daemon/ungoverned-scanner.js";
+import { claimEnterpriseHostIdentity } from "../dist/core/enterprise-host-identity.js";
+import { enterpriseCredentialId } from "../dist/core/license.js";
 
 function makeWorkspace(governMode, installs = null) {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-ungoverned-"));
@@ -41,7 +43,7 @@ test("writeHostAuditEvent appends one JSONL line per call", async () => {
   }
 });
 
-test("runScanOnce: writes audit event with action=logged in advisory mode", async () => {
+test("runScanOnce: does not write unattributed host process metadata into project audit", async () => {
   const { root } = makeWorkspace("advisory");
   try {
     const fakeProcs = [
@@ -54,20 +56,64 @@ test("runScanOnce: writes audit event with action=logged in advisory mode", asyn
     });
     assert.equal(findings.length, 1);
 
-    const date = new Date().toISOString().slice(0, 10);
-    const file = path.join(root, ".context", "audit", `host-events-${date}.jsonl`);
-    const events = fs.readFileSync(file, "utf8").trim().split("\n").map(JSON.parse);
-    assert.equal(events.length, 1);
-    assert.equal(events[0].event_type, "ungoverned_ai_session_detected");
-    assert.equal(events[0].cli, "claude");
-    assert.equal(events[0].mode, "advisory");
-    assert.equal(events[0].action, "logged");
-    assert.equal(events[0].host_id, "test-host");
+    assert.equal(
+      fs.existsSync(path.join(root, ".context", "audit")),
+      false,
+    );
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
   }
 });
 
+test("runScanOnce: writes detections only to the credential-bound user-global queue", async () => {
+  const { root } = makeWorkspace("advisory");
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "cortex-global-events-"));
+  const endpoint = "https://events.example.com";
+  const apiKey = "ent_global_events_12345678";
+  const credentialId = enterpriseCredentialId(endpoint, apiKey);
+  process.env.HOME = homeDir;
+  try {
+    assert.equal(
+      claimEnterpriseHostIdentity(credentialId, endpoint),
+      true,
+    );
+    await runScanOnce({
+      cwd: root,
+      credentialId,
+      detectorOptions: {
+        hostId: "host-global",
+        processes: [
+          {
+            pid: 4321,
+            ppid: 1,
+            user: os.userInfo().username,
+            comm: "claude",
+            args: "claude --prompt private",
+          },
+        ],
+      },
+    });
+
+    assert.equal(fs.existsSync(path.join(root, ".context", "audit")), false);
+    const queueDir = path.join(homeDir, ".cortex", "host-events");
+    const queueFile = fs.readdirSync(queueDir).find((name) =>
+      name.startsWith("ungoverned-")
+    );
+    assert.ok(queueFile);
+    assert.equal(fs.statSync(path.join(queueDir, queueFile)).mode & 0o777, 0o600);
+    const event = JSON.parse(
+      fs.readFileSync(path.join(queueDir, queueFile), "utf8").trim(),
+    );
+    assert.equal(event.credential_id, credentialId);
+    assert.equal(event.pid, 4321);
+    assert.match(event.args, /private/);
+  } finally {
+    delete process.env.HOME;
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.rmSync(homeDir, { recursive: true, force: true });
+  }
+});
+
 test("runScanOnce: enforced mode marks action=sigterm but our mock doesn't actually signal real procs", async () => {
   const { root } = makeWorkspace("enforced");
   try {
@@ -91,12 +137,11 @@ test("runScanOnce: enforced mode marks action=sigterm but our mock doesn't actua
       process.kill = origKill;
     }
 
-    const date = new Date().toISOString().slice(0, 10);
-    const file = path.join(root, ".context", "audit", `host-events-${date}.jsonl`);
-    const events = fs.readFileSync(file, "utf8").trim().split("\n").map(JSON.parse);
-    assert.equal(events[0].mode, "enforced");
-    assert.equal(events[0].action, "sigterm");
     assert.deepEqual(killed, [99999, "SIGTERM"]);
+    assert.equal(
+      fs.existsSync(path.join(root, ".context", "audit")),
+      false,
+    );
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
   }
@@ -127,9 +172,15 @@ test("runScanOnce: emits onFinding callback per detection", async () => {
 test("runScanOnce: skips Tier 1 CLIs that already have managed installs", async () => {
   const { root } = makeWorkspace("enforced");
   const managedClaudePath = path.join(root, "managed-settings.json");
-  fs.writeFileSync(managedClaudePath, "{}\n");
+  fs.writeFileSync(
+    managedClaudePath,
+    JSON.stringify({ allowManagedHooksOnly: true }) + "\n",
+  );
   const managedCodexPath = path.join(root, "requirements.toml");
-  fs.writeFileSync(managedCodexPath, "# managed\n");
+  fs.writeFileSync(
+    managedCodexPath,
+    "# Cortex govern — codex requirements (test).\n",
+  );
   fs.writeFileSync(
     path.join(root, ".context", "govern.local.json"),
     JSON.stringify({
@@ -160,16 +211,47 @@ test("runScanOnce: skips Tier 1 CLIs that already have managed installs", async
     const findings = await runScanOnce({
       cwd: root,
       mode: "enforced",
+      managedPathOverrides: {
+        claude: managedClaudePath,
+        codex: managedCodexPath,
+      },
       detectorOptions: { processes: fakeProcs, hostId: "test-host" },
     });
     assert.equal(findings.length, 1);
     assert.equal(findings[0].cli, "copilot");
 
-    const date = new Date().toISOString().slice(0, 10);
-    const file = path.join(root, ".context", "audit", `host-events-${date}.jsonl`);
-    const events = fs.readFileSync(file, "utf8").trim().split("\n").map(JSON.parse);
-    assert.equal(events.length, 1);
-    assert.equal(events[0].cli, "copilot");
+    assert.equal(fs.existsSync(path.join(root, ".context", "audit")), false);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("runScanOnce: forged persisted paths cannot suppress Tier 1 findings", async () => {
+  const { root } = makeWorkspace("advisory", {
+    claude: {
+      mode: "advisory",
+      path: "/bin/sh",
+      version: "forged",
+      frameworks: [],
+      installed_at: "now",
+    },
+  });
+  try {
+    const findings = await runScanOnce({
+      cwd: root,
+      mode: "advisory",
+      detectorOptions: {
+        processes: [{
+          pid: 7654,
+          ppid: 1,
+          user: os.userInfo().username,
+          comm: "claude",
+          args: "claude --prompt hi",
+        }],
+      },
+    });
+    assert.equal(findings.length, 1);
+    assert.equal(findings[0].cli, "claude");
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
   }

package/scaffold/mcp/tests/workflow-cli.test.mjs

@@ -5,6 +5,10 @@ import os from "node:os";
 import path from "node:path";
 
 import { runStageCommand } from "../dist/cli/stage.js";
+import { enterpriseCredentialId } from "../dist/core/license.js";
+
+const ENTERPRISE_ENDPOINT = "https://licenses.example.com";
+const ENTERPRISE_KEY = "ent_workflow_cli_12345678";
 
 const TINY_WORKFLOW = {
   id: "tiny",
@@ -41,7 +45,12 @@ function makeWorkspace() {
   fs.mkdirSync(path.join(dir, ".context"), { recursive: true });
   fs.writeFileSync(
     path.join(dir, ".context", "enterprise.yml"),
-    "enterprise:\n  api_key: test-key-for-cli-tests\n",
+    [
+      "enterprise:",
+      `  api_key: ${ENTERPRISE_KEY}`,
+      `  endpoint: ${ENTERPRISE_ENDPOINT}`,
+      "",
+    ].join("\n"),
     "utf8",
   );
   return dir;
@@ -53,6 +62,10 @@ function writeSyncedWorkflow(homeDir, workflowId, definition) {
   fs.writeFileSync(
     path.join(cortexDir, "workflows.local.json"),
     JSON.stringify({
+      credential_id: enterpriseCredentialId(
+        ENTERPRISE_ENDPOINT,
+        ENTERPRISE_KEY,
+      ),
       workflows: {
         [workflowId]: {
           workflow_id: workflowId,