@usezombie/zombiectl 0.3.0

package/test/suggest.test.js

@@ -0,0 +1,75 @@
+import { describe, test, expect } from "bun:test";
+import { levenshteinDistance, suggestCommand } from "../src/program/suggest.js";
+
+describe("levenshteinDistance", () => {
+  test("identical strings return 0", () => {
+    expect(levenshteinDistance("login", "login")).toBe(0);
+  });
+
+  test("single character difference", () => {
+    expect(levenshteinDistance("login", "loign")).toBe(2);
+  });
+
+  test("empty string vs non-empty", () => {
+    expect(levenshteinDistance("", "abc")).toBe(3);
+  });
+
+  test("both empty", () => {
+    expect(levenshteinDistance("", "")).toBe(0);
+  });
+
+  test("completely different strings", () => {
+    expect(levenshteinDistance("abc", "xyz")).toBe(3);
+  });
+});
+
+describe("suggestCommand", () => {
+  test("exact match returns empty for distant input", () => {
+    // "doctor" is far enough from all other commands to return only itself-related matches
+    const result = suggestCommand("doctor");
+    // exact match has distance 0, so it should be excluded
+    expect(result).not.toContain("doctor");
+  });
+
+  test("close typo 'loign' suggests 'login'", () => {
+    const result = suggestCommand("loign");
+    expect(result).toContain("login");
+  });
+
+  test("close typo 'logut' suggests 'logout'", () => {
+    const result = suggestCommand("logut");
+    expect(result).toContain("logout");
+  });
+
+  test("multi-word: 'workspace ad' suggests 'workspace add'", () => {
+    const result = suggestCommand("workspace ad");
+    expect(result).toContain("workspace add");
+  });
+
+  test("no match for very different input", () => {
+    const result = suggestCommand("zzzzzzzzzzzzzzzzz");
+    expect(result).toEqual([]);
+  });
+
+  test("multiple suggestions sorted by distance", () => {
+    const result = suggestCommand("run");
+    // "run" is an exact top-level match (distance 0, excluded)
+    // but "runs list" and "run status" may be close
+    // All results should be sorted by ascending distance
+    for (let i = 1; i < result.length; i++) {
+      const dPrev = levenshteinDistance("run", result[i - 1]);
+      const dCurr = levenshteinDistance("run", result[i]);
+      expect(dCurr).toBeGreaterThanOrEqual(dPrev);
+    }
+  });
+
+  test("'harnes' suggests 'harness'", () => {
+    const result = suggestCommand("harnes");
+    expect(result).toContain("harness");
+  });
+
+  test("'doctr' suggests 'doctor'", () => {
+    const result = suggestCommand("doctr");
+    expect(result).toContain("doctor");
+  });
+});

package/test/tool-executors.unit.test.js

@@ -0,0 +1,165 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { validatePath, executeTool } from "../src/lib/tool-executors.js";
+
+function makeTmp() {
+  const dir = join(import.meta.dir, ".tmp-tool-exec-" + Date.now());
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+describe("validatePath", () => {
+  test("allows path within repo root", () => {
+    const result = validatePath("src/main.js", "/repo");
+    expect(result.resolved).toBe("/repo/src/main.js");
+    expect(result.error).toBeUndefined();
+  });
+
+  test("allows repo root itself", () => {
+    const result = validatePath(".", "/repo");
+    expect(result.resolved).toBe("/repo");
+    expect(result.error).toBeUndefined();
+  });
+
+  test("rejects path traversal with ../", () => {
+    const result = validatePath("../../.ssh/id_rsa", "/repo");
+    expect(result.error).toBe("path outside repo root");
+    expect(result.resolved).toBeUndefined();
+  });
+
+  test("rejects absolute path outside repo", () => {
+    const result = validatePath("/etc/passwd", "/repo");
+    expect(result.error).toBe("path outside repo root");
+  });
+});
+
+describe("executeTool — read_file", () => {
+  let tmp;
+  beforeEach(() => { tmp = makeTmp(); });
+  afterEach(() => { rmSync(tmp, { recursive: true, force: true }); });
+
+  test("reads file content", () => {
+    writeFileSync(join(tmp, "hello.txt"), "world");
+    const result = executeTool("read_file", { path: "hello.txt" }, tmp);
+    expect(result).toBe("world");
+  });
+
+  test("returns error for missing file", () => {
+    const result = executeTool("read_file", { path: "nope.txt" }, tmp);
+    expect(result).toContain("error:");
+    expect(result).toContain("not found");
+  });
+
+  test("rejects path traversal", () => {
+    const result = executeTool("read_file", { path: "../../.ssh/id_rsa" }, tmp);
+    expect(result).toContain("error: path outside repo root");
+  });
+});
+
+describe("executeTool — list_dir", () => {
+  let tmp;
+  beforeEach(() => { tmp = makeTmp(); });
+  afterEach(() => { rmSync(tmp, { recursive: true, force: true }); });
+
+  test("lists directory entries", () => {
+    mkdirSync(join(tmp, "subdir"));
+    writeFileSync(join(tmp, "file.txt"), "");
+    const result = executeTool("list_dir", { path: "." }, tmp);
+    expect(result).toContain("file.txt");
+    expect(result).toContain("subdir/");
+  });
+
+  test("filters out .git", () => {
+    mkdirSync(join(tmp, ".git"));
+    writeFileSync(join(tmp, "file.txt"), "");
+    const result = executeTool("list_dir", { path: "." }, tmp);
+    expect(result).not.toContain(".git");
+  });
+
+  test("rejects path traversal", () => {
+    const result = executeTool("list_dir", { path: "../.." }, tmp);
+    expect(result).toContain("error: path outside repo root");
+  });
+});
+
+describe("executeTool — glob", () => {
+  let tmp;
+  beforeEach(() => { tmp = makeTmp(); });
+  afterEach(() => { rmSync(tmp, { recursive: true, force: true }); });
+
+  test("matches files by pattern", () => {
+    mkdirSync(join(tmp, "src"), { recursive: true });
+    writeFileSync(join(tmp, "src", "main.js"), "");
+    writeFileSync(join(tmp, "src", "util.js"), "");
+    const result = executeTool("glob", { pattern: "src/*.js" }, tmp);
+    expect(result).toContain("src/main.js");
+    expect(result).toContain("src/util.js");
+  });
+
+  test("returns no matches message", () => {
+    const result = executeTool("glob", { pattern: "*.nonexistent" }, tmp);
+    expect(result).toBe("(no matches)");
+  });
+
+  test("** matches deeply nested files", () => {
+    mkdirSync(join(tmp, "a", "b", "c"), { recursive: true });
+    writeFileSync(join(tmp, "a", "b", "c", "deep.js"), "");
+    writeFileSync(join(tmp, "a", "top.js"), "");
+    const result = executeTool("glob", { pattern: "**/*.js" }, tmp);
+    expect(result).toContain("a/b/c/deep.js");
+    expect(result).toContain("a/top.js");
+  });
+
+  test("** matches root-level files", () => {
+    mkdirSync(join(tmp, "src"), { recursive: true });
+    writeFileSync(join(tmp, "jest.config.js"), "");
+    writeFileSync(join(tmp, "src", "nested.js"), "");
+    const result = executeTool("glob", { pattern: "**/*.js" }, tmp);
+    expect(result).toContain("jest.config.js");
+    expect(result).toContain("src/nested.js");
+  });
+
+  test("? matches single character", () => {
+    writeFileSync(join(tmp, "a.js"), "");
+    writeFileSync(join(tmp, "ab.js"), "");
+    const result = executeTool("glob", { pattern: "?.js" }, tmp);
+    expect(result).toContain("a.js");
+    expect(result).not.toContain("ab.js");
+  });
+
+  test("excludes .git directory", () => {
+    mkdirSync(join(tmp, ".git", "objects"), { recursive: true });
+    mkdirSync(join(tmp, "src"), { recursive: true });
+    writeFileSync(join(tmp, ".git", "config"), "");
+    writeFileSync(join(tmp, "src", "real.js"), "");
+    const result = executeTool("glob", { pattern: "**/*.js" }, tmp);
+    expect(result).toContain("src/real.js");
+    expect(result).not.toContain(".git");
+    expect(result).not.toContain("config");
+  });
+
+  test("* does not cross directory boundaries", () => {
+    mkdirSync(join(tmp, "src"), { recursive: true });
+    writeFileSync(join(tmp, "src", "nested.js"), "");
+    writeFileSync(join(tmp, "root.js"), "");
+    const result = executeTool("glob", { pattern: "*.js" }, tmp);
+    expect(result).toContain("root.js");
+    expect(result).not.toContain("src/nested.js");
+  });
+
+  test("matches dotfiles in pattern", () => {
+    writeFileSync(join(tmp, ".env"), "");
+    writeFileSync(join(tmp, ".gitignore"), "");
+    const result = executeTool("glob", { pattern: ".*" }, tmp);
+    expect(result).toContain(".env");
+    expect(result).toContain(".gitignore");
+  });
+});
+
+describe("executeTool — unknown tool", () => {
+  test("returns error for unknown tool name", () => {
+    const result = executeTool("write_file", { path: "x" }, "/tmp");
+    expect(result).toContain('error: unknown tool "write_file"');
+  });
+});

package/test/validate.test.js

@@ -0,0 +1,81 @@
+import { describe, test, expect } from "bun:test";
+import { isValidId, validateRequiredId } from "../src/program/validate.js";
+
+describe("isValidId", () => {
+  test("valid UUID passes", () => {
+    expect(isValidId("550e8400-e29b-41d4-a716-446655440000")).toBe(true);
+  });
+
+  test("uppercase UUID passes", () => {
+    expect(isValidId("550E8400-E29B-41D4-A716-446655440000")).toBe(true);
+  });
+
+  test("empty string fails", () => {
+    expect(isValidId("")).toBe(false);
+  });
+
+  test("null fails", () => {
+    expect(isValidId(null)).toBe(false);
+  });
+
+  test("undefined fails", () => {
+    expect(isValidId(undefined)).toBe(false);
+  });
+
+  test("too short fails (3 chars)", () => {
+    expect(isValidId("abc")).toBe(false);
+  });
+
+  test("valid non-UUID ID (alphanumeric) passes", () => {
+    expect(isValidId("ws_123456789abc")).toBe(true);
+  });
+
+  test("valid non-UUID with dashes passes", () => {
+    expect(isValidId("my-workspace-id")).toBe(true);
+  });
+
+  test("special characters (spaces) fail", () => {
+    expect(isValidId("has spaces")).toBe(false);
+  });
+
+  test("special characters (dots) fail", () => {
+    expect(isValidId("has.dots")).toBe(false);
+  });
+
+  test("4-char minimum passes", () => {
+    expect(isValidId("abcd")).toBe(true);
+  });
+
+  test("128-char maximum passes", () => {
+    expect(isValidId("a".repeat(128))).toBe(true);
+  });
+
+  test("129-char string fails", () => {
+    expect(isValidId("a".repeat(129))).toBe(false);
+  });
+});
+
+describe("validateRequiredId", () => {
+  test("valid UUID returns ok", () => {
+    const result = validateRequiredId("550e8400-e29b-41d4-a716-446655440000", "workspace_id");
+    expect(result.ok).toBe(true);
+  });
+
+  test("empty string returns error with name", () => {
+    const result = validateRequiredId("", "workspace_id");
+    expect(result.ok).toBe(false);
+    expect(result.message).toContain("workspace_id");
+  });
+
+  test("invalid format returns helpful message", () => {
+    const result = validateRequiredId("!@#", "run_id");
+    expect(result.ok).toBe(false);
+    expect(result.message).toContain("run_id");
+    expect(result.message).toContain("UUID");
+  });
+
+  test("valid non-UUID ID returns ok", () => {
+    const result = validateRequiredId("ws_123456789abc", "workspace_id");
+    expect(result.ok).toBe(true);
+  });
+});

package/test/workspace-add.test.js

@@ -0,0 +1,106 @@
+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 { loadWorkspaces } from "../src/lib/state.js";
+
+function bufferStream() {
+  let data = "";
+  return {
+    stream: new Writable({
+      write(chunk, _enc, cb) {
+        data += String(chunk);
+        cb();
+      },
+    }),
+    read: () => data,
+  };
+}
+
+async function withStateDir(fn) {
+  const old = process.env.ZOMBIE_STATE_DIR;
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "zombiectl-state-"));
+  process.env.ZOMBIE_STATE_DIR = dir;
+  try {
+    return await fn(dir);
+  } finally {
+    if (old === undefined) delete process.env.ZOMBIE_STATE_DIR;
+    else process.env.ZOMBIE_STATE_DIR = old;
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+}
+
+test("workspace add does not persist local state when API create fails", async () => {
+  await withStateDir(async () => {
+    const out = bufferStream();
+    const err = bufferStream();
+
+    const fetchImpl = async (url, options) => {
+      assert.equal(url, "http://localhost:3000/v1/workspaces");
+      assert.equal(options.method, "POST");
+      return {
+        ok: false,
+        status: 500,
+        statusText: "Internal Server Error",
+        text: async () => JSON.stringify({
+          error: { code: "INTERNAL_ERROR", message: "Failed to create workspace" },
+          request_id: "req_abc123",
+        }),
+      };
+    };
+
+    const code = await runCli(["workspace", "add", "https://github.com/acme/repo"], {
+      env: { ...process.env, ZOMBIE_TOKEN: "header.payload.sig", BROWSER: "false" },
+      stdout: out.stream,
+      stderr: err.stream,
+      fetchImpl,
+    });
+
+    assert.equal(code, 1);
+    assert.match(err.read(), /INTERNAL_ERROR/);
+    assert.match(err.read(), /request_id: req_abc123/);
+
+    const workspaces = await loadWorkspaces();
+    assert.equal(workspaces.current_workspace_id, null);
+    assert.deepEqual(workspaces.items, []);
+  });
+});
+
+test("workspace add persists backend workspace_id and emits install url in json mode", async () => {
+  await withStateDir(async () => {
+    const out = bufferStream();
+    const err = 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_123",
+      }),
+    });
+
+    const code = await runCli(["--json", "workspace", "add", "https://github.com/acme/repo"], {
+      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.workspace_id, "ws_123456789abc");
+    assert.match(parsed.install_url, /github\.com\/apps\/usezombie\/installations\/new\?state=ws_123456789abc/);
+
+    const workspaces = await loadWorkspaces();
+    assert.equal(workspaces.current_workspace_id, "ws_123456789abc");
+    assert.equal(workspaces.items.length, 1);
+    assert.equal(workspaces.items[0].workspace_id, "ws_123456789abc");
+  });
+});

package/test/workspace.unit.test.js

@@ -0,0 +1,230 @@
+import { describe, test, expect } from "bun:test";
+import { makeNoop, makeBufferStream, ui, WS_ID } from "./helpers.js";
+import { createCoreHandlers } from "../src/commands/core.js";
+
+const WS_ID_2 = "0195b4ba-8d3a-7f13-8abc-000000000099";
+
+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("commandWorkspace", () => {
+  test("list shows table", async () => {
+    let tableRows = null;
+    const deps = makeDeps({
+      printTable: (_s, _cols, rows) => { tableRows = rows; },
+    });
+    const items = [
+      { workspace_id: WS_ID, repo_url: "https://github.com/acme/repo" },
+      { workspace_id: WS_ID_2, repo_url: "https://github.com/acme/other" },
+    ];
+    const ctx = { stdout: makeNoop(), stderr: makeNoop(), jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandWorkspace(["list"]);
+    expect(code).toBe(0);
+    expect(tableRows.length).toBe(2);
+    expect(tableRows[0].active).toBe("*");
+    expect(tableRows[1].active).toBe("");
+  });
+
+  test("list empty state", async () => {
+    const out = makeBufferStream();
+    const deps = makeDeps({
+      printTable: () => {},
+    });
+    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.commandWorkspace(["list"]);
+    expect(code).toBe(0);
+    expect(out.read()).toContain("no workspaces");
+  });
+
+  test("remove by ID", async () => {
+    let savedWs = null;
+    const deps = makeDeps({
+      saveWorkspaces: async (ws) => { savedWs = ws; },
+    });
+    const items = [{ workspace_id: WS_ID, repo_url: "https://github.com/acme/repo" }];
+    const ctx = { stdout: makeNoop(), stderr: makeNoop(), jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [...items] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandWorkspace(["remove", WS_ID]);
+    expect(code).toBe(0);
+    expect(savedWs.items.length).toBe(0);
+  });
+
+  test("remove updates current workspace", async () => {
+    let savedWs = null;
+    const deps = makeDeps({
+      saveWorkspaces: async (ws) => { savedWs = ws; },
+    });
+    const items = [
+      { workspace_id: WS_ID, repo_url: "https://github.com/acme/repo" },
+      { workspace_id: WS_ID_2, repo_url: "https://github.com/acme/other" },
+    ];
+    const ctx = { stdout: makeNoop(), stderr: makeNoop(), jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [...items] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandWorkspace(["remove", WS_ID]);
+    expect(code).toBe(0);
+    expect(savedWs.current_workspace_id).toBe(WS_ID_2);
+  });
+
+  test("remove without id returns error", async () => {
+    const err = makeBufferStream();
+    const deps = makeDeps();
+    const ctx = { stdout: makeNoop(), stderr: err.stream, jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: null, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandWorkspace(["remove"]);
+    expect(code).toBe(2);
+    expect(err.read()).toContain("workspace remove requires");
+  });
+
+  test("upgrade-scale requires workspace id", async () => {
+    const err = makeBufferStream();
+    const deps = makeDeps();
+    const ctx = { stdout: makeNoop(), stderr: err.stream, jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: null, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandWorkspace(["upgrade-scale"]);
+    expect(code).toBe(2);
+    expect(err.read()).toContain("workspace upgrade-scale requires --workspace-id");
+  });
+
+  test("upgrade-scale requires subscription id", async () => {
+    const err = makeBufferStream();
+    const deps = makeDeps();
+    const ctx = { stdout: makeNoop(), stderr: err.stream, jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandWorkspace(["upgrade-scale", "--workspace-id", WS_ID]);
+    expect(code).toBe(2);
+    expect(err.read()).toContain("workspace upgrade-scale requires --subscription-id");
+  });
+
+  test("upgrade-scale calls billing endpoint", async () => {
+    const out = makeBufferStream();
+    let called = null;
+    const deps = makeDeps({
+      request: async (_ctx, reqPath, options) => {
+        called = { reqPath, options };
+        return { plan_tier: "scale", billing_status: "active", subscription_id: "sub_scale_123" };
+      },
+    });
+    const ctx = { stdout: out.stream, stderr: makeNoop(), jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandWorkspace(["upgrade-scale", "--workspace-id", WS_ID, "--subscription-id", "sub_scale_123"]);
+    expect(code).toBe(0);
+    expect(called.reqPath).toContain(`/v1/workspaces/${WS_ID}/billing/scale`);
+    expect(JSON.parse(called.options.body).subscription_id).toBe("sub_scale_123");
+    expect(out.read()).toContain("workspace upgraded to scale");
+  });
+
+  test("upgrade-scale with subscription_id as second positional (both positional)", async () => {
+    const out = makeBufferStream();
+    let called = null;
+    const deps = makeDeps({
+      request: async (_ctx, reqPath, options) => {
+        called = { reqPath, options };
+        return { plan_tier: "scale", billing_status: "active", subscription_id: "sub_pos_456" };
+      },
+    });
+    const ctx = { stdout: out.stream, stderr: makeNoop(), jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandWorkspace(["upgrade-scale", WS_ID, "sub_pos_456"]);
+    expect(code).toBe(0);
+    expect(called.reqPath).toContain(`/v1/workspaces/${WS_ID}/billing/scale`);
+    expect(JSON.parse(called.options.body).subscription_id).toBe("sub_pos_456");
+    const output = out.read();
+    expect(output).toContain("workspace upgraded to scale");
+    expect(output).toContain("subscription_id: sub_pos_456");
+  });
+
+  test("upgrade-scale with --workspace-id flag and bare positional requires --subscription-id", async () => {
+    const err = makeBufferStream();
+    const deps = makeDeps();
+    const ctx = { stdout: makeNoop(), stderr: err.stream, jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandWorkspace(["upgrade-scale", "--workspace-id", WS_ID, "sub_pos_456"]);
+    expect(code).toBe(2);
+    expect(err.read()).toContain("requires --subscription-id");
+  });
+
+  test("upgrade-scale with null subscription_id in response omits subscription_id line", async () => {
+    const out = makeBufferStream();
+    const deps = makeDeps({
+      request: async () => ({ plan_tier: "scale", billing_status: "active", subscription_id: null }),
+    });
+    const ctx = { stdout: out.stream, stderr: makeNoop(), jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandWorkspace(["upgrade-scale", "--workspace-id", WS_ID, "--subscription-id", "sub_input_789"]);
+    expect(code).toBe(0);
+    const output = out.read();
+    expect(output).toContain("workspace upgraded to scale");
+    expect(output).toContain("plan_tier: scale");
+    expect(output).toContain("billing_status: active");
+    expect(output).not.toContain("subscription_id:");
+  });
+
+  test("upgrade-scale in JSON mode prints JSON output", async () => {
+    const apiResponse = { plan_tier: "scale", billing_status: "active", subscription_id: "sub_json_001" };
+    let jsonOutput = null;
+    const deps = makeDeps({
+      request: async () => apiResponse,
+      printJson: (_s, v) => { jsonOutput = v; },
+    });
+    const ctx = { stdout: makeNoop(), stderr: makeNoop(), jsonMode: true, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandWorkspace(["upgrade-scale", "--workspace-id", WS_ID, "--subscription-id", "sub_json_001"]);
+    expect(code).toBe(0);
+    expect(jsonOutput).toEqual(apiResponse);
+  });
+
+  test("upgrade-scale when API request throws propagates error", async () => {
+    const deps = makeDeps({
+      request: async () => { throw new Error("network failure"); },
+    });
+    const ctx = { stdout: makeNoop(), stderr: makeNoop(), jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    await expect(
+      core.commandWorkspace(["upgrade-scale", "--workspace-id", WS_ID, "--subscription-id", "sub_err_999"]),
+    ).rejects.toThrow("network failure");
+  });
+});