@base44-preview/cli 0.1.15-pr.626.d48e59b → 0.1.15-pr.626.da7a7d8

package/dist/cli/index.js

@@ -239635,6 +239635,16 @@ var MIME_TYPES = {
 function getAssetContentType(filePath) {
   return MIME_TYPES[extname(filePath).toLowerCase()] ?? "application/octet-stream";
 }
+async function walkBuildOutput(outputDir) {
+  const found = await globby("**/*", {
+    cwd: outputDir,
+    dot: true,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    ignoreFiles: [ASSETS_IGNORE_FILE]
+  });
+  return found.filter((path) => !ALWAYS_IGNORED.has(basename5(path))).sort();
+}
 async function hashAssetFile(appId, absolutePath) {
   const hash = createHash("sha256").update(Buffer.from(appId, "utf8"));
   for await (const chunk of createReadStream(absolutePath)) {
@@ -239645,18 +239655,11 @@ async function hashAssetFile(appId, absolutePath) {
 async function buildAssetManifest(assetsDir, appId) {
   const manifest = {};
   const filesByHash = new Map;
-  const found = await globby("**/*", {
-    cwd: assetsDir,
-    dot: true,
-    onlyFiles: true,
-    followSymbolicLinks: false,
-    ignoreFiles: [ASSETS_IGNORE_FILE]
-  });
-  const relativeFilePaths = found.filter((path) => !ALWAYS_IGNORED.has(basename5(path)));
+  const relativeFilePaths = await walkBuildOutput(assetsDir);
   if (relativeFilePaths.length > MAX_ASSET_COUNT) {
     throw new InvalidInputError(`Too many static assets: found ${relativeFilePaths.length}, the limit is ${MAX_ASSET_COUNT} files.`);
   }
-  for (const relativePath of relativeFilePaths.sort()) {
+  for (const relativePath of relativeFilePaths) {
     const absolutePath = join16(assetsDir, ...relativePath.split("/"));
     const { size } = await stat(absolutePath);
     const hash = await hashAssetFile(appId, absolutePath);
@@ -239994,7 +239997,10 @@ async function uploadPresignedAsset(upload, assets) {
   if (!file) {
     throw new InternalError(`Server requested upload of unknown asset path: ${upload.path}`);
   }
-  const content = await readFile2(file.absolutePath);
+  await putPresigned(upload, file.absolutePath);
+}
+async function putPresigned(upload, absolutePath) {
+  const content = await readFile2(absolutePath);
   try {
     await distribution_default.put(upload.url, {
       body: new Uint8Array(content),
@@ -247244,17 +247250,24 @@ var CreateVersionResponseSchema = object({
   versionId: data.version_id,
   manifestHash: data.manifest_hash
 }));
-var DeployVersionResponseSchema = object({
-  deployment_id: string2(),
-  manifest_hash: string2()
+var EnvironmentResponseSchema = object({
+  name: string2(),
+  version_id: string2(),
+  manifest_hash: string2(),
+  deployment_id: string2()
 }).transform((data) => ({
-  deploymentId: data.deployment_id,
-  manifestHash: data.manifest_hash
+  name: data.name,
+  versionId: data.version_id,
+  manifestHash: data.manifest_hash,
+  deploymentId: data.deployment_id
 }));
 
 // src/core/version/api.ts
 var DEFAULT_VERSION_UPLOAD_CONCURRENCY = 8;
 var MAX_VERSION_UPLOAD_CONCURRENCY = 16;
+function declaredFile({ path, size, digest }) {
+  return { path, size, digest };
+}
 async function post(path, json, doing) {
   try {
     return await getAppClient().post(path, { json, timeout: 180000 });
@@ -247262,6 +247275,13 @@ async function post(path, json, doing) {
     throw await ApiError.fromHttpError(error, doing);
   }
 }
+async function patch(path, json, doing) {
+  try {
+    return await getAppClient().patch(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) {
@@ -247271,49 +247291,51 @@ function parse10(schema, body, what) {
 }
 async function createVersion(artifacts, options = {}) {
   const declared = parse10(DeclareVersionResponseSchema, await (await post("versions", {
-    static_bundle: artifacts.files.map(({ path, size, digest }) => ({
-      path,
-      size,
-      digest
-    })),
+    static_bundle: artifacts.files.map(declaredFile),
+    ...artifacts.siteWorker ? {
+      site_worker: {
+        main: artifacts.siteWorker.main,
+        modules: artifacts.siteWorker.modules.map(declaredFile),
+        compatibility_date: artifacts.siteWorker.compatibilityDate,
+        compatibility_flags: artifacts.siteWorker.compatibilityFlags
+      }
+    } : {},
     entities: artifacts.entities,
     agents: artifacts.agents,
-    source_commit: options.sourceCommit,
-    frontend_commit: options.sourceCommit
+    source_commit: options.sourceCommit
   }, "declaring a version")).json(), "declare");
+  const declaredFiles = [
+    ...artifacts.files,
+    ...artifacts.siteWorker?.modules ?? []
+  ];
   options.progress?.onDeclared?.({
-    fileCount: artifacts.files.length,
+    fileCount: declaredFiles.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
-  });
+  if (declared.uploads.length !== declaredFiles.length) {
+    throw new InternalError(`Declared ${declaredFiles.length} files but the server signed ${declared.uploads.length} upload URLs.`);
+  }
+  let uploadedFiles = 0;
+  await pMap(declared.uploads, async (upload, index) => {
+    await putPresigned(upload, declaredFiles[index].absolutePath);
+    uploadedFiles++;
+    options.progress?.onUpload?.({
+      uploadedFiles,
+      totalFiles: declared.uploads.length
+    });
+  }, { concurrency: options.concurrency ?? DEFAULT_VERSION_UPLOAD_CONCURRENCY });
   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 } : {},
+async function setEnvironmentVersion(environment, versionId, options = {}) {
+  return parse10(EnvironmentResponseSchema, await (await patch(`environments/${encodeURIComponent(environment)}`, {
+    version_id: versionId,
     ...options.idempotencyKey ? { idempotency_key: options.idempotencyKey } : {}
-  }, "deploying a version")).json(), "deploy");
+  }, "setting the environment's version")).json(), "environment");
 }
 
 // src/core/version/publish.ts
 var STEP = Symbol.for("base44.publishStep");
+var DEFAULT_ENVIRONMENT = "production";
 async function tagStep(step, run) {
   try {
     return await run();
@@ -247333,11 +247355,15 @@ async function publishVersion(artifacts, options = {}) {
     concurrency: options.concurrency,
     progress: options.progress
   }));
-  const deployment = await tagStep("deploy", () => deployVersion(version.versionId, {
-    target: options.target,
+  const environment = await tagStep("deploy", () => setEnvironmentVersion(options.target ?? DEFAULT_ENVIRONMENT, version.versionId, {
     idempotencyKey: randomUUID4()
   }));
-  return { ...version, ...deployment };
+  return {
+    environment: environment.name,
+    versionId: environment.versionId,
+    manifestHash: environment.manifestHash,
+    deploymentId: environment.deploymentId
+  };
 }
 
 // src/cli/utils/command/Base44Command.ts
@@ -249707,14 +249733,9 @@ async function maybeAskToBuild(isNonInteractive, buildCommand) {
 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 basename6, join as join27 } 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"
-]);
+import { join as join27, resolve as resolve10 } from "node:path";
+var MAX_FILE_COUNT = 50000;
+var HASH_CONCURRENCY = 32;
 var ENTRY2 = "index.html";
 async function digestFile(absolutePath) {
   const hash = createHash2("sha256");
@@ -249724,14 +249745,7 @@ async function digestFile(absolutePath) {
   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(basename6(path))).sort();
+  const relativePaths = await walkBuildOutput(outputDir);
   if (relativePaths.length === 0) {
     throw new InvalidInputError(`No files found in ${outputDir}. Build the site before creating a version.`, {
       hints: [
@@ -249745,7 +249759,7 @@ async function collectBuildOutput(outputDir) {
   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) => {
+  return await pMap(relativePaths, async (path) => {
     const absolutePath = join27(outputDir, ...path.split("/"));
     const { size } = await stat3(absolutePath);
     return {
@@ -249754,7 +249768,32 @@ async function collectBuildOutput(outputDir) {
       size,
       digest: await digestFile(absolutePath)
     };
-  }));
+  }, { concurrency: HASH_CONCURRENCY });
+}
+async function collectSiteWorker(projectRoot) {
+  const redirectPath = await detectFullStackArtifact(projectRoot);
+  if (!redirectPath) {
+    return null;
+  }
+  const config = await resolveWranglerConfig(redirectPath);
+  const modules = await collectModules(config);
+  const entry = resolve10(config.configDir, config.main);
+  const main = modules.find((m) => m.absolutePath === entry)?.name;
+  if (!main) {
+    throw new InvalidInputError(`The Worker's entry module ${config.main} is not among the ${modules.length} modules collected from ${config.configDir}.`);
+  }
+  return {
+    main,
+    modules: await pMap(modules, async ({ name, absolutePath, size }) => ({
+      path: name,
+      absolutePath,
+      size,
+      digest: await digestFile(absolutePath)
+    }), { concurrency: HASH_CONCURRENCY }),
+    compatibilityDate: config.compatibilityDate,
+    compatibilityFlags: config.compatibilityFlags,
+    assetsDir: config.assetsDirectory && await pathExists(config.assetsDirectory) ? config.assetsDirectory : null
+  };
 }
 async function readRawResources(dir) {
   if (!await pathExists(dir)) {
@@ -249786,7 +249825,7 @@ function versionsApiEnabled(env = process.env) {
   return value === "1" || value === "true";
 }
 // src/core/version/project.ts
-import { dirname as dirname21, join as join28, resolve as resolve10 } from "node:path";
+import { dirname as dirname21, join as join28, resolve as resolve11 } from "node:path";
 var DEFAULT_BUILD_COMMAND = "npm run build";
 var DEFAULT_OUTPUT_DIRECTORY = "dist";
 async function resolvePublishTarget(projectRoot, overrides = {}) {
@@ -249803,7 +249842,7 @@ async function resolvePublishTarget(projectRoot, overrides = {}) {
 }
 function outputDirectory(project, root, override) {
   const configured = override ?? (project ? project.site?.outputDirectory : DEFAULT_OUTPUT_DIRECTORY);
-  return configured ? resolve10(root, configured) : null;
+  return configured ? resolve11(root, configured) : null;
 }
 function requireOutputDir(target) {
   if (target.outputDir === null) {
@@ -249846,7 +249885,7 @@ function getBuildCommand() {
 }
 
 // src/cli/commands/project/create.ts
-import { basename as basename7, resolve as resolve11 } from "node:path";
+import { basename as basename6, resolve as resolve12 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
 
 // src/cli/commands/project/scaffold-shared.ts
@@ -250011,8 +250050,8 @@ async function createInteractive(options, ctx) {
     name: () => {
       return options.name ? Promise.resolve(options.name) : Ze({
         message: "What is the name of your project?",
-        placeholder: basename7(process.cwd()),
-        initialValue: basename7(process.cwd()),
+        placeholder: basename6(process.cwd()),
+        initialValue: basename6(process.cwd()),
         validate: (value) => {
           if (!value || value.trim().length === 0) {
             return "Every project deserves a name";
@@ -250042,7 +250081,7 @@ async function createInteractive(options, ctx) {
   }, ctx);
 }
 async function createNonInteractive(options, ctx) {
-  ctx.log.info(`Creating a new project at ${resolve11(options.path)}`);
+  ctx.log.info(`Creating a new project at ${resolve12(options.path)}`);
   const template = await getTemplateById(options.template ?? DEFAULT_TEMPLATE_ID);
   return await executeCreate({
     template,
@@ -250066,7 +250105,7 @@ async function executeCreate({
 }, ctx) {
   const { log, runTask } = ctx;
   const name = rawName.trim();
-  const resolvedPath = resolve11(projectPath);
+  const resolvedPath = resolve12(projectPath);
   const organizationId = await resolveWorkspaceId(ctx, flagWorkspaceId, isInteractive);
   const { projectId } = await runTask("Setting up your project...", async () => {
     return await createProjectFiles({
@@ -250707,7 +250746,7 @@ function getLogsCommand() {
 }
 
 // src/cli/commands/project/scaffold.ts
-import { basename as basename8, resolve as resolve12 } from "node:path";
+import { basename as basename7, resolve as resolve13 } from "node:path";
 function resolveAppId(options) {
   const appId = options.appId;
   if (!appId) {
@@ -250723,8 +250762,8 @@ function resolveAppId(options) {
 async function scaffoldAction(ctx, name, options, command) {
   const { log, runTask } = ctx;
   const appId = resolveAppId(command.optsWithGlobals());
-  const resolvedPath = resolve12("./");
-  const projectName = (name ?? basename8(resolvedPath)).trim();
+  const resolvedPath = resolve13("./");
+  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 () => {
@@ -250809,13 +250848,17 @@ async function publishAction(ctx, options) {
       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)
-    };
+    const artifacts = await tagStep("create_version", async () => {
+      const siteWorker = await collectSiteWorker(target.root);
+      const outputDir = siteWorker?.assetsDir ?? requireOutputDir(target);
+      return {
+        files: await collectBuildOutput(outputDir),
+        ...siteWorker ? { siteWorker } : {},
+        ...await collectResources(target.configDir, target)
+      };
+    });
     return await publishVersion(artifacts, {
       sourceCommit: gitHash,
       target: options.target,
@@ -250830,7 +250873,7 @@ async function publishAction(ctx, options) {
     log.message(theme.styles.dim(`version ${result.versionId}`));
   }
   return {
-    outroMessage: `Deployment ${result.deploymentId}`,
+    outroMessage: `${result.environment} now serves ${result.versionId}`,
     stdout: jsonMode ? `${JSON.stringify(result, null, 2)}
 ` : undefined
   };
@@ -251208,7 +251251,7 @@ function getSecretsListCommand() {
 }
 
 // src/cli/commands/secrets/set.ts
-import { resolve as resolve13 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 function parseEntries(entries) {
   const secrets = {};
   for (const entry of entries) {
@@ -251239,7 +251282,7 @@ async function setSecretsAction({ log, runTask }, entries, options) {
   validateInput(entries, options);
   let secrets;
   if (options.envFile) {
-    secrets = await parseEnvFile(resolve13(options.envFile));
+    secrets = await parseEnvFile(resolve14(options.envFile));
     if (Object.keys(secrets).length === 0) {
       throw new InvalidInputError("The env file contains no valid KEY=VALUE entries.");
     }
@@ -251268,7 +251311,7 @@ function getSecretsCommand() {
 }
 
 // src/cli/commands/site/deploy.ts
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve15 } from "node:path";
 async function deployAction2(ctx, options) {
   const { isNonInteractive } = ctx;
   if (isNonInteractive && !options.yes) {
@@ -251346,7 +251389,7 @@ async function deployTarball({ runTask }, project) {
 }
 function siteOutputDir(project) {
   const outputDirectory = project.site?.outputDirectory;
-  return outputDirectory ? resolve14(project.root, outputDirectory) : null;
+  return outputDirectory ? resolve15(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)");
@@ -251563,18 +251606,21 @@ function getVersionCreateCommand() {
 // 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,
+  const environment = options.target ?? DEFAULT_ENVIRONMENT;
+  const result = await runTask(`Pointing ${environment} at ${versionId}...`, async () => await setEnvironmentVersion(environment, versionId, {
     idempotencyKey: randomUUID5()
-  }), { successMessage: "Version deployed", errorMessage: "Deploy failed" });
+  }), {
+    successMessage: "Environment updated",
+    errorMessage: "Could not update the environment"
+  });
   return {
-    outroMessage: `Deployment ${deployment.deploymentId}`,
-    stdout: jsonMode ? `${JSON.stringify(deployment, null, 2)}
+    outroMessage: `${result.name} now serves ${result.versionId}`,
+    stdout: jsonMode ? `${JSON.stringify(result, 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").addOption(targetOption()).action(deployAction3);
+  return new Base44Command("deploy").description("Point an environment at an already-recorded version (also the rollback)").argument("<version-id>", "The version to serve").option("--target <name>", "Environment to point at it").action(deployAction3);
 }
 
 // src/cli/commands/versions/index.ts
@@ -256095,7 +256141,7 @@ Examples:
 }
 
 // src/cli/commands/project/eject.ts
-import { resolve as resolve18 } from "node:path";
+import { resolve as resolve19 } from "node:path";
 var import_kebabCase2 = __toESM(require_kebabCase(), 1);
 async function eject(ctx, options, command) {
   const { log, runTask, isNonInteractive } = ctx;
@@ -256159,7 +256205,7 @@ async function eject(ctx, options, command) {
     Ne("Operation cancelled.");
     throw new CLIExitError(0);
   }
-  const resolvedPath = resolve18(selectedPath);
+  const resolvedPath = resolve19(selectedPath);
   await runTask("Downloading your project's code...", async (updateMessage) => {
     await createProjectFilesForExistingProject({
       projectId,
@@ -260298,4 +260344,4 @@ export {
   runCLI
 };
 
-//# debugId=2D4CD02B7197620F64756E2164756E21
+//# debugId=1EF49975E5A11DC264756E2164756E21