@base44-preview/cli 0.1.33-pr.667.b65bd0b → 0.2.0-pr.671.556605b

package/dist/cli/index.js

@@ -239376,7 +239376,7 @@ import { join as join13 } from "node:path";
 // package.json
 var package_default = {
   name: "base44",
-  version: "0.1.33",
+  version: "0.2.0",
   description: "Base44 CLI - Unified interface for managing Base44 applications",
   type: "module",
   bin: {
@@ -239681,6 +239681,21 @@ async function finalizeDeployment(deploymentId, sessionId, payload) {
   }
   return result.data;
 }
+async function publishDeployment(gitHash) {
+  const appClient = getAppClient();
+  try {
+    await appClient.post("deploy", {
+      json: { git_commit_hash: gitHash },
+      timeout: 120000
+    });
+  } catch (error) {
+    throw await ApiError.fromHttpError(error, "publishing deployment");
+  }
+  const appUrl = await getSiteUrl().catch(() => {
+    return;
+  });
+  return { gitHash, appUrl };
+}
 // src/core/site/config.ts
 async function getSiteFilePaths(outputDir) {
   return await globby("**/*", {
@@ -240264,11 +240279,6 @@ async function putPresignedBody(upload, body) {
 
 // src/core/site/deployment.ts
 var NO_ASSETS = { manifest: {}, filesByHash: new Map };
-var DEPLOYMENTS_API_ENV = "BASE44_DEPLOYMENTS_API";
-function deploymentsApiEnabled(env = process.env) {
-  const value = env[DEPLOYMENTS_API_ENV];
-  return value === "1" || value === "true";
-}
 async function deployToDeployments(options) {
   const { projectRoot, outputDir, gitHash, concurrency, progress } = options;
   const worker = await resolveWorkerBuild(projectRoot, progress);
@@ -246843,22 +246853,21 @@ function isGitCommitHash(value) {
 }
 
 // src/core/site/git-hash.ts
-async function resolveGitHash(projectRoot, explicit) {
-  const hash = explicit ?? await gitHead(projectRoot);
-  if (!hash || !isGitCommitHash(hash)) {
-    throw new InvalidInputError(explicit ? `'${explicit}' is not a git commit hash.` : "Deployments are addressed by the commit that produced the build, and no git commit was found.", {
-      hints: [
-        {
-          message: "Run the deploy from a git checkout, or pass the commit explicitly with --git-hash."
-        }
-      ]
-    });
-  }
-  return hash;
+function workerBuildNeedsGitHashError() {
+  return new InvalidInputError("A full-stack build deploys by the commit that produced it, and none was given.", {
+    hints: [
+      {
+        message: "Pass it with --git-hash, e.g. --git-hash $(git rev-parse HEAD)."
+      }
+    ]
+  });
 }
 async function resolveProvenanceCommit(projectRoot, explicit) {
   if (explicit) {
-    return await resolveGitHash(projectRoot, explicit);
+    if (!isGitCommitHash(explicit)) {
+      throw new InvalidInputError(`'${explicit}' is not a git commit hash.`);
+    }
+    return explicit;
   }
   const hash = await gitHead(projectRoot);
   return hash && isGitCommitHash(hash) ? hash : undefined;
@@ -246874,7 +246883,7 @@ async function gitHead(projectRoot) {
   }
 }
 // src/core/project/deploy.ts
-function hasResourcesToDeploy(projectData) {
+async function hasResourcesToDeploy(projectData) {
   const {
     project,
     entities,
@@ -246885,7 +246894,7 @@ function hasResourcesToDeploy(projectData) {
     connectors,
     authConfig
   } = projectData;
-  const hasSite = Boolean(project.site?.outputDirectory);
+  const hasSite = Boolean(project.site?.outputDirectory) || Boolean(await detectFullStackArtifact(project.root));
   const hasEntities = entities.length > 0;
   const hasFunctions = functions.length > 0;
   const hasActors = actors.length > 0;
@@ -246907,6 +246916,9 @@ async function deployAll(projectData, options) {
     connectors,
     authConfig
   } = projectData;
+  if (!options?.gitHash && await detectFullStackArtifact(project.root)) {
+    throw workerBuildNeedsGitHashError();
+  }
   await setAppVisibility(project.visibility);
   if (project.visibility) {
     options?.onVisibilitySet?.(project.visibility);
@@ -246944,12 +246956,49 @@ async function deployAll(projectData, options) {
   await authConfigResource.push(authConfig);
   const skipConnectorSync = connectors.length === 0 && hasWorkspaceApiKeyAuth();
   const connectorResults = skipConnectorSync ? [] : (await pushConnectors(connectors)).results;
-  if (project.site?.outputDirectory) {
-    const outputDir = resolve5(project.root, project.site.outputDirectory);
-    const { appUrl } = await deploySite(outputDir);
-    return { appUrl, connectorResults };
+  const appUrl = await deployProjectSite(project, options);
+  return appUrl ? { appUrl, connectorResults } : { connectorResults };
+}
+async function deployProjectSite(project, options) {
+  const outputDirectory = project.site?.outputDirectory;
+  const outputDir = outputDirectory ? resolve5(project.root, outputDirectory) : null;
+  const gitHash = options?.gitHash;
+  if (gitHash && (outputDir || await detectFullStackArtifact(project.root))) {
+    return shipCommit(project.root, outputDir, gitHash, options);
+  }
+  if (!outputDir) {
+    return;
+  }
+  const { appUrl } = await deploySite(outputDir);
+  return appUrl;
+}
+async function shipCommit(projectRoot, outputDir, gitHash, options) {
+  await deployToDeployments({
+    projectRoot,
+    outputDir,
+    gitHash,
+    progress: {
+      onWarning: (message) => options?.onSiteProgress?.(message),
+      onAssets: ({ totalAssets, newAssets }) => options?.onSiteProgress?.(`Found ${totalAssets} static assets (${newAssets} new)`)
+    }
+  });
+  try {
+    const { appUrl } = await publishDeployment(gitHash);
+    return appUrl;
+  } catch (error) {
+    if (!publishesFromBuilder(error)) {
+      throw error;
+    }
+    options?.onSiteProgress?.("Site deployed. This app is published from the Base44 builder, so production was left where it was.");
+    return;
+  }
+}
+function publishesFromBuilder(error) {
+  if (!(error instanceof ApiError)) {
+    return false;
   }
-  return { connectorResults };
+  const body = error.responseBody;
+  return body?.error?.code === "git_commit_hash_not_supported";
 }
 // src/core/project/target.ts
 import { dirname as dirname13, join as join19, resolve as resolve6 } from "node:path";
@@ -247587,6 +247636,13 @@ function normalizeDatetime(value) {
     return value;
   return `${value}Z`;
 }
+// src/cli/utils/git-hash.ts
+function parseGitHash(value) {
+  if (!isGitCommitHash(value)) {
+    throw new InvalidArgumentError2("Expected a git commit hash (7-64 hex chars).");
+  }
+  return value;
+}
 // src/cli/utils/json.ts
 function toJsonStdout(result, options = {}) {
   return `${JSON.stringify(result, null, options.compact ? undefined : 2)}
@@ -251942,7 +251998,7 @@ async function deployAction(ctx, options = {}) {
     throw new InvalidInputError("--yes is required in non-interactive mode");
   }
   const projectData = await readProjectConfig(options.projectRoot);
-  if (!hasResourcesToDeploy(projectData)) {
+  if (!await hasResourcesToDeploy(projectData)) {
     return {
       outroMessage: "No resources found to deploy"
     };
@@ -252001,6 +252057,10 @@ ${summaryLines.join(`
   const functionTotal = functions.length;
   let actorCompleted = 0;
   const result = await deployAll(projectData, {
+    gitHash: options.gitHash,
+    onSiteProgress: (message) => {
+      log.message(theme.styles.dim(message));
+    },
     onVisibilitySet: (level) => {
       log.success(`App visibility set to ${level}`);
     },
@@ -252036,7 +252096,7 @@ ${summaryLines.join(`
   return { outroMessage: "App deployed successfully" };
 }
 function getDeployCommand3() {
-  return new Base44Command("deploy").description("Deploy all project resources (entities, functions, actors, agents, connectors, and site)").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)").action(deployAction);
+  return new Base44Command("deploy").description("Deploy all project resources (entities, functions, actors, agents, connectors, and site)").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)").addOption(new Option2("--git-hash <hash>", "Deploy by the commit the build came from, through the deployments API").argParser(parseGitHash)).action(deployAction);
 }
 async function handleOAuthConnectors(connectorResults, isNonInteractive, options, log) {
   const needsOAuth = filterPendingOAuth(connectorResults);
@@ -262868,64 +262928,6 @@ function logEvent(level, event, fields = {}) {
   sink(level, event, fields);
 }
 
-// ../functions-compiler/src/fetch-guard.ts
-var ALLOWED_HOST_SUFFIXES = ["npmjs.org", "jsr.io", "esm.sh", "deno.land"];
-var MAX_RESPONSE_BYTES = 30 * 1024 * 1024;
-function requestUrl(input) {
-  if (input instanceof URL)
-    return input;
-  if (typeof input === "string")
-    return new URL(input);
-  return new URL(input.url);
-}
-function isDependencyHost(hostname) {
-  return ALLOWED_HOST_SUFFIXES.some((suffix) => hostname === suffix || hostname.endsWith(`.${suffix}`));
-}
-
-// ../functions-compiler/src/dependency-fetch-retry.ts
-var RETRY_DELAYS_MS = [250, 1000];
-var installed = false;
-function installDependencyFetchRetry() {
-  if (installed)
-    return;
-  installed = true;
-  globalThis.fetch = createRetryingFetch(globalThis.fetch.bind(globalThis));
-}
-function createRetryingFetch(originalFetch, delaysMs = RETRY_DELAYS_MS) {
-  return async (input, init) => {
-    const url = requestUrl(input);
-    const method = init?.method ?? (input instanceof Request ? input.method : "GET");
-    if (method.toUpperCase() !== "GET" || !isDependencyHost(url.hostname)) {
-      return originalFetch(input, init);
-    }
-    for (let attempt = 0;; attempt++) {
-      const delay = delaysMs[attempt];
-      let response;
-      let error;
-      try {
-        response = await originalFetch(input, init);
-        if (response.status !== 429 && response.status < 500)
-          return response;
-      } catch (err) {
-        error = err;
-      }
-      logEvent(delay === undefined ? "error" : "warn", "base44.bundler.dependency_fetch_failed", {
-        url: url.href,
-        attempt: attempt + 1,
-        http_status: response?.status,
-        error: response ? undefined : String(error?.cause ?? error)
-      });
-      if (delay === undefined) {
-        if (response)
-          return response;
-        throw error;
-      }
-      await response?.body?.cancel();
-      await new Promise((resolve) => setTimeout(resolve, delay));
-    }
-  };
-}
-
 // ../functions-compiler/src/esbuild/deno-resolver.ts
 var NAMESPACES = ["file", "http", "https", "data", "npm", "jsr"];
 var RESOLVE_NAMESPACES = [...NAMESPACES, USER_NAMESPACE];
@@ -262934,7 +262936,6 @@ function denoResolverPlugin(options = {}) {
   return {
     name: "deno-resolver",
     async setup(build) {
-      installDependencyFetchRetry();
       deno = await lazyDenoLoader();
       const baseDir = options.configPath ? path20.dirname(options.configPath) : undefined;
       const depRoots = [denoCacheRoot(), baseDir].filter((d) => Boolean(d)).map(canonicalPath);
@@ -263799,6 +263800,8 @@ function denoCompatErrorOrThrow(e) {
 function denoCompatErrorItem(e) {
   return { message: e.message, file: e.file };
 }
+// ../functions-compiler/src/fetch-guard.ts
+var MAX_RESPONSE_BYTES = 30 * 1024 * 1024;
 // ../functions-compiler/src/static-egress-marker.ts
 var STATIC_EGRESS_ARTIFACT_MARKER = "base44.static-egress.request-env.v2";
 
@@ -264278,12 +264281,7 @@ function targetOption() {
   return new Option2("--target <name>", "Environment to serve the version at");
 }
 function gitHashOption() {
-  return 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;
-  });
+  return new Option2("--git-hash <hash>", "Commit the build came from (defaults to the checkout's HEAD)").argParser(parseGitHash);
 }
 function concurrencyOption() {
   return new Option2("--concurrency <n>", "Parallel file uploads").default(DEFAULT_VERSION_UPLOAD_CONCURRENCY).argParser((value) => {
@@ -264795,17 +264793,24 @@ async function deployAction2(ctx, options) {
       return { outroMessage: "Deployment cancelled" };
     }
   }
-  return deploymentsApiEnabled() ? await deployToDeploymentsApi(ctx, project, options) : await deployTarball(ctx, project);
+  return deployToDeploymentsApi(ctx, project, options);
 }
 async function deployToDeploymentsApi(ctx, project, options) {
   const { runTask, log, jsonMode } = ctx;
   const projectRoot = project.root;
-  const gitHash = await resolveGitHash(projectRoot, options.gitHash);
+  const outputDir = siteOutputDir(project);
+  const gitHash = options.gitHash;
+  if (!gitHash) {
+    if (await detectFullStackArtifact(projectRoot)) {
+      throw workerBuildNeedsGitHashError();
+    }
+    return deployArchive(ctx, outputDir);
+  }
   const progressLines = [];
   const warnings = [];
   const { deploymentId } = await runTask("Deploying site...", async (updateMessage) => await deployToDeployments({
     projectRoot,
-    outputDir: siteOutputDir(project),
+    outputDir,
     gitHash,
     concurrency: options.concurrency,
     progress: {
@@ -264831,37 +264836,35 @@ async function deployToDeploymentsApi(ctx, project, options) {
   for (const warning of warnings) {
     log.warn(warning);
   }
+  const published = options.publish ? await runTask("Publishing site...", async () => await publishDeployment(gitHash), { successMessage: "Site published", errorMessage: "Publish failed" }) : undefined;
+  if (published?.appUrl) {
+    log.message(`${theme.styles.header("App URL")}: ${theme.colors.links(published.appUrl)}`);
+  } else if (!published) {
+    log.info("Not published: production still serves its previous build. Run again with --publish to serve this one.");
+  }
   return {
     outroMessage: `Deployment ${deploymentId} (commit ${gitHash.slice(0, 12)})`,
-    stdout: jsonMode ? `${JSON.stringify({ deploymentId, gitHash }, null, 2)}
+    stdout: jsonMode ? `${JSON.stringify({ deploymentId, gitHash, published: Boolean(published) }, null, 2)}
 ` : undefined
   };
 }
-async function deployTarball({ runTask }, project) {
-  const outputDir = siteOutputDir(project);
+async function deployArchive({ runTask, jsonMode }, outputDir) {
   const { appUrl } = await runTask("Creating archive and deploying site...", async () => await deploySite(outputDir), {
     successMessage: "Site deployed successfully",
     errorMessage: "Deployment failed"
   });
-  return { outroMessage: `Visit your site at: ${appUrl}` };
+  return {
+    outroMessage: `Visit your site at: ${appUrl}`,
+    stdout: jsonMode ? `${JSON.stringify({ appUrl, published: true }, null, 2)}
+` : undefined
+  };
 }
 function siteOutputDir(project) {
   const { outputDirectory = DEFAULT_SITE.outputDirectory } = siteOrDefault(project);
   return resolve16(project.root, outputDirectory);
 }
 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));
-  }
-  return command.action(deployAction2);
-}
-function parseGitHash(value) {
-  if (!isGitCommitHash(value)) {
-    throw new InvalidArgumentError2("Expected a git commit hash (7-64 hex chars).");
-  }
-  return value;
+  return 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)").option("--publish", "Serve this build in production once it is deployed").addOption(new Option2("--git-hash <hash>", "Deploy by the commit the build came from, through the deployments API").argParser(parseGitHash)).addOption(new Option2("--concurrency <n>", "Parallel asset uploads").default(DEFAULT_UPLOAD_CONCURRENCY).argParser(parseConcurrency)).action(deployAction2);
 }
 function parseConcurrency(value) {
   const parsed = Number(value);
@@ -274006,4 +274009,4 @@ export {
   runCLI
 };
 
-//# debugId=41D501CA10C9A0AA64756E2164756E21
+//# debugId=B539C7BB9AAE429D64756E2164756E21