@base44-preview/cli 0.1.14-pr.624.af1a615 → 0.1.14-pr.626.0acc5e4

package/dist/cli/index.js

@@ -31177,7 +31177,7 @@ function cleanDoc(doc) {
   return mapDoc(doc, (currentDoc) => cleanDocFn(currentDoc));
 }
 function replaceEndOfLine(doc, replacement = literalline) {
-  return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? join27(replacement, currentDoc.split(`
+  return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? join29(replacement, currentDoc.split(`
 `)) : currentDoc);
 }
 function canBreakFn(doc) {
@@ -31257,7 +31257,7 @@ function indentIfBreak(contents, options) {
     negate: options.negate
   };
 }
-function join27(separator, docs) {
+function join29(separator, docs) {
   assertDoc(separator);
   assertDocArray(docs);
   const parts = [];
@@ -31968,7 +31968,7 @@ var init_doc = __esm(() => {
   MODE_FLAT = Symbol("MODE_FLAT");
   DOC_FILL_PRINTED_LENGTH = Symbol("DOC_FILL_PRINTED_LENGTH");
   builders = {
-    join: join27,
+    join: join29,
     line,
     softline,
     hardline,
@@ -228779,7 +228779,7 @@ function normalizeBase44Env() {
 loadProjectEnvFiles();
 
 // src/cli/index.ts
-import { dirname as dirname26, join as join36 } from "node:path";
+import { dirname as dirname27, join as join38 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // ../../node_modules/@clack/core/dist/index.mjs
@@ -239812,7 +239812,10 @@ async function uploadPresignedAsset(upload, assets) {
   try {
     await distribution_default.put(upload.url, {
       body: new Uint8Array(content),
-      headers: { "Content-Type": upload.contentType },
+      headers: {
+        "Content-Type": upload.contentType,
+        ...upload.checksumSha256 ? { "x-amz-checksum-sha256": upload.checksumSha256 } : {}
+      },
       timeout: 120000,
       retry: UPLOAD_RETRY
     });
@@ -246483,6 +246486,13 @@ async function resolveGitHash(projectRoot, explicit) {
   }
   return hash;
 }
+async function resolveProvenanceCommit(projectRoot, explicit) {
+  if (explicit) {
+    return await resolveGitHash(projectRoot, explicit);
+  }
+  const hash = await gitHead(projectRoot);
+  return hash && isGitCommitHash(hash) ? hash : undefined;
+}
 async function gitHead(projectRoot) {
   try {
     const { stdout } = await execa("git", ["rev-parse", "HEAD"], {
@@ -246992,6 +247002,136 @@ async function resolveBranchName(name) {
   return matches[0].id;
 }
 
+// src/core/version/publish.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+
+// src/core/version/schema.ts
+var DeclareVersionResponseSchema = object({
+  session_id: string2(),
+  uploads: array(object({
+    path: string2(),
+    url: string2(),
+    content_type: string2(),
+    content_length: number2(),
+    checksum_sha256: string2()
+  }))
+}).transform((data) => ({
+  sessionId: data.session_id,
+  uploads: data.uploads.map((upload) => ({
+    path: upload.path,
+    url: upload.url,
+    contentType: upload.content_type,
+    contentLength: upload.content_length,
+    checksumSha256: upload.checksum_sha256
+  }))
+}));
+var CreateVersionResponseSchema = object({
+  version_id: string2(),
+  manifest_hash: string2(),
+  deduplicated: boolean2()
+}).transform((data) => ({
+  versionId: data.version_id,
+  manifestHash: data.manifest_hash,
+  deduplicated: data.deduplicated
+}));
+var DeployVersionResponseSchema = object({
+  deployment_id: string2(),
+  manifest_hash: string2(),
+  revision: number2()
+}).transform((data) => ({
+  deploymentId: data.deployment_id,
+  manifestHash: data.manifest_hash,
+  revision: data.revision
+}));
+
+// src/core/version/api.ts
+var DEFAULT_VERSION_UPLOAD_CONCURRENCY = 8;
+var MAX_VERSION_UPLOAD_CONCURRENCY = 16;
+async function post(path, json, doing) {
+  try {
+    return await getAppClient().post(path, { json, timeout: 180000 });
+  } catch (error) {
+    throw await ApiError.fromHttpError(error, doing);
+  }
+}
+function parse10(schema, body, what) {
+  const result = schema.safeParse(body);
+  if (!result.success) {
+    throw new SchemaValidationError(`Invalid ${what} response from server`, result.error);
+  }
+  return result.data;
+}
+async function createVersion(artifacts, options = {}) {
+  const declared = parse10(DeclareVersionResponseSchema, await (await post("versions", {
+    static_bundle: artifacts.files.map(({ path, size, digest }) => ({
+      path,
+      size,
+      digest
+    })),
+    entities: artifacts.entities,
+    agents: artifacts.agents,
+    source_commit: options.sourceCommit,
+    frontend_commit: options.sourceCommit
+  }, "declaring a version")).json(), "declare");
+  options.progress?.onDeclared?.({
+    fileCount: artifacts.files.length,
+    owedFiles: declared.uploads.length
+  });
+  await uploadPresignedAssets(declared.uploads, {
+    manifest: Object.fromEntries(artifacts.files.map((file) => [
+      file.path,
+      { hash: file.digest, size: file.size }
+    ])),
+    filesByHash: new Map(artifacts.files.map((file) => [
+      file.digest,
+      {
+        absolutePath: file.absolutePath,
+        hash: file.digest,
+        size: file.size,
+        contentType: "application/octet-stream"
+      }
+    ]))
+  }, {
+    concurrency: options.concurrency ?? DEFAULT_VERSION_UPLOAD_CONCURRENCY,
+    onProgress: options.progress?.onUpload
+  });
+  return parse10(CreateVersionResponseSchema, await (await post(`versions/${encodeURIComponent(declared.sessionId)}/finalize`, {}, "creating a version")).json(), "create version");
+}
+async function deployVersion(versionId, options = {}) {
+  return parse10(DeployVersionResponseSchema, await (await post(`versions/${encodeURIComponent(versionId)}/deployments`, {
+    ...options.target ? { target: options.target } : {},
+    ...options.idempotencyKey ? { idempotency_key: options.idempotencyKey } : {}
+  }, "deploying a version")).json(), "deploy");
+}
+
+// src/core/version/publish.ts
+var STEP = Symbol.for("base44.publishStep");
+async function tagStep(step, run) {
+  try {
+    return await run();
+  } catch (error) {
+    if (error !== null && typeof error === "object" && !(STEP in error)) {
+      Object.defineProperty(error, STEP, { value: step, enumerable: false });
+    }
+    throw error;
+  }
+}
+function stepOf(error) {
+  return error !== null && typeof error === "object" && STEP in error ? error[STEP] : undefined;
+}
+async function publishVersion(artifacts, options = {}) {
+  const version = await tagStep("create_version", () => createVersion(artifacts, {
+    sourceCommit: options.sourceCommit,
+    concurrency: options.concurrency,
+    progress: options.progress
+  }));
+  const deployment = await tagStep("deploy", () => deployVersion(version.versionId, {
+    target: options.target,
+    idempotencyKey: randomUUID4()
+  }));
+  return { ...version, ...deployment };
+}
+
 // src/cli/utils/command/Base44Command.ts
 function writeJsonSuccess(result) {
   if (result.stdout) {
@@ -247009,6 +247149,10 @@ function writeJsonError(error) {
   const envelope = {
     error: error instanceof Error ? error.message : String(error)
   };
+  const step = stepOf(error);
+  if (step !== undefined) {
+    envelope.step = step;
+  }
   if (isCLIError(error)) {
     envelope.code = error.code;
     if (error.details.length > 0) {
@@ -249260,33 +249404,154 @@ async function maybeAskToBuild(isNonInteractive, buildCommand) {
   });
   return !Ct(answer) && answer;
 }
-
+// src/core/version/artifacts.ts
+import { createHash as createHash2 } from "node:crypto";
+import { createReadStream as createReadStream3 } from "node:fs";
+import { stat as stat3 } from "node:fs/promises";
+import { basename as basename5, join as join26 } from "node:path";
+var MAX_FILE_COUNT = 1e5;
+var ASSETS_IGNORE_FILE2 = ".assetsignore";
+var ALWAYS_IGNORED2 = new Set([
+  ASSETS_IGNORE_FILE2,
+  "wrangler.json",
+  ".dev.vars"
+]);
+var ENTRY2 = "index.html";
+async function digestFile(absolutePath) {
+  const hash = createHash2("sha256");
+  for await (const chunk of createReadStream3(absolutePath)) {
+    hash.update(chunk);
+  }
+  return `sha256:${hash.digest("hex")}`;
+}
+async function collectBuildOutput(outputDir) {
+  const found = await globby("**/*", {
+    cwd: outputDir,
+    dot: true,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    ignoreFiles: [ASSETS_IGNORE_FILE2]
+  });
+  const relativePaths = found.filter((path) => !ALWAYS_IGNORED2.has(basename5(path))).sort();
+  if (relativePaths.length === 0) {
+    throw new InvalidInputError(`No files found in ${outputDir}. Build the site before creating a version.`, {
+      hints: [
+        { message: "Run 'base44 build' first", command: "base44 build" }
+      ]
+    });
+  }
+  if (relativePaths.length > MAX_FILE_COUNT) {
+    throw new InvalidInputError(`Too many files: found ${relativePaths.length}, the limit is ${MAX_FILE_COUNT}.`);
+  }
+  if (!relativePaths.includes(ENTRY2)) {
+    throw new InvalidInputError(`${outputDir} has no ${ENTRY2}, so nothing could enter the site.`);
+  }
+  return await Promise.all(relativePaths.map(async (path) => {
+    const absolutePath = join26(outputDir, ...path.split("/"));
+    const { size } = await stat3(absolutePath);
+    return {
+      path,
+      absolutePath,
+      size,
+      digest: await digestFile(absolutePath)
+    };
+  }));
+}
+async function readRawResources(dir) {
+  if (!await pathExists(dir)) {
+    return {};
+  }
+  const files = await globby(`**/*.${CONFIG_FILE_EXTENSION_GLOB}`, {
+    cwd: dir,
+    onlyFiles: true,
+    followSymbolicLinks: false
+  });
+  const payloads = {};
+  for (const relativePath of files.sort()) {
+    const name = relativePath.replace(/\.jsonc?$/, "");
+    payloads[name] = await readJsonFile(join26(dir, ...relativePath.split("/")));
+  }
+  return payloads;
+}
+async function collectResources(configDir, dirs) {
+  const [entities, agents] = await Promise.all([
+    readRawResources(join26(configDir, dirs.entitiesDir)),
+    readRawResources(join26(configDir, dirs.agentsDir))
+  ]);
+  return { entities, agents };
+}
+// src/core/version/gate.ts
+var VERSIONS_API_ENV = "BASE44_VERSIONS_API";
+function versionsApiEnabled(env = process.env) {
+  const value = env[VERSIONS_API_ENV];
+  return value === "1" || value === "true";
+}
+// src/core/version/project.ts
+import { dirname as dirname19, join as join27, resolve as resolve10 } from "node:path";
+var DEFAULT_BUILD_COMMAND = "npm run build";
+var DEFAULT_OUTPUT_DIRECTORY = "dist";
+async function resolvePublishTarget(projectRoot, overrides = {}) {
+  const project = await readSettingsIfPresent(projectRoot);
+  const root = project?.root ?? projectRoot ?? process.cwd();
+  return {
+    root,
+    configDir: project ? dirname19(project.configPath) : join27(root, PROJECT_SUBDIR),
+    buildCommand: project ? project.site?.buildCommand : DEFAULT_BUILD_COMMAND,
+    outputDir: outputDirectory(project, root, overrides.outputDir),
+    entitiesDir: project?.entitiesDir ?? "entities",
+    agentsDir: project?.agentsDir ?? "agents"
+  };
+}
+function outputDirectory(project, root, override) {
+  const configured = override ?? (project ? project.site?.outputDirectory : DEFAULT_OUTPUT_DIRECTORY);
+  return configured ? resolve10(root, configured) : null;
+}
+function requireOutputDir(target) {
+  if (target.outputDir === null) {
+    throw new ConfigNotFoundError("No site configuration found.", {
+      hints: [
+        {
+          message: `Add 'site.outputDirectory' to your config.jsonc (e.g., "site": { "outputDirectory": "dist" })`
+        },
+        { message: `Or pass --output-dir <dir>, relative to ${target.root}` }
+      ]
+    });
+  }
+  return target.outputDir;
+}
+async function readSettingsIfPresent(projectRoot) {
+  try {
+    return await readProjectSettings(projectRoot);
+  } catch (error) {
+    if (error instanceof ConfigNotFoundError) {
+      return null;
+    }
+    throw error;
+  }
+}
 // src/cli/commands/project/build.ts
 async function buildAction(ctx) {
   const { app } = ctx;
-  if (!app?.projectRoot) {
-    throw new ConfigInvalidError("base44 build requires a linked local project. Run it from a project with base44/.app.jsonc.");
-  }
-  const { project } = await readProjectConfig(app.projectRoot);
+  const target = await resolvePublishTarget(app?.projectRoot);
   await runSiteBuild(ctx, {
-    root: project.root,
-    buildCommand: project.site?.buildCommand,
-    appId: app.id
+    root: target.root,
+    buildCommand: target.buildCommand,
+    appId: app?.id ?? ""
   });
   return {
-    outroMessage: `Site built with app id ${theme.styles.bold(app.id)}`
+    outroMessage: `Site built with app id ${theme.styles.bold(app?.id ?? "")}`
   };
 }
 function getBuildCommand() {
-  return new Base44Command("build").description("Build the site with the Base44 app id injected").action(buildAction);
+  return new Base44Command("build", { requireAuth: false }).description("Build the site with the Base44 app id injected").action(buildAction);
 }
 
 // src/cli/commands/project/create.ts
-import { basename as basename5, resolve as resolve10 } from "node:path";
+import { basename as basename6, resolve as resolve11 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
 
 // src/cli/commands/project/scaffold-shared.ts
-import { join as join26 } from "node:path";
+import { join as join28 } from "node:path";
 var DEFAULT_TEMPLATE_ID = "backend-only";
 async function getTemplateById(templateId) {
   const templates = await listTemplates();
@@ -249349,7 +249614,7 @@ async function completeProjectSetup({
           env: { VITE_BASE44_APP_ID: projectId }
         })`${buildCommand}`;
         updateMessage("Deploying site...");
-        return await deploySite(join26(resolvedPath, outputDirectory));
+        return await deploySite(join28(resolvedPath, outputDirectory));
       }, {
         successMessage: theme.colors.base44Orange("Site deployed successfully"),
         errorMessage: "Failed to deploy site"
@@ -249447,8 +249712,8 @@ async function createInteractive(options, ctx) {
     name: () => {
       return options.name ? Promise.resolve(options.name) : Ze({
         message: "What is the name of your project?",
-        placeholder: basename5(process.cwd()),
-        initialValue: basename5(process.cwd()),
+        placeholder: basename6(process.cwd()),
+        initialValue: basename6(process.cwd()),
         validate: (value) => {
           if (!value || value.trim().length === 0) {
             return "Every project deserves a name";
@@ -249478,7 +249743,7 @@ async function createInteractive(options, ctx) {
   }, ctx);
 }
 async function createNonInteractive(options, ctx) {
-  ctx.log.info(`Creating a new project at ${resolve10(options.path)}`);
+  ctx.log.info(`Creating a new project at ${resolve11(options.path)}`);
   const template = await getTemplateById(options.template ?? DEFAULT_TEMPLATE_ID);
   return await executeCreate({
     template,
@@ -249502,7 +249767,7 @@ async function executeCreate({
 }, ctx) {
   const { log, runTask } = ctx;
   const name = rawName.trim();
-  const resolvedPath = resolve10(projectPath);
+  const resolvedPath = resolve11(projectPath);
   const organizationId = await resolveWorkspaceId(ctx, flagWorkspaceId, isInteractive);
   const { projectId } = await runTask("Setting up your project...", async () => {
     return await createProjectFiles({
@@ -250117,11 +250382,11 @@ async function logsAction(ctx, options) {
 function getLogsCommand() {
   return new Base44Command("logs").description("Fetch function logs for this app").option("--function <names>", "Filter by function name(s), comma-separated. If omitted, fetches logs for all deployed functions").option("--since <datetime>", "Show logs from this time. ISO datetime or relative shorthand (e.g. 1h, 30m, 2d)", normalizeDatetime).option("--until <datetime>", "Show logs until this time. ISO datetime or relative shorthand (e.g. 1h, 30m, 2d)", normalizeDatetime).addOption(new Option2("--level <level>", "Filter by log level").choices([
     ...LogLevelSchema.options
-  ])).option("-n, --limit <n>", "Results per page (1-1000; the server returns at most 500)").option("-f, --follow", "Stream new logs as they arrive").addOption(new Option2("--order <order>", "Sort order").choices(["asc", "desc"])).addOption(new Option2("--env <env>", "Which deployment to read logs from: preview (current draft) or prod (published). Omit to read both.").choices([...LogEnvSchema.options])).action(logsAction);
+  ])).option("-n, --limit <n>", "Results per page (1-1000; the server returns at most 500)").option("-f, --follow", "Stream new logs as they arrive").addOption(new Option2("--order <order>", "Sort order").choices(["asc", "desc"])).addOption(new Option2("--env <env>", "Which deployment to read logs from: preview (current draft) or prod (published). Default: preview").choices([...LogEnvSchema.options])).action(logsAction);
 }
 
 // src/cli/commands/project/scaffold.ts
-import { basename as basename6, resolve as resolve11 } from "node:path";
+import { basename as basename7, resolve as resolve12 } from "node:path";
 function resolveAppId(options) {
   const appId = options.appId;
   if (!appId) {
@@ -250137,8 +250402,8 @@ function resolveAppId(options) {
 async function scaffoldAction(ctx, name, options, command) {
   const { log, runTask } = ctx;
   const appId = resolveAppId(command.optsWithGlobals());
-  const resolvedPath = resolve11("./");
-  const projectName = (name ?? basename6(resolvedPath)).trim();
+  const resolvedPath = resolve12("./");
+  const projectName = (name ?? basename7(resolvedPath)).trim();
   const template = await getTemplateById("backend-only");
   log.info(`Scaffolding project at ${resolvedPath}`);
   const { projectId } = await runTask("Setting up your project...", async () => {
@@ -250185,6 +250450,62 @@ function getVisibilityCommand() {
   ])).action(setVisibility);
 }
 
+// src/cli/commands/publish.ts
+async function publishAction(ctx, options) {
+  const { runTask, log, jsonMode, app } = ctx;
+  const target = await resolvePublishTarget(app?.projectRoot, {
+    outputDir: options.outputDir
+  });
+  if (options.build !== false) {
+    await tagStep("build", () => runSiteBuild(ctx, {
+      root: target.root,
+      buildCommand: target.buildCommand,
+      appId: app?.id ?? ""
+    }));
+  }
+  const outputDir = requireOutputDir(target);
+  const gitHash = await resolveProvenanceCommit(target.root, options.gitHash);
+  const result = await runTask("Publishing...", async (updateMessage) => {
+    const artifacts = {
+      files: await collectBuildOutput(outputDir),
+      ...await collectResources(target.configDir, target)
+    };
+    return await publishVersion(artifacts, {
+      sourceCommit: gitHash,
+      target: options.target,
+      concurrency: options.concurrency,
+      progress: {
+        onDeclared: ({ fileCount, owedFiles }) => updateMessage(`Uploading ${owedFiles} of ${fileCount} files`),
+        onUpload: ({ uploadedFiles, totalFiles }) => updateMessage(`Uploaded ${uploadedFiles} of ${totalFiles} files`)
+      }
+    });
+  }, { successMessage: "Published", errorMessage: "Publish failed" });
+  if (!jsonMode) {
+    log.message(theme.styles.dim(`version ${result.versionId}${result.deduplicated ? " (existing content)" : ""}`));
+  }
+  return {
+    outroMessage: `Deployment ${result.deploymentId} at revision ${result.revision}`,
+    stdout: jsonMode ? `${JSON.stringify(result, null, 2)}
+` : undefined
+  };
+}
+function getPublishCommand() {
+  return new Base44Command("publish").description("Build the app, record it as a version, and serve that version").option("--no-build", "Publish the existing build output without rebuilding").option("--output-dir <dir>", "Build output directory (defaults to the project's, else dist)").option("--target <name>", "Environment to serve the version at").addOption(new Option2("--git-hash <hash>", "Commit the build came from (defaults to the checkout's HEAD)").argParser(parseGitHash)).addOption(new Option2("--concurrency <n>", "Parallel file uploads").default(DEFAULT_VERSION_UPLOAD_CONCURRENCY).argParser(parseConcurrency)).action(publishAction);
+}
+function parseGitHash(value) {
+  if (!isGitCommitHash(value)) {
+    throw new InvalidArgumentError2("Expected a git commit hash (7-64 hex chars).");
+  }
+  return value;
+}
+function parseConcurrency(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_VERSION_UPLOAD_CONCURRENCY) {
+    throw new InvalidArgumentError2(`Expected a whole number between 1 and ${MAX_VERSION_UPLOAD_CONCURRENCY}.`);
+  }
+  return parsed;
+}
+
 // src/core/resources/sandbox/schema.ts
 var FileErrorSchema = object({
   code: string2(),
@@ -250554,7 +250875,7 @@ function getSecretsListCommand() {
 }
 
 // src/cli/commands/secrets/set.ts
-import { resolve as resolve12 } from "node:path";
+import { resolve as resolve13 } from "node:path";
 function parseEntries(entries) {
   const secrets = {};
   for (const entry of entries) {
@@ -250585,7 +250906,7 @@ async function setSecretsAction({ log, runTask }, entries, options) {
   validateInput(entries, options);
   let secrets;
   if (options.envFile) {
-    secrets = await parseEnvFile(resolve12(options.envFile));
+    secrets = await parseEnvFile(resolve13(options.envFile));
     if (Object.keys(secrets).length === 0) {
       throw new InvalidInputError("The env file contains no valid KEY=VALUE entries.");
     }
@@ -250614,7 +250935,7 @@ function getSecretsCommand() {
 }
 
 // src/cli/commands/site/deploy.ts
-import { resolve as resolve13 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 async function deployAction2(ctx, options) {
   const { isNonInteractive } = ctx;
   if (isNonInteractive && !options.yes) {
@@ -250692,23 +251013,23 @@ async function deployTarball({ runTask }, project) {
 }
 function siteOutputDir(project) {
   const outputDirectory = project.site?.outputDirectory;
-  return outputDirectory ? resolve13(project.root, outputDirectory) : null;
+  return outputDirectory ? resolve14(project.root, outputDirectory) : null;
 }
 function getSiteDeployCommand() {
   const command = new Base44Command("deploy").description("Deploy built site files to Base44 hosting").option("-y, --yes", "Skip confirmation prompt").option("--build", "Build the site before deploying (skips the prompt)").option("--no-build", "Deploy without building (skips the prompt)");
   if (deploymentsApiEnabled()) {
-    command.addOption(new Option2("--git-hash <hash>", "Commit the build came from (defaults to the checkout's HEAD)").argParser(parseGitHash));
-    command.addOption(new Option2("--concurrency <n>", "Parallel asset uploads").default(DEFAULT_UPLOAD_CONCURRENCY).argParser(parseConcurrency));
+    command.addOption(new Option2("--git-hash <hash>", "Commit the build came from (defaults to the checkout's HEAD)").argParser(parseGitHash2));
+    command.addOption(new Option2("--concurrency <n>", "Parallel asset uploads").default(DEFAULT_UPLOAD_CONCURRENCY).argParser(parseConcurrency2));
   }
   return command.action(deployAction2);
 }
-function parseGitHash(value) {
+function parseGitHash2(value) {
   if (!isGitCommitHash(value)) {
     throw new InvalidArgumentError2("Expected a git commit hash (7-64 hex chars).");
   }
   return value;
 }
-function parseConcurrency(value) {
+function parseConcurrency2(value) {
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_UPLOAD_CONCURRENCY) {
     throw new InvalidArgumentError2(`Expected a whole number between 1 and ${MAX_UPLOAD_CONCURRENCY}.`);
@@ -250820,10 +251141,10 @@ function toPascalCase(name) {
   return name.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
 }
 // src/core/types/update-project.ts
-import { join as join29 } from "node:path";
+import { join as join31 } from "node:path";
 var TYPES_INCLUDE_PATH = `${PROJECT_SUBDIR}/${TYPES_OUTPUT_SUBDIR}/*.d.ts`;
 async function updateProjectConfig(projectRoot) {
-  const tsconfigPath = join29(projectRoot, "tsconfig.json");
+  const tsconfigPath = join31(projectRoot, "tsconfig.json");
   if (!await pathExists(tsconfigPath)) {
     return false;
   }
@@ -250871,6 +251192,69 @@ function getTypesCommand() {
   return new Command2("types").description("Manage TypeScript type generation").addCommand(getTypesGenerateCommand());
 }
 
+// src/cli/commands/versions/create.ts
+async function createAction2({ runTask, jsonMode, app }, options) {
+  const target = await resolvePublishTarget(app?.projectRoot, {
+    outputDir: options.outputDir
+  });
+  const gitHash = await resolveProvenanceCommit(target.root, options.gitHash);
+  const version = await runTask("Creating version...", async (updateMessage) => await createVersion({
+    files: await collectBuildOutput(requireOutputDir(target)),
+    ...await collectResources(target.configDir, target)
+  }, {
+    sourceCommit: gitHash,
+    concurrency: options.concurrency,
+    progress: {
+      onDeclared: ({ fileCount, owedFiles }) => updateMessage(`Uploading ${owedFiles} of ${fileCount} files`),
+      onUpload: ({ uploadedFiles, totalFiles }) => updateMessage(`Uploaded ${uploadedFiles} of ${totalFiles} files`)
+    }
+  }), {
+    successMessage: "Version created",
+    errorMessage: "Create version failed"
+  });
+  return {
+    outroMessage: `Version ${version.versionId} (${version.manifestHash})`,
+    stdout: jsonMode ? `${JSON.stringify(version, null, 2)}
+` : undefined
+  };
+}
+function getVersionCreateCommand() {
+  return new Base44Command("create").description("Record the built output as a version, without deploying it").option("--output-dir <dir>", "Build output directory (defaults to the project's, else dist)").addOption(new Option2("--git-hash <hash>", "Commit the build came from (defaults to the checkout's HEAD)").argParser((value) => {
+    if (!isGitCommitHash(value)) {
+      throw new InvalidArgumentError2("Expected a git commit hash (7-64 hex chars).");
+    }
+    return value;
+  })).addOption(new Option2("--concurrency <n>", "Parallel file uploads").default(DEFAULT_VERSION_UPLOAD_CONCURRENCY).argParser((value) => {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_VERSION_UPLOAD_CONCURRENCY) {
+      throw new InvalidArgumentError2(`Expected a whole number between 1 and ${MAX_VERSION_UPLOAD_CONCURRENCY}.`);
+    }
+    return parsed;
+  })).action(createAction2);
+}
+
+// src/cli/commands/versions/deploy.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+async function deployAction3({ runTask, jsonMode }, versionId, options) {
+  const deployment = await runTask(`Deploying version ${versionId}...`, async () => await deployVersion(versionId, {
+    target: options.target,
+    idempotencyKey: randomUUID5()
+  }), { successMessage: "Version deployed", errorMessage: "Deploy failed" });
+  return {
+    outroMessage: `Deployment ${deployment.deploymentId} at revision ${deployment.revision}`,
+    stdout: jsonMode ? `${JSON.stringify(deployment, null, 2)}
+` : undefined
+  };
+}
+function getVersionDeployCommand() {
+  return new Base44Command("deploy").description("Serve an already-recorded version (also how a rollback is done)").argument("<version-id>", "The version to serve").option("--target <name>", "Environment to serve the version at").action(deployAction3);
+}
+
+// src/cli/commands/versions/index.ts
+function getVersionsCommand() {
+  return new Command2("versions").description("Record app versions and serve them").addCommand(getVersionCreateCommand()).addCommand(getVersionDeployCommand());
+}
+
 // src/core/resources/workflow/schema.ts
 var WorkflowRunStatusSchema = _enum([
   "running",
@@ -251287,7 +251671,7 @@ function createDevLogger(label, labelColor = theme.styles.dim) {
 // src/cli/dev/dev-server/main.ts
 var import_cors = __toESM(require_lib4(), 1);
 var import_express6 = __toESM(require_express(), 1);
-import { dirname as dirname24, join as join35 } from "node:path";
+import { dirname as dirname25, join as join37 } from "node:path";
 
 // ../../node_modules/get-port/index.js
 import net from "node:net";
@@ -251417,7 +251801,7 @@ var $tmpName = promisify11(tmp.tmpName);
 
 // src/cli/dev/dev-server/function-manager.ts
 import { spawn as spawn2 } from "node:child_process";
-import { dirname as dirname21, join as join30 } from "node:path";
+import { dirname as dirname22, join as join33 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/cli/dev/dev-server/base-function-manager.ts
@@ -251522,7 +251906,7 @@ class FunctionManager extends BaseFunctionManager {
   }
   spawnFunction(func, port) {
     this.logger.log(`Spawning function "${func.name}" on port ${port}`);
-    const importMapPath = join30(dirname21(this.wrapperPath), "import-map.json");
+    const importMapPath = join33(dirname22(this.wrapperPath), "import-map.json");
     const process2 = spawn2("deno", ["run", "--allow-all", "--import-map", importMapPath, this.wrapperPath], {
       env: {
         ...globalThis.process.env,
@@ -251596,7 +251980,7 @@ class FunctionManager extends BaseFunctionManager {
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { isBuiltin } from "node:module";
 import { homedir as homedir3 } from "node:os";
-import { join as join31 } from "node:path";
+import { join as join34 } from "node:path";
 import { pathToFileURL as pathToFileURL6 } from "node:url";
 var depsPromise;
 function loadDeps() {
@@ -251717,9 +252101,9 @@ export default {
 };
 `;
 function ensureBundlerConfig() {
-  const dir = join31(homedir3(), ".base44", "function-bundler");
+  const dir = join34(homedir3(), ".base44", "function-bundler");
   mkdirSync2(dir, { recursive: true });
-  const configPath = join31(dir, "deno.json");
+  const configPath = join34(dir, "deno.json");
   writeFileSync2(configPath, `${JSON.stringify({ nodeModulesDir: "auto" }, null, 2)}
 `);
   return configPath;
@@ -253100,11 +253484,11 @@ async function createEntityRoutes(db, logger, broadcast) {
 // src/cli/dev/dev-server/routes/integrations.ts
 var import_express5 = __toESM(require_express(), 1);
 var import_multer = __toESM(require_multer(), 1);
-import { createHash as createHash2, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID6 } from "node:crypto";
 import fs28 from "node:fs";
 import path18 from "node:path";
 function createFileToken(fileUri) {
-  return createHash2("sha256").update(fileUri).digest("hex");
+  return createHash3("sha256").update(fileUri).digest("hex");
 }
 function createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, logger) {
   const router = import_express5.Router({ mergeParams: true });
@@ -253117,14 +253501,14 @@ function createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, logger) {
     destination: mediaFilesDir,
     filename: (_req, file, cb) => {
       const ext = path18.extname(file.originalname);
-      cb(null, `${randomUUID4()}${ext}`);
+      cb(null, `${randomUUID6()}${ext}`);
     }
   });
   const privateStorage = import_multer.default.diskStorage({
     destination: privateFilesDir,
     filename: (_req, file, cb) => {
       const ext = path18.extname(file.originalname);
-      cb(null, `${randomUUID4()}${ext}`);
+      cb(null, `${randomUUID6()}${ext}`);
     }
   });
   const upload = import_multer.default({ storage, limits: { fileSize: MAX_FILE_SIZE } });
@@ -253194,11 +253578,11 @@ import { relative as relative7 } from "node:path";
 // ../../node_modules/chokidar/index.js
 import { EventEmitter as EventEmitter3 } from "node:events";
 import { stat as statcb, Stats } from "node:fs";
-import { readdir as readdir3, stat as stat6 } from "node:fs/promises";
+import { readdir as readdir3, stat as stat7 } from "node:fs/promises";
 import * as sp3 from "node:path";
 
 // ../../node_modules/readdirp/index.js
-import { lstat as lstat2, readdir as readdir2, realpath, stat as stat4 } from "node:fs/promises";
+import { lstat as lstat2, readdir as readdir2, realpath, stat as stat5 } from "node:fs/promises";
 import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "node:path";
 import { Readable as Readable6 } from "node:stream";
 var EntryTypes = {
@@ -253280,7 +253664,7 @@ class ReaddirpStream extends Readable6 {
     const { root, type } = opts;
     this._fileFilter = normalizeFilter(opts.fileFilter);
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
-    const statMethod = opts.lstat ? lstat2 : stat4;
+    const statMethod = opts.lstat ? lstat2 : stat5;
     if (wantBigintFsStats) {
       this._stat = (path) => statMethod(path, { bigint: true });
     } else {
@@ -253433,7 +253817,7 @@ function readdirp(root, options = {}) {
 
 // ../../node_modules/chokidar/handler.js
 import { watch as fs_watch, unwatchFile, watchFile } from "node:fs";
-import { realpath as fsrealpath, lstat as lstat3, open as open2, stat as stat5 } from "node:fs/promises";
+import { realpath as fsrealpath, lstat as lstat3, open as open2, stat as stat6 } from "node:fs/promises";
 import { type as osType } from "node:os";
 import * as sp2 from "node:path";
 var STR_DATA = "data";
@@ -253459,7 +253843,7 @@ var EVENTS = {
 };
 var EV = EVENTS;
 var THROTTLE_MODE_WATCH = "watch";
-var statMethods = { lstat: lstat3, stat: stat5 };
+var statMethods = { lstat: lstat3, stat: stat6 };
 var KEY_LISTENERS = "listeners";
 var KEY_ERR = "errHandlers";
 var KEY_RAW = "rawEmitters";
@@ -253930,7 +254314,7 @@ class NodeFsHandler {
         return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
-          const newStats = await stat5(file);
+          const newStats = await stat6(file);
           if (this.fsw.closed)
             return;
           const at = newStats.atimeMs;
@@ -254602,7 +254986,7 @@ class FSWatcher extends EventEmitter3 {
       const fullPath = opts.cwd ? sp3.join(opts.cwd, path) : path;
       let stats;
       try {
-        stats = await stat6(fullPath);
+        stats = await stat7(fullPath);
       } catch (err) {}
       if (!stats || this.closed)
         return;
@@ -254981,8 +255365,8 @@ async function createDevServer(options) {
     broadcastEntityEvent(io, appId, entityName, event);
   };
   const base44ConfigWatcher = new WatchBase44({
-    functions: join35(dirname24(project.configPath), project.functionsDir),
-    entities: join35(dirname24(project.configPath), project.entitiesDir)
+    functions: join37(dirname25(project.configPath), project.functionsDir),
+    entities: join37(dirname25(project.configPath), project.entitiesDir)
   }, devLogger);
   base44ConfigWatcher.on("change", async (name) => {
     try {
@@ -255379,7 +255763,7 @@ Examples:
 }
 
 // src/cli/commands/project/eject.ts
-import { resolve as resolve17 } from "node:path";
+import { resolve as resolve18 } from "node:path";
 var import_kebabCase2 = __toESM(require_kebabCase(), 1);
 async function eject(ctx, options, command) {
   const { log, runTask, isNonInteractive } = ctx;
@@ -255443,7 +255827,7 @@ async function eject(ctx, options, command) {
     Ne("Operation cancelled.");
     throw new CLIExitError(0);
   }
-  const resolvedPath = resolve17(selectedPath);
+  const resolvedPath = resolve18(selectedPath);
   await runTask("Downloading your project's code...", async (updateMessage) => {
     await createProjectFilesForExistingProject({
       projectId,
@@ -255526,6 +255910,10 @@ function createProgram(context) {
   program.addCommand(getBranchesCommand());
   program.addCommand(getAuthCommand());
   program.addCommand(getSiteCommand());
+  if (versionsApiEnabled()) {
+    program.addCommand(getPublishCommand());
+    program.addCommand(getVersionsCommand());
+  }
   program.addCommand(getTypesCommand());
   program.addCommand(getExecCommand());
   program.addCommand(getDevCommand());
@@ -255538,7 +255926,7 @@ var import_detect_agent = __toESM(require_dist5(), 1);
 import { release, type } from "node:os";
 
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname25, posix, sep as sep2 } from "path";
+import { dirname as dirname26, posix, sep as sep2 } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -255547,7 +255935,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname25(process.argv[1]) : process.cwd(), isWindows = sep2 === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname26(process.argv[1]) : process.cwd(), isWindows = sep2 === "\\") {
   const normalizedBase = isWindows ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -257582,7 +257970,7 @@ class ReduceableCache {
   }
 }
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/context-lines.node.mjs
-import { createReadStream as createReadStream3 } from "node:fs";
+import { createReadStream as createReadStream4 } from "node:fs";
 import { createInterface as createInterface2 } from "node:readline";
 var LRU_FILE_CONTENTS_CACHE = new ReduceableCache(25);
 var LRU_FILE_CONTENTS_FS_READ_FAILED = new ReduceableCache(20);
@@ -257626,7 +258014,7 @@ async function addSourceContext(frames) {
 }
 function getContextLinesFromFile(path, ranges, output) {
   return new Promise((resolve) => {
-    const stream = createReadStream3(path);
+    const stream = createReadStream4(path);
     const lineReaded = createInterface2({
       input: stream
     });
@@ -259536,9 +259924,9 @@ function addCommandInfoToErrorReporter(program, errorReporter) {
   });
 }
 // src/cli/index.ts
-var __dirname4 = dirname26(fileURLToPath6(import.meta.url));
+var __dirname4 = dirname27(fileURLToPath6(import.meta.url));
 async function runCLI(options) {
-  ensureNpmAssets(join36(__dirname4, "../assets"));
+  ensureNpmAssets(join38(__dirname4, "../assets"));
   const errorReporter = new ErrorReporter;
   errorReporter.registerProcessErrorHandlers();
   const jsonMode = process.argv.includes("--json");
@@ -259577,4 +259965,4 @@ export {
   runCLI
 };
 
-//# debugId=717552FD8532AC4A64756E2164756E21
+//# debugId=FEA39F6748E8A4DB64756E2164756E21