agentful 0.4.16 → 0.4.17

package/README.md

@@ -44,9 +44,12 @@ 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

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.16" ? "0.4.16" : 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(".");
@@ -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,10 +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(mode, mode === "source" ? readBackendDeclaration(rootDir) : null);
-  const oversized = measured.filter((file) => file.zipLower > maxZipBytes).sort((a, b) => b.zipLower - a.zipLower || byPath(a, b));
+  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");
@@ -6747,7 +6789,7 @@ function analyzePush(options) {
       title: file.title,
       sha256: file.sha256,
       same_content_as: first && first !== file.path ? first : null,
-      ...file.zipLower > maxZipBytes ? { larger_than_a_push: true } : {}
+      ...oversizedPaths.has(file.path) ? { larger_than_a_push: true } : {}
     };
   });
   const fittingCandidates = candidates.filter((candidate) => !candidate.larger_than_a_push);
@@ -6778,28 +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 one = oversized.length === 1;
-      const named = samplePaths(oversized.map((file) => `${file.path} (${sizeOverLimit(file.zipLower, maxZipBytes)[0]})`));
-      message += one ? ` ${named} is larger than that on its own, so no push can carry it.` : ` ${plural(oversized.length, "file")} are each larger than that on their own, so no push can carry them: ${named}.`;
-      message += ` Without ${one ? "it" : "them"} the upload is ${restZipLower > maxZipBytes ? `still ${sizeOverLimit(restZipLower, maxZipBytes)[0]} compressed` : `${formatBytes(restZipLower)} compressed, which is within that limit`}.`;
+      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,
-      ...oversized.length > 0 ? { paths: oversized.map((file) => file.path).slice(0, FINDING_PATHS) } : {}
+      ...namedHere.length > 0 ? { paths: namedHere.map((file) => file.path).slice(0, FINDING_PATHS) } : {}
     });
   } else if (!zipExact && zipBytes > maxZipBytes) {
     warnings.push({
@@ -6845,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({
@@ -6888,14 +6960,16 @@ function analyzePush(options) {
     ].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 spareZipBytes = spareCopies.reduce((total, group) => total + group.redundant_zip_bytes, 0);
-    const base = oversized.length > 0 ? restZipLower : zipBytes;
-    if (spareCopies.length > 0 && spareZipBytes >= base / 20) {
+    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 - spareZipBytes;
+      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(spareZipBytes)} to the 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 > maxZipBytes ? ` \u2014 still above the ${zipLimit} limit` : ""}.`,
+        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)
       });
     }
@@ -7058,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 = {
@@ -7599,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({
@@ -7617,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");
@@ -7840,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");
@@ -7897,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");
 }
@@ -8214,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.
 
@@ -8225,8 +8395,9 @@ 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. 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_zip_bytes\` is the exact limit for this
-push. Run it before the first push of a session, after a push was stopped,
+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
@@ -8249,11 +8420,11 @@ answer, such as whether a \`.gitignore\` is in effect
   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\`): settle first whether the site can fit at all. The
-  \`zip_too_large\` 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
+- **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
@@ -8270,6 +8441,12 @@ answer, such as whether a \`.gitignore\` is in effect
   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
@@ -8463,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: {
@@ -8482,7 +8659,7 @@ var SLASH_COMMANDS = {
     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 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, 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.
+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.
@@ -9315,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;
@@ -9441,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.16",
+  "version": "0.4.17",
   "description": "Agentful in your terminal — local development with push-to-cloud previews",
   "license": "Apache-2.0",
   "homepage": "https://agentful.dev",