@lizard-build/cli 4.0.26 → 4.0.28

package/src/commands/volume.ts

@@ -4,7 +4,7 @@ import { Command } from "commander";
 import { api, withScope, type ResourceScope } from "../lib/api.js";
 import { assertValidVolumeName, resolveVolume, type VolumeRecord } from "../lib/volume.js";
 import { resolveProjectScope } from "../lib/resolve.js";
-import { success, info, warn, isJSONMode, printJSON, table, isTTY } from "../lib/format.js";
+import { success, info, isJSONMode, printJSON, table, isTTY } from "../lib/format.js";
 
 function parseIntOption(v: string): number {
   const n = Number(v);
@@ -12,8 +12,7 @@ function parseIntOption(v: string): number {
   return n;
 }
 
-/** parseIntOption, but whole numbers only: parseInt("1.5") is 1, and a resize that
- *  silently rounds a typo down is a shrink the user never asked for. */
+/** Accept whole-number sizes without rounding or numeric suffixes. */
 function parseSizeGbOption(v: string): number {
   if (!/^\s*\d+\s*$/.test(v)) throw new Error(`--size must be a whole number of GB (got ${v}).`);
   return parseIntOption(v);
@@ -91,50 +90,6 @@ export function registerVolume(program: Command) {
       info(chalk.dim(`  Attach it to a sandbox: lizard sandbox create --volume ${created.name}`));
     });
 
-  vol
-    .command("resize")
-    .argument("<volume>", "Volume name or ID")
-    .description(
-      "Grow or shrink a volume in place. Online: no data is copied, it takes under a second, " +
-        "and an attached sandbox keeps running and sees the new size immediately. " +
-        "A shrink must leave at least 10% of the new size free.",
-    )
-    .requiredOption("--size <gb>", "New size in GB (whole number; the server enforces the project's min/max)", parseSizeGbOption)
-    .option("-p, --project <id>", "Project name, slug, or ID")
-    .action(async (nameOrId: string, opts) => {
-      const sizeGb: number = opts.size;
-      if (!Number.isInteger(sizeGb) || sizeGb < 1) {
-        throw new Error(`--size must be a whole number of GB, at least 1 (got ${opts.size}).`);
-      }
-      // No client-side upper bound: the limit is per-platform config (volume-limits),
-      // and the server reports it in its error when exceeded.
-      const { projectId, scope } = await resolveProjectScope(opts.project);
-      const volume = await resolveVolume(projectId, scope, nameOrId);
-
-      if (volume.sizeGb === sizeGb) {
-        if (isJSONMode()) {
-          printJSON(volume);
-        } else {
-          info(`Volume ${chalk.bold(volume.name)} is already ${sizeGb} GB — nothing to do.`);
-        }
-        return;
-      }
-
-      const resized = await api.patch<VolumeRecord & { sizeEnforced?: boolean }>(
-        withScope(`/api/projects/${projectId}/volumes/${encodeURIComponent(volume.name)}`, scope),
-        { sizeGb },
-      );
-
-      if (isJSONMode()) {
-        printJSON(resized);
-        return;
-      }
-      success(`Volume ${chalk.bold(resized.name)} resized: ${volume.sizeGb} GB → ${resized.sizeGb} GB`);
-      if (resized.sizeEnforced === false) {
-        warn("This region's storage does not enforce volume size; the new size is recorded but not a hard limit.");
-      }
-    });
-
   vol
     .command("rm")
     .alias("delete")

package/src/lib/api.ts

@@ -226,9 +226,8 @@ 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> {
+/** Read a response as bytes, preserving binary files and text alike. */
+export async function getRawBytes(path: string): Promise<Buffer> {
   const url = baseURL + path;
   const token = _accessToken || getToken();
   const headers: Record<string, string> = clientHeaders();
@@ -242,7 +241,11 @@ export async function getRawText(path: string): Promise<string> {
     } catch {}
     throw apiErrorFrom(res.status, res.statusText, body);
   }
-  return res.text();
+  return Buffer.from(await res.arrayBuffer());
+}
+
+export async function getRawText(path: string): Promise<string> {
+  return (await getRawBytes(path)).toString("utf8");
 }
 
 export const api = {

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.26";
+export const CURRENT_VERSION = "4.0.28";
 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/sandbox-transport.test.ts

@@ -0,0 +1,112 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import http from "node:http";
+import net from "node:net";
+import { once } from "node:events";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { Command } from "commander";
+import { WebSocketServer } from "ws";
+import { execStream, registerSandbox } from "../../src/commands/sandbox.js";
+import { getBaseURL, setBaseURL, setAccessToken } from "../../src/lib/api.js";
+import { startVncTunnel, vncTarget } from "../../src/commands/sandbox-vnc.js";
+vi.mock("../../src/lib/format.js", () => ({ isJSONMode: () => true, printJSON: vi.fn() }));
+
+const originalURL = getBaseURL();
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "sandbox-transport-"));
+let respond: (req: http.IncomingMessage, res: http.ServerResponse) => void;
+const server = http.createServer((req, res) => respond(req, res));
+let base: string;
+beforeAll(async () => {
+  server.listen(0, "127.0.0.1"); await once(server, "listening");
+  base = `http://127.0.0.1:${(server.address() as net.AddressInfo).port}`;
+  setBaseURL(base); setAccessToken("test-token");
+});
+afterAll(async () => { setBaseURL(originalURL); setAccessToken(""); await new Promise<void>(r => server.close(() => r())); fs.rmSync(tmp, { recursive: true }); });
+beforeEach(() => { respond = (_req, res) => res.end(); });
+function command(args: string[]) {
+  const program = new Command().exitOverride().configureOutput({ writeErr: () => {} });
+  registerSandbox(program);
+  return program.parseAsync(["sandbox", ...args], { from: "user" });
+}
+
+describe("sandbox exec stream", () => {
+  it("decodes split UTF-8, CRLF and a final exit without a newline", async () => {
+    const output: [string, string][] = [];
+    respond = (req, res) => {
+      expect(req.headers.authorization).toBe("Bearer test-token");
+      expect(req.headers["user-agent"]).toMatch(/^lizard-cli\//);
+      res.setHeader("Content-Type", "text/event-stream");
+      const bytes = Buffer.from('event: output\r\ndata: {"stream":"stderr",\r\ndata: "line":"привет"}\r\n\r\nevent: exit\ndata: {"exitCode":7}');
+      for (let i = 0; i < bytes.length; i++) res.write(bytes.subarray(i, i + 1));
+      res.end();
+    };
+    expect(await execStream("sb", "test", (s, l) => output.push([s, l]))).toBe(7);
+    expect(output).toEqual([["stderr", "привет"]]);
+  });
+  it.each(["", 'event: output\ndata: {"line":"partial"}\n\n'])("rejects an incomplete stream", async body => {
+    respond = (_req, res) => res.end(body);
+    await expect(execStream("sb", "test", () => {})).rejects.toMatchObject({ code: "EXEC_STREAM_INCOMPLETE" });
+  });
+  it.each([null, -1, 256, 1.5, "0"])("rejects invalid exit code %s", async exitCode => {
+    respond = (_req, res) => res.end(`event: exit\ndata: ${JSON.stringify({ exitCode })}\n\n`);
+    await expect(execStream("sb", "test", () => {})).rejects.toThrow("Invalid exec exit event");
+  });
+  it.each([401, 403, 404, 408, 504])("preserves HTTP %i as an APIError", async status => {
+    respond = (_req, res) => { res.writeHead(status); res.end(JSON.stringify({ error: "test failure", code: "TEST" })); };
+    await expect(execStream("sb", "test", () => {})).rejects.toMatchObject({ status, message: "test failure", code: "TEST" });
+  });
+  it("accepts a complete success", async () => {
+    respond = (_req, res) => res.end('event: exit\ndata: {"exitCode":0}\n\n');
+    expect(await execStream("sb", "true", () => {})).toBe(0);
+  });
+});
+
+describe("binary files", () => {
+  it.each([Buffer.from([0, 255, 128, 13, 10, 195, 40]), Buffer.alloc(0)])("round-trips arbitrary bytes", async bytes => {
+    const input = path.join(tmp, "input.bin"), output = path.join(tmp, "output.bin");
+    fs.writeFileSync(input, bytes);
+    let stored = Buffer.alloc(0);
+    respond = (req, res) => {
+      if (req.method === "POST") {
+        let body = ""; req.on("data", b => body += b); req.on("end", () => {
+          const data = JSON.parse(body); expect(data.encoding).toBe("base64");
+          expect(data.path).toBe("/workspace/binary"); stored = Buffer.from(data.content, data.encoding);
+          res.setHeader("Content-Type", "application/json"); res.end('{"status":"written"}');
+        });
+      } else { res.setHeader("Content-Type", "application/octet-stream"); res.end(stored); }
+    };
+    await command(["files", "put", "sb", input, "/workspace/binary"]);
+    await command(["files", "get", "sb", "/workspace/binary", output]);
+    expect(fs.readFileSync(output)).toEqual(bytes);
+  });
+});
+
+describe("ports", () => {
+  it.each(["3000oops", "3.5", "0", "65536", "-1"])("rejects %s before a request", async port => {
+    let requests = 0; respond = (_req, res) => { requests++; res.end('{}'); };
+    await expect(command(["vnc", "sb", "--port", port])).rejects.toThrow(/Port must be/);
+    expect(requests).toBe(0);
+  });
+});
+
+describe("private VNC tunnel", () => {
+  it.each(["control", "view"])("forwards both tokens for %s sessions", async token => {
+    const wss = new WebSocketServer({ port: 0, host: "127.0.0.1", verifyClient: info => info.req.headers["x-lizard-access-token"] === "private" });
+    await once(wss, "listening");
+    const port = (wss.address() as net.AddressInfo).port;
+    const target = vncTarget(`http://127.0.0.1:${port}/stream.html?token=${token}&password=pw&lizard_token=private`);
+    let upstreamPath = "";
+    wss.on("connection", (ws, req) => { upstreamPath = req.url!; ws.send(Buffer.from("RFB 003.008\n")); });
+    const tunnel = await startVncTunnel(target.wsUrl, 19590, {}, target.headers);
+    const sock = net.connect(tunnel.port, "127.0.0.1");
+    try {
+      const [bytes] = await once(sock, "data");
+      expect(bytes.toString()).toBe("RFB 003.008\n");
+      expect(upstreamPath).toBe(`/websockify?token=${token}`);
+    } finally { sock.destroy(); tunnel.close(); for (const ws of wss.clients) ws.terminate(); await new Promise<void>(r => wss.close(() => r())); }
+  });
+  it("supports older noVNC URLs", () => {
+    expect(vncTarget("https://desktop/vnc.html?path=websockify%3Ftoken%3Da%252Bb&password=pw")).toEqual({ wsUrl: "wss://desktop/websockify?token=a%2Bb", password: "pw", headers: {} });
+  });
+});

package/test/unit/sandbox.test.ts

@@ -47,7 +47,7 @@ describe("sandbox create timeout", () => {
 
 
 describe("unsupported sandbox commands", () => {
-  it.each(["fork", "snapshot-fork"])(
+  it.each(["fork", "snapshot-fork", "logs"])(
     "rejects %s without making an API request", async (name) => {
       vi.clearAllMocks();
       const program = new Command().exitOverride().configureOutput({ writeErr: () => {} });

package/test/unit/volume.test.ts

@@ -1,92 +1,20 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { expect, it, vi } from "vitest";
 import { Command } from "commander";
 import { registerVolume } from "../../src/commands/volume.js";
-import { api, APIError } from "../../src/lib/api.js";
-import { printJSON } from "../../src/lib/format.js";
+import { api } from "../../src/lib/api.js";
 
 vi.mock("../../src/lib/api.js", async (importOriginal) => {
   const actual = await importOriginal<typeof import("../../src/lib/api.js")>();
   return { ...actual, api: { get: vi.fn(), patch: vi.fn() } };
 });
-vi.mock("../../src/lib/resolve.js", () => ({
-  resolveProjectScope: vi.fn().mockResolvedValue({ projectId: "project-test", scope: { workspaceId: "workspace-test" } }),
-}));
-vi.mock("../../src/lib/format.js", () => ({
-  isJSONMode: () => true,
-  printJSON: vi.fn(),
-  success: vi.fn(),
-  info: vi.fn(),
-  warn: vi.fn(),
-  table: vi.fn(),
-  isTTY: () => false,
-}));
 
-const VOLUME = { id: "Vx1234567890abcdefghi", name: "build-cache", sizeGb: 5, status: "ready" };
-
-function resize(args: string[]) {
-  const program = new Command().exitOverride();
+it("rejects the removed resize command without making API requests", async () => {
+  const program = new Command().exitOverride().configureOutput({ writeErr: () => {} });
   registerVolume(program);
-  return program.parseAsync(["volume", "resize", ...args], { from: "user" });
-}
-
-describe("volume resize", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.mocked(api.get).mockResolvedValue(VOLUME);
-    vi.mocked(api.patch).mockResolvedValue({ ...VOLUME, sizeGb: 10, sizeEnforced: true });
-  });
-
-  it("PATCHes the volume by name with the new size and prints the result", async () => {
-    await resize(["build-cache", "--size", "10"]);
-    expect(api.patch).toHaveBeenCalledWith(
-      "/api/projects/project-test/volumes/build-cache?workspaceId=workspace-test",
-      { sizeGb: 10 },
-    );
-    expect(printJSON).toHaveBeenCalledWith(expect.objectContaining({ sizeGb: 10, sizeEnforced: true }));
-  });
-
-  it("resolves a volume given by ID and addresses the PATCH by its name", async () => {
-    await resize([VOLUME.id, "--size", "10"]);
-    expect(api.get).toHaveBeenCalledWith(
-      `/api/projects/project-test/volumes/${VOLUME.id}?workspaceId=workspace-test`,
-    );
-    expect(api.patch).toHaveBeenCalledWith(
-      "/api/projects/project-test/volumes/build-cache?workspaceId=workspace-test",
-      { sizeGb: 10 },
-    );
-  });
-
-  it("allows a shrink", async () => {
-    vi.mocked(api.patch).mockResolvedValue({ ...VOLUME, sizeGb: 2 });
-    await resize(["build-cache", "--size", "2"]);
-    expect(api.patch).toHaveBeenCalledWith(expect.any(String), { sizeGb: 2 });
-  });
-
-  it("makes no request when the size is unchanged", async () => {
-    await resize(["build-cache", "--size", "5"]);
-    expect(api.patch).not.toHaveBeenCalled();
-    expect(printJSON).toHaveBeenCalledWith(VOLUME);
-  });
-
-  it("surfaces the server's error message", async () => {
-    vi.mocked(api.patch).mockRejectedValue(
-      new APIError(409, "Volume has 4.8 GB used; shrinking to 5 GB would leave less than 10% free", "volume_too_full_to_shrink"),
-    );
-    await expect(resize(["build-cache", "--size", "3"])).rejects.toMatchObject({
-      status: 409,
-      code: "volume_too_full_to_shrink",
-      message: expect.stringMatching(/less than 10% free/),
-    });
-  });
-
-  it.each(["0", "-1", "1.5", "ten"])("rejects --size %s before making a request", async (value) => {
-    await expect(resize(["build-cache", "--size", value])).rejects.toThrow(/--size|Invalid number/);
-    expect(api.get).not.toHaveBeenCalled();
-    expect(api.patch).not.toHaveBeenCalled();
-  });
-
-  it("requires --size", async () => {
-    await expect(resize(["build-cache"])).rejects.toThrow();
-    expect(api.patch).not.toHaveBeenCalled();
-  });
+  const volume = program.commands.find(command => command.name() === "volume")!;
+  expect(volume.commands.flatMap(command => [command.name(), ...command.aliases()])).not.toContain("resize");
+  await expect(program.parseAsync(["volume", "resize", "build-cache", "--size", "10"], { from: "user" }))
+    .rejects.toMatchObject({ code: "commander.unknownCommand" });
+  expect(api.get).not.toHaveBeenCalled();
+  expect(api.patch).not.toHaveBeenCalled();
 });