@usezombie/zombiectl 0.3.0

package/test/cli-analytics.unit.test.js

@@ -0,0 +1,296 @@
+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";
+import { cliAnalytics } from "../src/lib/analytics.js";
+
+function bufferStream() {
+  let data = "";
+  return {
+    stream: new Writable({
+      write(chunk, _enc, cb) {
+        data += String(chunk);
+        cb();
+      },
+    }),
+    read: () => data,
+  };
+}
+
+function makeToken(payload) {
+  const header = Buffer.from(JSON.stringify({ alg: "none", typ: "JWT" })).toString("base64url");
+  const body = Buffer.from(JSON.stringify(payload)).toString("base64url");
+  return `${header}.${body}.sig`;
+}
+
+function withAnalyticsStub(fn) {
+  const originalCreate = cliAnalytics.createCliAnalytics;
+  const originalTrack = cliAnalytics.trackCliEvent;
+  const originalShutdown = cliAnalytics.shutdownCliAnalytics;
+
+  return (async () => {
+    try {
+      await fn();
+    } finally {
+      cliAnalytics.createCliAnalytics = originalCreate;
+      cliAnalytics.trackCliEvent = originalTrack;
+      cliAnalytics.shutdownCliAnalytics = originalShutdown;
+    }
+  })();
+}
+
+async function withStateDir(fn) {
+  const previous = process.env.ZOMBIE_STATE_DIR;
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "zombiectl-analytics-"));
+  process.env.ZOMBIE_STATE_DIR = dir;
+  try {
+    return await fn(dir);
+  } finally {
+    if (previous === undefined) delete process.env.ZOMBIE_STATE_DIR;
+    else process.env.ZOMBIE_STATE_DIR = previous;
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+}
+
+test("runCli tracks login success with post-login distinct id and shuts down analytics", async () => {
+  await withStateDir(async () => {
+    await withAnalyticsStub(async () => {
+      const events = [];
+      let shutdownClient = null;
+      const analyticsClient = { name: "test-client" };
+      const clerkToken = makeToken({ sub: "user_login_123" });
+
+      cliAnalytics.createCliAnalytics = async () => analyticsClient;
+      cliAnalytics.trackCliEvent = (client, distinctId, event, properties = {}) => {
+        events.push({ client, distinctId, event, properties });
+      };
+      cliAnalytics.shutdownCliAnalytics = async (client) => {
+        shutdownClient = client;
+      };
+
+      const stdout = bufferStream();
+      const stderr = bufferStream();
+      let pollCount = 0;
+      const fetchImpl = async (_url, options = {}) => {
+        if (options.method === "POST") {
+          return {
+            ok: true,
+            status: 201,
+            text: async () => JSON.stringify({ session_id: "sess_analytics", login_url: "https://login.test" }),
+          };
+        }
+        pollCount += 1;
+        return {
+          ok: true,
+          status: 200,
+          text: async () => JSON.stringify({ status: "complete", token: clerkToken }),
+        };
+      };
+
+      const code = await runCli(["login", "--no-open"], {
+        env: { ...process.env, NO_COLOR: "1", BROWSER: "false" },
+        stdout: stdout.stream,
+        stderr: stderr.stream,
+        fetchImpl,
+      });
+
+      assert.equal(code, 0);
+      assert.equal(pollCount, 1);
+      assert.equal(events.length, 4);
+      assert.deepEqual(events.map(({ event }) => event), [
+        "cli_command_started",
+        "cli_command_finished",
+        "user_authenticated",
+        "login_completed",
+      ]);
+      assert.deepEqual(events[0], {
+        client: analyticsClient,
+        distinctId: null,
+        event: "cli_command_started",
+        properties: { command: "login", json_mode: "false" },
+      });
+      assert.deepEqual(events[1], {
+        client: analyticsClient,
+        distinctId: null,
+        event: "cli_command_finished",
+        properties: { command: "login", exit_code: "0", session_id: "sess_analytics" },
+      });
+      assert.deepEqual(events[2], {
+        client: analyticsClient,
+        distinctId: "user_login_123",
+        event: "user_authenticated",
+        properties: { command: "login", session_id: "sess_analytics" },
+      });
+      assert.deepEqual(events[3], {
+        client: analyticsClient,
+        distinctId: "user_login_123",
+        event: "login_completed",
+        properties: { command: "login", session_id: "sess_analytics" },
+      });
+      assert.equal(shutdownClient, analyticsClient);
+    });
+  });
+});
+
+test("runCli tracks workspace creation with existing distinct id", async () => {
+  await withStateDir(async () => {
+    await withAnalyticsStub(async () => {
+      const events = [];
+      const analyticsClient = { name: "workspace-client" };
+      const clerkToken = makeToken({ sub: "user_workspace_456" });
+
+      cliAnalytics.createCliAnalytics = async () => analyticsClient;
+      cliAnalytics.trackCliEvent = (client, distinctId, event, properties = {}) => {
+        events.push({ client, distinctId, event, properties });
+      };
+      cliAnalytics.shutdownCliAnalytics = async () => {};
+
+      const stdout = bufferStream();
+      const stderr = bufferStream();
+      const fetchImpl = async () => ({
+        ok: true,
+        status: 201,
+        text: async () =>
+          JSON.stringify({
+            workspace_id: "ws_123456789abc",
+            repo_url: "https://github.com/acme/repo",
+            default_branch: "main",
+            install_url: "https://github.com/apps/usezombie/installations/new?state=ws_123456789abc",
+            request_id: "req_workspace",
+          }),
+      });
+
+      const code = await runCli(["workspace", "add", "https://github.com/acme/repo"], {
+        env: { ...process.env, NO_COLOR: "1", BROWSER: "false", ZOMBIE_TOKEN: clerkToken },
+        stdout: stdout.stream,
+        stderr: stderr.stream,
+        fetchImpl,
+      });
+
+      assert.equal(code, 0);
+      assert.equal(events.length, 4);
+      assert.deepEqual(events.map(({ event }) => event), [
+        "cli_command_started",
+        "cli_command_finished",
+        "workspace_created",
+        "workspace_add_completed",
+      ]);
+      assert.deepEqual(events[0], {
+        client: analyticsClient,
+        distinctId: "user_workspace_456",
+        event: "cli_command_started",
+        properties: { command: "workspace", json_mode: "false" },
+      });
+      assert.deepEqual(events[1], {
+        client: analyticsClient,
+        distinctId: "user_workspace_456",
+        event: "cli_command_finished",
+        properties: {
+          command: "workspace",
+          exit_code: "0",
+          workspace_id: "ws_123456789abc",
+          repo_url: "https://github.com/acme/repo",
+          branch: "main",
+        },
+      });
+      assert.deepEqual(events[2], {
+        client: analyticsClient,
+        distinctId: "user_workspace_456",
+        event: "workspace_created",
+        properties: {
+          command: "workspace",
+          workspace_id: "ws_123456789abc",
+          repo_url: "https://github.com/acme/repo",
+          branch: "main",
+        },
+      });
+      assert.deepEqual(events[3], {
+        client: analyticsClient,
+        distinctId: "user_workspace_456",
+        event: "workspace_add_completed",
+        properties: {
+          command: "workspace",
+          workspace_id: "ws_123456789abc",
+          repo_url: "https://github.com/acme/repo",
+          branch: "main",
+        },
+      });
+    });
+  });
+});
+
+test("runCli tracks unknown-command errors and still shuts down analytics when tracking throws", async () => {
+  await withStateDir(async () => {
+    await withAnalyticsStub(async () => {
+      const events = [];
+      let shutdownCalls = 0;
+      const analyticsClient = {
+        capture({ distinctId, event, properties }) {
+          events.push({ distinctId, event, properties });
+          throw new Error("capture failed");
+        },
+      };
+
+      cliAnalytics.createCliAnalytics = async () => analyticsClient;
+      cliAnalytics.shutdownCliAnalytics = async () => {
+        shutdownCalls += 1;
+      };
+
+      const stdout = bufferStream();
+      const stderr = bufferStream();
+
+      const code = await runCli(["runx"], {
+        env: { ...process.env, NO_COLOR: "1" },
+        stdout: stdout.stream,
+        stderr: stderr.stream,
+      });
+
+      assert.equal(code, 2);
+      assert.match(stderr.read(), /unknown command: runx/);
+      assert.equal(events.length, 1);
+      assert.equal(events[0].event, "cli_error");
+      assert.equal(events[0].distinctId, "anonymous");
+      assert.equal(shutdownCalls, 1);
+    });
+  });
+});
+
+test("runCli honors analytics opt-out with bundled key", async () => {
+  await withAnalyticsStub(async () => {
+    let createCalls = 0;
+    let trackCalls = 0;
+    let shutdownCalls = 0;
+
+    cliAnalytics.createCliAnalytics = async (env) => {
+      createCalls += 1;
+      assert.equal(env.ZOMBIE_POSTHOG_ENABLED, "false");
+      return null;
+    };
+    cliAnalytics.trackCliEvent = (client) => {
+      if (!client) return;
+      trackCalls += 1;
+    };
+    cliAnalytics.shutdownCliAnalytics = async () => {
+      shutdownCalls += 1;
+    };
+
+    const stdout = bufferStream();
+    const stderr = bufferStream();
+
+    const code = await runCli(["runx"], {
+      env: { ...process.env, NO_COLOR: "1", ZOMBIE_POSTHOG_ENABLED: "false" },
+      stdout: stdout.stream,
+      stderr: stderr.stream,
+    });
+
+    assert.equal(code, 2);
+    assert.match(stderr.read(), /unknown command: runx/);
+    assert.equal(createCalls, 1);
+    assert.equal(trackCalls, 0);
+    assert.equal(shutdownCalls, 1);
+  });
+});

package/test/did-you-mean.integration.test.js

@@ -0,0 +1,76 @@
+import { describe, test, expect } from "bun:test";
+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,
+  };
+}
+
+describe("did-you-mean integration", () => {
+  test("'runx' suggests 'run'", async () => {
+    const out = bufferStream();
+    const err = bufferStream();
+    const code = await runCli(["runx"], {
+      stdout: out.stream,
+      stderr: err.stream,
+      env: { ...process.env, NO_COLOR: "1" },
+    });
+    expect(code).toBe(2);
+    const errText = err.read();
+    expect(errText).toContain("unknown command: runx");
+    expect(errText).toContain("run");
+  });
+
+  test("'workspace ad' suggests 'workspace add'", async () => {
+    const out = bufferStream();
+    const err = bufferStream();
+    // runCli sees command="workspace" args=["ad"], which IS a valid route (workspace)
+    // but the workspace handler itself handles bad subcommands
+    // For did-you-mean, we test a truly unknown top-level command
+    const code = await runCli(["workspac"], {
+      stdout: out.stream,
+      stderr: err.stream,
+      env: { ...process.env, NO_COLOR: "1" },
+    });
+    expect(code).toBe(2);
+    const errText = err.read();
+    expect(errText).toContain("unknown command");
+    expect(errText).toContain("workspace");
+  });
+
+  test("completely unrelated input shows help hint", async () => {
+    const out = bufferStream();
+    const err = bufferStream();
+    const code = await runCli(["zzzzzzzzzzzzzzzzz"], {
+      stdout: out.stream,
+      stderr: err.stream,
+      env: { ...process.env, NO_COLOR: "1" },
+    });
+    expect(code).toBe(2);
+    const errText = err.read();
+    expect(errText).toContain("unknown command");
+    expect(errText).toContain("--help");
+  });
+
+  test("'logn' suggests 'login'", async () => {
+    const out = bufferStream();
+    const err = bufferStream();
+    const code = await runCli(["logn"], {
+      stdout: out.stream,
+      stderr: err.stream,
+      env: { ...process.env, NO_COLOR: "1" },
+    });
+    expect(code).toBe(2);
+    const errText = err.read();
+    expect(errText).toContain("login");
+  });
+});

package/test/doctor-json.test.js

@@ -0,0 +1,81 @@
+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,
+  };
+}
+
+async function withStateDir(fn) {
+  const previous = process.env.ZOMBIE_STATE_DIR;
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "zombiectl-doctor-"));
+  process.env.ZOMBIE_STATE_DIR = dir;
+  try {
+    await fs.writeFile(
+      path.join(dir, "workspaces.json"),
+      `${JSON.stringify({ current_workspace_id: "ws_test", items: [{ workspace_id: "ws_test" }] }, null, 2)}\n`,
+      "utf8",
+    );
+    return await fn();
+  } finally {
+    if (previous === undefined) delete process.env.ZOMBIE_STATE_DIR;
+    else process.env.ZOMBIE_STATE_DIR = previous;
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+}
+
+test("doctor --json emits machine-parseable payload", async () => {
+  await withStateDir(async () => {
+    const out = bufferStream();
+    const err = bufferStream();
+
+    const fetchImpl = async (url) => {
+      if (url.endsWith("/healthz")) {
+        return {
+          ok: true,
+          status: 200,
+          text: async () => JSON.stringify({ status: "ok", service: "zombied" }),
+        };
+      }
+      if (url.endsWith("/readyz")) {
+        return {
+          ok: true,
+          status: 200,
+          text: async () => JSON.stringify({ ready: true }),
+        };
+      }
+      return {
+        ok: false,
+        status: 404,
+        statusText: "Not Found",
+        text: async () => JSON.stringify({ error: { code: "NOT_FOUND", message: "Not found" } }),
+      };
+    };
+
+    const code = await runCli(["--json", "doctor"], {
+      env: { ...process.env, ZOMBIE_TOKEN: "header.payload.sig" },
+      stdout: out.stream,
+      stderr: err.stream,
+      fetchImpl,
+    });
+
+    assert.equal(code, 0);
+    const parsed = JSON.parse(out.read());
+    assert.equal(parsed.ok, true);
+    assert.equal(Array.isArray(parsed.checks), true);
+    assert.equal(parsed.checks.length >= 4, true);
+  });
+});

package/test/error-codes.unit.test.js

@@ -0,0 +1,7 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { ERR_BILLING_CREDIT_EXHAUSTED } from "../src/constants/error-codes.js";
+
+test("ERR_BILLING_CREDIT_EXHAUSTED matches canonical code", () => {
+  assert.equal(ERR_BILLING_CREDIT_EXHAUSTED, "UZ-BILLING-005");
+});

package/test/harness-command.unit.test.js

@@ -0,0 +1,180 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import { Writable } from "node:stream";
+import { commandHarness } from "../src/commands/harness.js";
+
+function bufferStream() {
+  let data = "";
+  return {
+    stream: new Writable({
+      write(chunk, _enc, cb) {
+        data += String(chunk);
+        cb();
+      },
+    }),
+    read: () => data,
+  };
+}
+
+function parseFlags(tokens) {
+  const options = {};
+  for (let i = 0; i < tokens.length; i += 1) {
+    const token = tokens[i];
+    if (!token.startsWith("--")) continue;
+    const key = token.slice(2);
+    const next = tokens[i + 1];
+    if (next && !next.startsWith("--")) {
+      options[key] = next;
+      i += 1;
+    } else {
+      options[key] = true;
+    }
+  }
+  return { options, positionals: [] };
+}
+
+test("commandHarness source put builds source_markdown payload", async () => {
+  const out = bufferStream();
+  const err = bufferStream();
+  let captured = null;
+  const deps = {
+    parseFlags,
+    request: async (_ctx, reqPath, options) => {
+      captured = { reqPath, options };
+      return { config_version_id: "pver_1" };
+    },
+    apiHeaders: () => ({ "Content-Type": "application/json" }),
+    ui: { ok: (s) => s, err: (s) => s, info: (s) => s },
+    printJson: () => {},
+    writeLine: (stream, line = "") => stream.write(`${line}\n`),
+    readFile: async () => "# Harness\n\n```json\n{\"profile_id\":\"ws_123-harness\",\"stages\":[]}\n```",
+    resolvePath: (p) => p,
+  };
+  const ctx = { stdout: out.stream, stderr: err.stream, jsonMode: false };
+  const workspaces = { current_workspace_id: "ws_123" };
+
+  const code = await commandHarness(
+    ctx,
+    ["source", "put", "--file", "profile.md", "--agent-id", "ws_123-harness"],
+    workspaces,
+    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, "ws_123-harness");
+  assert.equal(body.name, "profile");
+  assert.match(body.source_markdown, /# Harness/);
+});
+
+test("commandHarness compile sends explicit profile selectors", async () => {
+  let captured = null;
+  const deps = {
+    parseFlags,
+    request: async (_ctx, reqPath, options) => {
+      captured = { reqPath, options };
+      return { compile_job_id: "cjob_1", is_valid: true };
+    },
+    apiHeaders: () => ({ "Content-Type": "application/json" }),
+    ui: { ok: (s) => s, err: (s) => s, info: (s) => s },
+    printJson: () => {},
+    writeLine: () => {},
+  };
+  const ctx = { stdout: new Writable({ write(_c, _e, cb) { cb(); } }), stderr: new Writable({ write(_c, _e, cb) { cb(); } }), jsonMode: false };
+  const workspaces = { current_workspace_id: "ws_123" };
+
+  const code = await commandHarness(
+    ctx,
+    ["compile", "--config-version-id", "pver_9"],
+    workspaces,
+    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.agent_id, null);
+  assert.equal(body.config_version_id, "pver_9");
+});
+
+test("commandHarness activate requires profile version id", async () => {
+  const out = bufferStream();
+  const err = bufferStream();
+  const deps = {
+    parseFlags,
+    request: async () => {
+      throw new Error("should not be called");
+    },
+    apiHeaders: () => ({ "Content-Type": "application/json" }),
+    ui: { ok: (s) => s, err: (s) => s, info: (s) => s },
+    printJson: () => {},
+    writeLine: (stream, line = "") => stream.write(`${line}\n`),
+  };
+  const ctx = { stdout: out.stream, stderr: err.stream, jsonMode: false };
+  const workspaces = { current_workspace_id: "ws_123" };
+
+  const code = await commandHarness(ctx, ["activate"], workspaces, deps);
+  assert.equal(code, 2);
+  assert.match(err.read(), /requires --config-version-id/);
+});
+
+test("commandHarness activate sends profile version and activated_by", async () => {
+  let captured = null;
+  const deps = {
+    parseFlags,
+    request: async (_ctx, reqPath, options) => {
+      captured = { reqPath, options };
+      return {
+        agent_id: "ws_123-harness",
+        config_version_id: "pver_2",
+        run_snapshot_version: "pver_2",
+        activated_at: 1730000000,
+      };
+    },
+    apiHeaders: () => ({ "Content-Type": "application/json" }),
+    ui: { ok: (s) => s, err: (s) => s, info: (s) => s },
+    printJson: () => {},
+    writeLine: () => {},
+  };
+  const ctx = { stdout: new Writable({ write(_c, _e, cb) { cb(); } }), stderr: new Writable({ write(_c, _e, cb) { cb(); } }), jsonMode: false };
+  const workspaces = { current_workspace_id: "ws_123" };
+
+  const code = await commandHarness(
+    ctx,
+    ["activate", "--config-version-id", "pver_2", "--activated-by", "operator"],
+    workspaces,
+    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_2");
+  assert.equal(body.activated_by, "operator");
+});
+
+test("commandHarness active queries active profile endpoint", async () => {
+  let captured = null;
+  const deps = {
+    parseFlags,
+    request: async (_ctx, reqPath, options) => {
+      captured = { reqPath, options };
+      return {
+        source: "active",
+        agent_id: "ws_123-harness",
+        config_version_id: "pver_2",
+        run_snapshot_version: "pver_2",
+      };
+    },
+    apiHeaders: () => ({ "Content-Type": "application/json" }),
+    ui: { ok: (s) => s, err: (s) => s, info: (s) => s },
+    printJson: () => {},
+    writeLine: () => {},
+  };
+  const ctx = { stdout: new Writable({ write(_c, _e, cb) { cb(); } }), stderr: new Writable({ write(_c, _e, cb) { cb(); } }), jsonMode: false };
+  const workspaces = { current_workspace_id: "ws_123" };
+
+  const code = await commandHarness(ctx, ["active"], workspaces, deps);
+  assert.equal(code, 0);
+  assert.equal(captured.reqPath, "/v1/workspaces/ws_123/harness/active");
+  assert.equal(captured.options.method, "GET");
+});