@getexception/cli 0.1.13 → 0.1.14

package/README.md

@@ -26,9 +26,9 @@ Permanent upload tokens cannot be created or used for projects with GitLab authe
 
 Deploy the resulting `dist` unchanged. Upload failure does not undo preparation: retry within the same job using the same prepared directory. **Do not save source maps as GitLab artifacts or cache when access has not been verified.** The GitLab identity flow keeps them only in the isolated job workspace and uploads directly to GetException. A retry after that job ends requires a new build with a new job prefix; it cannot replace maps for the old build. Do not run `prepare` twice or rebuild only the maps. Never publish the private artifact directory alongside the application. Other map formats (for example CSS maps) should also be excluded from the public deploy artifact by your build configuration.
 
-`upload` sends an authenticated manifest, uploads files with checksums, then waits for background validation. It supports retries and resuming the same manifest, has a two-minute deadline, and exits nonzero on failure. Neither production nor preview deployment depends on GetException availability. The CI wrapper catches monitoring failures, emits a prominent production warning or a single neutral preview log line, and continues deployment after the mandatory public-output safety check. Only report successful map delivery when all batches are ready. A failed local prepare requires one clean rebuild without maps; an upload failure may deploy already prepared, verified JavaScript. Do not retain maps in GitLab artifacts as a fallback. Raw maps have no download endpoint.
+`upload` sends an authenticated manifest, gzip-compresses each map in memory, uploads up to eight files concurrently with checksums, then waits for background validation. It retries bounded transient network/server failures, resumes the same manifest from its missing files, has a twenty-minute deadline per batch, and exits nonzero on failure. Neither production nor preview deployment depends on GetException availability. Deploy the safe prepared JavaScript first, then attempt map delivery from the same isolated job workspace. The CI wrapper catches monitoring failures and emits a prominent production warning or a single neutral preview log line. Only report successful map delivery when all batches are ready. A failed local prepare requires one clean rebuild without maps; a late successful upload automatically reprocesses existing errors. Do not retain maps in GitLab artifacts as a fallback. Raw maps have no download endpoint.
 
-Limits: 128 JS files and 128 MiB per upload, 16 MiB per map, 1 GiB per project, 10 GiB per installation. Non-indexed Source Map v3 JSON only; no archives, compression or remote source downloads. Existing events are processed after a late upload. Errors thrown in the browser console have no source file and cannot gain a source snippet from a map.
+Limits: 128 JS files and 128 MiB per upload, 16 MiB per map, 1 GiB per project, 10 GiB per installation. Non-indexed Source Map v3 JSON only; no archives or remote source downloads. Gzip is used only as bounded HTTPS transfer encoding and does not change the stored map format. Existing events are processed after a late upload. Errors thrown in the browser console have no source file and cannot gain a source snippet from a map.
 
 MIT. See `THIRD-PARTY-NOTICES.md`.
 
@@ -46,6 +46,6 @@ With GitLab build authentication, use the exact `release` and `deployment` retur
 
 Debug IDs are deterministic for identical JS, maps and paths, regardless of the release SHA. The server reuses private bytes within the project and `upload` skips files it already has. Every release still sends its own manifest. Changed JavaScript requires its matching map: there is no fallback to the latest production map. Ready maps older than 30 days are eligible for cleanup only when their release has no retained events or pending inbox events. Shared files survive until all references expire.
 
-CI wrappers must bound subprocess duration and share a network budget across context, upload batches and registration; see the [failure handling contract](../../docs/gitlab-ci.md#обработка-сбоев-в-account). Do not mark the whole build job as allowed to fail. Compiler, deployment and public-output safety failures remain real job failures.
+CI wrappers must keep `ci context` and release registration on short timeouts. Run map delivery only after the application is deployed and give each upload subprocess a hard timeout slightly longer than the CLI's twenty-minute deadline. Do not impose one small shared timeout on all batches: that makes valid larger builds fail based on transfer time. See the [failure handling contract](../../docs/gitlab-ci.md#обработка-сбоев-в-account). Do not mark the whole build job as allowed to fail. Compiler, deployment and public-output safety failures remain real job failures.
 
 On failure the CLI exits 1 and prints one `GETEXCEPTION_DIAGNOSTIC` JSON line to stderr with `version:1`, an allowlisted `code`, optional `httpStatus` and optional server UUID `requestId`. Network, response-contract and CI identity failures have separate codes. It never prints raw errors, tokens, headers or response bodies. Callers must parse and validate this diagnostic, not forward arbitrary stderr. Successful `ci context` stdout remains JSON only. Older CLI versions without this format can be handled with a generic safe failure code without blocking application deployment.

package/dist/index.js

@@ -19217,7 +19217,9 @@ async function readPreparedMap(directory, entry) {
 }
 
 // packages/cli/src/upload.ts
+import { promisify } from "util";
 import { setTimeout as delay2 } from "timers/promises";
+import { constants, gzip } from "zlib";
 
 // packages/cli/src/api.ts
 import { setTimeout as delay } from "timers/promises";
@@ -19378,7 +19380,15 @@ async function httpError(response) {
 }
 
 // packages/cli/src/api.ts
-function projectApi(address, project, token, transport = fetch) {
+function retryableNetworkError(error61) {
+  return [
+    "NETWORK_DNS",
+    "NETWORK_CONNECTION",
+    "NETWORK_TIMEOUT",
+    "NETWORK_ERROR"
+  ].includes(error61.code);
+}
+function projectApi(address, project, token, transport = fetch, options = {}) {
   let url2;
   try {
     url2 = new URL(address);
@@ -19393,8 +19403,9 @@ function projectApi(address, project, token, transport = fetch) {
   }
   const authorization = authorizationHeader(token);
   const base = `${url2.origin}/api/v1/projects/${project}`;
-  const deadline = Date.now() + 12e4;
-  return async function request(path, method = "GET", body) {
+  const deadline = Date.now() + (options.deadlineMs ?? 12e4);
+  const requestTimeout = options.requestTimeoutMs ?? 3e4;
+  return async function request(path, method = "GET", body, contentEncoding) {
     for (let attempt = 0; attempt < 3; attempt++) {
       if (Date.now() >= deadline) {
         throw new CliError("NETWORK_TIMEOUT");
@@ -19405,15 +19416,23 @@ function projectApi(address, project, token, transport = fetch) {
           method,
           headers: {
             Authorization: authorization,
-            "Content-Type": "application/json"
+            "Content-Type": "application/json",
+            ...contentEncoding ? { "Content-Encoding": contentEncoding } : {}
           },
           body,
           redirect: "error",
           credentials: "omit",
-          signal: AbortSignal.timeout(Math.min(3e4, deadline - Date.now()))
+          signal: AbortSignal.timeout(
+            Math.min(requestTimeout, deadline - Date.now())
+          )
         });
       } catch (error61) {
-        throw networkError(error61);
+        const failure = networkError(error61);
+        if (retryableNetworkError(failure) && attempt < 2) {
+          await delay(1e3 * 2 ** attempt);
+          continue;
+        }
+        throw failure;
       }
       if (response.ok) {
         return responseJson(response);
@@ -19442,10 +19461,15 @@ var receiptSchema = external_exports.object({
   )
 });
 var uploadConcurrency = 8;
+var uploadDeadlineMs = 20 * 6e4;
+var gzipAsync = promisify(gzip);
 async function uploadMaps(directory, address, project, token, transport = fetch) {
   const manifest = await readPrepared(directory);
-  const api = projectApi(address, project, token, transport);
-  const request = (path, method = "GET", body) => api("/source-maps" + path, method, body);
+  const api = projectApi(address, project, token, transport, {
+    deadlineMs: uploadDeadlineMs,
+    requestTimeoutMs: 6e4
+  });
+  const request = (path, method = "GET", body, contentEncoding) => api("/source-maps" + path, method, body, contentEncoding);
   const receipt = receiptSchema.parse(
     await request("", "POST", JSON.stringify(manifest))
   );
@@ -19467,13 +19491,18 @@ async function uploadMaps(directory, address, project, token, transport = fetch)
     for (let start = 0; start < pending.length; start += uploadConcurrency) {
       const group = pending.slice(start, start + uploadConcurrency);
       await Promise.all(
-        group.map(
-          async ({ entry, id }) => request(
+        group.map(async ({ entry, id }) => {
+          const bytes = await readPreparedMap(directory, entry);
+          const compressed = await gzipAsync(bytes, {
+            level: constants.Z_BEST_SPEED
+          });
+          return request(
             `/${receipt.uploadId}/${id}`,
             "PUT",
-            await readPreparedMap(directory, entry)
-          )
-        )
+            compressed,
+            "gzip"
+          );
+        })
       );
     }
     await request(`/${receipt.uploadId}`, "POST");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getexception/cli",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Private source map uploads for GetException",
   "type": "module",
   "license": "MIT",