@lizard-build/cli 0.1.0 → 0.3.29

package/test/unit/init.test.ts

@@ -0,0 +1,211 @@
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { Workspace } from "../../src/lib/api.js";
+
+const personalWs: Workspace = {
+  id: "ws_personal",
+  name: "personal",
+  slug: "personal",
+  role: "owner",
+  isPersonal: true,
+  projectCount: 0,
+};
+const teamWs: Workspace = {
+  id: "ws_team",
+  name: "acme-team",
+  slug: "acme-team",
+  role: "member",
+  isPersonal: false,
+  projectCount: 2,
+};
+
+let tmpDir: string;
+let originalCwd: string;
+let originalIsTTY: boolean | undefined;
+let originalLizardHome: string | undefined;
+
+beforeEach(() => {
+  originalCwd = process.cwd();
+  originalIsTTY = process.stdout.isTTY;
+  originalLizardHome = process.env.LIZARD_HOME;
+
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "lizard-init-test-"));
+  process.env.LIZARD_HOME = tmpDir;
+  process.chdir(tmpDir);
+  Object.defineProperty(process.stdout, "isTTY", { value: false, configurable: true });
+});
+
+afterEach(() => {
+  process.chdir(originalCwd);
+  if (originalLizardHome === undefined) delete process.env.LIZARD_HOME;
+  else process.env.LIZARD_HOME = originalLizardHome;
+  Object.defineProperty(process.stdout, "isTTY", {
+    value: originalIsTTY,
+    configurable: true,
+  });
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+  vi.resetModules();
+  vi.restoreAllMocks();
+});
+
+/**
+ * Mock the API for one test. Returns the init module loaded fresh against
+ * those mocks so each test gets a clean import.
+ */
+async function withMockedApi(handlers: {
+  get?: (path: string) => unknown;
+  post?: (path: string, body?: unknown) => unknown;
+}) {
+  vi.resetModules();
+  const calls: Array<{ method: string; path: string; body?: unknown }> = [];
+  vi.doMock("../../src/lib/api.js", async () => {
+    const actual = await vi.importActual<typeof import("../../src/lib/api.js")>(
+      "../../src/lib/api.js",
+    );
+    return {
+      ...actual,
+      api: {
+        get: (p: string) => {
+          calls.push({ method: "GET", path: p });
+          return Promise.resolve(handlers.get?.(p));
+        },
+        post: (p: string, body?: unknown) => {
+          calls.push({ method: "POST", path: p, body });
+          return Promise.resolve(handlers.post?.(p, body));
+        },
+        put: () => Promise.reject(new Error("unexpected PUT")),
+        patch: () => Promise.reject(new Error("unexpected PATCH")),
+        delete: () => Promise.reject(new Error("unexpected DELETE")),
+      },
+    };
+  });
+
+  const init = await import("../../src/commands/init.js");
+  return { init, calls };
+}
+
+describe("ensureLinked — Railway-style workspace flow", () => {
+  test("non-TTY, single workspace, no flags → creates project in personal", async () => {
+    const { init, calls } = await withMockedApi({
+      get: (p) => (p === "/api/workspaces" ? [personalWs] : []),
+      post: (p) =>
+        p === "/api/projects"
+          ? { id: "proj_new", name: path.basename(tmpDir), slug: "demo" }
+          : null,
+    });
+    const link = await init.ensureLinked({});
+
+    expect(link.workspaceId).toBe("ws_personal");
+    expect(link.workspaceName).toBe("personal");
+    expect(link.projectId).toBe("proj_new");
+
+    // Backend got workspaceId in the POST body.
+    const post = calls.find((c) => c.method === "POST" && c.path === "/api/projects");
+    expect(post).toBeDefined();
+    expect((post!.body as any).workspaceId).toBe("ws_personal");
+  });
+
+  test("non-TTY with --name and multiple workspaces: unique hint auto-resolves ws", async () => {
+    const projects = [
+      { id: "p1", name: "api-backend", slug: "api-backend", workspaceId: "ws_team" },
+    ];
+    const { init, calls } = await withMockedApi({
+      get: (p) => {
+        if (p === "/api/workspaces") return [personalWs, teamWs];
+        if (p === "/api/projects") return projects;
+        if (p.startsWith("/api/projects?workspaceId=ws_team")) return projects;
+        return [];
+      },
+    });
+
+    const link = await init.ensureLinked({ projectName: "api-backend" });
+
+    expect(link.workspaceId).toBe("ws_team");
+    expect(link.projectId).toBe("p1");
+    // No POST — existing project was matched.
+    expect(calls.find((c) => c.method === "POST")).toBeUndefined();
+  });
+
+  test("--workspace + --name on a not-yet-existing project → creates in chosen ws", async () => {
+    const { init, calls } = await withMockedApi({
+      get: (p) => {
+        if (p === "/api/workspaces") return [personalWs, teamWs];
+        // Project lookup inside the chosen workspace: empty
+        return [];
+      },
+      post: (p, body: any) =>
+        p === "/api/projects"
+          ? { id: "proj_made", name: body.name, slug: "new-thing" }
+          : null,
+    });
+
+    const link = await init.ensureLinked({
+      workspaceFlag: "acme-team",
+      projectName: "new-thing",
+    });
+
+    expect(link.workspaceId).toBe("ws_team");
+    expect(link.projectId).toBe("proj_made");
+
+    const post = calls.find((c) => c.method === "POST" && c.path === "/api/projects");
+    expect((post!.body as any).workspaceId).toBe("ws_team");
+    expect((post!.body as any).name).toBe("new-thing");
+  });
+
+  test("--name with collisions across workspaces → fails", async () => {
+    const projects = [
+      { id: "p1", name: "api", slug: "api", workspaceId: "ws_personal" },
+      { id: "p2", name: "api", slug: "api", workspaceId: "ws_team" },
+    ];
+    const { init } = await withMockedApi({
+      get: (p) =>
+        p === "/api/workspaces"
+          ? [personalWs, teamWs]
+          : p === "/api/projects"
+            ? projects
+            : [],
+    });
+
+    await expect(init.ensureLinked({ projectName: "api" })).rejects.toThrow(
+      /Multiple projects named "api"/,
+    );
+  });
+
+  test("existing link, no --force → returns existing without API calls", async () => {
+    // Key the link under process.cwd() — macOS resolves /var → /private/var,
+    // so the symlink path used to seed the file would otherwise not match.
+    const cwd = process.cwd();
+    fs.mkdirSync(path.join(tmpDir, ".lizard"), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpDir, ".lizard", "config.json"),
+      JSON.stringify({
+        projects: {
+          [cwd]: {
+            projectId: "proj_existing",
+            projectName: "demo",
+            workspaceId: "ws_existing",
+            workspaceName: "old-ws",
+          },
+        },
+      }),
+    );
+
+    const { init, calls } = await withMockedApi({});
+    const link = await init.ensureLinked({});
+
+    expect(link.projectId).toBe("proj_existing");
+    expect(link.workspaceId).toBe("ws_existing");
+    expect(calls).toHaveLength(0);
+  });
+
+  test("unknown --workspace flag → clear error", async () => {
+    const { init } = await withMockedApi({
+      get: (p) => (p === "/api/workspaces" ? [personalWs, teamWs] : []),
+    });
+    await expect(
+      init.ensureLinked({ workspaceFlag: "ghost", projectName: "x" }),
+    ).rejects.toThrow(/Workspace "ghost" not found/);
+  });
+});

package/test/unit/json.test.ts

@@ -0,0 +1,208 @@
+/**
+ * --json flag tests. Runs the built CLI (dist/index.js) and asserts the
+ * output is parseable JSON for every command path that promises it.
+ *
+ * No network, no auth — every test runs with LIZARD_HOME pointed at a fresh
+ * tmp dir so credentials and link state are empty. Commands that *would*
+ * hit the network are tested only via their pre-network failure paths
+ * (auth errors, validation errors) which still surface JSON to stdout.
+ *
+ * Prereq: `npm run build` (these tests run dist/index.js, not src).
+ */
+
+import { execa } from "execa";
+import { describe, test, expect, beforeAll } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+const CLI = path.resolve(import.meta.dirname, "../../dist/index.js");
+const NODE = process.execPath;
+
+let TMP_HOME: string;
+let TMP_CWD: string;
+
+beforeAll(() => {
+  if (!fs.existsSync(CLI)) {
+    throw new Error(
+      `dist/index.js missing — run \`npm run build\` before this suite.`,
+    );
+  }
+  // realpathSync because /var/folders -> /private/var/folders on macOS; the
+  // child process resolves the link too and we want cwd assertions to match.
+  TMP_HOME = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "lizard-json-home-")));
+  TMP_CWD = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "lizard-json-cwd-")));
+});
+
+function run(args: string[], extra: { cwd?: string; env?: Record<string, string> } = {}) {
+  return execa(NODE, [CLI, ...args], {
+    reject: false,
+    cwd: extra.cwd ?? TMP_CWD,
+    env: {
+      ...process.env,
+      LIZARD_HOME: TMP_HOME,
+      // Belt-and-suspenders: even if a leaked LIZARD_TOKEN sits in the
+      // parent env, drop it so unauth tests can't pass by accident.
+      LIZARD_TOKEN: "",
+      ...(extra.env ?? {}),
+    },
+  });
+}
+
+function parseJSON(s: string): any {
+  return JSON.parse(s);
+}
+
+// Top-level commands that should appear in the help dump. Used both to
+// assert the dump is complete and to drill into each subcommand's --help
+// --json output.
+const TOP_LEVEL_COMMANDS = [
+  "add", "config", "docs", "domain", "git", "init", "link", "list", "login",
+  "logout", "logs", "open", "port", "project", "ps", "redeploy", "regions",
+  "restart", "run", "scale", "secrets", "service", "ssh", "status", "unlink",
+  "up", "upgrade", "whoami", "workspace",
+];
+
+// ── help dump ────────────────────────────────────────────────────────────────
+
+describe("--help --json dump", () => {
+  test("root help dumps the full command tree", async () => {
+    const { stdout, exitCode } = await run(["--help", "--json"]);
+    expect(exitCode).toBe(0);
+    const out = parseJSON(stdout);
+    expect(out).toMatchObject({ cli: "lizard" });
+    expect(typeof out.version).toBe("string");
+    expect(Array.isArray(out.command.subcommands)).toBe(true);
+    const names = out.command.subcommands.map((c: any) => c.name);
+    for (const cmd of TOP_LEVEL_COMMANDS) {
+      expect(names).toContain(cmd);
+    }
+    // Global --json option must appear at the root.
+    expect(out.command.options.some((o: any) => o.long === "--json")).toBe(true);
+  });
+
+  test.each(TOP_LEVEL_COMMANDS)(
+    "`%s --help --json` is valid JSON and names the command",
+    async (cmd) => {
+      const { stdout, exitCode } = await run([cmd, "--help", "--json"]);
+      expect(exitCode).toBe(0);
+      const out = parseJSON(stdout);
+      expect(out.command.name).toBe(cmd);
+      // globalOptions are exposed once we're inside a subcommand so the
+      // dump knows --json/--region/etc. are inherited.
+      expect(Array.isArray(out.globalOptions)).toBe(true);
+    },
+  );
+
+  test("nested subcommand drills correctly (`secrets set --help --json`)", async () => {
+    const { stdout, exitCode } = await run(["secrets", "set", "--help", "--json"]);
+    expect(exitCode).toBe(0);
+    const out = parseJSON(stdout);
+    expect(out.command.name).toBe("set");
+    expect(out.command.arguments.some((a: any) => a.name === "pairs")).toBe(true);
+  });
+
+  test("exitCodes is included in the dump", async () => {
+    const { stdout } = await run(["--help", "--json"]);
+    const out = parseJSON(stdout);
+    expect(out.exitCodes).toMatchObject({
+      "0": expect.any(String),
+      "2": expect.any(String),
+    });
+  });
+});
+
+// ── status (no auth, no network) ─────────────────────────────────────────────
+
+describe("status --json", () => {
+  test("explicit --json from an unlinked cwd returns {linked:false}", async () => {
+    const { stdout, exitCode } = await run(["status", "--json"]);
+    expect(exitCode).toBe(0);
+    const out = parseJSON(stdout);
+    expect(out).toMatchObject({ linked: false });
+    expect(out.cwd).toBe(TMP_CWD);
+  });
+
+  test("non-TTY auto-JSON: piped `status` (no flag) also returns JSON", async () => {
+    // execa pipes stdout → process.stdout.isTTY === false in the child →
+    // preAction enables JSON mode automatically.
+    const { stdout, exitCode } = await run(["status"]);
+    expect(exitCode).toBe(0);
+    const out = parseJSON(stdout);
+    expect(out).toHaveProperty("linked");
+    expect(out).toHaveProperty("cwd");
+  });
+});
+
+// ── upgrade (no auth) ────────────────────────────────────────────────────────
+
+describe("upgrade --json", () => {
+  // Network reachability isn't guaranteed in every CI; we just assert that
+  // *some* JSON object comes out for both `--check` and the bare form,
+  // regardless of which branch fires (rate-limited / error / up-to-date /
+  // update-available). All four branches now emit JSON.
+  test("--check --json always emits a JSON payload", async () => {
+    const { stdout, exitCode } = await run(["upgrade", "--check", "--json"]);
+    expect(exitCode).toBe(0);
+    const out = parseJSON(stdout);
+    expect(out).toHaveProperty("currentVersion");
+  }, 20_000);
+});
+
+// ── error path: auth ────────────────────────────────────────────────────────
+
+describe("error JSON to stdout", () => {
+  test("whoami with no credentials emits JSON error + exit 2", async () => {
+    // LIZARD_HOME points at an empty tmp dir → no creds → non-TTY (execa
+    // pipes) so requireAuth throws NOT_AUTHENTICATED instead of prompting.
+    const { stdout, exitCode } = await run(["whoami", "--json"]);
+    expect(exitCode).toBe(2);
+    const out = parseJSON(stdout);
+    expect(out.error).toBeDefined();
+    expect(out.error.code).toBe("NOT_AUTHENTICATED");
+    expect(typeof out.error.message).toBe("string");
+  });
+
+  test("auto-JSON: non-TTY whoami without --json still emits JSON error", async () => {
+    const { stdout, exitCode } = await run(["whoami"]);
+    expect(exitCode).toBe(2);
+    const out = parseJSON(stdout);
+    expect(out.error.code).toBe("NOT_AUTHENTICATED");
+  });
+
+  test("unknown command with --json doesn't write JSON-corrupting text to stdout", async () => {
+    // Commander rejects unknown commands before preAction. Our early
+    // setJSONMode(true) in main() lets the catch block still know --json
+    // was requested. The error message itself goes through commander's
+    // own path (stderr) — we just need stdout to stay parseable-or-empty.
+    const { stdout, exitCode } = await run(["totally-nonexistent-cmd", "--json"]);
+    expect(exitCode).not.toBe(0);
+    // stdout may legitimately be empty (commander prints to stderr) or
+    // contain a JSON error object — never plain text.
+    const trimmed = stdout.trim();
+    if (trimmed) {
+      expect(() => parseJSON(trimmed)).not.toThrow();
+    }
+  });
+});
+
+// ── stdout cleanliness ───────────────────────────────────────────────────────
+
+describe("stdout cleanliness in JSON mode", () => {
+  test("status --json stdout parses end-to-end (no spinner/info leak)", async () => {
+    const { stdout } = await run(["status", "--json"]);
+    // The whole stdout must be exactly one JSON value with optional
+    // trailing newline — no ANSI escapes, no leading spinner frames.
+    expect(stdout.trim().endsWith("}")).toBe(true);
+    expect(() => parseJSON(stdout)).not.toThrow();
+    // No ANSI escape sequences from chalk should leak into stdout.
+    // eslint-disable-next-line no-control-regex
+    expect(stdout).not.toMatch(/\x1b\[/);
+  });
+
+  test("help dump JSON contains no ANSI escapes either", async () => {
+    const { stdout } = await run(["--help", "--json"]);
+    // eslint-disable-next-line no-control-regex
+    expect(stdout).not.toMatch(/\x1b\[/);
+  });
+});

package/test/unit/picker.test.ts

@@ -0,0 +1,161 @@
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
+import type { Workspace } from "../../src/lib/api.js";
+
+const personalWs: Workspace = {
+  id: "ws_personal",
+  name: "personal",
+  slug: "personal",
+  role: "owner",
+  isPersonal: true,
+  projectCount: 1,
+};
+
+const teamWs: Workspace = {
+  id: "ws_team",
+  name: "acme-team",
+  slug: "acme-team",
+  role: "member",
+  isPersonal: false,
+  projectCount: 3,
+};
+
+let originalIsTTY: boolean | undefined;
+
+beforeEach(() => {
+  originalIsTTY = process.stdout.isTTY;
+  // Default to non-TTY so prompts don't hang the test runner.
+  Object.defineProperty(process.stdout, "isTTY", { value: false, configurable: true });
+});
+
+afterEach(() => {
+  Object.defineProperty(process.stdout, "isTTY", {
+    value: originalIsTTY,
+    configurable: true,
+  });
+  vi.resetModules();
+  vi.restoreAllMocks();
+});
+
+async function freshPicker(mockApi: { get: (path: string) => unknown }) {
+  vi.resetModules();
+  vi.doMock("../../src/lib/api.js", async () => {
+    const actual = await vi.importActual<typeof import("../../src/lib/api.js")>(
+      "../../src/lib/api.js",
+    );
+    return { ...actual, api: mockApi };
+  });
+  return await import("../../src/lib/picker.js");
+}
+
+describe("matchWorkspace", () => {
+  test("matches by id, slug, and name (case-insensitive)", async () => {
+    const picker = await freshPicker({ get: () => [] });
+    const list = [personalWs, teamWs];
+    expect(picker.matchWorkspace(list, "ws_team")?.id).toBe("ws_team");
+    expect(picker.matchWorkspace(list, "acme-team")?.id).toBe("ws_team");
+    expect(picker.matchWorkspace(list, "ACME-TEAM")?.id).toBe("ws_team");
+    expect(picker.matchWorkspace(list, "Personal")?.id).toBe("ws_personal");
+    expect(picker.matchWorkspace(list, "nope")).toBeUndefined();
+  });
+});
+
+describe("resolveWorkspace", () => {
+  test("returns the workspace when the flag matches", async () => {
+    const picker = await freshPicker({
+      get: () => [personalWs, teamWs],
+    });
+    const result = await picker.resolveWorkspace("acme-team");
+    expect(result.id).toBe("ws_team");
+  });
+
+  test("throws with the available list when nothing matches", async () => {
+    const picker = await freshPicker({
+      get: () => [personalWs, teamWs],
+    });
+    await expect(picker.resolveWorkspace("ghost")).rejects.toThrow(
+      /not found.*personal.*acme-team/,
+    );
+  });
+});
+
+describe("pickWorkspace", () => {
+  test("uses --workspace flag when provided", async () => {
+    const picker = await freshPicker({
+      get: () => [personalWs, teamWs],
+    });
+    const ws = await picker.pickWorkspace({
+      flag: "acme-team",
+      workspaces: [personalWs, teamWs],
+    });
+    expect(ws.id).toBe("ws_team");
+  });
+
+  test("auto-selects the only workspace", async () => {
+    const picker = await freshPicker({
+      get: () => [personalWs],
+    });
+    const ws = await picker.pickWorkspace({ workspaces: [personalWs] });
+    expect(ws.id).toBe("ws_personal");
+  });
+
+  test("non-TTY with multiple workspaces falls back to personal", async () => {
+    const picker = await freshPicker({
+      get: () => [personalWs, teamWs],
+    });
+    const ws = await picker.pickWorkspace({
+      workspaces: [personalWs, teamWs],
+    });
+    expect(ws.id).toBe("ws_personal");
+  });
+
+  test("non-TTY with multiple non-personal workspaces falls back to first", async () => {
+    const other: Workspace = { ...teamWs, id: "ws_other", name: "other-team", slug: "other-team" };
+    const picker = await freshPicker({
+      get: () => [teamWs, other],
+    });
+    const ws = await picker.pickWorkspace({
+      workspaces: [teamWs, other],
+    });
+    expect(ws.id).toBe("ws_team");
+  });
+
+  test("projectNameHint with unique match auto-resolves the workspace", async () => {
+    // pickWorkspace will call api.get('/api/projects') to find which ws has the
+    // project with name "api-backend" — return one match only.
+    const projects = [
+      { id: "p1", name: "api-backend", slug: "api-backend", workspaceId: "ws_team" },
+      { id: "p2", name: "other", slug: "other", workspaceId: "ws_personal" },
+    ];
+    const picker = await freshPicker({
+      get: (p: string) => (p === "/api/projects" ? projects : []),
+    });
+    const ws = await picker.pickWorkspace({
+      projectNameHint: "api-backend",
+      workspaces: [personalWs, teamWs],
+    });
+    expect(ws.id).toBe("ws_team");
+  });
+
+  test("projectNameHint with collisions fails with helpful message", async () => {
+    const projects = [
+      { id: "p1", name: "api", slug: "api", workspaceId: "ws_personal" },
+      { id: "p2", name: "api", slug: "api", workspaceId: "ws_team" },
+    ];
+    const picker = await freshPicker({
+      get: (p: string) => (p === "/api/projects" ? projects : []),
+    });
+    await expect(
+      picker.pickWorkspace({
+        projectNameHint: "api",
+        workspaces: [personalWs, teamWs],
+      }),
+    ).rejects.toThrow(/Multiple projects named "api"/);
+  });
+
+  test("no workspaces throws a clear error", async () => {
+    const picker = await freshPicker({ get: () => [] });
+    await expect(
+      picker.pickWorkspace({ workspaces: [] }),
+    ).rejects.toThrow(/No workspaces available/);
+  });
+});