hillclimb 0.9.7 → 0.9.9

package/dist/main.js

@@ -115,6 +115,7 @@ function formatError(err) {
 import fs2 from "fs";
 import http from "http";
 import https from "https";
+import net from "net";
 var DEFAULT_SOCKET_IDLE_TIMEOUT_MS = 12e4;
 var DEFAULT_DEADLINE_MS = 60 * 6e4;
 var MAX_RESPONSE_BODY_BYTES = 64 * 1024;
@@ -129,18 +130,33 @@ async function putToPresignedUrl(url, headers, body, options) {
     let inputStream;
     let progressTimer;
     let phase = "connecting";
+    let requestFinished = false;
+    const seen = {};
+    const snapshot = () => ({
+      elapsedMs: Date.now() - start,
+      phase,
+      requestFinished,
+      totalBodyBytes: contentLength,
+      ...inputStream ? { bodyBytesRead: inputStream.bytesRead } : {},
+      ...seen,
+      // Bun fills the peer address in only after 'connect'.
+      remoteAddress: seen.remoteAddress ?? req.socket?.remoteAddress
+    });
     let settled = false;
     const settleResolve = (result) => {
       if (settled) return;
       settled = true;
+      const attempt = snapshot();
       clearTimeout(deadlineTimer);
       clearInterval(progressTimer);
       inputStream?.destroy();
-      resolve(result);
+      resolve({ ...result, attempt });
     };
     const settleReject = (err) => {
       if (settled) return;
       settled = true;
+      err.message = redactLocalAddress(err.message);
+      err.putAttempt = snapshot();
       clearTimeout(deadlineTimer);
       clearInterval(progressTimer);
       inputStream?.destroy();
@@ -158,6 +174,13 @@ async function putToPresignedUrl(url, headers, body, options) {
       },
       (res) => {
         phase = "receiving-response";
+        seen.status = res.statusCode;
+        const header2 = (name) => {
+          const value = res.headers[name];
+          return Array.isArray(value) ? value[0] : value;
+        };
+        seen.requestId = header2("x-amz-request-id");
+        seen.hostId = header2("x-amz-id-2");
         const chunks = [];
         let buffered = 0;
         res.on("data", (chunk) => {
@@ -191,11 +214,32 @@ async function putToPresignedUrl(url, headers, body, options) {
       const connected = () => {
         if (phase === "connecting") phase = "sending";
       };
-      if (parsed.protocol === "https:") socket.once("secureConnect", connected);
-      else if (!socket.connecting) connected();
+      const tcpConnected = () => {
+        seen.connectMs = Date.now() - start;
+        seen.remoteAddress = socket.remoteAddress;
+        seen.localNet = addressClass(socket.localAddress);
+      };
+      if (!socket.connecting) tcpConnected();
+      else socket.once("connect", tcpConnected);
+      if (parsed.protocol === "https:") {
+        socket.once("secureConnect", () => {
+          seen.tlsMs = Date.now() - start;
+          const secure = socket;
+          try {
+            seen.tlsProtocol = secure.getProtocol?.() ?? void 0;
+            const issuer = secure.getPeerCertificate?.()?.issuer;
+            const name = [issuer?.O, issuer?.CN].filter(Boolean).join("/");
+            if (name) seen.tlsIssuer = name;
+          } catch {
+          }
+          connected();
+        });
+      } else if (!socket.connecting) connected();
       else socket.once("connect", connected);
     });
     req.on("finish", () => {
+      if (req.socket?.errored) return;
+      requestFinished = true;
       if (phase !== "receiving-response") phase = "awaiting-response";
     });
     if (options?.onProgress) {
@@ -204,7 +248,8 @@ async function putToPresignedUrl(url, headers, body, options) {
           elapsedMs: Date.now() - start,
           phase,
           socketBytesWritten: req.socket?.bytesWritten ?? 0,
-          totalBodyBytes: contentLength
+          totalBodyBytes: contentLength,
+          requestFinished
         });
       }, options.progressIntervalMs ?? 3e4);
       progressTimer.unref();
@@ -229,10 +274,36 @@ async function putToPresignedUrl(url, headers, body, options) {
     }
   });
 }
+function addressClass(address) {
+  if (!address) return void 0;
+  const ip = address.startsWith("::ffff:") ? address.slice(7) : address;
+  if (net.isIPv4(ip)) {
+    const [a, b] = ip.split(".").map(Number);
+    if (a === 10 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168)
+      return "private";
+    if (a === 100 && b >= 64 && b <= 127) return "cgnat";
+    if (a === 169 && b === 254) return "link-local";
+    if (a === 127) return "loopback";
+    return "public";
+  }
+  const lower = ip.toLowerCase();
+  if (lower === "::1") return "loopback";
+  if (/^fe[89ab]/.test(lower)) return "link-local";
+  if (/^f[cd]/.test(lower)) return "private";
+  return "public";
+}
+function redactLocalAddress(message) {
+  return message.replace(/ - Local \([^)]*\)/g, "");
+}
 
 // src/platform/retry.ts
 var MAX_ATTEMPTS = 3;
-var TRANSIENT_DELAYS_MS = [1e3, 3e3];
+var LARGE_PUT_BYTES = 8 * 1024 * 1024;
+var LARGE_PUT_MAX_ATTEMPTS = 5;
+function putMaxAttempts(bodyBytes) {
+  return bodyBytes >= LARGE_PUT_BYTES ? LARGE_PUT_MAX_ATTEMPTS : MAX_ATTEMPTS;
+}
+var TRANSIENT_DELAYS_MS = [1e3, 3e3, 1e4, 3e4];
 var RATE_LIMIT_DELAYS_MS = [5e3, 15e3];
 var MAX_RETRY_AFTER_MS = 3e4;
 var CONNECT_FAILURE_CODES = /* @__PURE__ */ new Set([
@@ -301,7 +372,7 @@ function apiRetryDelayMs(input) {
   return null;
 }
 function putRetryDelayMs(input) {
-  if (input.attempt >= MAX_ATTEMPTS) return null;
+  if (input.attempt >= (input.maxAttempts ?? MAX_ATTEMPTS)) return null;
   const delayIndex = input.attempt - 1;
   if (input.status !== void 0) {
     if (input.status === 429 || input.status === 500 || input.status === 502 || input.status === 503 || input.status === 504) {
@@ -599,6 +670,7 @@ var PlatformClient = class {
       const context = {
         contributionId,
         uploadId: target2.upload.id,
+        filename: input.originalFilename,
         requireVerificationOnConflict: true
       };
       try {
@@ -790,6 +862,12 @@ var PlatformClient = class {
       }
     })();
     const sizeBytes = body.kind === "buffer" ? body.buffer.byteLength : body.sizeBytes;
+    const maxAttempts = putMaxAttempts(sizeBytes);
+    const label = [
+      refresh?.filename && `file=${refresh.filename}`,
+      refresh?.uploadId && `upload=${refresh.uploadId}`,
+      `size=${sizeBytes}`
+    ].filter(Boolean).join(" ");
     let hadNetworkError = false;
     let refreshed = false;
     for (let attempt = 1; ; attempt++) {
@@ -799,52 +877,56 @@ var PlatformClient = class {
         res = await putToPresignedUrl(presignedUrl, headers, body, {
           onProgress: (progress) => appendLog(
             "info",
-            `[PUT ${host}] progress (attempt=${attempt}, phase=${progress.phase}, elapsedMs=${progress.elapsedMs}, socketBytesWritten=${progress.socketBytesWritten}, totalBodyBytes=${progress.totalBodyBytes})`
+            `[PUT ${host}] progress (attempt=${attempt}, phase=${progress.phase}, elapsedMs=${progress.elapsedMs}, requestFinished=${progress.requestFinished}, socketBytesWritten=${progress.socketBytesWritten}, totalBodyBytes=${progress.totalBodyBytes}) | ${label}`
           )
         });
       } catch (err) {
         hadNetworkError = true;
+        const diagnostics2 = `| ${label} ${formatPutAttempt(err.putAttempt)}`;
         const delayMs2 = putRetryDelayMs({
           attempt,
-          networkErrorCode: networkErrorCode(err)
+          networkErrorCode: networkErrorCode(err),
+          maxAttempts
         });
         if (delayMs2 !== null) {
           appendLog(
             "warn",
-            `[PUT ${host}] network error, retrying in ${delayMs2}ms (attempt ${attempt}/${MAX_ATTEMPTS}) ${formatError(err)}`
+            `[PUT ${host}] network error, retrying in ${delayMs2}ms (attempt ${attempt}/${maxAttempts}) ${formatError(err)} ${diagnostics2}`
           );
           await sleep(delayMs2);
           continue;
         }
         appendLog(
           "error",
-          `[PUT ${host}] FAILED ${Date.now() - start}ms ${formatError(err)}`
+          `[PUT ${host}] FAILED ${Date.now() - start}ms ${formatError(err)} (attempt ${attempt}/${maxAttempts}) ${diagnostics2}`
         );
         throw err;
       }
       const elapsedMs = Date.now() - start;
+      const diagnostics = `| ${label} ${formatPutAttempt(res.attempt)}`;
       if (res.ok) {
         appendLog(
           "info",
-          `[PUT ${host}] ${res.status} ${elapsedMs}ms (${sizeBytes} bytes)`
+          `[PUT ${host}] ${res.status} ${elapsedMs}ms (${sizeBytes} bytes) (attempt ${attempt}/${maxAttempts}) | ${label}${sizeBytes >= LARGE_PUT_BYTES ? ` ${formatPutAttempt(res.attempt)}` : ""}`
         );
         return;
       }
       if (res.status === 412 && hadNetworkError && !refresh?.requireVerificationOnConflict) {
         appendLog(
           "info",
-          `[PUT ${host}] 412 after retry \u2014 object already stored (${sizeBytes} bytes)`
+          `[PUT ${host}] 412 after retry \u2014 object already stored (${sizeBytes} bytes) ${diagnostics}`
         );
         return;
       }
       const code = /<Code>\s*([A-Za-z][A-Za-z0-9]*)\s*<\/Code>/.exec(
         res.bodyText
       )?.[1];
-      if ((res.status === 400 || res.status === 403) && code === "ExpiredToken" && refresh && attempt < MAX_ATTEMPTS && !refreshed) {
+      const urlExpired = res.status === 403 && code === "AccessDenied" && /<Message>\s*Request has expired\s*<\/Message>/.test(res.bodyText);
+      if ((res.status === 400 || res.status === 403) && (code === "ExpiredToken" || urlExpired) && refresh && attempt < maxAttempts && !refreshed) {
         refreshed = true;
         appendLog(
           "warn",
-          `[PUT ${host}] ${res.status} ${elapsedMs}ms (code=ExpiredToken); refreshing AWS upload URL once for the existing object`
+          `[PUT ${host}] ${res.status} ${elapsedMs}ms (code=${code}${urlExpired ? ", request expired" : ""}); refreshing AWS upload URL once for the existing object ${diagnostics}`
         );
         const renewed = await this.request(
           "POST",
@@ -864,19 +946,23 @@ var PlatformClient = class {
         headers = renewed.headers;
         continue;
       }
-      const delayMs = putRetryDelayMs({ attempt, status: res.status });
+      const delayMs = putRetryDelayMs({
+        attempt,
+        status: res.status,
+        maxAttempts
+      });
       if (delayMs !== null) {
         appendLog(
           "warn",
-          `[PUT ${host}] ${res.status} ${elapsedMs}ms, retrying in ${delayMs}ms (attempt ${attempt}/${MAX_ATTEMPTS})`
+          `[PUT ${host}] ${res.status} ${elapsedMs}ms${code ? ` (code=${code})` : ""}, retrying in ${delayMs}ms (attempt ${attempt}/${maxAttempts}) ${diagnostics}`
         );
         await sleep(delayMs);
         continue;
       }
-      const detail = code ? `(code=${code})` : res.bodyText;
+      const detail = code ? `(code=${code})` : res.bodyText ? `(${Buffer.byteLength(res.bodyText)}-byte body without an S3 error code)` : "";
       appendLog(
         "warn",
-        `[PUT ${host}] ${res.status} ${elapsedMs}ms${code ? ` (code=${code})` : ""}`
+        `[PUT ${host}] ${res.status} ${elapsedMs}ms${code ? ` (code=${code})` : ""} (attempt ${attempt}/${maxAttempts}) ${diagnostics}`
       );
       throw new PlatformError(
         `PUT to presigned URL failed: HTTP ${res.status}${detail ? ` ${detail}` : ""}`,
@@ -906,6 +992,31 @@ var PlatformClient = class {
     );
   }
 };
+function formatPutAttempt(attempt) {
+  const fields = [];
+  if (attempt) {
+    fields.push(
+      `elapsedMs=${attempt.elapsedMs}`,
+      `phase=${attempt.phase}`,
+      `requestFinished=${attempt.requestFinished}`
+    );
+    if (attempt.bodyBytesRead !== void 0)
+      fields.push(`bodyBytesRead=${attempt.bodyBytesRead}`);
+    if (attempt.connectMs !== void 0)
+      fields.push(`connectMs=${attempt.connectMs}`);
+    if (attempt.tlsMs !== void 0) fields.push(`tlsMs=${attempt.tlsMs}`);
+    if (attempt.remoteAddress) fields.push(`remote=${attempt.remoteAddress}`);
+    if (attempt.localNet) fields.push(`localNet=${attempt.localNet}`);
+    if (attempt.tlsProtocol) fields.push(`tls=${attempt.tlsProtocol}`);
+    if (attempt.tlsIssuer)
+      fields.push(`issuer=${JSON.stringify(attempt.tlsIssuer)}`);
+    if (attempt.status !== void 0) fields.push(`status=${attempt.status}`);
+    if (attempt.requestId) fields.push(`requestId=${attempt.requestId}`);
+    if (attempt.hostId) fields.push(`hostId=${attempt.hostId}`);
+  }
+  fields.push(`node=${process.version}`, `platform=${process.platform}`);
+  return fields.join(" ");
+}
 
 // src/platform/hooks.ts
 import { execFileSync } from "child_process";
@@ -965,7 +1076,7 @@ async function ensureGitignored(repoRoot, files) {
 // src/platform/hooks.ts
 var HOOK_CMD = (sub) => `npx hillclimb@latest ${sub}`;
 var GIT_TRACES_CMD = (tool) => `npx hillclimb@latest git-traces --tool=${tool}`;
-var CLAUDE_SESSIONEND_UPLOAD_TIMEOUT_SECONDS = 30;
+var CLAUDE_SESSIONEND_HOOK_TIMEOUT_SECONDS = 30;
 var DEV_HOOK_ENV = "HILLCLIMB_DEV_HOOK=1";
 var SKIP_SELF_HEAL_ENV = "HILLCLIMB_SKIP_HOOK_SELF_HEAL=1";
 var TOOLS = [
@@ -978,7 +1089,7 @@ var TOOLS = [
       {
         eventName: "SessionEnd",
         command: HOOK_CMD("upload"),
-        timeout: CLAUDE_SESSIONEND_UPLOAD_TIMEOUT_SECONDS
+        timeout: CLAUDE_SESSIONEND_HOOK_TIMEOUT_SECONDS
       },
       // Per-turn transcript capture. SessionEnd is the clean one-shot
       // upload, but it never fires for sessions that are killed or never
@@ -991,7 +1102,11 @@ var TOOLS = [
       { eventName: "Stop", command: `${HOOK_CMD("upload")} --tool=claude` },
       { eventName: "SessionStart", command: GIT_TRACES_CMD("claude") },
       { eventName: "Stop", command: GIT_TRACES_CMD("claude") },
-      { eventName: "SessionEnd", command: GIT_TRACES_CMD("claude") }
+      {
+        eventName: "SessionEnd",
+        command: GIT_TRACES_CMD("claude"),
+        timeout: CLAUDE_SESSIONEND_HOOK_TIMEOUT_SECONDS
+      }
     ],
     detect: () => isDir(path4.join(homeDir(), ".claude"))
   },
@@ -3729,7 +3844,7 @@ var DEFAULT_STATE_DIR = path9.join(
   "agent-uploads"
 );
 var DEFAULT_LOCK_WAIT_MS = 5 * 60 * 1e3;
-var DEFAULT_LIVE_OWNER_MAX_WAIT_MS = 4 * 60 * 60 * 1e3;
+var DEFAULT_LIVE_OWNER_MAX_WAIT_MS = 6 * 60 * 60 * 1e3;
 var DEFAULT_LOCK_RETRY_DELAY_MS = 500;
 var DEFAULT_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
 var STALE_LOCK_TTL_MS = DEFAULT_LIVE_OWNER_MAX_WAIT_MS;
@@ -14356,7 +14471,11 @@ var PlatformUploadOutput = class {
           presigned.headers,
           filePath,
           sizeBytes,
-          { contributionId, uploadId: presigned.upload.id }
+          {
+            contributionId,
+            uploadId: presigned.upload.id,
+            filename: zipFilename
+          }
         );
         appendLog("info", `PUT to presigned URL succeeded for ${zipFilename}`);
       }
@@ -17850,13 +17969,13 @@ async function uploadArtifact(client, contributionId, filename, mimeType, buffer
     presigned.presignedUrl,
     presigned.headers,
     buffer,
-    { contributionId, uploadId: presigned.upload.id }
+    { contributionId, uploadId: presigned.upload.id, filename }
   );
   appendLog("info", `PUT to presigned URL succeeded for ${filename}`);
 }
 
 // package.json
-var version = "0.9.7";
+var version = "0.9.9";
 
 // src/version.ts
 var CLI_VERSION = version;
@@ -19631,7 +19750,7 @@ async function uploadFile(client, contributionId, filename, mimeType, buffer) {
     presigned.presignedUrl,
     presigned.headers,
     buffer,
-    { contributionId, uploadId: presigned.upload.id }
+    { contributionId, uploadId: presigned.upload.id, filename }
   );
   appendLog(
     "info",

package/package.json

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