@lumerahq/cli 0.10.0 → 0.11.0

package/dist/chunk-CHRKCAIZ.js

@@ -0,0 +1,155 @@
+// src/lib/templates.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "fs";
+import { homedir, tmpdir } from "os";
+import { join } from "path";
+import { spawnSync } from "child_process";
+var GITHUB_OWNER = "lumerahq";
+var GITHUB_REPO = "app-templates";
+var GITHUB_REF = "main";
+function getCacheDir() {
+  return join(homedir(), ".lumera", "templates");
+}
+function readCacheMeta() {
+  const metaPath = join(getCacheDir(), ".cache-meta.json");
+  if (!existsSync(metaPath)) return null;
+  try {
+    return JSON.parse(readFileSync(metaPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function fetchLatestSha() {
+  const url = `https://api.github.com/repos/${GITHUB_OWNER}/${GITHUB_REPO}/commits/${GITHUB_REF}`;
+  const res = await fetch(url, {
+    headers: { Accept: "application/vnd.github.sha" }
+  });
+  if (!res.ok) throw new Error(`GitHub API error: ${res.status}`);
+  return (await res.text()).trim();
+}
+async function downloadAndExtract(commitSha) {
+  const cacheDir = getCacheDir();
+  const tarballUrl = `https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/archive/refs/heads/${GITHUB_REF}.tar.gz`;
+  const res = await fetch(tarballUrl);
+  if (!res.ok) throw new Error(`Failed to download templates: ${res.status}`);
+  const tmpFile = join(tmpdir(), `lumera-templates-${Date.now()}.tar.gz`);
+  const buffer = Buffer.from(await res.arrayBuffer());
+  writeFileSync(tmpFile, buffer);
+  mkdirSync(cacheDir, { recursive: true });
+  for (const entry of readdirSync(cacheDir)) {
+    if (entry === ".cache-meta.json" || entry === ".refs") continue;
+    rmSync(join(cacheDir, entry), { recursive: true, force: true });
+  }
+  const result = spawnSync("tar", ["xzf", tmpFile, "-C", cacheDir, "--strip-components=1"], { stdio: "ignore" });
+  if (result.status !== 0) throw new Error("Failed to extract template archive");
+  unlinkSync(tmpFile);
+  const meta = { commitSha, fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  writeFileSync(join(cacheDir, ".cache-meta.json"), JSON.stringify(meta));
+  return cacheDir;
+}
+async function ensureRemoteCache() {
+  const cacheDir = getCacheDir();
+  const cached = readCacheMeta();
+  const latestSha = await fetchLatestSha();
+  if (cached?.commitSha === latestSha && existsSync(cacheDir)) {
+    return cacheDir;
+  }
+  console.log("  Fetching latest templates...");
+  return downloadAndExtract(latestSha);
+}
+function parseTemplateRef(input) {
+  const atIndex = input.lastIndexOf("@");
+  if (atIndex > 0) {
+    return {
+      name: input.slice(0, atIndex),
+      ref: input.slice(atIndex + 1)
+    };
+  }
+  return { name: input, ref: null };
+}
+async function ensureRemoteCacheForRef(ref) {
+  const refCacheDir = join(getCacheDir(), ".refs", ref);
+  if (existsSync(refCacheDir) && existsSync(join(refCacheDir, ".cache-meta.json"))) {
+    return refCacheDir;
+  }
+  console.log(`  Fetching templates at ref "${ref}"...`);
+  const urls = [
+    `https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/archive/refs/tags/${ref}.tar.gz`,
+    `https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/archive/refs/heads/${ref}.tar.gz`,
+    `https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/archive/${ref}.tar.gz`
+  ];
+  let res = null;
+  for (const url of urls) {
+    const attempt = await fetch(url);
+    if (attempt.ok) {
+      res = attempt;
+      break;
+    }
+  }
+  if (!res) {
+    throw new Error(
+      `Failed to fetch templates at ref "${ref}". Ensure the tag, branch, or SHA exists in ${GITHUB_OWNER}/${GITHUB_REPO}.`
+    );
+  }
+  const tmpFile = join(tmpdir(), `lumera-templates-${ref}-${Date.now()}.tar.gz`);
+  const buffer = Buffer.from(await res.arrayBuffer());
+  writeFileSync(tmpFile, buffer);
+  mkdirSync(refCacheDir, { recursive: true });
+  const result = spawnSync("tar", ["xzf", tmpFile, "-C", refCacheDir, "--strip-components=1"], { stdio: "ignore" });
+  if (result.status !== 0) throw new Error("Failed to extract template archive");
+  unlinkSync(tmpFile);
+  const meta = { commitSha: ref, fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  writeFileSync(join(refCacheDir, ".cache-meta.json"), JSON.stringify(meta));
+  return refCacheDir;
+}
+function listTemplates(baseDir) {
+  if (!existsSync(baseDir)) return [];
+  const templates = [];
+  for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const metaPath = join(baseDir, entry.name, "template.json");
+    if (!existsSync(metaPath)) continue;
+    try {
+      const raw = JSON.parse(readFileSync(metaPath, "utf-8"));
+      if (!raw.name || !raw.title || !raw.description || !raw.category) {
+        console.warn(`Warning: Skipping template "${entry.name}" \u2014 template.json is missing required fields (name, title, description, category)`);
+        continue;
+      }
+      templates.push(raw);
+    } catch {
+      console.warn(`Warning: Skipping template "${entry.name}" \u2014 invalid template.json`);
+    }
+  }
+  return templates.sort((a, b) => {
+    if (a.name === "default") return -1;
+    if (b.name === "default") return 1;
+    return a.title.localeCompare(b.title);
+  });
+}
+async function resolveTemplate(nameWithRef) {
+  const { name, ref } = parseTemplateRef(nameWithRef);
+  const cacheDir = ref ? await ensureRemoteCacheForRef(ref) : await ensureRemoteCache();
+  const dir = join(cacheDir, name);
+  if (!existsSync(dir) || !existsSync(join(dir, "template.json"))) {
+    const available = listTemplates(cacheDir).map((t) => t.name).join(", ");
+    if (ref) {
+      throw new Error(
+        `Template "${name}" not found at ref "${ref}". Available: ${available || "none"}`
+      );
+    }
+    throw new Error(
+      `Template "${name}" not found. Available: ${available || "none"}
+  Cache location: ${cacheDir}
+  Try deleting the cache and retrying: rm -rf ${cacheDir}`
+    );
+  }
+  return dir;
+}
+async function listAllTemplates() {
+  const cacheDir = await ensureRemoteCache();
+  return listTemplates(cacheDir);
+}
+
+export {
+  resolveTemplate,
+  listAllTemplates
+};

package/dist/{chunk-WRAZC6SJ.js → chunk-HIYM7EM2.js}

@@ -143,6 +143,22 @@ function createApiClient(token, baseUrl) {
   return new ApiClient(token, baseUrl);
 }
 
+// src/lib/env.ts
+import { config } from "dotenv";
+import { existsSync } from "fs";
+import { resolve } from "path";
+function loadEnv(cwd = process.cwd()) {
+  const envPath = resolve(cwd, ".env");
+  const envLocalPath = resolve(cwd, ".env.local");
+  if (existsSync(envPath)) {
+    config({ path: envPath });
+  }
+  if (existsSync(envLocalPath)) {
+    config({ path: envLocalPath, override: true });
+  }
+}
+
 export {
-  createApiClient
+  createApiClient,
+  loadEnv
 };

package/dist/dev-2HVDP3NX.js

@@ -0,0 +1,155 @@
+import {
+  dev
+} from "./chunk-CDZZ3JYU.js";
+import {
+  createApiClient,
+  loadEnv
+} from "./chunk-HIYM7EM2.js";
+import {
+  getToken
+} from "./chunk-NDLYGKS6.js";
+import {
+  findProjectRoot,
+  getApiUrl,
+  getAppName,
+  getAppTitle
+} from "./chunk-D2BLSEGR.js";
+
+// src/commands/dev.ts
+import pc from "picocolors";
+import { execFileSync, execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+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.
+  On first run, automatically applies resources and seeds demo data.
+
+${pc.dim("Options:")}
+  --port <number>        Dev server port (default: 8080)
+  --url <url>            App URL for dev mode (default: http://localhost:{port})
+  --skip-setup           Skip auto-apply on first run
+  --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 --skip-setup       # Skip first-run auto-apply
+`);
+}
+async function isFreshProject(projectRoot) {
+  try {
+    const api = createApiClient();
+    const remoteCollections = await api.listCollections();
+    const customCollections = remoteCollections.filter((c) => !c.system && !c.managed);
+    const platformDir = existsSync(join(projectRoot, "platform")) ? join(projectRoot, "platform") : join(projectRoot, "lumera_platform");
+    const collectionsDir = join(platformDir, "collections");
+    const hasLocalCollections = existsSync(collectionsDir);
+    return customCollections.length === 0 && hasLocalCollections;
+  } catch {
+    return false;
+  }
+}
+function runApply(projectRoot) {
+  try {
+    execFileSync(process.execPath, [...process.execArgv, process.argv[1], "apply"], {
+      cwd: projectRoot,
+      stdio: "inherit",
+      env: process.env
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runSeed(projectRoot) {
+  const seedScript = join(projectRoot, "scripts", "seed-demo.py");
+  if (!existsSync(seedScript)) return false;
+  try {
+    execSync(`uv run "${seedScript}"`, {
+      cwd: projectRoot,
+      stdio: "inherit",
+      env: process.env
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+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();
+  if (!flags["skip-setup"]) {
+    const fresh = await isFreshProject(projectRoot);
+    if (fresh) {
+      console.log();
+      console.log(pc.cyan(pc.bold("  First run detected")), pc.dim("\u2014 applying resources and seeding data..."));
+      console.log();
+      const applyOk = runApply(projectRoot);
+      if (!applyOk) {
+        console.log(pc.yellow("  \u26A0 Some resources failed to apply (continuing)"));
+      }
+      const seedScript = join(projectRoot, "scripts", "seed-demo.py");
+      if (existsSync(seedScript)) {
+        console.log();
+        console.log(pc.dim("  Running seed script..."));
+        if (runSeed(projectRoot)) {
+          console.log(pc.green("  \u2713"), pc.dim("Seed data applied"));
+        } else {
+          console.log(pc.yellow("  \u26A0"), pc.dim("Seed script failed (continuing)"));
+        }
+      }
+      console.log();
+    }
+  }
+  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

@@ -1,16 +1,127 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync } from "fs";
-import { dirname, join } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
 import pc from "picocolors";
+
+// src/lib/update-check.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function getCachePath() {
+  return join(homedir(), ".lumera", "update-check.json");
+}
+function readCache() {
+  const cachePath = getCachePath();
+  if (!existsSync(cachePath)) return null;
+  try {
+    return JSON.parse(readFileSync(cachePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeCache(data) {
+  const dir = join(homedir(), ".lumera");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(getCachePath(), JSON.stringify(data));
+}
+function isNewer(latest, current) {
+  const l = latest.split(".").map(Number);
+  const c = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((l[i] || 0) > (c[i] || 0)) return true;
+    if ((l[i] || 0) < (c[i] || 0)) return false;
+  }
+  return false;
+}
+async function checkForUpdate(currentVersion) {
+  try {
+    if (process.env.CI || process.env.LUMERA_NO_UPDATE_CHECK) return null;
+    const cache = readCache();
+    if (cache) {
+      const age = Date.now() - new Date(cache.lastCheck).getTime();
+      if (age < CHECK_INTERVAL_MS) {
+        if (isNewer(cache.latestVersion, currentVersion)) {
+          return { current: currentVersion, latest: cache.latestVersion };
+        }
+        return null;
+      }
+    }
+    const res = await fetch("https://registry.npmjs.org/@lumerahq/cli/latest");
+    if (!res.ok) return null;
+    const data = await res.json();
+    const latest = data.version;
+    writeCache({ lastCheck: (/* @__PURE__ */ new Date()).toISOString(), latestVersion: latest });
+    if (isNewer(latest, currentVersion)) {
+      return { current: currentVersion, latest };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/index.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
-var pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync2(join2(__dirname, "..", "package.json"), "utf-8"));
 var VERSION = pkg.version;
-var args = process.argv.slice(2);
+var rawArgs = process.argv.slice(2);
+var jsonMode = rawArgs.includes("--json");
+if (jsonMode) process.env.LUMERA_JSON = "1";
+var args = rawArgs.filter((a) => a !== "--json");
 var command = args[0];
 var subcommand = args[1];
+var COMMANDS = [
+  "plan",
+  "apply",
+  "pull",
+  "destroy",
+  "list",
+  "show",
+  "dev",
+  "run",
+  "init",
+  "templates",
+  "status",
+  "migrate",
+  "skills",
+  "login",
+  "logout",
+  "whoami"
+];
+function editDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    }
+  }
+  return dp[m][n];
+}
+function suggestCommand(input) {
+  let best = "";
+  let bestDist = Infinity;
+  for (const cmd of COMMANDS) {
+    const d = editDistance(input.toLowerCase(), cmd);
+    if (d < bestDist) {
+      bestDist = d;
+      best = cmd;
+    }
+  }
+  const threshold = Math.max(2, Math.ceil(input.length * 0.4));
+  return bestDist <= threshold ? best : null;
+}
+function formatElapsed(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
 function showHelp() {
   console.log(`
 ${pc.bold("Lumera CLI")} - Build and deploy Lumera apps
@@ -32,6 +143,8 @@ ${pc.dim("Development:")}
 
 ${pc.dim("Project:")}
   ${pc.cyan("init")} [name]              Scaffold a new project
+  ${pc.cyan("templates list")}           List available templates
+  ${pc.cyan("templates validate")}       Validate a template directory
   ${pc.cyan("status")}                   Show project info
   ${pc.cyan("migrate")}                  Upgrade legacy project
 
@@ -48,6 +161,7 @@ ${pc.dim("Auth:")}
 ${pc.dim("Options:")}
   --help, -h               Show help
   --version, -v            Show version
+  --json                   Output as JSON (where supported)
 
 ${pc.dim("Resource Types:")}
   collections              Data collections (schemas)
@@ -88,37 +202,42 @@ async function main() {
       process.exit(1);
     }
   }
+  const startTime = performance.now();
+  const updateCheck = checkForUpdate(VERSION);
   try {
     switch (command) {
       // Resource commands
       case "plan":
-        await import("./resources-PGBVCS2K.js").then((m) => m.plan(args.slice(1)));
+        await import("./resources-GTG3QMVV.js").then((m) => m.plan(args.slice(1)));
         break;
       case "apply":
-        await import("./resources-PGBVCS2K.js").then((m) => m.apply(args.slice(1)));
+        await import("./resources-GTG3QMVV.js").then((m) => m.apply(args.slice(1)));
         break;
       case "pull":
-        await import("./resources-PGBVCS2K.js").then((m) => m.pull(args.slice(1)));
+        await import("./resources-GTG3QMVV.js").then((m) => m.pull(args.slice(1)));
         break;
       case "destroy":
-        await import("./resources-PGBVCS2K.js").then((m) => m.destroy(args.slice(1)));
+        await import("./resources-GTG3QMVV.js").then((m) => m.destroy(args.slice(1)));
         break;
       case "list":
-        await import("./resources-PGBVCS2K.js").then((m) => m.list(args.slice(1)));
+        await import("./resources-GTG3QMVV.js").then((m) => m.list(args.slice(1)));
         break;
       case "show":
-        await import("./resources-PGBVCS2K.js").then((m) => m.show(args.slice(1)));
+        await import("./resources-GTG3QMVV.js").then((m) => m.show(args.slice(1)));
         break;
       // Development
       case "dev":
-        await import("./dev-BHBF4ECH.js").then((m) => m.dev(args.slice(1)));
+        await import("./dev-2HVDP3NX.js").then((m) => m.dev(args.slice(1)));
         break;
       case "run":
-        await import("./run-WIRQDYYX.js").then((m) => m.run(args.slice(1)));
+        await import("./run-47GF5VVS.js").then((m) => m.run(args.slice(1)));
         break;
       // Project
       case "init":
-        await import("./init-EDSRR3YM.js").then((m) => m.init(args.slice(1)));
+        await import("./init-VNJNSU4Q.js").then((m) => m.init(args.slice(1)));
+        break;
+      case "templates":
+        await import("./templates-6KMZWOYH.js").then((m) => m.templates(subcommand, args.slice(2)));
         break;
       case "status":
         await import("./status-E4IHEUKO.js").then((m) => m.status(args.slice(1)));
@@ -140,10 +259,43 @@ async function main() {
       case "whoami":
         await import("./auth-7RGL7GXU.js").then((m) => m.whoami());
         break;
-      default:
+      // Convenience aliases
+      case "help":
+        showHelp();
+        break;
+      case "version":
+        showVersion();
+        break;
+      default: {
+        const suggestion = suggestCommand(command);
         console.error(pc.red(`Unknown command: ${command}`));
+        if (suggestion) {
+          console.error(`Did you mean ${pc.cyan(suggestion)}?`);
+        }
         console.error(`Run ${pc.cyan("lumera --help")} for usage.`);
         process.exit(1);
+      }
+    }
+    if (!jsonMode) {
+      const elapsed = performance.now() - startTime;
+      if (elapsed >= 500) {
+        console.log(pc.dim(`
+Done in ${formatElapsed(elapsed)}`));
+      }
+    }
+    if (!jsonMode) {
+      try {
+        const update = await Promise.race([
+          updateCheck,
+          new Promise((resolve) => setTimeout(() => resolve(null), 3e3))
+        ]);
+        if (update) {
+          console.log();
+          console.log(`  ${pc.yellow("Update available:")} ${pc.dim(update.current)} \u2192 ${pc.green(update.latest)}`);
+          console.log(`  Run ${pc.cyan("npm i -g @lumerahq/cli")} to update`);
+        }
+      } catch {
+      }
     }
   } catch (error) {
     if (error instanceof Error) {