@lizard-build/cli 0.3.74 → 0.3.76

package/src/commands/volume.ts

@@ -0,0 +1,143 @@
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import { Command } from "commander";
+import { api, withScope, type ResourceScope } from "../lib/api.js";
+import { resolveProjectScope } from "../lib/resolve.js";
+import { success, info, isJSONMode, printJSON, table, isTTY } from "../lib/format.js";
+
+interface VolumeRecord {
+  id: string;
+  name: string;
+  sizeGb: number;
+  status: string;
+  attachedTo?: string | null;
+  createdAt?: number;
+}
+
+/** Resolve a volume by name or ID within a project. Mirrors resolveService. */
+async function resolveVolume(
+  projectId: string,
+  scope: ResourceScope,
+  nameOrId: string,
+): Promise<VolumeRecord> {
+  const volumes = await api.get<VolumeRecord[]>(
+    withScope(`/api/projects/${projectId}/volumes`, scope),
+  );
+  const lower = nameOrId.toLowerCase();
+  const match = volumes.find(
+    (v) => v.id.toLowerCase() === lower || v.name.toLowerCase() === lower,
+  );
+  if (!match) {
+    throw new Error(
+      `Volume "${nameOrId}" not found. Available: ${volumes.map((v) => v.name).join(", ") || "(none)"}`,
+    );
+  }
+  return match;
+}
+
+function parseIntOption(v: string): number {
+  const n = parseInt(v, 10);
+  if (Number.isNaN(n)) throw new Error(`Invalid number: ${v}`);
+  return n;
+}
+
+export function registerVolume(program: Command) {
+  const vol = program
+    .command("volume")
+    .alias("vol")
+    .description("Manage persistent volumes for sandboxes");
+
+  vol
+    .command("list")
+    .alias("ls")
+    .description("List volumes in a project")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .action(async (opts) => {
+      const { projectId, scope } = await resolveProjectScope(opts.project);
+      const volumes = await api.get<VolumeRecord[]>(
+        withScope(`/api/projects/${projectId}/volumes`, scope),
+      );
+
+      if (isJSONMode()) {
+        printJSON(volumes);
+        return;
+      }
+
+      if (volumes.length === 0) {
+        console.log("No volumes. Use `lizard volume create <name>`.");
+        return;
+      }
+
+      table(
+        ["Name", "ID", "Size", "Status", "Attached to"],
+        volumes.map((v) => [
+          v.name,
+          chalk.dim(v.id),
+          `${v.sizeGb} GB`,
+          v.status,
+          v.attachedTo ? chalk.dim(v.attachedTo) : chalk.dim("—"),
+        ]),
+      );
+    });
+
+  vol
+    .command("create")
+    .argument("<name>", "Volume name")
+    .description("Create a persistent volume")
+    .option("--size <gb>", "Size in GB (1-100, default 5)", parseIntOption)
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .action(async (name: string, opts) => {
+      const { projectId, scope } = await resolveProjectScope(opts.project);
+      const sizeGb = opts.size ?? 5;
+      if (sizeGb < 1 || sizeGb > 100) {
+        throw new Error(`--size must be between 1 and 100 (got ${sizeGb}).`);
+      }
+
+      if (!isJSONMode()) info(`Creating volume ${chalk.cyan(name)}...`);
+      const created = await api.post<VolumeRecord>(
+        withScope(`/api/projects/${projectId}/volumes`, scope),
+        { name, sizeGb },
+      );
+
+      if (isJSONMode()) {
+        printJSON(created);
+        return;
+      }
+      success(`Volume ${chalk.bold(created.name)} created (${created.sizeGb} GB)`);
+      info(chalk.dim(`  ID: ${created.id}`));
+      info(chalk.dim(`  Attach it to a sandbox: lizard sandbox create --volume ${created.id}`));
+    });
+
+  vol
+    .command("rm")
+    .alias("delete")
+    .argument("<volume>", "Volume name or ID")
+    .description("Delete a volume")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .option("-y, --yes", "Skip confirmation")
+    .action(async (nameOrId: string, opts) => {
+      const { projectId, scope } = await resolveProjectScope(opts.project);
+      const volume = await resolveVolume(projectId, scope, nameOrId);
+
+      if (volume.attachedTo) {
+        throw new Error(
+          `Volume "${volume.name}" is attached to sandbox ${volume.attachedTo}. Delete the sandbox first.`,
+        );
+      }
+
+      if (!opts.yes && isTTY() && !isJSONMode()) {
+        const ok = await p.confirm({
+          message: `Delete volume ${chalk.bold(volume.name)}? This cannot be undone.`,
+        });
+        if (p.isCancel(ok) || !ok) process.exit(5);
+      }
+
+      await api.delete(withScope(`/api/projects/${projectId}/volumes/${volume.id}`, scope));
+
+      if (isJSONMode()) {
+        printJSON({ id: volume.id, status: "deleted" });
+      } else {
+        success(`Volume ${chalk.bold(volume.name)} deleted`);
+      }
+    });
+}

package/src/index.ts

@@ -79,6 +79,7 @@ import { registerRedeploy } from "./commands/redeploy.js";
 import { registerRegions } from "./commands/regions.js";
 import { registerRestart } from "./commands/restart.js";
 import { registerRun } from "./commands/run.js";
+import { registerSandbox } from "./commands/sandbox.js";
 import { registerScale } from "./commands/scale.js";
 import { registerSecrets } from "./commands/secrets.js";
 import { registerService } from "./commands/service.js";
@@ -88,6 +89,7 @@ import { registerStatus } from "./commands/status.js";
 import { registerUnlink } from "./commands/unlink.js";
 import { registerUp } from "./commands/up.js";
 import { registerUpgrade } from "./commands/upgrade.js";
+import { registerVolume } from "./commands/volume.js";
 import { registerWhoami } from "./commands/whoami.js";
 import { registerWorkspace } from "./commands/workspace.js";
 
@@ -169,6 +171,7 @@ registerRedeploy(program);
 registerRegions(program);
 registerRestart(program);
 registerRun(program);
+registerSandbox(program);
 registerScale(program);
 registerSecrets(program);
 registerService(program);
@@ -178,6 +181,7 @@ registerStatus(program);
 registerUnlink(program);
 registerUp(program);
 registerUpgrade(program);
+registerVolume(program);
 registerWhoami(program);
 registerWorkspace(program);
 

package/src/lib/api.ts

@@ -131,6 +131,30 @@ async function request<T = any>(
   return JSON.parse(text) as T;
 }
 
+/** Like api.get, but returns the raw response body instead of JSON.parse-ing
+ *  it — for endpoints that reply with `text/plain` (e.g. sandbox file reads). */
+export async function getRawText(path: string): Promise<string> {
+  const url = baseURL + path;
+  const token = _accessToken || getToken();
+  const headers: Record<string, string> = { "User-Agent": USER_AGENT };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+
+  const res = await fetch(url, { method: "GET", headers });
+  if (!res.ok) {
+    let msg = res.statusText;
+    let code = "";
+    let body: unknown = null;
+    try {
+      const j = (await res.json()) as any;
+      body = j;
+      msg = j.error || j.message || msg;
+      code = j.code || "";
+    } catch {}
+    throw new APIError(res.status, msg, code, body);
+  }
+  return res.text();
+}
+
 export const api = {
   get: <T = any>(path: string) => request<T>("GET", path),
   post: <T = any>(path: string, body?: unknown, headers?: Record<string, string>) =>
@@ -139,7 +163,7 @@ export const api = {
     request<T>("PUT", path, body),
   patch: <T = any>(path: string, body?: unknown) =>
     request<T>("PATCH", path, body),
-  delete: <T = any>(path: string) => request<T>("DELETE", path),
+  delete: <T = any>(path: string, body?: unknown) => request<T>("DELETE", path, body),
 };
 
 /** Compare two Redis-stream-style event ids (`<ms>-<seq>`). Returns true when

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 = "0.3.74";
+export const CURRENT_VERSION = "0.3.76";
 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";