@lizard-build/cli 0.1.0

package/src/commands/init.ts

@@ -0,0 +1,139 @@
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import {
+  findProjectConfig,
+  saveProjectConfig,
+} from "../lib/config.js";
+import {
+  success,
+  info,
+  isJSONMode,
+  printJSON,
+  isTTY,
+} from "../lib/format.js";
+
+interface Project {
+  id: string;
+  name: string;
+  slug: string;
+}
+
+/** Detect framework from files in cwd */
+function detectFramework(): {
+  name: string;
+  port: number;
+  buildCmd: string;
+  startCmd: string;
+} | null {
+  const cwd = process.cwd();
+  const has = (f: string) => fs.existsSync(path.join(cwd, f));
+
+  if (has("next.config.js") || has("next.config.mjs") || has("next.config.ts"))
+    return { name: "Next.js", port: 3000, buildCmd: "npm run build", startCmd: "npm start" };
+  if (has("nuxt.config.ts") || has("nuxt.config.js"))
+    return { name: "Nuxt", port: 3000, buildCmd: "npm run build", startCmd: "npm start" };
+  if (has("remix.config.js") || has("remix.config.ts"))
+    return { name: "Remix", port: 3000, buildCmd: "npm run build", startCmd: "npm start" };
+  if (has("astro.config.mjs") || has("astro.config.ts"))
+    return { name: "Astro", port: 4321, buildCmd: "npm run build", startCmd: "npm start" };
+  if (has("vite.config.ts") || has("vite.config.js"))
+    return { name: "Vite", port: 3000, buildCmd: "npm run build", startCmd: "npm run preview" };
+  if (has("Dockerfile"))
+    return { name: "Docker", port: 8080, buildCmd: "", startCmd: "" };
+  if (has("go.mod"))
+    return { name: "Go", port: 8080, buildCmd: "go build -o app .", startCmd: "./app" };
+  if (has("requirements.txt") || has("pyproject.toml"))
+    return { name: "Python", port: 8000, buildCmd: "pip install -r requirements.txt", startCmd: "python app.py" };
+  if (has("package.json"))
+    return { name: "Node.js", port: 3000, buildCmd: "npm run build", startCmd: "npm start" };
+  return null;
+}
+
+function writeLizardToml(
+  framework: { name: string; port: number; buildCmd: string; startCmd: string } | null,
+) {
+  const port = framework?.port ?? 3000;
+  const build = framework?.buildCmd ?? "";
+  const start = framework?.startCmd ?? "";
+
+  let toml = `# lizard.toml\n\n`;
+  if (build) toml += `[build]\ncommand = "${build}"\n\n`;
+  toml += `[deploy]\nport = ${port}\n`;
+  if (start) toml += `start_command = "${start}"\n`;
+  toml += `\n[resources]\ncpu = 1\nmemory = 512\n`;
+
+  const tomlPath = path.join(process.cwd(), "lizard.toml");
+  if (!fs.existsSync(tomlPath)) {
+    fs.writeFileSync(tomlPath, toml);
+  }
+}
+
+export function registerInit(program: Command) {
+  program
+    .command("init")
+    .description("Create a new project and link current directory")
+    .option("--name <name>", "Project name")
+    .action(async (opts) => {
+      // Check if already initialized
+      const existing = findProjectConfig();
+      if (existing) {
+        throw new Error(
+          "Already initialized. Run `lizard link` to change project.",
+        );
+      }
+
+      // Detect framework
+      const framework = detectFramework();
+      if (framework && !isJSONMode()) {
+        info(`Detected framework: ${chalk.cyan(framework.name)}`);
+      }
+
+      // Get project name
+      let projectName = opts.name;
+      if (!projectName) {
+        if (!isTTY()) {
+          throw new Error("--name is required in non-interactive mode");
+        }
+        const result = await p.text({
+          message: "Project name",
+          defaultValue: path.basename(process.cwd()),
+          placeholder: path.basename(process.cwd()),
+        });
+        if (p.isCancel(result)) process.exit(5);
+        projectName = result as string;
+      }
+
+      // Create project via API
+      const project = await api.post<Project>("/api/projects", {
+        name: projectName,
+      });
+
+      // Save local config
+      saveProjectConfig({
+        projectId: project.id,
+        projectName: project.name,
+      });
+
+      // Write lizard.toml
+      writeLizardToml(framework);
+
+      if (isJSONMode()) {
+        printJSON({
+          projectId: project.id,
+          name: project.name,
+          framework: framework?.name,
+        });
+      } else {
+        success(`Project "${chalk.bold(project.name)}" created`);
+        info(chalk.dim("  Linked to current directory"));
+        info(chalk.dim("  Config saved to .lizard/config.json"));
+        if (framework) {
+          info(chalk.dim(`  lizard.toml created for ${framework.name}`));
+        }
+      }
+    });
+}

package/src/commands/link.ts

@@ -0,0 +1,63 @@
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { saveProjectConfig, findProjectConfig } from "../lib/config.js";
+import { success, isJSONMode, printJSON, isTTY } from "../lib/format.js";
+
+interface Project {
+  id: string;
+  name: string;
+  slug: string;
+}
+
+export function registerLink(program: Command) {
+  program
+    .command("link")
+    .description("Link current directory to an existing project")
+    .option("--project <id>", "Project ID")
+    .action(async (opts) => {
+      let projectId = opts.project;
+      let projectName: string | undefined;
+
+      if (!projectId) {
+        // Fetch projects and let user pick
+        const projects = await api.get<Project[]>("/api/projects");
+        if (projects.length === 0) {
+          throw new Error("No projects found. Run `lizard init` to create one.");
+        }
+
+        if (!isTTY()) {
+          throw new Error(
+            "Use --project <id> in non-interactive mode. Available: " +
+              projects.map((p) => `${p.name} (${p.id})`).join(", "),
+          );
+        }
+
+        const selected = await p.select({
+          message: "Select project",
+          options: projects.map((proj) => ({
+            value: proj.id,
+            label: proj.name,
+            hint: proj.id,
+          })),
+        });
+        if (p.isCancel(selected)) process.exit(5);
+        projectId = selected as string;
+        projectName = projects.find((p) => p.id === projectId)?.name;
+      }
+
+      const old = findProjectConfig();
+      saveProjectConfig({ projectId, projectName });
+
+      if (isJSONMode()) {
+        printJSON({ projectId, projectName });
+      } else if (old?.projectId && old.projectId !== projectId) {
+        success(
+          `Relinked to ${chalk.bold(projectName || projectId)} (was ${old.projectName || old.projectId})`,
+        );
+      } else {
+        success(`Linked to ${chalk.bold(projectName || projectId)}`);
+      }
+    });
+}

package/src/commands/login.ts

@@ -0,0 +1,158 @@
+import chalk from "chalk";
+import ora from "ora";
+import { Command } from "commander";
+import {
+  saveCredentials,
+  openURL,
+  type Credentials,
+} from "../lib/auth.js";
+import { getBaseURL } from "../lib/api.js";
+import { success, info, isJSONMode, printJSON } from "../lib/format.js";
+
+const POLL_INTERVAL = 2000;
+const SESSION_TIMEOUT = 300_000; // 5 min
+
+interface SessionResponse {
+  sessionId: string;
+  sessionSecret: string;
+  expiresIn: number;
+}
+
+interface PollResponse {
+  status: "pending" | "complete" | "expired";
+  accessToken?: string;
+  refreshToken?: string;
+  user?: {
+    id: string;
+    username: string;
+    email?: string;
+    avatarUrl?: string;
+  };
+}
+
+/** Create a CLI login session on the server */
+async function createSession(): Promise<SessionResponse> {
+  const res = await fetch(`${getBaseURL()}/api/auth/cli/session`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to create login session: ${res.statusText}`);
+  }
+  return res.json() as Promise<SessionResponse>;
+}
+
+/** Poll the server to check if the user completed login */
+async function pollSession(
+  sessionId: string,
+  sessionSecret: string,
+): Promise<PollResponse> {
+  const res = await fetch(`${getBaseURL()}/api/auth/cli/poll`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ sessionId, sessionSecret }),
+  });
+  if (!res.ok) {
+    throw new Error(`Poll failed: ${res.statusText}`);
+  }
+  return res.json() as Promise<PollResponse>;
+}
+
+/**
+ * Perform the login flow. Used by the login command and by auto-login in requireAuth.
+ */
+export async function performLogin(): Promise<Credentials> {
+  // 1. Create session
+  const session = await createSession();
+  const loginURL = `${getBaseURL()}/auth/cli?session=${session.sessionId}`;
+
+  // 2. Try to open browser
+  const opened = await openURL(loginURL);
+  if (opened) {
+    info("Opening browser to log in...");
+  } else {
+    info(`Open this URL in your browser to log in:\n  ${chalk.cyan(loginURL)}`);
+  }
+
+  // 3. Poll until complete
+  const spinner = ora("Waiting for login...").start();
+  const deadline = Date.now() + SESSION_TIMEOUT;
+
+  while (Date.now() < deadline) {
+    await sleep(POLL_INTERVAL);
+
+    try {
+      const result = await pollSession(session.sessionId, session.sessionSecret);
+
+      if (result.status === "complete" && result.accessToken && result.user) {
+        spinner.stop();
+        const creds: Credentials = {
+          accessToken: result.accessToken,
+          refreshToken: result.refreshToken,
+          userId: result.user.id,
+          username: result.user.username,
+          email: result.user.email,
+          avatarUrl: result.user.avatarUrl,
+        };
+        saveCredentials(creds);
+
+        if (isJSONMode()) {
+          printJSON({ username: creds.username, email: creds.email });
+        } else {
+          success(`Logged in as ${chalk.bold(creds.username)}`);
+        }
+        return creds;
+      }
+
+      if (result.status === "expired") {
+        spinner.stop();
+        throw new Error("Login session expired. Please try again.");
+      }
+    } catch (err: any) {
+      if (err.message?.includes("expired")) {
+        spinner.stop();
+        throw err;
+      }
+      // Network error — keep trying
+    }
+  }
+
+  spinner.stop();
+  throw new Error("Login timed out. Please try again.");
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+export function registerLogin(program: Command) {
+  program
+    .command("login")
+    .description("Log in to Lizard")
+    .option("--token <token>", "Authenticate with an API token")
+    .action(async (opts) => {
+      if (opts.token) {
+        // Direct token auth — validate it
+        const res = await fetch(`${getBaseURL()}/api/auth/me`, {
+          headers: { Authorization: `Bearer ${opts.token}` },
+        });
+        if (!res.ok) throw new Error("Invalid token");
+        const user = (await res.json()) as any;
+        saveCredentials({
+          accessToken: opts.token,
+          userId: user.id,
+          username: user.username,
+          email: user.email,
+          avatarUrl: user.avatarUrl,
+        });
+        if (isJSONMode()) {
+          printJSON({ username: user.username });
+        } else {
+          success(`Logged in as ${chalk.bold(user.username)}`);
+        }
+        return;
+      }
+
+      await performLogin();
+    });
+}

package/src/commands/logout.ts

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import { clearCredentials } from "../lib/auth.js";
+import { success, isJSONMode, printJSON } from "../lib/format.js";
+
+export function registerLogout(program: Command) {
+  program
+    .command("logout")
+    .description("Log out of Lizard")
+    .action(async () => {
+      clearCredentials();
+      if (isJSONMode()) {
+        printJSON({ status: "logged_out" });
+      } else {
+        success("Logged out");
+      }
+    });
+}

package/src/commands/logs.ts

@@ -0,0 +1,104 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { streamSSE, api } from "../lib/api.js";
+import { resolveProjectId } from "../lib/config.js";
+import { info, error } from "../lib/format.js";
+
+export function registerLogs(program: Command) {
+  program
+    .command("logs")
+    .description("Stream runtime logs")
+    .option("--build", "Show build logs instead of runtime")
+    .option("--service <id>", "Only show logs for a specific service")
+    .action(async (opts) => {
+      const projectId = resolveProjectId(program.opts().project);
+
+      if (opts.build) {
+        // Show build logs for the latest build
+        await showBuildLogs(opts.service, projectId);
+        return;
+      }
+
+      if (opts.service) {
+        // Stream logs for a specific app
+        info(chalk.dim("Streaming logs... (Ctrl+C to stop)\n"));
+        await streamSSE(`/api/apps/${opts.service}/logs`, (event, data) => {
+          if (event === "error") {
+            error(data);
+            return false;
+          }
+          printLogLine(data);
+          return true;
+        });
+        return;
+      }
+
+      // Stream all project logs
+      info(chalk.dim("Streaming project logs... (Ctrl+C to stop)\n"));
+      await streamSSE(
+        `/api/projects/${projectId}/logs/stream`,
+        (event, data) => {
+          if (event === "error") {
+            error(data);
+            return false;
+          }
+          printLogLine(data);
+          return true;
+        },
+      );
+    });
+}
+
+function printLogLine(data: string) {
+  try {
+    const parsed = JSON.parse(data);
+    if (parsed.service && parsed.line) {
+      const prefix = chalk.cyan(`[${parsed.service}]`);
+      process.stdout.write(`${prefix} ${parsed.line}\n`);
+    } else if (parsed.line) {
+      process.stdout.write(parsed.line + "\n");
+    } else if (parsed.message) {
+      process.stdout.write(parsed.message + "\n");
+    } else if (typeof parsed === "string") {
+      process.stdout.write(parsed + "\n");
+    } else {
+      process.stdout.write(data + "\n");
+    }
+  } catch {
+    process.stdout.write(data + "\n");
+  }
+}
+
+async function showBuildLogs(serviceId: string | undefined, projectId: string) {
+  let appId = serviceId;
+
+  if (!appId) {
+    // Get first app in project
+    const data = await api.get<{ apps: Array<{ id: string; name: string }> }>(
+      `/api/projects/${projectId}/services`,
+    );
+    if (!data.apps?.length) {
+      throw new Error("No apps in project");
+    }
+    appId = data.apps[0].id;
+  }
+
+  // Get latest build
+  const app = await api.get<{
+    builds?: Array<{ id: string; status: string }>;
+  }>(`/api/apps/${appId}`);
+  if (!app.builds?.length) {
+    throw new Error("No builds found");
+  }
+
+  const buildId = app.builds[0].id;
+  info(chalk.dim(`Build ${buildId}\n`));
+
+  await streamSSE(`/api/builds/${buildId}/logs`, (event, data) => {
+    if (event === "done" || event === "error") {
+      return false;
+    }
+    printLogLine(data);
+    return true;
+  });
+}

package/src/commands/open.ts

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import open from "open";
+import { resolveProjectId } from "../lib/config.js";
+import { getBaseURL } from "../lib/api.js";
+import { success } from "../lib/format.js";
+
+export function registerOpen(program: Command) {
+  program
+    .command("open")
+    .description("Open project in browser")
+    .action(async () => {
+      const projectId = resolveProjectId(program.opts().project);
+      const url = `${getBaseURL()}/projects/${projectId}`;
+      await open(url);
+      success("Opened in browser");
+    });
+}

package/src/commands/projects.ts

@@ -0,0 +1,45 @@
+import { Command } from "commander";
+import { api } from "../lib/api.js";
+import { isJSONMode, printJSON, table } from "../lib/format.js";
+
+interface Project {
+  id: string;
+  name: string;
+  slug: string;
+  role: string;
+  memberCount: number;
+  createdAt: number;
+}
+
+export function registerProjects(program: Command) {
+  const proj = program
+    .command("project")
+    .description("Project management");
+
+  proj
+    .command("list")
+    .description("List all projects")
+    .action(async () => {
+      const projects = await api.get<Project[]>("/api/projects");
+
+      if (isJSONMode()) {
+        printJSON(projects);
+        return;
+      }
+
+      if (projects.length === 0) {
+        console.log("No projects. Run `lizard init` to create one.");
+        return;
+      }
+
+      table(
+        ["Name", "ID", "Role", "Members"],
+        projects.map((p) => [
+          p.name,
+          p.id,
+          p.role || "owner",
+          String(p.memberCount || 1),
+        ]),
+      );
+    });
+}

package/src/commands/ps.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 {
+  isJSONMode,
+  printJSON,
+  table,
+  statusColor,
+} from "../lib/format.js";
+
+interface Service {
+  id: string;
+  name: string;
+  type: "app" | "addon";
+  addonType?: string;
+  status: string;
+  domain?: string;
+  hostname?: string;
+  createdAt?: number;
+}
+
+export function registerPs(program: Command) {
+  program
+    .command("ps")
+    .description("List all services in the project")
+    .action(async () => {
+      const projectId = resolveProjectId(program.opts().project);
+      const data = await api.get<{ apps: any[]; addons: any[] }>(
+        `/api/projects/${projectId}/services`,
+      );
+
+      const services: Service[] = [];
+
+      for (const app of data.apps || []) {
+        services.push({
+          id: app.id,
+          name: app.name,
+          type: "app",
+          status: app.status,
+          domain: app.domain,
+          createdAt: app.createdAt,
+        });
+      }
+
+      for (const addon of data.addons || []) {
+        services.push({
+          id: addon.id,
+          name: addon.name || addon.addonType,
+          type: "addon",
+          addonType: addon.addonType,
+          status: addon.status,
+          hostname: addon.hostname,
+          createdAt: addon.createdAt,
+        });
+      }
+
+      if (isJSONMode()) {
+        printJSON(services);
+        return;
+      }
+
+      if (services.length === 0) {
+        console.log("No services. Use `lizard add` or `lizard deploy`.");
+        return;
+      }
+
+      table(
+        ["Name", "Type", "Status", "URL/Host"],
+        services.map((s) => [
+          s.name,
+          s.addonType || s.type,
+          statusColor(s.status),
+          s.domain
+            ? `https://${s.domain}`
+            : s.hostname || chalk.dim("—"),
+        ]),
+      );
+    });
+}

package/src/commands/redeploy.ts

@@ -0,0 +1,74 @@
+import chalk from "chalk";
+import ora from "ora";
+import { Command } from "commander";
+import { api, streamSSE } from "../lib/api.js";
+import { success, info, error, isJSONMode, printJSON } 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")
+    .option("--detach", "Run in background")
+    .action(async (id: string, opts) => {
+      const spinner = ora("Starting redeploy...").start();
+
+      await api.post(`/api/apps/${id}/redeploy`);
+
+      spinner.stop();
+
+      if (opts.detach || isJSONMode()) {
+        if (isJSONMode()) {
+          printJSON({ id, status: "deploying" });
+        } else {
+          success("Redeploy started");
+          info(chalk.dim(`  Check status: lizard deploy-status ${id}`));
+        }
+        return;
+      }
+
+      // Stream build logs if not detached
+      info("Redeploying...");
+
+      // Poll for build
+      let buildId: string | null = null;
+      for (let i = 0; i < 30; i++) {
+        await new Promise((r) => setTimeout(r, 2000));
+        try {
+          const app = await api.get<{ builds?: Array<{ id: string; status: string }> }>(
+            `/api/apps/${id}`,
+          );
+          if (app.builds?.length) {
+            const latest = app.builds[0];
+            if (["building", "deploying", "running", "failed"].includes(latest.status)) {
+              buildId = latest.id;
+              break;
+            }
+          }
+        } catch {}
+      }
+
+      if (buildId) {
+        await streamSSE(`/api/builds/${buildId}/logs`, (event, data) => {
+          if (event === "done" || event === "error") {
+            if (event === "error") error(`Build failed: ${data}`);
+            return false;
+          }
+          try {
+            const parsed = JSON.parse(data);
+            process.stdout.write((parsed.line || data) + "\n");
+          } catch {
+            process.stdout.write(data + "\n");
+          }
+          return true;
+        });
+      }
+
+      const app = await api.get<{ status: string; domain?: string }>(`/api/apps/${id}`);
+      if (app.status === "running") {
+        success(`Redeployed! ${app.domain ? chalk.cyan(`https://${app.domain}`) : ""}`);
+      } else {
+        error("Redeploy failed");
+      }
+    });
+}