@lizard-build/cli 0.1.0 → 0.3.30

package/src/commands/redeploy.ts

@@ -1,20 +1,60 @@
 import chalk from "chalk";
 import ora from "ora";
+import * as p from "@clack/prompts";
 import { Command } from "commander";
-import { api, streamSSE } from "../lib/api.js";
-import { success, info, error, isJSONMode, printJSON } from "../lib/format.js";
+import { api, streamSSE, withScope } from "../lib/api.js";
+import { resolveProjectScope, resolveService } from "../lib/resolve.js";
+import { success, info, error, isJSONMode, printJSON, isTTY } from "../lib/format.js";
 
 export function registerRedeploy(program: Command) {
   program
     .command("redeploy")
-    .argument("<id>", "Service ID to redeploy")
-    .description("Redeploy a service from latest build with current secrets")
+    .argument("[nameOrId]", "App name or ID to redeploy")
+    .description("Trigger a fresh build (latest commit / last upload) with current vars")
     .option("--detach", "Run in background")
-    .action(async (id: string, opts) => {
-      const spinner = ora("Starting redeploy...").start();
+    .option("-s, --service <name>", "App name or ID (alias for positional)")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .action(async (nameOrId: string | undefined, opts) => {
+      const ref = nameOrId || opts.service;
+      let id: string | undefined;
+      if (ref) {
+        const { projectId } = await resolveProjectScope(opts.project);
+        const resolved = await resolveService(projectId, ref);
+        if (resolved.kind !== "app") {
+          throw new Error(`"${ref}" is not an app`);
+        }
+        id = resolved.id;
+      } else {
+        if (!isTTY()) throw new Error("Provide an app name or ID, or run interactively");
 
-      await api.post(`/api/apps/${id}/redeploy`);
+        const { projectId, scope } = await resolveProjectScope(opts.project);
+        const data = await api.get<{ apps: any[] }>(withScope(`/api/projects/${projectId}/services`, scope));
+        const apps = data.apps || [];
+
+        if (apps.length === 0) {
+          throw new Error(
+            "No apps in project. Create one with `lizard up` or `lizard add`.",
+          );
+        }
 
+        if (apps.length === 1) {
+          id = apps[0].id;
+        } else {
+          const selected = await p.select({
+            message: "Select app to redeploy",
+            options: apps.map((a: any) => ({
+              value: a.id,
+              label: a.name || a.id,
+              hint: a.status,
+            })),
+          });
+          if (p.isCancel(selected)) process.exit(5);
+          id = selected as string;
+        }
+      }
+
+      const spinner = ora("Starting redeploy...").start();
+      await api.post(`/api/apps/${id}/redeploy`);
       spinner.stop();
 
       if (opts.detach || isJSONMode()) {
@@ -22,12 +62,11 @@ export function registerRedeploy(program: Command) {
           printJSON({ id, status: "deploying" });
         } else {
           success("Redeploy started");
-          info(chalk.dim(`  Check status: lizard deploy-status ${id}`));
+          info(chalk.dim(`  Check status: lizard deploy status ${id}`));
         }
         return;
       }
 
-      // Stream build logs if not detached
       info("Redeploying...");
 
       // Poll for build
@@ -56,7 +95,9 @@ export function registerRedeploy(program: Command) {
           }
           try {
             const parsed = JSON.parse(data);
-            process.stdout.write((parsed.line || data) + "\n");
+            const line =
+              typeof parsed === "string" ? parsed : (parsed.line ?? data);
+            process.stdout.write(line + "\n");
           } catch {
             process.stdout.write(data + "\n");
           }

package/src/commands/regions.ts

@@ -10,12 +10,8 @@ interface Region {
 }
 
 export function registerRegions(program: Command) {
-  const region = program
-    .command("region")
-    .description("Region management");
-
-  region
-    .command("list")
+  program
+    .command("regions")
     .description("List available regions")
     .action(async () => {
       const regions = await api.get<Region[]>("/api/regions");

package/src/commands/restart.ts

@@ -1,24 +1,98 @@
 import chalk from "chalk";
 import ora from "ora";
+import * as p from "@clack/prompts";
 import { Command } from "commander";
-import { api } from "../lib/api.js";
-import { success, isJSONMode, printJSON } from "../lib/format.js";
+import { api, withScope } from "../lib/api.js";
+import { resolveProjectScope, resolveService } from "../lib/resolve.js";
+import { success, info, error, isJSONMode, printJSON, isTTY } from "../lib/format.js";
 
 export function registerRestart(program: Command) {
   program
     .command("restart")
-    .argument("<id>", "Service ID to restart")
-    .description("Restart a service")
-    .action(async (id: string) => {
-      const spinner = ora("Restarting...").start();
+    .argument("[nameOrId]", "App name or ID to restart")
+    .description("Restart an app")
+    .option("--detach", "Run in background")
+    .option("-s, --service <name>", "App name or ID (alias for positional)")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .action(async (nameOrId: string | undefined, opts) => {
+      const ref = nameOrId || opts.service;
+      let id: string | undefined;
+      if (ref) {
+        const { projectId } = await resolveProjectScope(opts.project);
+        const resolved = await resolveService(projectId, ref);
+        if (resolved.kind !== "app") {
+          throw new Error(`"${ref}" is not an app`);
+        }
+        id = resolved.id;
+      } else {
+        if (!isTTY()) throw new Error("Provide an app name or ID, or run interactively");
+
+        const { projectId, scope } = await resolveProjectScope(opts.project);
+        const data = await api.get<{ apps: any[] }>(withScope(`/api/projects/${projectId}/services`, scope));
+        const apps = data.apps || [];
+
+        if (apps.length === 0) throw new Error("No apps in project");
 
-      await api.post(`/api/apps/${id}/restart`);
+        if (apps.length === 1) {
+          id = apps[0].id;
+        } else {
+          const selected = await p.select({
+            message: "Select app to restart",
+            options: apps.map((a: any) => ({
+              value: a.id,
+              label: a.name || a.id,
+              hint: a.status,
+            })),
+          });
+          if (p.isCancel(selected)) process.exit(5);
+          id = selected as string;
+        }
+      }
 
+      const spinner = ora("Starting restart...").start();
+      await api.post(`/api/apps/${id}/restart`, undefined, { "X-Deploy-Source": "cli" });
       spinner.stop();
-      if (isJSONMode()) {
-        printJSON({ id, status: "restarting" });
+
+      if (opts.detach || isJSONMode()) {
+        if (isJSONMode()) {
+          printJSON({ id, status: "restarting" });
+        } else {
+          success("Restart started");
+          info(chalk.dim(`  Check status: lizard ps ${id}`));
+        }
+        return;
+      }
+
+      const waitSpinner = ora("Restarting...").start();
+
+      let finalStatus: string | undefined;
+      let domain: string | undefined;
+      for (let i = 0; i < 60; i++) {
+        await new Promise((r) => setTimeout(r, 2000));
+        try {
+          const app = await api.get<{ status: string; domain?: string }>(
+            `/api/apps/${id}`,
+          );
+          domain = app.domain;
+          if (app.status === "running") {
+            finalStatus = "running";
+            break;
+          }
+          if (app.status === "failed" || app.status === "error") {
+            finalStatus = app.status;
+            break;
+          }
+        } catch {}
+      }
+
+      waitSpinner.stop();
+
+      if (finalStatus === "running") {
+        success(`Restarted! ${domain ? chalk.cyan(`https://${domain}`) : ""}`);
+      } else if (finalStatus) {
+        error("Restart failed");
       } else {
-        success(`Service ${id} restarting`);
+        info(chalk.dim("Still restarting — check status with: lizard ps " + id));
       }
     });
 }

package/src/commands/run.ts

@@ -1,43 +1,87 @@
-import { execSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import { Command } from "commander";
-import { api } from "../lib/api.js";
-import { resolveProjectId } from "../lib/config.js";
+import { api, withScope } from "../lib/api.js";
+import { getProjectLink } from "../lib/config.js";
+import { resolveProjectScope, resolveService } from "../lib/resolve.js";
 
 interface Secret {
   key: string;
   value: string;
 }
 
+/**
+ * `lizard run <command...>` — run a local command with platform secrets in
+ * the environment. Project-scope secrets are loaded first, then the linked
+ * (or `-s <service>`) service overrides on key collisions, mirroring the
+ * order the platform applies them on the server.
+ *
+ * Pass `-s <service>` to switch service without touching the link.
+ * Pass `--no-service` to load only project-scope secrets.
+ */
 export function registerRun(program: Command) {
   program
     .command("run")
-    .argument("<command...>", "Command to run with project env vars")
-    .description("Run a command with project secrets as env vars")
+    .argument("<command...>", "Command to run with platform env vars")
+    .description("Run a command with project + service secrets injected")
+    .option("-s, --service <name>", "Service to pull secrets from (defaults to linked)")
+    .option("--no-service", "Skip service-scope secrets, project only")
+    .option("-p, --project <id>", "Project ID (defaults to linked)")
     .allowUnknownOption()
-    .action(async (args: string[]) => {
-      const projectId = resolveProjectId(program.opts().project);
+    .action(async (args: string[], opts: any) => {
+      const { projectId, scope } = await resolveProjectScope(opts.project);
 
-      // Fetch secrets
-      const secrets = await api.get<Secret[]>(
-        `/api/projects/${projectId}/secrets`,
+      const env: Record<string, string> = { ...(process.env as Record<string, string>) };
+
+      // 1. project secrets
+      const projectSecrets = await api.get<Secret[]>(
+        withScope(`/api/projects/${projectId}/secrets`, scope),
       );
+      for (const s of projectSecrets) env[s.key] = s.value;
+
+      // 2. service / addon secrets (override project)
+      if (opts.service !== false) {
+        const serviceRef =
+          typeof opts.service === "string" ? opts.service : getProjectLink()?.serviceId;
 
-      // Build env
-      const env: Record<string, string> = { ...process.env as Record<string, string> };
-      for (const s of secrets) {
-        env[s.key] = s.value;
+        if (serviceRef) {
+          const svc = await resolveService(projectId, serviceRef);
+          const path =
+            svc.kind === "app"
+              ? withScope(`/api/apps/${svc.id}/secrets`, scope)
+              : withScope(`/api/projects/${projectId}/addons/${svc.id}/secrets`, scope);
+          const serviceSecrets = await api.get<Secret[]>(path).catch((err: any) => {
+            if (err?.status === 404) {
+              if (svc.kind === "addon") {
+                console.warn(
+                  `warning: addon "${svc.name}" exposes no secrets endpoint yet ` +
+                    `(needs GET ${path}). Falling back to project-only env.`,
+                );
+              }
+              return [] as Secret[];
+            }
+            throw err;
+          });
+          for (const s of serviceSecrets) env[s.key] = s.value;
+        }
       }
 
-      // Run command
-      const cmd = args.join(" ");
-      try {
-        execSync(cmd, {
-          env,
-          stdio: "inherit",
-          shell: process.env.SHELL || "/bin/sh",
-        });
-      } catch (err: any) {
-        process.exit(err.status || 1);
+      // argv-style spawn — no shell, so quoting / pipes / `;` in user-supplied
+      // args are passed verbatim to the target program instead of being parsed
+      // by /bin/sh. If the user wants a shell, they can invoke one explicitly:
+      // `lizard run sh -c 'foo | bar'`.
+      const result = spawnSync(args[0], args.slice(1), {
+        env,
+        stdio: "inherit",
+      });
+      if (result.error) {
+        const code = (result.error as NodeJS.ErrnoException).code;
+        if (code === "ENOENT") {
+          console.error(`lizard run: command not found: ${args[0]}`);
+          process.exit(127);
+        }
+        console.error(`lizard run: ${result.error.message}`);
+        process.exit(1);
       }
+      process.exit(result.status ?? 1);
     });
 }

package/src/commands/scale.ts

@@ -0,0 +1,216 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { api, withScope, type ResourceScope } from "../lib/api.js";
+import { getActiveServiceWithKind, resolveProjectScope } from "../lib/resolve.js";
+import { success, isJSONMode, printJSON } from "../lib/format.js";
+
+// Discrete tiers the dashboard slider exposes (CPU_OPTIONS / MEMORY_OPTIONS in
+// lizard-client). The API and node-agent accept other values, but anything off
+// the tier list lands in DB as a string the UI slider can't snap to — the row
+// shows raw "3000m" and the slider falls to index 0. Mirror the UI tiers so the
+// CLI and dashboard stay in lockstep.
+const ALLOWED_CPU_CORES = [1, 2, 4] as const;
+const ALLOWED_MEMORY_MB = [512, 1024, 2048, 4096] as const;
+// Storage tiers match the addon size selector on the dashboard. Addon-only —
+// apps don't have a resizable data volume on this path.
+const ALLOWED_STORAGE_MB = [512, 1024, 2048, 4096, 8192, 16384] as const;
+
+/**
+ * `lizard scale` — service scaling.
+ *   --replicas <n>     change replica count (1-10) — apps only
+ *   --cpu <cores>      CPU cap; allowed: 1, 2, 4
+ *   --memory <mb>      memory cap; allowed: 512, 1024, 2048, 4096
+ *   --storage <mb>     data volume size; addons only, grow-only;
+ *                      allowed: 512, 1024, 2048, 4096, 8192, 16384
+ */
+export function registerScale(program: Command) {
+  program
+    .command("scale")
+    .description("Scale a service (replicas / CPU / memory / storage)")
+    .argument("[service]", "Service name or ID (defaults to linked)")
+    .option("-s, --service <name>", "Service name or ID")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .option("--replicas <n>", "Number of replicas (1-10), apps only", parseIntOption)
+    .option("--cpu <cores>", `CPU cap, whole cores (allowed: ${ALLOWED_CPU_CORES.join(", ")})`, parseIntOption)
+    .option("--memory <mb>", `Memory cap in MB (allowed: ${ALLOWED_MEMORY_MB.join(", ")})`, parseIntOption)
+    .option("--storage <mb>", `Data volume size in MB, addons only, grow-only (allowed: ${ALLOWED_STORAGE_MB.join(", ")})`, parseIntOption)
+    .action(async (serviceArg: string | undefined, opts, _cmd) => {
+      const { projectId, scope } = await resolveProjectScope(opts.project);
+      const service = await getActiveServiceWithKind(serviceArg || opts.service, projectId);
+
+      if (
+        opts.replicas === undefined &&
+        opts.cpu === undefined &&
+        opts.memory === undefined &&
+        opts.storage === undefined
+      ) {
+        throw new Error("Pass at least one of: --replicas, --cpu, --memory, --storage.");
+      }
+
+      if (opts.replicas !== undefined && (opts.replicas < 1 || opts.replicas > 10)) {
+        throw new Error(`--replicas must be between 1 and 10 (got ${opts.replicas}).`);
+      }
+      if (opts.cpu !== undefined && !(ALLOWED_CPU_CORES as readonly number[]).includes(opts.cpu)) {
+        throw new Error(
+          `--cpu ${opts.cpu} not supported. Allowed: ${ALLOWED_CPU_CORES.join(", ")} cores.`,
+        );
+      }
+      if (opts.memory !== undefined && !(ALLOWED_MEMORY_MB as readonly number[]).includes(opts.memory)) {
+        throw new Error(
+          `--memory ${opts.memory} not supported. Allowed: ${ALLOWED_MEMORY_MB.join(", ")} MB.`,
+        );
+      }
+      if (opts.storage !== undefined && !(ALLOWED_STORAGE_MB as readonly number[]).includes(opts.storage)) {
+        throw new Error(
+          `--storage ${opts.storage} not supported. Allowed: ${ALLOWED_STORAGE_MB.join(", ")} MB.`,
+        );
+      }
+
+      if (service.kind === "addon") {
+        if (opts.replicas !== undefined) {
+          throw new Error("Addons run as a single VM and don't support --replicas.");
+        }
+        return scaleAddon(projectId, scope, service, opts.cpu, opts.memory, opts.storage);
+      }
+
+      if (opts.storage !== undefined) {
+        throw new Error("--storage is only supported for addons (postgres, redis, mongo, mysql).");
+      }
+
+      // App path — replicas go to /scale; cpu/memory go through config:apply
+      // (PATCH /api/apps/:id was retired with 410 in favour of config:apply).
+      const calls: Promise<unknown>[] = [];
+
+      if (opts.replicas !== undefined) {
+        calls.push(api.patch(`/api/apps/${service.id}/scale`, { replicas: opts.replicas }));
+      }
+
+      let configApplyResult: ConfigApplyResult | undefined;
+      if (opts.cpu !== undefined || opts.memory !== undefined) {
+        const serviceEntry: Record<string, unknown> = { id: service.id, name: service.name };
+        if (opts.cpu !== undefined) serviceEntry.cpuLimit = `${opts.cpu * 1000}m`;
+        if (opts.memory !== undefined) serviceEntry.memoryLimit = mbToK8s(opts.memory);
+        calls.push(
+          api.post<ConfigApplyResult>(
+            withScope(`/api/projects/${projectId}/config:apply`, scope),
+            { services: [serviceEntry] },
+          ).then((r) => { configApplyResult = r; return r; }),
+        );
+      }
+
+      await Promise.all(calls);
+      if (configApplyResult) warnSideEffects(configApplyResult);
+
+      if (isJSONMode()) {
+        printJSON({
+          id: service.id,
+          ...(opts.replicas !== undefined ? { replicas: opts.replicas } : {}),
+          ...(opts.cpu !== undefined ? { cpuLimit: `${opts.cpu * 1000}m` } : {}),
+          ...(opts.memory !== undefined ? { memoryLimit: mbToK8s(opts.memory) } : {}),
+        });
+      } else {
+        success(`Scaled ${chalk.bold(service.name)}`);
+      }
+    });
+}
+
+interface ConfigApplyResult {
+  revision?: number;
+  sideEffectFailures?: { op: string; error: string }[];
+}
+
+interface AddonRecord {
+  id: string;
+  status?: string;
+  config?: {
+    vcpu?: number;
+    vcpuLimit?: number;
+    memoryMb?: number;
+    memoryMbLimit?: number;
+    storageSize?: string;
+  };
+}
+
+/** Warn the user about any deferred side-effect failures from a config:apply response. */
+function warnSideEffects(result: ConfigApplyResult): void {
+  if (!result.sideEffectFailures?.length) return;
+  for (const f of result.sideEffectFailures) {
+    process.stderr.write(chalk.yellow(`⚠ Side effect failed (${f.op}): ${f.error}\n`));
+  }
+}
+
+async function scaleAddon(
+  projectId: string,
+  scope: ResourceScope,
+  service: { id: string; name: string },
+  cpu: number | undefined,
+  memory: number | undefined,
+  storageMb: number | undefined,
+): Promise<void> {
+  // Only pre-fetch addon list when --storage is passed — needed for the
+  // grow-only check. cpu/memory go through config:apply which accepts partial
+  // deltas, so no pre-fetch is needed for those axes.
+  if (storageMb !== undefined) {
+    const addons = await api.get<AddonRecord[]>(
+      withScope(`/api/projects/${projectId}/addons`, scope),
+    );
+    const current = addons.find((a) => a.id === service.id);
+    if (!current) throw new Error(`Addon "${service.name}" not found in project.`);
+    const currentMb = current.config?.storageSize ? parseStorageToMb(current.config.storageSize) : 0;
+    if (currentMb > 0 && storageMb <= currentMb) {
+      throw new Error(
+        `--storage ${storageMb} MB is not larger than current ${currentMb} MB. Storage is grow-only.`,
+      );
+    }
+  }
+
+  // Build the config:apply addon patch. All three axes are optional and can
+  // be combined freely — the server writes only the fields present.
+  const addonPatch: Record<string, unknown> = { id: service.id };
+  if (cpu !== undefined || memory !== undefined) {
+    const limits: Record<string, number> = {};
+    if (cpu !== undefined) limits.vcpu = cpu;
+    if (memory !== undefined) limits.memoryMb = memory;
+    addonPatch.limits = limits;
+  }
+  if (storageMb !== undefined) {
+    addonPatch.storageSize = mbToK8s(storageMb);
+  }
+
+  const result = await api.post<ConfigApplyResult>(
+    withScope(`/api/projects/${projectId}/config:apply`, scope),
+    { addons: [addonPatch] },
+  );
+  warnSideEffects(result);
+
+  if (isJSONMode()) {
+    printJSON({
+      id: service.id,
+      kind: "addon",
+      ...(cpu !== undefined ? { vcpu: cpu } : {}),
+      ...(memory !== undefined ? { memoryMb: memory } : {}),
+      ...(storageMb !== undefined ? { storageSize: mbToK8s(storageMb) } : {}),
+    });
+  } else {
+    success(`Scaled ${chalk.bold(service.name)} (addon)`);
+  }
+}
+
+/** 1024 → "1Gi", 512 → "512Mi". Matches the dashboard size tiers (memory + addon storage). */
+function mbToK8s(mb: number): string {
+  return mb % 1024 === 0 ? `${mb / 1024}Gi` : `${mb}Mi`;
+}
+
+/** Inverse of mbToK8s for grow-only comparison; supports Gi/Mi/Ti. */
+function parseStorageToMb(size: string): number {
+  if (size.endsWith("Gi")) return parseFloat(size) * 1024;
+  if (size.endsWith("Mi")) return parseFloat(size);
+  if (size.endsWith("Ti")) return parseFloat(size) * 1024 * 1024;
+  return 0;
+}
+
+function parseIntOption(v: string): number {
+  const n = parseInt(v, 10);
+  if (Number.isNaN(n)) throw new Error(`Invalid number: ${v}`);
+  return n;
+}