@lumerahq/cli 0.7.0

package/README.md

@@ -0,0 +1,118 @@
+# @lumerahq/cli
+
+CLI for building and deploying Lumera apps.
+
+## Installation
+
+```bash
+npm install -g @lumerahq/cli
+# or use directly with npx/pnpm dlx
+pnpm dlx @lumerahq/cli init my-app
+```
+
+## Commands
+
+```bash
+lumera init [name]         # Scaffold a new Lumera app
+lumera login               # Authenticate with Lumera
+lumera logout              # Clear stored credentials
+lumera whoami              # Show current user
+lumera status              # Show project info
+
+lumera app dev             # Start dev server
+lumera app deploy          # Deploy frontend to S3
+lumera app destroy         # Delete app from Lumera
+
+lumera platform plan       # Preview infrastructure changes
+lumera platform apply      # Apply collections, automations, hooks
+lumera platform pull       # Pull remote state to local
+lumera platform destroy    # Delete remote resources
+
+lumera run <script>        # Run Python scripts locally
+```
+
+## Scaffolding Projects
+
+### Interactive Mode
+
+```bash
+lumera init                # Prompts for project name and directory
+lumera init my-app         # Prompts for directory only
+```
+
+### Non-Interactive Mode
+
+For CI/CD or scripted environments, use `-y` (or `--yes`) flag:
+
+```bash
+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
+```
+
+### Init Options
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--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 |
+| `--help` | `-h` | Show help |
+
+### CI/CD Example
+
+```bash
+# Full non-interactive setup
+lumera init my-app -y -f -i
+```
+
+## Authentication
+
+### Interactive Login
+
+```bash
+lumera login
+```
+
+Opens a browser for OAuth authentication. Credentials are stored locally.
+
+### CI/CD Usage
+
+For automated environments, use the `LUMERA_TOKEN` environment variable:
+
+```bash
+export LUMERA_TOKEN=your_api_token
+lumera app deploy
+```
+
+The CLI checks for credentials in this order:
+1. `LUMERA_TOKEN` environment variable
+2. Project-local credentials (`.lumera/credentials.json`)
+3. Global credentials (`~/.config/lumera/credentials.json`)
+
+## Security
+
+### Credential Storage
+
+- **Never commit credentials**: The `.lumera/` directory is gitignored by default in scaffolded projects
+- **Token scope**: Use tokens with minimal required permissions for CI/CD
+- **Rotation**: Rotate tokens periodically, especially after team member offboarding
+
+### Environment Variables
+
+- `LUMERA_TOKEN` - API token for authentication (recommended for CI/CD)
+- `LUMERA_BASE_URL` - Override base URL (defaults to `https://app.lumerahq.com`)
+- `LUMERA_API_URL` - Override API URL (defaults to `https://app.lumerahq.com/api`)
+
+### Best Practices
+
+1. Use `lumera login` for local development (stores credentials securely)
+2. Use `LUMERA_TOKEN` for CI/CD pipelines
+3. Never hardcode tokens in scripts or config files
+4. Keep `.lumera/` in `.gitignore` to prevent accidental credential commits
+
+## License
+
+MIT

package/dist/auth-7RGL7GXU.js

@@ -0,0 +1,311 @@
+import {
+  getCredentials,
+  getTokenSource
+} from "./chunk-NDLYGKS6.js";
+import {
+  getBaseUrl
+} from "./chunk-D2BLSEGR.js";
+
+// src/commands/auth.ts
+import pc from "picocolors";
+import { createServer } from "http";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import open from "open";
+import crypto from "crypto";
+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 isLumeraProject() {
+  const cwd = process.cwd();
+  const hasPackageJson = existsSync(join(cwd, "package.json"));
+  const hasPlatformDir = existsSync(join(cwd, "platform"));
+  return hasPackageJson && hasPlatformDir;
+}
+async function findAvailablePort(startPort) {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        resolve(findAvailablePort(startPort + 1));
+      } else {
+        reject(err);
+      }
+    });
+    server.once("listening", () => {
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : startPort;
+      server.close(() => resolve(port));
+    });
+    server.listen(startPort, "127.0.0.1");
+  });
+}
+async function fetchUserInfo(token) {
+  const baseUrl = getBaseUrl();
+  try {
+    const response = await fetch(`${baseUrl}/api/me`, {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch user info: ${response.status}`);
+    }
+    const data = await response.json();
+    const user = data.user || {};
+    return {
+      email: user.email || "unknown",
+      company: user.company?.name || user.company_name || "unknown"
+    };
+  } catch {
+    return { email: "unknown", company: "unknown" };
+  }
+}
+function showLoginHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera login [options]
+
+${pc.dim("Description:")}
+  Login to Lumera via browser-based authentication.
+  By default, credentials are stored in the current project.
+
+${pc.dim("Options:")}
+  --global, -g           Store credentials globally (~/.config/lumera/)
+  --help, -h             Show this help
+
+${pc.dim("Token storage:")}
+  Project: .lumera/credentials.json (default, requires platform/ directory)
+  Global:  ~/.config/lumera/credentials.json (with --global)
+`);
+}
+async function login(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    showLoginHelp();
+    return;
+  }
+  const isGlobal = args.includes("--global") || args.includes("-g");
+  if (!isGlobal && !isLumeraProject()) {
+    console.log();
+    console.log(pc.red("  \u2717 Not in a Lumera project directory"));
+    console.log(pc.dim("    Expected package.json and platform/ directory."));
+    console.log();
+    console.log(pc.dim("  Options:"));
+    console.log(pc.dim("    \u2022 Run from a Lumera project directory"));
+    console.log(pc.dim("    \u2022 Use --global to store credentials globally"));
+    console.log();
+    process.exit(1);
+  }
+  console.log();
+  console.log(pc.cyan(pc.bold("  Lumera Login")));
+  console.log();
+  const port = await findAvailablePort(9876);
+  const state = crypto.randomUUID();
+  const baseUrl = getBaseUrl();
+  let resolveLogin;
+  let rejectLogin;
+  const loginPromise = new Promise((resolve, reject) => {
+    resolveLogin = resolve;
+    rejectLogin = reject;
+  });
+  const server = createServer((req, res) => {
+    const reqUrl = new URL(req.url, `http://127.0.0.1:${port}`);
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (reqUrl.pathname === "/callback") {
+      const token = reqUrl.searchParams.get("token");
+      const returnedState = reqUrl.searchParams.get("state");
+      const error = reqUrl.searchParams.get("error");
+      if (error) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
+              <div style="text-align: center;">
+                <h1 style="color: #dc2626;">Login Failed</h1>
+                <p>${error}</p>
+                <p style="color: #6b7280;">You can close this tab.</p>
+              </div>
+            </body>
+          </html>
+        `);
+        rejectLogin(new Error(error));
+        return;
+      }
+      if (!token || !returnedState) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
+              <div style="text-align: center;">
+                <h1 style="color: #dc2626;">Invalid Callback</h1>
+                <p>Missing token or state parameter.</p>
+                <p style="color: #6b7280;">You can close this tab.</p>
+              </div>
+            </body>
+          </html>
+        `);
+        rejectLogin(new Error("Invalid callback - missing token or state"));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(`
+        <html>
+          <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
+            <div style="text-align: center;">
+              <h1 style="color: #16a34a;">Login Successful!</h1>
+              <p style="color: #6b7280;">You can close this tab and return to the terminal.</p>
+            </div>
+          </body>
+        </html>
+      `);
+      resolveLogin({ token, state: returnedState });
+    } else {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  server.listen(port, "127.0.0.1");
+  const authUrl = `${baseUrl}/cli/auth?callback=http://127.0.0.1:${port}/callback&state=${state}`;
+  console.log(pc.dim(`  Opening browser to ${baseUrl}/cli/auth...`));
+  console.log();
+  try {
+    await open(authUrl);
+  } catch {
+    console.log(pc.yellow("  Could not open browser automatically."));
+    console.log(pc.dim("  Please open this URL manually:"));
+    console.log();
+    console.log(pc.cyan(`  ${authUrl}`));
+    console.log();
+  }
+  console.log(pc.dim("  Waiting for authentication..."));
+  console.log();
+  const timeout = setTimeout(() => {
+    server.close();
+    rejectLogin(new Error("Login timed out after 5 minutes"));
+  }, 5 * 60 * 1e3);
+  try {
+    const result = await loginPromise;
+    clearTimeout(timeout);
+    server.close();
+    if (result.state !== state) {
+      console.log(pc.red("  \u2717 Invalid state - possible CSRF attack"));
+      process.exit(1);
+    }
+    const userInfo = await fetchUserInfo(result.token);
+    const credentials = {
+      token: result.token,
+      user: userInfo.email,
+      company: userInfo.company,
+      created: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (isGlobal) {
+      mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+      writeFileSync(GLOBAL_CREDS_PATH, JSON.stringify(credentials, null, 2));
+      console.log(pc.green("  \u2713"), `Logged in as ${pc.bold(userInfo.email)} (${userInfo.company})`);
+      console.log(pc.dim(`    Token saved to ~/.config/lumera/credentials.json`));
+    } else {
+      const localDir = join(process.cwd(), ".lumera");
+      mkdirSync(localDir, { recursive: true });
+      writeFileSync(getLocalCredsPath(), JSON.stringify(credentials, null, 2));
+      console.log(pc.green("  \u2713"), `Logged in as ${pc.bold(userInfo.email)} (${userInfo.company})`);
+      console.log(pc.dim(`    Token saved to .lumera/credentials.json`));
+    }
+    console.log();
+  } catch (error) {
+    clearTimeout(timeout);
+    server.close();
+    if (error instanceof Error) {
+      console.log(pc.red(`  \u2717 ${error.message}`));
+    } else {
+      console.log(pc.red("  \u2717 Login failed"));
+    }
+    process.exit(1);
+  }
+}
+function showLogoutHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera logout [options]
+
+${pc.dim("Description:")}
+  Clear stored Lumera credentials.
+  By default, removes project-local credentials.
+
+${pc.dim("Options:")}
+  --global, -g           Remove global credentials
+  --help, -h             Show this help
+`);
+}
+async function logout(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    showLogoutHelp();
+    return;
+  }
+  const isGlobal = args.includes("--global") || args.includes("-g");
+  console.log();
+  if (isGlobal) {
+    if (existsSync(GLOBAL_CREDS_PATH)) {
+      rmSync(GLOBAL_CREDS_PATH);
+      console.log(pc.green("  \u2713"), "Logged out");
+      console.log(pc.dim(`    Deleted ~/.config/lumera/credentials.json`));
+    } else {
+      console.log(pc.yellow("  \u26A0"), "No global credentials found");
+    }
+  } else {
+    const localPath = getLocalCredsPath();
+    if (existsSync(localPath)) {
+      rmSync(localPath);
+      console.log(pc.green("  \u2713"), "Removed project credentials");
+      console.log(pc.dim(`    Deleted .lumera/credentials.json`));
+    } else {
+      console.log(pc.yellow("  \u26A0"), "No project credentials found");
+    }
+  }
+  console.log();
+}
+async function whoami() {
+  console.log();
+  if (process.env.LUMERA_TOKEN) {
+    const userInfo = await fetchUserInfo(process.env.LUMERA_TOKEN);
+    console.log(`  ${pc.dim("User:")}    ${pc.bold(userInfo.email)}`);
+    console.log(`  ${pc.dim("Company:")} ${userInfo.company}`);
+    console.log(`  ${pc.dim("Source:")}  environment (LUMERA_TOKEN)`);
+    console.log();
+    return;
+  }
+  const credentials = getCredentials();
+  const source = getTokenSource();
+  if (!credentials) {
+    console.log(pc.yellow("  Not logged in"));
+    console.log();
+    console.log(pc.dim("  Run `lumera login` to authenticate."));
+    console.log();
+    return;
+  }
+  let email = credentials.user || "unknown";
+  let company = credentials.company || "unknown";
+  if (email === "unknown" || company === "unknown") {
+    const userInfo = await fetchUserInfo(credentials.token);
+    email = userInfo.email;
+    company = userInfo.company;
+  }
+  console.log(`  ${pc.dim("User:")}    ${pc.bold(email)}`);
+  console.log(`  ${pc.dim("Company:")} ${company}`);
+  console.log(`  ${pc.dim("Source:")}  ${source}`);
+  console.log();
+}
+export {
+  login,
+  logout,
+  whoami
+};

package/dist/chunk-2CR762KB.js

@@ -0,0 +1,18 @@
+// 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 {
+  loadEnv
+};

package/dist/chunk-AVKPM7C4.js

@@ -0,0 +1,199 @@
+// src/lib/deploy.ts
+import { execSync, spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { resolve, dirname } from "path";
+import archiver from "archiver";
+import pc from "picocolors";
+function formatTimestampVersion(date = /* @__PURE__ */ new Date()) {
+  const pad = (value) => String(value).padStart(2, "0");
+  return [
+    date.getUTCFullYear(),
+    pad(date.getUTCMonth() + 1),
+    pad(date.getUTCDate())
+  ].join("") + "T" + [
+    pad(date.getUTCHours()),
+    pad(date.getUTCMinutes()),
+    pad(date.getUTCSeconds())
+  ].join("") + "Z";
+}
+function resolveVersion(cwd) {
+  const pkgPath = resolve(cwd, "package.json");
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    if (pkg?.version && pkg.version !== "0.0.0") return String(pkg.version);
+  } catch {
+  }
+  try {
+    const sha = execSync("git rev-parse --short HEAD", {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    if (sha) return sha;
+  } catch {
+  }
+  return formatTimestampVersion();
+}
+async function createTarball(distDir) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    const archive = archiver("tar", { gzip: true });
+    archive.on("data", (chunk) => chunks.push(chunk));
+    archive.on("end", () => resolve2(Buffer.concat(chunks)));
+    archive.on("error", reject);
+    archive.directory(distDir, false);
+    archive.finalize();
+  });
+}
+async function ensureAppRecord(apiBase, token, appName, appTitle) {
+  const filterParam = encodeURIComponent(JSON.stringify({ external_id: appName }));
+  const searchRes = await fetch(
+    `${apiBase}/pb/collections/lm_custom_apps/records?filter=${filterParam}`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  );
+  if (!searchRes.ok) {
+    throw new Error(`Failed to check app record: ${await searchRes.text()}`);
+  }
+  const existing = (await searchRes.json()).items?.[0];
+  const appData = {
+    external_id: appName,
+    name: appTitle,
+    hosting_type: "s3"
+  };
+  const endpoint = existing ? `${apiBase}/pb/collections/lm_custom_apps/records/${existing.id}` : `${apiBase}/pb/collections/lm_custom_apps/records`;
+  const res = await fetch(endpoint, {
+    method: existing ? "PATCH" : "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(appData)
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to register app: ${await res.text()}`);
+  }
+}
+async function deploy(options) {
+  const {
+    token,
+    appName,
+    appTitle,
+    distDir,
+    apiUrl
+  } = options;
+  if (!existsSync(distDir)) {
+    throw new Error(`dist directory not found: ${distDir}`);
+  }
+  console.log(pc.dim("Ensuring app record..."));
+  await ensureAppRecord(apiUrl, token, appName, appTitle);
+  console.log(pc.cyan(`Deploying ${appTitle}...`));
+  const version = options.version || resolveVersion(dirname(distDir));
+  console.log(pc.dim(`Version: ${version}`));
+  const tarball = await createTarball(distDir);
+  console.log(pc.dim(`Package: ${(tarball.length / 1024).toFixed(1)} KB`));
+  const formData = new FormData();
+  formData.append("tarball", new Blob([new Uint8Array(tarball)]), "dist.tar.gz");
+  formData.append("version", version);
+  const res = await fetch(`${apiUrl}/custom-apps/${appName}/deploy`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}` },
+    body: formData
+  });
+  if (!res.ok) {
+    throw new Error(`Deploy failed: ${await res.text()}`);
+  }
+  const result = await res.json();
+  console.log(pc.green(`
+Deployed! ${result.url}`));
+  return { url: result.url, version };
+}
+async function registerDevApp(apiBase, token, appName, appTitle, appUrl) {
+  const filterParam = encodeURIComponent(JSON.stringify({ external_id: appName }));
+  const searchRes = await fetch(
+    `${apiBase}/pb/collections/lm_custom_apps/records?filter=${filterParam}`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  );
+  if (!searchRes.ok) {
+    throw new Error(`Failed to check app record: ${await searchRes.text()}`);
+  }
+  const existing = (await searchRes.json()).items?.[0];
+  const appData = {
+    dev_iframe_url: appUrl
+  };
+  if (!existing) {
+    appData.external_id = appName;
+    appData.name = appTitle;
+  }
+  const endpoint = existing ? `${apiBase}/pb/collections/lm_custom_apps/records/${existing.id}` : `${apiBase}/pb/collections/lm_custom_apps/records`;
+  const res = await fetch(endpoint, {
+    method: existing ? "PATCH" : "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(appData)
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to register app: ${await res.text()}`);
+  }
+}
+async function dev(options) {
+  const {
+    token,
+    appName,
+    appTitle,
+    port,
+    appUrl = `http://localhost:${port}`,
+    apiUrl
+  } = options;
+  console.log();
+  console.log(pc.cyan(pc.bold(`  ${appTitle} - Dev Server`)));
+  console.log();
+  console.log(pc.dim("  Configuration:"));
+  console.log(pc.dim(`    Port: ${port}`));
+  console.log(pc.dim(`    URL:  ${appUrl}`));
+  console.log();
+  console.log(pc.dim("  Registering app with Lumera..."));
+  try {
+    await registerDevApp(apiUrl, token, appName, appTitle, appUrl);
+    console.log(pc.green("  \u2713 App registered"));
+  } catch (err) {
+    console.log(pc.yellow("  \u26A0 Failed to register app (continuing anyway)"));
+    if (err instanceof Error) {
+      console.log(pc.dim(`    ${err.message}`));
+    }
+  }
+  console.log();
+  console.log(pc.green("  Starting dev server..."));
+  console.log();
+  console.log(pc.cyan(pc.bold("  Open in Lumera (dev mode):")));
+  console.log(pc.cyan(`  https://app.lumerahq.com/custom-apps/${appName}?dev`));
+  console.log();
+  const safeEnvPrefixes = ["VITE_", "LUMERA_", "NODE_", "npm_"];
+  const safeEnvKeys = ["PATH", "HOME", "USER", "SHELL", "TERM", "LANG", "LC_ALL", "TMPDIR", "TZ"];
+  const filteredEnv = Object.fromEntries(
+    Object.entries(process.env).filter(
+      ([key]) => safeEnvPrefixes.some((prefix) => key.startsWith(prefix)) || safeEnvKeys.includes(key)
+    )
+  );
+  const vite = spawn("pnpm", ["exec", "vite", "--port", String(port)], {
+    stdio: "inherit",
+    env: {
+      ...filteredEnv,
+      VITE_PARENT_ORIGIN: "https://app.lumerahq.com"
+    }
+  });
+  setTimeout(() => {
+    console.log();
+    console.log(pc.cyan(pc.bold(`  \u279C  Lumera:  https://app.lumerahq.com/custom-apps/${appName}?dev`)));
+  }, 2e3);
+  vite.on("close", (code) => {
+    process.exit(code || 0);
+  });
+  process.on("SIGINT", () => vite.kill("SIGINT"));
+  process.on("SIGTERM", () => vite.kill("SIGTERM"));
+}
+
+export {
+  deploy,
+  dev
+};

package/dist/chunk-D2BLSEGR.js

@@ -0,0 +1,59 @@
+// src/lib/config.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve, join } from "path";
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = startDir;
+  while (dir !== "/") {
+    if (existsSync(join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = resolve(dir, "..");
+  }
+  throw new Error("Could not find project root (no package.json found)");
+}
+function readPackageJson(projectRoot) {
+  const pkgPath = join(projectRoot, "package.json");
+  if (!existsSync(pkgPath)) {
+    throw new Error(`package.json not found at ${pkgPath}`);
+  }
+  return JSON.parse(readFileSync(pkgPath, "utf-8"));
+}
+function getAppName(projectRoot) {
+  const pkg = readPackageJson(projectRoot);
+  return pkg.name;
+}
+function getAppTitle(projectRoot) {
+  const pkg = readPackageJson(projectRoot);
+  return pkg.lumera?.name || pkg.name;
+}
+function detectProjectVersion(projectRoot) {
+  const pkg = readPackageJson(projectRoot);
+  if (pkg.lumera?.version !== void 0) {
+    return pkg.lumera.version;
+  }
+  if (existsSync(join(projectRoot, "lumera_platform"))) {
+    return 0;
+  }
+  if (existsSync(join(projectRoot, "platform"))) {
+    return 1;
+  }
+  return 1;
+}
+function getBaseUrl() {
+  let base = process.env.LUMERA_BASE_URL || process.env.LUMERA_API_URL || "https://app.lumerahq.com";
+  base = base.replace(/\/api\/?$/, "").replace(/\/$/, "");
+  return base;
+}
+function getApiUrl() {
+  return `${getBaseUrl()}/api`;
+}
+
+export {
+  findProjectRoot,
+  readPackageJson,
+  getAppName,
+  getAppTitle,
+  detectProjectVersion,
+  getBaseUrl,
+  getApiUrl
+};