@lizard-build/cli 0.1.0

package/src/lib/api.ts

@@ -0,0 +1,134 @@
+import { getToken } from "./auth.js";
+
+const DEFAULT_BASE_URL = "https://lizard.build";
+const USER_AGENT = "lizard-cli/0.1";
+
+let baseURL = process.env.LIZARD_API_URL || DEFAULT_BASE_URL;
+let _accessToken: string | null = null;
+
+export function setBaseURL(url: string) { baseURL = url; }
+export function getBaseURL() { return baseURL; }
+export function setAccessToken(token: string) { _accessToken = token; }
+
+export class APIError extends Error {
+  status: number;
+  code: string;
+  constructor(status: number, message: string, code = "") {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+}
+
+export function isNotFound(err: unknown): boolean {
+  return err instanceof APIError && err.status === 404;
+}
+
+export function isAuthError(err: unknown): boolean {
+  return err instanceof APIError && (err.status === 401 || err.status === 403);
+}
+
+async function request<T = any>(
+  method: string,
+  path: string,
+  body?: unknown,
+): Promise<T> {
+  const url = baseURL + path;
+  const token = _accessToken || getToken();
+
+  const headers: Record<string, string> = {
+    "User-Agent": USER_AGENT,
+  };
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (body !== undefined) {
+    headers["Content-Type"] = "application/json";
+  }
+
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: body !== undefined ? JSON.stringify(body) : undefined,
+  });
+
+  if (!res.ok) {
+    let msg = res.statusText;
+    let code = "";
+    try {
+      const j = (await res.json()) as any;
+      msg = j.error || j.message || msg;
+      code = j.code || "";
+    } catch {}
+    throw new APIError(res.status, msg, code);
+  }
+
+  const text = await res.text();
+  if (!text) return undefined as T;
+  return JSON.parse(text) as T;
+}
+
+export const api = {
+  get: <T = any>(path: string) => request<T>("GET", path),
+  post: <T = any>(path: string, body?: unknown) =>
+    request<T>("POST", path, body),
+  put: <T = any>(path: string, body?: unknown) =>
+    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),
+};
+
+/** Stream SSE and call handler for each data line. Return false to stop. */
+export async function streamSSE(
+  path: string,
+  handler: (event: string, data: string) => boolean | void,
+): Promise<void> {
+  const url = baseURL + path;
+  const token = _accessToken || getToken();
+  const headers: Record<string, string> = {
+    "User-Agent": USER_AGENT,
+    Accept: "text/event-stream",
+  };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    throw new APIError(res.status, `SSE failed: ${res.statusText}`);
+  }
+  if (!res.body) return;
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let currentEvent = "";
+  let currentData = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      const trimmed = line.replace(/\r$/, "");
+      if (trimmed === "") {
+        if (currentData) {
+          const cont = handler(currentEvent, currentData);
+          if (cont === false) {
+            reader.cancel();
+            return;
+          }
+        }
+        currentEvent = "";
+        currentData = "";
+      } else if (trimmed.startsWith("event:")) {
+        currentEvent = trimmed.slice(6).trim();
+      } else if (trimmed.startsWith("data:")) {
+        currentData = trimmed.slice(5).trimStart();
+      }
+    }
+  }
+}

package/src/lib/auth.ts

@@ -0,0 +1,113 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import open from "open";
+
+const LIZARD_DIR = path.join(os.homedir(), ".lizard");
+const CREDENTIALS_FILE = path.join(LIZARD_DIR, "credentials.json");
+
+export interface Credentials {
+  accessToken: string;
+  refreshToken?: string;
+  expiresAt?: string;
+  userId: string;
+  username: string;
+  email?: string;
+  avatarUrl?: string;
+}
+
+let tokenOverride: string | null = null;
+
+export function setTokenOverride(token: string) {
+  tokenOverride = token;
+}
+
+/** Get the active token in priority order: override → env → file */
+export function getToken(): string | null {
+  if (tokenOverride) return tokenOverride;
+  if (process.env.LIZARD_TOKEN) return process.env.LIZARD_TOKEN;
+  const creds = loadCredentials();
+  return creds?.accessToken ?? null;
+}
+
+export function loadCredentials(): Credentials | null {
+  try {
+    const data = fs.readFileSync(CREDENTIALS_FILE, "utf-8");
+    return JSON.parse(data) as Credentials;
+  } catch {
+    return null;
+  }
+}
+
+export function saveCredentials(creds: Credentials) {
+  fs.mkdirSync(LIZARD_DIR, { recursive: true });
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(creds, null, 2), {
+    mode: 0o600,
+  });
+}
+
+export function clearCredentials() {
+  try {
+    fs.unlinkSync(CREDENTIALS_FILE);
+  } catch {}
+}
+
+export function isLoggedIn(): boolean {
+  return getToken() !== null;
+}
+
+function isTTY(): boolean {
+  return Boolean(process.stdout.isTTY);
+}
+
+/**
+ * Ensure the user is authenticated. If not logged in and TTY, auto-login.
+ * Returns credentials or throws.
+ */
+export async function requireAuth(): Promise<Credentials> {
+  // Token override or env var — we don't have full Credentials, fake it
+  if (tokenOverride || process.env.LIZARD_TOKEN) {
+    return {
+      accessToken: (tokenOverride || process.env.LIZARD_TOKEN)!,
+      userId: "",
+      username: "",
+    };
+  }
+
+  const creds = loadCredentials();
+  if (creds) return creds;
+
+  // Not logged in
+  if (!isTTY()) {
+    throw new Error(
+      "Not authenticated. Set LIZARD_TOKEN or run `lizard login` first.",
+    );
+  }
+
+  // Auto-login
+  const { performLogin } = await import("../commands/login.js");
+  return performLogin();
+}
+
+/** Open a URL in the default browser, or print it if headless. */
+export async function openURL(url: string) {
+  const isSSH = Boolean(
+    process.env.SSH_CLIENT || process.env.SSH_TTY || process.env.SSH_CONNECTION,
+  );
+  const isCI = Boolean(process.env.CI);
+  const noDisplay =
+    process.platform === "linux" &&
+    !process.env.DISPLAY &&
+    !process.env.WAYLAND_DISPLAY;
+
+  if (isSSH || isCI || noDisplay) {
+    return false; // caller should show URL manually
+  }
+
+  try {
+    await open(url);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/lib/config.ts

@@ -0,0 +1,93 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const CONFIG_DIR = ".lizard";
+const CONFIG_FILE = "config.json";
+const GLOBAL_SETTINGS_FILE = path.join(os.homedir(), ".lizard", "settings.json");
+
+export interface ProjectConfig {
+  workspaceId?: string;
+  projectId: string;
+  projectName?: string;
+  environment?: string;
+}
+
+export interface GlobalSettings {
+  defaultWorkspace?: string;
+}
+
+/** Find project config by walking up from cwd */
+export function findProjectConfig(): ProjectConfig | null {
+  let dir = process.cwd();
+  while (true) {
+    const configPath = path.join(dir, CONFIG_DIR, CONFIG_FILE);
+    if (fs.existsSync(configPath)) {
+      try {
+        return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      } catch {
+        return null;
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/** Save project config in cwd */
+export function saveProjectConfig(config: ProjectConfig) {
+  const dir = path.join(process.cwd(), CONFIG_DIR);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, CONFIG_FILE), JSON.stringify(config, null, 2));
+
+  // Add .lizard/ to .gitignore if not already there
+  const gitignorePath = path.join(process.cwd(), ".gitignore");
+  try {
+    const existing = fs.existsSync(gitignorePath)
+      ? fs.readFileSync(gitignorePath, "utf-8")
+      : "";
+    if (!existing.includes(".lizard/")) {
+      fs.appendFileSync(
+        gitignorePath,
+        (existing.endsWith("\n") ? "" : "\n") + ".lizard/\n",
+      );
+    }
+  } catch {}
+}
+
+export function loadGlobalSettings(): GlobalSettings {
+  try {
+    return JSON.parse(fs.readFileSync(GLOBAL_SETTINGS_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+export function saveGlobalSettings(settings: GlobalSettings) {
+  const dir = path.dirname(GLOBAL_SETTINGS_FILE);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(GLOBAL_SETTINGS_FILE, JSON.stringify(settings, null, 2));
+}
+
+/**
+ * Resolve projectId from: --project flag → .lizard/config.json → error
+ */
+export function resolveProjectId(flagValue?: string): string {
+  if (flagValue) return flagValue;
+  const config = findProjectConfig();
+  if (config?.projectId) return config.projectId;
+  throw new Error(
+    "No project linked. Run `lizard init` or `lizard link` first, or use --project <id>.",
+  );
+}
+
+/**
+ * Resolve environment from: --environment flag → .lizard/config.json → "production"
+ */
+export function resolveEnvironment(flagValue?: string): string {
+  if (flagValue) return flagValue;
+  const config = findProjectConfig();
+  return config?.environment ?? "production";
+}

package/src/lib/format.ts

@@ -0,0 +1,95 @@
+import chalk from "chalk";
+
+export function isTTY(): boolean {
+  return Boolean(process.stdout.isTTY);
+}
+
+let jsonMode = false;
+export function setJSONMode(on: boolean) {
+  jsonMode = on;
+}
+export function isJSONMode(): boolean {
+  return jsonMode;
+}
+
+export function printJSON(data: unknown) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+export function success(msg: string) {
+  if (jsonMode) return;
+  process.stderr.write(chalk.green("✓") + " " + msg + "\n");
+}
+
+export function error(msg: string) {
+  process.stderr.write(chalk.red("Error:") + " " + msg + "\n");
+}
+
+export function warn(msg: string) {
+  process.stderr.write(chalk.yellow("Warning:") + " " + msg + "\n");
+}
+
+export function info(msg: string) {
+  if (jsonMode) return;
+  process.stderr.write(msg + "\n");
+}
+
+export function table(
+  headers: string[],
+  rows: string[][],
+) {
+  if (rows.length === 0) return;
+
+  const widths = headers.map((h) => h.length);
+  for (const row of rows) {
+    for (let i = 0; i < row.length; i++) {
+      if (i < widths.length) {
+        widths[i] = Math.max(widths[i], (row[i] || "").length);
+      }
+    }
+  }
+
+  const header = headers
+    .map((h, i) => h.toUpperCase().padEnd(widths[i]))
+    .join("  ");
+  console.log(chalk.dim(header));
+
+  for (const row of rows) {
+    const line = headers
+      .map((_, i) => (row[i] || "").padEnd(widths[i]))
+      .join("  ");
+    console.log(line);
+  }
+}
+
+export function statusColor(status: string): string {
+  switch (status) {
+    case "running":
+      return chalk.green(status);
+    case "failed":
+    case "error":
+      return chalk.red(status);
+    case "building":
+    case "deploying":
+    case "restarting":
+    case "pending":
+      return chalk.yellow(status);
+    case "deleting":
+      return chalk.dim(status);
+    default:
+      return status;
+  }
+}
+
+export function timeAgo(ts: number | string): string {
+  const ms = typeof ts === "string" ? Date.parse(ts) : ts;
+  const diff = Date.now() - ms;
+  const secs = Math.floor(diff / 1000);
+  if (secs < 60) return `${secs}s ago`;
+  const mins = Math.floor(secs / 60);
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "types": ["node"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "resolveJsonModule": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"]
+}