@lumerahq/cli 0.26.0 → 0.29.1

package/dist/{functions-PVOVWMON.js → chunk-QPVRRJFJ.js}

@@ -1,12 +1,10 @@
-import "./chunk-PNKVD2UK.js";
-
 // src/commands/functions.ts
 import { spawn } from "child_process";
 import { existsSync } from "fs";
 import { join, resolve } from "path";
 import pc from "picocolors";
 var SUPPORTED_SUBCOMMANDS = /* @__PURE__ */ new Set(["list", "inspect", "invoke", "test"]);
-var FUNCTIONS_SDK_REQUIREMENT = "lumera[functions]>=0.30.0,<0.31.0";
+var FUNCTIONS_SDK_REQUIREMENT = "lumera[functions]>=0.32.0,<0.33.0";
 var FUNCTIONS_RUNNER_PROTOCOL_VERSION = 1;
 function errorMessage(error, fallback) {
   return error instanceof Error && error.message ? error.message : fallback;
@@ -52,14 +50,18 @@ ${pc.dim("Usage:")}
   lumera functions list
   lumera functions inspect <function-id>
   lumera functions invoke <function-id> --input <path|-> --local
+  lumera functions invoke <function-id> --input <path|-> --remote --project <project>
   lumera functions test [-- <pytest-options>]
 
 ${pc.dim("Description:")}
-  Discover, inspect, invoke, and test configured Functions in a fresh local
-  Python process. Phase 1 does not deploy or invoke Functions remotely.
+  Discover, inspect, invoke, and test configured Functions. Invocation can run
+  in a fresh local process or create a durable remote execution.
 
 ${pc.dim("Options:")}
-  --local                Required for invoke; remote invocation is unavailable
+  --local                Run from the local project source
+  --remote               Create a durable execution from the active release
+  --project <project>    Project ID or external ID for remote invocation
+  --idempotency-key <k>  Deduplicate matching remote invocation requests
   --input <path|->       Read a JSON object from a project file or stdin (-)
   --help, -h             Show this help
 
@@ -67,6 +69,7 @@ ${pc.dim("Examples:")}
   lumera functions list
   lumera functions inspect invoices:approve
   lumera functions invoke invoices:approve --input input.json --local
+  lumera functions invoke invoices:approve --input input.json --remote --project finance
   cat input.json | lumera functions invoke invoices:approve --input - --local
   lumera functions test
   lumera functions test -- -k approve
@@ -76,10 +79,17 @@ function buildFunctionRunnerArgs(subcommand, args, projectRoot) {
   if (!SUPPORTED_SUBCOMMANDS.has(subcommand)) {
     throw new Error(`Unknown functions subcommand: ${subcommand}`);
   }
-  if (subcommand === "invoke" && !args.includes("--local")) {
-    throw new Error(
-      "Function invocation is local-only in Phase 1; pass --local explicitly."
-    );
+  if (subcommand === "invoke") {
+    const local = args.includes("--local");
+    const remote = args.includes("--remote");
+    if (local === remote) {
+      throw new Error(
+        "Pass exactly one of --local or --remote for Function invocation."
+      );
+    }
+    if (remote && !args.includes("--project")) {
+      throw new Error("--project is required for remote Function invocation.");
+    }
   }
   const runnerPrefix = ["run"];
   if (existsSync(join(projectRoot, "uv.lock"))) {
@@ -203,10 +213,11 @@ async function functions(subcommand, args, dependencies = {}) {
     process.exitCode = exitCode;
   }
 }
+
 export {
-  buildFunctionRunnerArgs,
   emitFunctionCliFailure,
   findFunctionsProjectRoot,
-  functions,
-  runFunctionRunner
+  buildFunctionRunnerArgs,
+  runFunctionRunner,
+  functions
 };

package/dist/functions-KP2NO4RC.js

@@ -0,0 +1,15 @@
+import {
+  buildFunctionRunnerArgs,
+  emitFunctionCliFailure,
+  findFunctionsProjectRoot,
+  functions,
+  runFunctionRunner
+} from "./chunk-QPVRRJFJ.js";
+import "./chunk-PNKVD2UK.js";
+export {
+  buildFunctionRunnerArgs,
+  emitFunctionCliFailure,
+  findFunctionsProjectRoot,
+  functions,
+  runFunctionRunner
+};

package/dist/index.js

@@ -12,7 +12,7 @@ import pc from "picocolors";
 
 // src/lib/command-output.ts
 function commandOwnsStdout(command2) {
-  return command2 === "functions";
+  return command2 === "functions" || command2 === "project";
 }
 
 // src/lib/update-check.ts
@@ -96,6 +96,7 @@ var COMMANDS = [
   "dev",
   "run",
   "functions",
+  "project",
   "init",
   "register",
   "templates",
@@ -158,6 +159,7 @@ ${pc.dim("Development:")}
   ${pc.cyan("dev")}                      Start dev server
   ${pc.cyan("run")} <target>             Run script, trigger automation, or invoke agent
   ${pc.cyan("functions")} <command>       Develop and test Functions locally
+  ${pc.cyan("project release")} <command> Build and verify immutable releases
 
 ${pc.dim("Project:")}
   ${pc.cyan("init")} [name]              Scaffold a new project
@@ -238,25 +240,25 @@ async function main() {
     switch (command) {
       // Resource commands
       case "plan":
-        await import("./resources-R53XKJL2.js").then((m) => m.plan(args.slice(1)));
+        await import("./resources-P4VA2JPE.js").then((m) => m.plan(args.slice(1)));
         break;
       case "apply":
-        await import("./resources-R53XKJL2.js").then((m) => m.apply(args.slice(1)));
+        await import("./resources-P4VA2JPE.js").then((m) => m.apply(args.slice(1)));
         break;
       case "pull":
-        await import("./resources-R53XKJL2.js").then((m) => m.pull(args.slice(1)));
+        await import("./resources-P4VA2JPE.js").then((m) => m.pull(args.slice(1)));
         break;
       case "destroy":
-        await import("./resources-R53XKJL2.js").then((m) => m.destroy(args.slice(1)));
+        await import("./resources-P4VA2JPE.js").then((m) => m.destroy(args.slice(1)));
         break;
       case "list":
-        await import("./resources-R53XKJL2.js").then((m) => m.list(args.slice(1)));
+        await import("./resources-P4VA2JPE.js").then((m) => m.list(args.slice(1)));
         break;
       case "show":
-        await import("./resources-R53XKJL2.js").then((m) => m.show(args.slice(1)));
+        await import("./resources-P4VA2JPE.js").then((m) => m.show(args.slice(1)));
         break;
       case "diff":
-        await import("./resources-R53XKJL2.js").then((m) => m.diff(args.slice(1)));
+        await import("./resources-P4VA2JPE.js").then((m) => m.diff(args.slice(1)));
         break;
       // Development
       case "dev":
@@ -266,13 +268,18 @@ async function main() {
         await import("./run-WHVUVIYB.js").then((m) => m.run(args.slice(1)));
         break;
       case "functions":
-        await import("./functions-PVOVWMON.js").then(
+        await import("./functions-KP2NO4RC.js").then(
           (m) => m.functions(subcommand, args.slice(2))
         );
         break;
+      case "project":
+        await import("./project-OPA5UUMQ.js").then(
+          (m) => m.project(subcommand, args.slice(2))
+        );
+        break;
       // Project
       case "init":
-        await import("./init-CUB3KH6M.js").then((m) => m.init(args.slice(1)));
+        await import("./init-ZR2SLJ3K.js").then((m) => m.init(args.slice(1)));
         break;
       case "register":
         await import("./register-HRLBT4FI.js").then((m) => m.register(args.slice(1)));

package/dist/project-OPA5UUMQ.js

@@ -0,0 +1,125 @@
+import {
+  findFunctionsProjectRoot
+} from "./chunk-QPVRRJFJ.js";
+import "./chunk-PNKVD2UK.js";
+
+// src/commands/project.ts
+import { spawn } from "child_process";
+import pc from "picocolors";
+var RELEASE_SDK_REQUIREMENT = "lumera[release]>=0.32.0,<0.33.0";
+var RELEASE_PROTOCOL_VERSION = 1;
+var RELEASE_COMMANDS = /* @__PURE__ */ new Set([
+  "build",
+  "inspect",
+  "contract-test",
+  "deploy",
+  "stage",
+  "activate"
+]);
+function showHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera project release build [--output dist/releases]
+  lumera project release inspect <archive> [--expected-digest <sha256>]
+  lumera project release contract-test <archive> [--mode api|worker|all]
+  lumera project release deploy <archive> --project <project-id>
+  lumera project release stage <release-id> --project <project-id> --expected-generation <n>
+  lumera project release activate <deployment-id> --project <project-id> --expected-generation <n>
+
+${pc.dim("Description:")}
+  Build, verify, and contract-test immutable Python 3.13/Linux/ARM64 project
+  releases, upload an inactive resource, stage a healthy runtime, and activate
+  it atomically with an expected generation.
+`);
+}
+function buildReleaseRunnerArgs(command, args, projectRoot) {
+  if (!RELEASE_COMMANDS.has(command)) {
+    throw new Error(`Unknown project release command: ${command}`);
+  }
+  return [
+    "run",
+    "--locked",
+    "--with",
+    RELEASE_SDK_REQUIREMENT,
+    "python",
+    "-m",
+    "lumera.releases",
+    "--project-root",
+    projectRoot,
+    command,
+    ...args
+  ];
+}
+async function runReleaseRunner(runnerArgs, projectRoot, spawnRunner = (command, args, options) => spawn(command, args, options)) {
+  return await new Promise((resolvePromise, reject) => {
+    const child = spawnRunner("uv", runnerArgs, {
+      cwd: projectRoot,
+      env: process.env,
+      shell: false,
+      stdio: ["inherit", "pipe", "inherit"]
+    });
+    let output = "";
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      output += chunk;
+    });
+    child.once("error", (error) => {
+      reject(
+        error.code === "ENOENT" ? new Error("uv is not installed. Install it from https://docs.astral.sh/uv/") : error
+      );
+    });
+    child.once("close", (code) => {
+      try {
+        const envelope = JSON.parse(output);
+        if (envelope.protocol_version !== RELEASE_PROTOCOL_VERSION || typeof envelope.ok !== "boolean") {
+          throw new Error("invalid release runner protocol");
+        }
+        resolvePromise({ code: code ?? 1, envelope, raw: output });
+      } catch {
+        reject(
+          new Error(
+            `Release runner exited with status ${code ?? 1} before emitting a valid protocol envelope`
+          )
+        );
+      }
+    });
+  });
+}
+async function project(subcommand, args, dependencies = {}) {
+  if (subcommand !== "release" || args.length === 0 || args.includes("--help") || args.includes("-h")) {
+    showHelp();
+    return;
+  }
+  const [releaseCommand, ...releaseArgs] = args;
+  const findProjectRoot = dependencies.findProjectRoot ?? findFunctionsProjectRoot;
+  const runRunner = dependencies.runRunner ?? runReleaseRunner;
+  const writeOutput = dependencies.writeOutput ?? ((value) => process.stdout.write(value));
+  try {
+    const projectRoot = findProjectRoot();
+    const result = await runRunner(
+      buildReleaseRunnerArgs(releaseCommand, releaseArgs, projectRoot),
+      projectRoot
+    );
+    writeOutput(result.raw);
+    if (result.code !== 0) process.exitCode = result.code;
+  } catch (error) {
+    writeOutput(
+      `${JSON.stringify({
+        protocol_version: RELEASE_PROTOCOL_VERSION,
+        ok: false,
+        error: {
+          code: "release_cli_error",
+          message: error instanceof Error ? error.message : "Release command failed",
+          retryable: false
+        }
+      })}
+`
+    );
+    process.exitCode = 1;
+  }
+}
+export {
+  buildReleaseRunnerArgs,
+  project,
+  runReleaseRunner
+};

package/dist/{resources-R53XKJL2.js → resources-P4VA2JPE.js}

@@ -93,10 +93,132 @@ var automationConfigRule = {
   }
 };
 
-// src/lib/lint/rules/collection-schema.ts
+// src/lib/lint/rules/automation-main-guard.ts
+import { spawnSync } from "child_process";
+var PYTHON_AST_SCRIPT = String.raw`
+import ast
+import json
+import sys
+
+source = sys.stdin.read()
+try:
+    module = ast.parse(source)
+except SyntaxError:
+    print("null")
+    raise SystemExit(0)
+
+
+def is_name(node):
+    return isinstance(node, ast.Name) and node.id == "__name__"
+
+
+def is_main_string(node):
+    if isinstance(node, ast.Str):
+        return node.s == "__main__"
+    return isinstance(node, ast.Constant) and node.value == "__main__"
+
+
+def is_main_guard(node):
+    test = node.test
+    if not isinstance(test, ast.Compare):
+        return False
+    if len(test.ops) != 1 or not isinstance(test.ops[0], ast.Eq):
+        return False
+    if len(test.comparators) != 1:
+        return False
+    right = test.comparators[0]
+    return (is_name(test.left) and is_main_string(right)) or (
+        is_main_string(test.left) and is_name(right)
+    )
+
+
+for statement in module.body:
+    if not isinstance(statement, ast.If) or not is_main_guard(statement):
+        continue
+    get_segment = getattr(ast, "get_source_segment", None)
+    condition = get_segment(source, statement.test) if get_segment else None
+    if not condition:
+        condition = '__name__ == "__main__"'
+    snippet = "if " + " ".join(condition.split()) + ":"
+    print(json.dumps({"line": statement.lineno, "snippet": snippet}))
+    break
+else:
+    print("null")
+`;
+var cachedPython3;
+function findPython3() {
+  if (cachedPython3 !== void 0) return cachedPython3;
+  for (const executable of ["python3", "python"]) {
+    const probe = spawnSync(executable, ["-I", "-S", "--version"], {
+      encoding: "utf8",
+      timeout: 2e3,
+      windowsHide: true
+    });
+    const version = `${probe.stdout ?? ""}${probe.stderr ?? ""}`.trim();
+    if (probe.status === 0 && /^Python 3(?:\.|\s|$)/.test(version)) {
+      cachedPython3 = executable;
+      return executable;
+    }
+  }
+  cachedPython3 = null;
+  return null;
+}
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function functionEntrypoint(config) {
+  if (!isRecord2(config) || !isRecord2(config.function)) {
+    return null;
+  }
+  const name = config.function.name;
+  return typeof name === "string" && name.trim() !== "" ? name.trim() : null;
+}
+function findTopLevelMainGuard(source) {
+  const python = findPython3();
+  if (python === null) return null;
+  const parsed = spawnSync(python, ["-I", "-S", "-c", PYTHON_AST_SCRIPT], {
+    input: source,
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024,
+    timeout: 5e3,
+    windowsHide: true
+  });
+  if (parsed.status !== 0) return null;
+  try {
+    const value = JSON.parse(parsed.stdout.trim());
+    if (!isRecord2(value) || typeof value.line !== "number" || typeof value.snippet !== "string") {
+      return null;
+    }
+    return { line: value.line, snippet: value.snippet };
+  } catch {
+    return null;
+  }
+}
+var automationMainGuardRule = {
+  id: "automation-main-guard",
+  description: "Warns when a function automation contains a top-level __main__ guard.",
+  appliesTo: ["automation"],
+  check(target) {
+    const entrypoint = functionEntrypoint(target.config);
+    if (entrypoint === null) return [];
+    const guard = findTopLevelMainGuard(target.source);
+    if (guard === null) return [];
+    const warning2 = {
+      ruleId: "automation-main-guard",
+      target,
+      severity: "warning",
+      line: guard.line,
+      snippet: guard.snippet,
+      message: `Function automations must not contain a top-level __main__ guard. Lumera invokes "${entrypoint}" automatically; remove the guard.`
+    };
+    return [warning2];
+  }
+};
+
+// src/lib/lint/rules/collection-schema.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function error(target, message, snippet) {
   return {
     ruleId: "collection-schema",
@@ -118,7 +240,7 @@ var collectionSchemaRule = {
       const message = err instanceof Error ? err.message : String(err);
       return [error(target, `Invalid JSON: ${message}`)];
     }
-    if (!isRecord2(parsed)) {
+    if (!isRecord3(parsed)) {
       return [error(target, "Collection file must contain a JSON object.")];
     }
     const issues = [];
@@ -131,7 +253,7 @@ var collectionSchemaRule = {
     const localFieldTypes = /* @__PURE__ */ new Map();
     if (Array.isArray(fields)) {
       for (const field of fields) {
-        if (isRecord2(field) && typeof field.name === "string") {
+        if (isRecord3(field) && typeof field.name === "string") {
           localFieldTypes.set(field.name, field.type);
         }
       }
@@ -155,7 +277,7 @@ var collectionSchemaRule = {
     } else {
       for (let i = 0; i < fields.length; i++) {
         const field = fields[i];
-        if (!isRecord2(field)) {
+        if (!isRecord3(field)) {
           issues.push(error(target, `Field at index ${i} must be an object.`));
           continue;
         }
@@ -176,7 +298,7 @@ var collectionSchemaRule = {
       } else {
         for (let i = 0; i < indexes.length; i++) {
           const index = indexes[i];
-          if (!isRecord2(index)) {
+          if (!isRecord3(index)) {
             const hint = typeof index === "string" ? ' Indexes are objects like { "fields": ["title"], "unique": true }, not CREATE INDEX SQL strings.' : "";
             issues.push(error(target, `Index at index ${i} must be an object.${hint}`));
             continue;
@@ -193,7 +315,7 @@ var collectionSchemaRule = {
       }
     }
     if (search !== void 0) {
-      if (!isRecord2(search)) {
+      if (!isRecord3(search)) {
         issues.push(error(target, 'Optional field "search" must be an object when present.'));
       } else {
         const unknownSearchKeys = Object.keys(search).filter((key) => key !== "fulltext" && key !== "semantic");
@@ -205,14 +327,14 @@ var collectionSchemaRule = {
         if (fulltext === void 0 && semantic === void 0) {
           issues.push(error(target, '"search" must include "fulltext" or "semantic".'));
         }
-        if (fulltext !== void 0 && !isRecord2(fulltext)) {
+        if (fulltext !== void 0 && !isRecord3(fulltext)) {
           issues.push(error(target, '"search.fulltext" must be an object when present.'));
-        } else if (isRecord2(fulltext)) {
+        } else if (isRecord3(fulltext)) {
           const allowed = /* @__PURE__ */ new Set(["fields", "language", "fuzzy_fields"]);
           for (const key of Object.keys(fulltext).filter((key2) => !allowed.has(key2))) {
             issues.push(error(target, `Unknown search.fulltext option "${key}".`));
           }
-          if (!isRecord2(fulltext.fields) || Object.keys(fulltext.fields).length === 0) {
+          if (!isRecord3(fulltext.fields) || Object.keys(fulltext.fields).length === 0) {
             issues.push(error(target, '"search.fulltext.fields" must be a non-empty field-to-weight object.'));
           } else {
             if (Object.keys(fulltext.fields).length > 8) {
@@ -244,9 +366,9 @@ var collectionSchemaRule = {
             }
           }
         }
-        if (semantic !== void 0 && !isRecord2(semantic)) {
+        if (semantic !== void 0 && !isRecord3(semantic)) {
           issues.push(error(target, '"search.semantic" must be an object when present.'));
-        } else if (isRecord2(semantic)) {
+        } else if (isRecord3(semantic)) {
           const allowed = /* @__PURE__ */ new Set(["fields", "model"]);
           for (const key of Object.keys(semantic).filter((key2) => !allowed.has(key2))) {
             issues.push(error(target, `Unknown search.semantic option "${key}".`));
@@ -653,7 +775,13 @@ var llmImportRule = {
 };
 
 // src/lib/lint/registry.ts
-var ALL_RULES = [automationConfigRule, collectionSchemaRule, hookVerifyRule, llmImportRule];
+var ALL_RULES = [
+  automationConfigRule,
+  automationMainGuardRule,
+  collectionSchemaRule,
+  hookVerifyRule,
+  llmImportRule
+];
 
 // src/lib/lint/format.ts
 import { relative } from "path";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumerahq/cli",
-  "version": "0.26.0",
+  "version": "0.29.1",
   "description": "CLI for building and deploying Lumera apps",
   "type": "module",
   "engines": {

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.30.0,<0.31.0",
+    "lumera[functions]>=0.32.0,<0.33.0",
 ]
 
 [project.optional-dependencies]

package/dist/{init-CUB3KH6M.js → init-ZR2SLJ3K.js}

@@ -1,3 +1,6 @@
+import {
+  spinner
+} from "./chunk-BHYDYR75.js";
 import {
   listAllTemplates,
   resolveTemplate
@@ -6,9 +9,6 @@ import {
   installAllSkills,
   syncClaudeMd
 } from "./chunk-VL5GDJKU.js";
-import {
-  spinner
-} from "./chunk-BHYDYR75.js";
 import {
   createApiClient,
   validateProjectNameLength