@usezombie/zombiectl 0.3.0

package/test/harness_source.unit.test.js

@@ -0,0 +1,59 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { commandHarnessSourcePut } from "../src/commands/harness_source.js";
+import { makeNoop, makeBufferStream, ui } from "./helpers.js";
+
+const bufferStream = makeBufferStream;
+
+test("commandHarnessSourcePut builds source_markdown payload", async () => {
+  const out = bufferStream();
+  const err = bufferStream();
+  let captured = null;
+
+  const deps = {
+    request: async (_ctx, reqPath, options) => { captured = { reqPath, options }; return { config_version_id: "pver_1" }; },
+    apiHeaders: () => ({}),
+    ui,
+    printJson: () => {},
+    writeLine: (stream, line = "") => stream.write(`${line}\n`),
+    readFile: async () => "# Harness\n\n```json\n{}\n```",
+    resolvePath: (p) => p,
+  };
+
+  const parsed = { options: { file: "profile.md", "agent-id": "agent_1" }, positionals: [] };
+  const code = await commandHarnessSourcePut({ stdout: out.stream, stderr: err.stream, jsonMode: false }, parsed, "ws_123", deps);
+
+  assert.equal(code, 0);
+  assert.equal(err.read(), "");
+  assert.equal(captured.reqPath, "/v1/workspaces/ws_123/harness/source");
+  const body = JSON.parse(captured.options.body);
+  assert.equal(body.agent_id, "agent_1");
+  assert.equal(body.name, "profile");
+  assert.match(body.source_markdown, /# Harness/);
+});
+
+test("commandHarnessSourcePut returns 2 when --file is missing", async () => {
+  const err = bufferStream();
+  const deps = { ui, writeLine: (stream, line = "") => stream.write(`${line}\n`) };
+  const parsed = { options: {}, positionals: [] };
+  const code = await commandHarnessSourcePut({ stdout: makeNoop(), stderr: err.stream, jsonMode: false }, parsed, "ws_123", deps);
+  assert.equal(code, 2);
+  assert.match(err.read(), /--file/);
+});
+
+test("commandHarnessSourcePut json mode outputs raw response", async () => {
+  let printed = null;
+  const deps = {
+    request: async () => ({ config_version_id: "pver_9" }),
+    apiHeaders: () => ({}),
+    ui,
+    printJson: (_stream, v) => { printed = v; },
+    writeLine: () => {},
+    readFile: async () => "# H",
+    resolvePath: (p) => p,
+  };
+  const parsed = { options: { file: "f.md" }, positionals: [] };
+  const code = await commandHarnessSourcePut({ stdout: makeNoop(), stderr: makeNoop(), jsonMode: true }, parsed, "ws_123", deps);
+  assert.equal(code, 0);
+  assert.equal(printed.config_version_id, "pver_9");
+});

package/test/help.test.js

@@ -0,0 +1,276 @@
+import { describe, test, expect } from "bun:test";
+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,
+  };
+}
+
+async function withIsolatedStateDir(run) {
+  const stateDir = await fs.mkdtemp(path.join(os.tmpdir(), "zombiectl-help-"));
+  const previousStateDir = process.env.ZOMBIE_STATE_DIR;
+  process.env.ZOMBIE_STATE_DIR = stateDir;
+  try {
+    return await run(stateDir);
+  } finally {
+    if (previousStateDir === undefined) delete process.env.ZOMBIE_STATE_DIR;
+    else process.env.ZOMBIE_STATE_DIR = previousStateDir;
+    await fs.rm(stateDir, { recursive: true, force: true });
+  }
+}
+
+describe("help output", () => {
+  test("--help output contains all user commands", async () => {
+    await withIsolatedStateDir(async () => {
+      const out = bufferStream();
+      const err = bufferStream();
+      const code = await runCli(["--help"], {
+        stdout: out.stream,
+        stderr: err.stream,
+        env: { NO_COLOR: "1" },
+      });
+      expect(code).toBe(0);
+      const output = out.read();
+      expect(output).toContain("login");
+      expect(output).toContain("logout");
+      expect(output).toContain("workspace add");
+      expect(output).toContain("workspace list");
+      expect(output).toContain("workspace remove");
+      expect(output).toContain("specs sync");
+      expect(output).toContain("run status");
+      expect(output).toContain("runs list");
+      expect(output).toContain("doctor");
+      expect(output).not.toContain("workspace upgrade-scale");
+    });
+  });
+
+  test("--help with ZOMBIE_OPERATOR=1 contains operator commands", async () => {
+    const out = bufferStream();
+    const err = bufferStream();
+    const code = await runCli(["--help"], {
+      stdout: out.stream,
+      stderr: err.stream,
+      env: { ...process.env, ZOMBIE_OPERATOR: "1", NO_COLOR: "1" },
+    });
+    expect(code).toBe(0);
+    const output = out.read();
+    expect(output).toContain("OPERATOR COMMANDS");
+    expect(output).toContain("harness source put");
+    expect(output).toContain("harness compile");
+    expect(output).toContain("harness activate");
+    expect(output).toContain("workspace upgrade-scale");
+    expect(output).toContain("skill-secret put");
+    expect(output).toContain("agent scores");
+    expect(output).toContain("agent profile");
+    expect(output).toContain("agent improvement-report");
+    expect(output).toContain("agent proposals <agent-id> veto <proposal-id>");
+    expect(output).toContain("agent harness revert");
+  });
+
+  test("--help without ZOMBIE_OPERATOR does NOT contain operator commands", async () => {
+    await withIsolatedStateDir(async () => {
+      const out = bufferStream();
+      const err = bufferStream();
+      const code = await runCli(["--help"], {
+        stdout: out.stream,
+        stderr: err.stream,
+        env: { NO_COLOR: "1" },
+      });
+      expect(code).toBe(0);
+      const output = out.read();
+      expect(output).not.toContain("OPERATOR COMMANDS");
+      expect(output).not.toContain("harness source put");
+      expect(output).not.toContain("workspace upgrade-scale");
+    });
+  });
+
+  test("--help with operator token contains operator commands without env override", async () => {
+    await withIsolatedStateDir(async () => {
+      const out = bufferStream();
+      const err = bufferStream();
+      const token = [
+        Buffer.from(JSON.stringify({ alg: "none", typ: "JWT" })).toString("base64url"),
+        Buffer.from(JSON.stringify({ sub: "user_123", role: "operator" })).toString("base64url"),
+        "sig",
+      ].join(".");
+      const code = await runCli(["--help"], {
+        stdout: out.stream,
+        stderr: err.stream,
+        env: { ZOMBIE_TOKEN: token, NO_COLOR: "1" },
+      });
+      expect(code).toBe(0);
+      const output = out.read();
+      expect(output).toContain("OPERATOR COMMANDS");
+      expect(output).toContain("workspace upgrade-scale");
+      expect(output).toContain("admin config set scoring_context_max_tokens");
+    });
+  });
+
+  test("--help with API_KEY contains operator commands without ZOMBIE_API_KEY", async () => {
+    await withIsolatedStateDir(async () => {
+      const out = bufferStream();
+      const err = bufferStream();
+      const code = await runCli(["--help"], {
+        stdout: out.stream,
+        stderr: err.stream,
+        env: { API_KEY: "dev-key", NO_COLOR: "1" },
+      });
+      expect(code).toBe(0);
+      const output = out.read();
+      expect(output).toContain("OPERATOR COMMANDS");
+      expect(output).toContain("workspace upgrade-scale");
+    });
+  });
+
+  test("--help uses saved login credentials to show operator commands", async () => {
+    await withIsolatedStateDir(async (stateDir) => {
+      const out = bufferStream();
+      const err = bufferStream();
+      const token = [
+        Buffer.from(JSON.stringify({ alg: "none", typ: "JWT" })).toString("base64url"),
+        Buffer.from(JSON.stringify({ sub: "user_123", metadata: { role: "operator" } })).toString("base64url"),
+        "sig",
+      ].join(".");
+
+      await fs.writeFile(path.join(stateDir, "credentials.json"), JSON.stringify({
+        token,
+        saved_at: Date.now(),
+        session_id: "sess_test",
+        api_url: null,
+      }));
+
+      const code = await runCli(["--help"], {
+        stdout: out.stream,
+        stderr: err.stream,
+        env: { NO_COLOR: "1" },
+      });
+      expect(code).toBe(0);
+      const output = out.read();
+      expect(output).toContain("OPERATOR COMMANDS");
+      expect(output).toContain("workspace upgrade-scale");
+    });
+  });
+
+  test("--help shows environment variables section", async () => {
+    const out = bufferStream();
+    const err = bufferStream();
+    await runCli(["--help"], {
+      stdout: out.stream,
+      stderr: err.stream,
+      env: { ...process.env, NO_COLOR: "1" },
+    });
+    const output = out.read();
+    expect(output).toContain("ZOMBIE_API_URL");
+    expect(output).toContain("ZOMBIE_TOKEN");
+    expect(output).toContain("ZOMBIE_API_KEY");
+    expect(output).toContain("NO_COLOR");
+  });
+
+  test("--help with admin role token shows OPERATOR COMMANDS", async () => {
+    await withIsolatedStateDir(async () => {
+      const out = bufferStream();
+      const err = bufferStream();
+      const token = [
+        Buffer.from(JSON.stringify({ alg: "none", typ: "JWT" })).toString("base64url"),
+        Buffer.from(JSON.stringify({ sub: "user_admin", role: "admin" })).toString("base64url"),
+        "sig",
+      ].join(".");
+      const code = await runCli(["--help"], {
+        stdout: out.stream,
+        stderr: err.stream,
+        env: { ZOMBIE_TOKEN: token, NO_COLOR: "1" },
+      });
+      expect(code).toBe(0);
+      const output = out.read();
+      expect(output).toContain("OPERATOR COMMANDS");
+      expect(output).toContain("workspace upgrade-scale");
+    });
+  });
+
+  test("--help with user role token does NOT show OPERATOR COMMANDS", async () => {
+    await withIsolatedStateDir(async () => {
+      const out = bufferStream();
+      const err = bufferStream();
+      const token = [
+        Buffer.from(JSON.stringify({ alg: "none", typ: "JWT" })).toString("base64url"),
+        Buffer.from(JSON.stringify({ sub: "user_basic", role: "user" })).toString("base64url"),
+        "sig",
+      ].join(".");
+      const code = await runCli(["--help"], {
+        stdout: out.stream,
+        stderr: err.stream,
+        env: { ZOMBIE_TOKEN: token, NO_COLOR: "1" },
+      });
+      expect(code).toBe(0);
+      const output = out.read();
+      expect(output).not.toContain("OPERATOR COMMANDS");
+      expect(output).not.toContain("workspace upgrade-scale");
+    });
+  });
+
+  test("--help shows global flags", async () => {
+    const out = bufferStream();
+    const err = bufferStream();
+    await runCli(["--help"], {
+      stdout: out.stream,
+      stderr: err.stream,
+      env: { ...process.env, NO_COLOR: "1" },
+    });
+    const output = out.read();
+    expect(output).toContain("--json");
+    expect(output).toContain("--no-input");
+    expect(output).toContain("--version");
+  });
+});
+
+describe("version output", () => {
+  test("--version shows banner", async () => {
+    const out = bufferStream();
+    const err = bufferStream();
+    const code = await runCli(["--version"], {
+      stdout: out.stream,
+      stderr: err.stream,
+      env: { ...process.env },
+    });
+    expect(code).toBe(0);
+    expect(out.read()).toContain("zombiectl v0.3.0");
+  });
+
+  test("--version --json suppresses banner", async () => {
+    const out = bufferStream();
+    const err = bufferStream();
+    const code = await runCli(["--json", "--version"], {
+      stdout: out.stream,
+      stderr: err.stream,
+      env: { ...process.env },
+    });
+    expect(code).toBe(0);
+    const parsed = JSON.parse(out.read());
+    expect(parsed.version).toBe("0.3.0");
+  });
+
+  test("--version with NO_COLOR shows plain text", async () => {
+    const out = bufferStream();
+    const err = bufferStream();
+    const code = await runCli(["--version"], {
+      stdout: out.stream,
+      stderr: err.stream,
+      env: { ...process.env, NO_COLOR: "1" },
+    });
+    expect(code).toBe(0);
+    const output = out.read();
+    expect(output).toContain("zombiectl v0.3.0");
+  });
+});

package/test/helpers-fs.js

@@ -0,0 +1,32 @@
+/**
+ * Filesystem test helpers shared across spec-init and run-preview test suites.
+ */
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import os from "node:os";
+
+export function makeTmp() {
+  const dir = join(os.tmpdir(), `zctl-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function cleanup(dir) {
+  try { rmSync(dir, { recursive: true, force: true }); } catch {}
+}
+
+/** Simple parseFlags for use in tests that bypasses the real arg parser. */
+export function parseFlags(tokens) {
+  const options = {};
+  for (let i = 0; i < tokens.length; i++) {
+    if (tokens[i].startsWith("--")) {
+      const key = tokens[i].slice(2);
+      const next = tokens[i + 1];
+      if (next && !next.startsWith("--")) { options[key] = next; i++; }
+      else options[key] = true;
+    }
+  }
+  return { options, positionals: [] };
+}
+
+export const writeLine = (s, l = "") => s.write(`${l}\n`);

package/test/helpers.js

@@ -0,0 +1,31 @@
+import { Writable } from "node:stream";
+import { ApiError } from "../src/lib/http.js";
+
+export { ApiError };
+
+/** Discard-all writable stream (use one per test to avoid state leaks). */
+export function makeNoop() {
+  return new Writable({ write(_c, _e, cb) { cb(); } });
+}
+
+/** Writable that buffers output; call .read() to inspect. */
+export function makeBufferStream() {
+  let data = "";
+  return {
+    stream: new Writable({ write(chunk, _enc, cb) { data += String(chunk); cb(); } }),
+    read: () => data,
+  };
+}
+
+/** Passthrough UI theme (no ANSI escapes). */
+export const ui = { ok: (s) => s, err: (s) => s, info: (s) => s, dim: (s) => s, head: (s) => s };
+
+// ── Stable test constants ─────────────────────────────────────────────────────
+export const AGENT_ID   = "0195b4ba-8d3a-7f13-8abc-000000000001";
+export const AGENT_NAME = "my-agent";
+export const WS_ID      = "0195b4ba-8d3a-7f13-8abc-000000000010";
+export const SCORE_ID_1 = "0195b4ba-8d3a-7f13-8abc-000000000021";
+export const SCORE_ID_2 = "0195b4ba-8d3a-7f13-8abc-000000000022";
+export const RUN_ID_1   = "0195b4ba-8d3a-7f13-8abc-000000000031";
+export const RUN_ID_2   = "0195b4ba-8d3a-7f13-8abc-000000000032";
+export const PVER_ID    = "0195b4ba-8d3a-7f13-8abc-000000000041";

package/test/io.unit.test.js

@@ -0,0 +1,57 @@
+import { describe, test, expect } from "bun:test";
+import { makeBufferStream, ui } from "./helpers.js";
+import { printHelp } from "../src/program/io.js";
+
+describe("printHelp authRole option", () => {
+  test("authRole=operator shows operator commands", () => {
+    const out = makeBufferStream();
+    printHelp(out.stream, ui, { authRole: "operator" });
+    const output = out.read();
+    expect(output).toContain("OPERATOR COMMANDS");
+    expect(output).toContain("workspace upgrade-scale");
+  });
+
+  test("authRole=admin shows operator commands", () => {
+    const out = makeBufferStream();
+    printHelp(out.stream, ui, { authRole: "admin" });
+    const output = out.read();
+    expect(output).toContain("OPERATOR COMMANDS");
+    expect(output).toContain("workspace upgrade-scale");
+  });
+
+  test("authRole=user does NOT show operator commands", () => {
+    const out = makeBufferStream();
+    printHelp(out.stream, ui, { authRole: "user" });
+    const output = out.read();
+    expect(output).not.toContain("OPERATOR COMMANDS");
+    expect(output).not.toContain("workspace upgrade-scale");
+  });
+
+  test("no authRole and no ZOMBIE_OPERATOR hides operator commands", () => {
+    const out = makeBufferStream();
+    printHelp(out.stream, ui, {});
+    const output = out.read();
+    expect(output).not.toContain("OPERATOR COMMANDS");
+  });
+
+  test("ZOMBIE_OPERATOR=1 still works as env override", () => {
+    const out = makeBufferStream();
+    printHelp(out.stream, ui, { env: { ZOMBIE_OPERATOR: "1" } });
+    const output = out.read();
+    expect(output).toContain("OPERATOR COMMANDS");
+  });
+
+  test("operator commands section includes workspace upgrade-scale", () => {
+    const out = makeBufferStream();
+    printHelp(out.stream, ui, { operator: true });
+    const output = out.read();
+    expect(output).toContain("workspace upgrade-scale --workspace-id ID --subscription-id SUBSCRIPTION_ID");
+  });
+
+  test("ZOMBIE_OPERATOR description says force-show", () => {
+    const out = makeBufferStream();
+    printHelp(out.stream, ui, {});
+    const output = out.read();
+    expect(output).toContain("force-show operator commands");
+  });
+});

package/test/login.unit.test.js

@@ -0,0 +1,115 @@
+import { describe, test, expect } from "bun:test";
+import { makeNoop, makeBufferStream, ui } from "./helpers.js";
+import { createCoreHandlers } from "../src/commands/core.js";
+
+function makeDeps(overrides = {}) {
+  return {
+    clearCredentials: async () => {},
+    createSpinner: () => ({ start() {}, succeed() {}, fail() {} }),
+    newIdempotencyKey: () => "idem_test",
+    openUrl: async () => false,
+    parseFlags: (tokens) => {
+      const options = {};
+      const positionals = [];
+      for (let i = 0; i < tokens.length; i++) {
+        if (tokens[i].startsWith("--")) {
+          const key = tokens[i].slice(2);
+          const next = tokens[i + 1];
+          if (next && !next.startsWith("--")) { options[key] = next; i++; }
+          else options[key] = true;
+        } else { positionals.push(tokens[i]); }
+      }
+      return { options, positionals };
+    },
+    printJson: (_s, v) => {},
+    printKeyValue: () => {},
+    printTable: () => {},
+    request: async () => ({}),
+    saveCredentials: async () => {},
+    saveWorkspaces: async () => {},
+    ui,
+    writeLine: (stream, line = "") => stream.write(`${line}\n`),
+    apiHeaders: () => ({}),
+    ...overrides,
+  };
+}
+
+describe("commandLogin", () => {
+  test("successful login flow", async () => {
+    const out = makeBufferStream();
+    let pollCount = 0;
+    const deps = makeDeps({
+      request: async (_ctx, reqPath) => {
+        if (reqPath === "/v1/auth/sessions") {
+          return { session_id: "sess_1", login_url: "https://login.test" };
+        }
+        pollCount++;
+        return { status: "complete", token: "tok_123" };
+      },
+      saveCredentials: async (creds) => {
+        expect(creds.token).toBe("tok_123");
+      },
+    });
+    const ctx = { stdout: out.stream, stderr: makeNoop(), jsonMode: false, noOpen: true, env: {} };
+    const workspaces = { current_workspace_id: null, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandLogin([]);
+    expect(code).toBe(0);
+    expect(out.read()).toContain("login complete");
+  });
+
+  test("expired session returns 1", async () => {
+    const err = makeBufferStream();
+    const deps = makeDeps({
+      request: async (_ctx, reqPath) => {
+        if (reqPath === "/v1/auth/sessions") {
+          return { session_id: "sess_2", login_url: "https://login.test" };
+        }
+        return { status: "expired" };
+      },
+    });
+    const ctx = { stdout: makeNoop(), stderr: err.stream, jsonMode: false, noOpen: true, env: {} };
+    const workspaces = { current_workspace_id: null, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandLogin([]);
+    expect(code).toBe(1);
+    expect(err.read()).toContain("expired");
+  });
+
+  test("timeout returns 1", async () => {
+    const err = makeBufferStream();
+    const deps = makeDeps({
+      request: async (_ctx, reqPath) => {
+        if (reqPath === "/v1/auth/sessions") {
+          return { session_id: "sess_3", login_url: "https://login.test" };
+        }
+        return { status: "pending", token: null };
+      },
+    });
+    const ctx = { stdout: makeNoop(), stderr: err.stream, jsonMode: false, noOpen: true, env: {} };
+    const workspaces = { current_workspace_id: null, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    // use very short timeout
+    const code = await core.commandLogin(["--timeout-sec", "1", "--poll-ms", "100"]);
+    expect(code).toBe(1);
+    expect(err.read()).toContain("timed out");
+  });
+
+  test("--no-open flag skips browser", async () => {
+    let browserOpened = false;
+    const deps = makeDeps({
+      request: async (_ctx, reqPath) => {
+        if (reqPath === "/v1/auth/sessions") {
+          return { session_id: "sess_4", login_url: "https://login.test" };
+        }
+        return { status: "complete", token: "tok_456" };
+      },
+      openUrl: async () => { browserOpened = true; return true; },
+    });
+    const ctx = { stdout: makeNoop(), stderr: makeNoop(), jsonMode: false, noOpen: false, env: {} };
+    const workspaces = { current_workspace_id: null, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    await core.commandLogin(["--no-open"]);
+    expect(browserOpened).toBe(false);
+  });
+});

package/test/logout.unit.test.js

@@ -0,0 +1,65 @@
+import { describe, test, expect } from "bun:test";
+import { makeNoop, makeBufferStream, ui } from "./helpers.js";
+import { createCoreHandlers } from "../src/commands/core.js";
+
+function makeDeps(overrides = {}) {
+  return {
+    clearCredentials: async () => {},
+    createSpinner: () => ({ start() {}, succeed() {}, fail() {} }),
+    newIdempotencyKey: () => "idem_test",
+    openUrl: async () => false,
+    parseFlags: (tokens) => {
+      const options = {};
+      const positionals = [];
+      for (let i = 0; i < tokens.length; i++) {
+        if (tokens[i].startsWith("--")) {
+          const key = tokens[i].slice(2);
+          const next = tokens[i + 1];
+          if (next && !next.startsWith("--")) { options[key] = next; i++; }
+          else options[key] = true;
+        } else { positionals.push(tokens[i]); }
+      }
+      return { options, positionals };
+    },
+    printJson: (_s, v) => {},
+    printKeyValue: () => {},
+    printTable: () => {},
+    request: async () => ({}),
+    saveCredentials: async () => {},
+    saveWorkspaces: async () => {},
+    ui,
+    writeLine: (stream, line = "") => stream.write(`${line}\n`),
+    apiHeaders: () => ({}),
+    ...overrides,
+  };
+}
+
+describe("commandLogout", () => {
+  test("clears credentials", async () => {
+    let cleared = false;
+    const out = makeBufferStream();
+    const deps = makeDeps({
+      clearCredentials: async () => { cleared = true; },
+    });
+    const ctx = { stdout: out.stream, stderr: makeNoop(), jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: null, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandLogout();
+    expect(code).toBe(0);
+    expect(cleared).toBe(true);
+    expect(out.read()).toContain("logout complete");
+  });
+
+  test("JSON mode output", async () => {
+    let printed = null;
+    const deps = makeDeps({
+      printJson: (_s, v) => { printed = v; },
+    });
+    const ctx = { stdout: makeNoop(), stderr: makeNoop(), jsonMode: true, env: {} };
+    const workspaces = { current_workspace_id: null, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandLogout();
+    expect(code).toBe(0);
+    expect(printed).toEqual({ status: "ok", logged_out: true });
+  });
+});

package/test/parse.test.js

@@ -0,0 +1,16 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { parseGlobalArgs } from "../src/cli.js";
+
+test("parseGlobalArgs uses flag api over env", () => {
+  const env = { ZOMBIE_API_URL: "https://env.example" };
+  const out = parseGlobalArgs(["--api", "https://flag.example", "doctor"], env);
+  assert.equal(out.global.apiUrl, "https://flag.example");
+  assert.equal(out.rest[0], "doctor");
+});
+
+test("parseGlobalArgs falls back to env api", () => {
+  const env = { ZOMBIE_API_URL: "https://env.example" };
+  const out = parseGlobalArgs(["doctor"], env);
+  assert.equal(out.global.apiUrl, "https://env.example");
+});