@light-cloud/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,4090 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command, CommanderError } from "commander";
+
+// src/lib/errors.ts
+var EXIT = {
+  OK: 0,
+  ERROR: 1,
+  USAGE: 2,
+  AUTH: 3,
+  NOT_FOUND: 4,
+  FAILED: 5,
+  CANCELLED: 130
+};
+var CliError = class extends Error {
+  hint;
+  exitCode;
+  code;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "CliError";
+    this.hint = options.hint;
+    this.exitCode = options.exitCode ?? EXIT.ERROR;
+    this.code = options.code ?? "ERROR";
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+var CancelledError = class extends CliError {
+  constructor() {
+    super("Cancelled.", { exitCode: EXIT.CANCELLED, code: "CANCELLED" });
+    this.name = "CancelledError";
+  }
+};
+var ApiError = class extends CliError {
+  status;
+  constructor(status, code, message, hint) {
+    super(message, {
+      code,
+      hint,
+      exitCode: status === 401 ? EXIT.AUTH : status === 404 ? EXIT.NOT_FOUND : EXIT.ERROR
+    });
+    this.name = "ApiError";
+    this.status = status;
+  }
+};
+var notLoggedIn = () => new CliError("You are not signed in to Light Cloud.", {
+  hint: "Run `lc login`, or set LIGHT_CLOUD_API_KEY for unattended use.",
+  exitCode: EXIT.AUTH,
+  code: "UNAUTHENTICATED"
+});
+
+// src/lib/open-browser.ts
+import { spawn } from "child_process";
+function openBrowser(url) {
+  try {
+    const child = process.platform === "darwin" ? spawn("open", [url], { detached: true, stdio: "ignore" }) : process.platform === "win32" ? spawn("cmd", ["/c", "start", "", url.replace(/&/g, "^&")], { detached: true, stdio: "ignore" }) : spawn("xdg-open", [url], { detached: true, stdio: "ignore" });
+    child.on("error", () => void 0);
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/ui/output.ts
+import pc from "picocolors";
+var state = {
+  json: false,
+  color: pc.isColorSupported,
+  quiet: false
+};
+var palette = pc.createColors(state.color);
+function configureOutput(options) {
+  Object.assign(state, options);
+  palette = pc.createColors(state.color);
+}
+var isJson = () => state.json;
+var isInteractive = () => !state.json && Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && !process.env.CI;
+var c = {
+  bold: (s) => palette.bold(s),
+  dim: (s) => palette.dim(s),
+  italic: (s) => palette.italic(s),
+  underline: (s) => palette.underline(s),
+  red: (s) => palette.red(s),
+  green: (s) => palette.green(s),
+  yellow: (s) => palette.yellow(s),
+  blue: (s) => palette.blue(s),
+  magenta: (s) => palette.magenta(s),
+  cyan: (s) => palette.cyan(s),
+  gray: (s) => palette.gray(s),
+  white: (s) => palette.white(s),
+  bgRed: (s) => palette.bgRed(s),
+  inverse: (s) => palette.inverse(s),
+  /** Brand accent. */
+  accent: (s) => palette.yellow(s)
+};
+var sym = {
+  ok: "\u2714",
+  fail: "\u2716",
+  warn: "\u25B2",
+  info: "\u2139",
+  dot: "\u25CF",
+  ring: "\u25CB",
+  arrow: "\u2192",
+  bullet: "\xB7",
+  bar: "\u2502",
+  star: "\u2605"
+};
+function out(line = "") {
+  if (state.json) return;
+  process.stdout.write(line + "\n");
+}
+function err(line = "") {
+  process.stderr.write(line + "\n");
+}
+function printJson(value) {
+  process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+function emit(value, human) {
+  if (state.json) {
+    printJson(value);
+    return;
+  }
+  human();
+}
+var log = {
+  info: (message) => {
+    if (state.json || state.quiet) return;
+    out(`${c.blue(sym.info)} ${message}`);
+  },
+  success: (message) => {
+    if (state.json || state.quiet) return;
+    out(`${c.green(sym.ok)} ${message}`);
+  },
+  warn: (message) => {
+    if (state.json) return;
+    err(`${c.yellow(sym.warn)} ${message}`);
+  },
+  error: (message, hint) => {
+    err(`${c.red(sym.fail)} ${message}`);
+    if (hint) err(`  ${c.dim(hint)}`);
+  },
+  step: (message) => {
+    if (state.json || state.quiet) return;
+    out(`${c.dim(sym.bar)} ${message}`);
+  },
+  blank: () => out()
+};
+function statusBadge(status) {
+  const value = (status || "unknown").toLowerCase();
+  switch (value) {
+    case "deployed":
+    case "ready":
+    case "healthy":
+    case "active":
+    case "completed":
+    case "success":
+      return c.green(`${sym.dot} ${value}`);
+    case "deploying":
+    case "building":
+    case "provisioning":
+    case "queued":
+    case "pending":
+    case "in_progress":
+    case "pending_verification":
+      return c.yellow(`${sym.ring} ${value}`);
+    case "failed":
+    case "delete_failed":
+    case "error":
+    case "degraded":
+      return c.red(`${sym.fail} ${value}`);
+    case "deleting":
+    case "deleted":
+      return c.gray(`${sym.ring} ${value}`);
+    default:
+      return c.gray(`${sym.ring} ${value}`);
+  }
+}
+function severityBadge(severity) {
+  const s = (severity || "DEFAULT").toUpperCase().padEnd(8);
+  switch (severity?.toUpperCase()) {
+    case "ERROR":
+    case "CRITICAL":
+    case "ALERT":
+    case "EMERGENCY":
+      return c.red(s);
+    case "WARNING":
+      return c.yellow(s);
+    case "INFO":
+    case "NOTICE":
+      return c.blue(s);
+    case "DEBUG":
+      return c.gray(s);
+    default:
+      return c.dim(s);
+  }
+}
+function relativeTime(value) {
+  if (!value) return c.dim("never");
+  const date = typeof value === "string" ? new Date(value) : value;
+  if (Number.isNaN(date.getTime())) return c.dim("unknown");
+  const seconds = Math.round((Date.now() - date.getTime()) / 1e3);
+  const abs = Math.abs(seconds);
+  const suffix = seconds >= 0 ? "ago" : "from now";
+  if (abs < 45) return "just now";
+  if (abs < 3600) return `${Math.round(abs / 60)}m ${suffix}`;
+  if (abs < 86400) return `${Math.round(abs / 3600)}h ${suffix}`;
+  if (abs < 86400 * 30) return `${Math.round(abs / 86400)}d ${suffix}`;
+  return date.toISOString().slice(0, 10);
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.max(0, Math.round(ms))}ms`;
+  const seconds = ms / 1e3;
+  if (seconds < 60) return `${seconds < 10 ? seconds.toFixed(1) : Math.round(seconds)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const rest = Math.round(seconds % 60);
+  if (minutes < 60) return `${minutes}m ${rest}s`;
+  const hours = Math.floor(minutes / 60);
+  return `${hours}h ${minutes % 60}m`;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB"];
+  let value = bytes / 1024;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit++;
+  }
+  return `${value < 10 ? value.toFixed(1) : Math.round(value)} ${units[unit]}`;
+}
+function shortId(id, length = 8) {
+  if (!id) return "";
+  return id.length > length ? id.slice(0, length) : id;
+}
+function truncate(value, width) {
+  if (visibleLength(value) <= width) return value;
+  if (width <= 1) return "\u2026";
+  let result = "";
+  let used = 0;
+  for (const char of stripAnsi(value)) {
+    if (used + 1 > width - 1) break;
+    result += char;
+    used += 1;
+  }
+  return result + "\u2026";
+}
+var ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+function stripAnsi(value) {
+  return value.replace(ANSI_PATTERN, "");
+}
+function visibleLength(value) {
+  return [...stripAnsi(value)].length;
+}
+function pad(value, width, align = "left") {
+  const gap = Math.max(0, width - visibleLength(value));
+  return align === "right" ? " ".repeat(gap) + value : value + " ".repeat(gap);
+}
+function renderTable(rows, columns, options = {}) {
+  const indent = options.indent ?? "  ";
+  const terminalWidth = process.stdout.columns || 120;
+  const cells = rows.map(
+    (row) => columns.map((column) => {
+      const value = column.cell(row) ?? "";
+      const width = column.maxWidth ?? Math.max(20, Math.floor(terminalWidth / 2));
+      return truncate(value, width);
+    })
+  );
+  const widths = columns.map(
+    (column, index) => Math.max(visibleLength(column.header), ...cells.map((cell) => visibleLength(cell[index] ?? "")))
+  );
+  const lines = [];
+  lines.push(
+    indent + columns.map((column, index) => c.dim(pad(column.header.toUpperCase(), widths[index] ?? 0, column.align))).join("  ")
+  );
+  for (const row of cells) {
+    lines.push(indent + row.map((cell, index) => pad(cell, widths[index] ?? 0, columns[index]?.align)).join("  "));
+  }
+  return lines.join("\n");
+}
+function printTable(rows, columns, options) {
+  out(renderTable(rows, columns, options));
+}
+function renderDetails(pairs, options = {}) {
+  const indent = options.indent ?? "  ";
+  const visible = pairs.filter(([, value]) => value !== void 0 && value !== null && value !== "");
+  const width = Math.max(...visible.map(([label]) => label.length), 0);
+  return visible.map(([label, value]) => `${indent}${c.dim(label.padEnd(width))}  ${value}`).join("\n");
+}
+function printDetails(pairs, options) {
+  out(renderDetails(pairs, options));
+}
+function heading(text3) {
+  out(c.bold(text3));
+}
+function link(url) {
+  return c.cyan(c.underline(url));
+}
+function maskSecret(value) {
+  if (value.length <= 6) return "\u2022\u2022\u2022\u2022\u2022\u2022";
+  return `${value.slice(0, 3)}${"\u2022".repeat(Math.min(12, value.length - 4))}${value.slice(-2)}`;
+}
+function brand() {
+  return `${c.accent("\u2601")} ${c.bold("Light Cloud")}`;
+}
+
+// src/lib/ui/prompts.ts
+import * as clack from "@clack/prompts";
+function guard(value) {
+  if (clack.isCancel(value)) throw new CancelledError();
+  return value;
+}
+function intro2(title) {
+  if (!isInteractive()) return;
+  clack.intro(title);
+}
+function outro2(message) {
+  if (isJson()) return;
+  if (!isInteractive()) {
+    out(message);
+    return;
+  }
+  clack.outro(message);
+}
+function note2(message, title) {
+  if (isJson()) return;
+  if (!isInteractive()) {
+    if (title) out(c.bold(title));
+    out(message);
+    return;
+  }
+  clack.note(message, title);
+}
+function logStep(message) {
+  if (isJson()) return;
+  if (!isInteractive()) {
+    out(message);
+    return;
+  }
+  clack.log.step(message);
+}
+async function select2(message, options, config) {
+  if (!isInteractive()) {
+    throw new CliError(`${message} \u2014 no terminal to ask in.`, {
+      hint: `Pass ${config.flag} to choose without a prompt.`,
+      exitCode: EXIT.USAGE,
+      code: "NON_INTERACTIVE"
+    });
+  }
+  if (options.length === 0) {
+    throw new CliError(`${message} \u2014 nothing to choose from.`, { exitCode: EXIT.NOT_FOUND });
+  }
+  const value = await clack.select({
+    message,
+    options: options.map((option) => ({ value: option.value, label: option.label, hint: option.hint })),
+    initialValue: config.initialValue,
+    maxItems: 12
+  });
+  return guard(value);
+}
+async function confirm2(message, config) {
+  if (config.yes) return true;
+  if (!isInteractive()) {
+    throw new CliError(`${message} \u2014 no terminal to confirm in.`, {
+      hint: `Pass ${config.flag ?? "--yes"} to confirm without a prompt.`,
+      exitCode: EXIT.USAGE,
+      code: "NON_INTERACTIVE"
+    });
+  }
+  const value = await clack.confirm({ message, initialValue: config.initialValue ?? false });
+  return guard(value);
+}
+async function text2(message, config) {
+  if (!isInteractive()) {
+    throw new CliError(`${message} \u2014 no terminal to ask in.`, {
+      hint: `Pass ${config.flag} to provide the value.`,
+      exitCode: EXIT.USAGE,
+      code: "NON_INTERACTIVE"
+    });
+  }
+  const value = await clack.text({
+    message,
+    placeholder: config.placeholder,
+    initialValue: config.initialValue,
+    validate: config.validate ? (input) => {
+      const result = config.validate?.(String(input ?? ""));
+      return result ? result : void 0;
+    } : void 0
+  });
+  return guard(value);
+}
+function spinner2() {
+  if (isInteractive()) {
+    const s = clack.spinner();
+    return {
+      start: (message) => s.start(message),
+      message: (message) => s.message(message),
+      stop: (message, code) => {
+        if (code === 1) s.error(message);
+        else if (code === 2) s.cancel(message);
+        else s.stop(message);
+      }
+    };
+  }
+  let current = "";
+  return {
+    start: (message) => {
+      current = message;
+      if (!isJson()) out(`${c.dim("\u2026")} ${message}`);
+    },
+    message: (message) => {
+      if (message !== current) {
+        current = message;
+        if (!isJson()) out(`${c.dim("\u2026")} ${message}`);
+      }
+    },
+    stop: (message, code) => {
+      if (isJson() || !message) return;
+      const glyph = code === 1 ? c.red("\u2716") : code === 2 ? c.yellow("\u25B2") : c.green("\u2714");
+      out(`${glyph} ${message}`);
+    }
+  };
+}
+
+// src/lib/auth/credentials.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var CONFIG_DIR = path.join(os.homedir(), ".lightcloud");
+var CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+function credentialsPath() {
+  return CREDENTIALS_FILE;
+}
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+function readCredentials() {
+  try {
+    if (!fs.existsSync(CREDENTIALS_FILE)) return {};
+    const parsed = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeCredentials(credentials) {
+  ensureConfigDir();
+  const clean = {};
+  for (const [key, value] of Object.entries(credentials)) {
+    if (value !== void 0 && value !== null && value !== "") {
+      clean[key] = value;
+    }
+  }
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(clean, null, 2) + "\n", {
+    mode: 384
+  });
+}
+function updateCredentials(patch) {
+  writeCredentials({ ...readCredentials(), ...patch });
+}
+function clearCredentials() {
+  try {
+    if (fs.existsSync(CREDENTIALS_FILE)) fs.unlinkSync(CREDENTIALS_FILE);
+  } catch {
+  }
+}
+function resolveAuth() {
+  const fromEnv = process.env.LIGHT_CLOUD_API_KEY?.trim();
+  if (fromEnv) return { source: "env-api-key", token: fromEnv };
+  const stored = readCredentials();
+  if (stored.apiKey) return { source: "stored-api-key", token: stored.apiKey };
+  if (stored.accessToken) return { source: "session", token: stored.accessToken };
+  return { source: "none", token: null };
+}
+function isApiKey(token) {
+  return typeof token === "string" && token.startsWith("lc_");
+}
+
+// src/lib/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function cliVersion() {
+  try {
+    const pkg = require2("../package.json");
+    if (pkg.version) return pkg.version;
+  } catch {
+  }
+  try {
+    const pkg = require2("../../package.json");
+    if (pkg.version) return pkg.version;
+  } catch {
+  }
+  return "0.0.0";
+}
+var USER_AGENT = `light-cloud-cli/${cliVersion()} (${process.platform}; node ${process.versions.node})`;
+
+// src/lib/api/client.ts
+var NEXT_STEP_HINTS = {
+  "choose-plan": "Change plan with `lc billing plans` then `lc billing plan use <id>`.",
+  "add-payment-method": "Add a card with `lc billing card add`."
+};
+var ApiClient = class {
+  endpoints;
+  refreshing = null;
+  constructor(endpoints) {
+    this.endpoints = endpoints;
+  }
+  authSource() {
+    return resolveAuth().source;
+  }
+  /** True when a credential is present. Whether it still works is for the API to say. */
+  hasCredentials() {
+    return resolveAuth().token !== null;
+  }
+  usingApiKey() {
+    return isApiKey(resolveAuth().token);
+  }
+  async get(path10, options = {}) {
+    return this.json("GET", path10, options);
+  }
+  async post(path10, body, options = {}) {
+    return this.json("POST", path10, { ...options, body });
+  }
+  async put(path10, body, options = {}) {
+    return this.json("PUT", path10, { ...options, body });
+  }
+  async delete(path10, body, options = {}) {
+    return this.json("DELETE", path10, { ...options, body });
+  }
+  /**
+   * A raw response for streaming bodies (SSE log tails, database dumps).
+   * The caller owns the body; errors are still raised as ApiError.
+   */
+  async stream(path10, options = {}) {
+    const { method = "GET", ...rest } = options;
+    const response = await this.send(method, path10, {
+      ...rest,
+      headers: { Accept: "text/event-stream, application/octet-stream, */*", ...rest.headers }
+    });
+    if (!response.ok) throw await this.toApiError(response);
+    return response;
+  }
+  async json(method, path10, options) {
+    const response = await this.send(method, path10, options);
+    if (!response.ok) throw await this.toApiError(response);
+    if (response.status === 204) return void 0;
+    const text3 = await response.text();
+    if (!text3) return void 0;
+    try {
+      return JSON.parse(text3);
+    } catch {
+      throw new CliError(`The API returned something that is not JSON (${response.status}).`, {
+        hint: `Check that ${this.endpoints.apiUrl} is a Light Cloud API URL.`
+      });
+    }
+  }
+  async send(method, path10, options, retried = false) {
+    const url = this.buildUrl(path10, options.query);
+    const headers = {
+      Accept: "application/json",
+      "User-Agent": USER_AGENT,
+      "X-Client-Type": "cli",
+      ...options.headers
+    };
+    if (options.body !== void 0) headers["Content-Type"] = "application/json";
+    if (!options.anonymous) {
+      const auth = resolveAuth();
+      if (!auth.token) throw notLoggedIn();
+      headers.Authorization = `Bearer ${auth.token}`;
+    }
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers,
+        body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
+        signal: options.signal
+      });
+    } catch (error) {
+      if (options.signal?.aborted) throw error;
+      const reason = error instanceof Error ? error.cause?.message || error.message : String(error);
+      throw new CliError(`Could not reach ${this.endpoints.apiUrl} (${reason}).`, {
+        hint: "Check your network connection, or set --api-url if you use a different endpoint.",
+        code: "NETWORK",
+        cause: error
+      });
+    }
+    if (response.status === 401 && !options.anonymous && !retried && !this.usingApiKey()) {
+      const refreshed = await this.refreshSession();
+      if (refreshed) return this.send(method, path10, options, true);
+    }
+    return response;
+  }
+  buildUrl(path10, query) {
+    const url = new URL(path10.startsWith("http") ? path10 : `${this.endpoints.apiUrl}${path10}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0 && value !== "") url.searchParams.set(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  async refreshSession() {
+    if (!this.refreshing) {
+      this.refreshing = this.doRefresh().finally(() => {
+        this.refreshing = null;
+      });
+    }
+    return this.refreshing;
+  }
+  async doRefresh() {
+    const { refreshToken } = readCredentials();
+    if (!refreshToken) return false;
+    try {
+      const response = await fetch(`${this.endpoints.apiUrl}/api/auth/refresh`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": USER_AGENT,
+          "X-Client-Type": "cli"
+        },
+        body: JSON.stringify({ refreshToken })
+      });
+      if (!response.ok) return false;
+      const data = await response.json();
+      const accessToken = data.token || data.accessToken;
+      if (!accessToken) return false;
+      updateCredentials({ accessToken, refreshToken: data.refreshToken || refreshToken });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async toApiError(response) {
+    let body = {};
+    try {
+      body = await response.json();
+    } catch {
+    }
+    const message = body.message || body.error || response.statusText || `HTTP ${response.status}`;
+    const code = body.code || `HTTP_${response.status}`;
+    if (response.status === 401) {
+      const hint = this.usingApiKey() ? "The API key was rejected. It may be revoked, expired, or from another environment." : "Your session has expired. Run `lc login` to sign in again.";
+      return new ApiError(401, code, "Authentication failed.", hint);
+    }
+    const nextStep = body.nextStep ? NEXT_STEP_HINTS[body.nextStep] : void 0;
+    if (response.status === 402) {
+      return new ApiError(402, code, message, nextStep ?? "This needs a paid plan. Manage plans with `lc billing plans`.");
+    }
+    if (response.status === 403) {
+      return new ApiError(
+        403,
+        code,
+        message,
+        nextStep ?? "Your role in this workspace does not allow it, or the resource belongs to another workspace."
+      );
+    }
+    if (response.status === 429) {
+      return new ApiError(429, code, "Too many requests.", "Wait a moment and try again.");
+    }
+    return new ApiError(response.status, code, message, nextStep);
+  }
+};
+
+// src/lib/api/light-cloud.ts
+var LightCloudApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  // ---- account -------------------------------------------------------------
+  async profile() {
+    const data = await this.client.get("/api/auth/profile");
+    return "user" in data ? data.user : data;
+  }
+  async platformConfig() {
+    return this.client.get("/api/config/platform");
+  }
+  // ---- applications --------------------------------------------------------
+  async listApplications(organisationId, filter, limit = 100) {
+    const page = await this.client.post("/api/applications", {
+      targetOrganisationId: organisationId,
+      page: 1,
+      limit,
+      filter: filter || void 0
+    });
+    return page.items;
+  }
+  async getApplication(organisationId, applicationId) {
+    return this.client.post("/api/applications/get", {
+      targetOrganisationId: organisationId,
+      applicationId
+    });
+  }
+  async applicationStatus(organisationId, applicationId) {
+    return this.client.post("/api/applications/status", {
+      targetOrganisationId: organisationId,
+      applicationId
+    });
+  }
+  async createApplication(request) {
+    return this.client.post("/api/applications/create", request);
+  }
+  async createFromUpload(request) {
+    return this.client.post("/api/applications/create-from-upload", request);
+  }
+  async deployApplication(organisationId, applicationId, uploadId) {
+    return this.client.post("/api/applications/deploy", {
+      targetOrganisationId: organisationId,
+      applicationId,
+      uploadId
+    });
+  }
+  async deleteApplication(organisationId, applicationId) {
+    await this.client.post("/api/applications/delete", { targetOrganisationId: organisationId, applicationId });
+  }
+  async renameApplication(organisationId, applicationId, name) {
+    return this.client.post("/api/applications/rename", {
+      targetOrganisationId: organisationId,
+      applicationId,
+      name
+    });
+  }
+  async detectFramework(input) {
+    return this.client.post("/api/applications/detect-framework", {
+      targetOrganisationId: input.organisationId,
+      organisationId: input.organisationId,
+      owner: input.owner,
+      repo: input.repo,
+      branch: input.branch,
+      rootDirectory: input.rootDirectory,
+      gitProvider: input.gitProvider
+    });
+  }
+  // ---- environments --------------------------------------------------------
+  async listEnvironments(organisationId, applicationId) {
+    return this.client.post("/api/environments", {
+      targetOrganisationId: organisationId,
+      applicationId
+    });
+  }
+  async getEnvironment(organisationId, environmentId) {
+    return this.client.post("/api/environments/get", {
+      targetOrganisationId: organisationId,
+      environmentId
+    });
+  }
+  async environmentStatus(organisationId, environmentId) {
+    return this.client.post("/api/environments/status", {
+      targetOrganisationId: organisationId,
+      environmentId
+    });
+  }
+  async createEnvironment(request) {
+    return this.client.post("/api/environments/create", request);
+  }
+  async updateEnvironment(request) {
+    return this.client.post("/api/environments/update", request);
+  }
+  async deployEnvironment(organisationId, environmentId, uploadId) {
+    return this.client.post("/api/environments/deploy", {
+      targetOrganisationId: organisationId,
+      environmentId,
+      uploadId
+    });
+  }
+  async deleteEnvironment(organisationId, environmentId) {
+    await this.client.post("/api/environments/delete", { targetOrganisationId: organisationId, environmentId });
+  }
+  async scaleEnvironment(organisationId, environmentId, scale) {
+    return this.client.post("/api/environments/scale", {
+      targetOrganisationId: organisationId,
+      environmentId,
+      ...scale
+    });
+  }
+  async fetchLogs(organisationId, environmentId, filters) {
+    return this.client.post("/api/environments/logs", {
+      targetOrganisationId: organisationId,
+      environmentId,
+      filters
+    });
+  }
+  /** Server-sent events; the caller reads `response.body`. */
+  async streamLogs(organisationId, environmentId, severity, signal) {
+    return this.client.stream(`/api/environments/${organisationId}/${environmentId}/logs/stream`, {
+      query: { severity: severity?.length ? severity.join(",") : void 0 },
+      signal
+    });
+  }
+  // ---- domains -------------------------------------------------------------
+  async addDomain(organisationId, environmentId, domain) {
+    return this.client.post("/api/environments/add-domain", {
+      targetOrganisationId: organisationId,
+      environmentId,
+      domain
+    });
+  }
+  async checkDomain(organisationId, environmentId) {
+    return this.client.post("/api/environments/check-domain", {
+      targetOrganisationId: organisationId,
+      environmentId
+    });
+  }
+  async retryDomain(organisationId, environmentId) {
+    return this.client.post("/api/environments/retry-domain", {
+      targetOrganisationId: organisationId,
+      environmentId
+    });
+  }
+  async removeDomain(organisationId, environmentId) {
+    return this.client.post("/api/applications/remove-domain", {
+      targetOrganisationId: organisationId,
+      environmentId
+    });
+  }
+  // ---- deployments ---------------------------------------------------------
+  async listDeployments(organisationId, environmentId, limit = 20, offset = 0) {
+    return this.client.post("/api/deployments", {
+      targetOrganisationId: organisationId,
+      environmentId,
+      limit,
+      offset
+    });
+  }
+  async getDeployment(organisationId, deploymentId) {
+    return this.client.post("/api/deployments/get", {
+      targetOrganisationId: organisationId,
+      deploymentId
+    });
+  }
+  async rollback(organisationId, environmentId, deploymentId) {
+    return this.client.post("/api/deployments/rollback", {
+      targetOrganisationId: organisationId,
+      environmentId,
+      deploymentId
+    });
+  }
+  // ---- databases -----------------------------------------------------------
+  async listDatabases(organisationId) {
+    const data = await this.client.post("/api/databases", {
+      targetOrganisationId: organisationId
+    });
+    return data.databases;
+  }
+  async getDatabase(organisationId, databaseId) {
+    return this.client.post("/api/databases/get", {
+      targetOrganisationId: organisationId,
+      databaseId
+    });
+  }
+  async databaseStatus(organisationId, databaseId) {
+    return this.client.post("/api/databases/status", {
+      targetOrganisationId: organisationId,
+      databaseId
+    });
+  }
+  async createDatabase(request) {
+    return this.client.post("/api/databases/create", request);
+  }
+  async deleteDatabase(organisationId, databaseId) {
+    await this.client.post("/api/databases/delete", { targetOrganisationId: organisationId, databaseId });
+  }
+  async connectionDetails(organisationId, databaseId) {
+    return this.client.post("/api/databases/connection-string", {
+      targetOrganisationId: organisationId,
+      databaseId
+    });
+  }
+  async rotatePassword(organisationId, databaseId, newPassword) {
+    return this.client.post("/api/databases/rotate-password", {
+      targetOrganisationId: organisationId,
+      databaseId,
+      newPassword
+    });
+  }
+  /** A gzip stream of the dump; the caller writes `response.body` to disk. */
+  async dumpDatabase(organisationId, databaseId) {
+    return this.client.stream("/api/databases/dump", {
+      method: "POST",
+      body: { targetOrganisationId: organisationId, databaseId }
+    });
+  }
+  // ---- git providers -------------------------------------------------------
+  // ---- Billing ----
+  async ownerBillingSummary() {
+    return this.client.post("/api/billing/owner-summary", {});
+  }
+  async plans(organisationId) {
+    return this.client.post("/api/billing/plans", { targetOrganisationId: organisationId });
+  }
+  async choosePlan(organisationId, planId) {
+    return this.client.post("/api/billing/choose-plan", { targetOrganisationId: organisationId, planId });
+  }
+  async createCheckoutSession(organisationId) {
+    return this.client.post("/api/billing/checkout-session", { targetOrganisationId: organisationId, client: "cli" });
+  }
+  async checkoutSessionStatus(organisationId, sessionId) {
+    return this.client.post("/api/billing/checkout-session/status", { targetOrganisationId: organisationId, sessionId });
+  }
+  async removePaymentMethod(organisationId) {
+    await this.client.post("/api/billing/payment-method/remove", { targetOrganisationId: organisationId });
+  }
+  async listRepositories(organisationId) {
+    return this.client.get(`/api/github-app/organisation/${organisationId}/repositories`);
+  }
+  async listBranches(organisationId, owner, repo) {
+    return this.client.get(
+      `/api/github-app/organisation/${organisationId}/repositories/${owner}/${repo}/branches`
+    );
+  }
+  async githubInstallationStatus(organisationId, owner, repo) {
+    return this.client.get("/api/github-app/installation-status", {
+      query: { organisationId, owner, repo }
+    });
+  }
+  async githubInstallUrl() {
+    return this.client.get("/api/github-app/install");
+  }
+  // ---- uploads -------------------------------------------------------------
+  async requestUpload(organisationId, fileSize) {
+    return this.client.post("/api/upload/request-url", {
+      targetOrganisationId: organisationId,
+      fileName: "source.zip",
+      contentType: "application/zip",
+      fileSize
+    });
+  }
+  async completeUpload(organisationId, uploadId, detection) {
+    return this.client.post("/api/upload/complete", {
+      targetOrganisationId: organisationId,
+      uploadId,
+      ...detection
+    });
+  }
+};
+
+// src/lib/config/global-config.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var CONFIG_FILE = path2.join(CONFIG_DIR, "config.json");
+var DEFAULT_API_URL = "https://api.light-cloud.com";
+var DEFAULT_CONSOLE_URL = "https://console.light-cloud.com";
+function globalConfigPath() {
+  return CONFIG_FILE;
+}
+function readGlobalConfig() {
+  try {
+    if (!fs2.existsSync(CONFIG_FILE)) return {};
+    const parsed = JSON.parse(fs2.readFileSync(CONFIG_FILE, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeGlobalConfig(config) {
+  if (!fs2.existsSync(CONFIG_DIR)) {
+    fs2.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+  const clean = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (value !== void 0 && value !== null && value !== "") clean[key] = value;
+  }
+  fs2.writeFileSync(CONFIG_FILE, JSON.stringify(clean, null, 2) + "\n", { mode: 384 });
+}
+function updateGlobalConfig(patch) {
+  const next = { ...readGlobalConfig(), ...patch };
+  writeGlobalConfig(next);
+  return next;
+}
+var trimSlash = (url) => url.replace(/\/+$/, "");
+function resolveEndpoints(overrides = {}) {
+  const config = readGlobalConfig();
+  const apiUrl = trimSlash(
+    overrides.apiUrl || process.env.LIGHT_CLOUD_API_URL || config.apiUrl || DEFAULT_API_URL
+  );
+  const consoleUrl = trimSlash(
+    process.env.LIGHT_CLOUD_CONSOLE_URL || config.consoleUrl || inferConsoleUrl(apiUrl)
+  );
+  return { apiUrl, consoleUrl, socketUrl: apiUrl.replace(/\/api$/, "") };
+}
+function inferConsoleUrl(apiUrl) {
+  try {
+    const parsed = new URL(apiUrl);
+    if (parsed.hostname.startsWith("api.")) {
+      parsed.hostname = "console." + parsed.hostname.slice("api.".length);
+      parsed.pathname = "/";
+      return trimSlash(parsed.toString());
+    }
+    if (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1") {
+      return "http://localhost:5173";
+    }
+  } catch {
+  }
+  return DEFAULT_CONSOLE_URL;
+}
+
+// src/lib/config/project-config.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var PROJECT_CONFIG_FILENAME = ".lightcloud";
+function findProjectConfig(startDir = process.cwd()) {
+  let dir = path3.resolve(startDir);
+  for (; ; ) {
+    const candidate = path3.join(dir, PROJECT_CONFIG_FILENAME);
+    const config = readProjectConfigFile(candidate);
+    if (config) return { config, path: candidate, directory: dir };
+    if (fs3.existsSync(path3.join(dir, ".git"))) return null;
+    const parent = path3.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function readProjectConfig(directory = process.cwd()) {
+  return readProjectConfigFile(path3.join(directory, PROJECT_CONFIG_FILENAME));
+}
+function readProjectConfigFile(file) {
+  try {
+    if (!fs3.existsSync(file)) return null;
+    const parsed = JSON.parse(fs3.readFileSync(file, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function writeProjectConfig(config, directory = process.cwd()) {
+  const file = path3.join(directory, PROJECT_CONFIG_FILENAME);
+  const merged = { ...readProjectConfig(directory) ?? {}, ...config };
+  for (const key of Object.keys(merged)) {
+    if (merged[key] === void 0) delete merged[key];
+  }
+  fs3.writeFileSync(file, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  return file;
+}
+function deleteProjectConfig(directory = process.cwd()) {
+  const file = path3.join(directory, PROJECT_CONFIG_FILENAME);
+  if (!fs3.existsSync(file)) return false;
+  fs3.unlinkSync(file);
+  return true;
+}
+
+// src/lib/context.ts
+var API_KEY_ORG_PLACEHOLDER = "api-key";
+var looksLikeId = (value) => /^[a-z0-9]{20,}$/i.test(value) || /^[0-9a-f-]{36}$/i.test(value);
+var Context = class {
+  api;
+  endpoints;
+  yes;
+  json;
+  cwd;
+  project;
+  orgFlag;
+  profileCache = null;
+  orgCache = null;
+  constructor(options) {
+    this.endpoints = resolveEndpoints({ apiUrl: options.apiUrl });
+    this.api = new LightCloudApi(new ApiClient(this.endpoints));
+    this.yes = Boolean(options.yes);
+    this.json = Boolean(options.json);
+    this.cwd = options.cwd ?? process.cwd();
+    this.project = findProjectConfig(this.cwd);
+    this.orgFlag = options.org?.trim() || void 0;
+  }
+  get usingApiKey() {
+    return isApiKey(resolveAuth().token);
+  }
+  requireAuth() {
+    if (!this.api.client.hasCredentials()) throw notLoggedIn();
+  }
+  async profile() {
+    if (this.profileCache) return this.profileCache;
+    this.requireAuth();
+    this.profileCache = await this.api.profile();
+    return this.profileCache;
+  }
+  // ---- workspace -----------------------------------------------------------
+  async resolveOrg(options = {}) {
+    if (this.orgCache) return this.orgCache;
+    this.requireAuth();
+    if (this.usingApiKey) {
+      this.orgCache = await this.resolveOrgForApiKey();
+      return this.orgCache;
+    }
+    const profile = await this.profile();
+    const orgs = profile.organisations ?? [];
+    if (this.orgFlag) {
+      const match = findOrg(orgs, this.orgFlag);
+      if (!match) {
+        throw new CliError(`No workspace called "${this.orgFlag}" on this account.`, {
+          hint: `Your workspaces: ${orgs.map((org2) => org2.name).join(", ") || "none"}. Run \`lc orgs\` to list them.`,
+          exitCode: EXIT.NOT_FOUND
+        });
+      }
+      this.orgCache = toRef(match);
+      return this.orgCache;
+    }
+    const linked = this.project?.config.organisationId;
+    if (linked) {
+      const match = orgs.find((org2) => org2.id === linked);
+      if (match) {
+        this.orgCache = toRef(match);
+        return this.orgCache;
+      }
+      log.warn(`The linked workspace in ${c.bold(".lightcloud")} is not one you belong to; ignoring it.`);
+    }
+    const saved = readGlobalConfig().defaultOrganisationId;
+    if (saved) {
+      const match = orgs.find((org2) => org2.id === saved);
+      if (match) {
+        this.orgCache = toRef(match);
+        return this.orgCache;
+      }
+    }
+    if (orgs.length === 1) {
+      this.orgCache = toRef(orgs[0]);
+      return this.orgCache;
+    }
+    if (orgs.length === 0) {
+      throw new CliError("This account has no workspaces yet.", {
+        hint: `Create one in the console: ${this.endpoints.consoleUrl}`,
+        exitCode: EXIT.NOT_FOUND
+      });
+    }
+    if (options.interactive === false || !isInteractive()) {
+      throw new CliError("Several workspaces on this account; which one?", {
+        hint: `Pass --org <name>, or set a default with \`lc org use <name>\`. Workspaces: ${orgs.map((org2) => org2.name).join(", ")}.`,
+        exitCode: EXIT.USAGE
+      });
+    }
+    const chosen = await select2(
+      "Which workspace?",
+      orgs.map((org2) => ({ value: org2.id, label: org2.name, hint: org2.role })),
+      { flag: "--org <name>" }
+    );
+    const org = orgs.find((entry) => entry.id === chosen);
+    const remember = await confirm2(`Use ${c.bold(org.name)} by default from now on?`, { yes: false, initialValue: true });
+    if (remember) updateGlobalConfig({ defaultOrganisationId: org.id, defaultOrganisationName: org.name });
+    this.orgCache = toRef(org);
+    return this.orgCache;
+  }
+  /**
+   * An API key is bound to one workspace and the profile endpoint does not
+   * serve keys, so the id comes from the flag or the link file — or from the
+   * first resource the key can see, since every resource names its workspace.
+   */
+  async resolveOrgForApiKey() {
+    const known = this.orgFlag || this.project?.config.organisationId || readGlobalConfig().defaultOrganisationId;
+    if (known) return { id: known };
+    try {
+      const apps = await this.api.listApplications(API_KEY_ORG_PLACEHOLDER, void 0, 1);
+      if (apps[0]) return { id: apps[0].organisation_id };
+      const dbs = await this.api.listDatabases(API_KEY_ORG_PLACEHOLDER);
+      if (dbs[0]) return { id: dbs[0].organisation_id };
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 403) {
+        throw new CliError("The API key does not belong to the workspace this folder is linked to.", {
+          hint: "Use a key created in that workspace, or pass --org <id>.",
+          exitCode: EXIT.AUTH
+        });
+      }
+      throw error;
+    }
+    return { id: API_KEY_ORG_PLACEHOLDER };
+  }
+  // ---- applications --------------------------------------------------------
+  async resolveApp(ref, options = {}) {
+    const org = await this.resolveOrg();
+    if (ref) {
+      if (looksLikeId(ref)) {
+        try {
+          return await this.api.getApplication(org.id, ref);
+        } catch (error) {
+          if (!(error instanceof ApiError && (error.status === 404 || error.status === 400))) throw error;
+        }
+      }
+      const apps2 = await this.api.listApplications(org.id, ref);
+      const match = pickByName(apps2, ref, (app) => [app.name, app.slug]);
+      if (match.kind === "one") return this.api.getApplication(org.id, match.item.id);
+      if (match.kind === "many") {
+        throw new CliError(`"${ref}" matches several apps: ${match.items.map((app) => app.name).join(", ")}.`, {
+          hint: "Use the full name or the id.",
+          exitCode: EXIT.USAGE
+        });
+      }
+      throw new CliError(`No app called "${ref}" in ${org.name ?? "this workspace"}.`, {
+        hint: "Run `lc apps` to list them.",
+        exitCode: EXIT.NOT_FOUND
+      });
+    }
+    const linked = this.project?.config.applicationId;
+    if (linked) {
+      try {
+        return await this.api.getApplication(org.id, linked);
+      } catch (error) {
+        if (error instanceof ApiError && (error.status === 404 || error.status === 400)) {
+          log.warn(`The app linked in ${c.bold(".lightcloud")} no longer exists.`);
+        } else {
+          throw error;
+        }
+      }
+    }
+    const apps = await this.api.listApplications(org.id);
+    if (apps.length === 0) {
+      throw new CliError(`No apps in ${org.name ?? "this workspace"} yet.`, {
+        hint: "Create one with `lc init` in a project folder.",
+        exitCode: EXIT.NOT_FOUND
+      });
+    }
+    if (options.interactive === false || !isInteractive()) {
+      throw new CliError("Which app?", {
+        hint: "Pass --app <name>, or link this folder with `lc init`.",
+        exitCode: EXIT.USAGE
+      });
+    }
+    const chosen = await select2(
+      "Which app?",
+      apps.map((app) => ({ value: app.id, label: app.name, hint: `${app.framework} \xB7 ${app.status}` })),
+      { flag: "--app <name>" }
+    );
+    return this.api.getApplication(org.id, chosen);
+  }
+  // ---- environments --------------------------------------------------------
+  async resolveEnv(app, ref, options = {}) {
+    const org = await this.resolveOrg();
+    const envs = app.environments ?? await this.api.listEnvironments(org.id, app.id);
+    if (ref) {
+      const byId = envs.find((env) => env.id === ref);
+      if (byId) return byId;
+      const match = pickByName(envs, ref, (env) => [env.name, env.github_branch]);
+      if (match.kind === "one") return match.item;
+      if (match.kind === "many") {
+        throw new CliError(`"${ref}" matches several environments: ${match.items.map((env) => env.name).join(", ")}.`, {
+          exitCode: EXIT.USAGE
+        });
+      }
+      throw new CliError(`No environment "${ref}" on ${app.name}.`, {
+        hint: `Environments: ${envs.map((env) => env.name).join(", ") || "none"}.`,
+        exitCode: EXIT.NOT_FOUND
+      });
+    }
+    const linked = this.project?.config.environmentId;
+    if (linked && this.project?.config.applicationId === app.id) {
+      const match = envs.find((env) => env.id === linked);
+      if (match) return match;
+    }
+    if (envs.length === 0) {
+      throw new CliError(`${app.name} has no environments.`, {
+        hint: "Create one with `lc env create <name> --branch <branch>`.",
+        exitCode: EXIT.NOT_FOUND
+      });
+    }
+    const production = envs.find((env) => env.is_production);
+    if (production) return production;
+    if (envs.length === 1) return envs[0];
+    if (options.interactive === false || !isInteractive()) {
+      throw new CliError("Which environment?", {
+        hint: `Pass --env <name>. Environments: ${envs.map((env) => env.name).join(", ")}.`,
+        exitCode: EXIT.USAGE
+      });
+    }
+    const chosen = await select2(
+      "Which environment?",
+      envs.map((env) => ({ value: env.id, label: env.name, hint: `${env.github_branch} \xB7 ${env.status}` })),
+      { flag: "--env <name>" }
+    );
+    return envs.find((env) => env.id === chosen);
+  }
+  // ---- databases -----------------------------------------------------------
+  async resolveDb(ref, options = {}) {
+    const org = await this.resolveOrg();
+    const dbs = await this.api.listDatabases(org.id);
+    if (ref) {
+      const byId = dbs.find((db) => db.id === ref);
+      if (byId) return byId;
+      const match = pickByName(dbs, ref, (db) => [db.name, db.slug, db.database_name ?? ""]);
+      if (match.kind === "one") return match.item;
+      if (match.kind === "many") {
+        throw new CliError(`"${ref}" matches several databases: ${match.items.map((db) => db.name).join(", ")}.`, { exitCode: EXIT.USAGE });
+      }
+      throw new CliError(`No database called "${ref}".`, { hint: "Run `lc dbs` to list them.", exitCode: EXIT.NOT_FOUND });
+    }
+    if (dbs.length === 0) {
+      throw new CliError("No databases in this workspace yet.", { hint: "Create one with `lc db create`.", exitCode: EXIT.NOT_FOUND });
+    }
+    if (dbs.length === 1) return dbs[0];
+    if (options.interactive === false || !isInteractive()) {
+      throw new CliError("Which database?", { hint: "Pass the database name as an argument.", exitCode: EXIT.USAGE });
+    }
+    const chosen = await select2(
+      "Which database?",
+      dbs.map((db) => ({ value: db.id, label: db.name, hint: `${db.database_type} \xB7 ${db.tier} \xB7 ${db.status}` })),
+      { flag: "<name>" }
+    );
+    return dbs.find((db) => db.id === chosen);
+  }
+  // ---- links ---------------------------------------------------------------
+  consoleUrl(path10 = "") {
+    return `${this.endpoints.consoleUrl}${path10}`;
+  }
+  appConsoleUrl(app) {
+    return this.consoleUrl(`/applications/${app.id}`);
+  }
+  dbConsoleUrl(db) {
+    return this.consoleUrl(`/databases/${db.id}`);
+  }
+};
+function toRef(org) {
+  return { id: org.id, name: org.name, role: org.role };
+}
+function findOrg(orgs, ref) {
+  const needle = ref.trim().toLowerCase();
+  return orgs.find((org) => org.id === ref) ?? orgs.find((org) => org.name.toLowerCase() === needle) ?? (() => {
+    const partial = orgs.filter((org) => org.name.toLowerCase().includes(needle));
+    return partial.length === 1 ? partial[0] : void 0;
+  })();
+}
+function pickByName(items, ref, names) {
+  const needle = ref.trim().toLowerCase();
+  const exact = items.filter((item) => names(item).some((name) => name.toLowerCase() === needle));
+  if (exact.length === 1) return { kind: "one", item: exact[0] };
+  if (exact.length > 1) return { kind: "many", items: exact };
+  const prefix = items.filter((item) => names(item).some((name) => name.toLowerCase().startsWith(needle)));
+  if (prefix.length === 1) return { kind: "one", item: prefix[0] };
+  if (prefix.length > 1) return { kind: "many", items: prefix };
+  const partial = items.filter((item) => names(item).some((name) => name.toLowerCase().includes(needle)));
+  if (partial.length === 1) return { kind: "one", item: partial[0] };
+  if (partial.length > 1) return { kind: "many", items: partial };
+  return { kind: "none" };
+}
+
+// src/lib/realtime/socket.ts
+import { io } from "socket.io-client";
+function connectLive(socketUrl, token, options = {}) {
+  return new Promise((resolve6) => {
+    const socket = io(socketUrl, {
+      transports: ["websocket", "polling"],
+      auth: token ? { token } : void 0,
+      reconnection: true,
+      reconnectionAttempts: 5,
+      reconnectionDelay: 1e3,
+      timeout: options.timeoutMs ?? 8e3
+    });
+    const subscriptions = [];
+    let settled = false;
+    const connection = {
+      socket,
+      subscribe(kind, id) {
+        subscriptions.push({ kind, id });
+        if (socket.connected) socket.emit("subscribe", { type: kind, id });
+      },
+      onEvent(event, handler) {
+        socket.on(event, handler);
+        return () => socket.off(event, handler);
+      },
+      close() {
+        socket.removeAllListeners();
+        socket.disconnect();
+      }
+    };
+    socket.on("connect", () => {
+      for (const sub of subscriptions) socket.emit("subscribe", { type: sub.kind, id: sub.id });
+      if (!settled) {
+        settled = true;
+        resolve6(connection);
+      }
+    });
+    socket.on("connect_error", () => {
+      if (!settled) {
+        settled = true;
+        socket.disconnect();
+        resolve6(null);
+      }
+    });
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        socket.disconnect();
+        resolve6(null);
+      }
+    }, (options.timeoutMs ?? 8e3) + 500);
+    timer.unref();
+  });
+}
+
+// src/lib/realtime/watch.ts
+var TERMINAL = {
+  environment: /* @__PURE__ */ new Set(["deployed", "failed", "delete_failed", "deleted"]),
+  application: /* @__PURE__ */ new Set(["deployed", "failed", "delete_failed", "deleted", "healthy", "degraded"]),
+  database: /* @__PURE__ */ new Set(["ready", "failed", "delete_failed", "deleted"])
+};
+var SUCCESS = /* @__PURE__ */ new Set(["deployed", "ready", "healthy", "deleted"]);
+var StepRenderer = class {
+  constructor(silent) {
+    this.silent = silent;
+  }
+  silent;
+  printed = /* @__PURE__ */ new Map();
+  startedAt = /* @__PURE__ */ new Map();
+  spin = null;
+  activeIndex = null;
+  render(steps) {
+    if (this.silent || isJson() || !steps) return;
+    steps.forEach((step, index) => {
+      const previous = this.printed.get(index);
+      if (previous === step.status) return;
+      if (step.status === "started") {
+        this.startedAt.set(index, Date.parse(step.timestamp) || Date.now());
+        this.stopSpinner();
+        this.spin = spinner2();
+        this.spin.start(step.step + (step.message && step.message !== step.step ? c.dim(`  ${step.message}`) : ""));
+        this.activeIndex = index;
+      } else {
+        const began = this.startedAt.get(index);
+        const finished = Date.parse(step.timestamp) || Date.now();
+        const took = began ? c.dim(`  ${formatDuration(finished - began)}`) : "";
+        const line = step.status === "completed" ? `${step.step}${took}` : `${step.step}${step.message ? c.red(`  ${step.message}`) : ""}`;
+        if (this.activeIndex === index && this.spin) {
+          this.spin.stop(line, step.status === "completed" ? 0 : 1);
+          this.spin = null;
+          this.activeIndex = null;
+        } else {
+          out(`${step.status === "completed" ? c.green(sym.ok) : c.red(sym.fail)} ${line}`);
+        }
+      }
+      this.printed.set(index, step.status);
+    });
+  }
+  finish(message, ok) {
+    if (this.silent || isJson()) return;
+    if (this.spin) {
+      this.spin.stop(message, ok ? 0 : 1);
+      this.spin = null;
+    } else {
+      out(`${ok ? c.green(sym.ok) : c.red(sym.fail)} ${message}`);
+    }
+  }
+  stopSpinner() {
+    if (this.spin && this.activeIndex !== null) {
+      this.spin.stop(c.dim("\u2026"), 0);
+      this.spin = null;
+      this.activeIndex = null;
+    }
+  }
+};
+async function fetchStatus(api, target) {
+  switch (target.kind) {
+    case "environment":
+      return api.environmentStatus(target.organisationId, target.id);
+    case "application":
+      return api.applicationStatus(target.organisationId, target.id);
+    case "database":
+      return api.databaseStatus(target.organisationId, target.id);
+  }
+}
+async function watchResource(api, target, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 25 * 60 * 1e3;
+  const pollIntervalMs = options.pollIntervalMs ?? 4e3;
+  const startedAt = options.startedAt ?? Date.now();
+  const renderer = new StepRenderer(Boolean(options.silent));
+  const terminal = TERMINAL[target.kind];
+  let lastSeenAt = 0;
+  const live = await connectLive(api.client.endpoints.socketUrl, tokenForSocket());
+  if (live) live.subscribe(target.kind, target.id);
+  return new Promise((resolve6, reject) => {
+    let finished = false;
+    let pollTimer = null;
+    let polling = false;
+    const done = (update) => {
+      if (finished) return;
+      finished = true;
+      if (pollTimer) clearInterval(pollTimer);
+      clearTimeout(deadline);
+      live?.close();
+      const ok = SUCCESS.has(update.status);
+      resolve6({ status: update.status, update, ok, elapsedMs: Date.now() - startedAt });
+    };
+    const fail = (error) => {
+      if (finished) return;
+      finished = true;
+      if (pollTimer) clearInterval(pollTimer);
+      clearTimeout(deadline);
+      live?.close();
+      reject(error);
+    };
+    const apply = (update) => {
+      lastSeenAt = Date.now();
+      renderer.render(update.deployment_logs);
+      if (terminal.has(update.status)) done(update);
+    };
+    const deadline = setTimeout(() => {
+      fail(
+        new CliError(`Still running after ${formatDuration(timeoutMs)}; stopped waiting.`, {
+          hint: "The run continues on Light Cloud. Check it with `lc status` or in the console.",
+          exitCode: EXIT.FAILED
+        })
+      );
+    }, timeoutMs);
+    const eventName = `${target.kind}:update`;
+    live?.onEvent(eventName, (data) => {
+      const id = data.environmentId || data.databaseId || data.applicationId;
+      if (id && id !== target.id) return;
+      apply(data);
+    });
+    const poll = async (force = false) => {
+      if (polling || finished) return;
+      polling = true;
+      try {
+        if (force || !live || Date.now() - lastSeenAt > pollIntervalMs * 2) {
+          apply(await fetchStatus(api, target));
+        }
+      } catch (error) {
+        if (error instanceof CliError && error.exitCode === EXIT.AUTH) fail(error);
+      } finally {
+        polling = false;
+      }
+    };
+    void poll(true);
+    pollTimer = setInterval(() => void poll(), pollIntervalMs);
+  }).then((result) => {
+    const took = formatDuration(result.elapsedMs);
+    if (result.ok) {
+      const url = result.update.deployed_url || result.update.connection_host;
+      renderer.finish(`${verbFor(target.kind, true)} in ${took}${url ? `  ${c.cyan(url)}` : ""}`, true);
+    } else {
+      renderer.finish(`${verbFor(target.kind, false)} after ${took}${result.update.deployment_error ? `  ${c.red(result.update.deployment_error)}` : ""}`, false);
+    }
+    return result;
+  });
+}
+function verbFor(kind, ok) {
+  if (kind === "database") return ok ? "Database ready" : "Provisioning failed";
+  return ok ? "Deployed" : "Deployment failed";
+}
+function tokenForSocket() {
+  return resolveAuth().token;
+}
+
+// src/lib/upload/packager.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import archiver from "archiver";
+
+// src/lib/upload/excludes.ts
+var DEFAULT_EXCLUDES = [
+  ".git",
+  ".git/**",
+  ".svn",
+  ".svn/**",
+  ".hg",
+  ".hg/**",
+  "node_modules",
+  "node_modules/**",
+  "vendor",
+  "vendor/**",
+  "bower_components",
+  "bower_components/**",
+  "__pycache__",
+  "__pycache__/**",
+  "*.pyc",
+  "*.pyo",
+  "*.pyd",
+  ".Python",
+  "venv",
+  "venv/**",
+  ".venv",
+  ".venv/**",
+  "env",
+  "env/**",
+  ".env",
+  "pip-wheel-metadata",
+  "*.egg-info",
+  "*.egg-info/**",
+  "dist",
+  "dist/**",
+  "build",
+  "build/**",
+  "out",
+  "out/**",
+  ".next",
+  ".next/**",
+  ".nuxt",
+  ".nuxt/**",
+  ".svelte-kit",
+  ".svelte-kit/**",
+  ".cache",
+  ".cache/**",
+  ".parcel-cache",
+  ".parcel-cache/**",
+  ".turbo",
+  ".turbo/**",
+  ".idea",
+  ".idea/**",
+  ".vscode",
+  ".vscode/**",
+  "*.swp",
+  "*.swo",
+  "*~",
+  ".project",
+  ".classpath",
+  ".settings",
+  ".settings/**",
+  ".DS_Store",
+  "Thumbs.db",
+  "desktop.ini",
+  "*.log",
+  "logs",
+  "logs/**",
+  "npm-debug.log*",
+  "yarn-debug.log*",
+  "yarn-error.log*",
+  "coverage",
+  "coverage/**",
+  ".nyc_output",
+  ".nyc_output/**",
+  "htmlcov",
+  "htmlcov/**",
+  "tmp",
+  "tmp/**",
+  "temp",
+  "temp/**",
+  ".tmp",
+  ".tmp/**",
+  "*.zip",
+  "*.tar",
+  "*.tar.gz",
+  "*.tgz",
+  "*.rar",
+  "*.7z"
+];
+function parseGitignore(content) {
+  const patterns = [];
+  for (const raw of content.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || line.startsWith("!")) continue;
+    patterns.push(line);
+  }
+  return patterns;
+}
+function gitignoreToGlob(pattern) {
+  let normalized = pattern.replace(/^\//, "");
+  const patterns = [];
+  if (normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+    patterns.push(normalized, `${normalized}/**`);
+  } else {
+    patterns.push(normalized, `${normalized}/**`);
+  }
+  if (!normalized.includes("/")) {
+    patterns.push(`**/${normalized}`, `**/${normalized}/**`);
+  }
+  return patterns;
+}
+
+// src/lib/upload/packager.ts
+function buildExcludePatterns(directory, additionalExcludes = []) {
+  const patterns = [...DEFAULT_EXCLUDES, ...additionalExcludes];
+  const gitignore = path4.join(directory, ".gitignore");
+  if (fs4.existsSync(gitignore)) {
+    try {
+      for (const pattern of parseGitignore(fs4.readFileSync(gitignore, "utf-8"))) {
+        patterns.push(...gitignoreToGlob(pattern));
+      }
+    } catch {
+    }
+  }
+  return [...new Set(patterns)].filter((pattern) => pattern !== ".lightcloud");
+}
+function packageSource(options = {}) {
+  const directory = path4.resolve(options.directory ?? process.cwd());
+  const excludes = buildExcludePatterns(directory, options.additionalExcludes);
+  return new Promise((resolve6, reject) => {
+    const chunks = [];
+    let fileCount = 0;
+    let totalSize = 0;
+    const archive = archiver("zip", { zlib: { level: 6 } });
+    archive.on("data", (chunk) => chunks.push(chunk));
+    archive.on("entry", (entry) => {
+      if (entry.stats?.isFile()) {
+        fileCount += 1;
+        totalSize += entry.stats.size;
+        options.onProgress?.(fileCount, totalSize);
+      }
+    });
+    archive.on("warning", (error) => {
+      if (error.code !== "ENOENT") reject(error);
+    });
+    archive.on("error", reject);
+    archive.on("end", () => resolve6({ buffer: Buffer.concat(chunks), fileCount, totalSize }));
+    archive.glob("**/*", { cwd: directory, ignore: excludes, dot: true, nodir: true, follow: false });
+    archive.finalize().catch(reject);
+  });
+}
+
+// src/commands/shared.ts
+function contextFrom(command) {
+  const options = command.optsWithGlobals();
+  return new Context(options);
+}
+function sourceLabel(app) {
+  if (app.git_provider === "upload" || app.github_repo_url?.startsWith("upload://")) return "upload";
+  const host = app.git_provider === "gitlab" ? "gitlab.com" : app.git_provider === "bitbucket" ? "bitbucket.org" : "github.com";
+  if (app.github_repo_owner && app.github_repo_name) return `${host}/${app.github_repo_owner}/${app.github_repo_name}`;
+  return app.github_repo_url || app.git_provider || "unknown";
+}
+function appUrl(app, env) {
+  return env?.deployed_url || app.deployed_url || app.environments?.find((e) => e.is_production)?.deployed_url || void 0;
+}
+function envName(env) {
+  return env.is_production ? `${env.name} ${c.accent(sym.star)}` : env.name;
+}
+function printAppsTable(apps) {
+  printTable(apps, [
+    { header: "App", cell: (app) => c.bold(app.name) },
+    { header: "Status", cell: (app) => statusBadge(app.status) },
+    { header: "Type", cell: (app) => `${app.deployment_type} ${c.dim(sym.bullet)} ${app.framework}` },
+    { header: "Envs", cell: (app) => String(app.environments?.length ?? 0), align: "right" },
+    { header: "URL", cell: (app) => appUrl(app) ? link(appUrl(app)) : c.dim("\u2014"), maxWidth: 60 },
+    { header: "Updated", cell: (app) => c.dim(relativeTime(app.updated_at)) }
+  ]);
+}
+function printEnvsTable(envs) {
+  printTable(envs, [
+    { header: "Environment", cell: envName },
+    { header: "Status", cell: (env) => statusBadge(env.status) },
+    { header: "Branch", cell: (env) => env.github_branch || c.dim("\u2014") },
+    { header: "URL", cell: (env) => env.deployed_url ? link(env.deployed_url) : c.dim("\u2014"), maxWidth: 60 },
+    { header: "Domain", cell: (env) => env.custom_domain ? `${env.custom_domain} ${c.dim(env.custom_domain_status ?? "")}` : c.dim("\u2014") },
+    { header: "Deployed", cell: (env) => c.dim(relativeTime(env.last_deployed_at)) }
+  ]);
+}
+function printDeploymentsTable(deployments) {
+  printTable(deployments, [
+    { header: "ID", cell: (d) => c.dim(shortId(d.id, 10)) },
+    { header: "Status", cell: (d) => statusBadge(d.status) },
+    { header: "Commit", cell: (d) => d.commit_sha ? `${c.accent(d.commit_sha.slice(0, 7))} ${d.commit_message?.split("\n")[0] ?? ""}` : c.dim("\u2014"), maxWidth: 56 },
+    { header: "By", cell: (d) => d.deployed_by_name || c.dim("\u2014") },
+    { header: "Took", cell: (d) => d.duration_seconds != null ? formatDuration(d.duration_seconds * 1e3) : c.dim("\u2014"), align: "right" },
+    { header: "Started", cell: (d) => c.dim(relativeTime(d.started_at)) },
+    { header: "", cell: (d) => d.is_current ? c.green("current") : d.rollback_eligible ? c.dim("rollback ok") : "" }
+  ]);
+}
+function printDbsTable(dbs) {
+  printTable(dbs, [
+    { header: "Database", cell: (db) => c.bold(db.name) },
+    { header: "Status", cell: (db) => statusBadge(db.status) },
+    { header: "Engine", cell: (db) => db.database_type },
+    { header: "Tier", cell: (db) => db.tier },
+    { header: "Region", cell: (db) => db.region },
+    { header: "Host", cell: (db) => db.connection_hostname || db.connection_host || c.dim("\u2014") },
+    { header: "Created", cell: (db) => c.dim(relativeTime(db.created_at)) }
+  ]);
+}
+async function runDeploy(ctx, options) {
+  const org = await ctx.resolveOrg();
+  const { app, env } = options;
+  const queued = env ? await ctx.api.deployEnvironment(org.id, env.id, options.uploadId) : await ctx.api.deployApplication(org.id, app.id, options.uploadId);
+  if (!isJson()) {
+    out(`${c.green(sym.ok)} Deployment queued ${c.dim(`${app.name}${env ? ` / ${env.name}` : ""}`)}`);
+  }
+  if (!options.watch) return { queued };
+  const watched = await watchResource(ctx.api, {
+    kind: env ? "environment" : "application",
+    id: env ? env.id : app.id,
+    organisationId: org.id
+  });
+  if (!watched.ok) {
+    throw new CliError(watched.update.deployment_error || `Deployment ended with status "${watched.status}".`, {
+      hint: `See the full log with \`lc deployments${env ? ` --env ${env.name}` : ""}\` or in the console: ${ctx.appConsoleUrl(app)}`,
+      exitCode: EXIT.FAILED,
+      code: "DEPLOY_FAILED"
+    });
+  }
+  return { queued, watched };
+}
+async function uploadSource(ctx, directory, detection) {
+  const org = await ctx.resolveOrg();
+  const spin = spinner2();
+  spin.start("Packaging source");
+  const pack = await packageSource({
+    directory,
+    onProgress: (files) => {
+      if (files % 250 === 0) spin.message(`Packaging source ${c.dim(`${files} files`)}`);
+    }
+  });
+  spin.message(`Packaged ${pack.fileCount} files ${c.dim(`(${formatBytes(pack.totalSize)} \u2192 ${formatBytes(pack.buffer.length)})`)}`);
+  if (pack.fileCount === 0) {
+    spin.stop("Nothing to upload", 1);
+    throw new CliError(`No files to upload in ${directory}.`, {
+      hint: "Everything matched an ignore rule. Check .gitignore and run from the project root.",
+      exitCode: EXIT.USAGE
+    });
+  }
+  const session = await ctx.api.requestUpload(org.id, pack.buffer.length);
+  if (pack.buffer.length > session.maxSize) {
+    spin.stop("Archive too large", 1);
+    throw new CliError(`The source archive is ${formatBytes(pack.buffer.length)}; the limit is ${formatBytes(session.maxSize)}.`, {
+      hint: "Exclude build output and large assets via .gitignore, or deploy from a git repository instead.",
+      exitCode: EXIT.USAGE
+    });
+  }
+  spin.message(`Uploading ${formatBytes(pack.buffer.length)}`);
+  const put = await fetch(session.signedUrl, {
+    method: "PUT",
+    headers: { "Content-Type": "application/zip" },
+    body: new Uint8Array(pack.buffer)
+  });
+  if (!put.ok) {
+    spin.stop("Upload failed", 1);
+    throw new CliError(`Upload rejected by storage (${put.status} ${put.statusText}).`, { hint: "Try again in a moment." });
+  }
+  await ctx.api.completeUpload(org.id, session.uploadId, {
+    detectedFramework: detection.framework,
+    detectedRuntime: detection.runtime,
+    detectedDeploymentType: detection.deploymentType,
+    detectedBuildCommand: detection.buildCommand,
+    detectedOutputDirectory: detection.outputDirectory
+  });
+  spin.stop(`Uploaded ${pack.fileCount} files ${c.dim(`(${formatBytes(pack.buffer.length)})`)}`);
+  return { uploadId: session.uploadId, fileCount: pack.fileCount, totalSize: pack.totalSize, archiveSize: pack.buffer.length };
+}
+function describeDetection(detection) {
+  const parts = [];
+  parts.push(detection.frameworkLabel ? c.bold(detection.frameworkLabel) : c.yellow("unknown framework"));
+  parts.push(detection.deploymentType === "static" ? "static site" : "container");
+  if (detection.packageManager) parts.push(detection.packageManager);
+  if (detection.notes.length) parts.push(c.dim(detection.notes.join(", ")));
+  return parts.join(` ${c.dim(sym.bullet)} `);
+}
+function warnIfDirty(isDirty, branch) {
+  if (isDirty) log.warn(`Uncommitted changes on ${c.bold(branch ?? "this branch")} will be included in the upload.`);
+}
+
+// src/commands/apps.ts
+function registerAppCommands(program2) {
+  program2.command("apps [filter]").alias("ls").alias("list").description("List apps in the workspace").action(async (filter, _options, command) => {
+    const ctx = contextFrom(command);
+    const org = await ctx.resolveOrg();
+    const apps = await ctx.api.listApplications(org.id, filter);
+    const others = ctx.usingApiKey ? [] : ((await ctx.profile()).organisations ?? []).filter((o) => o.id !== org.id);
+    emit(apps, () => {
+      if (apps.length === 0) {
+        log.info(filter ? `No apps matching "${filter}".` : `No apps in ${c.bold(org.name ?? "this workspace")} yet. Run ${c.bold("lc init")} in a project folder to create one.`);
+        if (!filter && others.length) {
+          out(c.dim(`  Other workspaces: ${others.map((o) => o.name).join(", ")}  \u2192  lc apps --org <name>, or lc org use <name> to switch.`));
+        }
+        return;
+      }
+      heading(`${org.name ?? "Workspace"} ${c.dim(`\xB7 ${apps.length} app${apps.length === 1 ? "" : "s"}`)}`);
+      out();
+      printAppsTable(apps);
+      const failing = apps.filter((app) => app.status === "failed" || app.environments?.some((env) => env.status === "failed"));
+      if (failing.length) {
+        out();
+        log.warn(`${failing.length} app${failing.length === 1 ? "" : "s"} with a failed deployment: ${failing.map((app) => app.name).join(", ")}. Try ${c.bold("lc logs <app>")}.`);
+      }
+    });
+  });
+  program2.command("status [app]").alias("app").description("Show an app with its environments and latest deployment").option("-a, --app <app>", "app name or id (alternative to the positional)").action(async (positional, options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(positional ?? options.app);
+    const org = await ctx.resolveOrg();
+    const envs = app.environments ?? await ctx.api.listEnvironments(org.id, app.id);
+    emit({ ...app, environments: envs }, () => printAppStatus(ctx.appConsoleUrl(app), app, envs));
+  });
+  program2.command("open [app]").description("Open the deployed app (or the console page) in your browser").option("-e, --env <env>", "environment to open").option("--console", "open the app in the Light Cloud console instead").action(async (positional, options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(positional);
+    let url;
+    if (options.console) {
+      url = ctx.appConsoleUrl(app);
+    } else {
+      const env = await ctx.resolveEnv(app, options.env);
+      url = env.deployed_url || appUrl(app, env);
+      if (!url) {
+        throw new CliError(`${app.name} / ${env.name} has no URL yet.`, {
+          hint: "Deploy it first with `lc deploy`, or open the console with `lc open --console`.",
+          exitCode: EXIT.NOT_FOUND
+        });
+      }
+    }
+    const opened = openBrowser(url);
+    emit({ url, opened }, () => opened ? log.success(`Opened ${link(url)}`) : out(url));
+  });
+  program2.command("delete <app>").alias("rm").description("Delete an app and every environment in it").action(async (ref, _options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(ref);
+    const org = await ctx.resolveOrg();
+    const envCount = app.environments?.length ?? 0;
+    const ok = await confirm2(
+      `Delete ${c.bold(app.name)}${envCount ? ` and its ${envCount} environment${envCount === 1 ? "" : "s"}` : ""}? This cannot be undone.`,
+      { yes: ctx.yes }
+    );
+    if (!ok) return;
+    await ctx.api.deleteApplication(org.id, app.id);
+    emit({ ok: true, id: app.id, name: app.name }, () => log.success(`Deleting ${c.bold(app.name)}. Resources are torn down in the background.`));
+  });
+  program2.command("rename <app> <name>").description("Rename an app").action(async (ref, name, _options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(ref);
+    const org = await ctx.resolveOrg();
+    const updated = await ctx.api.renameApplication(org.id, app.id, name.trim());
+    emit(updated, () => log.success(`${c.bold(app.name)} is now ${c.bold(updated.name ?? name)}.`));
+  });
+}
+function printAppStatus(consoleUrl, app, envs) {
+  if (isJson()) return;
+  const url = appUrl(app);
+  heading(`${app.name}  ${statusBadge(app.status)}`);
+  printDetails([
+    ["Type", `${app.deployment_type} ${c.dim(sym.bullet)} ${app.framework}${app.runtime ? c.dim(` (${app.runtime})`) : ""}`],
+    ["Source", `${sourceLabel(app)}${app.github_branch ? c.dim(`  ${app.github_branch}`) : ""}${app.root_directory ? c.dim(`  /${app.root_directory}`) : ""}`],
+    ["URL", url ? link(url) : void 0],
+    ["Domain", app.custom_domain ? `${app.custom_domain} ${c.dim(app.custom_domain_status ?? "")}` : void 0],
+    ["Auto-deploy", app.auto_deploy_branches === void 0 ? void 0 : app.auto_deploy_branches ? "on push" : "off"],
+    ["Last deploy", relativeTime(app.last_deployed_at)],
+    ["Console", c.dim(consoleUrl)],
+    ["ID", c.dim(app.id)]
+  ]);
+  if (app.status === "failed" && app.deployment_error) {
+    out();
+    out(`  ${c.red(sym.fail)} ${app.deployment_error}`);
+  }
+  out();
+  if (envs.length === 0) {
+    log.info("No environments.");
+    return;
+  }
+  printEnvsTable(envs);
+  const failing = envs.filter((env) => env.status === "failed");
+  if (failing.length) {
+    out();
+    for (const env of failing) {
+      out(`  ${c.red(sym.fail)} ${envName(env)} failed${env.last_deployed_at ? c.dim(` (${relativeTime(env.last_deployed_at)})`) : ""} \u2014 ${c.dim(`lc deployments --env ${env.name}`)}`);
+    }
+  }
+}
+
+// src/lib/auth/browser-login.ts
+import * as crypto from "crypto";
+import * as http from "http";
+var SIGN_IN_CANCELLED = "SIGN_IN_CANCELLED";
+function startLoginFlow(consoleUrl, options = {}) {
+  const state2 = crypto.randomBytes(16).toString("hex");
+  const timeoutMs = options.timeoutMs ?? 5 * 60 * 1e3;
+  return new Promise((resolveFlow, rejectFlow) => {
+    let settle = null;
+    const tokens = new Promise((resolve6, reject) => {
+      settle = { resolve: resolve6, reject };
+    });
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url || "/", "http://127.0.0.1");
+      if (url.pathname !== "/callback") {
+        res.writeHead(404).end("Not found");
+        return;
+      }
+      const error = url.searchParams.get("error");
+      const token = url.searchParams.get("token");
+      const refreshToken = url.searchParams.get("refreshToken") || void 0;
+      const returnedState = url.searchParams.get("state");
+      const finish = (kind, message) => {
+        const target = new URL(`${consoleUrl}/auth/cli`);
+        target.searchParams.set("done", kind);
+        target.searchParams.set("client", "cli");
+        if (message) target.searchParams.set("message", message);
+        res.writeHead(302, { Location: target.toString() });
+        res.end();
+        server.close();
+      };
+      if (error === "cancelled") {
+        finish("cancelled");
+        settle?.reject(new CliError("Sign-in cancelled in the browser.", { exitCode: EXIT.CANCELLED, code: SIGN_IN_CANCELLED }));
+        return;
+      }
+      if (error) {
+        finish("error", error);
+        settle?.reject(new CliError(`Sign-in failed: ${error}`, { exitCode: EXIT.AUTH }));
+        return;
+      }
+      if (returnedState !== state2) {
+        finish("error", "This sign-in link does not match the one the CLI is waiting for.");
+        settle?.reject(new CliError("Sign-in state mismatch. Start again with `lc login`.", { exitCode: EXIT.AUTH }));
+        return;
+      }
+      if (!token) {
+        finish("error", "No token was received from the console.");
+        settle?.reject(new CliError("The console sent no token back.", { exitCode: EXIT.AUTH }));
+        return;
+      }
+      finish("success");
+      settle?.resolve({ accessToken: token, refreshToken });
+    });
+    server.on("error", (error) => rejectFlow(new CliError(`Could not start the sign-in listener: ${error.message}`)));
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address();
+      const callback = `http://127.0.0.1:${port}/callback`;
+      const url = `${consoleUrl}/auth/cli?callback=${encodeURIComponent(callback)}&state=${state2}`;
+      const timer = setTimeout(() => {
+        server.close();
+        settle?.reject(new CliError("Sign-in timed out after 5 minutes.", { hint: "Run `lc login` again.", exitCode: EXIT.AUTH }));
+      }, timeoutMs);
+      timer.unref();
+      resolveFlow({
+        url,
+        tokens: tokens.finally(() => clearTimeout(timer)),
+        cancel: () => {
+          clearTimeout(timer);
+          server.close();
+        }
+      });
+    });
+  });
+}
+
+// src/lib/auth/device-login.ts
+import * as os2 from "os";
+var DEVICE_SIGN_IN_DENIED = "DEVICE_SIGN_IN_DENIED";
+var DEVICE_SIGN_IN_EXPIRED = "DEVICE_SIGN_IN_EXPIRED";
+var DEVICE_SIGN_IN_UNAVAILABLE = "DEVICE_SIGN_IN_UNAVAILABLE";
+async function startDeviceFlow(api, email) {
+  let started;
+  try {
+    started = await api.post(
+      "/api/auth/device/start",
+      { email, client: "cli", clientName: `Light Cloud CLI on ${os2.hostname()}` },
+      { anonymous: true }
+    );
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 404) {
+      throw new CliError("Device sign-in is not enabled on this Light Cloud environment.", {
+        hint: "Run `lc login` without --device to sign in through a browser.",
+        code: DEVICE_SIGN_IN_UNAVAILABLE,
+        exitCode: EXIT.ERROR
+      });
+    }
+    throw error;
+  }
+  const expiresAt = Date.now() + started.expiresIn * 1e3;
+  let cancelled = false;
+  let timer = null;
+  const tokens = new Promise((resolve6, reject) => {
+    let delay = Math.max(started.interval, 3) * 1e3;
+    const poll = async () => {
+      if (cancelled) return;
+      if (Date.now() > expiresAt) {
+        reject(new CliError("The code expired before it was approved.", { code: DEVICE_SIGN_IN_EXPIRED, hint: "Run `lc login` again for a new one." }));
+        return;
+      }
+      let answer = null;
+      try {
+        answer = await api.post("/api/auth/device/poll", { deviceCode: started.deviceCode }, { anonymous: true });
+      } catch {
+      }
+      if (answer) {
+        switch (answer.status) {
+          case "approved":
+            resolve6({ accessToken: answer.token, refreshToken: answer.refreshToken });
+            return;
+          case "access_denied":
+            reject(new CliError("Sign-in was refused in the browser.", { code: DEVICE_SIGN_IN_DENIED }));
+            return;
+          case "expired_token":
+            reject(new CliError("The code expired before it was approved.", { code: DEVICE_SIGN_IN_EXPIRED, hint: "Run `lc login` again for a new one." }));
+            return;
+          case "slow_down":
+            delay += 5e3;
+            break;
+          default:
+            break;
+        }
+      }
+      timer = setTimeout(poll, delay);
+    };
+    timer = setTimeout(poll, delay);
+  });
+  return {
+    userCode: started.userCode,
+    verificationUrl: started.verificationUrl,
+    newAccount: started.newAccount,
+    emailSent: started.emailSent,
+    expiresAt,
+    tokens,
+    cancel() {
+      cancelled = true;
+      if (timer) clearTimeout(timer);
+    }
+  };
+}
+
+// src/commands/auth.ts
+async function browserSignIn(consoleUrl, openIt) {
+  const flow = await startLoginFlow(consoleUrl);
+  const opened = openIt && isInteractive() ? openBrowser(flow.url) : false;
+  if (opened) {
+    out(`${c.dim("\u2502")}  Browser opened. If nothing happened, open this link:`);
+  } else {
+    out(`${c.dim("\u2502")}  Open this link in your browser to sign in:`);
+  }
+  out(`${c.dim("\u2502")}  ${link(flow.url)}`);
+  const spin = spinner2();
+  spin.start("Waiting for you to sign in\u2026");
+  try {
+    const tokens = await flow.tokens;
+    spin.stop("Signed in");
+    return tokens;
+  } catch (error) {
+    if (error instanceof CliError && error.code === SIGN_IN_CANCELLED) {
+      spin.stop("Sign-in cancelled in the browser", 2);
+      throw new CancelledError();
+    }
+    spin.stop("Sign-in did not complete", 1);
+    throw error;
+  }
+}
+async function deviceSignIn(client, emailFlag) {
+  const email = emailFlag?.trim().toLowerCase() || (await text2("Email address", {
+    flag: "--email <address>",
+    placeholder: "you@example.com",
+    validate: (value) => /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(value.trim()) ? void 0 : "Enter an email address"
+  })).trim().toLowerCase();
+  const flow = await startDeviceFlow(client, email);
+  const minutes = Math.max(1, Math.round((flow.expiresAt - Date.now()) / 6e4));
+  if (flow.newAccount) {
+    out(`${c.dim("\u2502")}  No account exists for ${c.bold(email)} yet \u2014 approving creates one (free plan).`);
+    out(`${c.dim("\u2502")}  Open the link in the email we sent to ${email}, then enter the code:`);
+  } else {
+    out(`${c.dim("\u2502")}  Open ${link(flow.verificationUrl)} on any device, sign in, and enter the code:`);
+  }
+  out(`${c.dim("\u2502")}`);
+  out(`${c.dim("\u2502")}      ${c.bold(flow.userCode)}`);
+  out(`${c.dim("\u2502")}`);
+  out(`${c.dim("\u2502")}  ${c.dim(`The code expires in ${minutes} minutes.`)}`);
+  if (!flow.emailSent) {
+    log.warn("The confirmation email could not be sent; an existing account can still approve by signing in on the page above.");
+  }
+  const spin = spinner2();
+  spin.start("Waiting for the code to be approved\u2026");
+  try {
+    const tokens = await flow.tokens;
+    spin.stop(flow.newAccount ? "Account created and signed in" : "Signed in");
+    return tokens;
+  } catch (error) {
+    if (error instanceof CliError && error.code === DEVICE_SIGN_IN_DENIED) {
+      spin.stop("Sign-in refused in the browser", 2);
+      throw new CancelledError();
+    }
+    spin.stop("Sign-in did not complete", 1);
+    throw error;
+  }
+}
+function registerAuthCommands(program2) {
+  program2.command("login").description("Sign in to Light Cloud (opens your browser, or a code to type on another device)").option("--api-key <key>", "sign in with an API key instead of a browser session").option("--no-browser", "print the sign-in URL instead of opening a browser").option("--device", "sign in with a short code from any device (no browser needed here); creates the account if the email has none").option("--email <address>", "email for --device sign-in").action(async (options, command) => {
+    const ctx = contextFrom(command);
+    if (options.apiKey) {
+      if (!isApiKey(options.apiKey)) {
+        throw new CliError("That does not look like a Light Cloud API key.", {
+          hint: "Keys start with `lc_`. Create one in the console under Organisation settings \u2192 API keys.",
+          exitCode: EXIT.USAGE
+        });
+      }
+      writeCredentials({ ...readCredentials(), apiKey: options.apiKey, accessToken: void 0, refreshToken: void 0 });
+      try {
+        await ctx.api.listApplications("api-key", void 0, 1);
+      } catch (error) {
+        clearCredentials();
+        throw error;
+      }
+      emit({ ok: true, method: "api-key" }, () => log.success(`API key saved to ${c.dim(credentialsPath())}.`));
+      return;
+    }
+    if (process.env.LIGHT_CLOUD_API_KEY) {
+      log.warn("LIGHT_CLOUD_API_KEY is set in this shell and takes precedence over a browser session.");
+    }
+    if (ctx.api.client.hasCredentials() && !ctx.usingApiKey) {
+      try {
+        const profile2 = await ctx.api.profile();
+        emit({ ok: true, alreadySignedIn: true, email: profile2.email }, () => {
+          log.info(`Already signed in as ${c.bold(profile2.email)}. Run \`lc logout\` first to switch accounts.`);
+        });
+        return;
+      } catch {
+      }
+    }
+    intro2(`${brand()} sign-in`);
+    const useDevice = options.device || Boolean(options.email) || !process.env.DISPLAY && process.platform === "linux" && !options.browser;
+    const tokens = useDevice ? await deviceSignIn(ctx.api.client, options.email) : await browserSignIn(ctx.endpoints.consoleUrl, options.browser);
+    writeCredentials({ accessToken: tokens.accessToken, refreshToken: tokens.refreshToken });
+    const profile = await ctx.api.profile();
+    const orgs = profile.organisations ?? [];
+    logStep(`Signed in as ${c.bold(profile.email)}`);
+    const saved = readGlobalConfig().defaultOrganisationId;
+    let defaultOrg = orgs.find((org) => org.id === saved);
+    if (!defaultOrg && orgs.length === 1) defaultOrg = orgs[0];
+    if (!defaultOrg && orgs.length > 1 && isInteractive()) {
+      const chosen = await select2(
+        "Which workspace should lc use by default?",
+        orgs.map((org) => ({ value: org.id, label: org.name, hint: org.role })),
+        { flag: "lc org use <name>" }
+      );
+      defaultOrg = orgs.find((org) => org.id === chosen);
+    }
+    if (defaultOrg) {
+      updateGlobalConfig({ defaultOrganisationId: defaultOrg.id, defaultOrganisationName: defaultOrg.name });
+    }
+    emit({ ok: true, method: useDevice ? "device" : "browser", email: profile.email, organisations: orgs, defaultOrganisationId: defaultOrg?.id ?? null }, () => {
+      if (orgs.length > 1) {
+        logStep(`Workspaces${defaultOrg ? c.dim(`  (default: ${defaultOrg.name}; change with lc org use <name>)`) : ""}`);
+        for (const org of orgs) {
+          const marker = org.id === defaultOrg?.id ? c.accent(" \u2714 default") : "";
+          out(`${c.dim("\u2502")}  ${c.dim("\xB7")} ${org.name} ${c.dim(`(${org.role})`)}${marker}`);
+        }
+      } else if (defaultOrg) {
+        logStep(`Workspace ${c.bold(defaultOrg.name)} ${c.dim(`(${defaultOrg.role})`)}`);
+      }
+      if (!defaultOrg && orgs.length > 1) {
+        out(`${c.dim("\u2502")}  Pick one with: ${orgs.map((org) => c.bold(`lc org use ${quoteArg(org.name)}`)).join(c.dim("  or  "))}`);
+      }
+      outro2(`Ready. Try ${c.bold("lc apps")} or ${c.bold("lc init")} in a project folder.`);
+    });
+  });
+  program2.command("logout").description("Sign out and forget stored credentials").action(async () => {
+    const had = readCredentials();
+    clearCredentials();
+    emit({ ok: true }, () => {
+      if (had.accessToken || had.apiKey) log.success("Signed out. Credentials removed.");
+      else log.info("You were not signed in.");
+    });
+  });
+  program2.command("whoami").description("Show the signed-in account and its workspaces").action(async (_options, command) => {
+    const ctx = contextFrom(command);
+    const auth = resolveAuth();
+    if (!auth.token) {
+      throw new CliError("Not signed in.", { hint: "Run `lc login`.", exitCode: EXIT.AUTH });
+    }
+    if (isApiKey(auth.token)) {
+      const org = await ctx.resolveOrg();
+      emit({ method: auth.source, organisationId: org.id, apiUrl: ctx.endpoints.apiUrl }, () => {
+        printDetails([
+          ["Signed in with", `API key ${c.dim(`(${auth.source === "env-api-key" ? "LIGHT_CLOUD_API_KEY" : credentialsPath()})`)}`],
+          ["Workspace", org.id],
+          ["API", ctx.endpoints.apiUrl]
+        ]);
+      });
+      return;
+    }
+    let profile;
+    try {
+      profile = await ctx.api.profile();
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 401) {
+        throw new CliError("Your session has expired.", { hint: "Run `lc login` to sign in again.", exitCode: EXIT.AUTH });
+      }
+      throw error;
+    }
+    const defaultOrg = readGlobalConfig().defaultOrganisationId;
+    const name = [profile.first_name, profile.last_name].filter(Boolean).join(" ");
+    emit({ ...profile, defaultOrganisationId: defaultOrg, apiUrl: ctx.endpoints.apiUrl }, () => {
+      printDetails([
+        ["Account", `${c.bold(profile.email)}${name ? c.dim(`  ${name}`) : ""}`],
+        ["API", ctx.endpoints.apiUrl],
+        ["Linked app", ctx.project ? `${ctx.project.config.applicationName ?? ctx.project.config.applicationId} ${c.dim(ctx.project.path)}` : void 0]
+      ]);
+      out();
+      printTable(profile.organisations ?? [], [
+        { header: "Workspace", cell: (org) => `${org.name}${org.id === defaultOrg ? c.accent(" (default)") : ""}` },
+        { header: "Role", cell: (org) => org.role },
+        { header: "ID", cell: (org) => c.dim(org.id) }
+      ]);
+    });
+  });
+}
+function quoteArg(value) {
+  return /^[A-Za-z0-9_.-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+// src/commands/billing.ts
+var money = (value) => `$${value.toFixed(2)}`;
+function registerBillingCommands(program2) {
+  const billing = program2.command("billing").description("Plan, usage pool and payment card for a workspace");
+  billing.command("show", { isDefault: true }).description("Plan, card on file and usage pool this cycle").action(async (_options, command) => {
+    const ctx = contextFrom(command);
+    const org = await ctx.resolveOrg();
+    const [{ data: plans }, summary] = await Promise.all([
+      ctx.api.plans(org.id),
+      ctx.api.ownerBillingSummary().catch(() => null)
+    ]);
+    const current = plans.plans.find((plan2) => plan2.id === (plans.currentPlanId ?? "hobby"));
+    const card2 = summary?.data.payment_method ?? null;
+    emit({ organisation: org, plan: current ?? null, pendingPlanId: plans.pendingPlanId, card: card2, pool: plans.pool, hardStopped: plans.hardStopped }, () => {
+      heading(org.name ?? org.id);
+      printDetails([
+        ["Plan", current ? `${c.bold(current.name)} ${c.dim(`(${current.id})`)} \xB7 ${money(current.price)}/month` : plans.currentPlanId ?? "free"],
+        ["Pending", plans.pendingPlanId ? `${plans.pendingPlanId} at next cycle` : void 0],
+        ["Card", card2 ? `${card2.brand} \u2022\u2022\u2022\u2022 ${card2.last4}` : `none ${c.dim("(lc billing card add)")}`],
+        ["Pool", `${money(plans.pool.spent)} of ${money(plans.pool.total)} used (${Math.round(plans.pool.pct)}%)${plans.pool.overage > 0 ? `, overage ${money(plans.pool.overage)}` : ""}`],
+        ["Next invoice", summary?.data.billing_cycle.next_billing_date?.slice(0, 10)]
+      ]);
+      if (plans.hardStopped) {
+        out();
+        log.warn("Free-plan pool used up \u2014 projects are paused until an upgrade (lc billing plan use <id>) or the next cycle.");
+      }
+    });
+  });
+  billing.command("plans").description("Plans this workspace can be on").action(async (_options, command) => {
+    const ctx = contextFrom(command);
+    const org = await ctx.resolveOrg();
+    const { data } = await ctx.api.plans(org.id);
+    const currentId = data.currentPlanId ?? "hobby";
+    emit(data.plans, () => {
+      printTable(data.plans, [
+        { header: "Plan", cell: (plan2) => `${c.bold(plan2.name)}${plan2.id === currentId ? c.accent(" (current)") : ""}` },
+        { header: "ID", cell: (plan2) => plan2.id },
+        { header: "Price", cell: (plan2) => `${money(plan2.price)}/mo` },
+        { header: "Includes", cell: (plan2) => summariseEntitlements(plan2.entitlements) }
+      ]);
+      out();
+      out(c.dim("  Switch: lc billing plan use <id>   \xB7   paid plans need a card: lc billing card add"));
+    });
+  });
+  const plan = billing.command("plan").description("Change plan");
+  plan.command("use [plan]").description("Put the workspace on a plan (no id: pick from a list)").option("-y, --yes", "skip the confirmation").action(async (ref, options, command) => {
+    const ctx = contextFrom(command);
+    const org = await ctx.resolveOrg();
+    const { data } = await ctx.api.plans(org.id);
+    const currentId = data.currentPlanId ?? "hobby";
+    let target = ref ? data.plans.find((p) => p.id === ref.toLowerCase() || p.name.toLowerCase() === ref.toLowerCase()) : void 0;
+    if (ref && !target) {
+      throw new CliError(`No plan called "${ref}".`, { hint: `Plans: ${data.plans.map((p) => p.id).join(", ")}.`, exitCode: EXIT.NOT_FOUND });
+    }
+    if (!target) {
+      const chosen = await select2(
+        "Which plan?",
+        data.plans.map((p) => ({ value: p.id, label: `${p.name} \u2014 ${money(p.price)}/mo`, hint: p.id === currentId ? "current" : void 0 })),
+        { flag: "lc billing plan use <id>", initialValue: currentId }
+      );
+      target = data.plans.find((p) => p.id === chosen);
+    }
+    const current = data.plans.find((p) => p.id === currentId);
+    if (target.price > (current?.price ?? 0)) {
+      const charge = (current?.price ?? 0) <= 0 ? target.price : void 0;
+      const ok = await confirm2(
+        `Switch ${org.name ?? "this workspace"} to ${target.name} (${money(target.price)}/month)?${charge !== void 0 ? ` The card on file is charged ${money(charge)} now.` : ""}`,
+        { yes: Boolean(options.yes), flag: "--yes" }
+      );
+      if (!ok) throw new CancelledError();
+    }
+    let result;
+    try {
+      result = await ctx.api.choosePlan(org.id, target.id);
+    } catch (error) {
+      if (error instanceof ApiError && error.code === "PAYMENT_METHOD_REQUIRED") {
+        throw new CliError("A card is needed for a paid plan.", { hint: `Run ${c.bold("lc billing card add")}, then this command again.`, exitCode: EXIT.ERROR, code: error.code });
+      }
+      throw error;
+    }
+    emit(result.data, () => {
+      if (result.data.pendingPlanId) {
+        log.success(`Downgrade scheduled: ${result.data.planId} until ${result.data.effectiveAt?.slice(0, 10) ?? "the next cycle"}, then ${result.data.pendingPlanId}.`);
+      } else {
+        const charge = result.data.proratedCharge > 0 ? ` Charged ${money(result.data.proratedCharge)} (${result.data.chargeStatus}).` : "";
+        log.success(`${org.name ?? "Workspace"} is now on ${c.bold(result.data.planId)}.${charge}`);
+      }
+    });
+  });
+  const card = billing.command("card").description("Payment card");
+  card.command("show", { isDefault: true }).description("The card on file").action(async (_options, command) => {
+    const ctx = contextFrom(command);
+    const summary = await ctx.api.ownerBillingSummary();
+    const method = summary.data.payment_method;
+    emit({ card: method }, () => {
+      if (method) log.info(`${method.brand} \u2022\u2022\u2022\u2022 ${method.last4}`);
+      else log.info(`No card on file. Add one with ${c.bold("lc billing card add")}.`);
+    });
+  });
+  card.command("add").description("Save a card through a Stripe-hosted page (link you can open on any device)").option("--no-browser", "print the link instead of opening a browser").option("--plan <id>", "switch to this plan once the card is saved").action(async (options, command) => {
+    const ctx = contextFrom(command);
+    const org = await ctx.resolveOrg();
+    let session;
+    try {
+      session = (await ctx.api.createCheckoutSession(org.id)).data;
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 404) {
+        throw new CliError("Hosted card setup is not enabled on this Light Cloud environment.", {
+          hint: "Add a card in the console under Billing \u2192 General.",
+          exitCode: EXIT.ERROR
+        });
+      }
+      throw error;
+    }
+    const opened = options.browser && isInteractive() ? openBrowser(session.url) : false;
+    out(`${c.dim("\u2502")}  ${opened ? "Browser opened. If nothing happened, open this link" : "Open this link on any device to save a card"} ${c.dim("(Stripe-hosted; the card never passes through lc)")}:`);
+    out(`${c.dim("\u2502")}  ${link(session.url)}`);
+    const spin = spinner2();
+    spin.start("Waiting for the card to be saved\u2026");
+    const deadline = new Date(session.expiresAt).getTime();
+    let status = "open";
+    let saved = null;
+    while (Date.now() < deadline) {
+      await new Promise((resolve6) => setTimeout(resolve6, 4e3));
+      try {
+        const answer = (await ctx.api.checkoutSessionStatus(org.id, session.sessionId)).data;
+        status = answer.status;
+        if (status === "complete") {
+          saved = answer.paymentMethod;
+          break;
+        }
+        if (status === "expired") break;
+      } catch {
+      }
+    }
+    if (status !== "complete") {
+      spin.stop("No card saved", 1);
+      throw new CliError(status === "expired" ? "The card setup link expired." : "The card setup link timed out.", { hint: "Run `lc billing card add` again for a new link." });
+    }
+    spin.stop(`Card saved${saved ? `: ${saved.brand} \u2022\u2022\u2022\u2022 ${saved.last4}` : ""}`);
+    let planResult = null;
+    if (options.plan) {
+      planResult = (await ctx.api.choosePlan(org.id, options.plan)).data;
+      log.success(`${org.name ?? "Workspace"} is now on ${c.bold(planResult.planId)}${planResult.proratedCharge > 0 ? ` (charged ${money(planResult.proratedCharge)})` : ""}.`);
+    }
+    emit({ ok: true, card: saved, plan: planResult }, () => {
+      if (!options.plan) out(c.dim("  Pick a plan with: lc billing plan use <id>"));
+    });
+  });
+  card.command("remove").description("Remove the card on file").option("-y, --yes", "skip the confirmation").action(async (options, command) => {
+    const ctx = contextFrom(command);
+    const org = await ctx.resolveOrg();
+    const ok = await confirm2("Remove the card on file? Paid plans cannot be charged without one.", { yes: Boolean(options.yes), flag: "--yes" });
+    if (!ok) throw new CancelledError();
+    await ctx.api.removePaymentMethod(org.id);
+    emit({ ok: true }, () => log.success("Card removed."));
+  });
+}
+function summariseEntitlements(entitlements) {
+  if (!entitlements) return c.dim("\u2014");
+  const parts = [];
+  for (const [key, value] of Object.entries(entitlements)) {
+    if (Array.isArray(value)) parts.push(`${key}: ${value.join("/")}`);
+    else if (typeof value === "boolean") {
+      if (value) parts.push(key);
+    } else if (value !== null && typeof value !== "object") parts.push(`${key}: ${String(value)}`);
+  }
+  return parts.length ? parts.join(", ") : c.dim("\u2014");
+}
+
+// src/commands/config.ts
+function registerConfigCommands(program2) {
+  const config = program2.command("config").description("CLI settings (API endpoint, defaults)");
+  config.command("show", { isDefault: true }).description("Show effective settings and where they come from").action(async () => {
+    const stored = readGlobalConfig();
+    const endpoints = resolveEndpoints();
+    const auth = resolveAuth();
+    const project = findProjectConfig();
+    emit(
+      { endpoints, auth: auth.source, config: stored, configPath: globalConfigPath(), project: project?.config ?? null, projectPath: project?.path ?? null },
+      () => {
+        printDetails([
+          ["API URL", `${endpoints.apiUrl}${process.env.LIGHT_CLOUD_API_URL ? c.dim("  (LIGHT_CLOUD_API_URL)") : stored.apiUrl ? c.dim("  (config)") : c.dim("  (default)")}`],
+          ["Console URL", endpoints.consoleUrl],
+          ["Credentials", `${auth.source === "none" ? c.yellow("none") : auth.source} ${c.dim(credentialsPath())}`],
+          ["Default workspace", stored.defaultOrganisationName ? `${stored.defaultOrganisationName} ${c.dim(stored.defaultOrganisationId ?? "")}` : c.dim("not set")],
+          ["Settings file", c.dim(globalConfigPath())],
+          ["Linked app", project ? `${project.config.applicationName ?? project.config.applicationId ?? "?"} ${c.dim(project.path)}` : c.dim("none in this folder")]
+        ]);
+      }
+    );
+  });
+  config.command("set <key> <value>").description("Set a value: api-url, console-url").action(async (key, value) => {
+    const normalised = key.toLowerCase().replace(/_/g, "-");
+    if (normalised === "api-url" || normalised === "apiurl") {
+      assertUrl(value);
+      updateGlobalConfig({ apiUrl: value.replace(/\/+$/, "") });
+    } else if (normalised === "console-url" || normalised === "consoleurl") {
+      assertUrl(value);
+      updateGlobalConfig({ consoleUrl: value.replace(/\/+$/, "") });
+    } else {
+      throw new CliError(`Unknown setting "${key}".`, { hint: "Settings: api-url, console-url.", exitCode: EXIT.USAGE });
+    }
+    emit({ ok: true, key: normalised, value }, () => log.success(`${normalised} = ${value}`));
+  });
+  config.command("unset <key>").description("Remove a setting and fall back to the default").action(async (key) => {
+    const stored = readGlobalConfig();
+    const normalised = key.toLowerCase().replace(/_/g, "-");
+    if (normalised === "api-url") delete stored.apiUrl;
+    else if (normalised === "console-url") delete stored.consoleUrl;
+    else if (normalised === "default-org" || normalised === "org") {
+      delete stored.defaultOrganisationId;
+      delete stored.defaultOrganisationName;
+    } else throw new CliError(`Unknown setting "${key}".`, { hint: "Settings: api-url, console-url, default-org.", exitCode: EXIT.USAGE });
+    writeGlobalConfig(stored);
+    emit({ ok: true, key: normalised }, () => log.success(`${normalised} cleared.`));
+  });
+  program2.command("unlink").description("Remove the .lightcloud link file from this folder").action(async () => {
+    const project = findProjectConfig();
+    if (!project) {
+      emit({ ok: true, removed: false }, () => log.info("This folder is not linked to an app."));
+      return;
+    }
+    deleteProjectConfig(project.directory);
+    emit({ ok: true, removed: true, path: project.path }, () => log.success(`Removed ${c.dim(project.path)}. The app itself is untouched.`));
+  });
+}
+function assertUrl(value) {
+  try {
+    const url = new URL(value);
+    if (!["http:", "https:"].includes(url.protocol)) throw new Error();
+  } catch {
+    throw new CliError(`"${value}" is not an http(s) URL.`, { exitCode: EXIT.USAGE });
+  }
+}
+
+// src/commands/dbs.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { Readable, Transform } from "stream";
+import { pipeline } from "stream/promises";
+function registerDbCommands(program2) {
+  program2.command("dbs").alias("databases").description("List databases in the workspace").action(async (_options, command) => {
+    const ctx = contextFrom(command);
+    const org = await ctx.resolveOrg();
+    const dbs = await ctx.api.listDatabases(org.id);
+    emit(dbs, () => {
+      if (dbs.length === 0) {
+        log.info(`No databases yet. Create one with ${c.bold("lc db create")}.`);
+        return;
+      }
+      heading(`${org.name ?? "Workspace"} ${c.dim(`\xB7 ${dbs.length} database${dbs.length === 1 ? "" : "s"}`)}`);
+      out();
+      printDbsTable(dbs);
+    });
+  });
+  const db = program2.command("db").description("Manage one database");
+  db.command("get [name]").alias("show").description("Show a database").action(async (ref, _options, command) => {
+    const ctx = contextFrom(command);
+    const database = await ctx.resolveDb(ref);
+    emit(database, () => printDb(database, ctx.dbConsoleUrl(database)));
+  });
+  db.command("create [name]").description("Create a database").option("--engine <type>", "postgresql or mysql").option("--tier <tier>", "machine tier id (see `lc db tiers`)").option("--region <region>", "region id").option("--storage <gb>", "storage in GB").option("--ha", "high availability").option("--no-watch", "do not wait for provisioning").action(async (name, options, command) => {
+    const ctx = contextFrom(command);
+    const org = await ctx.resolveOrg();
+    intro2(`${brand()} database`);
+    const config = await ctx.api.platformConfig().catch(() => null);
+    const types = (config?.database?.types ?? []).filter((t) => t.available);
+    const tiers = (config?.database?.machineTypes ?? []).filter((t) => t.available);
+    const regions = (config?.database?.regions ?? []).filter((r) => r.available);
+    const chosenName = name ?? await text2("Database name", { flag: "<name>", placeholder: "my-app-db", validate: (v) => v.trim().length < 2 ? "At least 2 characters." : void 0 });
+    const engine = options.engine ?? (types.length ? await select2("Engine", types.map((t) => ({ value: t.id, label: t.label })), { flag: "--engine <type>", initialValue: "postgresql" }) : "postgresql");
+    const tier = options.tier ?? (tiers.length ? await select2(
+      "Tier",
+      tiers.map((t) => ({ value: t.id, label: t.label, hint: [t.ram, t.price != null ? `$${t.price}/mo` : void 0, t.isSharedPool ? "shared pool" : void 0].filter(Boolean).join(" \xB7 ") })),
+      { flag: "--tier <tier>" }
+    ) : void 0);
+    const tierEntry = tiers.find((t) => t.id === tier);
+    const regionChoices = tierEntry?.isSharedPool && config?.database?.sharedPoolRegions?.length ? regions.filter((r) => config.database.sharedPoolRegions.includes(r.id)) : regions;
+    const region = options.region ?? (regionChoices.length ? await select2("Region", regionChoices.map((r) => ({ value: r.id, label: r.label })), { flag: "--region <region>" }) : void 0);
+    const spin = spinner2();
+    spin.start(`Creating ${chosenName}`);
+    const created = await ctx.api.createDatabase({
+      targetOrganisationId: org.id,
+      name: chosenName,
+      databaseType: engine,
+      tier,
+      region,
+      storageGb: options.storage ? Number(options.storage) : void 0,
+      haEnabled: options.ha
+    });
+    spin.stop(`Created ${c.bold(created.name)} ${c.dim(created.id)}`);
+    let final = created;
+    if (options.watch) {
+      const result = await watchResource(ctx.api, { kind: "database", id: created.id, organisationId: org.id });
+      if (!result.ok) {
+        throw new CliError(result.update.deployment_error || "Provisioning failed.", { hint: `Console: ${ctx.dbConsoleUrl(created)}`, exitCode: EXIT.FAILED });
+      }
+      final = await ctx.api.getDatabase(org.id, created.id);
+    }
+    emit(final, () => outro2(options.watch ? `Connection details: ${c.bold(`lc db url ${final.name}`)}` : `Provisioning in the background; check with ${c.bold(`lc db get ${final.name}`)}.`));
+  });
+  db.command("tiers").description("List database tiers, engines and regions").action(async (_options, command) => {
+    const ctx = contextFrom(command);
+    const config = await ctx.api.platformConfig();
+    const database = config.database ?? {};
+    emit(database, () => {
+      out(c.bold("Engines"));
+      for (const t of database.types ?? []) out(`  ${t.id.padEnd(12)} ${t.label}${t.available ? "" : c.dim("  (unavailable)")}`);
+      out();
+      out(c.bold("Tiers"));
+      for (const t of database.machineTypes ?? []) {
+        out(`  ${t.id.padEnd(16)} ${String(t.label).padEnd(10)} ${c.dim([t.ram, t.vCPUs ? `${t.vCPUs} vCPU` : void 0, t.price != null ? `$${t.price}/mo` : void 0, t.isSharedPool ? "shared pool" : void 0].filter(Boolean).join(" \xB7 "))}${t.available ? "" : c.dim("  (unavailable)")}`);
+      }
+      out();
+      out(c.bold("Regions"));
+      for (const r of database.regions ?? []) out(`  ${r.id.padEnd(20)} ${r.label}${r.available ? "" : c.dim("  (unavailable)")}`);
+    });
+  });
+  db.command("delete <name>").alias("rm").description("Delete a database and all its data").action(async (ref, _options, command) => {
+    const ctx = contextFrom(command);
+    const database = await ctx.resolveDb(ref);
+    const org = await ctx.resolveOrg();
+    const ok = await confirm2(`Delete ${c.bold(database.name)} and ALL its data? This cannot be undone.`, { yes: ctx.yes });
+    if (!ok) return;
+    await ctx.api.deleteDatabase(org.id, database.id);
+    emit({ ok: true, id: database.id, name: database.name }, () => log.success(`Deleting ${c.bold(database.name)}.`));
+  });
+  db.command("url [name]").alias("connection-string").description("Print the connection string (secret!)").option("--details", "print host, port, user and password separately").action(async (ref, options, command) => {
+    const ctx = contextFrom(command);
+    const database = await ctx.resolveDb(ref);
+    const org = await ctx.resolveOrg();
+    const details = await ctx.api.connectionDetails(org.id, database.id);
+    emit(details, () => {
+      if (options.details) {
+        printDetails([
+          ["Host", details.host],
+          ["Port", String(details.port)],
+          ["Database", details.database],
+          ["User", details.user],
+          ["Password", details.password],
+          ["SSL", details.sslMode ?? void 0]
+        ]);
+      } else {
+        process.stdout.write(details.connectionString + "\n");
+      }
+    });
+  });
+  db.command("rotate-password [name]").description("Generate a new admin password (apps using the old one must be updated)").option("--password <value>", "use this password instead of a generated one").action(async (ref, options, command) => {
+    const ctx = contextFrom(command);
+    const database = await ctx.resolveDb(ref);
+    const org = await ctx.resolveOrg();
+    const ok = await confirm2(`Rotate the admin password of ${c.bold(database.name)}? Existing connections using the old password will break.`, { yes: ctx.yes });
+    if (!ok) return;
+    const result = await ctx.api.rotatePassword(org.id, database.id, options.password);
+    emit(result, () => {
+      log.success("Password rotated.");
+      out(`  ${c.bold("New password")}  ${result.password}`);
+      out(c.dim("  Update DATABASE_URL on every app that uses this database (lc env vars set \u2026)."));
+    });
+  });
+  db.command("dump [name]").description("Download a compressed SQL dump").option("-o, --output <file>", "file to write (default: <name>-<date>.sql.gz)").action(async (ref, options, command) => {
+    const ctx = contextFrom(command);
+    const database = await ctx.resolveDb(ref);
+    const org = await ctx.resolveOrg();
+    const response = await ctx.api.dumpDatabase(org.id, database.id);
+    const disposition = response.headers.get("content-disposition") ?? "";
+    const suggested = disposition.match(/filename="([^"]+)"/)?.[1] ?? `${database.slug || database.name}-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.sql.gz`;
+    const target = path5.resolve(options.output ?? suggested);
+    if (!response.body) throw new CliError("The API returned an empty dump.", { exitCode: EXIT.FAILED });
+    const spin = spinner2();
+    spin.start(`Downloading dump of ${database.name}`);
+    let bytes = 0;
+    const counter = new Transform({
+      transform(chunk, _encoding, callback) {
+        bytes += chunk.length;
+        if (bytes % (5 * 1024 * 1024) < chunk.length) spin.message(`Downloading dump of ${database.name} ${c.dim(formatBytes(bytes))}`);
+        callback(null, chunk);
+      }
+    });
+    await pipeline(Readable.fromWeb(response.body), counter, fs5.createWriteStream(target));
+    spin.stop(`Saved ${c.bold(target)} ${c.dim(`(${formatBytes(bytes)})`)}`);
+    emit({ ok: true, file: target, bytes }, () => void 0);
+  });
+}
+function printDb(db, consoleUrl) {
+  heading(`${db.name}  ${statusBadge(db.status)}`);
+  printDetails([
+    ["Engine", `${db.database_type}${db.engine ? c.dim(`  ${db.engine}`) : ""}`],
+    ["Tier", `${db.tier} ${c.dim(sym.bullet)} ${db.storage_gb} GB${db.ha_enabled ? ` ${c.dim(sym.bullet)} HA` : ""}`],
+    ["Region", db.region],
+    ["Host", db.connection_hostname || db.connection_host || void 0],
+    ["Port", db.connection_port != null ? String(db.connection_port) : void 0],
+    ["Database", db.database_name ?? void 0],
+    ["User", db.admin_user ? maskSecret(db.admin_user) : void 0],
+    ["Ready", relativeTime(db.ready_at)],
+    ["Console", c.dim(consoleUrl)],
+    ["ID", c.dim(db.id)]
+  ]);
+  if (db.status === "failed" && db.deployment_error) {
+    out();
+    out(`  ${c.red(sym.fail)} ${db.deployment_error}`);
+  }
+  if (!isJson() && db.status === "ready") {
+    out();
+    out(c.dim(`  lc db url ${db.name}  for the connection string`));
+  }
+}
+
+// src/commands/deploy.ts
+import * as path8 from "path";
+
+// src/lib/detection/detect.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+
+// src/lib/detection/catalogue.ts
+var FRAMEWORKS = [
+  { id: "nextjs", label: "Next.js", category: "fullstack", runtime: "nodejs", deploymentType: "container", buildScript: "build", outputDirectory: "out", defaultPort: 3e3, available: true, detection: { npmDeps: ["next"], priority: 100 } },
+  { id: "nuxt", label: "Nuxt", category: "fullstack", runtime: "nodejs", deploymentType: "container", buildScript: "build", outputDirectory: ".output/public", defaultPort: 3e3, available: true, detection: { npmDeps: ["nuxt", "nuxt3"], priority: 100 } },
+  { id: "sveltekit", label: "SvelteKit", category: "fullstack", runtime: "nodejs", deploymentType: "container", buildScript: "build", outputDirectory: "build", defaultPort: 3e3, available: true, detection: { npmDeps: ["@sveltejs/kit"], priority: 100 } },
+  { id: "remix", label: "Remix", category: "fullstack", runtime: "nodejs", deploymentType: "container", buildScript: "build", defaultPort: 3e3, available: true, detection: { npmDeps: ["@remix-run/dev", "@remix-run/node", "@remix-run/serve"], priority: 100 } },
+  { id: "astro", label: "Astro", category: "fullstack", runtime: "nodejs", deploymentType: "static", buildScript: "build", outputDirectory: "dist", defaultPort: 4321, available: true, detection: { npmDeps: ["astro"], priority: 100 } },
+  { id: "django", label: "Django", category: "fullstack", runtime: "python", deploymentType: "container", defaultPort: 8e3, available: true, detection: { rootFiles: ["manage.py"], manifest: { file: "requirements.txt", needles: ["django"] }, priority: 90 } },
+  { id: "rails", label: "Ruby on Rails", category: "fullstack", runtime: "ruby", deploymentType: "container", defaultPort: 3e3, available: true, detection: { manifest: { file: "Gemfile", needles: ["rails"] }, priority: 90 } },
+  { id: "laravel", label: "Laravel", category: "fullstack", runtime: "php", deploymentType: "container", defaultPort: 8080, available: true, detection: { rootFiles: ["artisan"], manifest: { file: "composer.json", needles: ["laravel/framework"] }, priority: 90 } },
+  { id: "symfony", label: "Symfony", category: "fullstack", runtime: "php", deploymentType: "container", defaultPort: 8080, available: true, detection: { manifest: { file: "composer.json", needles: ["symfony/framework-bundle", "symfony/symfony"] }, priority: 90 } },
+  { id: "wordpress", label: "WordPress", category: "fullstack", runtime: "php", deploymentType: "container", defaultPort: 8080, available: true, detection: { rootFiles: ["wp-config.php", "wp-config-sample.php", "wp-load.php", "wp-settings.php", "wp-content", "wp-includes", "wp-admin"], manifest: { file: "composer.json", needles: ["johnpbloch/wordpress", "roots/wordpress", "wpackagist-"] }, priority: 95 } },
+  { id: "blazor", label: "Blazor", category: "fullstack", runtime: "dotnet", deploymentType: "container", defaultPort: 8080, available: true },
+  { id: "wasp", label: "Wasp", category: "fullstack", runtime: "nodejs", deploymentType: "container", defaultPort: 8080, available: true, detection: { rootFiles: [".wasproot", "main.wasp", "main.wasp.ts"], npmDeps: ["wasp", "@wasp.sh/spec"], priority: 110 } },
+  { id: "react", label: "React", category: "frontend", runtime: null, deploymentType: "static", buildScript: "build", outputDirectory: "dist", available: true, detection: { npmDeps: ["react"], priority: 50 } },
+  { id: "vue", label: "Vue", category: "frontend", runtime: null, deploymentType: "static", buildScript: "build", outputDirectory: "dist", available: true, detection: { npmDeps: ["vue"], priority: 60 } },
+  { id: "angular", label: "Angular", category: "frontend", runtime: null, deploymentType: "static", buildScript: "build", outputDirectory: "dist/browser", available: true, detection: { npmDeps: ["@angular/core"], priority: 70 } },
+  { id: "svelte", label: "Svelte", category: "frontend", runtime: null, deploymentType: "static", buildScript: "build", outputDirectory: "dist", available: true, detection: { npmDeps: ["svelte"], priority: 60 } },
+  { id: "solid", label: "SolidJS", category: "frontend", runtime: null, deploymentType: "static", buildScript: "build", outputDirectory: "dist", available: true, detection: { npmDeps: ["solid-js"], priority: 70 } },
+  { id: "qwik", label: "Qwik", category: "frontend", runtime: "nodejs", deploymentType: "static", buildScript: "build", outputDirectory: "dist", defaultPort: 3e3, available: true, detection: { npmDeps: ["@builder.io/qwik"], priority: 70 } },
+  { id: "nestjs", label: "NestJS", category: "backend", runtime: "nodejs", deploymentType: "container", buildScript: "build", defaultPort: 3e3, available: true, detection: { npmProdDeps: ["@nestjs/core"], priority: 90 } },
+  { id: "adonisjs", label: "AdonisJS", category: "backend", runtime: "nodejs", deploymentType: "container", buildScript: "build", defaultPort: 3333, available: true, detection: { npmProdDeps: ["@adonisjs/core"], priority: 90 } },
+  { id: "hono", label: "Hono", category: "backend", runtime: "nodejs", deploymentType: "container", defaultPort: 3e3, available: true, detection: { npmProdDeps: ["hono"], priority: 85 } },
+  { id: "fastify", label: "Fastify", category: "backend", runtime: "nodejs", deploymentType: "container", defaultPort: 3e3, available: true, detection: { npmProdDeps: ["fastify"], priority: 80 } },
+  { id: "express", label: "Express", category: "backend", runtime: "nodejs", deploymentType: "container", defaultPort: 8080, available: true, detection: { npmProdDeps: ["express", "koa", "@hapi/hapi", "hapi"], priority: 80 } },
+  { id: "nodejs", label: "Node.js", category: "backend", runtime: "nodejs", deploymentType: "container", defaultPort: 8080, available: true, detection: { rootFiles: ["package.json"], priority: 10 } },
+  { id: "flask", label: "Flask", category: "backend", runtime: "python", deploymentType: "container", defaultPort: 8e3, available: true, detection: { manifest: { file: "requirements.txt", needles: ["flask"] }, priority: 85 } },
+  { id: "fastapi", label: "FastAPI", category: "backend", runtime: "python", deploymentType: "container", defaultPort: 8e3, available: true, detection: { manifest: { file: "requirements.txt", needles: ["fastapi"] }, priority: 86 } },
+  { id: "python", label: "Python", category: "backend", runtime: "python", deploymentType: "container", defaultPort: 8e3, available: true, detection: { rootFiles: ["requirements.txt", "pyproject.toml", "setup.py"], priority: 10 } },
+  { id: "gin", label: "Gin", category: "backend", runtime: "go", deploymentType: "container", defaultPort: 8080, available: true, detection: { manifest: { file: "go.mod", needles: ["github.com/gin-gonic/gin"] }, priority: 85 } },
+  { id: "echo", label: "Echo", category: "backend", runtime: "go", deploymentType: "container", defaultPort: 8080, available: true, detection: { manifest: { file: "go.mod", needles: ["github.com/labstack/echo"] }, priority: 85 } },
+  { id: "fiber", label: "Fiber", category: "backend", runtime: "go", deploymentType: "container", defaultPort: 8080, available: true, detection: { manifest: { file: "go.mod", needles: ["github.com/gofiber/fiber"] }, priority: 85 } },
+  { id: "go", label: "Go", category: "backend", runtime: "go", deploymentType: "container", defaultPort: 8080, available: true, detection: { rootFiles: ["go.mod"], priority: 10 } },
+  { id: "springboot", label: "Spring Boot", category: "backend", runtime: "java", deploymentType: "container", defaultPort: 8080, available: true, detection: { manifest: { file: "pom.xml", needles: ["spring-boot"] }, priority: 85 } },
+  { id: "quarkus", label: "Quarkus", category: "backend", runtime: "java", deploymentType: "container", defaultPort: 8080, available: true, detection: { manifest: { file: "pom.xml", needles: ["quarkus"] }, priority: 85 } },
+  { id: "java", label: "Java", category: "backend", runtime: "java", deploymentType: "container", defaultPort: 8080, available: true, detection: { rootFiles: ["pom.xml", "build.gradle", "build.gradle.kts"], priority: 10 } },
+  { id: "sinatra", label: "Sinatra", category: "backend", runtime: "ruby", deploymentType: "container", defaultPort: 3e3, available: true, detection: { manifest: { file: "Gemfile", needles: ["sinatra"] }, priority: 85 } },
+  { id: "ruby", label: "Ruby", category: "backend", runtime: "ruby", deploymentType: "container", defaultPort: 3e3, available: true, detection: { rootFiles: ["Gemfile", "config.ru"], priority: 10 } },
+  { id: "aspnet", label: "ASP.NET", category: "backend", runtime: "dotnet", deploymentType: "container", defaultPort: 8080, available: true, detection: { rootFileExtensions: [".csproj", ".sln", ".fsproj"], priority: 10 } },
+  { id: "php", label: "PHP", category: "backend", runtime: "php", deploymentType: "container", defaultPort: 8080, available: true, detection: { rootFiles: ["composer.json", "index.php"], priority: 10 } },
+  { id: "gatsby", label: "Gatsby", category: "frontend", runtime: null, deploymentType: "static", buildScript: "build", outputDirectory: "public", available: true, detection: { npmDeps: ["gatsby"], priority: 95 } },
+  { id: "docusaurus", label: "Docusaurus", category: "frontend", runtime: null, deploymentType: "static", buildScript: "build", outputDirectory: "build", available: true, detection: { npmDeps: ["@docusaurus/core"], priority: 95 } },
+  { id: "eleventy", label: "Eleventy", category: "frontend", runtime: null, deploymentType: "static", buildScript: "build", outputDirectory: "_site", available: true, detection: { npmDeps: ["@11ty/eleventy"], rootFiles: [".eleventy.js", "eleventy.config.js"], priority: 95 } },
+  { id: "html", label: "Static HTML", category: "frontend", runtime: null, deploymentType: "static", outputDirectory: ".", available: true, detection: { rootFiles: ["index.html"], priority: 5 } },
+  { id: "hugo", label: "Hugo", category: "frontend", runtime: null, deploymentType: "static", outputDirectory: "public", available: false, detection: { rootFiles: ["hugo.toml", "hugo.yaml", "hugo.json", "config.toml"], priority: 95 } },
+  { id: "jekyll", label: "Jekyll", category: "frontend", runtime: null, deploymentType: "static", outputDirectory: "_site", available: false, detection: { rootFiles: ["_config.yml"], priority: 95 } },
+  { id: "custom", label: "Dockerfile", category: "backend", runtime: "custom", deploymentType: "container", defaultPort: 8080, available: true }
+];
+function getFrameworkById(id) {
+  return FRAMEWORKS.find((framework) => framework.id === id);
+}
+
+// src/lib/detection/detect.ts
+var MANIFEST_FILES = [
+  "package.json",
+  "requirements.txt",
+  "pyproject.toml",
+  "go.mod",
+  "pom.xml",
+  "build.gradle",
+  "Gemfile",
+  "composer.json"
+];
+var ENV_FILES = [".env", ".env.local", ".env.example", ".env.development", ".env.production"];
+function readIfExists(file) {
+  try {
+    return fs6.readFileSync(file, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+function gatherSignals(directory) {
+  let rootFiles = [];
+  try {
+    rootFiles = fs6.readdirSync(directory);
+  } catch {
+    rootFiles = [];
+  }
+  const manifests = {};
+  for (const name of MANIFEST_FILES) {
+    if (rootFiles.includes(name)) {
+      const contents = readIfExists(path6.join(directory, name));
+      if (contents !== void 0) manifests[name] = contents;
+    }
+  }
+  if (!manifests["pom.xml"] && rootFiles.includes("build.gradle.kts")) {
+    manifests["pom.xml"] = readIfExists(path6.join(directory, "build.gradle.kts"));
+  }
+  if (!manifests["pom.xml"] && manifests["build.gradle"]) manifests["pom.xml"] = manifests["build.gradle"];
+  if (!manifests["requirements.txt"] && manifests["pyproject.toml"]) {
+    manifests["requirements.txt"] = manifests["pyproject.toml"];
+  }
+  let packageJson = null;
+  if (manifests["package.json"]) {
+    try {
+      packageJson = JSON.parse(manifests["package.json"]);
+    } catch {
+      packageJson = null;
+    }
+  }
+  const prod = Object.keys(packageJson?.dependencies ?? {});
+  const dev = Object.keys(packageJson?.devDependencies ?? {});
+  return {
+    rootFiles,
+    npmDependencies: [.../* @__PURE__ */ new Set([...prod, ...dev])],
+    npmProdDependencies: prod,
+    manifests,
+    packageJson
+  };
+}
+var WHOLE_NAME_MANIFESTS = /* @__PURE__ */ new Set(["Gemfile", "requirements.txt"]);
+function manifestNeedleMatches(file, haystack, needle) {
+  const lowered = needle.toLowerCase();
+  if (!WHOLE_NAME_MANIFESTS.has(file)) return haystack.includes(lowered);
+  const escaped = lowered.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(^|[^a-z0-9_-])${escaped}($|[^a-z0-9_-])`, "m").test(haystack);
+}
+function matchesDetection(detection, signals) {
+  if (detection.npmDeps?.some((dep) => signals.npmDependencies.includes(dep))) return true;
+  if (detection.npmProdDeps?.some((dep) => signals.npmProdDependencies.includes(dep))) return true;
+  if (detection.rootFiles?.some((file) => signals.rootFiles.includes(file))) return true;
+  if (detection.rootFileExtensions?.some((ext) => signals.rootFiles.some((file) => file.toLowerCase().endsWith(ext)))) {
+    return true;
+  }
+  if (detection.manifest) {
+    const contents = signals.manifests[detection.manifest.file];
+    if (contents) {
+      const haystack = contents.toLowerCase();
+      if (detection.manifest.needles.some((needle) => manifestNeedleMatches(detection.manifest.file, haystack, needle))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function matchFramework(signals) {
+  let best = null;
+  let bestPriority = -1;
+  for (const framework of FRAMEWORKS) {
+    if (!framework.detection) continue;
+    if (!matchesDetection(framework.detection, signals)) continue;
+    if (framework.detection.priority > bestPriority) {
+      best = framework;
+      bestPriority = framework.detection.priority;
+    }
+  }
+  return best;
+}
+function resolvePackageManager(rootFiles, packageJson) {
+  const declared = packageJson?.packageManager?.split("@")[0];
+  if (declared === "pnpm" || declared === "yarn" || declared === "bun" || declared === "npm") return declared;
+  if (rootFiles.includes("pnpm-lock.yaml")) return "pnpm";
+  if (rootFiles.includes("yarn.lock")) return "yarn";
+  if (rootFiles.includes("bun.lockb") || rootFiles.includes("bun.lock")) return "bun";
+  return "npm";
+}
+function installCommandFor(pm, rootFiles) {
+  switch (pm) {
+    case "pnpm":
+      return "pnpm install --frozen-lockfile";
+    case "yarn":
+      return "yarn install --frozen-lockfile";
+    case "bun":
+      return "bun install";
+    default:
+      return rootFiles.includes("package-lock.json") ? "npm ci" : "npm install";
+  }
+}
+function runScript(pm, script) {
+  if (pm === "npm" && script === "start") return "npm start";
+  return `${pm} run ${script}`;
+}
+function readFirst(directory, candidates) {
+  for (const candidate of candidates) {
+    const contents = readIfExists(path6.join(directory, candidate));
+    if (contents !== void 0) return contents;
+  }
+  return void 0;
+}
+function refineDeployment(framework, directory, signals) {
+  const base = {
+    deploymentType: framework.deploymentType,
+    outputDirectory: framework.outputDirectory,
+    containerPort: framework.defaultPort,
+    notes: []
+  };
+  switch (framework.id) {
+    case "nextjs": {
+      const config = readFirst(directory, ["next.config.js", "next.config.mjs", "next.config.ts", "next.config.mts", "next.config.cjs"]);
+      const output = config?.match(/output\s*:\s*['"`](\w+)['"`]/)?.[1];
+      const distDir = config?.match(/distDir\s*:\s*['"`]([^'"`]+)['"`]/)?.[1];
+      if (output === "export") {
+        return { deploymentType: "static", outputDirectory: distDir || "out", notes: ["output: export"] };
+      }
+      return {
+        deploymentType: "container",
+        containerPort: 3e3,
+        notes: [output === "standalone" ? "output: standalone" : "SSR mode"]
+      };
+    }
+    case "nuxt": {
+      const config = readFirst(directory, ["nuxt.config.ts", "nuxt.config.js", "nuxt.config.mjs"]);
+      const prerendered = config ? /ssr\s*:\s*false|preset\s*:\s*['"`]static['"`]|prerender\s*:\s*\{[^}]*routes/.test(config) : false;
+      if (prerendered) {
+        return { deploymentType: "static", outputDirectory: ".output/public", notes: ["prerendered"] };
+      }
+      return { deploymentType: "container", containerPort: 3e3, notes: ["SSR mode"] };
+    }
+    case "astro": {
+      const config = readFirst(directory, ["astro.config.mjs", "astro.config.ts", "astro.config.js", "astro.config.cjs"]);
+      const serverOutput = config ? /output\s*:\s*['"`](server|hybrid)['"`]/.test(config) : false;
+      const hasNodeAdapter = signals.npmDependencies.includes("@astrojs/node");
+      if (serverOutput || hasNodeAdapter) {
+        return { deploymentType: "container", containerPort: 4321, notes: ["server output"] };
+      }
+      return { deploymentType: "static", outputDirectory: "dist", notes: ["static output"] };
+    }
+    case "sveltekit": {
+      if (signals.npmDependencies.includes("@sveltejs/adapter-static")) {
+        return { deploymentType: "static", outputDirectory: "build", notes: ["adapter-static"] };
+      }
+      return { deploymentType: "container", containerPort: 3e3, notes: ["adapter-node"] };
+    }
+    case "react": {
+      if (!signals.npmDependencies.includes("vite") && signals.npmDependencies.includes("react-scripts")) {
+        return { ...base, outputDirectory: "build", notes: ["create-react-app"] };
+      }
+      return base;
+    }
+    case "angular": {
+      const angularJson = readIfExists(path6.join(directory, "angular.json"));
+      const outputPath = angularJson?.match(/"outputPath"\s*:\s*"([^"]+)"/)?.[1];
+      if (outputPath) return { ...base, outputDirectory: outputPath.endsWith("/browser") ? outputPath : `${outputPath}/browser`, notes: [] };
+      return base;
+    }
+    default:
+      return base;
+  }
+}
+function detectLocalProject(directory = process.cwd()) {
+  const signals = gatherSignals(directory);
+  const hasDockerfile = signals.rootFiles.includes("Dockerfile");
+  const envFiles = ENV_FILES.filter((file) => signals.rootFiles.includes(file));
+  const matched = matchFramework(signals);
+  if (!matched) {
+    if (hasDockerfile) {
+      const custom = getFrameworkById("custom");
+      return {
+        framework: custom.id,
+        frameworkLabel: custom.label,
+        runtime: "custom",
+        deploymentType: "container",
+        containerPort: custom.defaultPort,
+        hasDockerfile,
+        envFiles,
+        confidence: "medium",
+        notes: ["Dockerfile at root"]
+      };
+    }
+    return { deploymentType: "static", hasDockerfile, envFiles, confidence: "low", notes: [] };
+  }
+  const refinement = refineDeployment(matched, directory, signals);
+  const reported = refinement.framework && getFrameworkById(refinement.framework) || matched;
+  const isNode = reported.runtime === "nodejs" || reported.runtime === null;
+  const scripts = signals.packageJson?.scripts ?? {};
+  const result = {
+    framework: reported.id,
+    frameworkLabel: reported.label,
+    runtime: reported.runtime ?? void 0,
+    deploymentType: refinement.deploymentType,
+    outputDirectory: refinement.deploymentType === "static" ? refinement.outputDirectory : void 0,
+    containerPort: refinement.deploymentType === "container" ? refinement.containerPort : void 0,
+    hasDockerfile,
+    envFiles,
+    nodeVersion: signals.packageJson?.engines?.node,
+    confidence: matched.detection && matched.detection.priority >= 50 ? "high" : "medium",
+    notes: [...refinement.notes]
+  };
+  if (isNode && signals.packageJson) {
+    const pm = resolvePackageManager(signals.rootFiles, signals.packageJson);
+    result.packageManager = pm;
+    result.installCommand = installCommandFor(pm, signals.rootFiles);
+    const buildScript = reported.buildScript && scripts[reported.buildScript] ? reported.buildScript : scripts.build ? "build" : void 0;
+    if (buildScript) result.buildCommand = runScript(pm, buildScript);
+    if (scripts.start && refinement.deploymentType === "container") result.startCommand = runScript(pm, "start");
+  }
+  if (result.deploymentType === "static" && !result.buildCommand && reported.id !== "html" && isNode) {
+    result.notes.push("no build script found");
+  }
+  if (hasDockerfile && result.deploymentType === "container") {
+    result.notes.push("Dockerfile at root");
+  }
+  return result;
+}
+
+// src/lib/detection/git.ts
+import { execFileSync } from "child_process";
+import * as fs7 from "fs";
+import * as path7 from "path";
+function git(args, cwd) {
+  try {
+    return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function detectGit(directory = process.cwd()) {
+  const root = git(["rev-parse", "--show-toplevel"], directory);
+  if (!root) {
+    return { hasGit: fs7.existsSync(path7.join(directory, ".git")) };
+  }
+  const info = { hasGit: true, root };
+  info.remoteUrl = git(["remote", "get-url", "origin"], directory) || void 0;
+  if (info.remoteUrl) Object.assign(info, parseRemote(info.remoteUrl));
+  const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], directory);
+  info.branch = branch && branch !== "HEAD" ? branch : void 0;
+  info.commit = git(["rev-parse", "--short", "HEAD"], directory) || void 0;
+  const status = git(["status", "--porcelain"], directory);
+  info.isDirty = status === void 0 ? void 0 : status.length > 0;
+  return info;
+}
+function parseRemote(url) {
+  const match = url.match(/^(?:https?|ssh):\/\/(?:[^@/]+@)?([^/:]+)(?::\d+)?\/(.+?)(?:\.git)?\/?$/) || url.match(/^(?:[^@]+@)?([^:/]+):(.+?)(?:\.git)?\/?$/);
+  if (!match) return {};
+  const host = match[1].toLowerCase();
+  const segments = match[2].split("/").filter(Boolean);
+  if (segments.length < 2) return { host };
+  const repo = segments[segments.length - 1];
+  const owner = segments.slice(0, -1).join("/");
+  let provider;
+  if (host === "github.com" || host.endsWith(".github.com")) provider = "github";
+  else if (host === "gitlab.com" || host.includes("gitlab")) provider = "gitlab";
+  else if (host === "bitbucket.org" || host.includes("bitbucket")) provider = "bitbucket";
+  return { host, owner, repo, provider };
+}
+function webUrlFor(info) {
+  if (!info.host || !info.owner || !info.repo) return void 0;
+  return `https://${info.host}/${info.owner}/${info.repo}`;
+}
+
+// src/commands/deploy.ts
+function registerDeployCommand(program2) {
+  program2.command("deploy [app]").description("Deploy an app (the linked app by default) and follow the build").option("-e, --env <env>", "environment to deploy (default: production)").option("-u, --upload", "upload the local folder as the source instead of pulling from git").option("-d, --dir <path>", "folder to upload (with --upload)", ".").option("--no-watch", "queue the deployment and return immediately").action(async (positional, options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(positional);
+    const env = await ctx.resolveEnv(app, options.env);
+    const isUploadApp = app.git_provider === "upload" || app.github_repo_url?.startsWith("upload://");
+    intro2(`${brand()} deploy`);
+    if (!isJson()) {
+      out(`${c.dim("\u2502")}  ${c.bold(app.name)} ${c.dim(sym.arrow)} ${env.name}${env.is_production ? c.accent(` ${sym.star}`) : ""}`);
+    }
+    let uploadId;
+    if (options.upload) {
+      uploadId = await uploadForDeploy(ctx, options.dir);
+    } else if (isUploadApp) {
+      if (!isJson()) out(`${c.dim("\u2502")}  Source: last upload ${c.dim("(pass --upload to send this folder)")}`);
+    } else if (!isJson()) {
+      out(`${c.dim("\u2502")}  Source: ${sourceLabel(app)} ${c.dim(`@ ${env.github_branch}`)}`);
+    }
+    if (!isJson()) out(c.dim("\u2502"));
+    const result = await runDeploy(ctx, { app, env, uploadId, watch: options.watch });
+    const url = result.watched?.update.deployed_url || env.deployed_url;
+    emit(
+      {
+        ok: true,
+        application: { id: app.id, name: app.name },
+        environment: { id: env.id, name: env.name },
+        uploadId,
+        status: result.watched?.status ?? "queued",
+        url,
+        durationMs: result.watched?.elapsedMs
+      },
+      () => {
+        if (!options.watch) {
+          outro2(`Queued. Follow it with ${c.bold(`lc status ${app.name}`)} or ${c.bold("lc logs -f")}.`);
+        } else {
+          outro2(url ? `Live at ${link(url)}` : "Done.");
+        }
+      }
+    );
+  });
+}
+async function uploadForDeploy(ctx, dir) {
+  const directory = path8.resolve(dir);
+  const detection = detectLocalProject(directory);
+  const git2 = detectGit(directory);
+  if (!isJson()) out(`${c.dim("\u2502")}  Source: upload ${c.dim(directory)}  ${describeDetection(detection)}`);
+  warnIfDirty(git2.isDirty, git2.branch);
+  if (!detection.framework && !detection.hasDockerfile) {
+    throw new CliError(`Could not tell what kind of project ${directory} is.`, {
+      hint: "Run from the project root (where package.json, requirements.txt, go.mod or a Dockerfile lives).",
+      exitCode: EXIT.USAGE
+    });
+  }
+  const upload = await uploadSource(ctx, directory, detection);
+  log.step(c.dim(`upload ${upload.uploadId}`));
+  return upload.uploadId;
+}
+
+// src/commands/deployments.ts
+function registerDeploymentCommands(program2) {
+  program2.command("deployments [app]").alias("history").description("Deployment history of an environment").option("-e, --env <env>", "environment (default: production)").option("-n, --limit <n>", "how many to show (max 20)", "10").action(async (positional, options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(positional);
+    const env = await ctx.resolveEnv(app, options.env);
+    const org = await ctx.resolveOrg();
+    const page = await ctx.api.listDeployments(org.id, env.id, Math.min(20, Math.max(1, Number(options.limit) || 10)));
+    emit(page, () => {
+      heading(`${app.name} / ${env.name} ${c.dim(`\xB7 ${page.total} deployment${page.total === 1 ? "" : "s"}`)}`);
+      out();
+      if (page.deployments.length === 0) {
+        log.info("No deployments yet.");
+        return;
+      }
+      printDeploymentsTable(page.deployments);
+      out();
+      out(c.dim(`  lc deployment <id> for the build log \xB7 lc rollback to go back`));
+    });
+  });
+  program2.command("deployment <id>").description("Show one deployment with its build log").action(async (id, _options, command) => {
+    const ctx = contextFrom(command);
+    const org = await ctx.resolveOrg();
+    const deployment = await ctx.api.getDeployment(org.id, id);
+    emit(deployment, () => printDeployment(deployment));
+  });
+  program2.command("rollback [deployment]").description("Roll an environment back to an earlier deployment (no rebuild)").option("-a, --app <app>", "app name or id").option("-e, --env <env>", "environment (default: production)").option("--no-watch", "do not wait for the rollback to finish").action(async (ref, options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(options.app);
+    const env = await ctx.resolveEnv(app, options.env);
+    const org = await ctx.resolveOrg();
+    const page = await ctx.api.listDeployments(org.id, env.id, 20);
+    const eligible = page.deployments.filter((d) => d.rollback_eligible && !d.is_current);
+    let target;
+    if (ref) {
+      target = page.deployments.find((d) => d.id === ref || d.id.startsWith(ref));
+      if (!target) throw new CliError(`No deployment "${ref}" on ${app.name} / ${env.name}.`, { hint: "Run `lc deployments` to list them.", exitCode: EXIT.NOT_FOUND });
+      if (!target.rollback_eligible) throw new CliError(`Deployment ${shortId(target.id, 10)} cannot be rolled back to.`, { hint: "Only successful deployments within the rollback window are eligible.", exitCode: EXIT.USAGE });
+      if (target.is_current) throw new CliError("That deployment is already live.", { exitCode: EXIT.USAGE });
+    } else {
+      if (eligible.length === 0) throw new CliError(`Nothing to roll back to on ${app.name} / ${env.name}.`, { exitCode: EXIT.NOT_FOUND });
+      const id = await select2(
+        "Roll back to",
+        eligible.map((d) => ({
+          value: d.id,
+          label: `${d.commit_sha ? d.commit_sha.slice(0, 7) : shortId(d.id, 10)}  ${d.commit_message?.split("\n")[0] ?? ""}`.trim(),
+          hint: `${relativeTime(d.started_at)} \xB7 ${d.deployed_by_name}`
+        })),
+        { flag: "<deployment id>" }
+      );
+      target = eligible.find((d) => d.id === id);
+    }
+    const ok = await confirm2(
+      `Roll ${c.bold(`${app.name} / ${env.name}`)} back to ${c.accent(target.commit_sha?.slice(0, 7) ?? shortId(target.id, 10))} ${c.dim(`(${relativeTime(target.started_at)})`)}?`,
+      { yes: ctx.yes, initialValue: true }
+    );
+    if (!ok) return;
+    const result = await ctx.api.rollback(org.id, env.id, target.id);
+    if (!isJson()) out(`${c.green(sym.ok)} Rollback queued ${c.dim(shortId(result.deployment?.id, 10))}`);
+    let final = result;
+    if (options.watch) {
+      const watched = await watchResource(ctx.api, { kind: "environment", id: env.id, organisationId: org.id });
+      if (!watched.ok) {
+        throw new CliError(watched.update.deployment_error || "Rollback failed.", { exitCode: EXIT.FAILED });
+      }
+      final = { deployment: { ...result.deployment, status: watched.status, deployed_url: watched.update.deployed_url } };
+    }
+    emit({ ok: true, ...final }, () => void 0);
+  });
+}
+function printDeployment(deployment) {
+  heading(`Deployment ${shortId(deployment.id, 10)}  ${statusBadge(deployment.status)}`);
+  printDetails([
+    ["App", deployment.application_name ? `${deployment.application_name} / ${deployment.environment_name ?? ""}` : void 0],
+    ["Commit", deployment.commit_sha ? `${c.accent(deployment.commit_sha.slice(0, 7))} ${deployment.commit_message?.split("\n")[0] ?? ""}${deployment.commit_author ? c.dim(`  ${deployment.commit_author}`) : ""}` : void 0],
+    ["By", deployment.deployed_by_name],
+    ["Started", `${relativeTime(deployment.started_at)} ${c.dim(deployment.started_at)}`],
+    ["Duration", deployment.duration_seconds != null ? formatDuration(deployment.duration_seconds * 1e3) : void 0],
+    ["URL", deployment.deployed_url ? link(deployment.deployed_url) : void 0],
+    ["Rollback", deployment.is_current ? "current" : deployment.rollback_eligible ? "eligible" : "not eligible"],
+    ["Error", deployment.deployment_error ? c.red(deployment.deployment_error) : void 0]
+  ]);
+  if (deployment.deployment_logs?.length) {
+    out();
+    const renderer = new StepRenderer(false);
+    renderer.render(deployment.deployment_logs);
+  }
+}
+
+// src/commands/domains.ts
+function registerDomainCommands(program2) {
+  const domains = program2.command("domains").alias("domain").description("Custom domains for an environment");
+  domains.command("show", { isDefault: true }).description("Show the custom domain and its DNS status").option("-a, --app <app>", "app name or id").option("-e, --env <env>", "environment (default: production)").action(async (options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(options.app);
+    const env = await ctx.resolveEnv(app, options.env);
+    const org = await ctx.resolveOrg();
+    const full = await ctx.api.getEnvironment(org.id, env.id);
+    emit({ domain: full.custom_domain, status: full.custom_domain_status, dns: full.custom_domain_dns, url: full.deployed_url }, () => {
+      heading(`${app.name} / ${env.name}`);
+      if (!full.custom_domain) {
+        log.info(`No custom domain. Add one with ${c.bold("lc domains add example.com")}.`);
+        return;
+      }
+      printDetails([
+        ["Domain", `${c.bold(full.custom_domain)}  ${statusBadge(full.custom_domain_status ?? "unknown")}`],
+        ["Serves", full.deployed_url ?? void 0]
+      ]);
+      if (full.custom_domain_dns?.length) {
+        out();
+        printDns(full.custom_domain_dns);
+      }
+    });
+  });
+  domains.command("add <domain>").description("Attach a custom domain (prints the DNS records to create)").option("-a, --app <app>", "app name or id").option("-e, --env <env>", "environment (default: production)").action(async (domain, options, command) => {
+    const ctx = contextFrom(command);
+    const clean = domain.trim().toLowerCase().replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+    if (!/^[a-z0-9.-]+\.[a-z]{2,}$/.test(clean)) throw new CliError(`"${domain}" is not a domain name.`, { exitCode: EXIT.USAGE });
+    const app = await ctx.resolveApp(options.app);
+    const env = await ctx.resolveEnv(app, options.env);
+    const org = await ctx.resolveOrg();
+    const result = await ctx.api.addDomain(org.id, env.id, clean);
+    emit(result, () => printDomainResult(result, clean));
+  });
+  domains.command("check").description("Re-check DNS for the custom domain").option("-a, --app <app>", "app name or id").option("-e, --env <env>", "environment (default: production)").action(async (options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(options.app);
+    const env = await ctx.resolveEnv(app, options.env);
+    const org = await ctx.resolveOrg();
+    const result = await ctx.api.checkDomain(org.id, env.id);
+    emit(result, () => printDomainResult(result, env.custom_domain ?? result.domain));
+  });
+  domains.command("retry").description("Retry certificate issuance after fixing DNS").option("-a, --app <app>", "app name or id").option("-e, --env <env>", "environment (default: production)").action(async (options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(options.app);
+    const env = await ctx.resolveEnv(app, options.env);
+    const org = await ctx.resolveOrg();
+    const result = await ctx.api.retryDomain(org.id, env.id);
+    emit(result, () => printDomainResult(result, env.custom_domain ?? result.domain));
+  });
+  domains.command("remove").alias("rm").description("Detach the custom domain").option("-a, --app <app>", "app name or id").option("-e, --env <env>", "environment (default: production)").action(async (options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(options.app);
+    const env = await ctx.resolveEnv(app, options.env);
+    const org = await ctx.resolveOrg();
+    if (!env.custom_domain) throw new CliError(`${app.name} / ${env.name} has no custom domain.`, { exitCode: EXIT.NOT_FOUND });
+    const ok = await confirm2(`Remove ${c.bold(env.custom_domain)} from ${app.name} / ${env.name}?`, { yes: ctx.yes });
+    if (!ok) return;
+    const result = await ctx.api.removeDomain(org.id, env.id);
+    emit({ ok: true, ...result }, () => log.success(`Removed ${c.bold(env.custom_domain)}. The app stays reachable at its light-cloud.io address.`));
+  });
+}
+function printDomainResult(result, domain) {
+  const status = result.status ?? "unknown";
+  if (status === "active") log.success(`${c.bold(domain)} is active.`);
+  else log.info(`${c.bold(domain)}  ${statusBadge(status)}`);
+  if (result.message && status !== "active") out(`  ${c.dim(result.message)}`);
+  for (const issue of result.issues ?? []) log.warn(`  ${issue}`);
+  if (result.dnsRecords?.length) {
+    out();
+    printDns(result.dnsRecords);
+    out();
+    out(c.dim("  Create these records at your DNS provider, then run `lc domains check`."));
+  }
+}
+function printDns(records) {
+  printTable(records, [
+    { header: "Type", cell: (r) => c.bold(r.type) },
+    { header: "Name", cell: (r) => r.name },
+    { header: "Value", cell: (r) => r.value, maxWidth: 80 }
+  ]);
+}
+
+// src/commands/envs.ts
+import * as fs8 from "fs";
+function registerEnvCommands(program2) {
+  program2.command("envs [app]").description("List environments of an app").action(async (positional, _options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(positional);
+    const org = await ctx.resolveOrg();
+    const envs = await ctx.api.listEnvironments(org.id, app.id);
+    emit(envs, () => {
+      heading(`${app.name} ${c.dim(`\xB7 ${envs.length} environment${envs.length === 1 ? "" : "s"}`)}`);
+      out();
+      printEnvsTable(envs);
+    });
+  });
+  const env = program2.command("env").description("Manage one environment (create, delete, scale, vars)");
+  env.command("get [env]").description("Show one environment in detail").option("-a, --app <app>", "app name or id").action(async (ref, options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(options.app);
+    const target = await ctx.resolveEnv(app, ref);
+    const org = await ctx.resolveOrg();
+    const full = await ctx.api.getEnvironment(org.id, target.id);
+    emit(full, () => printEnvDetails(full));
+  });
+  env.command("create <name>").description("Create an environment from a branch").option("-a, --app <app>", "app name or id").option("-b, --branch <branch>", "git branch to deploy (default: the app branch)").option("--production", "mark it as the production environment").option("--no-auto-deploy", "do not deploy automatically on push").option("--deploy", "deploy right after creating").option("--memory <size>", "container memory, e.g. 512Mi").option("--min <n>", "minimum instances").option("--max <n>", "maximum instances").action(async (name, options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(options.app);
+    const org = await ctx.resolveOrg();
+    const created = await ctx.api.createEnvironment({
+      targetOrganisationId: org.id,
+      applicationId: app.id,
+      name,
+      githubBranch: options.branch ?? app.github_branch,
+      isProduction: options.production,
+      autoDeploy: options.autoDeploy,
+      memory: options.memory,
+      minInstances: options.min !== void 0 ? Number(options.min) : void 0,
+      maxInstances: options.max !== void 0 ? Number(options.max) : void 0
+    });
+    log.success(`Created ${c.bold(created.name)} ${c.dim(`(${created.github_branch})`)} on ${app.name}.`);
+    if (options.deploy) {
+      await runDeploy(ctx, { app, env: created, watch: true });
+    }
+    emit(created, () => {
+      if (!options.deploy) log.info(`Deploy it with ${c.bold(`lc deploy --env ${created.name}`)}.`);
+    });
+  });
+  env.command("delete <env>").alias("rm").description("Delete an environment").option("-a, --app <app>", "app name or id").action(async (ref, options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(options.app);
+    const target = await ctx.resolveEnv(app, ref);
+    const org = await ctx.resolveOrg();
+    if (target.is_production) {
+      log.warn("This is the production environment.");
+    }
+    const ok = await confirm2(`Delete ${c.bold(`${app.name} / ${target.name}`)}? This cannot be undone.`, { yes: ctx.yes });
+    if (!ok) return;
+    await ctx.api.deleteEnvironment(org.id, target.id);
+    emit({ ok: true, id: target.id, name: target.name }, () => log.success(`Deleting ${c.bold(target.name)}.`));
+  });
+  env.command("scale [env]").description("Set instance limits (container apps)").option("-a, --app <app>", "app name or id").option("--min <n>", "minimum instances (1 keeps it always on)").option("--max <n>", "maximum instances").action(async (ref, options, command) => {
+    const ctx = contextFrom(command);
+    if (options.min === void 0 && options.max === void 0) {
+      throw new CliError("Nothing to change.", { hint: "Pass --min <n> and/or --max <n>.", exitCode: EXIT.USAGE });
+    }
+    const app = await ctx.resolveApp(options.app);
+    const target = await ctx.resolveEnv(app, ref);
+    const org = await ctx.resolveOrg();
+    const result = await ctx.api.scaleEnvironment(org.id, target.id, {
+      minInstances: options.min !== void 0 ? Number(options.min) : void 0,
+      maxInstances: options.max !== void 0 ? Number(options.max) : void 0
+    });
+    emit(result, () => {
+      const applied = result.applied ?? {};
+      log.success(`${app.name} / ${target.name}: min ${applied.minInstances ?? result.environment?.min_instances ?? "\u2014"}, max ${applied.maxInstances ?? result.environment?.max_instances ?? "\u2014"}.`);
+      if (result.clamped) log.warn("The minimum was clamped by your plan.");
+      if (result.dedicated_addon_notice) log.info(result.dedicated_addon_notice);
+    });
+  });
+  const vars = env.command("vars").description("Environment variables");
+  vars.command("list", { isDefault: true }).description("List variables (values masked unless --reveal)").option("-a, --app <app>", "app name or id").option("-e, --env <env>", "environment (default: production)").option("--reveal", "print values in clear").action(async (options, command) => {
+    const ctx = contextFrom(command);
+    const { target, values } = await loadVars(ctx, options);
+    emit(values, () => {
+      const keys = Object.keys(values).sort();
+      if (keys.length === 0) {
+        log.info(`No variables on ${target.name}. Add one with ${c.bold("lc env vars set KEY=value")}.`);
+        return;
+      }
+      heading(`${target.name} ${c.dim(`\xB7 ${keys.length} variable${keys.length === 1 ? "" : "s"}`)}`);
+      const width = Math.max(...keys.map((key) => key.length));
+      for (const key of keys) {
+        out(`  ${c.bold(key.padEnd(width))}  ${options.reveal ? values[key] : c.dim(maskSecret(values[key] ?? ""))}`);
+      }
+      if (!options.reveal) out(c.dim("  (values masked; --reveal to show)"));
+    });
+  });
+  vars.command("set <pairs...>").description("Set variables: KEY=value [KEY2=value2 \u2026]").option("-a, --app <app>", "app name or id").option("-e, --env <env>", "environment (default: production)").option("--redeploy", "deploy after saving so the change takes effect").action(async (pairs, options, command) => {
+    const ctx = contextFrom(command);
+    const updates = parsePairs(pairs);
+    const { app, target, values } = await loadVars(ctx, options);
+    const next = { ...values, ...updates };
+    await saveVars(ctx, target, next);
+    emit({ ok: true, set: Object.keys(updates), total: Object.keys(next).length }, () => {
+      log.success(`Set ${Object.keys(updates).map((key) => c.bold(key)).join(", ")} on ${app.name} / ${target.name}.`);
+    });
+    await maybeRedeploy(ctx, app, target, options.redeploy);
+  });
+  vars.command("unset <keys...>").description("Remove variables").option("-a, --app <app>", "app name or id").option("-e, --env <env>", "environment (default: production)").option("--redeploy", "deploy after saving").action(async (keys, options, command) => {
+    const ctx = contextFrom(command);
+    const { app, target, values } = await loadVars(ctx, options);
+    const next = { ...values };
+    const missing = keys.filter((key) => !(key in next));
+    for (const key of keys) delete next[key];
+    await saveVars(ctx, target, next);
+    emit({ ok: true, unset: keys.filter((key) => key in values), missing }, () => {
+      if (missing.length) log.warn(`Not set: ${missing.join(", ")}.`);
+      const removed = keys.filter((key) => key in values);
+      if (removed.length) log.success(`Removed ${removed.map((key) => c.bold(key)).join(", ")} from ${app.name} / ${target.name}.`);
+    });
+    await maybeRedeploy(ctx, app, target, options.redeploy);
+  });
+  vars.command("import <file>").description("Load variables from a .env file (merges over existing ones)").option("-a, --app <app>", "app name or id").option("-e, --env <env>", "environment (default: production)").option("--replace", "replace all variables instead of merging").option("--redeploy", "deploy after saving").action(async (file, options, command) => {
+    const ctx = contextFrom(command);
+    let content;
+    try {
+      content = fs8.readFileSync(file, "utf-8");
+    } catch {
+      throw new CliError(`Cannot read ${file}.`, { exitCode: EXIT.USAGE });
+    }
+    const parsed = parseDotenv(content);
+    if (Object.keys(parsed).length === 0) {
+      throw new CliError(`${file} contains no KEY=value lines.`, { exitCode: EXIT.USAGE });
+    }
+    const { app, target, values } = await loadVars(ctx, options);
+    const next = options.replace ? parsed : { ...values, ...parsed };
+    await saveVars(ctx, target, next);
+    emit({ ok: true, imported: Object.keys(parsed), total: Object.keys(next).length }, () => {
+      log.success(`Imported ${Object.keys(parsed).length} variable${Object.keys(parsed).length === 1 ? "" : "s"} from ${file} into ${app.name} / ${target.name}.`);
+    });
+    await maybeRedeploy(ctx, app, target, options.redeploy);
+  });
+  vars.command("export").description("Print variables in .env format (redirect to a file)").option("-a, --app <app>", "app name or id").option("-e, --env <env>", "environment (default: production)").action(async (options, command) => {
+    const ctx = contextFrom(command);
+    const { values } = await loadVars(ctx, options);
+    emit(values, () => {
+      for (const key of Object.keys(values).sort()) {
+        process.stdout.write(`${key}=${quoteDotenv(values[key] ?? "")}
+`);
+      }
+    });
+  });
+}
+async function loadVars(ctx, options) {
+  const app = await ctx.resolveApp(options.app);
+  const target = await ctx.resolveEnv(app, options.env);
+  const org = await ctx.resolveOrg();
+  const full = await ctx.api.getEnvironment(org.id, target.id);
+  const values = {};
+  for (const [key, value] of Object.entries(full.environment_vars ?? {})) {
+    values[key] = value == null ? "" : String(value);
+  }
+  return { app, target: full, values };
+}
+async function saveVars(ctx, target, values) {
+  const org = await ctx.resolveOrg();
+  await ctx.api.updateEnvironment({ targetOrganisationId: org.id, environmentId: target.id, environmentVars: values });
+}
+async function maybeRedeploy(ctx, app, target, redeploy) {
+  if (redeploy) {
+    await runDeploy(ctx, { app, env: target, watch: true });
+  } else {
+    log.info(`Changes apply on the next deploy ${c.dim(`(lc deploy --env ${target.name}, or pass --redeploy)`)}.`);
+  }
+}
+function parsePairs(pairs) {
+  const result = {};
+  for (const pair of pairs) {
+    const index = pair.indexOf("=");
+    if (index <= 0) {
+      throw new CliError(`"${pair}" is not KEY=value.`, { exitCode: EXIT.USAGE });
+    }
+    const key = pair.slice(0, index).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      throw new CliError(`"${key}" is not a valid variable name.`, { hint: "Letters, digits and underscores; cannot start with a digit.", exitCode: EXIT.USAGE });
+    }
+    result[key] = pair.slice(index + 1);
+  }
+  return result;
+}
+function parseDotenv(content) {
+  const result = {};
+  for (const raw of content.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const match = line.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+    if (!match) continue;
+    let value = match[2] ?? "";
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      const quote = value[0];
+      value = value.slice(1, -1);
+      if (quote === '"') value = value.replace(/\\n/g, "\n").replace(/\\"/g, '"');
+    } else {
+      const comment = value.indexOf(" #");
+      if (comment !== -1) value = value.slice(0, comment);
+      value = value.trim();
+    }
+    result[match[1]] = value;
+  }
+  return result;
+}
+function quoteDotenv(value) {
+  if (/^[A-Za-z0-9_./:@-]*$/.test(value)) return value;
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+}
+function printEnvDetails(env) {
+  heading(`${envName(env)}  ${statusBadge(env.status)}`);
+  printDetails([
+    ["Branch", env.github_branch],
+    ["URL", env.deployed_url ? link(env.deployed_url) : void 0],
+    ["Domain", env.custom_domain ? `${env.custom_domain} ${c.dim(env.custom_domain_status ?? "")}` : void 0],
+    ["Auto-deploy", env.auto_deploy ? "on push" : "off"],
+    ["Build", env.build_command ?? void 0],
+    ["Output", env.output_directory ?? void 0],
+    ["Port", env.container_port != null ? String(env.container_port) : void 0],
+    ["Memory", env.memory ?? void 0],
+    ["Instances", env.min_instances != null || env.max_instances != null ? `${env.min_instances ?? 0} ${c.dim(sym.arrow)} ${env.max_instances ?? "?"}` : void 0],
+    ["Password", env.password_enabled ? "protected" : void 0],
+    ["Region", env.cloud_run_region ?? void 0],
+    ["Variables", `${Object.keys(env.environment_vars ?? {}).length}`],
+    ["Last deploy", relativeTime(env.last_deployed_at)],
+    ["ID", c.dim(env.id)]
+  ]);
+}
+
+// src/commands/init.ts
+import * as path9 from "path";
+function registerInitCommands(program2) {
+  program2.command("init").description("Link this folder to a Light Cloud app (existing or new)").option("-a, --app <app>", "link to this existing app without asking").option("-e, --env <env>", "default environment for `lc deploy` in this folder").option("-d, --dir <path>", "project folder", ".").action(async (options, command) => {
+    const ctx = contextFrom(command);
+    const directory = path9.resolve(options.dir);
+    ctx.requireAuth();
+    intro2(`${brand()} init`);
+    const org = await ctx.resolveOrg();
+    const detection = detectLocalProject(directory);
+    const git2 = detectGit(directory);
+    if (!isJson()) {
+      out(`${c.dim("\u2502")}  Folder     ${directory}`);
+      out(`${c.dim("\u2502")}  Detected   ${describeDetection(detection)}`);
+      if (git2.remoteUrl) out(`${c.dim("\u2502")}  Git        ${git2.provider ?? git2.host ?? "remote"} ${c.dim(git2.remoteUrl)}${git2.branch ? c.dim(`  @ ${git2.branch}`) : ""}`);
+      out(`${c.dim("\u2502")}  Workspace  ${org.name ?? org.id}`);
+      out(c.dim("\u2502"));
+    }
+    let app;
+    if (options.app) {
+      app = await ctx.resolveApp(options.app);
+    } else {
+      app = await chooseOrCreate(ctx, directory, detection, git2);
+    }
+    const envs = app.environments ?? await ctx.api.listEnvironments(org.id, app.id);
+    let env;
+    if (options.env) env = await ctx.resolveEnv(app, options.env);
+    else if (git2.branch) env = envs.find((e) => e.github_branch === git2.branch) ?? envs.find((e) => e.is_production);
+    else env = envs.find((e) => e.is_production);
+    const file = writeProjectConfig(
+      {
+        organisationId: org.id,
+        applicationId: app.id,
+        applicationName: app.name,
+        environmentId: env?.id,
+        framework: app.framework,
+        deploymentType: app.deployment_type
+      },
+      directory
+    );
+    emit({ ok: true, path: file, application: { id: app.id, name: app.name }, environment: env ? { id: env.id, name: env.name } : null }, () => {
+      note2(
+        [
+          `${c.bold("lc deploy")}        deploy ${env ? env.name : "the production environment"}`,
+          `${c.bold("lc status")}        see environments and URLs`,
+          `${c.bold("lc logs -f")}       tail runtime logs`,
+          `${c.bold("lc env vars set")}  KEY=value`
+        ].join("\n"),
+        "Next"
+      );
+      outro2(`Linked ${c.bold(app.name)} ${c.dim(sym.arrow)} ${c.dim(file)}`);
+    });
+  });
+  program2.command("create").description("Create an app from a git repository or a local folder (non-interactive friendly)").option("-n, --name <name>", "app name (default: folder or repository name)").option("-r, --repo <url>", "GitHub repository URL (default: the origin remote)").option("-b, --branch <branch>", "branch to deploy (default: current branch or main)").option("-u, --upload", "upload the folder instead of connecting a repository").option("-d, --dir <path>", "project folder", ".").option("-f, --framework <id>", "framework id (see `lc frameworks`)").option("-t, --type <type>", "deployment type: static or container").option("--build <command>", "build command").option("--output <dir>", "output directory for static sites").option("--port <port>", "container port").option("--root <dir>", "monorepo root directory inside the repository").option("--no-deploy", "create without deploying").option("--no-watch", "do not follow the first deployment").option("--no-link", "do not write a .lightcloud file").action(async (options, command) => {
+    const ctx = contextFrom(command);
+    const directory = path9.resolve(options.dir);
+    ctx.requireAuth();
+    intro2(`${brand()} create`);
+    const app = await createApp(ctx, directory, options);
+    if (options.link) {
+      writeProjectConfig(
+        { organisationId: app.organisation_id, applicationId: app.id, applicationName: app.name, framework: app.framework, deploymentType: app.deployment_type },
+        directory
+      );
+    }
+    let url = app.deployed_url ?? void 0;
+    let status = app.status;
+    if (options.deploy && options.watch) {
+      const env = (app.environments ?? []).find((e) => e.is_production) ?? app.environments?.[0];
+      const org = await ctx.resolveOrg();
+      const result = await watchResource(ctx.api, env ? { kind: "environment", id: env.id, organisationId: org.id } : { kind: "application", id: app.id, organisationId: org.id });
+      url = result.update.deployed_url ?? url;
+      status = result.status;
+      if (!result.ok) {
+        throw new CliError(result.update.deployment_error || "The first deployment failed.", {
+          hint: `Fix the build and run \`lc deploy\`. Console: ${ctx.appConsoleUrl(app)}`,
+          exitCode: EXIT.FAILED
+        });
+      }
+    }
+    emit({ ok: true, application: app, status, url }, () => outro2(url ? `Live at ${link(url)}` : `Created ${c.bold(app.name)}.`));
+  });
+  program2.command("frameworks").description("List framework ids the platform understands").action(async () => {
+    emit(FRAMEWORKS, () => {
+      for (const category of ["fullstack", "frontend", "backend"]) {
+        out(c.bold(category));
+        for (const framework of FRAMEWORKS.filter((f) => f.category === category)) {
+          out(`  ${framework.id.padEnd(12)} ${framework.label}${framework.available ? "" : c.dim("  (not yet available)")}`);
+        }
+        out();
+      }
+    });
+  });
+}
+async function chooseOrCreate(ctx, directory, detection, git2) {
+  const org = await ctx.resolveOrg();
+  const apps = await ctx.api.listApplications(org.id);
+  const suggested = git2.owner && git2.repo ? apps.find((app) => app.github_repo_owner?.toLowerCase() === git2.owner.toLowerCase() && app.github_repo_name?.toLowerCase() === git2.repo.toLowerCase()) : void 0;
+  if (!isInteractive()) {
+    if (suggested) return ctx.api.getApplication(org.id, suggested.id);
+    throw new CliError("No terminal to ask in.", {
+      hint: "Pass --app <name> to link an existing app, or use `lc create` for a new one.",
+      exitCode: EXIT.USAGE
+    });
+  }
+  const choices = [];
+  if (suggested) choices.push({ value: "suggested", label: `Link ${suggested.name}`, hint: `already connected to ${git2.owner}/${git2.repo}` });
+  choices.push({ value: "new", label: "Create a new app", hint: git2.provider === "github" ? `from ${git2.owner}/${git2.repo}` : "upload this folder" });
+  if (apps.length) choices.push({ value: "existing", label: "Link an existing app", hint: `${apps.length} in ${org.name ?? "workspace"}` });
+  const choice = await select2("What would you like to do?", choices, { flag: "--app <name>" });
+  if (choice === "suggested") return ctx.api.getApplication(org.id, suggested.id);
+  if (choice === "existing") {
+    const id = await select2(
+      "Which app?",
+      apps.map((app) => ({ value: app.id, label: app.name, hint: `${app.framework} \xB7 ${app.status}` })),
+      { flag: "--app <name>" }
+    );
+    return ctx.api.getApplication(org.id, id);
+  }
+  return createApp(ctx, directory, {
+    dir: directory,
+    deploy: true,
+    watch: true,
+    link: false,
+    upload: git2.provider !== "github" ? true : void 0
+  }, { detection, git: git2, interactive: true });
+}
+async function createApp(ctx, directory, options, extra = {}) {
+  const org = await ctx.resolveOrg();
+  const detection = extra.detection ?? detectLocalProject(directory);
+  const git2 = extra.git ?? detectGit(directory);
+  const interactive = extra.interactive ?? isInteractive();
+  let source;
+  let repoUrl = options.repo;
+  if (options.upload) source = "upload";
+  else if (repoUrl) source = "github";
+  else if (git2.provider === "github" && git2.owner && git2.repo) {
+    repoUrl = webUrlFor(git2);
+    source = interactive ? await select2(
+      "Deploy from?",
+      [
+        { value: "github", label: `GitHub ${git2.owner}/${git2.repo}`, hint: "auto-deploys on push" },
+        { value: "upload", label: "Upload this folder", hint: "no git connection" }
+      ],
+      { flag: "--repo <url> or --upload" }
+    ) : "github";
+  } else {
+    if (git2.provider && git2.provider !== "github") {
+      log.warn(`${git2.provider} repositories are connected from the console (${ctx.consoleUrl("/new")}); uploading the folder instead.`);
+    }
+    source = "upload";
+  }
+  let framework = options.framework ?? detection.framework;
+  let deploymentType = options.type ?? detection.deploymentType;
+  let buildCommand = options.build ?? detection.buildCommand;
+  let outputDirectory = options.output ?? detection.outputDirectory;
+  let containerPort = options.port ? Number(options.port) : detection.containerPort;
+  if (options.framework && !getFrameworkById(options.framework)) {
+    throw new CliError(`Unknown framework "${options.framework}".`, { hint: "Run `lc frameworks` for the list.", exitCode: EXIT.USAGE });
+  }
+  if (options.type && options.type !== "static" && options.type !== "container") {
+    throw new CliError("--type must be static or container.", { exitCode: EXIT.USAGE });
+  }
+  if (source === "github" && repoUrl) {
+    const parsed = parseGithubUrl(repoUrl);
+    if (!parsed) throw new CliError(`"${repoUrl}" is not a GitHub repository URL.`, { exitCode: EXIT.USAGE });
+    const branch = options.branch ?? git2.branch ?? "main";
+    const access = await ctx.api.githubInstallationStatus(org.id, parsed.owner, parsed.repo).catch(() => null);
+    if (access && (!access.installed || access.repoAccess === false)) {
+      const install = await ctx.api.githubInstallUrl().catch(() => null);
+      const hint = install?.url ? `Install the Light Cloud GitHub App for ${parsed.owner}: ${install.url}` : `Connect GitHub in the console: ${ctx.consoleUrl("/new")}`;
+      if (interactive && install?.url) {
+        const go = await confirm2(`Light Cloud cannot read ${parsed.owner}/${parsed.repo} yet. Open the GitHub App install page?`, { yes: false, initialValue: true });
+        if (go) openBrowser(install.url);
+      }
+      throw new CliError(`The Light Cloud GitHub App has no access to ${parsed.owner}/${parsed.repo}.`, { hint, exitCode: EXIT.AUTH });
+    }
+    const spin = spinner2();
+    spin.start(`Inspecting ${parsed.owner}/${parsed.repo}@${branch}`);
+    let remote = null;
+    try {
+      remote = await ctx.api.detectFramework({ organisationId: org.id, owner: parsed.owner, repo: parsed.repo, branch, rootDirectory: options.root });
+      spin.stop(`${remote.framework ? getFrameworkById(remote.framework)?.label ?? remote.framework : "Unknown framework"} ${c.dim(sym.bullet)} ${remote.deploymentType}${remote.detectedFiles?.length ? c.dim(`  ${remote.detectedFiles.slice(-1)[0]}`) : ""}`);
+    } catch {
+      spin.stop("Could not inspect the repository; using local detection", 2);
+    }
+    if (remote) {
+      framework = options.framework ?? remote.framework ?? framework;
+      deploymentType = options.type ?? remote.deploymentType;
+      buildCommand = options.build ?? remote.buildCommand ?? buildCommand;
+      outputDirectory = options.output ?? remote.outputDirectory ?? outputDirectory;
+      containerPort = options.port ? Number(options.port) : remote.containerPort ?? containerPort;
+      if (remote.configWarning) log.warn(remote.configWarning);
+    }
+    const name2 = await pickName(options.name ?? parsed.repo, interactive);
+    if (interactive) {
+      ({ framework, deploymentType } = await confirmKind(framework, deploymentType, interactive));
+    }
+    if (!framework) throw new CliError("Could not detect the framework.", { hint: "Pass --framework <id> (see `lc frameworks`).", exitCode: EXIT.USAGE });
+    const definition2 = getFrameworkById(framework);
+    const spinCreate2 = spinner2();
+    spinCreate2.start(`Creating ${name2}`);
+    const app2 = await ctx.api.createApplication({
+      targetOrganisationId: org.id,
+      name: name2,
+      githubRepoUrl: `https://github.com/${parsed.owner}/${parsed.repo}`,
+      githubBranch: branch,
+      isPrivate: false,
+      gitProvider: "github",
+      deploymentType,
+      framework,
+      runtime: definition2?.runtime ?? void 0,
+      buildCommand,
+      outputDirectory: deploymentType === "static" ? outputDirectory : void 0,
+      containerPort: deploymentType === "container" ? containerPort : void 0,
+      rootDirectory: options.root,
+      autoDeployOnPush: true
+    });
+    spinCreate2.stop(`Created ${c.bold(app2.name)} ${c.dim(app2.id)}`);
+    if (!options.deploy) log.info("Created without deploying; run `lc deploy` when ready.");
+    return app2;
+  }
+  warnIfDirty(git2.isDirty, git2.branch);
+  if (!framework && !detection.hasDockerfile) {
+    if (interactive) {
+      framework = await select2(
+        "What kind of project is this?",
+        FRAMEWORKS.filter((f) => f.available).map((f) => ({ value: f.id, label: f.label, hint: f.deploymentType })),
+        { flag: "--framework <id>" }
+      );
+      deploymentType = options.type ?? getFrameworkById(framework)?.deploymentType ?? deploymentType;
+    } else {
+      throw new CliError(`Could not tell what kind of project ${directory} is.`, { hint: "Pass --framework <id> (see `lc frameworks`).", exitCode: EXIT.USAGE });
+    }
+  } else if (interactive) {
+    ({ framework, deploymentType } = await confirmKind(framework, deploymentType, interactive));
+  }
+  const name = await pickName(options.name ?? path9.basename(directory), interactive);
+  const definition = framework ? getFrameworkById(framework) : void 0;
+  const upload = await uploadSource(ctx, directory, { ...detection, framework, deploymentType, buildCommand, outputDirectory });
+  const spinCreate = spinner2();
+  spinCreate.start(`Creating ${name}`);
+  const app = await ctx.api.createFromUpload({
+    targetOrganisationId: org.id,
+    name,
+    uploadId: upload.uploadId,
+    deploymentType,
+    framework: framework ?? (detection.hasDockerfile ? "custom" : void 0),
+    runtime: definition?.runtime ?? (detection.hasDockerfile ? "custom" : void 0),
+    buildCommand,
+    outputDirectory: deploymentType === "static" ? outputDirectory : void 0,
+    containerPort: deploymentType === "container" ? containerPort : void 0
+  });
+  spinCreate.stop(`Created ${c.bold(app.name)} ${c.dim(app.id)}`);
+  if (options.deploy && app.status && !["queued", "deploying", "pending"].includes(app.status)) {
+    await runDeploy(ctx, { app, env: (app.environments ?? []).find((e) => e.is_production) ?? null, watch: false });
+  }
+  return app;
+}
+async function pickName(suggested, interactive) {
+  const cleaned = suggested.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "app";
+  if (!interactive) return cleaned;
+  return text2("App name", {
+    flag: "--name <name>",
+    initialValue: cleaned,
+    validate: (value) => value.trim().length < 2 ? "At least 2 characters." : /^[a-z0-9][a-z0-9-]*$/.test(value.trim()) ? void 0 : "Lowercase letters, digits and dashes only."
+  });
+}
+async function confirmKind(framework, deploymentType, interactive) {
+  if (!interactive) return { framework, deploymentType };
+  const label = framework ? getFrameworkById(framework)?.label ?? framework : "unknown";
+  const keep = await confirm2(`Deploy as ${c.bold(label)} ${c.dim(sym.bullet)} ${deploymentType}?`, { yes: false, initialValue: true });
+  if (keep) return { framework, deploymentType };
+  const chosen = await select2(
+    "Framework",
+    FRAMEWORKS.filter((f) => f.available).map((f) => ({ value: f.id, label: f.label, hint: f.category })),
+    { flag: "--framework <id>", initialValue: framework }
+  );
+  const definition = getFrameworkById(chosen);
+  const type = definition.category === "fullstack" || definition.id === "html" ? await select2(
+    "Deployment type",
+    [
+      { value: "container", label: "Container", hint: "server-rendered, APIs" },
+      { value: "static", label: "Static site", hint: "prebuilt HTML/JS on a CDN" }
+    ],
+    { flag: "--type <type>", initialValue: definition.deploymentType }
+  ) : definition.deploymentType;
+  return { framework: chosen, deploymentType: type };
+}
+function parseGithubUrl(value) {
+  const match = value.trim().match(/^(?:https?:\/\/)?(?:www\.)?github\.com\/([^/\s]+)\/([^/\s#?]+?)(?:\.git)?\/?$/i) || value.trim().match(/^git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?$/i);
+  if (!match) {
+    const short = value.trim().match(/^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/);
+    return short ? { owner: short[1], repo: short[2] } : null;
+  }
+  return { owner: match[1], repo: match[2] };
+}
+
+// src/lib/realtime/log-stream.ts
+async function* readSse(response, signal) {
+  if (!response.body) return;
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    for (; ; ) {
+      if (signal?.aborted) return;
+      const { value, done } = await reader.read();
+      if (done) return;
+      buffer += decoder.decode(value, { stream: true });
+      let boundary = buffer.indexOf("\n\n");
+      while (boundary !== -1) {
+        const frame = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        const parsed = parseFrame(frame);
+        if (parsed) yield parsed;
+        boundary = buffer.indexOf("\n\n");
+      }
+    }
+  } finally {
+    reader.cancel().catch(() => void 0);
+  }
+}
+function parseFrame(frame) {
+  const data = frame.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+  if (!data) return null;
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/logs.ts
+var SEVERITIES = ["DEFAULT", "DEBUG", "INFO", "NOTICE", "WARNING", "ERROR", "CRITICAL", "ALERT", "EMERGENCY"];
+function registerLogsCommand(program2) {
+  program2.command("logs [app]").description("Show runtime logs of an environment; -f to follow").option("-e, --env <env>", "environment (default: production)").option("-f, --follow", "keep streaming new log lines").option("-n, --lines <n>", "how many recent lines to show first", "100").option("--since <duration>", "how far back to look, e.g. 30m, 2h, 1d", "1h").option("-s, --severity <levels>", "comma-separated: ERROR,WARNING,INFO,DEBUG \u2026").option("--min-severity <level>", "this level and above, e.g. WARNING").option("--search <text>", "only lines containing this text").option("--no-timestamps", "hide timestamps").action(async (positional, options, command) => {
+    const ctx = contextFrom(command);
+    const app = await ctx.resolveApp(positional);
+    const env = await ctx.resolveEnv(app, options.env);
+    const org = await ctx.resolveOrg();
+    if (app.deployment_type === "static" || !env.cloud_run_service) {
+      throw new CliError(`${app.name} / ${env.name} is a static site; it has no runtime logs.`, {
+        hint: "Deployment logs are under `lc deployments`.",
+        exitCode: EXIT.USAGE
+      });
+    }
+    const severity = parseSeverity(options);
+    const lines = Math.max(1, Math.min(1e3, Number(options.lines) || 100));
+    const since = new Date(Date.now() - parseDuration(options.since)).toISOString();
+    const page = await ctx.api.fetchLogs(org.id, env.id, {
+      startTime: since,
+      severity,
+      textSearch: options.search,
+      pageSize: lines
+    });
+    const entries = [...page.logs ?? []].sort((a, b) => a.timestamp.localeCompare(b.timestamp)).slice(-lines);
+    if (isJson() && !options.follow) {
+      printJson(entries);
+      return;
+    }
+    if (entries.length === 0 && !options.follow) {
+      log.info(`No logs on ${app.name} / ${env.name} in the last ${options.since}${severity ? ` at ${severity.join(",")}` : ""}.`);
+      return;
+    }
+    for (const entry of entries) printEntry(entry, options.timestamps);
+    if (!options.follow) return;
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    if (!isJson()) out(c.dim(`\u2500\u2500 following ${app.name} / ${env.name} \xB7 ctrl-c to stop \u2500\u2500`));
+    const seen = new Set(entries.map((entry) => entry.insertId));
+    const search = options.search?.toLowerCase();
+    try {
+      const response = await ctx.api.streamLogs(org.id, env.id, severity, controller.signal);
+      for await (const update of readSse(response, controller.signal)) {
+        if (update.type === "error") {
+          log.warn(update.error ?? "stream error");
+          continue;
+        }
+        if (update.type !== "log" || !update.entry) continue;
+        if (seen.has(update.entry.insertId)) continue;
+        seen.add(update.entry.insertId);
+        if (search && !entryText(update.entry).toLowerCase().includes(search)) continue;
+        if (isJson()) printJson(update.entry);
+        else printEntry(update.entry, options.timestamps);
+      }
+    } catch (error) {
+      if (!controller.signal.aborted) throw error;
+    } finally {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+    }
+  });
+}
+function parseSeverity(options) {
+  if (options.severity) {
+    const levels = options.severity.split(",").map((level) => level.trim().toUpperCase());
+    const bad = levels.filter((level) => !SEVERITIES.includes(level));
+    if (bad.length) throw new CliError(`Unknown severity: ${bad.join(", ")}.`, { hint: `Use: ${SEVERITIES.join(", ")}.`, exitCode: EXIT.USAGE });
+    return levels;
+  }
+  if (options.minSeverity) {
+    const level = options.minSeverity.trim().toUpperCase();
+    const index = SEVERITIES.indexOf(level);
+    if (index === -1) throw new CliError(`Unknown severity "${options.minSeverity}".`, { hint: `Use: ${SEVERITIES.join(", ")}.`, exitCode: EXIT.USAGE });
+    return SEVERITIES.slice(index);
+  }
+  return void 0;
+}
+function parseDuration(value) {
+  const match = value.trim().match(/^(\d+)\s*(s|m|h|d|w)?$/i);
+  if (!match) throw new CliError(`"${value}" is not a duration.`, { hint: "Examples: 90s, 30m, 2h, 1d.", exitCode: EXIT.USAGE });
+  const amount = Number(match[1]);
+  const unit = (match[2] ?? "m").toLowerCase();
+  const factor = unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : unit === "d" ? 864e5 : 6048e5;
+  return amount * factor;
+}
+function entryText(entry) {
+  if (entry.textPayload) return entry.textPayload;
+  if (entry.httpRequest) return `${entry.httpRequest.requestMethod} ${entry.httpRequest.requestUrl}`;
+  if (entry.jsonPayload) {
+    const payload = entry.jsonPayload;
+    const message = payload.message ?? payload.msg ?? payload.error;
+    return typeof message === "string" ? message : JSON.stringify(payload);
+  }
+  return "";
+}
+function formatEntry(entry, withTimestamp = true) {
+  const time = withTimestamp ? c.dim(formatTime(entry.timestamp)) + "  " : "";
+  const badge = severityBadge(entry.severity);
+  if (entry.httpRequest) {
+    const { requestMethod, requestUrl, status, latency } = entry.httpRequest;
+    let pathname = requestUrl;
+    try {
+      const parsed = new URL(requestUrl);
+      pathname = parsed.pathname + parsed.search;
+    } catch {
+    }
+    const code = status >= 500 ? c.red(String(status)) : status >= 400 ? c.yellow(String(status)) : c.green(String(status));
+    const ms = latency ? c.dim(latency.replace(/^([\d.]+)s$/, (_, s) => `${Math.round(Number(s) * 1e3)}ms`)) : "";
+    const text4 = entry.textPayload ? `  ${entry.textPayload}` : "";
+    return `${time}${badge} ${c.bold(requestMethod.padEnd(6))} ${pathname} ${code} ${ms}${text4}`;
+  }
+  const text3 = entryText(entry);
+  return `${time}${badge} ${text3.replace(/\s+$/, "")}`;
+}
+function printEntry(entry, withTimestamp) {
+  out(formatEntry(entry, withTimestamp));
+}
+function formatTime(iso) {
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return iso;
+  const pad2 = (n, width = 2) => String(n).padStart(width, "0");
+  return `${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}.${pad2(date.getMilliseconds(), 3)}`;
+}
+
+// src/commands/orgs.ts
+function registerOrgCommands(program2) {
+  program2.command("orgs").alias("workspaces").description("List the workspaces you belong to").action(async (_options, command) => {
+    const ctx = contextFrom(command);
+    const profile = await ctx.profile();
+    const defaultOrg = readGlobalConfig().defaultOrganisationId;
+    const orgs = profile.organisations ?? [];
+    emit(orgs, () => {
+      printTable(orgs, [
+        { header: "Workspace", cell: (org2) => `${c.bold(org2.name)}${org2.id === defaultOrg ? c.accent(" (default)") : ""}` },
+        { header: "Role", cell: (org2) => org2.role },
+        { header: "ID", cell: (org2) => c.dim(org2.id) }
+      ]);
+      if (orgs.length > 1) {
+        out();
+        out(c.dim("  Switch default: lc org use <name>   \xB7   one command only: lc <command> --org <name>"));
+      }
+    });
+  });
+  const org = program2.command("org").description("Workspace settings");
+  org.command("use [workspace]").alias("switch").description("Set the default workspace (no name: pick from a list)").action(async (ref, _options, command) => {
+    const ctx = contextFrom(command);
+    const profile = await ctx.profile();
+    const orgs = profile.organisations ?? [];
+    const current = readGlobalConfig().defaultOrganisationId;
+    let match = ref ? findOrg(orgs, ref) : void 0;
+    if (ref && !match) {
+      throw new CliError(`No workspace called "${ref}".`, {
+        hint: `Your workspaces: ${orgs.map((org2) => org2.name).join(", ")}.`,
+        exitCode: EXIT.NOT_FOUND
+      });
+    }
+    if (!match) {
+      if (orgs.length === 0) throw new CliError("This account has no workspaces yet.", { exitCode: EXIT.NOT_FOUND });
+      const chosen = await select2(
+        "Which workspace should lc use by default?",
+        orgs.map((org2) => ({ value: org2.id, label: org2.name, hint: org2.id === current ? `${org2.role} \xB7 current default` : org2.role })),
+        { flag: "lc org use <name>", initialValue: current ?? void 0 }
+      );
+      match = orgs.find((org2) => org2.id === chosen);
+    }
+    updateGlobalConfig({ defaultOrganisationId: match.id, defaultOrganisationName: match.name });
+    emit({ ok: true, organisation: match }, () => {
+      log.success(`Default workspace is now ${c.bold(match.name)}.`);
+      const others = orgs.filter((org2) => org2.id !== match.id);
+      if (others.length) log.info(c.dim(`One-off: add --org <name> to any command. Others: ${others.map((org2) => org2.name).join(", ")}.`));
+    });
+  });
+  org.command("current").description("Show which workspace commands will use here").action(async (_options, command) => {
+    const ctx = contextFrom(command);
+    const current = await ctx.resolveOrg({ interactive: false });
+    emit(current, () => {
+      const via = ctx.project?.config.organisationId === current.id ? "linked folder" : readGlobalConfig().defaultOrganisationId === current.id ? "default" : "only workspace";
+      log.info(`${c.bold(current.name ?? current.id)} ${c.dim(`(${via})`)}`);
+    });
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("lc").description(`${c.bold("Light Cloud")} from the terminal: deploy, watch, inspect.`).version(cliVersion(), "-v, --version", "print the CLI version").option("--json", "machine-readable output (one JSON document on stdout)").option("-o, --org <workspace>", "workspace name or id").option("-y, --yes", "answer yes to confirmations").option("--api-url <url>", "Light Cloud API endpoint (or LIGHT_CLOUD_API_URL)").option("--no-color", "disable colours").showHelpAfterError("(add --help for usage)").showSuggestionAfterError(true).configureHelp({ sortSubcommands: false, subcommandTerm: (cmd) => cmd.name() + (cmd.alias() ? `|${cmd.alias()}` : "") }).addHelpText(
+  "after",
+  `
+${c.bold("Getting started")}
+  $ lc login                  sign in (opens the browser)
+  $ lc init                   link this folder to an app, or create one
+  $ lc deploy                 deploy and follow the build
+  $ lc logs -f                tail runtime logs
+
+${c.bold("Everyday")}
+  $ lc apps                   what is deployed
+  $ lc status my-app          environments, URLs, last deploy
+  $ lc env vars set KEY=v --redeploy
+  $ lc rollback               go back to a previous deployment
+  $ lc db url my-db           connection string
+
+${c.dim("CI: set LIGHT_CLOUD_API_KEY and run from a folder with a .lightcloud file.")}
+${c.dim("Docs: https://docs.light-cloud.com/cli")}`
+);
+program.hook("preAction", (thisCommand) => {
+  const options = thisCommand.optsWithGlobals();
+  const noColor = options.color === false || Boolean(process.env.NO_COLOR);
+  configureOutput(noColor ? { json: Boolean(options.json), color: false } : { json: Boolean(options.json) });
+});
+registerAuthCommands(program);
+registerOrgCommands(program);
+registerInitCommands(program);
+registerAppCommands(program);
+registerDeployCommand(program);
+registerEnvCommands(program);
+registerLogsCommand(program);
+registerDeploymentCommands(program);
+registerDomainCommands(program);
+registerDbCommands(program);
+registerBillingCommands(program);
+registerConfigCommands(program);
+program.exitOverride();
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    handleError(error);
+  }
+}
+function handleError(error) {
+  if (error instanceof CommanderError) {
+    process.exit(error.exitCode);
+  }
+  if (error instanceof CancelledError) {
+    if (!isJson()) err(c.dim("Cancelled."));
+    process.exit(EXIT.CANCELLED);
+  }
+  if (error instanceof CliError) {
+    if (isJson()) {
+      printJson({ error: { code: error.code, message: error.message, hint: error.hint, status: error instanceof ApiError ? error.status : void 0 } });
+    } else {
+      err(`${c.red("\u2716")} ${error.message}`);
+      if (error.hint) err(`  ${c.dim(error.hint)}`);
+    }
+    process.exit(error.exitCode);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (isJson()) printJson({ error: { code: "UNEXPECTED", message } });
+  else {
+    err(`${c.red("\u2716")} ${message}`);
+    if (process.env.LC_DEBUG && error instanceof Error && error.stack) err(c.dim(error.stack));
+    else err(c.dim("  Set LC_DEBUG=1 for a stack trace."));
+  }
+  process.exit(EXIT.ERROR);
+}
+void main();