@lumerahq/cli 0.7.0

package/dist/chunk-NDLYGKS6.js

@@ -0,0 +1,77 @@
+// src/lib/auth.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var GLOBAL_CONFIG_DIR = join(homedir(), ".config", "lumera");
+var GLOBAL_CREDS_PATH = join(GLOBAL_CONFIG_DIR, "credentials.json");
+function getLocalCredsPath(cwd = process.cwd()) {
+  return join(cwd, ".lumera", "credentials.json");
+}
+function getToken(cwd = process.cwd()) {
+  if (process.env.LUMERA_TOKEN) {
+    return process.env.LUMERA_TOKEN;
+  }
+  const localCredsPath = getLocalCredsPath(cwd);
+  if (existsSync(localCredsPath)) {
+    try {
+      const creds = JSON.parse(readFileSync(localCredsPath, "utf-8"));
+      if (creds.token) return creds.token;
+    } catch {
+    }
+  }
+  if (existsSync(GLOBAL_CREDS_PATH)) {
+    try {
+      const creds = JSON.parse(readFileSync(GLOBAL_CREDS_PATH, "utf-8"));
+      if (creds.token) return creds.token;
+    } catch {
+    }
+  }
+  throw new Error(
+    "No Lumera token found.\n  Run `lumera login` to authenticate, or\n  Set LUMERA_TOKEN environment variable"
+  );
+}
+function getTokenSource(cwd = process.cwd()) {
+  if (process.env.LUMERA_TOKEN) {
+    return "environment (LUMERA_TOKEN)";
+  }
+  const localCredsPath = getLocalCredsPath(cwd);
+  if (existsSync(localCredsPath)) {
+    try {
+      const creds = JSON.parse(readFileSync(localCredsPath, "utf-8"));
+      if (creds.token) return `project (${localCredsPath})`;
+    } catch {
+    }
+  }
+  if (existsSync(GLOBAL_CREDS_PATH)) {
+    try {
+      const creds = JSON.parse(readFileSync(GLOBAL_CREDS_PATH, "utf-8"));
+      if (creds.token) return `global (${GLOBAL_CREDS_PATH})`;
+    } catch {
+    }
+  }
+  return null;
+}
+function getCredentials(cwd = process.cwd()) {
+  const localCredsPath = getLocalCredsPath(cwd);
+  if (existsSync(localCredsPath)) {
+    try {
+      const creds = JSON.parse(readFileSync(localCredsPath, "utf-8"));
+      if (creds.token) return creds;
+    } catch {
+    }
+  }
+  if (existsSync(GLOBAL_CREDS_PATH)) {
+    try {
+      const creds = JSON.parse(readFileSync(GLOBAL_CREDS_PATH, "utf-8"));
+      if (creds.token) return creds;
+    } catch {
+    }
+  }
+  return null;
+}
+
+export {
+  getToken,
+  getTokenSource,
+  getCredentials
+};

package/dist/chunk-V2XXMMEI.js

@@ -0,0 +1,147 @@
+import {
+  getToken
+} from "./chunk-NDLYGKS6.js";
+
+// src/lib/api.ts
+var ApiClient = class {
+  baseUrl;
+  token;
+  constructor(token, baseUrl) {
+    this.token = token || getToken();
+    let base = baseUrl || process.env.LUMERA_BASE_URL || "https://app.lumerahq.com";
+    base = base.replace(/\/$/, "");
+    if (base.endsWith("/api")) {
+      base = base.slice(0, -4);
+    }
+    this.baseUrl = base.replace(/\/$/, "");
+  }
+  async request(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.token}`,
+      ...options.headers
+    };
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`API request failed: ${response.status} ${text}`);
+    }
+    if (response.status === 204) {
+      return {};
+    }
+    return response.json();
+  }
+  // Collections
+  async listCollections() {
+    const result = await this.request("/api/pb/collections");
+    return result.items;
+  }
+  async getCollection(id) {
+    return this.request(`/api/pb/collections/${id}`);
+  }
+  async ensureCollection(name, def) {
+    return this.request(`/api/pb/collections/${name}`, {
+      method: "PUT",
+      body: JSON.stringify(def)
+    });
+  }
+  async deleteCollection(id) {
+    await this.request(`/api/pb/collections/${id}`, {
+      method: "DELETE"
+    });
+  }
+  // Automations
+  async listAutomations(params) {
+    let path = "/api/automations";
+    if (params?.external_id) {
+      path += `?external_id=${encodeURIComponent(params.external_id)}`;
+    }
+    const result = await this.request(path);
+    return result.automations || [];
+  }
+  async getAutomation(id) {
+    return this.request(`/api/automations/${id}`);
+  }
+  async createAutomation(def) {
+    return this.request("/api/automations", {
+      method: "POST",
+      body: JSON.stringify(def)
+    });
+  }
+  async updateAutomation(id, def) {
+    return this.request(`/api/automations/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(def)
+    });
+  }
+  async deleteAutomation(id) {
+    await this.request(`/api/automations/${id}`, {
+      method: "DELETE"
+    });
+  }
+  // Automation Presets
+  async listPresets(automationId) {
+    const result = await this.request(
+      `/api/automations/${automationId}/presets`
+    );
+    return result.presets || [];
+  }
+  async createPreset(automationId, def) {
+    return this.request(`/api/automations/${automationId}/presets`, {
+      method: "POST",
+      body: JSON.stringify(def)
+    });
+  }
+  async updatePreset(presetId, def) {
+    return this.request(`/api/automation-presets/${presetId}`, {
+      method: "PATCH",
+      body: JSON.stringify(def)
+    });
+  }
+  async deletePreset(presetId) {
+    await this.request(`/api/automation-presets/${presetId}`, {
+      method: "DELETE"
+    });
+  }
+  // Hooks
+  async listHooks(params) {
+    const query = new URLSearchParams();
+    if (params?.collection_id) query.set("collection_id", params.collection_id);
+    if (params?.external_id) query.set("external_id", params.external_id);
+    const queryString = query.toString();
+    const path = queryString ? `/api/pb/hooks?${queryString}` : "/api/pb/hooks";
+    const result = await this.request(path);
+    return result.items || [];
+  }
+  async getHook(id) {
+    return this.request(`/api/pb/hooks/${id}`);
+  }
+  async createHook(def) {
+    return this.request("/api/pb/hooks", {
+      method: "POST",
+      body: JSON.stringify(def)
+    });
+  }
+  async updateHook(id, def) {
+    return this.request(`/api/pb/hooks/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(def)
+    });
+  }
+  async deleteHook(id) {
+    await this.request(`/api/pb/hooks/${id}`, {
+      method: "DELETE"
+    });
+  }
+};
+function createApiClient(token, baseUrl) {
+  return new ApiClient(token, baseUrl);
+}
+
+export {
+  createApiClient
+};

package/dist/dev-UTZC4ZJ7.js

@@ -0,0 +1,87 @@
+import {
+  dev
+} from "./chunk-AVKPM7C4.js";
+import {
+  loadEnv
+} from "./chunk-2CR762KB.js";
+import {
+  getToken
+} from "./chunk-NDLYGKS6.js";
+import {
+  findProjectRoot,
+  getApiUrl,
+  getAppName,
+  getAppTitle
+} from "./chunk-D2BLSEGR.js";
+
+// src/commands/dev.ts
+import pc from "picocolors";
+function parseFlags(args) {
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith("--")) {
+        result[key] = next;
+        i++;
+      } else {
+        result[key] = true;
+      }
+    }
+  }
+  return result;
+}
+function showHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera dev [options]
+
+${pc.dim("Description:")}
+  Start the development server with Lumera registration.
+  Registers your app with Lumera and starts a local dev server.
+
+${pc.dim("Options:")}
+  --port <number>        Dev server port (default: 8080)
+  --url <url>            App URL for dev mode (default: http://localhost:{port})
+  --help, -h             Show this help
+
+${pc.dim("Environment variables:")}
+  LUMERA_TOKEN           API token (overrides \`lumera login\`)
+  LUMERA_API_URL         API base URL (default: https://app.lumerahq.com/api)
+  PORT                   Dev server port (default: 8080)
+  APP_URL                App URL for dev mode
+
+${pc.dim("Examples:")}
+  lumera dev                    # Start dev server on port 8080
+  lumera dev --port 3000        # Start dev server on port 3000
+  lumera dev --url http://192.168.1.100:8080  # Custom URL for mobile testing
+`);
+}
+async function dev2(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    showHelp();
+    return;
+  }
+  const flags = parseFlags(args);
+  const projectRoot = findProjectRoot();
+  loadEnv(projectRoot);
+  const token = getToken(projectRoot);
+  const appName = getAppName(projectRoot);
+  const appTitle = getAppTitle(projectRoot);
+  const apiUrl = getApiUrl();
+  const port = Number(flags.port || process.env.PORT || "8080");
+  const appUrl = typeof flags.url === "string" ? flags.url : process.env.APP_URL;
+  await dev({
+    token,
+    appName,
+    appTitle,
+    port,
+    appUrl,
+    apiUrl
+  });
+}
+export {
+  dev2 as dev
+};

package/dist/index.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import pc from "picocolors";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+var VERSION = pkg.version;
+var args = process.argv.slice(2);
+var command = args[0];
+var subcommand = args[1];
+function showHelp() {
+  console.log(`
+${pc.bold("Lumera CLI")} - Build and deploy Lumera apps
+
+${pc.dim("Usage:")}
+  lumera <command> [options]
+
+${pc.dim("Resource Commands:")}
+  ${pc.cyan("plan")} [resource]          Preview changes
+  ${pc.cyan("apply")} [resource]         Create/update resources
+  ${pc.cyan("pull")} [resource]          Download remote state
+  ${pc.cyan("destroy")} [resource]       Delete resources
+  ${pc.cyan("list")} [type]              List resources with status
+  ${pc.cyan("show")} <resource>          Show resource details
+
+${pc.dim("Development:")}
+  ${pc.cyan("dev")}                      Start dev server
+  ${pc.cyan("run")} <target>             Run script or trigger automation
+
+${pc.dim("Project:")}
+  ${pc.cyan("init")} [name]              Scaffold a new project
+  ${pc.cyan("status")}                   Show project info
+  ${pc.cyan("migrate")}                  Upgrade legacy project
+
+${pc.dim("Skills:")}
+  ${pc.cyan("skills list")}              List available skills
+  ${pc.cyan("skills install")}           Install skills
+  ${pc.cyan("skills update")}            Update skills
+
+${pc.dim("Auth:")}
+  ${pc.cyan("login")}                    Login to Lumera
+  ${pc.cyan("logout")}                   Clear credentials
+  ${pc.cyan("whoami")}                   Show current user
+
+${pc.dim("Options:")}
+  --help, -h               Show help
+  --version, -v            Show version
+
+${pc.dim("Resource Types:")}
+  collections              Data collections (schemas)
+  automations              Background Python scripts
+  hooks                    Collection lifecycle handlers
+  app                      Frontend application
+
+${pc.dim("Examples:")}
+  lumera apply                        # Apply all resources
+  lumera apply collections/users      # Apply single collection
+  lumera apply app                    # Deploy frontend
+  lumera list                         # List all resources
+  lumera show collections/users       # Show collection details
+  lumera run scripts/seed.py          # Run a script
+  lumera run automations/sync         # Trigger automation
+  lumera dev                          # Start dev server
+
+${pc.dim("Documentation:")}
+  https://docs.lumerahq.com/cli
+`);
+}
+function showVersion() {
+  console.log(`lumera ${VERSION}`);
+}
+async function main() {
+  if (!command || command.startsWith("-")) {
+    if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+      showHelp();
+      process.exit(0);
+    }
+    if (args.includes("--version") || args.includes("-v")) {
+      showVersion();
+      process.exit(0);
+    }
+    if (command?.startsWith("-")) {
+      console.error(pc.red(`Unknown option: ${command}`));
+      showHelp();
+      process.exit(1);
+    }
+  }
+  try {
+    switch (command) {
+      // Resource commands
+      case "plan":
+        await import("./resources-PNK3NESI.js").then((m) => m.plan(args.slice(1)));
+        break;
+      case "apply":
+        await import("./resources-PNK3NESI.js").then((m) => m.apply(args.slice(1)));
+        break;
+      case "pull":
+        await import("./resources-PNK3NESI.js").then((m) => m.pull(args.slice(1)));
+        break;
+      case "destroy":
+        await import("./resources-PNK3NESI.js").then((m) => m.destroy(args.slice(1)));
+        break;
+      case "list":
+        await import("./resources-PNK3NESI.js").then((m) => m.list(args.slice(1)));
+        break;
+      case "show":
+        await import("./resources-PNK3NESI.js").then((m) => m.show(args.slice(1)));
+        break;
+      // Development
+      case "dev":
+        await import("./dev-UTZC4ZJ7.js").then((m) => m.dev(args.slice(1)));
+        break;
+      case "run":
+        await import("./run-4NDI2CN4.js").then((m) => m.run(args.slice(1)));
+        break;
+      // Project
+      case "init":
+        await import("./init-OQCIET53.js").then((m) => m.init(args.slice(1)));
+        break;
+      case "status":
+        await import("./status-BEVUV6RY.js").then((m) => m.status(args.slice(1)));
+        break;
+      case "migrate":
+        await import("./migrate-2DZ6RQ5K.js").then((m) => m.migrate(args.slice(1)));
+        break;
+      // Skills
+      case "skills":
+        await import("./skills-56EUKHGY.js").then((m) => m.skills(subcommand, args.slice(2)));
+        break;
+      // Auth
+      case "login":
+        await import("./auth-7RGL7GXU.js").then((m) => m.login(args.slice(1)));
+        break;
+      case "logout":
+        await import("./auth-7RGL7GXU.js").then((m) => m.logout(args.slice(1)));
+        break;
+      case "whoami":
+        await import("./auth-7RGL7GXU.js").then((m) => m.whoami());
+        break;
+      default:
+        console.error(pc.red(`Unknown command: ${command}`));
+        console.error(`Run ${pc.cyan("lumera --help")} for usage.`);
+        process.exit(1);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(pc.red(`Error: ${error.message}`));
+    } else {
+      console.error(pc.red("An unexpected error occurred"));
+    }
+    process.exit(1);
+  }
+}
+main();