@spacelr/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1251 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// libs/cli/src/index.ts
+var import_commander13 = require("commander");
+
+// libs/cli/src/lib/output.ts
+var import_ora = __toESM(require("ora"));
+var import_picocolors = __toESM(require("picocolors"));
+var jsonMode = false;
+var verboseMode = false;
+function setOutputMode(options) {
+  jsonMode = options.json ?? false;
+  verboseMode = options.verbose ?? false;
+}
+function isJsonMode() {
+  return jsonMode;
+}
+function success(message) {
+  if (!jsonMode) {
+    console.log(import_picocolors.default.green(`\u2713 ${message}`));
+  }
+}
+function error(message) {
+  if (!jsonMode) {
+    console.error(import_picocolors.default.red(`\u2717 ${message}`));
+  }
+}
+function warn(message) {
+  if (!jsonMode) {
+    console.warn(import_picocolors.default.yellow(`! ${message}`));
+  }
+}
+function info(message) {
+  if (!jsonMode) {
+    console.log(import_picocolors.default.cyan(`\u2139 ${message}`));
+  }
+}
+function verbose(message) {
+  if (verboseMode && !jsonMode) {
+    console.log(import_picocolors.default.dim(`  ${message}`));
+  }
+}
+function json(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function table(headers, rows) {
+  if (jsonMode) return;
+  const colWidths = headers.map((h, i) => {
+    const maxRow = rows.reduce(
+      (max, row) => Math.max(max, (row[i] ?? "").length),
+      0
+    );
+    return Math.max(h.length, maxRow);
+  });
+  const headerLine = headers.map((h, i) => import_picocolors.default.bold(h.padEnd(colWidths[i] ?? 0))).join("  ");
+  const separator = colWidths.map((w) => "-".repeat(w)).join("  ");
+  console.log(headerLine);
+  console.log(separator);
+  for (const row of rows) {
+    console.log(
+      row.map((cell, i) => cell.padEnd(colWidths[i] ?? 0)).join("  ")
+    );
+  }
+}
+function spinner(text) {
+  if (jsonMode) {
+    return (0, import_ora.default)({ text, isSilent: true });
+  }
+  return (0, import_ora.default)(text).start();
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  const value = bytes / Math.pow(1024, i);
+  return `${value.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+
+// libs/cli/src/commands/login.ts
+var http = __toESM(require("http"));
+var crypto2 = __toESM(require("crypto"));
+var import_commander = require("commander");
+var import_open = __toESM(require("open"));
+
+// libs/cli/src/lib/auth.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var crypto = __toESM(require("crypto"));
+function getCredentialsDir() {
+  return path.join(
+    process.env["HOME"] ?? process.env["USERPROFILE"] ?? "~",
+    ".spacelr"
+  );
+}
+function getCredentialsFile() {
+  return path.join(getCredentialsDir(), "credentials.json");
+}
+function getStoredCredentials() {
+  try {
+    const file = getCredentialsFile();
+    if (!fs.existsSync(file)) return null;
+    const content = fs.readFileSync(file, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function storeCredentials(credentials) {
+  const dir = getCredentialsDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  fs.writeFileSync(
+    getCredentialsFile(),
+    JSON.stringify(credentials, null, 2),
+    { mode: 384 }
+  );
+}
+function clearCredentials() {
+  try {
+    const file = getCredentialsFile();
+    if (fs.existsSync(file)) {
+      fs.unlinkSync(file);
+    }
+  } catch {
+  }
+}
+function isTokenExpired(credentials) {
+  return Date.now() >= credentials.expiresAt - 6e4;
+}
+function resolveToken(flagToken) {
+  if (flagToken) return flagToken;
+  if (process.env["SPACELR_TOKEN"]) return process.env["SPACELR_TOKEN"];
+  const credentials = getStoredCredentials();
+  if (credentials && !isTokenExpired(credentials)) {
+    return credentials.accessToken;
+  }
+  return null;
+}
+var AuthRequiredError = class extends Error {
+  constructor() {
+    super('Not logged in. Run "spacelr login" to authenticate.');
+    this.name = "AuthRequiredError";
+  }
+};
+function requireAuth(flagToken) {
+  const token = resolveToken(flagToken);
+  if (!token) {
+    throw new AuthRequiredError();
+  }
+  return token;
+}
+function generatePKCE() {
+  const codeVerifier = crypto.randomBytes(32).toString("base64url");
+  const codeChallenge = crypto.createHash("sha256").update(codeVerifier).digest("base64url");
+  return { codeVerifier, codeChallenge };
+}
+
+// libs/cli/src/lib/config.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var CONFIG_FILENAME = "spacelr.json";
+function findConfigPath(startDir) {
+  let dir = startDir ?? process.cwd();
+  while (true) {
+    const candidate = path2.join(dir, CONFIG_FILENAME);
+    if (fs2.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+function loadConfig(configPath) {
+  const resolved = configPath ?? findConfigPath();
+  if (!resolved || !fs2.existsSync(resolved)) return null;
+  const content = fs2.readFileSync(resolved, "utf-8");
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error(
+      `Invalid JSON in config file: ${resolved}
+Please check the file for syntax errors.`
+    );
+  }
+}
+function saveConfig(config, configPath) {
+  const resolved = configPath ?? findConfigPath() ?? path2.join(process.cwd(), CONFIG_FILENAME);
+  fs2.writeFileSync(resolved, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function resolveProjectId(flagValue, config) {
+  const projectId = flagValue ?? config?.projectId;
+  if (!projectId) {
+    throw new Error(
+      'Project ID is required. Provide --project <id> or set "projectId" in spacelr.json'
+    );
+  }
+  return projectId;
+}
+function resolveApiUrl(flagValue, config) {
+  return flagValue ?? config?.apiUrl ?? process.env["SPACELR_API_URL"] ?? "https://api.spacelr.io";
+}
+
+// libs/cli/src/commands/login.ts
+var CLI_CLIENT_ID = "spacelr-cli";
+function createLoginCommand() {
+  return new import_commander.Command("login").description("Authenticate with Spacelr via browser").option("--auth-url <url>", "OAuth server URL (defaults to --api-url)").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig();
+    const apiUrl = resolveApiUrl(globalOpts.apiUrl, config);
+    const authUrl = opts.authUrl ?? apiUrl;
+    try {
+      const credentials = await performLogin(authUrl, apiUrl);
+      storeCredentials(credentials);
+      if (isJsonMode()) {
+        json({ success: true, expiresAt: credentials.expiresAt });
+      } else {
+        success("Logged in successfully");
+        info(`Credentials stored in ~/.spacelr/credentials.json`);
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Login failed");
+      process.exitCode = 1;
+    }
+  });
+}
+async function performLogin(authUrl, apiUrl) {
+  const { codeVerifier, codeChallenge } = generatePKCE();
+  const state = crypto2.randomBytes(16).toString("base64url");
+  const { port, waitForCode, close } = await startCallbackServer(state);
+  const authorizeUrl = buildAuthorizeUrl(authUrl, port, codeChallenge, state);
+  info(`Opening browser for authentication...`);
+  info(`If the browser doesn't open, visit: ${authorizeUrl}`);
+  await (0, import_open.default)(authorizeUrl);
+  const spin = spinner("Waiting for authentication...");
+  try {
+    const code = await waitForCode;
+    spin.text = "Exchanging authorization code...";
+    const tokenResponse = await exchangeCode(
+      authUrl,
+      code,
+      codeVerifier,
+      port
+    );
+    spin.succeed("Authentication complete");
+    return {
+      accessToken: tokenResponse.access_token,
+      refreshToken: tokenResponse.refresh_token,
+      expiresAt: Date.now() + tokenResponse.expires_in * 1e3,
+      apiUrl
+    };
+  } catch (err) {
+    spin.fail("Authentication failed");
+    throw err;
+  } finally {
+    close();
+  }
+}
+function buildAuthorizeUrl(apiUrl, port, codeChallenge, state) {
+  const params = new URLSearchParams({
+    client_id: CLI_CLIENT_ID,
+    redirect_uri: `http://127.0.0.1:${port}/callback`,
+    response_type: "code",
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    scope: "openid profile email",
+    state
+  });
+  return `${apiUrl}/auth/authorize?${params.toString()}`;
+}
+async function startCallbackServer(expectedState) {
+  return new Promise((resolveServer) => {
+    let resolveCode;
+    let rejectCode;
+    const waitForCode = new Promise((resolve3, reject) => {
+      resolveCode = resolve3;
+      rejectCode = reject;
+    });
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url ?? "/", `http://127.0.0.1`);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        const errorParam = url.searchParams.get("error");
+        const returnedState = url.searchParams.get("state");
+        if (errorParam) {
+          const description = url.searchParams.get("error_description") ?? errorParam;
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(errorPage(description));
+          rejectCode(new Error(`OAuth error: ${description}`));
+          return;
+        }
+        if (returnedState !== expectedState) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(errorPage("Invalid state parameter (possible CSRF attack)"));
+          rejectCode(new Error("OAuth state mismatch"));
+          return;
+        }
+        if (!code) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(errorPage("No authorization code received"));
+          rejectCode(new Error("No authorization code received"));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(successPage());
+        resolveCode(code);
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    const timeout = setTimeout(() => {
+      rejectCode(new Error("Login timed out after 5 minutes"));
+      server.close();
+    }, 5 * 60 * 1e3);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : 0;
+      resolveServer({
+        port,
+        waitForCode,
+        close: () => {
+          clearTimeout(timeout);
+          server.close();
+        }
+      });
+    });
+  });
+}
+async function exchangeCode(apiUrl, code, codeVerifier, port) {
+  const response = await fetch(`${apiUrl}/auth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      code_verifier: codeVerifier,
+      client_id: CLI_CLIENT_ID,
+      redirect_uri: `http://127.0.0.1:${port}/callback`
+    })
+  });
+  if (!response.ok) {
+    let message;
+    try {
+      const body = await response.json();
+      message = body.message ?? body.error ?? response.statusText;
+    } catch {
+      message = response.statusText;
+    }
+    throw new Error(`Token exchange failed: ${message}`);
+  }
+  return await response.json();
+}
+function successPage() {
+  return `<!DOCTYPE html>
+<html><head><title>Spacelr CLI</title>
+<style>body{font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;background:#f8f9fa;}
+.box{text-align:center;padding:2rem;}.check{font-size:3rem;color:#22c55e;}</style></head>
+<body><div class="box"><div class="check">&#10003;</div><h1>Authenticated</h1><p>You can close this window and return to the terminal.</p></div></body></html>`;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function errorPage(message) {
+  return `<!DOCTYPE html>
+<html><head><title>Spacelr CLI</title>
+<style>body{font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;background:#f8f9fa;}
+.box{text-align:center;padding:2rem;}.x{font-size:3rem;color:#ef4444;}</style></head>
+<body><div class="box"><div class="x">&#10007;</div><h1>Authentication Failed</h1><p>${escapeHtml(message)}</p></div></body></html>`;
+}
+
+// libs/cli/src/commands/logout.ts
+var import_commander2 = require("commander");
+function createLogoutCommand() {
+  return new import_commander2.Command("logout").description("Clear stored credentials").action(async (_opts, cmd) => {
+    cmd.optsWithGlobals();
+    const existing = getStoredCredentials();
+    clearCredentials();
+    if (isJsonMode()) {
+      json({ success: true, hadCredentials: !!existing });
+    } else if (existing) {
+      success("Logged out successfully");
+    } else {
+      warn("No credentials found");
+    }
+  });
+}
+
+// libs/cli/src/commands/whoami.ts
+var import_commander3 = require("commander");
+
+// libs/cli/src/lib/api-client.ts
+var ApiClient = class {
+  constructor(options) {
+    this.refreshing = null;
+    this.apiUrl = options.apiUrl.replace(/\/+$/, "");
+    this.explicitToken = options.token;
+  }
+  async getToken() {
+    if (this.explicitToken) return this.explicitToken;
+    const envToken = process.env["SPACELR_TOKEN"];
+    if (envToken) return envToken;
+    const credentials = getStoredCredentials();
+    if (!credentials) return null;
+    if (!isTokenExpired(credentials)) {
+      return credentials.accessToken;
+    }
+    if (credentials.refreshToken) {
+      return this.refreshAccessToken(credentials);
+    }
+    return null;
+  }
+  async refreshAccessToken(credentials) {
+    if (this.refreshing) return this.refreshing;
+    this.refreshing = (async () => {
+      try {
+        verbose("Refreshing access token...");
+        const response = await fetch(`${this.apiUrl}/auth/refresh`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            refreshToken: credentials.refreshToken ?? ""
+          })
+        });
+        if (!response.ok) {
+          verbose("Token refresh failed");
+          return null;
+        }
+        const data = await response.json();
+        const newCredentials = {
+          accessToken: data.access_token,
+          refreshToken: data.refresh_token ?? credentials.refreshToken,
+          // Admin refresh endpoint doesn't return expires_in; default to 1 hour
+          expiresAt: Date.now() + 3600 * 1e3,
+          apiUrl: credentials.apiUrl
+        };
+        storeCredentials(newCredentials);
+        verbose("Token refreshed successfully");
+        return data.access_token;
+      } catch {
+        verbose("Token refresh error");
+        return null;
+      } finally {
+        this.refreshing = null;
+      }
+    })();
+    return this.refreshing;
+  }
+  serializeBody(body, contentType) {
+    if (!body) return void 0;
+    if (contentType === "application/json") {
+      return JSON.stringify(body);
+    }
+    return body;
+  }
+  async request(path6, options = {}) {
+    const { method = "GET", body, headers = {}, timeout = 3e4 } = options;
+    const url = `${this.apiUrl}${path6}`;
+    const token = await this.getToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    if (body && !headers["Content-Type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+    const serializedBody = this.serializeBody(body, headers["Content-Type"]);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    verbose(`${method} ${url}`);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: serializedBody,
+        signal: controller.signal
+      });
+      if (response.status === 401 && !this.explicitToken) {
+        const credentials = getStoredCredentials();
+        if (credentials?.refreshToken) {
+          const newToken = await this.refreshAccessToken(credentials);
+          if (newToken) {
+            headers["Authorization"] = `Bearer ${newToken}`;
+            const retryController = new AbortController();
+            const retryTimer = setTimeout(() => retryController.abort(), timeout);
+            const retryResponse = await fetch(url, {
+              method,
+              headers,
+              body: serializedBody,
+              signal: retryController.signal
+            });
+            clearTimeout(retryTimer);
+            if (!retryResponse.ok) {
+              await this.throwApiError(retryResponse);
+            }
+            return await retryResponse.json();
+          }
+        }
+        throw new Error(
+          'Authentication required. Run "spacelr login" to authenticate.'
+        );
+      }
+      if (!response.ok) {
+        await this.throwApiError(response);
+      }
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        return await response.json();
+      }
+      return await response.text();
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error(`Request timed out: ${method} ${path6}`);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async throwApiError(response) {
+    let message;
+    try {
+      const body = await response.json();
+      message = body.message ?? body.error ?? response.statusText;
+    } catch {
+      message = response.statusText;
+    }
+    throw new Error(`API error (${response.status}): ${message}`);
+  }
+  async get(path6, timeout) {
+    return this.request(path6, { timeout });
+  }
+  async post(path6, body, timeout) {
+    return this.request(path6, { method: "POST", body, timeout });
+  }
+  async put(path6, body, timeout) {
+    return this.request(path6, { method: "PUT", body, timeout });
+  }
+  async delete(path6, timeout) {
+    return this.request(path6, { method: "DELETE", timeout });
+  }
+  async uploadFile(path6, fileBuffer, filename) {
+    const boundary = `----spacelr${Date.now()}`;
+    const parts = [];
+    const header = Buffer.from(
+      `--${boundary}\r
+Content-Disposition: form-data; name="file"; filename="${filename}"\r
+Content-Type: application/zip\r
+\r
+`
+    );
+    const footer = Buffer.from(`\r
+--${boundary}--\r
+`);
+    parts.push(header, fileBuffer, footer);
+    const body = Buffer.concat(parts);
+    return this.request(path6, {
+      method: "POST",
+      body,
+      headers: {
+        "Content-Type": `multipart/form-data; boundary=${boundary}`
+      },
+      timeout: 3e5
+      // 5 minutes for uploads
+    });
+  }
+};
+
+// libs/cli/src/commands/whoami.ts
+function createWhoamiCommand() {
+  return new import_commander3.Command("whoami").description("Show current authenticated user").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig();
+    const apiUrl = resolveApiUrl(globalOpts.apiUrl, config);
+    try {
+      const token = requireAuth(globalOpts.token);
+      const client = new ApiClient({ apiUrl, token });
+      const response = await client.get("/auth/me");
+      const user = response.user;
+      if (isJsonMode()) {
+        json(user);
+      } else {
+        success(`Logged in as ${user.email ?? user.username ?? user.id}`);
+        if (user.displayName) info(`Name: ${user.displayName}`);
+        if (user.roles?.length) info(`Roles: ${user.roles.join(", ")}`);
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get user info");
+      process.exitCode = 1;
+    }
+  });
+}
+
+// libs/cli/src/commands/projects.ts
+var import_commander4 = require("commander");
+function createProjectsCommand() {
+  return new import_commander4.Command("projects").description("List your projects").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig();
+    const apiUrl = resolveApiUrl(globalOpts.apiUrl, config);
+    try {
+      const token = requireAuth(globalOpts.token);
+      const client = new ApiClient({ apiUrl, token });
+      const spin = spinner("Fetching projects...");
+      const result = await client.get("/projects");
+      spin.stop();
+      const projects = result.projects;
+      if (projects.length === 0) {
+        info("No projects found");
+        return;
+      }
+      const activeProjectId = config?.projectId;
+      if (isJsonMode()) {
+        json(projects);
+      } else {
+        table(
+          ["", "ID", "Name", "Slug"],
+          projects.map((p) => [
+            p.id === activeProjectId ? "*" : " ",
+            p.id,
+            p.name,
+            p.slug
+          ])
+        );
+        if (activeProjectId) {
+          info(`
+* = active project (from spacelr.json)`);
+        }
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to list projects");
+      process.exitCode = 1;
+    }
+  });
+}
+async function fetchProjects(client) {
+  const result = await client.get("/projects");
+  return result.projects;
+}
+
+// libs/cli/src/commands/use.ts
+var import_commander5 = require("commander");
+
+// libs/cli/src/lib/prompt.ts
+var readline = __toESM(require("readline"));
+async function promptChoice(message, choices) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  console.error(`
+${message}
+`);
+  choices.forEach((choice, i) => {
+    console.error(`  ${i + 1}) ${choice.label}`);
+  });
+  console.error();
+  return new Promise((resolve3, reject) => {
+    rl.question("  Enter number: ", (answer) => {
+      rl.close();
+      const index = parseInt(answer, 10) - 1;
+      if (isNaN(index) || index < 0 || index >= choices.length) {
+        reject(new Error("Invalid selection"));
+        return;
+      }
+      resolve3(choices[index]);
+    });
+  });
+}
+async function promptConfirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  return new Promise((resolve3) => {
+    rl.question(`${message} (y/N) `, (answer) => {
+      rl.close();
+      resolve3(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function promptInput(message, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  const suffix = defaultValue ? ` (${defaultValue})` : "";
+  return new Promise((resolve3) => {
+    rl.question(`${message}${suffix}: `, (answer) => {
+      rl.close();
+      resolve3(answer.trim() || defaultValue || "");
+    });
+  });
+}
+
+// libs/cli/src/commands/use.ts
+function createUseCommand() {
+  return new import_commander5.Command("use").description("Set the active project").argument("[project]", "Project ID or slug").action(async (project, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig();
+    const apiUrl = resolveApiUrl(globalOpts.apiUrl, config);
+    try {
+      const token = requireAuth(globalOpts.token);
+      const client = new ApiClient({ apiUrl, token });
+      const spin = spinner("Fetching projects...");
+      const projects = await fetchProjects(client);
+      spin.stop();
+      if (projects.length === 0) {
+        error("No projects found. Create a project first.");
+        process.exitCode = 1;
+        return;
+      }
+      let selected;
+      if (project) {
+        const match = projects.find(
+          (p) => p.id === project || p.slug === project
+        );
+        if (!match) {
+          error(`Project "${project}" not found`);
+          info("Available projects:");
+          for (const p of projects) {
+            info(`  ${p.slug} (${p.id})`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+        selected = match;
+      } else {
+        selected = await promptChoice(
+          "Select a project:",
+          projects.map((p) => ({
+            ...p,
+            label: `${p.name} (${p.slug})`
+          }))
+        );
+      }
+      const updatedConfig = { ...config, projectId: selected.id };
+      saveConfig(updatedConfig);
+      if (isJsonMode()) {
+        json({ projectId: selected.id, name: selected.name, slug: selected.slug });
+      } else {
+        success(`Now using project "${selected.name}" (${selected.slug})`);
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to select project");
+      process.exitCode = 1;
+    }
+  });
+}
+
+// libs/cli/src/commands/init.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var import_commander6 = require("commander");
+function createInitCommand() {
+  return new import_commander6.Command("init").description("Initialize a spacelr.json config in the current directory").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const existingConfig = loadConfig();
+    const configPath = path3.join(process.cwd(), "spacelr.json");
+    if (fs3.existsSync(configPath)) {
+      warn(`spacelr.json already exists in ${process.cwd()}`);
+      info('Use "spacelr use" to change the active project');
+      return;
+    }
+    const apiUrl = resolveApiUrl(globalOpts.apiUrl, existingConfig);
+    try {
+      const token = requireAuth(globalOpts.token);
+      const client = new ApiClient({ apiUrl, token });
+      const spin = spinner("Fetching projects...");
+      const projects = await fetchProjects(client);
+      spin.stop();
+      if (projects.length === 0) {
+        error("No projects found. Create a project in the admin panel first.");
+        process.exitCode = 1;
+        return;
+      }
+      const selected = await promptChoice(
+        "Select a project:",
+        projects.map((p) => ({
+          ...p,
+          label: `${p.name} (${p.slug})`
+        }))
+      );
+      const hostingDir = await promptInput(
+        "Hosting directory",
+        "./dist"
+      );
+      const config = {
+        projectId: selected.id,
+        apiUrl: apiUrl !== "https://api.spacelr.io" ? apiUrl : void 0,
+        hosting: {
+          directory: hostingDir
+        },
+        database: {
+          indexes: {},
+          rules: {}
+        }
+      };
+      saveConfig(config, configPath);
+      if (isJsonMode()) {
+        json(config);
+      } else {
+        success(`Created spacelr.json for "${selected.name}"`);
+        info(`Project: ${selected.slug} (${selected.id})`);
+        info(`Hosting directory: ${hostingDir}`);
+        info("");
+        info("Next steps:");
+        info("  spacelr deploy              Deploy your site");
+        info("  spacelr db indexes pull     Pull database indexes");
+        info("  spacelr db rules pull       Pull database rules");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Initialization failed");
+      process.exitCode = 1;
+    }
+  });
+}
+
+// libs/cli/src/commands/deploy.ts
+var path5 = __toESM(require("path"));
+var import_commander7 = require("commander");
+
+// libs/cli/src/lib/zip.ts
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var import_archiver = __toESM(require("archiver"));
+async function createZipBuffer(directory) {
+  const absDir = path4.resolve(directory);
+  if (!fs4.existsSync(absDir)) {
+    throw new Error(`Directory not found: ${absDir}`);
+  }
+  if (!fs4.statSync(absDir).isDirectory()) {
+    throw new Error(`Not a directory: ${absDir}`);
+  }
+  return new Promise((resolve3, reject) => {
+    const chunks = [];
+    const archive = (0, import_archiver.default)("zip", { zlib: { level: 9 } });
+    archive.on("data", (chunk) => chunks.push(chunk));
+    archive.on("end", () => resolve3(Buffer.concat(chunks)));
+    archive.on("error", reject);
+    archive.directory(absDir, false);
+    archive.finalize();
+  });
+}
+function countFiles(directory) {
+  const absDir = path4.resolve(directory);
+  let count = 0;
+  function walk(dir) {
+    const entries = fs4.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        count++;
+      } else if (entry.isDirectory()) {
+        walk(path4.join(dir, entry.name));
+      }
+    }
+  }
+  walk(absDir);
+  return count;
+}
+
+// libs/cli/src/commands/deploy.ts
+function createDeployCommand() {
+  return new import_commander7.Command("deploy").description("Deploy a directory to Spacelr hosting").argument("[directory]", "Directory to deploy").option("--project <id>", "Project ID").option("--description <text>", "Deployment description").option("--no-wait", "Do not wait for processing to complete").option("--dry-run", "Show what would be deployed without uploading").action(async (directory, opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig();
+    const apiUrl = resolveApiUrl(globalOpts.apiUrl, config);
+    try {
+      const token = requireAuth(globalOpts.token);
+      const projectId = resolveProjectId(opts.project, config);
+      const deployDir = directory ?? config?.hosting?.directory ?? ".";
+      const absDir = path5.resolve(deployDir);
+      const client = new ApiClient({ apiUrl, token });
+      await deploy(client, projectId, absDir, {
+        description: opts.description,
+        wait: opts.wait !== false,
+        dryRun: opts.dryRun === true
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Deployment failed");
+      process.exitCode = 1;
+    }
+  });
+}
+async function deploy(client, projectId, directory, options) {
+  const spin = spinner("Preparing deployment...");
+  const fileCount = countFiles(directory);
+  verbose(`Found ${fileCount} files in ${directory}`);
+  spin.text = "Creating archive...";
+  const zipBuffer = await createZipBuffer(directory);
+  verbose(`Archive size: ${formatBytes(zipBuffer.length)}`);
+  if (options.dryRun) {
+    spin.succeed("Dry run complete");
+    if (isJsonMode()) {
+      json({ dryRun: true, fileCount, archiveSize: zipBuffer.length, directory });
+    } else {
+      info(`Directory: ${directory}`);
+      info(`Files: ${fileCount}`);
+      info(`Archive size: ${formatBytes(zipBuffer.length)}`);
+    }
+    return;
+  }
+  spin.text = "Creating deployment...";
+  const deployment = await client.post(
+    "/hosting/deployments",
+    {
+      projectId,
+      description: options.description
+    }
+  );
+  verbose(`Deployment ID: ${deployment.deploymentId}`);
+  spin.text = `Uploading ${formatBytes(zipBuffer.length)}...`;
+  await client.uploadFile(
+    `/hosting/deployments/${deployment.deploymentId}/upload`,
+    zipBuffer,
+    "deployment.zip"
+  );
+  if (!options.wait) {
+    spin.succeed("Upload complete");
+    info(`Deployment ${deployment.deploymentId} is processing`);
+    if (isJsonMode()) {
+      json({ deploymentId: deployment.deploymentId, status: "processing" });
+    }
+    return;
+  }
+  spin.text = "Processing deployment...";
+  const result = await pollDeploymentStatus(
+    client,
+    deployment.deploymentId,
+    spin
+  );
+  if (result.status === "active") {
+    spin.succeed("Deployment active");
+    if (isJsonMode()) {
+      json(result);
+    } else {
+      info(`Deployment ID: ${result.deploymentId}`);
+      info(`Files: ${result.fileCount}`);
+      info(`Size: ${formatBytes(result.totalSizeBytes)}`);
+    }
+  } else if (result.status === "failed") {
+    spin.fail("Deployment failed");
+    error(result.errorMessage ?? "Unknown error");
+    process.exitCode = 1;
+  } else {
+    spin.warn(`Deployment status: ${result.status}`);
+    if (isJsonMode()) {
+      json(result);
+    }
+  }
+}
+async function pollDeploymentStatus(client, deploymentId, spin) {
+  const maxAttempts = 120;
+  for (let i = 0; i < maxAttempts; i++) {
+    await sleep(5e3);
+    const status = await client.get(
+      `/hosting/deployments/${deploymentId}/status`
+    );
+    verbose(`Poll ${i + 1}: status=${status.status}`);
+    spin.text = `Processing deployment... (${status.status})`;
+    if (status.status === "active" || status.status === "failed") {
+      return status;
+    }
+  }
+  throw new Error("Deployment timed out after 10 minutes");
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// libs/cli/src/commands/db/index.ts
+var import_commander12 = require("commander");
+
+// libs/cli/src/commands/db/indexes-deploy.ts
+var import_commander8 = require("commander");
+function createIndexesDeployCommand() {
+  return new import_commander8.Command("deploy").description("Deploy indexes from config to remote").option("--project <id>", "Project ID").option("--config <path>", "Config file path").option("--yes", "Skip confirmation").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig(opts.config);
+    const apiUrl = resolveApiUrl(globalOpts.apiUrl, config);
+    try {
+      const token = requireAuth(globalOpts.token);
+      const projectId = resolveProjectId(opts.project, config);
+      const indexes = config?.database?.indexes;
+      if (!indexes || Object.keys(indexes).length === 0) {
+        warn("No indexes defined in config");
+        return;
+      }
+      const indexRules = convertIndexFormat(indexes);
+      const collectionCount = Object.keys(indexRules).length;
+      const totalIndexes = Object.values(indexRules).reduce(
+        (sum, arr) => sum + arr.length,
+        0
+      );
+      if (!opts.yes) {
+        info(
+          `Will deploy ${totalIndexes} index(es) across ${collectionCount} collection(s)`
+        );
+        const confirmed = await promptConfirm("Proceed with deployment?");
+        if (!confirmed) {
+          info("Aborted");
+          return;
+        }
+      }
+      const spin = spinner("Deploying indexes...");
+      const client = new ApiClient({ apiUrl, token });
+      const result = await client.put(
+        `/databases/${projectId}/index-rules`,
+        { indexRules }
+      );
+      spin.succeed("Indexes deployed");
+      if (isJsonMode()) {
+        json(result);
+      } else {
+        success(result.message ?? "Indexes synced successfully");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to deploy indexes");
+      process.exitCode = 1;
+    }
+  });
+}
+function convertIndexFormat(indexes) {
+  const result = {};
+  for (const [collection, entries] of Object.entries(indexes)) {
+    result[collection] = entries.map((entry) => {
+      const fields = {};
+      for (const [field, direction] of Object.entries(entry.fields)) {
+        fields[field] = direction === 1 ? "asc" : "desc";
+      }
+      return {
+        fields,
+        ...entry.unique !== void 0 && { unique: entry.unique },
+        ...entry.sparse !== void 0 && { sparse: entry.sparse },
+        ...entry.ttlSeconds !== void 0 && { ttlSeconds: entry.ttlSeconds }
+      };
+    });
+  }
+  return result;
+}
+
+// libs/cli/src/commands/db/indexes-pull.ts
+var import_commander9 = require("commander");
+function createIndexesPullCommand() {
+  return new import_commander9.Command("pull").description("Pull current indexes from remote to config").option("--project <id>", "Project ID").option("--config <path>", "Config file path").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig(opts.config);
+    const apiUrl = resolveApiUrl(globalOpts.apiUrl, config);
+    try {
+      const token = requireAuth(globalOpts.token);
+      const projectId = resolveProjectId(opts.project, config);
+      const spin = spinner("Pulling indexes...");
+      const client = new ApiClient({ apiUrl, token });
+      const result = await client.get(`/databases/${projectId}/index-rules`);
+      const indexes = convertFromRemoteFormat(result.indexRules);
+      const updatedConfig = {
+        ...config,
+        projectId: config?.projectId ?? projectId,
+        database: {
+          ...config?.database,
+          indexes
+        }
+      };
+      saveConfig(updatedConfig, opts.config);
+      spin.succeed("Indexes pulled");
+      const collectionCount = Object.keys(indexes).length;
+      const totalIndexes = Object.values(indexes).reduce(
+        (sum, arr) => sum + arr.length,
+        0
+      );
+      if (isJsonMode()) {
+        json(indexes);
+      } else {
+        success(
+          `Pulled ${totalIndexes} index(es) from ${collectionCount} collection(s)`
+        );
+        info("Config file updated");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to pull indexes");
+      process.exitCode = 1;
+    }
+  });
+}
+function convertFromRemoteFormat(remoteIndexes) {
+  const result = {};
+  for (const [collection, entries] of Object.entries(remoteIndexes)) {
+    result[collection] = entries.map((entry) => {
+      const fields = {};
+      for (const [field, direction] of Object.entries(entry.fields)) {
+        fields[field] = direction === "asc" ? 1 : -1;
+      }
+      return {
+        fields,
+        ...entry.unique !== void 0 && { unique: entry.unique },
+        ...entry.sparse !== void 0 && { sparse: entry.sparse },
+        ...entry.ttlSeconds !== void 0 && {
+          ttlSeconds: entry.ttlSeconds
+        }
+      };
+    });
+  }
+  return result;
+}
+
+// libs/cli/src/commands/db/rules-deploy.ts
+var import_commander10 = require("commander");
+function createRulesDeployCommand() {
+  return new import_commander10.Command("deploy").description("Deploy rules from config to remote").option("--project <id>", "Project ID").option("--config <path>", "Config file path").option("--yes", "Skip confirmation").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig(opts.config);
+    const apiUrl = resolveApiUrl(globalOpts.apiUrl, config);
+    try {
+      const token = requireAuth(globalOpts.token);
+      const projectId = resolveProjectId(opts.project, config);
+      const rules = config?.database?.rules;
+      if (!rules || Object.keys(rules).length === 0) {
+        warn("No rules defined in config");
+        return;
+      }
+      const ruleCount = Object.keys(rules).length;
+      if (!opts.yes) {
+        info(`Will deploy rules for ${ruleCount} collection(s)`);
+        const confirmed = await promptConfirm("Proceed with deployment?");
+        if (!confirmed) {
+          info("Aborted");
+          return;
+        }
+      }
+      const spin = spinner("Validating rules...");
+      const client = new ApiClient({ apiUrl, token });
+      await client.post(
+        `/databases/${projectId}/rules/validate`,
+        { rules }
+      );
+      spin.text = "Deploying rules...";
+      const result = await client.put(
+        `/databases/${projectId}/rules`,
+        { rules }
+      );
+      spin.succeed("Rules deployed");
+      if (isJsonMode()) {
+        json(result);
+      } else {
+        success(result.message ?? "Rules deployed successfully");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to deploy rules");
+      process.exitCode = 1;
+    }
+  });
+}
+
+// libs/cli/src/commands/db/rules-pull.ts
+var import_commander11 = require("commander");
+function createRulesPullCommand() {
+  return new import_commander11.Command("pull").description("Pull current rules from remote to config").option("--project <id>", "Project ID").option("--config <path>", "Config file path").action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig(opts.config);
+    const apiUrl = resolveApiUrl(globalOpts.apiUrl, config);
+    try {
+      const token = requireAuth(globalOpts.token);
+      const projectId = resolveProjectId(opts.project, config);
+      const spin = spinner("Pulling rules...");
+      const client = new ApiClient({ apiUrl, token });
+      const result = await client.get(
+        `/databases/${projectId}/rules`
+      );
+      const rules = result.rules;
+      const updatedConfig = {
+        ...config,
+        projectId: config?.projectId ?? projectId,
+        database: {
+          ...config?.database,
+          rules
+        }
+      };
+      saveConfig(updatedConfig, opts.config);
+      spin.succeed("Rules pulled");
+      const ruleCount = Object.keys(rules).length;
+      if (isJsonMode()) {
+        json(rules);
+      } else {
+        success(`Pulled rules for ${ruleCount} collection(s)`);
+        info("Config file updated");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to pull rules");
+      process.exitCode = 1;
+    }
+  });
+}
+
+// libs/cli/src/commands/db/index.ts
+function createDbCommand() {
+  const indexes = new import_commander12.Command("indexes").description("Manage database indexes");
+  indexes.addCommand(createIndexesDeployCommand());
+  indexes.addCommand(createIndexesPullCommand());
+  const rules = new import_commander12.Command("rules").description("Manage database rules");
+  rules.addCommand(createRulesDeployCommand());
+  rules.addCommand(createRulesPullCommand());
+  const db = new import_commander12.Command("db").description("Database management commands");
+  db.addCommand(indexes);
+  db.addCommand(rules);
+  return db;
+}
+
+// libs/cli/src/index.ts
+var program = new import_commander13.Command();
+program.name("spacelr").description("CLI tool for the Spacelr platform").version("0.1.0").option("--api-url <url>", "Override API URL").option("--token <token>", "Explicit auth token (CI mode)").option("--json", "Output as JSON").option("--verbose", "Verbose logging").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.optsWithGlobals();
+  setOutputMode({
+    json: opts["json"],
+    verbose: opts["verbose"]
+  });
+});
+program.addCommand(createLoginCommand());
+program.addCommand(createLogoutCommand());
+program.addCommand(createWhoamiCommand());
+program.addCommand(createProjectsCommand());
+program.addCommand(createUseCommand());
+program.addCommand(createInitCommand());
+program.addCommand(createDeployCommand());
+program.addCommand(createDbCommand());
+program.parse();
+//# sourceMappingURL=index.js.map