hostedge 0.1.1 → 0.1.2

package/dist/hostedge.js

@@ -1320,19 +1320,21 @@ function exitCodeFor(status, code) {
   return EXIT.failure;
 }
 var ApiError = class extends CliError {
-  constructor(message, status, code) {
+  constructor(message, status, code, retryAfter = null) {
     super(message, exitCodeFor(status, code));
     this.status = status;
     this.code = code;
+    this.retryAfter = retryAfter;
   }
   status;
   code;
+  retryAfter;
 };
 function createApi(io2, apiUrl, token) {
   async function raw(path, init2 = {}) {
     const headers = new Headers(init2.headers);
     headers.set("authorization", `Bearer ${token}`);
-    headers.set("user-agent", "hostedge-cli/0.1.1");
+    headers.set("user-agent", "hostedge-cli/0.1.2");
     let response;
     try {
       response = await io2.fetch(`${apiUrl}${path}`, { ...init2, headers });
@@ -1343,7 +1345,13 @@ function createApi(io2, apiUrl, token) {
       const body2 = await response.json().catch(() => ({}));
       const fields = body2.error?.fields ? ` ${Object.entries(body2.error.fields).map(([k, v]) => `${k}: ${v}`).join("; ")}` : "";
       const message = response.status === 401 ? `${body2.error?.message ?? "Not signed in."} Run \`hostedge login\`.` : `${body2.error?.message ?? `HostEdge answered ${response.status}.`}${fields}`;
-      throw new ApiError(message, response.status, body2.error?.code ?? null);
+      const wait = Number(response.headers.get("retry-after"));
+      throw new ApiError(
+        message,
+        response.status,
+        body2.error?.code ?? null,
+        Number.isFinite(wait) && wait > 0 ? wait : null
+      );
     }
     return response;
   }
@@ -1566,7 +1574,8 @@ async function withRetries(work, retryable, attempts = 4, delayMs = 500) {
       return await work();
     } catch (error) {
       if (attempt >= attempts || !retryable(error)) throw error;
-      await new Promise((resolve6) => setTimeout(resolve6, delayMs * 2 ** (attempt - 1)));
+      const wait = typeof delayMs === "function" ? delayMs(error, attempt) : delayMs * 2 ** (attempt - 1);
+      await new Promise((resolve6) => setTimeout(resolve6, wait));
     }
   }
 }
@@ -1639,8 +1648,31 @@ async function* readSse(body2) {
 
 // src/commands/deploy.ts
 var FINISHED = /* @__PURE__ */ new Set(["ready", "failed", "canceled"]);
-var UPLOAD_CONCURRENCY = 16;
+var UPLOAD_CONCURRENCY = 6;
+var BATCH_BYTES = 3 * 1024 * 1024;
+var BATCH_FILES = 100;
 var UPLOAD_TIMEOUT_MS = 3e4;
+function batchesOf(files) {
+  const batches = [];
+  let current = [];
+  let bytes = 0;
+  for (const file of files) {
+    if (current.length > 0 && (bytes + file.size > BATCH_BYTES || current.length >= BATCH_FILES)) {
+      batches.push(current);
+      current = [];
+      bytes = 0;
+    }
+    current.push(file);
+    bytes += file.size;
+  }
+  if (current.length > 0) batches.push(current);
+  return batches;
+}
+function retryDelay(error, attempt) {
+  if (error instanceof ApiError && error.retryAfter !== null)
+    return Math.min(6e4, (error.retryAfter + 1) * 1e3);
+  return Math.min(6e4, 500 * 2 ** (attempt - 1));
+}
 function temporary(error) {
   if (error instanceof ApiError) return error.status === 429 || error.status >= 500;
   return error instanceof CliError;
@@ -1721,23 +1753,56 @@ async function deploy(r, options) {
   let uploaded = 0;
   let reported = 0;
   const step = Math.max(1, Math.ceil(toUpload.length / 10));
-  await pool(toUpload, UPLOAD_CONCURRENCY, async (file) => {
-    const bytes = await readFile4(file.absolute);
-    await withRetries(
-      () => api.raw(`/api/v1/uploads/${file.hash}`, {
-        method: "PUT",
-        headers: { "content-type": "application/octet-stream" },
-        body: bytes,
-        signal: AbortSignal.timeout(UPLOAD_TIMEOUT_MS)
-      }),
-      temporary
-    );
-    uploaded++;
+  const progress = (count2) => {
+    uploaded += count2;
     if (toUpload.length > 20 && uploaded - reported >= step && uploaded < toUpload.length) {
       reported = uploaded;
       r.say(`${s.dim(`  ${uploaded}/${toUpload.length} uploaded`)}
 `);
     }
+  };
+  const send = (path, init2, bytes) => withRetries(
+    () => api.raw(path, {
+      ...init2,
+      // 30 s plus a few more for every MB, so a big file on a slow line can finish.
+      signal: AbortSignal.timeout(UPLOAD_TIMEOUT_MS + Math.ceil(bytes / 1048576) * 4e3)
+    }),
+    temporary,
+    6,
+    retryDelay
+  );
+  let batching = true;
+  await pool(batchesOf(toUpload), UPLOAD_CONCURRENCY, async (batch) => {
+    if (batching && (batch.length > 1 || (batch[0]?.size ?? 0) <= BATCH_BYTES)) {
+      const form = new FormData();
+      for (const file of batch)
+        form.append(file.hash, new Blob([await readFile4(file.absolute)]), file.hash);
+      try {
+        await send(
+          "/api/v1/uploads/batch",
+          { method: "POST", body: form },
+          batch.reduce((sum, file) => sum + file.size, 0)
+        );
+        progress(batch.length);
+        return;
+      } catch (error) {
+        if (!(error instanceof ApiError) || error.status !== 404 && error.status !== 405)
+          throw error;
+        batching = false;
+      }
+    }
+    for (const file of batch) {
+      await send(
+        `/api/v1/uploads/${file.hash}`,
+        {
+          method: "PUT",
+          headers: { "content-type": "application/octet-stream" },
+          body: await readFile4(file.absolute)
+        },
+        file.size
+      );
+      progress(1);
+    }
   });
   let project;
   if (!link) {
@@ -2969,7 +3034,7 @@ var Reporter = class {
 };
 
 // src/cli.ts
-var VERSION = "0.1.1";
+var VERSION = "0.1.2";
 var HELP = `hostedge \u2014 deploy to HostEdge from your terminal
 
 Usage

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hostedge",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Deploy to HostEdge from your terminal",
   "keywords": [
     "hostedge",