@lizard-build/cli 4.0.37 → 4.0.39

package/src/lib/default-project.ts

@@ -0,0 +1,47 @@
+import chalk from "chalk";
+import { api, APIError } from "./api.js";
+import { info } from "./format.js";
+
+// The project a command uses when the folder is not linked and no --project is
+// given: the platform's default for this account (GET /api/projects/default),
+// the oldest project in the personal workspace. Every account gets one at
+// sign-up, so `lizard sandbox create` or `lizard up` from any folder works
+// without `lizard init` first.
+
+export interface DefaultProject {
+  id: string;
+  name: string;
+  slug: string;
+  workspaceId: string;
+  workspaceName: string;
+}
+
+let lookup: Promise<DefaultProject | null> | undefined;
+
+/**
+ * The default project, asked once per run. Null when the account has none, or
+ * when the platform predates the route; callers then fail as they always did.
+ * 401 still throws: that is a sign-in problem, not a missing project.
+ */
+export function defaultProject(): Promise<DefaultProject | null> {
+  lookup ??= api.get<DefaultProject>("/api/projects/default").catch((err) => {
+    if (err instanceof APIError && err.status !== 401 && err.status >= 400 && err.status < 500) return null;
+    throw err;
+  });
+  return lookup;
+}
+
+let noted = false;
+
+/** Say once per run which project an unlinked folder ended up in, and how to choose another. */
+export function noteDefaultProject(name: string): void {
+  if (noted) return;
+  noted = true;
+  info(chalk.dim(`Project: ${name} (your default). Pass --project for another, or run \`lizard init\` to link this folder.`));
+}
+
+/** For tests: forget the cached answer. */
+export function resetDefaultProject(): void {
+  lookup = undefined;
+  noted = false;
+}

package/src/lib/updater.ts

@@ -5,7 +5,7 @@ import { join, dirname } from "node:path";
 import os from "node:os";
 import { spawn } from "node:child_process";
 
-export const CURRENT_VERSION = "4.0.37";
+export const CURRENT_VERSION = "4.0.39";
 const RELEASES_API = "https://api.github.com/repos/lizard-build/lizard-cli/releases/latest";
 const RELEASE_BASE = "https://github.com/lizard-build/lizard-cli/releases/latest/download";
 

package/test/unit/default-project.test.ts

@@ -0,0 +1,104 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { resolveProjectId, getProjectLink, setProjectLink } from "../../src/lib/config.js";
+import { resetDefaultProject } from "../../src/lib/default-project.js";
+import { ensureLinked } from "../../src/commands/init.js";
+import { setBaseURL, setAccessToken } from "../../src/lib/api.js";
+import { setJSONMode } from "../../src/lib/format.js";
+
+const fetchMock = vi.fn();
+let tmpHome: string;
+let tmpCwd: string;
+let cwd: string;
+const savedHome = process.env.LIZARD_HOME;
+
+const project = { id: "p-default", name: "ada's Project", slug: "ada", workspaceId: "ws-1", workspaceName: "ada" };
+
+function reply(status: number, body: unknown) {
+  return new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+}
+
+function routes(table: Record<string, () => Response>) {
+  fetchMock.mockImplementation(async (url: string, init?: RequestInit) => {
+    const key = `${init?.method ?? "GET"} ${new URL(url).pathname}`;
+    return table[key]?.() ?? reply(404, { error: `no route ${key}` });
+  });
+}
+
+const requested = () => fetchMock.mock.calls.map(([url, init]) => `${init?.method ?? "GET"} ${new URL(url).pathname}`);
+
+beforeEach(() => {
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "lizard-default-home-"));
+  tmpCwd = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "lizard-default-cwd-")));
+  process.env.LIZARD_HOME = tmpHome;
+  cwd = process.cwd();
+  process.chdir(tmpCwd);
+  fetchMock.mockReset();
+  vi.stubGlobal("fetch", fetchMock);
+  setBaseURL("https://lizard.build");
+  setAccessToken("tok");
+  setJSONMode(true);
+  resetDefaultProject();
+});
+
+afterEach(() => {
+  process.chdir(cwd);
+  if (savedHome === undefined) delete process.env.LIZARD_HOME;
+  else process.env.LIZARD_HOME = savedHome;
+  vi.unstubAllGlobals();
+  setJSONMode(false);
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+  fs.rmSync(tmpCwd, { recursive: true, force: true });
+});
+
+describe("resolveProjectId in an unlinked folder", () => {
+  test("uses the account's default project, asking the platform once per run", async () => {
+    routes({ "GET /api/projects/default": () => reply(200, project) });
+    expect(await resolveProjectId()).toBe("p-default");
+    expect(await resolveProjectId()).toBe("p-default");
+    expect(requested()).toEqual(["GET /api/projects/default"]);
+  });
+
+  test("a linked folder or --project never asks for it", async () => {
+    setProjectLink({ projectId: "p-linked" });
+    expect(await resolveProjectId()).toBe("p-linked");
+    expect(await resolveProjectId("abcdefghijklmnopqrstu")).toBe("abcdefghijklmnopqrstu");
+    expect(requested()).toEqual([]);
+  });
+
+  test("no default project, or a platform without the route: the old error", async () => {
+    routes({ "GET /api/projects/default": () => reply(404, { error: "none", code: "NO_DEFAULT_PROJECT" }) });
+    await expect(resolveProjectId()).rejects.toThrow("No project linked. Run `lizard init` or pass --project <id>.");
+  });
+
+  test("a sign-in problem is not mistaken for a missing project", async () => {
+    routes({ "GET /api/projects/default": () => reply(401, { error: "Unauthorized" }) });
+    await expect(resolveProjectId()).rejects.toMatchObject({ status: 401 });
+  });
+});
+
+describe("lizard up in an unlinked folder", () => {
+  test("links the folder to the default project without asking", async () => {
+    routes({ "GET /api/projects/default": () => reply(200, project) });
+    const link = await ensureLinked({ useDefault: true });
+
+    expect(link).toEqual({ projectId: "p-default", projectName: "ada's Project", workspaceId: "ws-1", workspaceName: "ada" });
+    expect(getProjectLink()).toMatchObject({ projectId: "p-default" });
+    expect(requested()).toEqual(["GET /api/projects/default"]);
+  });
+
+  test("--project, or lizard init itself, still goes through the old flow", async () => {
+    routes({});
+    await expect(ensureLinked({ useDefault: true, projectName: "api" })).rejects.toThrow();
+    await expect(ensureLinked({})).rejects.toThrow();
+    expect(requested()).not.toContain("GET /api/projects/default");
+  });
+
+  test("an already linked folder stays as it is", async () => {
+    setProjectLink({ projectId: "p-linked" });
+    expect((await ensureLinked({ useDefault: true })).projectId).toBe("p-linked");
+    expect(requested()).toEqual([]);
+  });
+});

package/test/unit/login.test.ts

@@ -186,20 +186,17 @@ describe("account state", () => {
 
   test("the closing note leads with sandboxes, aligned in two columns", () => {
     const plain = (t: string) => t.replace(/\x1b\[[0-9;]*m/g, "");
-    expect(plain(nextStepsNote(false)).split("\n")).toEqual([
-      "lizard init             Create a project and link this folder",
-      "lizard sandbox create   Start a sandbox in it",
-      "lizard up               Or deploy this folder",
-    ]);
-    expect(plain(nextStepsNote(true)).split("\n")).toEqual([
-      "lizard sandbox create   Start a sandbox in this project",
+    expect(plain(nextStepsNote()).split("\n")).toEqual([
+      "lizard sandbox create   Start a sandbox",
       "lizard up               Or deploy this folder",
     ]);
   });
 
-  test("an unlinked folder gets lizard init before lizard up", () => {
-    expect(nextSteps(false).map((s) => s.command)).toEqual(["lizard skills get core", "lizard init", "lizard sandbox create", "lizard up"]);
+  test("no lizard init needed: an unlinked folder uses the default project", () => {
+    expect(nextSteps(false).map((s) => s.command)).toEqual(["lizard skills get core", "lizard sandbox create", "lizard up"]);
+    expect(nextSteps(false)[1].why).toContain("default project");
     expect(nextSteps(true).map((s) => s.command)).toEqual(["lizard skills get core", "lizard sandbox create", "lizard up"]);
+    expect(nextSteps(true)[1].why).toContain("linked project");
   });
 });
 
@@ -239,7 +236,7 @@ describe("lizard login --json", () => {
     expect(out).toMatchObject({ status: "complete", username: "ada", email: "ada@example.com", source: "browser" });
     expect(out.account.state).toBe("trial_available");
     expect(out.account.billingUrl).toBe("https://lizard.build/profile/account-billing");
-    expect(out.next.map((s: { command: string }) => s.command)).toContain("lizard init");
+    expect(out.next.map((s: { command: string }) => s.command)).toContain("lizard sandbox create");
     expect(loadConfig().pendingAuth).toBeUndefined();
     expect(loadConfig().credentials?.username).toBe("ada");
   });

package/test/unit/sandbox.test.ts

@@ -3,6 +3,7 @@ import { Command } from "commander";
 import { registerSandbox } from "../../src/commands/sandbox.js";
 import { api, APIError } from "../../src/lib/api.js";
 import { printJSON } from "../../src/lib/format.js";
+import { getProjectLink, resolveProjectId } from "../../src/lib/config.js";
 
 vi.mock("../../src/lib/api.js", () => {
   class APIError extends Error {
@@ -13,8 +14,8 @@ vi.mock("../../src/lib/api.js", () => {
 vi.mock("open", () => ({ default: vi.fn().mockResolvedValue(undefined) }));
 vi.mock("../../src/lib/config.js", () => ({
   resolveProjectId: vi.fn().mockResolvedValue("project-test"),
+  getProjectLink: vi.fn(() => ({ projectId: "project-test" })),
 }));
-vi.mock("../../src/lib/config.js", () => ({ resolveProjectId: vi.fn().mockResolvedValue("project-test") }));
 vi.mock("../../src/lib/format.js", () => ({ isJSONMode: () => true, printJSON: vi.fn() }));
 
 function create(args: string[]) {
@@ -46,6 +47,41 @@ describe("sandbox create timeout", () => {
 });
 
 
+describe("sandbox create without a project", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(api.post).mockResolvedValue({ id: "sandbox-test" });
+  });
+
+  it("an unlinked folder sends no project and leaves the choice to the platform", async () => {
+    vi.mocked(getProjectLink).mockReturnValueOnce(null);
+    await create([]);
+    expect(resolveProjectId).not.toHaveBeenCalled();
+    expect(api.post).toHaveBeenCalledWith("/api/sandboxes", expect.objectContaining({ projectId: undefined }));
+  });
+
+  it("a linked folder or --project still sends its project", async () => {
+    await create([]);
+    expect(api.post).toHaveBeenCalledWith("/api/sandboxes", expect.objectContaining({ projectId: "project-test" }));
+    vi.mocked(getProjectLink).mockReturnValueOnce(null);
+    await create(["--project", "web"]);
+    expect(resolveProjectId).toHaveBeenLastCalledWith("web");
+  });
+
+  it("an unlinked --volume still resolves a project, since a volume name lives in one", async () => {
+    vi.mocked(getProjectLink).mockReturnValueOnce(null);
+    await create(["--volume", "data"]);
+    expect(resolveProjectId).toHaveBeenCalledWith(undefined);
+    expect(api.post).toHaveBeenCalledWith("/api/sandboxes", expect.objectContaining({ projectId: "project-test", volumeName: "data" }));
+  });
+
+  it("a platform that still wants a project gets the old message", async () => {
+    vi.mocked(getProjectLink).mockReturnValueOnce(null);
+    vi.mocked(api.post).mockRejectedValueOnce(new APIError(400, "A project is required", "PROJECT_REQUIRED"));
+    await expect(create([])).rejects.toThrow("No project linked. Run `lizard init` or pass --project <id>.");
+  });
+});
+
 describe("unsupported sandbox commands", () => {
   it.each(["fork", "snapshot-fork", "logs"])(
     "rejects %s without making an API request", async (name) => {
@@ -66,7 +102,7 @@ describe("private sandbox snapshots", () => {
   it("creates a snapshot with five warm copies by default", async () => {
     const program = new Command().exitOverride(); registerSandbox(program);
     await program.parseAsync(['sandbox', 'snapshot', 'sandbox-test', '--name', 'My app', '--no-wait'], { from: 'user' });
-    expect(api.post).toHaveBeenCalledWith('/api/sandboxes/sandbox-test/snapshot', { name: 'My app', poolSize: 5 });
+    expect(api.post).toHaveBeenCalledWith('/api/sandboxes/sandbox-test/snapshot', { name: 'My app', poolSize: 5, scope: 'user' });
   });
   it.each(['0', '11', '1.5', '5junk'])("rejects invalid warm count %s", async count => {
     const program = new Command().exitOverride(); registerSandbox(program);