@usezombie/zombiectl 0.3.0

package/test/harness-compile.test.js

@@ -0,0 +1,81 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { Writable } from "node:stream";
+import { runCli } from "../src/cli.js";
+
+function bufferStream() {
+  let data = "";
+  return {
+    stream: new Writable({
+      write(chunk, _enc, cb) {
+        data += String(chunk);
+        cb();
+      },
+    }),
+    read: () => data,
+  };
+}
+
+test("harness compile sends profile_id selector", async () => {
+  const out = bufferStream();
+  const err = bufferStream();
+
+  const fetchImpl = async (url, options) => {
+    assert.equal(url, "http://localhost:3000/v1/workspaces/ws_123/harness/compile");
+    assert.equal(options.method, "POST");
+    const payload = JSON.parse(String(options.body));
+    assert.equal(payload.agent_id, "ws_123-harness");
+    assert.equal(payload.config_version_id, null);
+    return {
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify({ compile_job_id: "cjob_123", is_valid: true }),
+    };
+  };
+
+  const code = await runCli(
+    ["harness", "compile", "--workspace-id", "ws_123", "--agent-id", "ws_123-harness"],
+    {
+      env: { ...process.env, ZOMBIE_TOKEN: "header.payload.sig" },
+      stdout: out.stream,
+      stderr: err.stream,
+      fetchImpl,
+    },
+  );
+
+  assert.equal(code, 0);
+  assert.equal(err.read(), "");
+  assert.match(out.read(), /Harness compile/);
+  assert.match(out.read(), /compile_job_id[\s·]+cjob_123/);
+});
+
+test("harness compile sends profile_version_id selector", async () => {
+  const out = bufferStream();
+  const err = bufferStream();
+
+  const fetchImpl = async (_url, options) => {
+    const payload = JSON.parse(String(options.body));
+    assert.equal(payload.agent_id, null);
+    assert.equal(payload.config_version_id, "pver_456");
+    return {
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify({ compile_job_id: "cjob_456", is_valid: true }),
+    };
+  };
+
+  const code = await runCli(
+    ["harness", "compile", "--workspace-id", "ws_123", "--config-version-id", "pver_456"],
+    {
+      env: { ...process.env, ZOMBIE_TOKEN: "header.payload.sig" },
+      stdout: out.stream,
+      stderr: err.stream,
+      fetchImpl,
+    },
+  );
+
+  assert.equal(code, 0);
+  assert.equal(err.read(), "");
+  assert.match(out.read(), /Harness compile/);
+  assert.match(out.read(), /compile_job_id[\s·]+cjob_456/);
+});

package/test/harness-lifecycle.integration.test.js

@@ -0,0 +1,339 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { Writable } from "node:stream";
+import { runCli } from "../src/cli.js";
+
+function bufferStream() {
+  let data = "";
+  return {
+    stream: new Writable({
+      write(chunk, _enc, cb) {
+        data += String(chunk);
+        cb();
+      },
+    }),
+    read: () => data,
+    reset: () => {
+      data = "";
+    },
+  };
+}
+
+function parseJsonOutput(text) {
+  return JSON.parse(String(text).trim());
+}
+
+test("harness lifecycle: activate deterministically changes subsequent run snapshot linkage", async () => {
+  const out = bufferStream();
+  const err = bufferStream();
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "zombiectl-harness-lifecycle-"));
+  const filePath = path.join(tmpDir, "profile.md");
+  await fs.writeFile(filePath, "# Harness\n\n```json\n{\"profile_id\":\"ws_123-harness\",\"stages\":[]}\n```", "utf8");
+  const prevStateDir = process.env.ZOMBIE_STATE_DIR;
+  process.env.ZOMBIE_STATE_DIR = tmpDir;
+
+  const state = {
+    activeProfileVersion: null,
+    profileByVersion: new Map(),
+    sequence: 0,
+    runCounter: 0,
+  };
+
+  const fetchImpl = async (url, options = {}) => {
+    const u = new URL(url);
+    const route = `${options.method || "GET"} ${u.pathname}`;
+
+    if (route === "PUT /v1/workspaces/ws_123/harness/source") {
+      state.sequence += 1;
+      const version = `pver_${state.sequence}`;
+      state.profileByVersion.set(version, "ws_123-harness");
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({ agent_id: "ws_123-harness", config_version_id: version }),
+      };
+    }
+
+    if (route === "POST /v1/workspaces/ws_123/harness/compile") {
+      const body = JSON.parse(String(options.body || "{}"));
+      const version = body.config_version_id;
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({
+          compile_job_id: `cjob_${version}`,
+          agent_id: state.profileByVersion.get(version),
+          config_version_id: version,
+          is_valid: true,
+          validation_report_json: "{}",
+        }),
+      };
+    }
+
+    if (route === "POST /v1/workspaces/ws_123/harness/activate") {
+      const body = JSON.parse(String(options.body || "{}"));
+      state.activeProfileVersion = body.config_version_id;
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({
+          workspace_id: "ws_123",
+          agent_id: state.profileByVersion.get(state.activeProfileVersion),
+          config_version_id: state.activeProfileVersion,
+          run_snapshot_version: state.activeProfileVersion,
+          activated_by: body.activated_by || "zombiectl",
+          activated_at: 1730000000,
+        }),
+      };
+    }
+
+    if (route === "GET /v1/workspaces/ws_123/harness/active") {
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({
+          workspace_id: "ws_123",
+          source: state.activeProfileVersion ? "active" : "default-v1",
+          agent_id: state.activeProfileVersion ? state.profileByVersion.get(state.activeProfileVersion) : null,
+          config_version_id: state.activeProfileVersion,
+          run_snapshot_version: state.activeProfileVersion,
+          active_at: state.activeProfileVersion ? 1730000000 : null,
+          profile: { profile_id: state.activeProfileVersion || "default-v1", stages: [] },
+        }),
+      };
+    }
+
+    if (route === "POST /v1/runs") {
+      state.runCounter += 1;
+      return {
+        ok: true,
+        status: 202,
+        text: async () => JSON.stringify({
+          run_id: `r_${state.runCounter}`,
+          state: "SPEC_QUEUED",
+          attempt: 1,
+          run_snapshot_version: state.activeProfileVersion,
+          request_id: `req_${state.runCounter}`,
+        }),
+      };
+    }
+
+    throw new Error(`unexpected route: ${route}`);
+  };
+
+  try {
+    const env = { ...process.env, ZOMBIE_TOKEN: "header.payload.sig" };
+
+    assert.equal(
+      await runCli(["harness", "source", "put", "--workspace-id", "ws_123", "--file", filePath], {
+        env,
+        stdout: out.stream,
+        stderr: err.stream,
+        fetchImpl,
+      }),
+      0,
+    );
+    assert.equal(
+      await runCli(["harness", "compile", "--workspace-id", "ws_123", "--config-version-id", "pver_1"], {
+        env,
+        stdout: out.stream,
+        stderr: err.stream,
+        fetchImpl,
+      }),
+      0,
+    );
+    assert.equal(
+      await runCli(["harness", "activate", "--workspace-id", "ws_123", "--config-version-id", "pver_1"], {
+        env,
+        stdout: out.stream,
+        stderr: err.stream,
+        fetchImpl,
+      }),
+      0,
+    );
+
+    out.reset();
+
+    assert.equal(
+      await runCli([
+        "--json",
+        "run",
+        "--workspace-id",
+        "ws_123",
+        "--spec-id",
+        "spec_123",
+        "--idempotency-key",
+        "idem_1",
+      ], {
+        env,
+        stdout: out.stream,
+        stderr: err.stream,
+        fetchImpl,
+      }),
+      0,
+    );
+    const firstRun = parseJsonOutput(out.read());
+    assert.equal(firstRun.run_snapshot_version, "pver_1");
+
+    out.reset();
+    assert.equal(
+      await runCli(["harness", "source", "put", "--workspace-id", "ws_123", "--file", filePath], {
+        env,
+        stdout: out.stream,
+        stderr: err.stream,
+        fetchImpl,
+      }),
+      0,
+    );
+    assert.equal(
+      await runCli(["harness", "compile", "--workspace-id", "ws_123", "--config-version-id", "pver_2"], {
+        env,
+        stdout: out.stream,
+        stderr: err.stream,
+        fetchImpl,
+      }),
+      0,
+    );
+    assert.equal(
+      await runCli(["harness", "activate", "--workspace-id", "ws_123", "--config-version-id", "pver_2"], {
+        env,
+        stdout: out.stream,
+        stderr: err.stream,
+        fetchImpl,
+      }),
+      0,
+    );
+
+    out.reset();
+    assert.equal(
+      await runCli([
+        "--json",
+        "run",
+        "--workspace-id",
+        "ws_123",
+        "--spec-id",
+        "spec_123",
+        "--idempotency-key",
+        "idem_2",
+      ], {
+        env,
+        stdout: out.stream,
+        stderr: err.stream,
+        fetchImpl,
+      }),
+      0,
+    );
+    const secondRun = parseJsonOutput(out.read());
+
+    assert.equal(secondRun.run_snapshot_version, "pver_2");
+    assert.notEqual(firstRun.run_snapshot_version, secondRun.run_snapshot_version);
+    assert.equal(err.read(), "");
+  } finally {
+    if (prevStateDir === undefined) delete process.env.ZOMBIE_STATE_DIR;
+    else process.env.ZOMBIE_STATE_DIR = prevStateDir;
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  }
+}, 15000);
+
+test("harness lifecycle contract: API and CLI JSON expose profile identity parity fields", async () => {
+  const out = bufferStream();
+  const err = bufferStream();
+  const stateDir = await fs.mkdtemp(path.join(os.tmpdir(), "zombiectl-harness-parity-"));
+  const prevStateDir = process.env.ZOMBIE_STATE_DIR;
+  process.env.ZOMBIE_STATE_DIR = stateDir;
+
+  const fetchImpl = async (url, options = {}) => {
+    const u = new URL(url);
+    const route = `${options.method || "GET"} ${u.pathname}`;
+
+    if (route === "POST /v1/workspaces/ws_123/harness/activate") {
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({
+          workspace_id: "ws_123",
+          agent_id: "ws_123-harness",
+          config_version_id: "pver_2",
+          run_snapshot_version: "pver_2",
+          activated_by: "operator",
+          activated_at: 1730000100,
+        }),
+      };
+    }
+
+    if (route === "GET /v1/workspaces/ws_123/harness/active") {
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({
+          workspace_id: "ws_123",
+          source: "active",
+          agent_id: "ws_123-harness",
+          config_version_id: "pver_2",
+          run_snapshot_version: "pver_2",
+          active_at: 1730000100,
+          profile: { profile_id: "ws_123-harness", stages: [] },
+        }),
+      };
+    }
+
+    throw new Error(`unexpected route: ${route}`);
+  };
+
+  const env = { ...process.env, ZOMBIE_TOKEN: "header.payload.sig" };
+
+  try {
+    assert.equal(
+      await runCli(
+        [
+          "--json",
+          "harness",
+          "activate",
+          "--workspace-id",
+          "ws_123",
+          "--config-version-id",
+          "pver_2",
+          "--activated-by",
+          "operator",
+        ],
+        {
+          env,
+          stdout: out.stream,
+          stderr: err.stream,
+          fetchImpl,
+        },
+      ),
+      0,
+    );
+    const activatePayload = parseJsonOutput(out.read());
+    assert.equal(activatePayload.agent_id, "ws_123-harness");
+    assert.equal(activatePayload.config_version_id, "pver_2");
+    assert.equal(activatePayload.run_snapshot_version, "pver_2");
+    assert.equal(activatePayload.activated_at, 1730000100);
+
+    out.reset();
+
+    assert.equal(
+      await runCli(["--json", "harness", "active", "--workspace-id", "ws_123"], {
+        env,
+        stdout: out.stream,
+        stderr: err.stream,
+        fetchImpl,
+      }),
+      0,
+    );
+    const activePayload = parseJsonOutput(out.read());
+    assert.equal(activePayload.agent_id, "ws_123-harness");
+    assert.equal(activePayload.config_version_id, "pver_2");
+    assert.equal(activePayload.run_snapshot_version, "pver_2");
+    assert.equal(activePayload.active_at, 1730000100);
+    assert.equal(err.read(), "");
+  } finally {
+    if (prevStateDir === undefined) delete process.env.ZOMBIE_STATE_DIR;
+    else process.env.ZOMBIE_STATE_DIR = prevStateDir;
+    await fs.rm(stateDir, { recursive: true, force: true });
+  }
+}, 15000);

package/test/harness-source-put.test.js

@@ -0,0 +1,72 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { Writable } from "node:stream";
+import { runCli } from "../src/cli.js";
+
+function bufferStream() {
+  let data = "";
+  return {
+    stream: new Writable({
+      write(chunk, _enc, cb) {
+        data += String(chunk);
+        cb();
+      },
+    }),
+    read: () => data,
+  };
+}
+
+test("harness source put uploads markdown file content as source_markdown", async () => {
+  const out = bufferStream();
+  const err = bufferStream();
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "zombiectl-harness-"));
+  const filePath = path.join(tmpDir, "agent-profile.md");
+  const markdown = "# Harness\n\n```json\n{\"profile_id\":\"ws_123-harness\",\"stages\":[]}\n```";
+  await fs.writeFile(filePath, markdown, "utf8");
+
+  try {
+    const fetchImpl = async (url, options) => {
+      assert.equal(url, "http://localhost:3000/v1/workspaces/ws_123/harness/source");
+      assert.equal(options.method, "PUT");
+      const payload = JSON.parse(String(options.body));
+      assert.equal(payload.agent_id, "ws_123-harness");
+      assert.equal(payload.name, "agent-profile");
+      assert.equal(payload.source_markdown, markdown);
+      return {
+        ok: true,
+        status: 200,
+        text: async () => JSON.stringify({ config_version_id: "pver_123" }),
+      };
+    };
+
+    const code = await runCli(
+      [
+        "harness",
+        "source",
+        "put",
+        "--workspace-id",
+        "ws_123",
+        "--file",
+        filePath,
+        "--agent-id",
+        "ws_123-harness",
+      ],
+      {
+        env: { ...process.env, ZOMBIE_TOKEN: "header.payload.sig" },
+        stdout: out.stream,
+        stderr: err.stream,
+        fetchImpl,
+      },
+    );
+
+    assert.equal(code, 0);
+    assert.equal(err.read(), "");
+    assert.match(out.read(), /Harness source stored/);
+    assert.match(out.read(), /config_version_id[\s·]+pver_123/);
+  } finally {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  }
+});

package/test/harness_activate.unit.test.js

@@ -0,0 +1,48 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { commandHarnessActivate } from "../src/commands/harness_activate.js";
+import { makeNoop, makeBufferStream, ui, PVER_ID } from "./helpers.js";
+
+test("commandHarnessActivate returns 2 when profile-version-id is missing", async () => {
+  const err = makeBufferStream();
+  const deps = { ui, writeLine: (stream, line = "") => stream.write(`${line}\n`) };
+  const parsed = { options: {}, positionals: [] };
+  const code = await commandHarnessActivate({ stdout: makeNoop(), stderr: err.stream, jsonMode: false }, parsed, "ws_123", deps);
+  assert.equal(code, 2);
+  assert.match(err.read(), /--config-version-id/);
+});
+
+test("commandHarnessActivate sends profile_version_id and activated_by", async () => {
+  let captured = null;
+  const deps = {
+    request: async (_ctx, reqPath, options) => {
+      captured = { reqPath, options };
+      return { agent_id: "agent_1", config_version_id: PVER_ID, run_snapshot_version: PVER_ID };
+    },
+    apiHeaders: () => ({}),
+    ui,
+    printJson: () => {},
+    writeLine: () => {},
+  };
+  const parsed = { options: { "config-version-id": PVER_ID, "activated-by": "operator" }, positionals: [] };
+  const code = await commandHarnessActivate({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, "ws_123", deps);
+  assert.equal(code, 0);
+  assert.equal(captured.reqPath, "/v1/workspaces/ws_123/harness/activate");
+  const body = JSON.parse(captured.options.body);
+  assert.equal(body.config_version_id, PVER_ID);
+  assert.equal(body.activated_by, "operator");
+});
+
+test("commandHarnessActivate defaults activated_by to zombiectl", async () => {
+  let body = null;
+  const deps = {
+    request: async (_ctx, _p, options) => { body = JSON.parse(options.body); return {}; },
+    apiHeaders: () => ({}),
+    ui,
+    printJson: () => {},
+    writeLine: () => {},
+  };
+  const parsed = { options: { "config-version-id": PVER_ID }, positionals: [] };
+  await commandHarnessActivate({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, "ws_123", deps);
+  assert.equal(body.activated_by, "zombiectl");
+});

package/test/harness_active.unit.test.js

@@ -0,0 +1,53 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { commandHarnessActive } from "../src/commands/harness_active.js";
+import { makeNoop, makeBufferStream, ui, PVER_ID } from "./helpers.js";
+
+test("commandHarnessActive calls GET harness/active", async () => {
+  let captured = null;
+  const deps = {
+    request: async (_ctx, reqPath, options) => {
+      captured = { reqPath, options };
+      return { agent_id: "agent_1", config_version_id: PVER_ID, run_snapshot_version: PVER_ID };
+    },
+    apiHeaders: () => ({}),
+    ui,
+    printJson: () => {},
+    writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  const code = await commandHarnessActive({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, "ws_123", deps);
+  assert.equal(code, 0);
+  assert.equal(captured.reqPath, "/v1/workspaces/ws_123/harness/active");
+  assert.equal(captured.options.method, "GET");
+});
+
+test("commandHarnessActive json mode outputs raw response", async () => {
+  let printed = null;
+  const deps = {
+    request: async () => ({ agent_id: "agent_1", config_version_id: PVER_ID, run_snapshot_version: PVER_ID }),
+    apiHeaders: () => ({}),
+    ui,
+    printJson: (_stream, v) => { printed = v; },
+    writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  const code = await commandHarnessActive({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: true }, parsed, "ws_123", deps);
+  assert.equal(code, 0);
+  assert.equal(printed.config_version_id, PVER_ID);
+});
+
+test("commandHarnessActive falls back to default-v1 for null fields", async () => {
+  let output = "";
+  const deps = {
+    request: async () => ({ agent_id: null, config_version_id: null, run_snapshot_version: null }),
+    apiHeaders: () => ({}),
+    ui,
+    printJson: () => {},
+    printSection: (_stream, title) => { output += title; },
+    printKeyValue: (_stream, rows) => { output += Object.values(rows).join(" "); },
+  };
+  const parsed = { options: {}, positionals: [] };
+  await commandHarnessActive({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, "ws_123", deps);
+  assert.match(output, /default-v1/);
+});

package/test/harness_compile.unit.test.js

@@ -0,0 +1,54 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { commandHarnessCompile } from "../src/commands/harness_compile.js";
+import { makeNoop, ui, AGENT_ID, PVER_ID } from "./helpers.js";
+
+test("commandHarnessCompile sends profile_version_id", async () => {
+  let captured = null;
+  const deps = {
+    request: async (_ctx, reqPath, options) => { captured = { reqPath, options }; return { compile_job_id: "cjob_1", is_valid: true }; },
+    apiHeaders: () => ({}),
+    ui,
+    printJson: () => {},
+    writeLine: () => {},
+  };
+  const parsed = { options: { "config-version-id": PVER_ID }, positionals: [] };
+  const code = await commandHarnessCompile({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, "ws_123", deps);
+  assert.equal(code, 0);
+  assert.equal(captured.reqPath, "/v1/workspaces/ws_123/harness/compile");
+  const body = JSON.parse(captured.options.body);
+  assert.equal(body.config_version_id, PVER_ID);
+  assert.equal(body.agent_id, null);
+});
+
+test("commandHarnessCompile sends profile_id selector", async () => {
+  let captured = null;
+  const deps = {
+    request: async (_ctx, reqPath, options) => { captured = { reqPath, options }; return { compile_job_id: "cjob_2", is_valid: true }; },
+    apiHeaders: () => ({}),
+    ui,
+    printJson: () => {},
+    writeLine: () => {},
+  };
+  const parsed = { options: { "agent-id": AGENT_ID }, positionals: [] };
+  const code = await commandHarnessCompile({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: false }, parsed, "ws_123", deps);
+  assert.equal(code, 0);
+  const body = JSON.parse(captured.options.body);
+  assert.equal(body.agent_id, AGENT_ID);
+  assert.equal(body.config_version_id, null);
+});
+
+test("commandHarnessCompile json mode outputs raw response", async () => {
+  let printed = null;
+  const deps = {
+    request: async () => ({ compile_job_id: "cjob_3", is_valid: false }),
+    apiHeaders: () => ({}),
+    ui,
+    printJson: (_stream, v) => { printed = v; },
+    writeLine: () => {},
+  };
+  const parsed = { options: {}, positionals: [] };
+  const code = await commandHarnessCompile({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: true }, parsed, "ws_123", deps);
+  assert.equal(code, 0);
+  assert.equal(printed.compile_job_id, "cjob_3");
+});