@danielblomma/cortex-mcp 2.0.5 → 2.0.7

package/scaffold/mcp/tests/workflow-synced-registry.test.mjs

@@ -0,0 +1,179 @@
+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 {
+  loadSyncedWorkflows,
+  syncedWorkflowsCachePath,
+} from "../dist/core/workflow/synced-registry.js";
+import { runWorkflowStart } from "../dist/core/workflow/mcp-tools.js";
+import { SECURE_BUILD_WORKFLOW } from "../dist/core/workflow/default-workflows.js";
+
+function makeWorkspace() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "cortex-synced-registry-"));
+}
+
+const TINY_WORKFLOW = {
+  id: "tiny",
+  description: "Two-stage tests workflow",
+  version: 1,
+  stages: [
+    {
+      name: "plan",
+      artifact: "plan.md",
+      reads: [],
+      required_fields: [],
+      capability: "planner",
+      description: "Produce a plan.",
+    },
+    {
+      name: "review",
+      artifact: "review.md",
+      reads: ["plan"],
+      required_fields: ["approved"],
+      capability: "reviewer",
+      description: "Review the plan.",
+    },
+  ],
+};
+
+function writeCache(dir, payload) {
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(
+    syncedWorkflowsCachePath(dir),
+    JSON.stringify(payload, null, 2),
+    "utf8",
+  );
+}
+
+test("syncedWorkflowsCachePath: defaults to ~/.cortex/workflows.local.json", () => {
+  const expected = path.join(os.homedir(), ".cortex", "workflows.local.json");
+  assert.equal(syncedWorkflowsCachePath(), expected);
+});
+
+test("loadSyncedWorkflows: returns {} when cache is missing", () => {
+  const dir = makeWorkspace();
+  assert.deepEqual(loadSyncedWorkflows(dir), {});
+});
+
+test("loadSyncedWorkflows: returns {} when cache is unreadable JSON", () => {
+  const dir = makeWorkspace();
+  fs.writeFileSync(syncedWorkflowsCachePath(dir), "not valid json", "utf8");
+  assert.deepEqual(loadSyncedWorkflows(dir), {});
+});
+
+test("loadSyncedWorkflows: returns {} when 'workflows' key is missing", () => {
+  const dir = makeWorkspace();
+  writeCache(dir, { last_synced_at: "x" });
+  assert.deepEqual(loadSyncedWorkflows(dir), {});
+});
+
+test("loadSyncedWorkflows: drops entries whose definition fails schema", () => {
+  const dir = makeWorkspace();
+  writeCache(dir, {
+    workflows: {
+      "valid-one": {
+        workflow_id: "valid-one",
+        version: 1,
+        updated_at: "2026-05-06T12:00:00.000Z",
+        definition: TINY_WORKFLOW,
+      },
+      "broken-one": {
+        workflow_id: "broken-one",
+        version: 1,
+        updated_at: "2026-05-06T12:00:00.000Z",
+        definition: { id: "broken-one" /* missing stages */ },
+      },
+    },
+  });
+  const loaded = loadSyncedWorkflows(dir);
+  assert.deepEqual(Object.keys(loaded).sort(), ["valid-one"]);
+});
+
+test("loadSyncedWorkflows: returns valid workflow definitions keyed by workflow_id", () => {
+  const dir = makeWorkspace();
+  writeCache(dir, {
+    workflows: {
+      tiny: {
+        workflow_id: "tiny",
+        version: 1,
+        updated_at: "2026-05-06T12:00:00.000Z",
+        definition: TINY_WORKFLOW,
+      },
+    },
+  });
+  const loaded = loadSyncedWorkflows(dir);
+  assert.equal(loaded.tiny.id, "tiny");
+  assert.equal(loaded.tiny.stages.length, 2);
+});
+
+test("resolveWorkflow integration: synced workflow takes precedence over bundled default", () => {
+  // We can't easily intercept loadSyncedWorkflows() from inside
+  // mcp-tools.ts (it reads from a fixed home-dir path). Instead, exercise
+  // the explicit-registry path which mirrors what the merge would do
+  // and confirm the contract: passing a registry that includes the same
+  // id as a bundled default uses the registry version.
+  const cwd = makeWorkspace();
+  process.env.HOME = cwd; // sandbox the cache lookup
+  try {
+    const overridden = {
+      ...SECURE_BUILD_WORKFLOW,
+      description: "Org-overridden secure-build",
+    };
+    const registry = { "secure-build": overridden };
+    const result = runWorkflowStart(
+      {
+        task_id: "task-1",
+        task_description: "test",
+        workflow_id: "secure-build",
+      },
+      { cwd, workflows: registry },
+    );
+    assert.equal(result.state.workflow_id, "secure-build");
+    // The envelope renders the workflow description verbatim — confirms
+    // we got the org-overridden version and not the bundled one.
+    assert.match(result.envelope.prompt, /Org-overridden secure-build/);
+  } finally {
+    delete process.env.HOME;
+  }
+});
+
+test("resolveWorkflow integration: synced cache adds new workflow_ids beyond defaults", () => {
+  const cwd = makeWorkspace();
+  // Build a cache under a tmp HOME and point HOME at it, so that the
+  // home-dir-based loader picks it up.
+  const fakeHome = makeWorkspace();
+  process.env.HOME = fakeHome;
+  try {
+    fs.mkdirSync(path.join(fakeHome, ".cortex"), { recursive: true });
+    fs.writeFileSync(
+      path.join(fakeHome, ".cortex", "workflows.local.json"),
+      JSON.stringify({
+        workflows: {
+          tiny: {
+            workflow_id: "tiny",
+            version: 1,
+            updated_at: "2026-05-06T12:00:00.000Z",
+            definition: TINY_WORKFLOW,
+          },
+        },
+      }),
+      "utf8",
+    );
+
+    const result = runWorkflowStart(
+      {
+        task_id: "task-2",
+        task_description: "Use synced workflow",
+        workflow_id: "tiny",
+      },
+      { cwd },
+    );
+    assert.equal(result.state.workflow_id, "tiny");
+    assert.equal(result.state.current_stage, "plan");
+  } finally {
+    delete process.env.HOME;
+  }
+});

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

@@ -0,0 +1,283 @@
+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 {
+  parseStageArtifact,
+  renderStageArtifact,
+  readRunState,
+  readStageArtifact,
+} from "../dist/core/workflow/artifact-io.js";
+import {
+  createRun,
+  advanceStage,
+  getRunState,
+} from "../dist/core/workflow/run-lifecycle.js";
+import {
+  workflowDefinitionSchema,
+  stageArtifactFrontmatterSchema,
+  runStateSchema,
+} from "../dist/core/workflow/schemas.js";
+import { SECURE_BUILD_WORKFLOW } from "../dist/core/workflow/default-workflows.js";
+
+function makeWorkspace() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "cortex-workflow-"));
+}
+
+const TINY_WORKFLOW = {
+  id: "tiny",
+  description: "Two-stage workflow used for tests",
+  version: 1,
+  stages: [
+    {
+      name: "plan",
+      artifact: "plan.md",
+      reads: [],
+      required_fields: [],
+      description: "Produce a plan",
+    },
+    {
+      name: "review",
+      artifact: "review.md",
+      reads: ["plan"],
+      required_fields: ["approved"],
+      description: "Review the plan",
+    },
+  ],
+};
+
+test("schemas: SECURE_BUILD_WORKFLOW validates against workflowDefinitionSchema", () => {
+  const parsed = workflowDefinitionSchema.parse(SECURE_BUILD_WORKFLOW);
+  assert.equal(parsed.id, "secure-build");
+  assert.ok(parsed.stages.length > 0);
+});
+
+test("schemas: stage names must be slug-cased", () => {
+  assert.throws(() =>
+    workflowDefinitionSchema.parse({
+      ...TINY_WORKFLOW,
+      stages: [
+        { ...TINY_WORKFLOW.stages[0], name: "Bad Name" },
+        TINY_WORKFLOW.stages[1],
+      ],
+    }),
+  );
+});
+
+test("schemas: stage artifact frontmatter requires status + stage", () => {
+  assert.throws(() =>
+    stageArtifactFrontmatterSchema.parse({
+      stage: "plan",
+      // status missing
+      written_at: new Date().toISOString(),
+    }),
+  );
+});
+
+test("artifact-io: render + parse round-trips frontmatter", () => {
+  const fm = stageArtifactFrontmatterSchema.parse({
+    stage: "plan",
+    status: "complete",
+    references: [],
+    written_at: "2026-05-06T19:00:00.000Z",
+  });
+  const text = renderStageArtifact(fm, "# Plan\n\nDo the thing.");
+  const parsed = parseStageArtifact(text);
+  assert.equal(parsed.frontmatter.stage, "plan");
+  assert.equal(parsed.frontmatter.status, "complete");
+  assert.equal(parsed.body, "# Plan\n\nDo the thing.");
+});
+
+test("artifact-io: parseStageArtifact rejects missing frontmatter", () => {
+  assert.throws(() => parseStageArtifact("# No frontmatter here\n"));
+});
+
+test("artifact-io: parseStageArtifact rejects unterminated frontmatter", () => {
+  assert.throws(() =>
+    parseStageArtifact("---\nstage: plan\nstatus: complete\n# no close marker\n"),
+  );
+});
+
+test("artifact-io: parseStageArtifact preserves passthrough fields", () => {
+  const text = `---
+stage: review
+status: complete
+references:
+  - plan.md
+written_at: "2026-05-06T19:00:00.000Z"
+approved: true
+blocking_comments: 0
+---
+
+# Review
+
+Looks good.
+`;
+  const parsed = parseStageArtifact(text);
+  assert.equal(parsed.frontmatter.stage, "review");
+  assert.deepEqual(parsed.frontmatter.references, ["plan.md"]);
+  assert.equal(parsed.frontmatter.approved, true);
+  assert.equal(parsed.frontmatter.blocking_comments, 0);
+});
+
+test("createRun: writes state.json with all stages pending and current_stage = first", () => {
+  const cwd = makeWorkspace();
+  const state = createRun({
+    cwd,
+    taskId: "2026-05-06-fixture",
+    workflow: TINY_WORKFLOW,
+    taskDescription: "Test run",
+  });
+
+  assert.equal(state.task_id, "2026-05-06-fixture");
+  assert.equal(state.current_stage, "plan");
+  assert.equal(state.outcome, "in_progress");
+  assert.deepEqual(
+    state.stages.map((s) => s.status),
+    ["pending", "pending"],
+  );
+
+  const persisted = readRunState(cwd, "2026-05-06-fixture");
+  assert.deepEqual(persisted, state);
+});
+
+test("advanceStage: writes artifact, updates state, advances current_stage", () => {
+  const cwd = makeWorkspace();
+  const taskId = "2026-05-06-advance";
+  createRun({ cwd, taskId, workflow: TINY_WORKFLOW, taskDescription: "Test" });
+
+  const after = advanceStage({
+    cwd,
+    taskId,
+    workflow: TINY_WORKFLOW,
+    stageName: "plan",
+    artifactName: "plan.md",
+    frontmatter: { stage: "plan", status: "complete", references: [] },
+    body: "# Plan\n\n- step 1\n- step 2",
+  });
+
+  assert.equal(after.current_stage, "review");
+  assert.equal(after.outcome, "in_progress");
+  assert.equal(after.stages[0].status, "complete");
+  assert.equal(after.stages[0].artifact, "plan.md");
+  assert.equal(after.stages[1].status, "pending");
+
+  // Artifact lives on disk under .agents/<taskId>/
+  const artifactPath = path.join(cwd, ".agents", taskId, "plan.md");
+  assert.ok(fs.existsSync(artifactPath));
+  const parsed = readStageArtifact(cwd, taskId, "plan.md");
+  assert.equal(parsed.frontmatter.stage, "plan");
+});
+
+test("advanceStage: marks run complete after final stage", () => {
+  const cwd = makeWorkspace();
+  const taskId = "2026-05-06-final";
+  createRun({ cwd, taskId, workflow: TINY_WORKFLOW, taskDescription: "Test" });
+
+  advanceStage({
+    cwd,
+    taskId,
+    workflow: TINY_WORKFLOW,
+    stageName: "plan",
+    artifactName: "plan.md",
+    frontmatter: { stage: "plan", status: "complete", references: [] },
+    body: "# Plan",
+  });
+
+  const after = advanceStage({
+    cwd,
+    taskId,
+    workflow: TINY_WORKFLOW,
+    stageName: "review",
+    artifactName: "review.md",
+    frontmatter: {
+      stage: "review",
+      status: "complete",
+      references: ["plan.md"],
+      approved: true,
+    },
+    body: "# Review\n\napproved",
+    outcome: { approved: true },
+  });
+
+  assert.equal(after.current_stage, null);
+  assert.equal(after.outcome, "complete");
+  assert.ok(after.completed_at);
+  assert.deepEqual(after.stages[1].outcome, { approved: true });
+});
+
+test("advanceStage: blocked status surfaces as run outcome", () => {
+  const cwd = makeWorkspace();
+  const taskId = "2026-05-06-blocked";
+  createRun({ cwd, taskId, workflow: TINY_WORKFLOW, taskDescription: "Test" });
+
+  const after = advanceStage({
+    cwd,
+    taskId,
+    workflow: TINY_WORKFLOW,
+    stageName: "plan",
+    artifactName: "plan.md",
+    frontmatter: { stage: "plan", status: "blocked", references: [] },
+    body: "# Plan blocked",
+    status: "blocked",
+  });
+
+  assert.equal(after.outcome, "blocked");
+  assert.equal(after.current_stage, null);
+});
+
+test("advanceStage: refuses to advance the wrong stage", () => {
+  const cwd = makeWorkspace();
+  const taskId = "2026-05-06-wrong";
+  createRun({ cwd, taskId, workflow: TINY_WORKFLOW, taskDescription: "Test" });
+
+  assert.throws(() =>
+    advanceStage({
+      cwd,
+      taskId,
+      workflow: TINY_WORKFLOW,
+      stageName: "review",
+      artifactName: "review.md",
+      frontmatter: { stage: "review", status: "complete", references: [] },
+      body: "# Out of order",
+    }),
+  );
+});
+
+test("getRunState: returns null for missing tasks", () => {
+  const cwd = makeWorkspace();
+  assert.equal(getRunState(cwd, "no-such-task"), null);
+});
+
+test("readRunState: validates persisted state against schema", () => {
+  const cwd = makeWorkspace();
+  const taskId = "2026-05-06-corrupt";
+  createRun({ cwd, taskId, workflow: TINY_WORKFLOW, taskDescription: "Test" });
+
+  // Corrupt the file: drop required field.
+  const statePath = path.join(cwd, ".agents", taskId, "state.json");
+  const raw = JSON.parse(fs.readFileSync(statePath, "utf8"));
+  delete raw.workflow_id;
+  fs.writeFileSync(statePath, JSON.stringify(raw, null, 2));
+
+  assert.throws(() => readRunState(cwd, taskId));
+});
+
+test("runStateSchema: rejects unknown outcome", () => {
+  assert.throws(() =>
+    runStateSchema.parse({
+      schema_version: 1,
+      task_id: "x",
+      workflow_id: "tiny",
+      workflow_version: 1,
+      task_description: "y",
+      current_stage: null,
+      outcome: "totally-bogus",
+      started_at: new Date().toISOString(),
+      completed_at: null,
+      stages: [{ name: "plan", status: "complete" }],
+    }),
+  );
+});