@base44-preview/cli 0.1.7-pr.585.a27bb8a → 0.1.7-pr.585.ca3aebe

package/dist/cli/index.js

@@ -23352,15 +23352,15 @@ var require_windows = __commonJS((exports, module) => {
     }
     return false;
   }
-  function checkStat(stat, path11, options) {
-    if (!stat.isSymbolicLink() && !stat.isFile()) {
+  function checkStat(stat2, path11, options) {
+    if (!stat2.isSymbolicLink() && !stat2.isFile()) {
       return false;
     }
     return checkPathExt(path11, options);
   }
   function isexe(path11, options, cb) {
-    fs14.stat(path11, function(er, stat) {
-      cb(er, er ? false : checkStat(stat, path11, options));
+    fs14.stat(path11, function(er, stat2) {
+      cb(er, er ? false : checkStat(stat2, path11, options));
     });
   }
   function sync(path11, options) {
@@ -23374,20 +23374,20 @@ var require_mode = __commonJS((exports, module) => {
   isexe.sync = sync;
   var fs14 = __require("fs");
   function isexe(path11, options, cb) {
-    fs14.stat(path11, function(er, stat) {
-      cb(er, er ? false : checkStat(stat, options));
+    fs14.stat(path11, function(er, stat2) {
+      cb(er, er ? false : checkStat(stat2, options));
     });
   }
   function sync(path11, options) {
     return checkStat(fs14.statSync(path11), options);
   }
-  function checkStat(stat, options) {
-    return stat.isFile() && checkMode(stat, options);
+  function checkStat(stat2, options) {
+    return stat2.isFile() && checkMode(stat2, options);
   }
-  function checkMode(stat, options) {
-    var mod = stat.mode;
-    var uid = stat.uid;
-    var gid = stat.gid;
+  function checkMode(stat2, options) {
+    var mod = stat2.mode;
+    var uid = stat2.uid;
+    var gid = stat2.gid;
     var myUid = options.uid !== undefined ? options.uid : process.getuid && process.getuid();
     var myGid = options.gid !== undefined ? options.gid : process.getgid && process.getgid();
     var u = parseInt("100", 8);
@@ -23419,12 +23419,12 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve3, reject) {
+      return new Promise(function(resolve4, reject) {
         isexe(path11, options || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve3(is);
+            resolve4(is);
           }
         });
       });
@@ -23486,27 +23486,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i) => new Promise((resolve3, reject) => {
+    const step = (i) => new Promise((resolve4, reject) => {
       if (i === pathEnv.length)
-        return opt.all && found.length ? resolve3(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve4(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
       const pCmd = path11.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve3(subStep(p, i, 0));
+      resolve4(subStep(p, i, 0));
     });
-    const subStep = (p, i, ii) => new Promise((resolve3, reject) => {
+    const subStep = (p, i, ii) => new Promise((resolve4, reject) => {
       if (ii === pathExt.length)
-        return resolve3(step(i + 1));
+        return resolve4(step(i + 1));
       const ext = pathExt[ii];
       isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p + ext);
           else
-            return resolve3(p + ext);
+            return resolve4(p + ext);
         }
-        return resolve3(subStep(p, i, ii + 1));
+        return resolve4(subStep(p, i, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -248113,6 +248113,7 @@ var package_default = {
     nanoid: "^5.1.6",
     open: "^11.0.0",
     outdent: "^0.8.0",
+    "p-map": "^7.0.6",
     "p-wait-for": "^6.0.0",
     "posthog-node": "5.21.2",
     qs: "^6.12.3",
@@ -248258,7 +248259,7 @@ async function createProjectFilesForExistingProject(options) {
   };
 }
 // src/core/project/deploy.ts
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 
 // src/core/site/api.ts
 async function uploadSite(archivePath) {
@@ -248361,13 +248362,576 @@ async function createArchive(pathToArchive, targetArchivePath) {
     cwd: pathToArchive
   }, ["."]);
 }
-// src/core/site/deploy-app.ts
-import { resolve as resolve3 } from "node:path";
-
+// src/core/site/manifest.ts
+import { createHash } from "node:crypto";
+import { readFile as readFile2, stat } from "node:fs/promises";
+import { basename as basename4, join as join15 } from "node:path";
+var MAX_ASSET_SIZE_BYTES = 25 * 1024 * 1024;
+var MAX_ASSET_COUNT = 1e5;
+var ASSETS_IGNORE_FILE = ".assetsignore";
+var ALWAYS_IGNORED = new Set([
+  ASSETS_IGNORE_FILE,
+  "wrangler.json",
+  ".dev.vars"
+]);
+function hashAsset(appId, content) {
+  return createHash("sha256").update(Buffer.from(appId, "utf8")).update(content).digest("hex").slice(0, 32);
+}
+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((path11) => !ALWAYS_IGNORED.has(basename4(path11)));
+  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()) {
+    const absolutePath = join15(assetsDir, ...relativePath.split("/"));
+    const { size } = await stat(absolutePath);
+    if (size > MAX_ASSET_SIZE_BYTES) {
+      throw new InvalidInputError(`Static asset "${relativePath}" is ${size} bytes, which exceeds the 25 MiB per-file limit.`);
+    }
+    const content = await readFile2(absolutePath);
+    const hash2 = hashAsset(appId, content);
+    manifest[`/${relativePath}`] = { hash: hash2, size };
+    if (!filesByHash.has(hash2)) {
+      filesByHash.set(hash2, { absolutePath, hash: hash2, size });
+    }
+  }
+  return { manifest, filesByHash };
+}
 // src/core/site/static-site.ts
 import { readFile as readFile4 } from "node:fs/promises";
 import { join as join16 } from "node:path";
 
+// src/core/site/upload.ts
+import { readFile as readFile3 } from "node:fs/promises";
+
+// ../../node_modules/p-map/index.js
+async function pMap(iterable, mapper, {
+  concurrency = Number.POSITIVE_INFINITY,
+  stopOnError = true,
+  signal
+} = {}) {
+  return new Promise((resolve_, reject_) => {
+    if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+      throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
+    }
+    if (typeof mapper !== "function") {
+      throw new TypeError("Mapper function is required");
+    }
+    if (!(Number.isSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) {
+      throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
+    }
+    const result = [];
+    const errors4 = [];
+    const skippedIndexesMap = new Map;
+    let isRejected = false;
+    let isResolved = false;
+    let isIterableDone = false;
+    let resolvingCount = 0;
+    let currentIndex = 0;
+    const iterator = iterable[Symbol.iterator] === undefined ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
+    const signalListener = () => {
+      reject(signal.reason);
+    };
+    const cleanup = () => {
+      signal?.removeEventListener("abort", signalListener);
+    };
+    const resolve3 = (value) => {
+      resolve_(value);
+      cleanup();
+    };
+    const reject = (reason) => {
+      isRejected = true;
+      isResolved = true;
+      reject_(reason);
+      cleanup();
+    };
+    if (signal) {
+      if (signal.aborted) {
+        reject(signal.reason);
+        return;
+      }
+      signal.addEventListener("abort", signalListener, { once: true });
+    }
+    const next = async () => {
+      if (isResolved) {
+        return;
+      }
+      const nextItem = await iterator.next();
+      const index = currentIndex;
+      currentIndex++;
+      if (nextItem.done) {
+        isIterableDone = true;
+        if (resolvingCount === 0 && !isResolved) {
+          if (!stopOnError && errors4.length > 0) {
+            reject(new AggregateError(errors4));
+            return;
+          }
+          isResolved = true;
+          if (skippedIndexesMap.size === 0) {
+            resolve3(result);
+            return;
+          }
+          const pureResult = [];
+          for (const [index2, value] of result.entries()) {
+            if (skippedIndexesMap.get(index2) === pMapSkip) {
+              continue;
+            }
+            pureResult.push(value);
+          }
+          resolve3(pureResult);
+        }
+        return;
+      }
+      resolvingCount++;
+      (async () => {
+        try {
+          const element = await nextItem.value;
+          if (isResolved) {
+            return;
+          }
+          const value = await mapper(element, index);
+          if (value === pMapSkip) {
+            skippedIndexesMap.set(index, value);
+          }
+          result[index] = value;
+          resolvingCount--;
+          await next();
+        } catch (error48) {
+          if (stopOnError) {
+            reject(error48);
+          } else {
+            errors4.push(error48);
+            resolvingCount--;
+            try {
+              await next();
+            } catch (error49) {
+              reject(error49);
+            }
+          }
+        }
+      })();
+    };
+    (async () => {
+      for (let index = 0;index < concurrency; index++) {
+        try {
+          await next();
+        } catch (error48) {
+          reject(error48);
+          break;
+        }
+        if (isIterableDone || isRejected) {
+          break;
+        }
+      }
+    })();
+  });
+}
+var pMapSkip = Symbol("skip");
+
+// src/core/site/upload.ts
+var DEFAULT_UPLOAD_CONCURRENCY = 3;
+var MAX_UPLOAD_CONCURRENCY = 50;
+var MAX_UPLOAD_ATTEMPTS = 3;
+var RETRY_BASE_DELAY_MS = 500;
+async function uploadPresignedAssets(uploads, assets, options = {}) {
+  const { concurrency = DEFAULT_UPLOAD_CONCURRENCY, onProgress } = options;
+  let uploadedFiles = 0;
+  await pMap(uploads, async (upload) => {
+    await uploadPresignedAsset(upload, assets);
+    uploadedFiles++;
+    onProgress?.({ uploadedFiles, totalFiles: uploads.length });
+  }, { concurrency });
+}
+async function uploadPresignedAsset(upload, assets) {
+  const entry = assets.manifest[upload.path];
+  const file2 = entry && assets.filesByHash.get(entry.hash);
+  if (!file2) {
+    throw new InternalError(`Server requested upload of unknown asset path: ${upload.path}`);
+  }
+  const content = await readFile3(file2.absolutePath);
+  try {
+    await distribution_default.put(upload.url, {
+      body: new Uint8Array(content),
+      headers: { "Content-Type": upload.contentType },
+      timeout: 120000,
+      retry: {
+        limit: MAX_UPLOAD_ATTEMPTS - 1,
+        delay: (attempt) => RETRY_BASE_DELAY_MS * 2 ** (attempt - 1)
+      }
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "uploading static assets");
+  }
+}
+
+// src/core/site/static-site.ts
+async function deployStaticSite(options) {
+  const { outputDir, gitHash, concurrency, progress } = options;
+  const assets = await buildAssetManifest(outputDir, getAppContext().id);
+  if (!assets.manifest["/index.html"]) {
+    throw new InvalidInputError(`No index.html found in "${outputDir}" — a static site needs one at the output directory root.`);
+  }
+  const created = await createDeployment({
+    git_hash: gitHash,
+    asset_manifest: assets.manifest
+  });
+  progress?.onAssets?.({
+    totalAssets: Object.keys(assets.manifest).length,
+    newAssets: created.assetUploads?.uploads.length ?? 0
+  });
+  if (created.assetUploads) {
+    await uploadPresignedAssets(created.assetUploads.uploads, assets, {
+      concurrency,
+      onProgress: progress?.onAssetUpload
+    });
+  }
+  const indexHtml = await readFile4(join16(outputDir, "index.html"));
+  const finalized = await finalizeStaticDeployment(created.deploymentId, new Uint8Array(indexHtml));
+  return { deploymentId: finalized.deploymentId };
+}
+// src/core/project/deploy.ts
+function hasResourcesToDeploy(projectData) {
+  const {
+    project,
+    entities,
+    functions,
+    agents,
+    agentSkills,
+    connectors,
+    authConfig
+  } = projectData;
+  const hasSite = Boolean(project.site?.outputDirectory);
+  const hasEntities = entities.length > 0;
+  const hasFunctions = functions.length > 0;
+  const hasAgents = agents.length > 0;
+  const hasAgentSkills = agentSkills.length > 0;
+  const hasConnectors = connectors.length > 0;
+  const hasAuthConfig = authConfig.length > 0;
+  const hasVisibility = Boolean(project.visibility);
+  return hasEntities || hasFunctions || hasAgents || hasAgentSkills || hasConnectors || hasAuthConfig || hasVisibility || hasSite;
+}
+async function deployAll(projectData, options) {
+  const {
+    project,
+    entities,
+    functions,
+    agents,
+    agentSkills,
+    connectors,
+    authConfig
+  } = projectData;
+  await setAppVisibility(project.visibility);
+  if (project.visibility) {
+    options?.onVisibilitySet?.(project.visibility);
+  }
+  await entityResource.push(entities);
+  await deployFunctionsSequentially(functions, {
+    onStart: options?.onFunctionStart,
+    onResult: options?.onFunctionResult
+  });
+  await agentSkillResource.push(agentSkills);
+  await agentResource.push(agents);
+  await authConfigResource.push(authConfig);
+  const skipConnectorSync = connectors.length === 0 && hasWorkspaceApiKeyAuth();
+  const connectorResults = skipConnectorSync ? [] : (await pushConnectors(connectors)).results;
+  if (project.site?.outputDirectory) {
+    const outputDir = resolve3(project.root, project.site.outputDirectory);
+    const { appUrl } = await deploySite(outputDir);
+    return { appUrl, connectorResults };
+  }
+  return { connectorResults };
+}
+// src/core/clients/base44-client.ts
+var retriedRequests = new WeakSet;
+async function captureRequestBody(request, options) {
+  if (request.body == null) {
+    return;
+  }
+  try {
+    const cloned = request.clone();
+    const text = await cloned.text();
+    options.context.__requestBody = text;
+  } catch {}
+}
+async function handleUnauthorized(request, _options, response) {
+  if (response.status !== 401) {
+    return;
+  }
+  if (hasWorkspaceApiKeyAuth()) {
+    return;
+  }
+  if (retriedRequests.has(request)) {
+    return;
+  }
+  const newAccessToken = await refreshAndSaveTokens();
+  if (!newAccessToken) {
+    return;
+  }
+  retriedRequests.add(request);
+  const requestId = request.headers.get("X-Request-ID");
+  return distribution_default(request.clone(), {
+    headers: {
+      ...requestId && { "X-Request-ID": requestId },
+      Authorization: `Bearer ${newAccessToken}`
+    }
+  });
+}
+var base44Client = distribution_default.create({
+  prefixUrl: getBase44ApiUrl(),
+  headers: {
+    "User-Agent": "Base44 CLI"
+  },
+  hooks: {
+    beforeRequest: [
+      (request) => {
+        request.headers.set("X-Request-ID", randomUUID2());
+      },
+      captureRequestBody,
+      async (request) => {
+        const workspaceApiKey = getWorkspaceApiKeyFromEnv();
+        if (workspaceApiKey && isWorkspaceApiKey(workspaceApiKey)) {
+          request.headers.set("api_key", workspaceApiKey);
+          return;
+        }
+        try {
+          const auth = await readAuth();
+          if (isTokenExpired(auth)) {
+            const newAccessToken = await refreshAndSaveTokens();
+            if (newAccessToken) {
+              request.headers.set("Authorization", `Bearer ${newAccessToken}`);
+              return;
+            }
+          }
+          request.headers.set("Authorization", `Bearer ${auth.accessToken}`);
+        } catch {}
+      }
+    ],
+    afterResponse: [handleUnauthorized]
+  }
+});
+function getAppClient() {
+  const { id } = getAppContext();
+  return base44Client.extend({
+    prefixUrl: new URL(`/api/apps/${id}/`, getBase44ApiUrl()).href
+  });
+}
+function getSandboxClient(appId) {
+  return base44Client.extend({
+    prefixUrl: new URL(`/api/apps/${appId}/sandbox-bridge/`, getBase44ApiUrl()).href
+  });
+}
+// src/core/clients/oauth-client.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+var oauthClient = distribution_default.create({
+  prefixUrl: getBase44ApiUrl(),
+  headers: {
+    "User-Agent": "Base44 CLI"
+  },
+  hooks: {
+    beforeRequest: [
+      (request) => {
+        request.headers.set("X-Request-ID", randomUUID3());
+      }
+    ]
+  }
+});
+// src/core/auth/api.ts
+async function generateDeviceCode() {
+  const response = await oauthClient.post("oauth/device/code", {
+    json: {
+      client_id: AUTH_CLIENT_ID,
+      scope: "apps:read apps:write sandbox:write"
+    },
+    throwHttpErrors: false
+  });
+  if (!response.ok) {
+    throw new ApiError(`Failed to generate device code: ${response.status} ${response.statusText}`, { statusCode: response.status });
+  }
+  const result = DeviceCodeResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid device code response from server", result.error);
+  }
+  return result.data;
+}
+async function getTokenFromDeviceCode(deviceCode) {
+  const searchParams = new URLSearchParams;
+  searchParams.set("grant_type", "urn:ietf:params:oauth:grant-type:device_code");
+  searchParams.set("device_code", deviceCode);
+  searchParams.set("client_id", AUTH_CLIENT_ID);
+  const response = await oauthClient.post("oauth/token", {
+    body: searchParams.toString(),
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    throwHttpErrors: false
+  });
+  const json2 = await response.json();
+  if (!response.ok) {
+    const errorResult = OAuthErrorSchema.safeParse(json2);
+    if (!errorResult.success) {
+      throw new SchemaValidationError("Token request failed", errorResult.error);
+    }
+    const { error: error48, error_description } = errorResult.data;
+    if (error48 === "authorization_pending" || error48 === "slow_down") {
+      return null;
+    }
+    throw new ApiError(error_description ?? `OAuth error: ${error48}`, {
+      statusCode: response.status
+    });
+  }
+  const result = TokenResponseSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid token response from server", result.error);
+  }
+  return result.data;
+}
+async function renewAccessToken(refreshToken) {
+  const searchParams = new URLSearchParams;
+  searchParams.set("grant_type", "refresh_token");
+  searchParams.set("refresh_token", refreshToken);
+  searchParams.set("client_id", AUTH_CLIENT_ID);
+  const response = await oauthClient.post("oauth/token", {
+    body: searchParams.toString(),
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    throwHttpErrors: false
+  });
+  const json2 = await response.json();
+  if (!response.ok) {
+    const errorResult = OAuthErrorSchema.safeParse(json2);
+    if (!errorResult.success) {
+      throw new ApiError(`Token refresh failed: ${response.statusText}`, {
+        statusCode: response.status
+      });
+    }
+    const { error: error48, error_description } = errorResult.data;
+    throw new ApiError(error_description ?? `OAuth error: ${error48}`, {
+      statusCode: response.status
+    });
+  }
+  const result = TokenResponseSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid token response from server", result.error);
+  }
+  return result.data;
+}
+async function getUserInfo(accessToken) {
+  const response = await oauthClient.get("oauth/userinfo", {
+    headers: { Authorization: `Bearer ${accessToken}` }
+  });
+  if (!response.ok) {
+    throw new ApiError(`Failed to fetch user info: ${response.status}`, {
+      statusCode: response.status
+    });
+  }
+  const result = UserInfoSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid UserInfo response from server", result.error);
+  }
+  return result.data;
+}
+// src/cli/commands/auth/login-flow.ts
+async function generateAndDisplayDeviceCode(log, runTask) {
+  const deviceCodeResponse = await runTask("Generating device code...", async () => {
+    return await generateDeviceCode();
+  }, {
+    successMessage: "Device code generated",
+    errorMessage: "Failed to generate device code"
+  });
+  log.info(`Verification code: ${theme.styles.bold(deviceCodeResponse.userCode)}` + `
+Please confirm this code at: ${deviceCodeResponse.verificationUri}`);
+  return deviceCodeResponse;
+}
+async function waitForAuthentication(deviceCode, expiresIn, interval, runTask) {
+  let tokenResponse;
+  try {
+    await runTask("Waiting for authentication...", async () => {
+      await pWaitFor(async () => {
+        const result = await getTokenFromDeviceCode(deviceCode);
+        if (result !== null) {
+          tokenResponse = result;
+          return true;
+        }
+        return false;
+      }, {
+        interval: interval * 1000,
+        timeout: expiresIn * 1000
+      });
+    }, {
+      successMessage: "Authentication completed!",
+      errorMessage: "Authentication failed"
+    });
+  } catch (error48) {
+    if (error48 instanceof Error && error48.message.includes("timed out")) {
+      throw new AuthExpiredError("Authentication timed out. Please try again.");
+    }
+    throw error48;
+  }
+  if (tokenResponse === undefined) {
+    throw new InternalError("Failed to retrieve authentication token.");
+  }
+  return tokenResponse;
+}
+async function saveAuthData(response, userInfo) {
+  const expiresAt = Date.now() + response.expiresIn * 1000;
+  await writeAuth({
+    accessToken: response.accessToken,
+    refreshToken: response.refreshToken,
+    expiresAt,
+    email: userInfo.email,
+    name: userInfo.name
+  });
+}
+async function login({
+  log,
+  runTask
+}) {
+  const deviceCodeResponse = await generateAndDisplayDeviceCode(log, runTask);
+  const token = await waitForAuthentication(deviceCodeResponse.deviceCode, deviceCodeResponse.expiresIn, deviceCodeResponse.interval, runTask);
+  const userInfo = await getUserInfo(token.accessToken);
+  await saveAuthData(token, userInfo);
+  return {
+    outroMessage: `Successfully logged in as ${theme.styles.bold(userInfo.email)}`
+  };
+}
+
+// src/cli/utils/command/middleware.ts
+async function ensureAuth(ctx) {
+  if (hasWorkspaceApiKeyAuth()) {
+    ctx.errorReporter.setContext({
+      user: { email: "workspace-api-key", name: "Workspace API key" }
+    });
+    return;
+  }
+  await seedAuthFromEnv();
+  const loggedIn = await isLoggedIn();
+  if (!loggedIn) {
+    ctx.log.info("You need to login first to continue.");
+    await login(ctx);
+  }
+  try {
+    const userInfo = await readAuth();
+    ctx.errorReporter.setContext({
+      user: { email: userInfo.email, name: userInfo.name }
+    });
+  } catch {}
+}
+async function ensureAppContext(ctx, options = {}) {
+  const appContext = await initAppContext(options);
+  ctx.app = appContext;
+  ctx.errorReporter.setContext({ appId: appContext.id });
+}
+
 // ../../node_modules/is-plain-obj/index.js
 function isPlainObject2(value) {
   if (typeof value !== "object" || value === null) {
@@ -248465,13 +249029,13 @@ var getJoinLength = (uint8Arrays) => {
 var isTemplateString = (templates) => Array.isArray(templates) && Array.isArray(templates.raw);
 var parseTemplates = (templates, expressions) => {
   let tokens = [];
-  for (const [index, template] of templates.entries()) {
+  for (const [index, template2] of templates.entries()) {
     tokens = parseTemplate({
       templates,
       expressions,
       tokens,
       index,
-      template
+      template: template2
     });
   }
   if (tokens.length === 0) {
@@ -248480,11 +249044,11 @@ var parseTemplates = (templates, expressions) => {
   const [file2, ...commandArguments] = tokens;
   return [file2, commandArguments, {}];
 };
-var parseTemplate = ({ templates, expressions, tokens, index, template }) => {
-  if (template === undefined) {
+var parseTemplate = ({ templates, expressions, tokens, index, template: template2 }) => {
+  if (template2 === undefined) {
     throw new TypeError(`Invalid backslash sequence: ${templates.raw[index]}`);
   }
-  const { nextTokens, leadingWhitespaces, trailingWhitespaces } = splitByWhitespaces(template, templates.raw[index]);
+  const { nextTokens, leadingWhitespaces, trailingWhitespaces } = splitByWhitespaces(template2, templates.raw[index]);
   const newTokens = concatTokens(tokens, nextTokens, leadingWhitespaces);
   if (index === expressions.length) {
     return newTokens;
@@ -248493,18 +249057,18 @@ var parseTemplate = ({ templates, expressions, tokens, index, template }) => {
   const expressionTokens = Array.isArray(expression) ? expression.map((expression2) => parseExpression(expression2)) : [parseExpression(expression)];
   return concatTokens(newTokens, expressionTokens, trailingWhitespaces);
 };
-var splitByWhitespaces = (template, rawTemplate) => {
+var splitByWhitespaces = (template2, rawTemplate) => {
   if (rawTemplate.length === 0) {
     return { nextTokens: [], leadingWhitespaces: false, trailingWhitespaces: false };
   }
   const nextTokens = [];
   let templateStart = 0;
   const leadingWhitespaces = DELIMITERS.has(rawTemplate[0]);
-  for (let templateIndex = 0, rawIndex = 0;templateIndex < template.length; templateIndex += 1, rawIndex += 1) {
+  for (let templateIndex = 0, rawIndex = 0;templateIndex < template2.length; templateIndex += 1, rawIndex += 1) {
     const rawCharacter = rawTemplate[rawIndex];
     if (DELIMITERS.has(rawCharacter)) {
       if (templateStart !== templateIndex) {
-        nextTokens.push(template.slice(templateStart, templateIndex));
+        nextTokens.push(template2.slice(templateStart, templateIndex));
       }
       templateStart = templateIndex + 1;
     } else if (rawCharacter === "\\") {
@@ -248520,9 +249084,9 @@ var splitByWhitespaces = (template, rawTemplate) => {
       }
     }
   }
-  const trailingWhitespaces = templateStart === template.length;
+  const trailingWhitespaces = templateStart === template2.length;
   if (!trailingWhitespaces) {
-    nextTokens.push(template.slice(templateStart));
+    nextTokens.push(template2.slice(templateStart));
   }
   return { nextTokens, leadingWhitespaces, trailingWhitespaces };
 };
@@ -249916,8 +250480,8 @@ var disconnect = (anyProcess) => {
 // ../../node_modules/execa/lib/utils/deferred.js
 var createDeferred = () => {
   const methods = {};
-  const promise2 = new Promise((resolve3, reject) => {
-    Object.assign(methods, { resolve: resolve3, reject });
+  const promise2 = new Promise((resolve4, reject) => {
+    Object.assign(methods, { resolve: resolve4, reject });
   });
   return Object.assign(promise2, methods);
 };
@@ -254281,11 +254845,11 @@ var addConcurrentStream = (concurrentStreams, stream, waitName) => {
   const promises = weakMap.get(stream);
   const promise2 = createDeferred();
   promises.push(promise2);
-  const resolve3 = promise2.resolve.bind(promise2);
-  return { resolve: resolve3, promises };
+  const resolve4 = promise2.resolve.bind(promise2);
+  return { resolve: resolve4, promises };
 };
-var waitForConcurrentStreams = async ({ resolve: resolve3, promises }, subprocess) => {
-  resolve3();
+var waitForConcurrentStreams = async ({ resolve: resolve4, promises }, subprocess) => {
+  resolve4();
   const [isSubprocessExit] = await Promise.race([
     Promise.allSettled([true, subprocess]),
     Promise.all([false, ...promises])
@@ -254864,523 +255428,6 @@ var {
   getCancelSignal: getCancelSignal2
 } = getIpcExport();
 
-// src/core/utils/git.ts
-var GIT_HASH_PATTERN = /^[a-fA-F0-9]{7,64}$/;
-function isGitCommitHash(value) {
-  return GIT_HASH_PATTERN.test(value);
-}
-async function getGitHead(cwd) {
-  try {
-    const { stdout } = await execa("git", ["rev-parse", "HEAD"], { cwd });
-    return stdout.trim();
-  } catch {
-    return null;
-  }
-}
-
-// src/core/site/manifest.ts
-import { createHash } from "node:crypto";
-import { readFile as readFile2, stat } from "node:fs/promises";
-import { basename as basename4, join as join15 } from "node:path";
-var MAX_ASSET_SIZE_BYTES = 25 * 1024 * 1024;
-var MAX_ASSET_COUNT = 1e5;
-var ASSETS_IGNORE_FILE = ".assetsignore";
-var ALWAYS_IGNORED = new Set([
-  ASSETS_IGNORE_FILE,
-  "wrangler.json",
-  ".dev.vars"
-]);
-function hashAsset(appId, content) {
-  return createHash("sha256").update(Buffer.from(appId, "utf8")).update(content).digest("hex").slice(0, 32);
-}
-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((path16) => !ALWAYS_IGNORED.has(basename4(path16)));
-  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()) {
-    const absolutePath = join15(assetsDir, ...relativePath.split("/"));
-    const { size } = await stat(absolutePath);
-    if (size > MAX_ASSET_SIZE_BYTES) {
-      throw new InvalidInputError(`Static asset "${relativePath}" is ${size} bytes, which exceeds the 25 MiB per-file limit.`);
-    }
-    const content = await readFile2(absolutePath);
-    const hash2 = hashAsset(appId, content);
-    manifest[`/${relativePath}`] = { hash: hash2, size };
-    if (!filesByHash.has(hash2)) {
-      filesByHash.set(hash2, { absolutePath, hash: hash2, size });
-    }
-  }
-  return { manifest, filesByHash };
-}
-
-// src/core/site/upload.ts
-import { readFile as readFile3 } from "node:fs/promises";
-var UPLOAD_CONCURRENCY = 3;
-var MAX_ATTEMPTS_PER_UPLOAD = 3;
-var RETRY_BASE_DELAY_MS = 500;
-async function uploadPresignedAssets(uploads, assets, onProgress) {
-  let uploadedFiles = 0;
-  let nextUpload = 0;
-  const worker = async () => {
-    while (nextUpload < uploads.length) {
-      const upload = uploads[nextUpload++];
-      await uploadPresignedAssetWithRetry(upload, assets);
-      uploadedFiles++;
-      onProgress?.({ uploadedFiles, totalFiles: uploads.length });
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(UPLOAD_CONCURRENCY, uploads.length) }, worker));
-}
-async function uploadPresignedAssetWithRetry(upload, assets) {
-  const entry = assets.manifest[upload.path];
-  const file2 = entry && assets.filesByHash.get(entry.hash);
-  if (!file2) {
-    throw new InternalError(`Server requested upload of unknown asset path: ${upload.path}`);
-  }
-  const content = await readFile3(file2.absolutePath);
-  let lastError;
-  for (let attempt = 0;attempt < MAX_ATTEMPTS_PER_UPLOAD; attempt++) {
-    if (attempt > 0) {
-      await sleep3(RETRY_BASE_DELAY_MS * 2 ** (attempt - 1));
-    }
-    try {
-      await distribution_default.put(upload.url, {
-        body: new Uint8Array(content),
-        headers: { "Content-Type": upload.contentType },
-        timeout: 120000,
-        retry: 0
-      });
-      return;
-    } catch (error48) {
-      lastError = error48;
-    }
-  }
-  throw await ApiError.fromHttpError(lastError, "uploading static assets");
-}
-function sleep3(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
-}
-
-// src/core/site/static-site.ts
-async function deployStaticSite(options) {
-  const { outputDir, projectRoot, progress } = options;
-  const gitHash = await resolveGitHash(projectRoot, options.gitHash);
-  const assets = await buildAssetManifest(outputDir, getAppContext().id);
-  if (!assets.manifest["/index.html"]) {
-    throw new InvalidInputError(`No index.html found in "${outputDir}" — a static site needs one at the output directory root.`);
-  }
-  const created = await createDeployment({
-    git_hash: gitHash,
-    asset_manifest: assets.manifest
-  });
-  const totalAssets = Object.keys(assets.manifest).length;
-  progress?.onAssets?.({
-    totalAssets,
-    newAssets: created.assetUploads?.uploads.length ?? 0
-  });
-  if (created.assetUploads) {
-    await uploadPresignedAssets(created.assetUploads.uploads, assets, progress?.onAssetUpload);
-  }
-  const indexHtml = await readFile4(join16(outputDir, "index.html"));
-  const finalized = await finalizeStaticDeployment(created.deploymentId, new Uint8Array(indexHtml));
-  return { deploymentId: finalized.deploymentId, gitHash };
-}
-async function resolveGitHash(projectRoot, explicit) {
-  const hash2 = explicit ?? await getGitHead(projectRoot);
-  if (!hash2 || !isGitCommitHash(hash2)) {
-    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: base44 site deploy --git-hash <commit>."
-        }
-      ]
-    });
-  }
-  return hash2;
-}
-
-// src/core/site/deploy-app.ts
-function planAppDeploy(target, staticDeployments) {
-  const outputDirectory = target.site?.outputDirectory;
-  if (!outputDirectory) {
-    return { kind: "none" };
-  }
-  const outputDir = resolve3(target.root, outputDirectory);
-  return staticDeployments ? { kind: "static-deployment", outputDir } : { kind: "static", outputDir };
-}
-function detectAppDeployKind(target, options = {}) {
-  return planAppDeploy(target, options.staticDeployments ?? false).kind;
-}
-async function deployAppSite(target, options = {}) {
-  const plan = planAppDeploy(target, options.staticDeployments ?? false);
-  switch (plan.kind) {
-    case "static-deployment": {
-      const { deploymentId, gitHash } = await deployStaticSite({
-        outputDir: plan.outputDir,
-        projectRoot: target.root,
-        gitHash: options.gitHash,
-        progress: options.progress
-      });
-      return { kind: "static-deployment", deploymentId, gitHash };
-    }
-    case "static": {
-      const { appUrl } = await deploySite(plan.outputDir);
-      return { kind: "static", appUrl };
-    }
-    case "none":
-      return { kind: "none" };
-  }
-}
-// src/core/site/gate.ts
-var STATIC_DEPLOYMENTS_ENV = "BASE44_STATIC_DEPLOYMENTS";
-function staticDeploymentsEnabled(env2 = process.env) {
-  const value = env2[STATIC_DEPLOYMENTS_ENV];
-  return value === "1" || value === "true";
-}
-// src/core/project/deploy.ts
-function hasResourcesToDeploy(projectData) {
-  const {
-    project,
-    entities,
-    functions,
-    agents,
-    agentSkills,
-    connectors,
-    authConfig
-  } = projectData;
-  const hasSite = Boolean(project.site?.outputDirectory || project.site?.buildCommand);
-  const hasEntities = entities.length > 0;
-  const hasFunctions = functions.length > 0;
-  const hasAgents = agents.length > 0;
-  const hasAgentSkills = agentSkills.length > 0;
-  const hasConnectors = connectors.length > 0;
-  const hasAuthConfig = authConfig.length > 0;
-  const hasVisibility = Boolean(project.visibility);
-  return hasEntities || hasFunctions || hasAgents || hasAgentSkills || hasConnectors || hasAuthConfig || hasVisibility || hasSite;
-}
-async function deployAll(projectData, options) {
-  const {
-    project,
-    entities,
-    functions,
-    agents,
-    agentSkills,
-    connectors,
-    authConfig
-  } = projectData;
-  await setAppVisibility(project.visibility);
-  if (project.visibility) {
-    options?.onVisibilitySet?.(project.visibility);
-  }
-  await entityResource.push(entities);
-  await deployFunctionsSequentially(functions, {
-    onStart: options?.onFunctionStart,
-    onResult: options?.onFunctionResult
-  });
-  await agentSkillResource.push(agentSkills);
-  await agentResource.push(agents);
-  await authConfigResource.push(authConfig);
-  const skipConnectorSync = connectors.length === 0 && hasWorkspaceApiKeyAuth();
-  const connectorResults = skipConnectorSync ? [] : (await pushConnectors(connectors)).results;
-  if ((options?.site ?? true) && project.site?.outputDirectory) {
-    const outputDir = resolve4(project.root, project.site.outputDirectory);
-    const { appUrl } = await deploySite(outputDir);
-    return { appUrl, connectorResults };
-  }
-  return { connectorResults };
-}
-// src/core/clients/base44-client.ts
-var retriedRequests = new WeakSet;
-async function captureRequestBody(request, options) {
-  if (request.body == null) {
-    return;
-  }
-  try {
-    const cloned = request.clone();
-    const text = await cloned.text();
-    options.context.__requestBody = text;
-  } catch {}
-}
-async function handleUnauthorized(request, _options, response) {
-  if (response.status !== 401) {
-    return;
-  }
-  if (hasWorkspaceApiKeyAuth()) {
-    return;
-  }
-  if (retriedRequests.has(request)) {
-    return;
-  }
-  const newAccessToken = await refreshAndSaveTokens();
-  if (!newAccessToken) {
-    return;
-  }
-  retriedRequests.add(request);
-  const requestId = request.headers.get("X-Request-ID");
-  return distribution_default(request.clone(), {
-    headers: {
-      ...requestId && { "X-Request-ID": requestId },
-      Authorization: `Bearer ${newAccessToken}`
-    }
-  });
-}
-var base44Client = distribution_default.create({
-  prefixUrl: getBase44ApiUrl(),
-  headers: {
-    "User-Agent": "Base44 CLI"
-  },
-  hooks: {
-    beforeRequest: [
-      (request) => {
-        request.headers.set("X-Request-ID", randomUUID2());
-      },
-      captureRequestBody,
-      async (request) => {
-        const workspaceApiKey = getWorkspaceApiKeyFromEnv();
-        if (workspaceApiKey && isWorkspaceApiKey(workspaceApiKey)) {
-          request.headers.set("api_key", workspaceApiKey);
-          return;
-        }
-        try {
-          const auth = await readAuth();
-          if (isTokenExpired(auth)) {
-            const newAccessToken = await refreshAndSaveTokens();
-            if (newAccessToken) {
-              request.headers.set("Authorization", `Bearer ${newAccessToken}`);
-              return;
-            }
-          }
-          request.headers.set("Authorization", `Bearer ${auth.accessToken}`);
-        } catch {}
-      }
-    ],
-    afterResponse: [handleUnauthorized]
-  }
-});
-function getAppClient() {
-  const { id } = getAppContext();
-  return base44Client.extend({
-    prefixUrl: new URL(`/api/apps/${id}/`, getBase44ApiUrl()).href
-  });
-}
-function getSandboxClient(appId) {
-  return base44Client.extend({
-    prefixUrl: new URL(`/api/apps/${appId}/sandbox-bridge/`, getBase44ApiUrl()).href
-  });
-}
-// src/core/clients/oauth-client.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-var oauthClient = distribution_default.create({
-  prefixUrl: getBase44ApiUrl(),
-  headers: {
-    "User-Agent": "Base44 CLI"
-  },
-  hooks: {
-    beforeRequest: [
-      (request) => {
-        request.headers.set("X-Request-ID", randomUUID3());
-      }
-    ]
-  }
-});
-// src/core/auth/api.ts
-async function generateDeviceCode() {
-  const response = await oauthClient.post("oauth/device/code", {
-    json: {
-      client_id: AUTH_CLIENT_ID,
-      scope: "apps:read apps:write sandbox:write"
-    },
-    throwHttpErrors: false
-  });
-  if (!response.ok) {
-    throw new ApiError(`Failed to generate device code: ${response.status} ${response.statusText}`, { statusCode: response.status });
-  }
-  const result = DeviceCodeResponseSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid device code response from server", result.error);
-  }
-  return result.data;
-}
-async function getTokenFromDeviceCode(deviceCode) {
-  const searchParams = new URLSearchParams;
-  searchParams.set("grant_type", "urn:ietf:params:oauth:grant-type:device_code");
-  searchParams.set("device_code", deviceCode);
-  searchParams.set("client_id", AUTH_CLIENT_ID);
-  const response = await oauthClient.post("oauth/token", {
-    body: searchParams.toString(),
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    throwHttpErrors: false
-  });
-  const json2 = await response.json();
-  if (!response.ok) {
-    const errorResult = OAuthErrorSchema.safeParse(json2);
-    if (!errorResult.success) {
-      throw new SchemaValidationError("Token request failed", errorResult.error);
-    }
-    const { error: error48, error_description } = errorResult.data;
-    if (error48 === "authorization_pending" || error48 === "slow_down") {
-      return null;
-    }
-    throw new ApiError(error_description ?? `OAuth error: ${error48}`, {
-      statusCode: response.status
-    });
-  }
-  const result = TokenResponseSchema.safeParse(json2);
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid token response from server", result.error);
-  }
-  return result.data;
-}
-async function renewAccessToken(refreshToken) {
-  const searchParams = new URLSearchParams;
-  searchParams.set("grant_type", "refresh_token");
-  searchParams.set("refresh_token", refreshToken);
-  searchParams.set("client_id", AUTH_CLIENT_ID);
-  const response = await oauthClient.post("oauth/token", {
-    body: searchParams.toString(),
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    throwHttpErrors: false
-  });
-  const json2 = await response.json();
-  if (!response.ok) {
-    const errorResult = OAuthErrorSchema.safeParse(json2);
-    if (!errorResult.success) {
-      throw new ApiError(`Token refresh failed: ${response.statusText}`, {
-        statusCode: response.status
-      });
-    }
-    const { error: error48, error_description } = errorResult.data;
-    throw new ApiError(error_description ?? `OAuth error: ${error48}`, {
-      statusCode: response.status
-    });
-  }
-  const result = TokenResponseSchema.safeParse(json2);
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid token response from server", result.error);
-  }
-  return result.data;
-}
-async function getUserInfo(accessToken) {
-  const response = await oauthClient.get("oauth/userinfo", {
-    headers: { Authorization: `Bearer ${accessToken}` }
-  });
-  if (!response.ok) {
-    throw new ApiError(`Failed to fetch user info: ${response.status}`, {
-      statusCode: response.status
-    });
-  }
-  const result = UserInfoSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid UserInfo response from server", result.error);
-  }
-  return result.data;
-}
-// src/cli/commands/auth/login-flow.ts
-async function generateAndDisplayDeviceCode(log, runTask) {
-  const deviceCodeResponse = await runTask("Generating device code...", async () => {
-    return await generateDeviceCode();
-  }, {
-    successMessage: "Device code generated",
-    errorMessage: "Failed to generate device code"
-  });
-  log.info(`Verification code: ${theme.styles.bold(deviceCodeResponse.userCode)}` + `
-Please confirm this code at: ${deviceCodeResponse.verificationUri}`);
-  return deviceCodeResponse;
-}
-async function waitForAuthentication(deviceCode, expiresIn, interval, runTask) {
-  let tokenResponse;
-  try {
-    await runTask("Waiting for authentication...", async () => {
-      await pWaitFor(async () => {
-        const result = await getTokenFromDeviceCode(deviceCode);
-        if (result !== null) {
-          tokenResponse = result;
-          return true;
-        }
-        return false;
-      }, {
-        interval: interval * 1000,
-        timeout: expiresIn * 1000
-      });
-    }, {
-      successMessage: "Authentication completed!",
-      errorMessage: "Authentication failed"
-    });
-  } catch (error48) {
-    if (error48 instanceof Error && error48.message.includes("timed out")) {
-      throw new AuthExpiredError("Authentication timed out. Please try again.");
-    }
-    throw error48;
-  }
-  if (tokenResponse === undefined) {
-    throw new InternalError("Failed to retrieve authentication token.");
-  }
-  return tokenResponse;
-}
-async function saveAuthData(response, userInfo) {
-  const expiresAt = Date.now() + response.expiresIn * 1000;
-  await writeAuth({
-    accessToken: response.accessToken,
-    refreshToken: response.refreshToken,
-    expiresAt,
-    email: userInfo.email,
-    name: userInfo.name
-  });
-}
-async function login({
-  log,
-  runTask
-}) {
-  const deviceCodeResponse = await generateAndDisplayDeviceCode(log, runTask);
-  const token = await waitForAuthentication(deviceCodeResponse.deviceCode, deviceCodeResponse.expiresIn, deviceCodeResponse.interval, runTask);
-  const userInfo = await getUserInfo(token.accessToken);
-  await saveAuthData(token, userInfo);
-  return {
-    outroMessage: `Successfully logged in as ${theme.styles.bold(userInfo.email)}`
-  };
-}
-
-// src/cli/utils/command/middleware.ts
-async function ensureAuth(ctx) {
-  if (hasWorkspaceApiKeyAuth()) {
-    ctx.errorReporter.setContext({
-      user: { email: "workspace-api-key", name: "Workspace API key" }
-    });
-    return;
-  }
-  await seedAuthFromEnv();
-  const loggedIn = await isLoggedIn();
-  if (!loggedIn) {
-    ctx.log.info("You need to login first to continue.");
-    await login(ctx);
-  }
-  try {
-    const userInfo = await readAuth();
-    ctx.errorReporter.setContext({
-      user: { email: userInfo.email, name: userInfo.name }
-    });
-  } catch {}
-}
-async function ensureAppContext(ctx, options = {}) {
-  const appContext = await initAppContext(options);
-  ctx.app = appContext;
-  ctx.errorReporter.setContext({ appId: appContext.id });
-}
-
 // src/cli/utils/version-check.ts
 async function checkForUpgrade() {
   const testLatestVersion = getTestOverrides()?.latestVersion;
@@ -255773,6 +255820,11 @@ function verifyDenoInstalled(context) {
     });
   }
 }
+// src/core/utils/git.ts
+var GIT_HASH_PATTERN = /^[a-fA-F0-9]{7,64}$/;
+function isGitCommitHash(value) {
+  return GIT_HASH_PATTERN.test(value);
+}
 // src/core/workspace/schema.ts
 var WorkspaceSchema = exports_external.object({
   id: exports_external.string(),
@@ -256076,7 +256128,7 @@ function getAuthPushCommand() {
 }
 
 // src/cli/commands/auth/social-login.ts
-import { dirname as dirname14, join as join21, resolve as resolve5 } from "node:path";
+import { dirname as dirname14, join as join21, resolve as resolve4 } from "node:path";
 var PROVIDER_LABELS = {
   google: "Google",
   microsoft: "Microsoft",
@@ -256116,7 +256168,7 @@ async function socialLoginAction({ log, isNonInteractive, runTask: runTask2 }, p
   let clientSecret;
   if (useCustomOAuth && oauth && oauthCli && hasSecretOptions(options)) {
     if (options.envFile) {
-      const secrets = await parseEnvFile(resolve5(options.envFile));
+      const secrets = await parseEnvFile(resolve4(options.envFile));
       const value = secrets[oauthCli.envVar];
       if (!value) {
         throw new InvalidInputError(`Key "${oauthCli.envVar}" not found in ${options.envFile}.`);
@@ -256172,7 +256224,7 @@ function getSocialLoginCommand() {
 }
 
 // src/cli/commands/auth/sso.ts
-import { dirname as dirname15, join as join22, resolve as resolve6 } from "node:path";
+import { dirname as dirname15, join as join22, resolve as resolve5 } from "node:path";
 var SSOConfigFileSchema = exports_external.object({
   provider: exports_external.enum(Object.values(KNOWN_SSO_PROVIDERS)),
   clientId: exports_external.string(),
@@ -256188,7 +256240,7 @@ var SSOConfigFileSchema = exports_external.object({
   ssoName: exports_external.string().optional()
 });
 async function loadSSOConfigFile(filePath) {
-  const resolved = resolve6(filePath);
+  const resolved = resolve5(filePath);
   const raw2 = await readJsonFile(resolved);
   const result = SSOConfigFileSchema.safeParse(raw2);
   if (!result.success) {
@@ -256276,7 +256328,7 @@ async function ssoEnableAction({ isNonInteractive, runTask: runTask2 }, options)
   }
   let clientSecret;
   if (merged.envFile && !merged.clientSecret) {
-    const secrets2 = await parseEnvFile(resolve6(merged.envFile));
+    const secrets2 = await parseEnvFile(resolve5(merged.envFile));
     const value = secrets2.sso_client_secret;
     if (!value) {
       throw new InvalidInputError(`Key "sso_client_secret" not found in ${merged.envFile}.`);
@@ -256914,19 +256966,19 @@ var baseOpen = async (options) => {
   }
   const subprocess = childProcess3.spawn(command2, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve6, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode !== 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve7(subprocess);
+        resolve6(subprocess);
       });
     });
   }
   if (isFallbackAttempt) {
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve6, reject) => {
       subprocess.once("error", reject);
       subprocess.once("spawn", () => {
         subprocess.once("close", (exitCode) => {
@@ -256936,17 +256988,17 @@ var baseOpen = async (options) => {
             return;
           }
           subprocess.unref();
-          resolve7(subprocess);
+          resolve6(subprocess);
         });
       });
     });
   }
   subprocess.unref();
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve6, reject) => {
     subprocess.once("error", reject);
     subprocess.once("spawn", () => {
       subprocess.off("error", reject);
-      resolve7(subprocess);
+      resolve6(subprocess);
     });
   });
 };
@@ -257209,10 +257261,10 @@ function getConnectorsListAvailableCommand() {
 }
 
 // src/cli/commands/connectors/pull.ts
-import { dirname as dirname16, join as join23, resolve as resolve7 } from "node:path";
+import { dirname as dirname16, join as join23, resolve as resolve6 } from "node:path";
 async function resolveConnectorsDir(options) {
   if (!getAppContext().projectRoot) {
-    return resolve7(options.dir ?? "connectors");
+    return resolve6(options.dir ?? "connectors");
   }
   const { project: project2 } = await readProjectConfig();
   return join23(dirname16(project2.configPath), project2.connectorsDir);
@@ -257256,10 +257308,10 @@ function getConnectorsPullCommand() {
 }
 
 // src/cli/commands/connectors/push.ts
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve7 } from "node:path";
 async function readConnectorsToPush(options) {
   if (!getAppContext().projectRoot) {
-    return readAllConnectors(resolve8(options.dir ?? "connectors"));
+    return readAllConnectors(resolve7(options.dir ?? "connectors"));
   }
   const { connectors } = await readProjectConfig();
   return connectors;
@@ -257760,7 +257812,7 @@ function getBuildCommand() {
 }
 
 // src/cli/commands/project/create.ts
-import { basename as basename5, resolve as resolve9 } from "node:path";
+import { basename as basename5, resolve as resolve8 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
 
 // src/cli/commands/project/scaffold-shared.ts
@@ -257952,7 +258004,7 @@ async function createInteractive(options, ctx) {
   }, ctx);
 }
 async function createNonInteractive(options, ctx) {
-  ctx.log.info(`Creating a new project at ${resolve9(options.path)}`);
+  ctx.log.info(`Creating a new project at ${resolve8(options.path)}`);
   const template2 = await getTemplateById(options.template ?? DEFAULT_TEMPLATE_ID);
   return await executeCreate({
     template: template2,
@@ -257976,7 +258028,7 @@ async function executeCreate({
 }, ctx) {
   const { log, runTask: runTask2 } = ctx;
   const name2 = rawName.trim();
-  const resolvedPath = resolve9(projectPath);
+  const resolvedPath = resolve8(projectPath);
   const organizationId = await resolveWorkspaceId(ctx, flagWorkspaceId, isInteractive);
   const { projectId } = await runTask2("Setting up your project...", async () => {
     return await createProjectFiles({
@@ -258026,48 +258078,6 @@ Examples:
   $ base44 create my-app --workspace 507f1f77bcf86cd799439011     Creates a base44 project in the given workspace`).hook("preAction", validateCreateOptions).action(createAction);
 }
 
-// src/cli/commands/site/run-app-deploy.ts
-var TASK_LABELS = {
-  "static-deployment": {
-    start: "Deploying site...",
-    success: "Site deployed",
-    error: "Site deploy failed"
-  },
-  static: {
-    start: "Creating archive and deploying site...",
-    success: "Site deployed successfully",
-    error: "Deployment failed"
-  }
-};
-async function runAppSiteDeploy({ runTask: runTask2, log, staticDeployments }, target, options = {}) {
-  const kind = detectAppDeployKind(target, { staticDeployments });
-  if (kind === "none")
-    return { kind: "none" };
-  const labels = TASK_LABELS[kind];
-  const progressLines = [];
-  const result = await runTask2(labels.start, async (updateMessage) => await deployAppSite(target, {
-    staticDeployments,
-    gitHash: options.gitHash,
-    progress: {
-      onAssets: ({ totalAssets, newAssets }) => {
-        const line = `Found ${totalAssets} static assets (${newAssets} new)`;
-        progressLines.push(line);
-        updateMessage(line);
-      },
-      onAssetUpload: ({ uploadedFiles, totalFiles }) => {
-        updateMessage(`Uploaded ${uploadedFiles} of ${totalFiles} assets`);
-      }
-    }
-  }), {
-    successMessage: labels.success,
-    errorMessage: labels.error
-  });
-  for (const line of progressLines) {
-    log.message(theme.styles.dim(line));
-  }
-  return result;
-}
-
 // src/cli/commands/project/deploy.ts
 async function deployAction(ctx, options = {}) {
   const { isNonInteractive, log } = ctx;
@@ -258075,12 +258085,12 @@ async function deployAction(ctx, options = {}) {
     throw new InvalidInputError("--yes is required in non-interactive mode");
   }
   const projectData = await readProjectConfig(options.projectRoot);
-  const { project: project2, entities, functions, agents, connectors, authConfig } = projectData;
   if (!hasResourcesToDeploy(projectData)) {
     return {
       outroMessage: "No resources found to deploy"
     };
   }
+  const { project: project2, entities, functions, agents, connectors, authConfig } = projectData;
   const summaryLines = [];
   if (entities.length > 0) {
     summaryLines.push(`  - ${entities.length} ${entities.length === 1 ? "entity" : "entities"}`);
@@ -258122,7 +258132,6 @@ ${summaryLines.join(`
   let functionCompleted = 0;
   const functionTotal = functions.length;
   const result = await deployAll(projectData, {
-    site: false,
     onVisibilitySet: (level) => {
       log.success(`App visibility set to ${level}`);
     },
@@ -258135,7 +258144,6 @@ ${summaryLines.join(`
       formatDeployResult(r, log);
     }
   });
-  const siteResult = await runAppSiteDeploy(ctx, project2);
   const connectorResults = result.connectorResults ?? [];
   await handleOAuthConnectors(connectorResults, isNonInteractive, options, log);
   const stripeResult = connectorResults.find((r) => r.type === "stripe");
@@ -258143,24 +258151,10 @@ ${summaryLines.join(`
     printStripeResult(stripeResult, log);
   }
   log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl())}`);
-  if (siteResult.kind === "static") {
-    log.message(`${theme.styles.header("App URL")}: ${theme.colors.links(siteResult.appUrl)}`);
+  if (result.appUrl) {
+    log.message(`${theme.styles.header("App URL")}: ${theme.colors.links(result.appUrl)}`);
   }
-  const deployment = siteResult.kind === "static-deployment" ? siteResult : undefined;
-  if (deployment) {
-    printDeploymentSummary(deployment, log);
-  }
-  return {
-    outroMessage: "App deployed successfully",
-    stdout: ctx.jsonMode && deployment ? `${JSON.stringify({
-      deploymentId: deployment.deploymentId,
-      gitHash: deployment.gitHash
-    }, null, 2)}
-` : undefined
-  };
-}
-function printDeploymentSummary(deployment, log) {
-  log.message(`${theme.styles.header("Deployment")}: ${deployment.deploymentId} ${theme.styles.dim(`(commit ${deployment.gitHash.slice(0, 12)})`)}`);
+  return { outroMessage: "App deployed successfully" };
 }
 function getDeployCommand2() {
   return new Base44Command("deploy").description("Deploy all project resources (entities, functions, 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);
@@ -258441,7 +258435,7 @@ async function followLogs(functionNames, options, availableFunctionNames, jsonMo
     for (const entry of fresh)
       writeFollowLine(entry, jsonMode);
     first = false;
-    await new Promise((resolve10) => setTimeout(resolve10, 2000));
+    await new Promise((resolve9) => setTimeout(resolve9, 2000));
   }
 }
 function formatLogs(entries, env3) {
@@ -258555,7 +258549,7 @@ function getLogsCommand() {
 }
 
 // src/cli/commands/project/scaffold.ts
-import { basename as basename6, resolve as resolve10 } from "node:path";
+import { basename as basename6, resolve as resolve9 } from "node:path";
 function resolveAppId(options) {
   const appId = options.appId;
   if (!appId) {
@@ -258571,7 +258565,7 @@ function resolveAppId(options) {
 async function scaffoldAction(ctx, name2, options, command2) {
   const { log, runTask: runTask2 } = ctx;
   const appId = resolveAppId(command2.optsWithGlobals());
-  const resolvedPath = resolve10("./");
+  const resolvedPath = resolve9("./");
   const projectName = (name2 ?? basename6(resolvedPath)).trim();
   const template2 = await getTemplateById("backend-only");
   log.info(`Scaffolding project at ${resolvedPath}`);
@@ -258968,7 +258962,7 @@ function getSecretsListCommand() {
 }
 
 // src/cli/commands/secrets/set.ts
-import { resolve as resolve11 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 function parseEntries(entries) {
   const secrets = {};
   for (const entry of entries) {
@@ -258999,7 +258993,7 @@ async function setSecretsAction({ log, runTask: runTask2 }, entries, options) {
   validateInput(entries, options);
   let secrets;
   if (options.envFile) {
-    secrets = await parseEnvFile(resolve11(options.envFile));
+    secrets = await parseEnvFile(resolve10(options.envFile));
     if (Object.keys(secrets).length === 0) {
       throw new InvalidInputError("The env file contains no valid KEY=VALUE entries.");
     }
@@ -259028,6 +259022,7 @@ function getSecretsCommand() {
 }
 
 // src/cli/commands/site/deploy.ts
+import { resolve as resolve11 } from "node:path";
 async function deployAction2(ctx, options) {
   const { isNonInteractive } = ctx;
   if (isNonInteractive && !options.yes) {
@@ -259053,28 +259048,67 @@ async function deployAction2(ctx, options) {
     }
   }
   await maybeBuildBeforeDeploy(ctx, project2, options.build);
-  const result = await runAppSiteDeploy(ctx, project2, {
-    gitHash: options.gitHash
-  });
-  if (result.kind === "static-deployment") {
-    return {
-      outroMessage: `Deployment ${result.deploymentId} (commit ${result.gitHash.slice(0, 12)})`,
-      stdout: ctx.jsonMode ? `${JSON.stringify({ deploymentId: result.deploymentId, gitHash: result.gitHash }, null, 2)}
-` : undefined
-    };
-  }
-  if (result.kind === "static") {
-    return { outroMessage: `Visit your site at: ${result.appUrl}` };
+  const outputDir = resolve11(project2.root, outputDirectory);
+  const { gitHash, concurrency } = options;
+  return gitHash ? await deployToDeploymentsApi(ctx, outputDir, gitHash, concurrency) : await deployTarball(ctx, outputDir);
+}
+async function deployToDeploymentsApi({ runTask: runTask2, log, jsonMode }, outputDir, gitHash, concurrency) {
+  const progressLines = [];
+  const { deploymentId } = await runTask2("Deploying site...", async (updateMessage) => await deployStaticSite({
+    outputDir,
+    gitHash,
+    concurrency,
+    progress: {
+      onAssets: ({ totalAssets, newAssets }) => {
+        const line = `Found ${totalAssets} static assets (${newAssets} new)`;
+        progressLines.push(line);
+        updateMessage(line);
+      },
+      onAssetUpload: ({ uploadedFiles, totalFiles }) => {
+        updateMessage(`Uploaded ${uploadedFiles} of ${totalFiles} assets`);
+      }
+    }
+  }), { successMessage: "Site deployed", errorMessage: "Site deploy failed" });
+  for (const line of progressLines) {
+    log.message(theme.styles.dim(line));
   }
-  return { outroMessage: "Nothing to deploy" };
+  return {
+    outroMessage: `Deployment ${deploymentId} (commit ${gitHash.slice(0, 12)})`,
+    stdout: jsonMode ? `${JSON.stringify({ deploymentId, gitHash }, null, 2)}
+` : undefined
+  };
+}
+async function deployTarball({ runTask: runTask2 }, outputDir) {
+  const { appUrl } = await runTask2("Creating archive and deploying site...", async () => await deploySite(outputDir), {
+    successMessage: "Site deployed successfully",
+    errorMessage: "Deployment failed"
+  });
+  return { outroMessage: `Visit your site at: ${appUrl}` };
 }
-function getSiteDeployCommand(staticDeployments = false) {
+function getSiteDeployCommand() {
   const command2 = 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 (staticDeployments) {
-    command2.addOption(new Option("--git-hash <hash>", "Commit the build came from (defaults to the checkout's HEAD)"));
+  if (staticDeploymentsEnabled()) {
+    command2.addOption(new Option("--git-hash <hash>", "Commit the build came from — deploys through the deployments API").argParser((value) => {
+      if (!isGitCommitHash(value)) {
+        throw new InvalidArgumentError("Expected a git commit hash (7-64 hex chars).");
+      }
+      return value;
+    }));
+    command2.addOption(new Option("--concurrency <n>", "Parallel asset uploads").default(DEFAULT_UPLOAD_CONCURRENCY).argParser(parseConcurrency));
   }
   return command2.action(deployAction2);
 }
+function parseConcurrency(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_UPLOAD_CONCURRENCY) {
+    throw new InvalidArgumentError(`Expected a whole number between 1 and ${MAX_UPLOAD_CONCURRENCY}.`);
+  }
+  return parsed;
+}
+function staticDeploymentsEnabled(env3 = process.env) {
+  const value = env3.BASE44_STATIC_DEPLOYMENTS;
+  return value === "1" || value === "true";
+}
 
 // src/cli/commands/site/open.ts
 async function openAction({
@@ -259091,8 +259125,8 @@ function getSiteOpenCommand() {
 }
 
 // src/cli/commands/site/index.ts
-function getSiteCommand(staticDeployments = false) {
-  return new Command("site").description("Manage app site (frontend app)").addCommand(getSiteDeployCommand(staticDeployments)).addCommand(getSiteOpenCommand());
+function getSiteCommand() {
+  return new Command("site").description("Manage app site (frontend app)").addCommand(getSiteDeployCommand()).addCommand(getSiteOpenCommand());
 }
 
 // src/core/types/generator.ts
@@ -263615,7 +263649,7 @@ function createProgram(context) {
   program2.addCommand(getSecretsCommand());
   program2.addCommand(getSandboxCommand());
   program2.addCommand(getAuthCommand());
-  program2.addCommand(getSiteCommand(context.staticDeployments));
+  program2.addCommand(getSiteCommand());
   program2.addCommand(getTypesCommand());
   program2.addCommand(getExecCommand());
   program2.addCommand(getDevCommand());
@@ -267839,7 +267873,6 @@ async function runCLI(options8) {
     errorReporter,
     isNonInteractive,
     jsonMode,
-    staticDeployments: staticDeploymentsEnabled(),
     distribution: options8?.distribution ?? "npm",
     log,
     runTask: runTask2
@@ -267868,4 +267901,4 @@ export {
   CLIExitError
 };
 
-//# debugId=6BAACF0BD26B212664756E2164756E21
+//# debugId=8588EA2CAEB0DBAE64756E2164756E21