@lizard-build/cli 0.1.0

package/src/commands/add.ts

@@ -0,0 +1,100 @@
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { resolveProjectId } from "../lib/config.js";
+import {
+  success,
+  info,
+  isJSONMode,
+  printJSON,
+  isTTY,
+  table,
+} from "../lib/format.js";
+
+const CATALOG = [
+  { name: "postgres", label: "PostgreSQL", description: "Relational database" },
+  { name: "redis", label: "Redis", description: "In-memory key-value store" },
+  { name: "mysql", label: "MySQL", description: "Relational database" },
+  { name: "mongodb", label: "MongoDB", description: "Document database" },
+] as const;
+
+export function registerAdd(program: Command) {
+  program
+    .command("add")
+    .argument("[name]", "Service name from catalog (postgres, redis, mysql, mongodb)")
+    .description("Add a service to the project")
+    .option("--list", "Show available services")
+    .option("--region <region>", "Region for the service")
+    .action(async (name: string | undefined, opts) => {
+      // Show catalog
+      if (opts.list || (!name && !isTTY())) {
+        if (isJSONMode()) {
+          printJSON(CATALOG);
+        } else {
+          table(
+            ["Name", "Description"],
+            CATALOG.map((c) => [c.name, c.description]),
+          );
+        }
+        return;
+      }
+
+      // Interactive selection
+      if (!name) {
+        const selected = await p.select({
+          message: "Select service to add",
+          options: CATALOG.map((c) => ({
+            value: c.name,
+            label: c.label,
+            hint: c.description,
+          })),
+        });
+        if (p.isCancel(selected)) process.exit(5);
+        name = selected as string;
+      }
+
+      // Validate name is in catalog
+      const catalogEntry = CATALOG.find((c) => c.name === name);
+      if (!catalogEntry) {
+        throw new Error(
+          `Unknown service "${name}". Available: ${CATALOG.map((c) => c.name).join(", ")}`,
+        );
+      }
+
+      const projectId = resolveProjectId(program.opts().project);
+      const region = opts.region || program.opts().region;
+
+      info(`Adding ${chalk.cyan(catalogEntry.label)}...`);
+
+      const addon = await api.post<{
+        id: string;
+        name: string;
+        addonType: string;
+        status: string;
+        hostname?: string;
+        connectionString?: string;
+        envVars?: Record<string, string>;
+      }>(`/api/projects/${projectId}/addons`, {
+        addonType: name,
+        region,
+      });
+
+      if (isJSONMode()) {
+        printJSON(addon);
+        return;
+      }
+
+      success(`${catalogEntry.label} added`);
+
+      if (addon.hostname) {
+        info(`  Host: ${chalk.cyan(addon.hostname)}`);
+      }
+      if (addon.envVars) {
+        info(chalk.dim("\n  Environment variables added to project:"));
+        for (const [key, val] of Object.entries(addon.envVars)) {
+          info(`  ${chalk.bold(key)}=${chalk.dim(val)}`);
+        }
+      }
+    });
+}

package/src/commands/connect.ts

@@ -0,0 +1,145 @@
+import { execSync } from "node:child_process";
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { resolveProjectId } from "../lib/config.js";
+import { info, isJSONMode, printJSON, isTTY } from "../lib/format.js";
+
+interface Addon {
+  id: string;
+  name: string;
+  addonType: string;
+  status: string;
+  hostname?: string;
+  config?: string;
+}
+
+const CLIENT_COMMANDS: Record<string, string> = {
+  postgres: "psql",
+  mysql: "mysql",
+  mongodb: "mongosh",
+  redis: "redis-cli",
+};
+
+export function registerConnect(program: Command) {
+  program
+    .command("connect")
+    .argument("[service]", "Service type or ID (postgres, redis, etc.)")
+    .description("Connect to a managed service")
+    .option("--url", "Print connection string without connecting")
+    .action(async (service: string | undefined, opts) => {
+      const projectId = resolveProjectId(program.opts().project);
+
+      // Get addons
+      const addons = await api.get<Addon[]>(
+        `/api/projects/${projectId}/addons`,
+      );
+
+      if (addons.length === 0) {
+        throw new Error("No managed services in this project. Use `lizard add`.");
+      }
+
+      let addon: Addon | undefined;
+
+      if (service) {
+        // Match by type or ID
+        addon =
+          addons.find((a) => a.addonType === service) ||
+          addons.find((a) => a.id === service) ||
+          addons.find((a) => a.name === service);
+      } else if (addons.length === 1) {
+        addon = addons[0];
+      } else {
+        if (!isTTY()) {
+          throw new Error(
+            "Multiple services found. Specify one: " +
+              addons.map((a) => a.addonType || a.name).join(", "),
+          );
+        }
+        const selected = await p.select({
+          message: "Select service to connect to",
+          options: addons.map((a) => ({
+            value: a.id,
+            label: a.name || a.addonType,
+            hint: a.addonType,
+          })),
+        });
+        if (p.isCancel(selected)) process.exit(5);
+        addon = addons.find((a) => a.id === selected);
+      }
+
+      if (!addon) {
+        throw new Error(`Service "${service}" not found`);
+      }
+
+      if (addon.status !== "running") {
+        throw new Error(`Service is ${addon.status}, not running`);
+      }
+
+      // Build connection string from secrets
+      const secrets = await api.get<Array<{ key: string; value: string }>>(
+        `/api/projects/${projectId}/secrets`,
+      );
+
+      const connString = findConnectionString(addon.addonType, secrets);
+
+      if (opts.url || isJSONMode()) {
+        if (isJSONMode()) {
+          printJSON({ type: addon.addonType, connectionString: connString });
+        } else {
+          console.log(connString || "Connection string not found in secrets");
+        }
+        return;
+      }
+
+      if (!connString) {
+        throw new Error(
+          "Connection string not found in project secrets. Check `lizard secret list --show`.",
+        );
+      }
+
+      // Connect using native client
+      const clientCmd = CLIENT_COMMANDS[addon.addonType];
+      if (!clientCmd) {
+        info(`Connection string: ${connString}`);
+        return;
+      }
+
+      info(chalk.dim(`Connecting via ${clientCmd}...\n`));
+
+      try {
+        if (addon.addonType === "postgres") {
+          execSync(`${clientCmd} "${connString}"`, { stdio: "inherit" });
+        } else if (addon.addonType === "redis") {
+          // redis-cli -u redis://...
+          execSync(`${clientCmd} -u "${connString}"`, { stdio: "inherit" });
+        } else if (addon.addonType === "mysql") {
+          execSync(`${clientCmd} "${connString}"`, { stdio: "inherit" });
+        } else if (addon.addonType === "mongodb") {
+          execSync(`${clientCmd} "${connString}"`, { stdio: "inherit" });
+        }
+      } catch (err: any) {
+        process.exit(err.status || 1);
+      }
+    });
+}
+
+function findConnectionString(
+  type: string,
+  secrets: Array<{ key: string; value: string }>,
+): string | null {
+  const envKeys: Record<string, string[]> = {
+    postgres: ["DATABASE_URL", "POSTGRES_URL", "PG_URL"],
+    mysql: ["MYSQL_URL", "DATABASE_URL"],
+    mongodb: ["MONGODB_URL", "MONGO_URL"],
+    redis: ["REDIS_URL"],
+  };
+
+  const keys = envKeys[type] || [];
+  for (const key of keys) {
+    const s = secrets.find((s) => s.key === key);
+    if (s) return s.value;
+  }
+  return null;
+}

package/src/commands/context.ts

@@ -0,0 +1,93 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { resolveProjectId, findProjectConfig } from "../lib/config.js";
+import { isJSONMode, printJSON, statusColor, table } from "../lib/format.js";
+
+export function registerContext(program: Command) {
+  program
+    .command("context")
+    .description("Show full project context (optimized for AI agents)")
+    .action(async () => {
+      const projectId = resolveProjectId(program.opts().project);
+      const config = findProjectConfig();
+
+      const [project, services, secrets] = await Promise.all([
+        api.get<{ id: string; name: string; slug: string }>(
+          `/api/projects/${projectId}`,
+        ),
+        api.get<{ apps: any[]; addons: any[] }>(
+          `/api/projects/${projectId}/services`,
+        ),
+        api.get<Array<{ key: string; value: string }>>(
+          `/api/projects/${projectId}/secrets`,
+        ).catch(() => []),
+      ]);
+
+      const context = {
+        project: {
+          id: project.id,
+          name: project.name,
+          slug: project.slug,
+        },
+        environment: config?.environment || "production",
+        apps: (services.apps || []).map((a: any) => ({
+          id: a.id,
+          name: a.name,
+          status: a.status,
+          domain: a.domain,
+          repo: a.repo,
+          branch: a.branch,
+          cpuLimit: a.cpuLimit,
+          memoryLimit: a.memoryLimit,
+        })),
+        addons: (services.addons || []).map((a: any) => ({
+          id: a.id,
+          name: a.name,
+          type: a.addonType,
+          status: a.status,
+          hostname: a.hostname,
+        })),
+        secrets: secrets.map((s) => s.key), // names only, not values
+      };
+
+      // Always JSON for pipe, since this is designed for AI agents
+      if (isJSONMode() || !process.stdout.isTTY) {
+        printJSON(context);
+        return;
+      }
+
+      // Human-readable
+      console.log(chalk.bold(context.project.name) + chalk.dim(` (${context.project.id})`));
+      console.log(chalk.dim(`Environment: ${context.environment}`));
+      console.log();
+
+      if (context.apps.length > 0) {
+        console.log(chalk.bold("Apps:"));
+        table(
+          ["Name", "Status", "Domain"],
+          context.apps.map((a) => [
+            a.name,
+            statusColor(a.status),
+            a.domain ? `https://${a.domain}` : "—",
+          ]),
+        );
+        console.log();
+      }
+
+      if (context.addons.length > 0) {
+        console.log(chalk.bold("Addons:"));
+        table(
+          ["Name", "Type", "Status", "Host"],
+          context.addons.map((a) => [a.name, a.type, statusColor(a.status), a.hostname || "—"]),
+        );
+        console.log();
+      }
+
+      if (context.secrets.length > 0) {
+        console.log(
+          chalk.bold("Secrets:") + " " + context.secrets.join(", "),
+        );
+      }
+    });
+}

package/src/commands/deploy.ts

@@ -0,0 +1,153 @@
+import chalk from "chalk";
+import ora from "ora";
+import { Command } from "commander";
+import { api, streamSSE } from "../lib/api.js";
+import { resolveProjectId } from "../lib/config.js";
+import {
+  success,
+  info,
+  error,
+  isJSONMode,
+  printJSON,
+  statusColor,
+  table,
+} from "../lib/format.js";
+
+interface App {
+  id: string;
+  name: string;
+  status: string;
+  domain?: string;
+  repo?: string;
+  branch?: string;
+  builds?: Array<{ id: string; status: string }>;
+}
+
+export function registerDeploy(program: Command) {
+  program
+    .command("deploy")
+    .description("Deploy the current project")
+    .option("--detach", "Run in background without streaming logs")
+    .option("--region <region>", "Region for deployment")
+    .action(async (opts) => {
+      const projectId = resolveProjectId(program.opts().project);
+
+      // Check if there's already an app, if so redeploy
+      const services = await api.get<{ apps: App[] }>(
+        `/api/projects/${projectId}/services`,
+      );
+
+      if (services.apps && services.apps.length > 0) {
+        // Redeploy existing app
+        const app = services.apps[0];
+        info(`Redeploying ${chalk.bold(app.name)}...`);
+
+        await api.post(`/api/apps/${app.id}/redeploy`);
+
+        if (opts.detach) {
+          if (isJSONMode()) {
+            printJSON({ appId: app.id, status: "deploying" });
+          } else {
+            success(`Redeploy started for ${app.name}`);
+            info(chalk.dim(`  Check status: lizard deploy status ${app.id}`));
+          }
+          return;
+        }
+
+        // Stream build logs
+        await streamBuildLogs(app.id);
+        return;
+      }
+
+      // First deploy — create app
+      // TODO: detect repo from git remote, create app from repo
+      throw new Error(
+        "First deploy requires an existing app. Create one from the dashboard or use `lizard init` + push via git.",
+      );
+    });
+
+  program
+    .command("deploy-status")
+    .argument("<id>", "App or deploy ID")
+    .description("Show deployment status")
+    .action(async (id) => {
+      const app = await api.get<App>(`/api/apps/${id}`);
+
+      if (isJSONMode()) {
+        printJSON(app);
+        return;
+      }
+
+      console.log(`${chalk.bold(app.name)}  ${statusColor(app.status)}`);
+      if (app.domain) console.log(`  URL: ${chalk.cyan(`https://${app.domain}`)}`);
+      if (app.builds?.length) {
+        const latest = app.builds[0];
+        console.log(`  Latest build: ${statusColor(latest.status)}`);
+      }
+    });
+}
+
+async function streamBuildLogs(appId: string) {
+  // Wait a moment for the build to start
+  const spinner = ora("Waiting for build...").start();
+
+  // Poll until we get a build ID
+  let buildId: string | null = null;
+  for (let i = 0; i < 30; i++) {
+    await sleep(2000);
+    try {
+      const app = await api.get<App>(`/api/apps/${appId}`);
+      if (app.builds?.length) {
+        const latest = app.builds[0];
+        if (["building", "deploying", "running", "failed"].includes(latest.status)) {
+          buildId = latest.id;
+          break;
+        }
+      }
+    } catch {}
+  }
+  spinner.stop();
+
+  if (!buildId) {
+    info(chalk.dim("No build found. Check `lizard deploy status <id>` for status."));
+    return;
+  }
+
+  info(chalk.dim("Streaming build logs...\n"));
+
+  await streamSSE(`/api/builds/${buildId}/logs`, (event, data) => {
+    if (event === "done" || event === "error") {
+      if (event === "error") {
+        error(`Build failed: ${data}`);
+      } else {
+        success("Build complete");
+      }
+      return false;
+    }
+
+    // Print log line
+    try {
+      const parsed = JSON.parse(data);
+      if (parsed.line) {
+        process.stdout.write(parsed.line + "\n");
+      } else if (typeof parsed === "string") {
+        process.stdout.write(parsed + "\n");
+      }
+    } catch {
+      process.stdout.write(data + "\n");
+    }
+    return true;
+  });
+
+  // Check final status
+  const app = await api.get<App>(`/api/apps/${appId}`);
+  if (app.status === "running") {
+    success(`Deployed! ${app.domain ? chalk.cyan(`https://${app.domain}`) : ""}`);
+  } else if (app.status === "failed") {
+    error("Deploy failed. Check logs with `lizard logs --build`");
+  }
+}
+
+function sleep(ms: number) {
+  return new Promise((r) => setTimeout(r, ms));
+}

package/src/commands/destroy.ts

@@ -0,0 +1,51 @@
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { resolveProjectId } from "../lib/config.js";
+import { success, isJSONMode, printJSON, isTTY } from "../lib/format.js";
+
+export function registerDestroy(program: Command) {
+  program
+    .command("destroy")
+    .argument("<id>", "Service ID to destroy")
+    .description("Destroy a service (irreversible)")
+    .action(async (id: string) => {
+      const projectId = resolveProjectId(program.opts().project);
+      const yes = program.opts().yes;
+
+      // Confirm
+      if (!yes) {
+        if (!isTTY()) {
+          throw new Error("Use -y to confirm destruction in non-interactive mode");
+        }
+        const confirm = await p.confirm({
+          message: `Destroy service ${chalk.bold(id)}? This is irreversible.`,
+        });
+        if (p.isCancel(confirm) || !confirm) {
+          process.exit(5);
+        }
+      }
+
+      // Try as app first, then as addon
+      try {
+        await api.delete(`/api/apps/${id}`);
+        if (isJSONMode()) {
+          printJSON({ id, status: "destroyed", type: "app" });
+        } else {
+          success(`Service ${id} destroyed`);
+        }
+        return;
+      } catch (err: any) {
+        if (err.status !== 404) throw err;
+      }
+
+      // Try as addon
+      await api.delete(`/api/projects/${projectId}/addons/${id}`);
+      if (isJSONMode()) {
+        printJSON({ id, status: "destroyed", type: "addon" });
+      } else {
+        success(`Service ${id} destroyed`);
+      }
+    });
+}

package/src/commands/git.ts

@@ -0,0 +1,80 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { resolveProjectId } from "../lib/config.js";
+import { success, info, isJSONMode, printJSON } from "../lib/format.js";
+
+export function registerGit(program: Command) {
+  const git = program
+    .command("git")
+    .description("Git integration");
+
+  git
+    .command("connect")
+    .argument("<repo>", "GitHub repository (user/repo)")
+    .description("Connect Git repository for auto-deploy")
+    .option("--branch <name>", "Branch for auto-deploy", "main")
+    .action(async (repo: string, opts) => {
+      const projectId = resolveProjectId(program.opts().project);
+
+      // This requires a server endpoint for programmatic webhook setup
+      // For now, guide the user to use the dashboard
+      if (isJSONMode()) {
+        printJSON({
+          error: "not_implemented",
+          message: "Git connect via CLI requires server endpoint. Use the dashboard.",
+        });
+      } else {
+        info(`To connect ${chalk.cyan(repo)} for auto-deploy:`);
+        info(`  1. Open your project on lizard.build`);
+        info(`  2. Go to Settings → Git Integration`);
+        info(`  3. Connect ${repo} (branch: ${opts.branch})`);
+        info("");
+        info(chalk.dim("CLI git connect will be available in a future update."));
+      }
+    });
+
+  git
+    .command("disconnect")
+    .description("Disconnect Git auto-deploy")
+    .action(async () => {
+      info(chalk.dim("Git disconnect via CLI will be available in a future update."));
+    });
+
+  git
+    .command("status")
+    .description("Show Git integration status")
+    .action(async () => {
+      const projectId = resolveProjectId(program.opts().project);
+
+      // Get apps to check for repo info
+      const services = await api.get<{ apps: any[] }>(
+        `/api/projects/${projectId}/services`,
+      );
+
+      const appsWithRepo = (services.apps || []).filter((a: any) => a.repo);
+
+      if (isJSONMode()) {
+        printJSON({
+          connected: appsWithRepo.length > 0,
+          apps: appsWithRepo.map((a: any) => ({
+            name: a.name,
+            repo: a.repo,
+            branch: a.branch,
+          })),
+        });
+        return;
+      }
+
+      if (appsWithRepo.length === 0) {
+        console.log("No Git repositories connected.");
+        return;
+      }
+
+      for (const app of appsWithRepo) {
+        console.log(
+          `${chalk.bold(app.name)}: ${chalk.cyan(app.repo)} (${app.branch || "main"})`,
+        );
+      }
+    });
+}