@lumerahq/cli 0.33.1 → 0.34.2

package/dist/{project-O7ZZQXFN.js → chunk-2EHJH2QU.js}

@@ -1,8 +1,9 @@
 import {
-  RELEASE_SDK_REQUIREMENT,
   findFunctionsProjectRoot
-} from "./chunk-BCSUKRDA.js";
-import "./chunk-PNKVD2UK.js";
+} from "./chunk-XZ5VCTGY.js";
+import {
+  RELEASE_SDK_REQUIREMENT
+} from "./chunk-5FGDEZSJ.js";
 
 // src/commands/project.ts
 import { spawn } from "child_process";
@@ -13,6 +14,7 @@ var RELEASE_COMMANDS = /* @__PURE__ */ new Set([
   "inspect",
   "contract-test",
   "deploy",
+  "deploy-project",
   "deploy-runtime"
 ]);
 function showHelp() {
@@ -22,12 +24,13 @@ ${pc.dim("Usage:")}
   lumera project release inspect <archive> [--expected-digest <sha256>]
   lumera project release contract-test <archive> [--mode api|function|all]
   lumera project release deploy <archive> --project <project-id>
+  lumera project release deploy-project --project <project-id>
   lumera project release deploy-runtime <release-id> --project <project-id>
 
 ${pc.dim("Description:")}
   Build, verify, and contract-test immutable Python 3.13/Linux/ARM64 project
-  releases. The deploy command uploads an inactive resource and reports the
-  required deploy-runtime command that activates it.
+  releases. deploy-project builds, uploads, and activates the complete project
+  runtime used by App APIs, Functions, and Automations.
 `);
 }
 function buildReleaseRunnerArgs(command, args, projectRoot) {
@@ -48,11 +51,11 @@ function buildReleaseRunnerArgs(command, args, projectRoot) {
     ...args
   ];
 }
-async function runReleaseRunner(runnerArgs, projectRoot, spawnRunner = (command, args, options) => spawn(command, args, options)) {
+async function runReleaseRunner(runnerArgs, projectRoot, spawnRunner = (command, args, options) => spawn(command, args, options), environment = process.env) {
   return await new Promise((resolvePromise, reject) => {
     const child = spawnRunner("uv", runnerArgs, {
       cwd: projectRoot,
-      env: process.env,
+      env: environment,
       shell: false,
       stdio: ["inherit", "pipe", "inherit"]
     });
@@ -116,8 +119,9 @@ async function project(subcommand, args, dependencies = {}) {
     process.exitCode = 1;
   }
 }
+
 export {
   buildReleaseRunnerArgs,
-  project,
-  runReleaseRunner
+  runReleaseRunner,
+  project
 };

package/dist/chunk-5FGDEZSJ.js

@@ -0,0 +1,12 @@
+// src/lib/functions-sdk.ts
+var FUNCTIONS_SDK_VERSION_RANGE = ">=0.45.0,<0.46.0";
+var FUNCTIONS_SDK_COMPATIBILITY_RANGE = ">=0.34.0,<0.46.0";
+var FUNCTIONS_SDK_REQUIREMENT = `lumera[functions]${FUNCTIONS_SDK_COMPATIBILITY_RANGE}`;
+var DEFAULT_FUNCTIONS_SDK_REQUIREMENT = `lumera[functions]${FUNCTIONS_SDK_VERSION_RANGE}`;
+var RELEASE_SDK_REQUIREMENT = `lumera[release]${FUNCTIONS_SDK_VERSION_RANGE}`;
+
+export {
+  FUNCTIONS_SDK_REQUIREMENT,
+  DEFAULT_FUNCTIONS_SDK_REQUIREMENT,
+  RELEASE_SDK_REQUIREMENT
+};

package/dist/{chunk-3MAALYAP.js → chunk-P6GDSHYC.js}

@@ -1,3 +1,11 @@
+import {
+  parseProjectTOML,
+  projectConfigTable
+} from "./chunk-UGAIWMQV.js";
+import {
+  buildReleaseRunnerArgs,
+  runReleaseRunner
+} from "./chunk-2EHJH2QU.js";
 import {
   userContextHeaders
 } from "./chunk-W57NUJFJ.js";
@@ -8,168 +16,10 @@ import {
 // src/lib/deploy.ts
 import { execSync, spawn } from "child_process";
 import { createConnection } from "net";
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { resolve as resolve2, dirname } from "path";
-import archiver2 from "archiver";
-import pc from "picocolors";
-
-// src/lib/app-runtime-deploy.ts
-import { execFileSync } from "child_process";
-import {
-  cpSync,
-  existsSync,
-  mkdtempSync,
-  rmSync
-} from "fs";
-import { tmpdir } from "os";
-import { basename, join, relative, resolve, sep } from "path";
+import { existsSync, readFileSync } from "fs";
+import { resolve, dirname } from "path";
 import archiver from "archiver";
-var APP_RUNTIME_RELATIVE_DIR = join("app-api", "lambda");
-var APP_RUNTIME_PYTHON_VERSION = "3.13";
-var APP_RUNTIME_PYTHON_PLATFORM = "aarch64-manylinux_2_34";
-var MAX_APP_RUNTIME_ZIP_BYTES = 45 * 1024 * 1024;
-var APP_RUNTIME_TARGET_ARGS = [
-  "--python-version",
-  APP_RUNTIME_PYTHON_VERSION,
-  "--python-platform",
-  APP_RUNTIME_PYTHON_PLATFORM
-];
-var EXCLUDED_SOURCE_DIRECTORIES = /* @__PURE__ */ new Set([
-  ".git",
-  ".venv",
-  "venv",
-  "__pycache__",
-  ".pytest_cache",
-  ".ruff_cache",
-  ".lambda-build",
-  "build",
-  "dist"
-]);
-function resolveAppRuntimeDirectory(projectRoot) {
-  const runtimeDir = resolve(projectRoot, APP_RUNTIME_RELATIVE_DIR);
-  if (!existsSync(runtimeDir)) return void 0;
-  if (!existsSync(join(runtimeDir, "server.py"))) {
-    throw new Error(`App API directory exists but is missing ${join(APP_RUNTIME_RELATIVE_DIR, "server.py")}`);
-  }
-  return runtimeDir;
-}
-function shouldCopyRuntimeSource(runtimeDir, sourcePath) {
-  const sourceRelativePath = relative(runtimeDir, sourcePath);
-  if (!sourceRelativePath) return true;
-  const segments = sourceRelativePath.split(sep);
-  if (segments.some((segment) => EXCLUDED_SOURCE_DIRECTORIES.has(segment))) return false;
-  if (segments.some((segment) => segment === ".env" || segment.startsWith(".env."))) return false;
-  const name = basename(sourcePath);
-  if (name === "lambda.zip") return false;
-  return !name.endsWith(".pyc") && !name.endsWith(".pyo");
-}
-function copyRuntimeSources(runtimeDir, buildDir) {
-  cpSync(runtimeDir, buildDir, {
-    recursive: true,
-    filter: (candidate) => shouldCopyRuntimeSource(runtimeDir, candidate)
-  });
-}
-function ensureUVAvailable(runCommand) {
-  try {
-    runCommand("uv", ["--version"], { stdio: "ignore" });
-  } catch (error) {
-    throw new Error(
-      "uv is required to package App APIs. Install uv: https://docs.astral.sh/uv/",
-      { cause: error }
-    );
-  }
-}
-async function createZip(directory) {
-  return new Promise((resolveZip, reject) => {
-    const chunks = [];
-    const archive = archiver("zip", { zlib: { level: 9 } });
-    archive.on("data", (chunk) => chunks.push(chunk));
-    archive.on("end", () => resolveZip(Buffer.concat(chunks)));
-    archive.on("error", reject);
-    archive.directory(directory, false);
-    archive.finalize();
-  });
-}
-async function packageAppRuntime(runtimeDir, options = {}) {
-  if (!existsSync(join(runtimeDir, "server.py"))) {
-    throw new Error(`App API must contain server.py at ${join(runtimeDir, "server.py")}`);
-  }
-  const requirementsPath = join(runtimeDir, "requirements.txt");
-  const pyprojectPath = join(runtimeDir, "pyproject.toml");
-  if (!existsSync(requirementsPath) && !existsSync(pyprojectPath)) {
-    throw new Error("App API must contain requirements.txt or pyproject.toml");
-  }
-  const buildDir = mkdtempSync(join(tmpdir(), "lumera-app-runtime-"));
-  const runCommand = options.runCommand ?? execFileSync;
-  try {
-    ensureUVAvailable(runCommand);
-    let installRequirementsPath = requirementsPath;
-    let generatedRequirements = false;
-    if (!existsSync(requirementsPath)) {
-      installRequirementsPath = join(buildDir, "requirements.generated.txt");
-      generatedRequirements = true;
-      runCommand(
-        "uv",
-        [
-          "pip",
-          "compile",
-          "pyproject.toml",
-          ...APP_RUNTIME_TARGET_ARGS,
-          "-o",
-          installRequirementsPath
-        ],
-        {
-          cwd: runtimeDir,
-          stdio: "inherit"
-        }
-      );
-    }
-    runCommand("uv", [
-      "pip",
-      "install",
-      "--target",
-      buildDir,
-      ...APP_RUNTIME_TARGET_ARGS,
-      "--only-binary=:all:",
-      "-r",
-      installRequirementsPath
-    ], { stdio: "inherit" });
-    if (generatedRequirements) {
-      rmSync(installRequirementsPath, { force: true });
-    }
-    copyRuntimeSources(runtimeDir, buildDir);
-    const lambdaZip = await createZip(buildDir);
-    if (lambdaZip.length > MAX_APP_RUNTIME_ZIP_BYTES) {
-      throw new Error(
-        `App API package is too large (${lambdaZip.length} bytes > ${MAX_APP_RUNTIME_ZIP_BYTES}); remove heavy dependencies or split the app`
-      );
-    }
-    return lambdaZip;
-  } finally {
-    rmSync(buildDir, { recursive: true, force: true });
-  }
-}
-async function deployAppRuntime(options) {
-  const formData = new FormData();
-  formData.append("lambda_zip", new Blob([new Uint8Array(options.lambdaZip)]), "lambda.zip");
-  formData.append("version", options.version);
-  const res = await fetchWithRetry(`${options.apiUrl}/app-runtimes/current-project/deploy`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${options.token}`,
-      "X-Lumera-Client": "lumera-cli",
-      "X-Lumera-Project": options.projectExternalId,
-      ...userContextHeaders()
-    },
-    body: formData
-  });
-  if (!res.ok) {
-    throw new Error(`App API deploy failed: ${await res.text()}`);
-  }
-  await res.arrayBuffer();
-}
-
-// src/lib/deploy.ts
+import pc from "picocolors";
 function formatTimestampVersion(date = /* @__PURE__ */ new Date()) {
   const pad = (value) => String(value).padStart(2, "0");
   return [
@@ -183,7 +33,7 @@ function formatTimestampVersion(date = /* @__PURE__ */ new Date()) {
   ].join("") + "Z";
 }
 function resolveVersion(cwd, gitRelease = resolveGitReleaseState(cwd)) {
-  const pkgPath = resolve2(cwd, "package.json");
+  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);
@@ -195,13 +45,13 @@ function resolveVersion(cwd, gitRelease = resolveGitReleaseState(cwd)) {
 function resolveUIVersion(cwd) {
   try {
     const installed = JSON.parse(
-      readFileSync(resolve2(cwd, "node_modules/@lumerahq/ui/package.json"), "utf-8")
+      readFileSync(resolve(cwd, "node_modules/@lumerahq/ui/package.json"), "utf-8")
     );
     if (installed?.version) return String(installed.version);
   } catch {
   }
   try {
-    const pkg = JSON.parse(readFileSync(resolve2(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync(resolve(cwd, "package.json"), "utf-8"));
     const spec = pkg?.dependencies?.["@lumerahq/ui"] ?? pkg?.devDependencies?.["@lumerahq/ui"];
     if (!spec) return "none";
     const cleaned = String(spec).replace(/^[\^~>=<\s]+/, "");
@@ -237,53 +87,84 @@ function resolveGitReleaseState(cwd) {
   }
 }
 async function createTarball(distDir) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve2, reject) => {
     const chunks = [];
-    const archive = archiver2("tar", { gzip: true });
+    const archive = archiver("tar", { gzip: true });
     archive.on("data", (chunk) => chunks.push(chunk));
-    archive.on("end", () => resolve3(Buffer.concat(chunks)));
+    archive.on("end", () => resolve2(Buffer.concat(chunks)));
     archive.on("error", reject);
     archive.directory(distDir, false);
     archive.finalize();
   });
 }
-async function packageResolvedAppRuntime(appRuntimeDir) {
-  console.log(pc.dim("Packaging App API..."));
-  const lambdaZip = await packageAppRuntime(appRuntimeDir);
-  console.log(pc.dim(`App API package: ${(lambdaZip.length / 1024).toFixed(1)} KB`));
-  return lambdaZip;
-}
-async function packageOptionalAppRuntime(projectRoot) {
-  const appRuntimeDir = resolveAppRuntimeDirectory(projectRoot);
-  return appRuntimeDir ? packageResolvedAppRuntime(appRuntimeDir) : void 0;
-}
-async function packageRequiredAppRuntime(projectRoot) {
-  const appRuntimeDir = resolveAppRuntimeDirectory(projectRoot);
-  if (!appRuntimeDir) {
-    throw new Error("App API not found. Expected app-api/lambda/server.py");
+function resolveConfiguredProjectRuntime(projectRoot) {
+  const legacyPath = resolve(projectRoot, "app-api", "lambda");
+  if (existsSync(legacyPath)) {
+    throw new Error(
+      "Legacy app-api/lambda deployment has been retired. Run `lumera migrate app-api`, commit the migrated project, and deploy again."
+    );
+  }
+  const configPath = resolve(projectRoot, "pyproject.toml");
+  if (!existsSync(configPath)) return { kind: "none" };
+  const document = parseProjectTOML(readFileSync(configPath, "utf8"));
+  const release = projectConfigTable(document, "tool", "lumera", "release");
+  const functions = projectConfigTable(document, "tool", "lumera", "functions");
+  const rawEntrypoint = release["app-entrypoint"];
+  if (rawEntrypoint !== void 0 && (typeof rawEntrypoint !== "string" || !rawEntrypoint.trim())) {
+    throw new Error("tool.lumera.release.app-entrypoint must be module:attribute");
+  }
+  const modules = functions.modules ?? [];
+  if (!Array.isArray(modules) || !modules.every((module) => typeof module === "string")) {
+    throw new Error("tool.lumera.functions.modules must be a string array");
   }
-  return packageResolvedAppRuntime(appRuntimeDir);
+  const entrypoint = typeof rawEntrypoint === "string" ? rawEntrypoint.trim() : void 0;
+  const hasFunctions = modules.length > 0;
+  if (entrypoint || hasFunctions) {
+    return { kind: "release", appEntrypoint: entrypoint };
+  }
+  return { kind: "none" };
 }
 function resolveDeploymentVersion(projectRoot, gitRelease, explicitVersion) {
   return explicitVersion || process.env.LUMERA_APP_VERSION?.trim() || resolveVersion(projectRoot, gitRelease);
 }
-async function publishAppRuntime(options) {
-  console.log(pc.cyan("Deploying App API..."));
-  await deployAppRuntime(options);
-  console.log(pc.green("App API deployed!"));
+async function deployProjectRuntime(options) {
+  console.log(pc.cyan("Deploying project runtime..."));
+  const result = await runReleaseRunner(
+    buildReleaseRunnerArgs(
+      "deploy-project",
+      ["--project", options.projectExternalId],
+      options.projectRoot
+    ),
+    options.projectRoot,
+    void 0,
+    {
+      ...process.env,
+      LUMERA_BASE_URL: options.apiUrl,
+      LUMERA_TOKEN: options.token
+    }
+  );
+  if (result.code !== 0 || !result.envelope.ok) {
+    const error = result.envelope.error;
+    throw new Error(error?.message || "Project runtime deployment failed");
+  }
+  console.log(pc.green("Project runtime deployed!"));
 }
 async function deployAppAPI(options) {
   const gitRelease = resolveGitReleaseState(options.projectRoot);
   assertDeployableGitRelease(gitRelease);
-  const lambdaZip = await packageRequiredAppRuntime(options.projectRoot);
+  const runtime = resolveConfiguredProjectRuntime(options.projectRoot);
+  if (runtime.kind === "none" || !runtime.appEntrypoint) {
+    throw new Error(
+      "App API not found. Configure tool.lumera.release.app-entrypoint."
+    );
+  }
   const version = resolveDeploymentVersion(options.projectRoot, gitRelease, options.version);
   console.log(pc.dim(`Version: ${version}`));
-  await publishAppRuntime({
+  await deployProjectRuntime({
     apiUrl: options.apiUrl,
     token: options.token,
     projectExternalId: options.appName,
-    version,
-    lambdaZip
+    projectRoot: options.projectRoot
   });
   return version;
 }
@@ -319,13 +200,13 @@ async function deploy(options) {
     accessLevel,
     skipAppAPI
   } = options;
-  if (!existsSync2(distDir)) {
+  if (!existsSync(distDir)) {
     throw new Error(`dist directory not found: ${distDir}`);
   }
   const projectDir = dirname(distDir);
   const gitRelease = resolveGitReleaseState(projectDir);
   assertDeployableGitRelease(gitRelease);
-  const lambdaZip = skipAppAPI ? void 0 : await packageOptionalAppRuntime(projectDir);
+  const projectRuntime = skipAppAPI ? { kind: "none" } : resolveConfiguredProjectRuntime(projectDir);
   console.log(pc.dim("Ensuring app record..."));
   await ensureAppRecord(apiUrl, token, appName, appTitle, accessLevel);
   console.log(pc.cyan(`Preparing ${appTitle}...`));
@@ -339,13 +220,12 @@ async function deploy(options) {
   if (gitRelease.sha) formData.append("git_sha", gitRelease.sha);
   const uiVersion = resolveUIVersion(projectDir);
   if (uiVersion) formData.append("ui_version", uiVersion);
-  if (lambdaZip) {
-    await publishAppRuntime({
+  if (projectRuntime.kind !== "none") {
+    await deployProjectRuntime({
       apiUrl,
       token,
       projectExternalId: appName,
-      version,
-      lambdaZip
+      projectRoot: projectDir
     });
   }
   console.log(pc.cyan(`Deploying ${appTitle} frontend...`));
@@ -391,19 +271,19 @@ async function registerDevApp(apiBase, token, appName, appTitle, appUrl) {
   }
 }
 function isPortInUse(port, host = "127.0.0.1") {
-  return new Promise((resolve3) => {
+  return new Promise((resolve2) => {
     const socket = createConnection({ port, host });
     socket.once("connect", () => {
       socket.destroy();
-      resolve3(true);
+      resolve2(true);
     });
     socket.once("error", () => {
       socket.destroy();
-      resolve3(false);
+      resolve2(false);
     });
     socket.setTimeout(1e3, () => {
       socket.destroy();
-      resolve3(false);
+      resolve2(false);
     });
   });
 }
@@ -423,7 +303,7 @@ function parsePackageManagerSpecifier(value) {
 }
 function packageManagerFromPackageJson(projectRoot) {
   try {
-    const pkg = JSON.parse(readFileSync(resolve2(projectRoot, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync(resolve(projectRoot, "package.json"), "utf-8"));
     return parsePackageManagerSpecifier(pkg.packageManager);
   } catch {
     return void 0;
@@ -453,7 +333,7 @@ function detectRunner(projectRoot) {
   ];
   for (const { pm, file } of lockfileManagers) {
     const runner = runnerForPackageManager(pm);
-    if (existsSync2(resolve2(projectRoot, file)) && commandAvailable(runner[0])) return runner;
+    if (existsSync(resolve(projectRoot, file)) && commandAvailable(runner[0])) return runner;
   }
   for (const pm of ["pnpm", "bun", "yarn", "npm"]) {
     const runner = runnerForPackageManager(pm);
@@ -506,8 +386,8 @@ async function dev(options) {
   );
   const runner = detectRunner(projectRoot);
   const viteArgs = ["vite", "--port", String(port), "--strictPort"];
-  const sandboxConfig = resolve2(projectRoot, "vite.sandbox.config.ts");
-  if (existsSync2(sandboxConfig)) {
+  const sandboxConfig = resolve(projectRoot, "vite.sandbox.config.ts");
+  if (existsSync(sandboxConfig)) {
     viteArgs.push("--config", "vite.sandbox.config.ts");
   }
   if (host) {

package/dist/chunk-UGAIWMQV.js

@@ -0,0 +1,26 @@
+// src/lib/project-runtime-config.ts
+import { parse } from "smol-toml";
+function parseProjectTOML(source) {
+  try {
+    return parse(source);
+  } catch (error) {
+    throw new Error(`Invalid pyproject.toml: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function projectConfigTable(document, ...path) {
+  let table = document;
+  for (let index = 0; index < path.length; index++) {
+    const value = table[path[index]];
+    if (value === void 0) return {};
+    if (value === null || typeof value !== "object" || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+      throw new Error(`pyproject.toml ${path.slice(0, index + 1).join(".")} must be a table`);
+    }
+    table = value;
+  }
+  return table;
+}
+
+export {
+  parseProjectTOML,
+  projectConfigTable
+};

package/dist/{chunk-BCSUKRDA.js → chunk-XZ5VCTGY.js}

@@ -1,17 +1,12 @@
+import {
+  FUNCTIONS_SDK_REQUIREMENT
+} from "./chunk-5FGDEZSJ.js";
+
 // src/commands/functions.ts
 import { spawn } from "child_process";
 import { existsSync } from "fs";
 import { join, resolve } from "path";
 import pc from "picocolors";
-
-// src/lib/functions-sdk.ts
-var FUNCTIONS_SDK_VERSION_RANGE = ">=0.43.0,<0.44.0";
-var FUNCTIONS_SDK_COMPATIBILITY_RANGE = ">=0.34.0,<0.44.0";
-var FUNCTIONS_SDK_REQUIREMENT = `lumera[functions]${FUNCTIONS_SDK_COMPATIBILITY_RANGE}`;
-var DEFAULT_FUNCTIONS_SDK_REQUIREMENT = `lumera[functions]${FUNCTIONS_SDK_VERSION_RANGE}`;
-var RELEASE_SDK_REQUIREMENT = `lumera[release]${FUNCTIONS_SDK_VERSION_RANGE}`;
-
-// src/commands/functions.ts
 var SUPPORTED_SUBCOMMANDS = /* @__PURE__ */ new Set(["list", "inspect", "invoke", "test"]);
 var FUNCTIONS_RUNNER_PROTOCOL_VERSION = 1;
 function errorMessage(error, fallback) {
@@ -223,7 +218,6 @@ async function functions(subcommand, args, dependencies = {}) {
 }
 
 export {
-  RELEASE_SDK_REQUIREMENT,
   emitFunctionCliFailure,
   findFunctionsProjectRoot,
   buildFunctionRunnerArgs,

package/dist/{dev-CGQTW7TN.js → dev-24PCZUAT.js}

@@ -1,6 +1,10 @@
 import {
   dev
-} from "./chunk-3MAALYAP.js";
+} from "./chunk-P6GDSHYC.js";
+import "./chunk-UGAIWMQV.js";
+import "./chunk-2EHJH2QU.js";
+import "./chunk-XZ5VCTGY.js";
+import "./chunk-5FGDEZSJ.js";
 import {
   syncDeps
 } from "./chunk-5JNNUIVJ.js";

package/dist/{functions-BAJ3PCNO.js → functions-5OOHGQT7.js}

@@ -4,7 +4,8 @@ import {
   findFunctionsProjectRoot,
   functions,
   runFunctionRunner
-} from "./chunk-BCSUKRDA.js";
+} from "./chunk-XZ5VCTGY.js";
+import "./chunk-5FGDEZSJ.js";
 import "./chunk-PNKVD2UK.js";
 export {
   buildFunctionRunnerArgs,

package/dist/index.js

@@ -242,40 +242,40 @@ async function main() {
     switch (command) {
       // Resource commands
       case "plan":
-        await import("./resources-IY3XSYJH.js").then((m) => m.plan(args.slice(1)));
+        await import("./resources-IGHWATTH.js").then((m) => m.plan(args.slice(1)));
         break;
       case "apply":
-        await import("./resources-IY3XSYJH.js").then((m) => m.apply(args.slice(1)));
+        await import("./resources-IGHWATTH.js").then((m) => m.apply(args.slice(1)));
         break;
       case "pull":
-        await import("./resources-IY3XSYJH.js").then((m) => m.pull(args.slice(1)));
+        await import("./resources-IGHWATTH.js").then((m) => m.pull(args.slice(1)));
         break;
       case "destroy":
-        await import("./resources-IY3XSYJH.js").then((m) => m.destroy(args.slice(1)));
+        await import("./resources-IGHWATTH.js").then((m) => m.destroy(args.slice(1)));
         break;
       case "list":
-        await import("./resources-IY3XSYJH.js").then((m) => m.list(args.slice(1)));
+        await import("./resources-IGHWATTH.js").then((m) => m.list(args.slice(1)));
         break;
       case "show":
-        await import("./resources-IY3XSYJH.js").then((m) => m.show(args.slice(1)));
+        await import("./resources-IGHWATTH.js").then((m) => m.show(args.slice(1)));
         break;
       case "diff":
-        await import("./resources-IY3XSYJH.js").then((m) => m.diff(args.slice(1)));
+        await import("./resources-IGHWATTH.js").then((m) => m.diff(args.slice(1)));
         break;
       // Development
       case "dev":
-        await import("./dev-CGQTW7TN.js").then((m) => m.dev(args.slice(1)));
+        await import("./dev-24PCZUAT.js").then((m) => m.dev(args.slice(1)));
         break;
       case "run":
         await import("./run-4XFA5ZDJ.js").then((m) => m.run(args.slice(1)));
         break;
       case "functions":
-        await import("./functions-BAJ3PCNO.js").then(
+        await import("./functions-5OOHGQT7.js").then(
           (m) => m.functions(subcommand, args.slice(2))
         );
         break;
       case "project":
-        await import("./project-O7ZZQXFN.js").then(
+        await import("./project-ISKXDHGJ.js").then(
           (m) => m.project(subcommand, args.slice(2))
         );
         break;
@@ -293,7 +293,7 @@ async function main() {
         await import("./status-NPNIY3QP.js").then((m) => m.status(args.slice(1)));
         break;
       case "migrate":
-        await import("./migrate-NEG3HKH4.js").then((m) => m.migrate(args.slice(1)));
+        await import("./migrate-DHNR3ESM.js").then((m) => m.migrate(args.slice(1)));
         break;
       // Skills
       case "skills":

package/dist/{migrate-NEG3HKH4.js → migrate-DHNR3ESM.js}

@@ -1,3 +1,10 @@
+import {
+  parseProjectTOML,
+  projectConfigTable
+} from "./chunk-UGAIWMQV.js";
+import {
+  DEFAULT_FUNCTIONS_SDK_REQUIREMENT
+} from "./chunk-5FGDEZSJ.js";
 import {
   detectProjectVersion,
   findProjectRoot
@@ -6,12 +13,15 @@ import "./chunk-PNKVD2UK.js";
 
 // src/commands/migrate.ts
 import pc from "picocolors";
-import { existsSync, mkdirSync, renameSync, readdirSync, readFileSync, writeFileSync, rmSync } from "fs";
-import { join } from "path";
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync, renameSync, readdirSync, readFileSync, writeFileSync, rmSync, rmdirSync } from "fs";
+import { join, resolve } from "path";
+import { stringify } from "smol-toml";
 function showHelp() {
   console.log(`
 ${pc.dim("Usage:")}
   lumera migrate [options]
+  lumera migrate app-api [--dry-run]
 
 ${pc.dim("Description:")}
   Upgrade legacy project structure (v0) to the current structure (v1).
@@ -24,8 +34,103 @@ ${pc.dim("Options:")}
 ${pc.dim("Examples:")}
   lumera migrate              # Migrate to v1 structure
   lumera migrate --dry-run    # Preview migration changes
+  lumera migrate app-api      # Move a ZIP App API into the project release
 `);
 }
+function addReleaseAppEntrypoint(pyproject, projectRoot) {
+  const document = parseProjectTOML(pyproject);
+  const release = projectConfigTable(document, "tool", "lumera", "release");
+  const functions = projectConfigTable(document, "tool", "lumera", "functions");
+  if (release["app-entrypoint"] !== void 0) {
+    throw new Error("pyproject.toml already defines a release app-entrypoint");
+  }
+  for (const [section, config] of [["release", release], ["functions", functions]]) {
+    const source = config["source-root"];
+    if (source !== void 0 && (typeof source !== "string" || !source.trim() || resolve(projectRoot, source) !== resolve(projectRoot, "platform"))) {
+      throw new Error(`Cannot migrate App API: tool.lumera.${section}.source-root must resolve to platform. Align the source roots before migrating.`);
+    }
+  }
+  const tool = document.tool ??= {};
+  const lumera = tool.lumera ??= {};
+  lumera.release = {
+    ...release,
+    "source-root": "platform",
+    "app-entrypoint": "app.server:app",
+    "runtime-abi": release["runtime-abi"] ?? "1.0"
+  };
+  return stringify(document);
+}
+function rewriteAppImports(source, modules) {
+  let rewritten = source;
+  for (const moduleName of modules) {
+    const escaped = moduleName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    rewritten = rewritten.replace(
+      new RegExp(`^(\\s*)import\\s+${escaped}(\\s*(?:#.*)?)$`, "gm"),
+      `$1from app import ${moduleName}$2`
+    );
+    rewritten = rewritten.replace(
+      new RegExp(`^(\\s*)from\\s+${escaped}\\s+import\\s+`, "gm"),
+      `$1from app.${moduleName} import `
+    );
+  }
+  return rewritten;
+}
+function migrateAppAPI(projectRoot, dryRun) {
+  const legacyDir = join(projectRoot, "app-api", "lambda");
+  const destination = join(projectRoot, "platform", "app");
+  const pyprojectPath = join(projectRoot, "pyproject.toml");
+  if (!existsSync(join(legacyDir, "server.py"))) {
+    throw new Error("Legacy App API not found at app-api/lambda/server.py");
+  }
+  if (existsSync(destination)) {
+    throw new Error("platform/app already exists; resolve it before migrating the ZIP App API");
+  }
+  if (!existsSync(pyprojectPath)) {
+    throw new Error("pyproject.toml is required for a project release");
+  }
+  addReleaseAppEntrypoint(readFileSync(pyprojectPath, "utf8"), projectRoot);
+  console.log(pc.bold("App API migration plan:"));
+  console.log(pc.yellow("  \u2192 app-api/lambda/ \u2192 platform/app/"));
+  console.log(pc.blue("  \u270E rewrite local Python imports as app package imports"));
+  console.log(pc.blue("  \u270E merge requirements.txt into pyproject.toml and uv.lock"));
+  console.log(pc.blue('  \u270E configure app-entrypoint = "app.server:app"'));
+  if (dryRun) {
+    console.log(pc.dim("\nDry run - no changes made."));
+    return;
+  }
+  const requirements = join(legacyDir, "requirements.txt");
+  if (existsSync(requirements) && readFileSync(requirements, "utf8").trim()) {
+    execFileSync("uv", ["add", "-r", requirements], { cwd: projectRoot, stdio: "inherit" });
+  }
+  execFileSync("uv", ["add", DEFAULT_FUNCTIONS_SDK_REQUIREMENT], {
+    cwd: projectRoot,
+    stdio: "inherit"
+  });
+  mkdirSync(join(projectRoot, "platform"), { recursive: true });
+  renameSync(legacyDir, destination);
+  rmSync(join(destination, "requirements.txt"), { force: true });
+  if (!existsSync(join(destination, "__init__.py"))) {
+    writeFileSync(join(destination, "__init__.py"), "", "utf8");
+  }
+  const modules = new Set(
+    readdirSync(destination, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".py")).map((entry) => entry.name.slice(0, -3)).filter((name) => name !== "__init__")
+  );
+  for (const entry of readdirSync(destination, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".py")) continue;
+    const path = join(destination, entry.name);
+    writeFileSync(path, rewriteAppImports(readFileSync(path, "utf8"), modules), "utf8");
+  }
+  writeFileSync(
+    pyprojectPath,
+    addReleaseAppEntrypoint(readFileSync(pyprojectPath, "utf8"), projectRoot),
+    "utf8"
+  );
+  const legacyParent = join(projectRoot, "app-api");
+  if (readdirSync(legacyParent).length === 0) {
+    rmdirSync(legacyParent);
+  }
+  console.log(pc.green("\nApp API migration complete. Review imports and paths relative to the project root, commit the migrated project, then run `lumera apply app`."));
+}
 async function migrate(args) {
   if (args.includes("--help") || args.includes("-h")) {
     showHelp();
@@ -39,6 +144,10 @@ async function migrate(args) {
     console.error(pc.red("Not in a Lumera project directory."));
     process.exit(1);
   }
+  if (args[0] === "app-api") {
+    migrateAppAPI(projectRoot, dryRun);
+    return;
+  }
   const version = detectProjectVersion(projectRoot);
   if (version === 1) {
     console.log(pc.green("Project is already using v1 structure."));

package/dist/project-ISKXDHGJ.js

@@ -0,0 +1,13 @@
+import {
+  buildReleaseRunnerArgs,
+  project,
+  runReleaseRunner
+} from "./chunk-2EHJH2QU.js";
+import "./chunk-XZ5VCTGY.js";
+import "./chunk-5FGDEZSJ.js";
+import "./chunk-PNKVD2UK.js";
+export {
+  buildReleaseRunnerArgs,
+  project,
+  runReleaseRunner
+};

package/dist/{resources-IY3XSYJH.js → resources-IGHWATTH.js}

@@ -1,7 +1,11 @@
 import {
   deploy,
   deployAppAPI
-} from "./chunk-3MAALYAP.js";
+} from "./chunk-P6GDSHYC.js";
+import "./chunk-UGAIWMQV.js";
+import "./chunk-2EHJH2QU.js";
+import "./chunk-XZ5VCTGY.js";
+import "./chunk-5FGDEZSJ.js";
 import {
   syncDeps
 } from "./chunk-5JNNUIVJ.js";
@@ -1563,8 +1567,8 @@ ${pc2.dim("Resources:")}
 
 ${pc2.dim("Options:")}
   --yes, -y           Skip confirmation prompt (for CI/CD)
-  --skip-build        Skip the frontend build; still package the App API
-  --skip-app-api      Publish only the frontend, even if an App API exists
+  --skip-build        Skip the frontend build; still deploy the project runtime
+  --skip-app-api      Publish only the frontend without deploying the project runtime
   --no-app            Apply resources only; do not build/deploy the app
   --resources-only    Alias for --no-app
   --package-manager   Package manager for app builds (pnpm, bun, yarn, npm)
@@ -1576,7 +1580,7 @@ ${pc2.dim("Examples:")}
   lumera apply agents -y             # Apply agents without confirmation
   lumera apply app                   # Deploy frontend and App API
   lumera apply app-api               # Deploy only the App API
-  lumera apply app --skip-build      # Reuse dist; package and deploy App API
+  lumera apply app --skip-build      # Reuse dist; deploy the project runtime
   lumera apply app --skip-app-api    # Deploy only the frontend
   lumera apply --no-app -y           # Apply resources without app build/deploy
   lumera apply app --package-manager pnpm

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumerahq/cli",
-  "version": "0.33.1",
+  "version": "0.34.2",
   "description": "CLI for building and deploying Lumera apps",
   "type": "module",
   "engines": {
@@ -25,7 +25,8 @@
     "dotenv": "^16.4.7",
     "open": "^10.1.0",
     "picocolors": "^1.1.1",
-    "prompts": "^2.4.2"
+    "prompts": "^2.4.2",
+    "smol-toml": "^1.9.0"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",

package/templates/default/AGENTS.md

@@ -1,56 +1,38 @@
 # {{projectTitle}}
 
-> Status: new project — nothing built yet.
-
-<!--
-AGENT CONTRACT — keep this file true.
-This is the project's durable memory, shared by every coding agent that works
-here. It records what cannot be re-derived from the code: why things are the
-way they are, what the business needs, what must not break.
-- Update it in the same turn as the change that makes it stale.
-- Small focused edits; delete stale lines rather than appending duplicates.
-- Leave a section empty rather than padding it.
-- Keep this file concise and always under 100 KB. Before an update would cross
-  that limit—or if the file is already over it—compact it in the same turn by
-  removing stale, superseded, duplicated, transient, and re-derivable detail
-  while preserving user-written notes.
-- Do NOT put here: platform documentation (skills and prompts carry that),
-  code inventories, secrets/credentials, or transient chat summaries.
--->
-
 ## What this is
 
-One paragraph: the problem this solves, for whom, and its current shape
+One short paragraph: the problem this solves, for whom, and its current shape
 (app / automation / agent / one-off analysis). Update when scope changes.
 
-## Business context
-
-- Who uses it, when, and for what workflow (roles, cadence — e.g. month-end)
-- Domain terms with tenant-specific meaning
-- Source-of-truth data and how it arrives (uploads, mailbox, webhooks, integrations)
-
-## Data
-
-- What each collection represents; non-obvious field/status semantics
-- Identifiers that map to external systems, and their formats
-
-## Decisions
-
-- YYYY-MM-DD — decision — why.
-
 ## Working agreements
 
-- User preferences: review gates, deploy expectations, formatting
-
-## Correctness
-
-- What "correct" means here: validations, reconciliations, tolerances, approvals
-- Known edge cases; behavior when required data is missing
-
-## Gotchas
-
-- Things that look wrong but are intentional; workarounds and why
-
-## Follow-ups
-
-- [ ] Open questions and deferred work
+Keep critical safety rules and user preferences that apply to every task here.
+
+## Managing memory
+
+- Keep this file short: ideally a few KB, always under 10 KB. Put detailed
+  knowledge in `memories/<topic>.md` and link it from the index below.
+- Save information that helps future agents: useful context, user preferences,
+  important decisions and their reasons, proven approaches, and lessons from
+  mistakes. Prefer knowledge that saves the user from repeating instructions or
+  future agents from rediscovering hard-won solutions. If there is nothing worth
+  remembering, do not update memory.
+- Distill what matters, not everything that happened. Keep routine progress and
+  temporary task state in the conversation.
+- Include useful paths, commands, and verification steps when they make a lesson
+  easier to reuse. For recurring problems, capture the symptom, cause, and proven
+  fix. Be honest about uncertainty. Do not turn a one-off request into a standing
+  rule. Check changeable facts against their source.
+- Read only relevant topics when needed; search if necessary. Do not load every
+  topic or use automatic file imports.
+- Organize by topic, not turn or date. Update existing notes, merge duplicates,
+  and remove outdated material. Keep memory files in version control and check
+  this file's size and links after changes.
+- Keep secrets out of memory. Link to source documents rather than copying them.
+  Data the app needs belongs in collections or app configuration.
+
+## Memory index
+
+Add one relative Markdown link with a one-line description per topic after
+creating the file. No topics recorded yet.

package/templates/default/pyproject.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 description = "{{projectTitle}} - Lumera custom app"
 requires-python = ">=3.11"
 dependencies = [
-    "lumera[functions]>=0.43.0,<0.44.0",
+    "lumera[functions]>=0.45.0,<0.46.0",
 ]
 
 [project.optional-dependencies]
@@ -17,3 +17,7 @@ dev = [
 source-root = "platform"
 modules = []
 test-paths = ["tests/functions"]
+
+[tool.lumera.release]
+source-root = "platform"
+runtime-abi = "1.0"