hillclimb 0.9.12 → 0.9.13

package/dist/main.js

@@ -118,19 +118,28 @@ import https from "https";
 import net from "net";
 var DEFAULT_SOCKET_IDLE_TIMEOUT_MS = 12e4;
 var DEFAULT_DEADLINE_MS = 60 * 6e4;
+var DEADLINE_FLOOR_BYTES_PER_SECOND = 128 * 1024;
+var BUFFER_BODY_SLICE_BYTES = 64 * 1024;
+function defaultPutDeadlineMs(bodyBytes) {
+  return Math.max(
+    DEFAULT_DEADLINE_MS,
+    Math.ceil(bodyBytes / DEADLINE_FLOOR_BYTES_PER_SECOND) * 1e3
+  );
+}
 var MAX_RESPONSE_BODY_BYTES = 64 * 1024;
 async function putToPresignedUrl(url, headers, body, options) {
   const socketIdleTimeoutMs = options?.socketIdleTimeoutMs ?? DEFAULT_SOCKET_IDLE_TIMEOUT_MS;
-  const deadlineMs = options?.deadlineMs ?? DEFAULT_DEADLINE_MS;
   const parsed = new URL(url);
   const transport = parsed.protocol === "http:" ? http : https;
   const contentLength = body.kind === "buffer" ? body.buffer.byteLength : body.sizeBytes;
+  const deadlineMs = options?.deadlineMs ?? defaultPutDeadlineMs(contentLength);
   const start = Date.now();
   return new Promise((resolve, reject) => {
     let inputStream;
     let progressTimer;
     let phase = "connecting";
     let requestFinished = false;
+    let bodyBytesWritten = 0;
     const seen = {};
     const snapshot = () => ({
       elapsedMs: Date.now() - start,
@@ -138,6 +147,7 @@ async function putToPresignedUrl(url, headers, body, options) {
       requestFinished,
       totalBodyBytes: contentLength,
       ...inputStream ? { bodyBytesRead: inputStream.bytesRead } : {},
+      ...body.kind === "buffer" ? { bodyBytesWritten } : {},
       ...seen,
       // Bun fills the peer address in only after 'connect'.
       remoteAddress: seen.remoteAddress ?? req.socket?.remoteAddress
@@ -150,6 +160,7 @@ async function putToPresignedUrl(url, headers, body, options) {
       clearTimeout(deadlineTimer);
       clearInterval(progressTimer);
       inputStream?.destroy();
+      if (!requestFinished) req.destroy();
       resolve({ ...result, attempt });
     };
     const settleReject = (err) => {
@@ -174,6 +185,7 @@ async function putToPresignedUrl(url, headers, body, options) {
       },
       (res) => {
         phase = "receiving-response";
+        seen.responseMs = Date.now() - start;
         seen.status = res.statusCode;
         const header2 = (name) => {
           const value = res.headers[name];
@@ -240,6 +252,7 @@ async function putToPresignedUrl(url, headers, body, options) {
     req.on("finish", () => {
       if (req.socket?.errored) return;
       requestFinished = true;
+      seen.finishMs = Date.now() - start;
       if (phase !== "receiving-response") phase = "awaiting-response";
     });
     if (options?.onProgress) {
@@ -248,6 +261,7 @@ async function putToPresignedUrl(url, headers, body, options) {
           elapsedMs: Date.now() - start,
           phase,
           socketBytesWritten: req.socket?.bytesWritten ?? 0,
+          ...body.kind === "buffer" ? { bodyBytesWritten } : {},
           totalBodyBytes: contentLength,
           requestFinished
         });
@@ -262,8 +276,33 @@ async function putToPresignedUrl(url, headers, body, options) {
       req.destroy(err);
     });
     req.on("error", settleReject);
-    if (body.kind === "buffer") {
-      req.end(body.buffer);
+    if (body.kind === "buffer" && process.versions.bun) {
+      const size = body.buffer.byteLength;
+      req.end(body.buffer, () => {
+        bodyBytesWritten = size;
+      });
+    } else if (body.kind === "buffer") {
+      const buffer = body.buffer;
+      let offset = 0;
+      const writeSlices = () => {
+        while (offset < buffer.byteLength) {
+          if (settled || req.destroyed) return;
+          const slice = buffer.subarray(
+            offset,
+            offset + BUFFER_BODY_SLICE_BYTES
+          );
+          offset += slice.byteLength;
+          const drained = req.write(slice, (err) => {
+            if (!err) bodyBytesWritten += slice.byteLength;
+          });
+          if (!drained) {
+            req.once("drain", writeSlices);
+            return;
+          }
+        }
+        req.end();
+      };
+      writeSlices();
     } else {
       inputStream = fs2.createReadStream(body.path);
       inputStream.on("error", (err) => {
@@ -388,6 +427,19 @@ function putRetryDelayMs(input) {
 
 // src/platform/client.ts
 var API_REQUEST_TIMEOUT_MS = 3e4;
+async function digestPutBody(body) {
+  const sha256 = createHash("sha256");
+  const md5 = createHash("md5");
+  let size = 0;
+  const update = (chunk) => {
+    sha256.update(chunk);
+    md5.update(chunk);
+    size += chunk.length;
+  };
+  if (body.kind === "buffer") update(body.buffer);
+  else for await (const chunk of fs3.createReadStream(body.path)) update(chunk);
+  return { sha256: sha256.digest("hex"), md5: md5.digest("hex"), size };
+}
 var PlatformError = class extends Error {
   constructor(message, status, code) {
     super(message);
@@ -639,30 +691,20 @@ var PlatformClient = class {
   async uploadReplayableArtifact(contributionId, input, body) {
     const sizeBytes = body.kind === "buffer" ? body.buffer.length : body.sizeBytes;
     const prefix = `/api/v1/contributions/${encodeURIComponent(contributionId)}`;
-    let digest;
+    let digests;
     const verify = async (uploadId, options = {}) => {
-      if (digest === void 0) {
-        const hash = createHash("sha256");
-        let localSize = 0;
-        if (body.kind === "buffer") {
-          hash.update(body.buffer);
-          localSize = body.buffer.length;
-        } else {
-          for await (const chunk of fs3.createReadStream(body.path)) {
-            hash.update(chunk);
-            localSize += chunk.length;
-          }
-        }
-        if (localSize !== sizeBytes)
+      if (digests === void 0) {
+        const local = await digestPutBody(body);
+        if (local.size !== sizeBytes)
           throw new PlatformError(
             "Prepared artifact size does not match its manifest"
           );
-        digest = hash.digest("hex");
+        digests = local;
       }
-      return this.verifyReplayArtifact(
+      return this.verifyStoredArtifact(
         `${prefix}/uploads/${encodeURIComponent(uploadId)}/download`,
         sizeBytes,
-        digest,
+        digests,
         options
       );
     };
@@ -739,7 +781,12 @@ var PlatformClient = class {
     }
     await put(target);
   }
-  async verifyReplayArtifact(relative, sizeBytes, expectedDigest, options = {}) {
+  /**
+   * Does storage hold exactly these bytes for an upload? Absent answers
+   * `exists: false`; different bytes throw UPLOAD_REPLAY_MISMATCH.
+   */
+  async verifyStoredArtifact(relative, sizeBytes, digests, options = {}) {
+    const logPrefix = options.logPrefix ?? "upload-replay";
     const redirect = await fetch(this.url(relative), {
       headers: this.headers(),
       redirect: "manual",
@@ -773,24 +820,42 @@ var PlatformClient = class {
         "Upload verification requires a secure storage target"
       );
     }
-    let response;
-    try {
-      response = await fetch(target, {
-        redirect: "error",
-        signal: AbortSignal.timeout(60 * 60 * 1e3)
-      });
-    } catch {
-      throw new PlatformError("Stored artifact verification request failed");
-    }
+    const get = async (range) => {
+      try {
+        return await fetch(target, {
+          redirect: "error",
+          ...range ? { headers: { range: "bytes=0-0" } } : {},
+          signal: AbortSignal.timeout(60 * 60 * 1e3)
+        });
+      } catch {
+        throw new PlatformError("Stored artifact verification request failed");
+      }
+    };
+    let response = await get(sizeBytes > 0);
     if (response.status === 404 || response.status === 403 && options.forbiddenIsAbsent) {
       await response.body?.cancel();
       if (response.status === 403)
         appendLog(
           "info",
-          "upload-replay: storage refused the pending artifact (403); treating it as never written and letting the guarded PUT decide"
+          `${logPrefix}: storage refused the pending artifact (403); treating it as never written and letting the guarded PUT decide`
         );
       return { exists: false, url: location };
     }
+    if (response.status === 206) {
+      await response.body?.cancel();
+      const total = /\/(\d+)$/.exec(
+        response.headers.get("content-range") ?? ""
+      )?.[1];
+      const etag = response.headers.get("etag")?.replace(/"/g, "");
+      if (Number(total) === sizeBytes && etag === digests.md5) {
+        appendLog(
+          "info",
+          `${logPrefix}: verified immutable stored artifact by ETag (bytes=${sizeBytes})`
+        );
+        return { exists: true, url: location };
+      }
+      response = await get(false);
+    }
     if (!response.ok) {
       await response.body?.cancel();
       throw new PlatformError(
@@ -822,7 +887,7 @@ var PlatformClient = class {
       await reader?.cancel().catch(() => {
       });
     }
-    if (bytes !== sizeBytes || hash.digest("hex") !== expectedDigest) {
+    if (bytes !== sizeBytes || hash.digest("hex") !== digests.sha256) {
       throw new PlatformError(
         "Stored artifact does not match the pending bytes",
         409,
@@ -831,10 +896,39 @@ var PlatformClient = class {
     }
     appendLog(
       "info",
-      `upload-replay: verified immutable stored artifact (bytes=${bytes})`
+      `${logPrefix}: verified immutable stored artifact (bytes=${bytes})`
     );
     return { exists: true, url: location };
   }
+  /**
+   * The whole body left this machine but no response came back. The object
+   * may still have landed: on Windows the OS finishes sending in the
+   * background after we close, and a response can be lost on the way back.
+   * Storage is the source of truth, so ask it before failing the upload.
+   */
+  async storedAfterLostResponse(refresh, body, sizeBytes, logPrefix, label) {
+    try {
+      const digests = await digestPutBody(body);
+      if (digests.size !== sizeBytes) return false;
+      const { exists } = await this.verifyStoredArtifact(
+        `/api/v1/contributions/${encodeURIComponent(refresh.contributionId)}/uploads/${encodeURIComponent(refresh.uploadId)}/download`,
+        sizeBytes,
+        digests,
+        { forbiddenIsAbsent: true, logPrefix: `${logPrefix} delivery check` }
+      );
+      appendLog(
+        exists ? "warn" : "info",
+        exists ? `${logPrefix} no response after the full body was sent, but storage holds exactly these bytes; treating the upload as complete | ${label}` : `${logPrefix} no response after the full body was sent, and storage does not hold the object | ${label}`
+      );
+      return exists;
+    } catch (error) {
+      appendLog(
+        "warn",
+        `${logPrefix} delivery check failed after a lost response: ${formatError(error)} | ${label}`
+      );
+      return false;
+    }
+  }
   async uploadToPresignedUrl(presignedUrl, headers, body, refresh) {
     await this.putToPresignedUrlLogged(
       presignedUrl,
@@ -877,7 +971,7 @@ var PlatformClient = class {
         res = await putToPresignedUrl(presignedUrl, headers, body, {
           onProgress: (progress) => appendLog(
             "info",
-            `[PUT ${host}] progress (attempt=${attempt}, phase=${progress.phase}, elapsedMs=${progress.elapsedMs}, requestFinished=${progress.requestFinished}, socketBytesWritten=${progress.socketBytesWritten}, totalBodyBytes=${progress.totalBodyBytes}) | ${label}`
+            `[PUT ${host}] progress (attempt=${attempt}, phase=${progress.phase}, elapsedMs=${progress.elapsedMs}, requestFinished=${progress.requestFinished}, socketBytesWritten=${progress.socketBytesWritten}${progress.bodyBytesWritten !== void 0 ? `, bodyBytesWritten=${progress.bodyBytesWritten}` : ""}, totalBodyBytes=${progress.totalBodyBytes}) | ${label}`
           )
         });
       } catch (err) {
@@ -900,6 +994,14 @@ var PlatformClient = class {
           "error",
           `[PUT ${host}] FAILED ${Date.now() - start}ms ${formatError(err)} (attempt ${attempt}/${maxAttempts}) ${diagnostics2}`
         );
+        if (refresh && err.putAttempt?.requestFinished && await this.storedAfterLostResponse(
+          refresh,
+          body,
+          sizeBytes,
+          `[PUT ${host}]`,
+          label
+        ))
+          return;
         throw err;
       }
       const elapsedMs = Date.now() - start;
@@ -1002,6 +1104,12 @@ function formatPutAttempt(attempt) {
     );
     if (attempt.bodyBytesRead !== void 0)
       fields.push(`bodyBytesRead=${attempt.bodyBytesRead}`);
+    if (attempt.bodyBytesWritten !== void 0)
+      fields.push(`bodyBytesWritten=${attempt.bodyBytesWritten}`);
+    if (attempt.finishMs !== void 0)
+      fields.push(`finishMs=${attempt.finishMs}`);
+    if (attempt.responseMs !== void 0)
+      fields.push(`responseMs=${attempt.responseMs}`);
     if (attempt.connectMs !== void 0)
       fields.push(`connectMs=${attempt.connectMs}`);
     if (attempt.tlsMs !== void 0) fields.push(`tlsMs=${attempt.tlsMs}`);
@@ -18764,7 +18872,7 @@ async function uploadArtifact(client, contributionId, filename, mimeType, buffer
 }
 
 // package.json
-var version = "0.9.12";
+var version = "0.9.13";
 
 // src/version.ts
 var CLI_VERSION = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hillclimb",
-  "version": "0.9.12",
+  "version": "0.9.13",
   "description": "Extract and export AI coding tool logs grouped by repo",
   "license": "MIT",
   "type": "module",