@lizard-build/cli 4.0.48 → 4.0.50

package/src/commands/workspace.ts

@@ -4,6 +4,7 @@ import { Command } from "commander";
 import { api, withQuery, type Workspace } from "../lib/api.js";
 import { fetchWorkspaces, resolveWorkspace } from "../lib/picker.js";
 import { isJSONMode, printJSON, table, success, info, isTTY } from "../lib/format.js";
+import { printBulkResult, type BulkPauseResult } from "./pause.js";
 
 /**
  * `lizard workspace` — create, list, and delete workspaces.
@@ -61,6 +62,21 @@ export function registerWorkspace(program: Command) {
       );
     });
 
+  for (const op of ["pause", "resume"] as const) {
+    ws.command(op)
+      .argument("<name-or-id>", "Workspace name, slug, or ID")
+      .description(op === "pause"
+        ? "Pause every service in every project of a workspace (owner only; keeps URLs, passwords, settings and data)"
+        : "Resume the services you paused in a workspace (owner only)")
+      .action(async (nameOrId: string) => {
+        const workspace = await resolveWorkspace(nameOrId);
+        if (workspace.role !== "owner") throw new Error(`Only the workspace owner can ${op} all of it.`);
+        const result = await api.post<BulkPauseResult>(`/api/workspaces/${workspace.id}/${op}`);
+        if (isJSONMode()) { printJSON({ id: workspace.id, ...result }); return; }
+        printBulkResult(op, `workspace ${chalk.bold(workspace.name)}`, result);
+      });
+  }
+
   ws.command("rm")
     .alias("delete")
     .argument("<name-or-id>", "Workspace name, slug, or ID")

package/src/index.ts

@@ -82,6 +82,7 @@ import { registerProjects } from "./commands/projects.js";
 import { registerPs } from "./commands/ps.js";
 import { registerRedeploy } from "./commands/redeploy.js";
 import { registerRegions } from "./commands/regions.js";
+import { registerPause } from "./commands/pause.js";
 import { registerRestart } from "./commands/restart.js";
 import { registerRun } from "./commands/run.js";
 import { registerS3 } from "./commands/s3.js";
@@ -178,6 +179,7 @@ registerProjects(program);
 registerPs(program);
 registerRedeploy(program);
 registerRegions(program);
+registerPause(program);
 registerRestart(program);
 registerRun(program);
 registerS3(program);

package/src/lib/format.ts

@@ -107,6 +107,7 @@ export function statusColor(status: string): string {
     case "pending":
       return chalk.yellow(status);
     case "deleting":
+    case "paused":
       return chalk.dim(status);
     default:
       return status;

package/src/lib/signin.ts

@@ -48,11 +48,44 @@ export interface CheckResponse {
   };
 }
 
-export interface Me {
+/** One project or workspace a scoped API key reaches, by name. */
+export interface KeyScope {
+  type: "workspace" | "project";
   id: string;
-  username: string;
+  name?: string | null;
+  workspaceId?: string | null;
+  workspaceName?: string | null;
+}
+
+export interface Me {
+  // Absent for a scoped API key: the platform never tells a scoped key whose account it
+  // is (it is handed to people who are not the account's members).
+  id?: string;
+  username?: string;
   email?: string | null;
   scoped?: boolean;
+  scopes?: KeyScope[];
+}
+
+/** "Project X (workspace Y)" for one scope; the id when the name is unknown. */
+export function describeScope(sc: KeyScope): string {
+  if (sc.type === "project") {
+    const ws = sc.workspaceName ? ` (workspace ${sc.workspaceName})` : "";
+    return `project ${sc.name || sc.id}${ws}`;
+  }
+  return `workspace ${sc.name || sc.id}`;
+}
+
+/** Who a login is, for "Signed in as ...": the username for an account, and the
+ *  project/workspace for a scoped key -- never the account owner's name, even from an
+ *  older platform that still sends it. */
+export function describeMe(me: Me): string {
+  if (me.scoped) {
+    const scopes = me.scopes ?? [];
+    if (scopes.length === 0) return "a scoped API key";
+    return `a key for ${scopes.map(describeScope).join(", ")}`;
+  }
+  return me.username ?? "unknown";
 }
 
 export interface Pending {
@@ -315,6 +348,6 @@ export async function signInInteractive(flag?: AuthProvider): Promise<Me> {
   saveSessionLogin({ accessToken: result.accessToken, user: result.user });
   spin.stop("Authorized");
   const me = await api.get<Me>("/api/auth/me");
-  p.log.success(`Signed in as ${chalk.bold(me.username)}`);
+  p.log.success(`Signed in as ${chalk.bold(describeMe(me))}`);
   return me;
 }

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.48";
+export const CURRENT_VERSION = "4.0.50";
 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/describe-me.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { describeMe } from "../../src/lib/signin.js";
+
+describe("describeMe", () => {
+  it("names an account by its username", () => {
+    expect(describeMe({ id: "u1", username: "alice" })).toBe("alice");
+  });
+
+  it("names a project-scoped key by its project and workspace, never the owner", () => {
+    const text = describeMe({
+      // An older platform still sent the owner for a scoped key.
+      id: "u1", username: "alice-the-owner", scoped: true,
+      scopes: [{ type: "project", id: "p1", name: "Shop", workspaceId: "w1", workspaceName: "Acme" }],
+    });
+    expect(text).toBe("a key for project Shop (workspace Acme)");
+    expect(text).not.toContain("alice");
+  });
+
+  it("names a workspace-scoped key by its workspace, falling back to the id", () => {
+    expect(describeMe({ scoped: true, scopes: [{ type: "workspace", id: "w1", name: "Acme" }, { type: "workspace", id: "w2" }] }))
+      .toBe("a key for workspace Acme, workspace w2");
+  });
+});

package/test/unit/pause.test.ts

@@ -0,0 +1,37 @@
+import { describe, test, expect, vi, afterEach } from "vitest";
+import { servicePausePath, printBulkResult } from "../../src/commands/pause.js";
+
+afterEach(() => vi.restoreAllMocks());
+
+describe("servicePausePath", () => {
+  test("an app pauses and resumes through /api/apps/:id", () => {
+    expect(servicePausePath("pause", { id: "a1", kind: "app" }, "p1", {})).toBe("/api/apps/a1/pause");
+    expect(servicePausePath("resume", { id: "a1", kind: "app" }, "p1", { workspaceId: "w1" })).toBe("/api/apps/a1/resume?workspaceId=w1");
+  });
+  test("a database (addon) pauses through its project", () => {
+    expect(servicePausePath("pause", { id: "d1", kind: "addon" }, "p1", { workspaceId: "w1" }))
+      .toBe("/api/projects/p1/addons/d1/pause?workspaceId=w1");
+  });
+});
+
+describe("printBulkResult", () => {
+  test("lists what was paused and what was skipped with why", () => {
+    const out: string[] = [];
+    vi.spyOn(process.stderr, "write").mockImplementation((chunk: any) => { out.push(String(chunk)); return true; });
+    printBulkResult("pause", "project demo", {
+      done: [{ kind: "app", id: "a1", name: "web" }, { kind: "database", id: "d1", name: "postgres" }],
+      skipped: [{ kind: "app", id: "a2", name: "worker", reason: "already paused" }],
+    });
+    const text = out.join("\n");
+    expect(text).toContain("Paused 2 services in project demo");
+    expect(text).toContain("web");
+    expect(text).toContain("worker");
+    expect(text).toContain("already paused");
+  });
+  test("says when there was nothing to do", () => {
+    const out: string[] = [];
+    vi.spyOn(process.stderr, "write").mockImplementation((chunk: any) => { out.push(String(chunk)); return true; });
+    printBulkResult("resume", "workspace team", { done: [], skipped: [] });
+    expect(out.join("\n")).toContain("nothing to resume");
+  });
+});