@lumerahq/cli 0.19.3-dev.0 → 0.19.3

package/README.md

@@ -51,24 +51,26 @@ For CI/CD or scripted environments, use `-y` (or `--yes`) flag:
 lumera init my-app -y                 # Creates ./my-app
 lumera init my-app -y --dir ./apps    # Creates ./apps
 lumera init my-app -y --force         # Overwrites if directory exists
-lumera init my-app -y --install       # Also runs pnpm install
+lumera init my-app -y --no-install    # Skip pnpm install
 ```
 
 ### Init Options
 
 | Flag | Short | Description |
 |------|-------|-------------|
+| `--template <name>` | `-t` | Template to use (currently bundled: `default`) |
 | `--yes` | `-y` | Non-interactive mode (project name required) |
 | `--dir <path>` | `-d` | Target directory (defaults to project name) |
 | `--force` | `-f` | Overwrite existing directory without prompting |
-| `--install` | `-i` | Install dependencies after scaffolding |
+| `--no-install` | | Skip dependency installation |
+| `--open` | `-o` | Open project in editor after scaffolding |
 | `--help` | `-h` | Show help |
 
 ### CI/CD Example
 
 ```bash
 # Full non-interactive setup
-lumera init my-app -y -f -i
+lumera init my-app -y -f
 ```
 
 ## Authentication

package/dist/chunk-H357NP7T.js

@@ -0,0 +1,77 @@
+// src/lib/templates.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function getBundledTemplatesDir() {
+  if (process.env.LUMERA_TEMPLATES_DIR) {
+    return process.env.LUMERA_TEMPLATES_DIR;
+  }
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    // Built package: dist/*.js -> templates/
+    join(moduleDir, "..", "templates"),
+    // Source/dev execution: src/lib/*.ts -> templates/
+    join(moduleDir, "..", "..", "templates")
+  ];
+  return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+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 };
+}
+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 templatesDir = getBundledTemplatesDir();
+  const available = listTemplates(templatesDir).map((t) => t.name).join(", ");
+  if (ref) {
+    throw new Error(
+      `Template refs are no longer downloaded by the CLI. Use one of the bundled templates: ${available || "none"}`
+    );
+  }
+  const dir = join(templatesDir, name);
+  if (!existsSync(dir) || !existsSync(join(dir, "template.json"))) {
+    throw new Error(
+      `Template "${name}" not found. Available: ${available || "none"}
+  Templates location: ${templatesDir}`
+    );
+  }
+  return dir;
+}
+async function listAllTemplates() {
+  return listTemplates(getBundledTemplatesDir());
+}
+
+export {
+  resolveTemplate,
+  listAllTemplates
+};

package/dist/{chunk-GKI2HQJC.js → chunk-JKXLKK5I.js}

@@ -74,6 +74,13 @@ var ApiClient = class {
     return response.json();
   }
   // Collections
+  async getMe() {
+    return this.request("/api/me");
+  }
+  async isProjectPermissionsModeEnabled() {
+    const me = await this.getMe();
+    return me.user?.feature_flags?.project_permissions_mode === true;
+  }
   async listCollections() {
     const result = await this.request("/api/pb/collections");
     return result.items;
@@ -302,7 +309,13 @@ var ApiClient = class {
       updated: rec.updated
     };
   }
-  // Project manifest — list public collections for a project
+  async listProjectResourceShares(projectExternalId, direction = "all") {
+    const qs = direction && direction !== "all" ? `?direction=${encodeURIComponent(direction)}` : "";
+    return this.request(
+      `/api/projects/${encodeURIComponent(projectExternalId)}/resource-shares${qs}`
+    );
+  }
+  // Project manifest — legacy collection list for project_deps.json.
   async getProjectManifest(externalId) {
     return this.request(`/api/pb/projects/${encodeURIComponent(externalId)}/manifest`);
   }

package/dist/chunk-P5HFNAVN.js

@@ -0,0 +1,280 @@
+import {
+  loadEnv
+} from "./chunk-2CR762KB.js";
+import {
+  createApiClient
+} from "./chunk-JKXLKK5I.js";
+import {
+  findProjectRoot,
+  getAppName
+} from "./chunk-ZH3NVYEQ.js";
+
+// src/commands/deps.ts
+import pc from "picocolors";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "fs";
+import { join } from "path";
+var LEGACY_DEPS_FILE = "platform/project_deps.json";
+var SHARED_COLLECTIONS_DIR = "platform/collections/shared";
+function loadLegacyDeps(projectRoot) {
+  const depsPath = join(projectRoot, LEGACY_DEPS_FILE);
+  if (!existsSync(depsPath)) return null;
+  try {
+    return JSON.parse(readFileSync(depsPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function sharedCollectionsDir(projectRoot) {
+  return join(projectRoot, SHARED_COLLECTIONS_DIR);
+}
+function safeShareFilenamePart(value) {
+  return value.trim().replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "") || "unknown";
+}
+function shareCollectionName(share) {
+  return share.object_name || share.object_display_name || share.object_id;
+}
+function shareFileName(share) {
+  const source = safeShareFilenamePart(share.source_project.external_id || share.source_project.name || "source");
+  const collection = safeShareFilenamePart(shareCollectionName(share));
+  return `${source}__${collection}.json`;
+}
+function readSharedCollectionFile(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function loadSharedCollectionDeps(projectRoot) {
+  const dir = sharedCollectionsDir(projectRoot);
+  if (!existsSync(dir)) return [];
+  const deps2 = [];
+  for (const entry of readdirSync(dir)) {
+    if (!entry.endsWith(".json")) continue;
+    const filePath = join(dir, entry);
+    const dep = readSharedCollectionFile(filePath);
+    if (dep) deps2.push({ file: entry, dep });
+  }
+  return deps2.sort((a, b) => a.file.localeCompare(b.file));
+}
+async function projectPermissionsModeEnabled(api) {
+  try {
+    return await api.isProjectPermissionsModeEnabled();
+  } catch {
+    return false;
+  }
+}
+function declarationForShare(share, existing) {
+  return {
+    ...existing ?? {},
+    source_project: share.source_project.external_id,
+    collection: shareCollectionName(share),
+    privilege: share.privilege,
+    reason: typeof existing?.reason === "string" ? existing.reason : ""
+  };
+}
+async function listIncomingCollectionShares(api, projectExternalId) {
+  const result = await api.listProjectResourceShares(projectExternalId, "incoming");
+  return (result.shares ?? []).filter((share) => share.object_type === "collection").sort((a, b) => {
+    const bySource = a.source_project.external_id.localeCompare(b.source_project.external_id);
+    if (bySource !== 0) return bySource;
+    return shareCollectionName(a).localeCompare(shareCollectionName(b));
+  });
+}
+async function syncResourceShareDeps(projectRoot, api, projectExternalId, opts) {
+  let shares;
+  try {
+    shares = await listIncomingCollectionShares(api, projectExternalId);
+  } catch (e) {
+    if (!opts.quiet) {
+      console.log(pc.red("  \u2717"), `Failed to list incoming resource shares \u2014 ${e}`);
+    }
+    return false;
+  }
+  if (shares.length === 0) {
+    if (!opts.quiet) console.log(pc.dim("  No incoming resource shares."));
+    return true;
+  }
+  const dir = sharedCollectionsDir(projectRoot);
+  const missing = [];
+  if (opts.write) {
+    mkdirSync(dir, { recursive: true });
+  }
+  for (const share of shares) {
+    const fileName = shareFileName(share);
+    const filePath = join(dir, fileName);
+    const exists = existsSync(filePath);
+    if (!opts.write) {
+      if (!exists) missing.push(fileName);
+      continue;
+    }
+    const existing = exists ? readSharedCollectionFile(filePath) ?? void 0 : void 0;
+    const declaration = declarationForShare(share, existing);
+    writeFileSync(filePath, JSON.stringify(declaration, null, 2) + "\n");
+    if (!opts.quiet) {
+      const action = exists ? pc.yellow("\u21BB") : pc.green("+");
+      console.log(`  ${action} collections/shared/${fileName}`);
+    }
+  }
+  if (!opts.write && missing.length > 0) {
+    if (!opts.quiet) {
+      console.log(pc.yellow(`  \u26A0 ${missing.length} incoming resource share${missing.length === 1 ? "" : "s"} not synced locally.`));
+      for (const file of missing) console.log(pc.dim(`    collections/shared/${file}`));
+      console.log(pc.dim(`  Run ${pc.cyan("lumera deps sync")} to write shared resource declarations.`));
+    }
+    return false;
+  }
+  if (!opts.quiet && !opts.write) {
+    console.log(pc.green("  \u2713"), "Incoming resource shares are synced locally.");
+  }
+  return true;
+}
+async function syncLegacyDeps(projectRoot, api, quiet = false) {
+  const deps2 = loadLegacyDeps(projectRoot);
+  if (!deps2 || !deps2.dependencies || Object.keys(deps2.dependencies).length === 0) {
+    return true;
+  }
+  let allOk = true;
+  for (const [depProject, config] of Object.entries(deps2.dependencies)) {
+    try {
+      const manifest = await api.getProjectManifest(depProject);
+      const remoteNames = new Set(manifest.collections.map((c) => c.name));
+      for (const col of config.collections) {
+        if (remoteNames.has(col)) {
+          if (!quiet) console.log(pc.green("  \u2713"), `${depProject}/${col}`);
+        } else {
+          if (!quiet) console.log(pc.red("  \u2717"), `${depProject}/${col} \u2014 not found in project manifest`);
+          allOk = false;
+        }
+      }
+    } catch (e) {
+      if (!quiet) console.log(pc.red("  \u2717"), `${depProject}: failed to fetch manifest \u2014 ${e}`);
+      allOk = false;
+    }
+  }
+  return allOk;
+}
+async function projectResourceDepsEnabled(projectRoot) {
+  const root = projectRoot ?? findProjectRoot();
+  loadEnv(root);
+  const appName = getAppName(root);
+  const api = createApiClient(void 0, void 0, appName);
+  return projectPermissionsModeEnabled(api);
+}
+async function syncDeps(projectRoot, options = {}) {
+  const root = projectRoot ?? findProjectRoot();
+  loadEnv(root);
+  const appName = getAppName(root);
+  const api = createApiClient(void 0, void 0, appName);
+  const flagOn = await projectPermissionsModeEnabled(api);
+  const quiet = options.quiet === true;
+  const write = options.write === true;
+  if (flagOn) {
+    return syncResourceShareDeps(root, api, appName, { write, quiet });
+  }
+  if (options.legacyWhenDisabled === false) {
+    return true;
+  }
+  return syncLegacyDeps(root, api, quiet);
+}
+async function deps(args) {
+  const sub = args[0];
+  const projectRoot = findProjectRoot();
+  loadEnv(projectRoot);
+  let cachedFlagOn;
+  async function flagOn() {
+    if (cachedFlagOn !== void 0) return cachedFlagOn;
+    cachedFlagOn = await projectResourceDepsEnabled(projectRoot);
+    return cachedFlagOn;
+  }
+  if (sub === "sync") {
+    const enabled = await flagOn();
+    console.log();
+    console.log(pc.cyan(pc.bold("  Deps Sync")));
+    console.log(pc.dim(enabled ? "  Syncing incoming resource shares into platform/collections/shared..." : "  Verifying legacy cross-project dependencies..."));
+    console.log();
+    const ok = await syncDeps(projectRoot, { write: enabled });
+    if (!ok) {
+      console.log();
+      console.log(pc.red(enabled ? "  Some resource-share dependencies could not be synced." : "  Some dependencies could not be resolved."));
+      process.exit(1);
+    }
+    console.log();
+    console.log(pc.green(enabled ? "  Resource shares synced." : "  All dependencies verified."));
+    return;
+  }
+  if (sub === "list") {
+    if (await flagOn()) {
+      const sharedDeps = loadSharedCollectionDeps(projectRoot);
+      if (sharedDeps.length === 0) {
+        console.log(pc.dim("  No shared collection declarations in platform/collections/shared"));
+        return;
+      }
+      console.log();
+      console.log(pc.cyan(pc.bold("  Shared Collection Dependencies")));
+      console.log();
+      for (const { file, dep } of sharedDeps) {
+        const source = dep.source_project ?? "unknown-source";
+        const collection = dep.collection ?? "unknown-table";
+        const privilege = dep.privilege ?? "collection.read";
+        console.log(`  ${pc.bold(file)}`);
+        console.log(`    ${source}/${collection} ${pc.dim(`(${privilege})`)}`);
+      }
+      console.log();
+      return;
+    }
+    const depsData = loadLegacyDeps(projectRoot);
+    if (!depsData || Object.keys(depsData.dependencies).length === 0) {
+      console.log(pc.dim("  No dependencies declared in platform/project_deps.json"));
+      return;
+    }
+    console.log();
+    console.log(pc.cyan(pc.bold("  Project Dependencies")));
+    console.log();
+    for (const [depProject, config] of Object.entries(depsData.dependencies)) {
+      console.log(`  ${pc.bold(depProject)}`);
+      for (const col of config.collections) {
+        console.log(`    \u2022 ${col}`);
+      }
+    }
+    console.log();
+    return;
+  }
+  if (sub === "init") {
+    if (await flagOn()) {
+      const dir = sharedCollectionsDir(projectRoot);
+      mkdirSync(dir, { recursive: true });
+      console.log(pc.green("  \u2713"), "Created platform/collections/shared/");
+      return;
+    }
+    const depsPath = join(projectRoot, LEGACY_DEPS_FILE);
+    if (existsSync(depsPath)) {
+      console.log(pc.yellow("  platform/project_deps.json already exists."));
+      return;
+    }
+    const platformDir = join(projectRoot, "platform");
+    mkdirSync(platformDir, { recursive: true });
+    const initial = { dependencies: {} };
+    writeFileSync(depsPath, JSON.stringify(initial, null, 2) + "\n");
+    console.log(pc.green("  \u2713"), "Created platform/project_deps.json");
+    return;
+  }
+  console.log(`
+  ${pc.bold("lumera deps")} \u2014 manage cross-project dependencies
+
+  ${pc.bold("Commands:")}
+    sync    Sync dependencies. With project permissions on, writes incoming
+            resource shares to platform/collections/shared/*.json
+    list    Show declared dependencies
+    init    Create dependency storage for the current feature mode
+
+  ${pc.bold("Project permissions mode:")} platform/collections/shared/*.json
+  ${pc.bold("Legacy mode:")}              platform/project_deps.json
+  `);
+}
+
+export {
+  projectResourceDepsEnabled,
+  syncDeps,
+  deps
+};

package/dist/{chunk-53NOF33P.js → chunk-SU26C4GL.js}

@@ -137,59 +137,19 @@ function isPortInUse(port, host = "127.0.0.1") {
     });
   });
 }
-function commandAvailable(command) {
-  try {
-    execSync(`${command} --version`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function parsePackageManagerSpecifier(value) {
-  const raw = (value || "").trim();
-  if (!raw) return void 0;
-  const name = raw.split("@")[0];
-  return ["bun", "pnpm", "yarn", "npm"].includes(name) ? name : void 0;
-}
-function packageManagerFromPackageJson(projectRoot) {
-  try {
-    const pkg = JSON.parse(readFileSync(resolve(projectRoot, "package.json"), "utf-8"));
-    return parsePackageManagerSpecifier(pkg.packageManager);
-  } catch {
-    return void 0;
-  }
-}
-function runnerForPackageManager(pm) {
-  if (pm === "pnpm") return ["pnpm", "exec"];
-  if (pm === "bun") return ["bunx"];
-  if (pm === "yarn") return ["yarn"];
-  return ["npx"];
-}
 function detectRunner(projectRoot) {
-  const requested = parsePackageManagerSpecifier(process.env.LUMERA_PACKAGE_MANAGER);
-  if (requested && commandAvailable(runnerForPackageManager(requested)[0])) {
-    return runnerForPackageManager(requested);
+  if (existsSync(resolve(projectRoot, "bun.lockb")) || existsSync(resolve(projectRoot, "bun.lock"))) {
+    return ["bunx"];
   }
-  const declared = packageManagerFromPackageJson(projectRoot);
-  if (declared && commandAvailable(runnerForPackageManager(declared)[0])) {
-    return runnerForPackageManager(declared);
+  if (existsSync(resolve(projectRoot, "pnpm-lock.yaml"))) {
+    return ["pnpm", "exec"];
   }
-  const lockfileManagers = [
-    { pm: "pnpm", file: "pnpm-lock.yaml" },
-    { pm: "bun", file: "bun.lockb" },
-    { pm: "bun", file: "bun.lock" },
-    { pm: "yarn", file: "yarn.lock" },
-    { pm: "npm", file: "package-lock.json" }
-  ];
-  for (const { pm, file } of lockfileManagers) {
-    const runner = runnerForPackageManager(pm);
-    if (existsSync(resolve(projectRoot, file)) && commandAvailable(runner[0])) return runner;
-  }
-  for (const pm of ["pnpm", "bun", "yarn", "npm"]) {
-    const runner = runnerForPackageManager(pm);
-    if (commandAvailable(runner[0])) return runner;
+  try {
+    execSync("pnpm --version", { stdio: "ignore" });
+    return ["pnpm", "exec"];
+  } catch {
+    return ["bunx"];
   }
-  return ["npx"];
 }
 function getParentOrigin(apiUrl) {
   return apiUrl.replace(/\/api\/?$/, "").replace(/\/$/, "");

package/dist/{deps-ULTIIDYK.js → deps-EC3VRNN7.js}

@@ -1,13 +1,15 @@
 import {
   deps,
+  projectResourceDepsEnabled,
   syncDeps
-} from "./chunk-XDTWVFPE.js";
+} from "./chunk-P5HFNAVN.js";
 import "./chunk-2CR762KB.js";
-import "./chunk-GKI2HQJC.js";
+import "./chunk-JKXLKK5I.js";
 import "./chunk-ZH3NVYEQ.js";
 import "./chunk-FJFIWC7G.js";
 import "./chunk-PNKVD2UK.js";
 export {
   deps,
+  projectResourceDepsEnabled,
   syncDeps
 };

package/dist/{dev-5JMHMS4U.js → dev-R43VQCZD.js}

@@ -1,12 +1,16 @@
 import {
   dev
-} from "./chunk-53NOF33P.js";
+} from "./chunk-SU26C4GL.js";
+import {
+  projectResourceDepsEnabled,
+  syncDeps
+} from "./chunk-P5HFNAVN.js";
 import {
   loadEnv
 } from "./chunk-2CR762KB.js";
 import {
   createApiClient
-} from "./chunk-GKI2HQJC.js";
+} from "./chunk-JKXLKK5I.js";
 import {
   findProjectRoot,
   getApiUrl,
@@ -121,6 +125,9 @@ async function dev2(args) {
   const appName = getAppName(projectRoot);
   const appTitle = getAppTitle(projectRoot);
   const apiUrl = getApiUrl();
+  if (await projectResourceDepsEnabled(projectRoot)) {
+    await syncDeps(projectRoot, { write: true, quiet: true, legacyWhenDisabled: false });
+  }
   if (!flags["skip-setup"]) {
     const fresh = await isFreshProject(projectRoot);
     if (fresh) {

package/dist/index.js

@@ -219,42 +219,42 @@ async function main() {
     switch (command) {
       // Resource commands
       case "plan":
-        await import("./resources-4IUZYKGX.js").then((m) => m.plan(args.slice(1)));
+        await import("./resources-OP7EECKZ.js").then((m) => m.plan(args.slice(1)));
         break;
       case "apply":
-        await import("./resources-4IUZYKGX.js").then((m) => m.apply(args.slice(1)));
+        await import("./resources-OP7EECKZ.js").then((m) => m.apply(args.slice(1)));
         break;
       case "pull":
-        await import("./resources-4IUZYKGX.js").then((m) => m.pull(args.slice(1)));
+        await import("./resources-OP7EECKZ.js").then((m) => m.pull(args.slice(1)));
         break;
       case "destroy":
-        await import("./resources-4IUZYKGX.js").then((m) => m.destroy(args.slice(1)));
+        await import("./resources-OP7EECKZ.js").then((m) => m.destroy(args.slice(1)));
         break;
       case "list":
-        await import("./resources-4IUZYKGX.js").then((m) => m.list(args.slice(1)));
+        await import("./resources-OP7EECKZ.js").then((m) => m.list(args.slice(1)));
         break;
       case "show":
-        await import("./resources-4IUZYKGX.js").then((m) => m.show(args.slice(1)));
+        await import("./resources-OP7EECKZ.js").then((m) => m.show(args.slice(1)));
         break;
       case "diff":
-        await import("./resources-4IUZYKGX.js").then((m) => m.diff(args.slice(1)));
+        await import("./resources-OP7EECKZ.js").then((m) => m.diff(args.slice(1)));
         break;
       // Development
       case "dev":
-        await import("./dev-5JMHMS4U.js").then((m) => m.dev(args.slice(1)));
+        await import("./dev-R43VQCZD.js").then((m) => m.dev(args.slice(1)));
         break;
       case "run":
-        await import("./run-5ZOSPBGO.js").then((m) => m.run(args.slice(1)));
+        await import("./run-EJP5WCQU.js").then((m) => m.run(args.slice(1)));
         break;
       // Project
       case "init":
-        await import("./init-37XOMJLU.js").then((m) => m.init(args.slice(1)));
+        await import("./init-TDIQAOG4.js").then((m) => m.init(args.slice(1)));
         break;
       case "register":
-        await import("./register-JJUMS4FI.js").then((m) => m.register(args.slice(1)));
+        await import("./register-JFJADKAJ.js").then((m) => m.register(args.slice(1)));
         break;
       case "templates":
-        await import("./templates-M3RDNDDY.js").then((m) => m.templates(subcommand, args.slice(2)));
+        await import("./templates-LNUOTNLN.js").then((m) => m.templates(subcommand, args.slice(2)));
         break;
       case "status":
         await import("./status-X7WQYX2L.js").then((m) => m.status(args.slice(1)));
@@ -268,7 +268,7 @@ async function main() {
         break;
       // Dependencies
       case "deps":
-        await import("./deps-ULTIIDYK.js").then((m) => m.deps(args.slice(1)));
+        await import("./deps-EC3VRNN7.js").then((m) => m.deps(args.slice(1)));
         break;
       // Auth
       case "login":