agentful 0.4.15 → 0.4.17

package/README.md

@@ -44,18 +44,24 @@ Inside the interface, `/` lists the Agentful commands (`/setup`, `/push`,
 site, and asks you before it changes a file or pushes.
 
 `push` respects your `.gitignore` and always excludes `.git`, `node_modules`,
-build output and every `.env` file. A push carries at most about 4.4 MiB
-compressed, 25 MiB of files and 2,000 files, and a static site or a prebuilt upload needs
-an `index.html` at its top level. `push` checks all of this before it signs you
+build output and every `.env` file. A push carries at most 25 MiB of files
+(32 MiB compressed) and 2,000 files, and a static site or a prebuilt upload needs
+an `index.html` at its top level. The preview does not deliver every file yet:
+images, fonts and PDFs up to about 4.4 MiB each, pages and scripts up to about
+5.5 MiB, and no video or audio. `push` names the files this concerns and uploads
+them all the same. `push` checks all of this before it signs you
 in or creates a project.
 
 `agentful push --dry-run` shows that check on its own: what would be uploaded
 and what is left out, the largest files, identical copies, media embedded in
-HTML, and every reason the upload would be rejected. It uploads nothing,
-creates no project and changes no file; it exits with 1 when the push would be
-blocked. `--dry-run --json` prints the same analysis as one JSON document
+HTML, and every reason the upload would be rejected. A file that is larger
+than a whole push on its own is named as such: it cannot be uploaded at all,
+whatever else is left out. It uploads nothing, creates no project and changes
+no file; it exits with 1 when the push would be blocked. `--dry-run --json`
+prints the same analysis as one JSON document
 (`"schema": "agentful.push-analysis"`) for scripts and agents; with `--summary`
-it leaves out the list of every file and keeps totals, limits and findings.
+it leaves out the list of every file, keeps totals, limits and findings, and
+prints every size as text next to its byte count.
 
 ## What you can deploy
 

package/dist/index.cjs

@@ -3044,7 +3044,7 @@ var VERSION, brand, useColor, wrap, paint, tuiDesign, sym, ui;
 var init_branding = __esm({
   "src/branding.ts"() {
     "use strict";
-    VERSION = "0.4.15" ? "0.4.15" : null.version;
+    VERSION = "0.4.17" ? "0.4.17" : null.version;
     brand = {
       name: "agentful",
       // the command users type
@@ -5780,17 +5780,49 @@ var contract_default = {
 
 // src/lib/uploadLimits.ts
 var MAX_ZIP_UPLOAD_BYTES = contract_default.limits.max_zip_upload_bytes;
+var MAX_DIRECT_ZIP_UPLOAD_BYTES = 32 * 1024 * 1024;
 var MAX_UNPACKED_BYTES = 25 * 1024 * 1024;
 var MAX_UPLOAD_FILES = 2e3;
 var MAX_INLINE_REQUEST_BYTES = 6 * 1024 * 1024 - 64 * 1024;
 function uploadRequestBody(zipBase64, mode, declaration) {
   return { zip_base64: zipBase64, mode, clean: true, ...declaration ? { backend_declaration: declaration } : {} };
 }
-function maxZipBytesForUpload(mode = "source", declaration = null) {
+function maxInlineZipBytes(mode = "source", declaration = null) {
   const around = Buffer.byteLength(JSON.stringify(uploadRequestBody("", mode, declaration)), "utf8");
   const base64Budget = Math.max(0, MAX_INLINE_REQUEST_BYTES - around);
   return Math.min(MAX_ZIP_UPLOAD_BYTES, Math.floor(base64Budget / 4) * 3);
 }
+function maxZipBytesForUpload() {
+  return MAX_DIRECT_ZIP_UPLOAD_BYTES;
+}
+function announceRequestBody(zipBytes, sha256Hex, mode) {
+  return { upload: { size: zipBytes, sha256: sha256Hex }, mode };
+}
+function completeRequestBody(uploadId, mode, declaration) {
+  return { upload_id: uploadId, mode, clean: true, ...declaration ? { backend_declaration: declaration } : {} };
+}
+var PREVIEW_BINARY_MEASURED_PASS_BYTES = 4666163;
+var PREVIEW_MAX_BINARY_BYTES = PREVIEW_BINARY_MEASURED_PASS_BYTES;
+var PREVIEW_MAX_TEXT_BYTES = 5.5 * 1024 * 1024;
+var PREVIEW_BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  "avif",
+  "apng",
+  "webp",
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "svg",
+  "ico",
+  "bmp",
+  "tiff",
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "eot",
+  "pdf"
+]);
 var SERVER_SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -5954,7 +5986,7 @@ function scanTree(rootDir, mode) {
 function collectFiles(rootDir, mode) {
   return scanTree(rootDir, mode).files;
 }
-function zipToBase64(files, maxBytes = maxZipBytesForUpload()) {
+function zipFiles(files, maxBytes = maxZipBytesForUpload()) {
   if (files.length === 0) {
     throw new ApiError(0, "empty_project", "Nothing to push \u2014 no files found after applying ignore rules.");
   }
@@ -5970,11 +6002,7 @@ function zipToBase64(files, maxBytes = maxZipBytesForUpload()) {
       `The upload is ${zipped.byteLength.toLocaleString("en-US")} bytes compressed \u2014 a push carries at most ${maxBytes.toLocaleString("en-US")}. \`agentful push --dry-run\` shows what takes the space.`
     );
   }
-  return {
-    base64: Buffer.from(zipped).toString("base64"),
-    bytes: zipped.byteLength,
-    count: files.length
-  };
+  return { data: zipped, bytes: zipped.byteLength, count: files.length };
 }
 function detectDistDir(rootDir, override) {
   if (override) {
@@ -6500,6 +6528,16 @@ var CLASS_BY_EXTENSION = new Map(
 );
 var EMBEDDED_SCAN_CLASSES = /* @__PURE__ */ new Set(["html", "css", "script", "data"]);
 var baseName = (rel) => rel.slice(rel.lastIndexOf("/") + 1);
+var TEXT_CLASSES = /* @__PURE__ */ new Set(["html", "css", "script", "data"]);
+var UNDELIVERED_CLASSES = /* @__PURE__ */ new Set(["image", "font", "document", "video", "audio", "archive"]);
+function previewDelivery(rel, bytes2) {
+  const base = baseName(rel);
+  const ext = base.includes(".") ? base.slice(base.lastIndexOf(".") + 1).toLowerCase() : "";
+  if (PREVIEW_BINARY_EXTENSIONS.has(ext)) return bytes2 > PREVIEW_MAX_BINARY_BYTES ? "too_large" : "ok";
+  const cls = classOf(rel);
+  if (TEXT_CLASSES.has(cls)) return bytes2 > PREVIEW_MAX_TEXT_BYTES ? "too_large" : "ok";
+  return UNDELIVERED_CLASSES.has(cls) || ext === "wasm" ? "not_delivered" : "ok";
+}
 function classOf(rel) {
   const base = baseName(rel);
   const dot = base.lastIndexOf(".");
@@ -6561,7 +6599,7 @@ function formatBytes(bytes2, rounding = "nearest") {
   }
   if (unit === 0 || Number.isInteger(value)) return `${value} ${units[unit]}`;
   const tenths = value * 10;
-  const rounded = (rounding === "down" ? Math.floor(tenths) : Math.round(tenths)) / 10;
+  const rounded = (rounding === "down" ? Math.floor(tenths) : rounding === "up" ? Math.ceil(tenths) : Math.round(tenths)) / 10;
   return `${rounded.toFixed(1)} ${units[unit]}`;
 }
 function sizeOverLimit(bytes2, limit) {
@@ -6612,7 +6650,7 @@ function failedAnalysis(mode, projectDir, blocker) {
     ok: false,
     framework: null,
     project: projectLink(projectDir),
-    limits: limits(maxZipBytesForUpload(mode)),
+    limits: limits(maxZipBytesForUpload()),
     totals: {
       files: 0,
       bytes: 0,
@@ -6728,6 +6766,14 @@ function analyzePush(options) {
   }
   duplicates.sort((a, b) => b.redundant_zip_bytes - a.redundant_zip_bytes || (a.paths[0] < b.paths[0] ? -1 : 1));
   const redundantZipBytes = duplicates.reduce((total, group) => total + group.redundant_zip_bytes, 0);
+  const maxZipBytes = maxZipBytesForUpload();
+  const tooBigAsFile = (file) => view.stored.has(file.path) && file.bytes > MAX_UNPACKED_BYTES;
+  const tooBigInZip = (file) => file.zipLower > maxZipBytes;
+  const oversized = measured.filter((file) => tooBigAsFile(file) || tooBigInZip(file)).sort((a, b) => b.bytes - a.bytes || byPath(a, b));
+  const oversizedPaths = new Set(oversized.map((file) => file.path));
+  const oversizedAsFile = oversized.filter(tooBigAsFile);
+  const restZipLower = zipLower - oversized.reduce((total, file) => total + file.zipLower, 0);
+  const restStoredBytes = storedBytes - oversizedAsFile.reduce((total, file) => total + file.bytes, 0);
   const preflight = mode === "source" ? runPreflight(rootDir) : null;
   const framework = preflight?.framework ?? null;
   const hasManifest = storedNames.has("package.json");
@@ -6739,12 +6785,14 @@ function analyzePush(options) {
     return {
       path: file.path,
       bytes: file.bytes,
+      zip_bytes: file.zip_bytes,
       title: file.title,
       sha256: file.sha256,
-      same_content_as: first && first !== file.path ? first : null
+      same_content_as: first && first !== file.path ? first : null,
+      ...oversizedPaths.has(file.path) ? { larger_than_a_push: true } : {}
     };
   });
-  const maxZipBytes = maxZipBytesForUpload(mode, mode === "source" ? readBackendDeclaration(rootDir) : null);
+  const fittingCandidates = candidates.filter((candidate) => !candidate.larger_than_a_push);
   const zipLimit = formatBytes(maxZipBytes, "down");
   const blockers = [];
   const warnings = [];
@@ -6772,20 +6820,39 @@ function analyzePush(options) {
       message: `${plural(measured.length, "file")} \u2014 the platform accepts at most ${MAX_UPLOAD_FILES.toLocaleString("en-US")} files per push.`
     });
   }
-  if (storedBytes > MAX_UNPACKED_BYTES) {
+  const largerOnTheirOwn = (files, sizeOf, limit) => {
+    const named = samplePaths(files.map((file) => `${file.path} (${sizeOverLimit(sizeOf(file), limit)[0]})`));
+    return files.length === 1 ? ` ${named} is larger than that on its own, so no push can carry it.` : ` ${plural(files.length, "file")} are each larger than that on their own, so no push can carry them: ${named}.`;
+  };
+  const filesTooLarge = storedBytes > MAX_UNPACKED_BYTES;
+  if (filesTooLarge) {
     const [size, allowed] = sizeOverLimit(storedBytes, MAX_UNPACKED_BYTES);
+    let message = `The files add up to ${size} \u2014 the platform accepts at most ${allowed} of files per push.`;
+    if (oversizedAsFile.length > 0) {
+      message += largerOnTheirOwn(oversizedAsFile, (file) => file.bytes, MAX_UNPACKED_BYTES);
+      message += ` Without ${oversizedAsFile.length === 1 ? "it" : "them"} the files ${restStoredBytes > MAX_UNPACKED_BYTES ? `still add up to ${sizeOverLimit(restStoredBytes, MAX_UNPACKED_BYTES)[0]}` : `add up to ${formatBytes(restStoredBytes)}, which is within that limit`}.`;
+    }
     blockers.push({
       code: "unpacked_too_large",
       overridable: false,
-      message: `The files add up to ${size} \u2014 the platform accepts at most ${allowed} of files per push.`
+      message,
+      ...oversizedAsFile.length > 0 ? { paths: oversizedAsFile.map((file) => file.path).slice(0, FINDING_PATHS) } : {}
     });
   }
   if (zipLower > maxZipBytes) {
     const [size, allowed] = sizeOverLimit(zipExact ? zipBytes : zipLower, maxZipBytes);
+    let message = `The upload is ${zipExact ? "" : "at least "}${size} compressed \u2014 a push carries at most ${allowed} compressed.`;
+    const namedHere = oversized.filter((file) => tooBigInZip(file) && !(filesTooLarge && tooBigAsFile(file)));
+    if (namedHere.length > 0) message += largerOnTheirOwn(namedHere, (file) => file.zipLower, maxZipBytes);
+    if (oversized.length > 0) {
+      const without = namedHere.length < oversized.length ? "the files no push can carry" : namedHere.length === 1 ? "it" : "them";
+      message += ` Without ${without} the upload is ${restZipLower > maxZipBytes ? `still ${sizeOverLimit(restZipLower, maxZipBytes)[0]} compressed` : `${formatBytes(restZipLower)} compressed, which is within that limit`}.`;
+    }
     blockers.push({
       code: "zip_too_large",
       overridable: false,
-      message: `The upload is ${zipExact ? "" : "at least "}${size} compressed \u2014 a push carries at most ${allowed} compressed.`
+      message,
+      ...namedHere.length > 0 ? { paths: namedHere.map((file) => file.path).slice(0, FINDING_PATHS) } : {}
     });
   } else if (!zipExact && zipBytes > maxZipBytes) {
     warnings.push({
@@ -6794,10 +6861,12 @@ function analyzePush(options) {
     });
   }
   if (entryMissing) {
+    const tooBig = candidates.filter((candidate) => candidate.larger_than_a_push);
+    const cannotBecomeIt = tooBig.length === 0 ? "" : fittingCandidates.length === 0 ? candidates.length === 1 ? " The one HTML file here cannot become it as it is: it is larger than a whole push." : ` None of the ${candidates.length} HTML files here can become it as they are: each is larger than a whole push.` : ` ${tooBig.length} of the ${candidates.length} HTML files here cannot become it as ${tooBig.length === 1 ? "it is" : "they are"}, larger than a whole push: ${samplePaths(tooBig.map((candidate) => candidate.path))}.`;
     blockers.push({
       code: "entry_missing",
       overridable: false,
-      message: mode === "dist" ? `No index.html at the top level of ${dirLabel === "." ? "the uploaded folder" : `${dirLabel}/`}. A prebuilt upload is served as it is, and index.html is its start page.` : "No index.html at the top level. Without a package.json this is a static site, and the platform serves index.html as its start page."
+      message: (mode === "dist" ? `No index.html at the top level of ${dirLabel === "." ? "the uploaded folder" : `${dirLabel}/`}. A prebuilt upload is served as it is, and index.html is its start page.` : "No index.html at the top level. Without a package.json this is a static site, and the platform serves index.html as its start page.") + cannotBecomeIt
     });
   }
   const backend = mode === "source" ? checkBackendDeclaration(rootDir) : null;
@@ -6829,6 +6898,25 @@ function analyzePush(options) {
       });
     }
   }
+  const servedAsIs = stored.filter((file) => mode === "dist" || framework === "vanilla" || /^(public|static)\//.test(view.stored.get(file.path) ?? ""));
+  const tooLargeForPreview = servedAsIs.filter((file) => previewDelivery(file.path, file.bytes) === "too_large").sort((a, b) => b.bytes - a.bytes || byPath(a, b));
+  if (tooLargeForPreview.length > 0) {
+    const one = tooLargeForPreview.length === 1;
+    warnings.push({
+      code: "preview_file_too_large",
+      message: `${plural(tooLargeForPreview.length, "file is", "files are")} larger than the preview delivers (about ${formatBytes(PREVIEW_MAX_BINARY_BYTES, "down")} for images, fonts and PDFs, about ${formatBytes(PREVIEW_MAX_TEXT_BYTES, "down")} for pages, scripts and other text): ${samplePaths(tooLargeForPreview.map((file) => `${file.path} (${formatBytes(file.bytes)})`))}. ${one ? "It is" : "They are"} uploaded, but the preview answers with an error instead of the file.`,
+      paths: tooLargeForPreview.map((file) => file.path).slice(0, FINDING_PATHS)
+    });
+  }
+  const notDeliveredByPreview = servedAsIs.filter((file) => previewDelivery(file.path, file.bytes) === "not_delivered").sort(byPath);
+  if (notDeliveredByPreview.length > 0) {
+    const one = notDeliveredByPreview.length === 1;
+    warnings.push({
+      code: "preview_type_not_delivered",
+      message: `${plural(notDeliveredByPreview.length, "file is", "files are")} of a kind the preview does not deliver intact (video, audio, archives and other binary formats): ${samplePaths(notDeliveredByPreview.map((file) => file.path))}. ${one ? "It is" : "They are"} uploaded, but ${one ? "it does" : "they do"} not play or open in the preview.`,
+      paths: notDeliveredByPreview.map((file) => file.path).slice(0, FINDING_PATHS)
+    });
+  }
   const filesOmitted = Math.max(0, measured.length - budgets.fileListCap);
   if (filesOmitted > 0) {
     warnings.push({
@@ -6838,11 +6926,11 @@ function analyzePush(options) {
   }
   const tooLarge = blockers.some((b) => b.code === "zip_too_large" || b.code === "unpacked_too_large");
   if (entryMissing) {
-    if (candidates.length > 0) {
+    if (fittingCandidates.length > 0) {
       suggestions.push({
         code: "name_start_page",
         message: "Rename or copy the page that should open first to index.html at the top level, check that its relative links still resolve, then push again.",
-        paths: candidates.map((candidate) => candidate.path).slice(0, FINDING_PATHS)
+        paths: fittingCandidates.map((candidate) => candidate.path).slice(0, FINDING_PATHS)
       });
     }
     const siteDirs = /* @__PURE__ */ new Set();
@@ -6864,29 +6952,33 @@ function analyzePush(options) {
     }
   }
   if (tooLarge) {
-    const oversized = measured.filter((file) => file.zipLower > maxZipBytes).sort((a, b) => b.bytes - a.bytes || byPath(a, b));
-    if (oversized.length > 0) {
-      suggestions.push({
-        code: "oversized_files",
-        message: `${samplePaths(oversized.map((file) => `${file.path} (${formatBytes(file.zipLower)} compressed)`))} ${oversized.length === 1 ? "is" : "are each"} larger than a whole push can carry. The upload cannot fit while ${oversized.length === 1 ? "it is" : "they are"} part of it.`,
-        paths: oversized.map((file) => file.path).slice(0, FINDING_PATHS)
-      });
-    }
-    if (duplicates.length > 0 && redundantZipBytes >= zipBytes / 20) {
-      const copies = duplicates.reduce((total, group) => total + group.paths.length - 1, 0);
-      const remaining = zipBytes - redundantZipBytes;
+    const overZip = zipLower - maxZipBytes;
+    const overFiles = storedBytes - MAX_UNPACKED_BYTES;
+    const mustStayOut = [
+      overZip > 0 ? `${formatBytes(overZip, "up")} of the ${formatBytes(zipLower)} compressed` : "",
+      overFiles > 0 ? `${formatBytes(overFiles, "up")} of the ${formatBytes(storedBytes)} of files` : ""
+    ].filter(Boolean);
+    const toFit = ` To fit, at least ${mustStayOut.join(" and ")} ${mustStayOut.length > 1 ? "have" : "has"} to stay out.`;
+    const spareCopies = duplicates.filter((group) => !oversizedPaths.has(group.paths[0]));
+    const extraStored = (group) => group.paths.slice(1).filter((path) => view.stored.has(path)).length * group.bytes;
+    const spare = spareCopies.reduce((total, group) => total + (filesTooLarge ? extraStored(group) : group.redundant_zip_bytes), 0);
+    const base = filesTooLarge ? oversized.length > 0 ? restStoredBytes : storedBytes : oversized.length > 0 ? restZipLower : zipBytes;
+    const limit = filesTooLarge ? MAX_UNPACKED_BYTES : maxZipBytes;
+    if (spareCopies.length > 0 && spare >= base / 20) {
+      const copies = spareCopies.reduce((total, group) => total + group.paths.length - 1, 0);
+      const remaining = base - spare;
       suggestions.push({
         code: "remove_identical_copies",
-        message: `${plural(copies, "file is an identical copy", "files are identical copies")} of another file and ${copies === 1 ? "adds" : "add"} ${formatBytes(redundantZipBytes)} to the compressed upload. If nothing links to the extra names, one copy each brings it to ${formatBytes(remaining)}${remaining > maxZipBytes ? ` \u2014 still above the ${zipLimit} limit` : ""}.`,
-        paths: duplicates.flatMap((group) => group.paths.slice(1)).slice(0, FINDING_PATHS)
+        message: `${plural(copies, "file is an identical copy", "files are identical copies")} of another file and ${copies === 1 ? "adds" : "add"} ${formatBytes(spare)} to the ${filesTooLarge ? "files of the upload" : "compressed upload"}. If nothing links to the extra names, one copy each brings ${oversized.length > 0 ? "what is left without the files no push can carry" : "it"} to ${formatBytes(remaining)}${remaining > limit ? ` \u2014 still above the ${formatBytes(limit, "down")} limit` : ""}.`,
+        paths: spareCopies.flatMap((group) => group.paths.slice(1)).slice(0, FINDING_PATHS)
       });
     }
     suggestions.push(mode === "source" ? {
       code: "exclude_with_gitignore",
-      message: "Files and folders listed in .gitignore are not uploaded. Leave out what the site does not serve \u2014 originals, working files, exports."
+      message: `Files and folders listed in .gitignore are not uploaded. Leave out what the site does not serve \u2014 originals, working files, exports.${toFit}`
     } : {
       code: "narrow_prebuilt_directory",
-      message: "A prebuilt upload takes every file in the folder. Put the finished site into a folder of its own and pass it with --dir."
+      message: `A prebuilt upload takes every file in the folder. Put the finished site into a folder of its own and pass it with --dir.${toFit}`
     });
     suggestions.push({
       code: "upload_limit",
@@ -6961,7 +7053,19 @@ var SUMMARY_LISTS = {
   finding_paths: 8
 };
 var SUMMARY_MAX_BYTES = 24 * 1024;
-var printAnalysis = (analysis) => `${JSON.stringify(analysis, null, 2)}
+var sizeLabelKey = (key) => key === "base64_chars" ? "base64_size" : /(^|_)bytes(_|$)/.test(key) ? key.replace("bytes", "size") : null;
+function withSizeLabels(value) {
+  if (Array.isArray(value)) return value.map(withSizeLabels);
+  if (!value || typeof value !== "object") return value;
+  const labelled = {};
+  for (const [key, inner] of Object.entries(value)) {
+    labelled[key] = withSizeLabels(inner);
+    const label = typeof inner === "number" ? sizeLabelKey(key) : null;
+    if (label) labelled[label] = formatBytes(inner, key.startsWith("max_") ? "down" : "nearest");
+  }
+  return labelled;
+}
+var printAnalysis = (analysis) => `${JSON.stringify(analysis.view === "summary" ? withSizeLabels(analysis) : analysis, null, 2)}
 `;
 function summarize(analysis, divisor) {
   const shortened = {};
@@ -7028,6 +7132,103 @@ function wouldUpload(analysis, force = false) {
   return analysis.blockers.every((blocker) => blocker.overridable && force);
 }
 
+// src/lib/zipTransfer.ts
+var import_node_crypto2 = require("crypto");
+var INLINE_UPLOAD_TIMEOUT_MS = 12e4;
+var ANNOUNCE_TIMEOUT_MS = 3e4;
+var PUT_TIMEOUT_MS = 6e5;
+var COMPLETE_TIMEOUT_MS = 12e4;
+var PUT_ATTEMPTS = 2;
+async function uploadZip(upload, deps = { request, fetch }) {
+  const { route, token, zip, mode, declaration, retry } = upload;
+  if (zip.byteLength <= maxInlineZipBytes(mode, declaration)) {
+    return deps.request(route, {
+      token,
+      retry,
+      timeoutMs: INLINE_UPLOAD_TIMEOUT_MS,
+      body: uploadRequestBody(Buffer.from(zip).toString("base64"), mode, declaration)
+    });
+  }
+  const ticket = await announce(upload, deps);
+  await putZip(ticket, zip, deps);
+  return deps.request(route, {
+    token,
+    retry,
+    timeoutMs: COMPLETE_TIMEOUT_MS,
+    body: completeRequestBody(ticket.upload_id, mode, declaration)
+  });
+}
+async function announce({ route, token, zip, mode, declaration, retry }, deps) {
+  let answer;
+  try {
+    answer = await deps.request(route, {
+      token,
+      retry,
+      timeoutMs: ANNOUNCE_TIMEOUT_MS,
+      body: announceRequestBody(zip.byteLength, (0, import_node_crypto2.createHash)("sha256").update(zip).digest("hex"), mode)
+    });
+  } catch (err2) {
+    if (err2 instanceof ApiError && (err2.code === "direct_upload_unavailable" || err2.code === "missing_zip")) {
+      const [size, allowed] = sizeOverLimit(zip.byteLength, maxInlineZipBytes(mode, declaration));
+      throw new ApiError(
+        err2.status,
+        "direct_upload_unavailable",
+        `The upload is ${size} compressed, and the platform does not take uploads of that size at the moment \u2014 only up to ${allowed}. Nothing was uploaded. Try again later.`
+      );
+    }
+    throw err2;
+  }
+  const headers = answer?.required_headers;
+  const understood = typeof answer?.upload_id === "string" && isHttpUrl(answer?.upload_url) && headers !== null && typeof headers === "object" && !Array.isArray(headers) && Object.values(headers).every((value) => typeof value === "string");
+  if (!understood) {
+    throw new ApiError(
+      0,
+      "invalid_upload_answer",
+      "The platform answered the upload request in a form this version of the CLI does not understand. Nothing was uploaded."
+    );
+  }
+  return { upload_id: answer.upload_id, upload_url: answer.upload_url, required_headers: headers };
+}
+function isHttpUrl(value) {
+  if (typeof value !== "string") return false;
+  try {
+    return ["https:", "http:"].includes(new URL(value).protocol);
+  } catch {
+    return false;
+  }
+}
+async function putZip(ticket, zip, deps) {
+  const deadline = Date.now() + PUT_TIMEOUT_MS;
+  for (let attempt = 1; ; attempt++) {
+    let failure;
+    let again = attempt < PUT_ATTEMPTS;
+    try {
+      const resp = await deps.fetch(ticket.upload_url, {
+        method: "PUT",
+        headers: ticket.required_headers,
+        body: zip,
+        signal: AbortSignal.timeout(Math.max(1, deadline - Date.now()))
+      });
+      if (resp.ok) return;
+      const code = /<Code>([\w.]{1,80})<\/Code>/.exec(await resp.text())?.[1];
+      failure = `the storage answered HTTP ${resp.status}${code ? ` (${code})` : ""}`;
+      again &&= resp.status >= 500;
+    } catch (err2) {
+      const timedOut = err2?.name === "TimeoutError";
+      const code = typeof err2?.cause?.code === "string" && /^\w{1,40}$/.test(err2.cause.code) ? ` (${err2.cause.code})` : "";
+      failure = timedOut ? `it did not finish within ${PUT_TIMEOUT_MS / 6e4} minutes` : `the connection to the storage broke${code}`;
+      again &&= !timedOut;
+    }
+    if (!again) {
+      throw new ApiError(
+        0,
+        "upload_failed",
+        `The upload did not go through: ${failure}. Nothing of the project was changed \u2014 run the push again.`
+      );
+    }
+  }
+}
+
 // src/lib/pushReport.ts
 init_branding();
 var EXCLUDE_REASON = {
@@ -7088,7 +7289,7 @@ function renderAnalysis(analysis, options = {}) {
         lines.push("  HTML files found:");
         for (const candidate of analysis.entry.candidates.slice(0, SHOWN_FILES)) {
           lines.push(
-            `  ${sizeColumn(candidate.bytes)}  ${candidate.path}` + (candidate.title ? paint.dim(`  "${candidate.title}"`) : "") + (candidate.same_content_as ? paint.dim(`  (same content as ${candidate.same_content_as})`) : "")
+            `  ${sizeColumn(candidate.bytes)}  ${candidate.path}` + (candidate.title ? paint.dim(`  "${candidate.title}"`) : "") + (candidate.same_content_as ? paint.dim(`  (same content as ${candidate.same_content_as})`) : "") + (candidate.larger_than_a_push ? paint.dim("  (larger than a whole push)") : "")
           );
         }
         lines.push(...more(analysis.entry.candidates.length, SHOWN_FILES, "HTML file"));
@@ -7569,7 +7770,7 @@ async function pushCommand(opts) {
   ui.step(mode === "source" ? "Packing source tree\u2026" : `Packing built output (${rootDir})\u2026`);
   const declaration = mode === "source" ? readBackendDeclaration() : null;
   const files = collectFiles(rootDir, mode);
-  const zip = zipToBase64(files, maxZipBytesForUpload(mode, declaration));
+  const zip = zipFiles(files, maxZipBytesForUpload());
   ui.info(`${zip.count} files, ${(zip.bytes / 1024).toFixed(0)} KiB compressed`);
   if (declaration) {
     const consent = await ensureDatabaseConsent({
@@ -7587,15 +7788,14 @@ async function pushCommand(opts) {
     }
   }
   ui.step("Uploading to your workspace\u2026");
-  const upload = await request(
-    `${API_URL}/api/workspaces/${userId}/${projectId}/source-zip`,
-    {
-      token: auth.pb_token,
-      body: uploadRequestBody(zip.base64, mode, declaration),
-      timeoutMs: 12e4,
-      retry: platformRetry
-    }
-  );
+  const upload = await uploadZip({
+    route: `${API_URL}/api/workspaces/${userId}/${projectId}/source-zip`,
+    token: auth.pb_token,
+    zip: zip.data,
+    mode,
+    declaration,
+    retry: platformRetry
+  });
   ui.info(`${upload.files_written} files written`);
   if (mode === "source") {
     ui.step("Building in the cloud (this can take a few minutes)\u2026");
@@ -7810,7 +8010,7 @@ init_branding();
 
 // src/lib/engine.ts
 var import_node_fs11 = require("fs");
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var import_node_path13 = require("path");
 var import_node_os4 = require("os");
 var import_node_child_process3 = require("child_process");
@@ -7867,7 +8067,7 @@ async function fetchManifest() {
   }
 }
 async function sha256File(path) {
-  const hash = (0, import_node_crypto2.createHash)("sha256");
+  const hash = (0, import_node_crypto3.createHash)("sha256");
   await (0, import_promises3.pipeline)((0, import_node_fs11.createReadStream)(path), hash);
   return hash.digest("hex");
 }
@@ -8184,7 +8384,7 @@ site can never be uploaded in several parts.
   source), and Managed Server Actions and \`.agentful/backend.json\` are NOT
   deployed by it.
 
-Limits of one push, either way: about ${formatBytes(maxZipBytesForUpload(), "down")} compressed, ${formatBytes(MAX_UNPACKED_BYTES)} of files, ${MAX_UPLOAD_FILES.toLocaleString("en-US")} files.
+Limits of one push, either way: ${formatBytes(MAX_UNPACKED_BYTES)} of files (their sizes added up), ${formatBytes(maxZipBytesForUpload(), "down")} compressed, ${MAX_UPLOAD_FILES.toLocaleString("en-US")} files.
 \`--force\` lifts none of them: it only lets the cloud build try despite a
 compatibility finding.
 
@@ -8193,36 +8393,60 @@ compatibility finding.
 reports what a push would upload: no sign-in, no project, no upload, nothing
 written. Sizes, limits, what is left out and what blocks the upload come from
 that report and from nowhere else: quote its figures, never estimate or
-recompute them (\`limits.max_zip_bytes\` is the exact limit for this push).
-Run it before the first push of a session, after a push was stopped, and after
-you changed what gets uploaded. In between, \`agentful push\` applies the same
+recompute them. Next to every byte count the report prints the size as text
+(\`size\` for \`bytes\`, \`zip_size\` for \`zip_bytes\`): use that text, do not
+convert bytes yourself. \`limits.max_unpacked_bytes\` is the limit a site
+runs into: the sizes of its files added up. Run it before the first push of a
+session, after a push was stopped,
+and after you changed what gets uploaded. In between, \`agentful push\` applies the same
 check itself and stops before sign-in when something blocks. A blocker with
 \`"overridable": false\` is final, the platform rejects that upload: do not
 retry, do not add \`--force\`, do not look for another route.
 
 Every change to the user's files for a push (including \`.gitignore\`) and every
 project script you run for it needs the user's OK first: name the concrete
-change, ask, wait for the answer.
+change, ask, wait for the answer. One question per reply: one decision, not
+several joined together. Never ask what the report or the project files
+answer, such as whether a \`.gitignore\` is in effect
+(\`excluded.gitignore_applied\`), which files are large or which are copies.
 
 - **No start page** (\`entry_missing\`): the platform serves \`index.html\` from
   the top level. With \`entry.candidates\`: show them (path and title;
-  \`same_content_as\` marks copies) and ask which page opens first. A candidate
-  at the top level can be renamed to \`index.html\`, or copied, which keeps the
-  old address and adds the file's size to the upload: ask which. A candidate
-  in a subfolder must not be copied up, its relative links would break. If
-  that folder is the whole site, push the folder (\`suggestions\` carries the
-  command); otherwise adjust the links and show the diff. Without candidates,
-  ask which folder holds the site.
-- **Too large or too many files** (\`zip_too_large\`, \`unpacked_too_large\`,
-  \`too_many_files\`): explain where the size is, from \`largest_files\`,
-  \`by_top_level\`, \`duplicates\` and \`embedded_media\` (media stored inside text
-  files as \`data:\` URLs). The ways out that exist: leave out files the site
-  does not load (\`.gitignore\`, source push), or push only the finished output
-  folder (prebuilt). Before proposing to leave a file out, search the sources
-  for references to it and say what you checked: identical content does not
-  make a copy unused. Never shrink, re-encode, move or delete the user's files
-  on your own. If what the site needs stays above the limits, say plainly that
-  it cannot be pushed yet. Larger uploads are not available.
+  \`same_content_as\` marks copies, \`larger_than_a_push\` marks pages no push
+  can carry: they cannot be the start page as they are, say so) and ask which
+  of the others opens first. A candidate at the top level can be renamed to
+  \`index.html\`, or copied, which keeps the old address and adds the file's
+  size to the upload: ask which. A candidate in a subfolder must not be copied
+  up, its relative links would break. If that folder is the whole site, push
+  the folder (\`suggestions\` carries the command); otherwise adjust the links
+  and show the diff. Without candidates, ask which folder holds the site.
+- **Too large or too many files** (\`unpacked_too_large\`, \`zip_too_large\`,
+  \`too_many_files\`): settle first whether the site can fit at all. A size
+  blocker names the files that are each larger than a whole push on their own
+  (all of them in its \`paths\`), and its message says what is left without
+  them. Such a file can only stay out. If
+  the site needs one of them (the page the user wants as the start page, or a
+  file a page loads: search the sources for references), the site cannot be
+  pushed yet: say that plainly, with the file and its size. Do not offer
+  \`.gitignore\` or a prebuilt push as a way around it, neither lifts a limit,
+  and larger uploads are not available.
+  Where no such file is needed: explain where the size is, from
+  \`largest_files\`, \`by_top_level\`, \`duplicates\` and \`embedded_media\` (media
+  stored inside text files as \`data:\` URLs), and propose which files the site
+  does not load to leave out with \`.gitignore\`. The \`exclude_with_gitignore\`
+  suggestion says how much has to stay out; if the site needs more than fits,
+  say plainly that it cannot be pushed yet. Before proposing to leave a file
+  out, search the sources for references to it and say what you checked:
+  identical content does not make a copy unused. A prebuilt push is smaller
+  than a source push only where a build produces the output folder; a site
+  without a build step is the same upload either way. Never shrink,
+  re-encode, move or delete the user's files on your own.
+- **Files the preview does not show** (\`preview_file_too_large\`,
+  \`preview_type_not_delivered\` in \`warnings\`): the push goes through, but
+  the preview does not deliver these files, so a page that needs one of them
+  looks broken there. Say which files and why, with the wording of the
+  warning, and ask whether to push anyway. Never shrink, convert or split
+  them on your own.
 - **Compatibility findings** (\`"overridable": true\`): fix the cause in the
   code. \`--force\` only when the user asks to try the cloud build anyway.
 - **Files that would be missing on the site:** the warnings
@@ -8416,7 +8640,7 @@ ${backendSessionLines(backend)}
 }
 
 // src/branding/commands.ts
-var PUSH_TOOL_TIMEOUT_MS = 9e5;
+var PUSH_TOOL_TIMEOUT_MS = 156e4;
 var NEEDS_A_PUSH = 'If the command reports "No Agentful project here", nothing has been deployed from this directory yet \u2014 run `agentful push` first (it creates the project and a preview), then retry.';
 var SLASH_COMMANDS = {
   setup: {
@@ -8434,8 +8658,8 @@ var SLASH_COMMANDS = {
     description: `${brand.displayName}: check, deploy and get a preview URL`,
     template: `Deploy this project, following "Pushing to the platform" in AGENTFUL_CLOUD.md. Run every command from the project root using the bash tool. What I typed after the command (may be empty): "$ARGUMENTS". If it names \`--prebuilt\`, a folder for \`--dir\`, or \`--force\`, pass that on to both commands below.
 
-1. Run \`${PUSH_ANALYSIS_COMMAND}\`. It only reads files: no sign-in, no upload. Its JSON report is the only source for sizes, limits and what blocks the upload: quote its figures, never estimate them.
-2. If the report or the project calls for a decision (a blocker, a file the site needs that would not be uploaded, a build step the cloud does not run), explain the finding in plain words with the figures of the report and ask me how to proceed. One question at a time, then wait for my answer. Until then do not change any file, do not run project scripts and do not push.
+1. Run \`${PUSH_ANALYSIS_COMMAND}\`. It only reads files: no sign-in, no upload. Its JSON report is the only source for sizes, limits and what blocks the upload: quote its figures as printed (the \`size\` texts next to the byte counts), never estimate or convert them.
+2. If the report or the project calls for a decision (a blocker, a file the site needs that would not be uploaded or that the preview would not show, a build step the cloud does not run), explain the finding in plain words with the figures of the report. If the report shows that what I want to publish cannot fit (a page or file it needs is larger than a whole push, or it stays above the limits without the files it does not load), say that plainly and do not offer ways out that do not get it under the limits. Otherwise ask me how to proceed: exactly one question per reply, and never one the report or the project files answer. Then wait for my answer. Until then do not change any file, do not run project scripts and do not push.
 3. After a change I approved, run the analysis again.
 4. When nothing blocks, run \`agentful push\` with the bash tool's \`timeout\` set to ${PUSH_TOOL_TIMEOUT_MS} (milliseconds): the cloud build takes minutes and the default timeout would cut the push off halfway. The command never waits for input. It creates the project automatically if this directory is not linked yet.
 5. Report the preview URL on its own line and what the push printed about the backend. If it fails: quote the printed error verbatim, and if the failure happened in the cloud (not before the upload), also run \`agentful build-status\` and quote its phase/error/details as the cause. Diagnose ONLY from those records \u2014 never invent causes, env vars, or settings they do not show.
@@ -9268,7 +9492,7 @@ function describeModelRoute(model, catalog, localProviders, connectedProviders)
 }
 
 // src/lib/engineEvents.ts
-var import_node_crypto3 = require("crypto");
+var import_node_crypto4 = require("crypto");
 var import_node_net = require("net");
 function payloadOf(event) {
   return event.payload && typeof event.payload === "object" ? event.payload : event;
@@ -9394,7 +9618,7 @@ var EngineLivenessPolicy = class {
 function engineServerCredentials(env = process.env) {
   return {
     username: env.OPENCODE_SERVER_USERNAME || void 0,
-    password: env.OPENCODE_SERVER_PASSWORD || (0, import_node_crypto3.randomUUID)()
+    password: env.OPENCODE_SERVER_PASSWORD || (0, import_node_crypto4.randomUUID)()
   };
 }
 async function reserveLoopbackPort() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentful",
-  "version": "0.4.15",
+  "version": "0.4.17",
   "description": "Agentful in your terminal — local development with push-to-cloud previews",
   "license": "Apache-2.0",
   "homepage": "https://agentful.dev",