@base44-preview/cli 0.1.7-pr.585.63c3afc → 0.1.7-pr.585.85db235

package/dist/cli/index.js

@@ -221220,7 +221220,7 @@ var require_dist5 = __commonJS((exports, module) => {
     determineAgent: () => determineAgent
   });
   module.exports = __toCommonJS2(src_exports);
-  var import_promises26 = __require("node:fs/promises");
+  var import_promises25 = __require("node:fs/promises");
   var import_node_fs24 = __require("node:fs");
   var DEVIN_LOCAL_PATH = "/opt/.devin";
   var CURSOR2 = "cursor";
@@ -221278,7 +221278,7 @@ var require_dist5 = __commonJS((exports, module) => {
       return { isAgent: true, agent: { name: REPLIT } };
     }
     try {
-      await (0, import_promises26.access)(DEVIN_LOCAL_PATH, import_node_fs24.constants.F_OK);
+      await (0, import_promises25.access)(DEVIN_LOCAL_PATH, import_node_fs24.constants.F_OK);
       return { isAgent: true, agent: { name: DEVIN } };
     } catch (error48) {}
     return { isAgent: false, agent: undefined };
@@ -248113,7 +248113,6 @@ 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",
@@ -248418,145 +248417,21 @@ import { join as join16 } from "node:path";
 
 // src/core/site/upload.ts
 import { readFile as readFile3 } from "node:fs/promises";
-import { setTimeout as sleep3 } from "node:timers/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 UPLOAD_CONCURRENCY = 3;
 var MAX_ATTEMPTS_PER_UPLOAD = 3;
 var RETRY_BASE_DELAY_MS = 500;
-async function uploadPresignedAssets(uploads, assets, options = {}) {
-  const { concurrency = DEFAULT_UPLOAD_CONCURRENCY, onProgress } = options;
+async function uploadPresignedAssets(uploads, assets, onProgress) {
   let uploadedFiles = 0;
-  await pMap(uploads, async (upload) => {
-    await uploadPresignedAssetWithRetry(upload, assets);
-    uploadedFiles++;
-    onProgress?.({ uploadedFiles, totalFiles: uploads.length });
-  }, { concurrency });
+  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];
@@ -248584,10 +248459,13 @@ async function uploadPresignedAssetWithRetry(upload, assets) {
   }
   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, gitHash, concurrency, progress } = options;
+  const { outputDir, gitHash, 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.`);
@@ -248601,10 +248479,7 @@ async function deployStaticSite(options) {
     newAssets: created.assetUploads?.uploads.length ?? 0
   });
   if (created.assetUploads) {
-    await uploadPresignedAssets(created.assetUploads.uploads, assets, {
-      concurrency,
-      onProgress: progress?.onAssetUpload
-    });
+    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));
@@ -259061,15 +258936,13 @@ async function deployAction2(ctx, options) {
   }
   await maybeBuildBeforeDeploy(ctx, project2, options.build);
   const outputDir = resolve11(project2.root, outputDirectory);
-  const { gitHash, concurrency } = options;
-  return gitHash ? await deployToDeploymentsApi(ctx, outputDir, gitHash, concurrency) : await deployTarball(ctx, outputDir);
+  return options.gitHash ? await deployToDeploymentsApi(ctx, outputDir, options.gitHash) : await deployTarball(ctx, outputDir);
 }
-async function deployToDeploymentsApi({ runTask: runTask2, log, jsonMode }, outputDir, gitHash, concurrency) {
+async function deployToDeploymentsApi({ runTask: runTask2, log, jsonMode }, outputDir, gitHash) {
   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)`;
@@ -259106,17 +258979,9 @@ function getSiteDeployCommand() {
       }
       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;
-}
 
 // src/cli/commands/site/open.ts
 async function openAction({
@@ -267909,4 +267774,4 @@ export {
   CLIExitError
 };
 
-//# debugId=8D3A45157A4E22AA64756E2164756E21
+//# debugId=54C8BB5F436D9BDE64756E2164756E21