@pixeyedev/core 0.4.3 → 0.4.4

package/dist/client.js

@@ -1,4 +1,5 @@
 import { CreateBuildResponseSchema, ListBuildsResponseSchema, PipelineFinalizeResponseSchema, PresignUploadResponseSchema, SubmitShardResponseSchema } from '@pixeyedev/shared';
+import { isRetryableHttpError, maskPresignedUrl, withRetry } from './retry.js';
 export class PixeyeError extends Error {
     status;
     path;
@@ -58,14 +59,23 @@ export class PixeyeClient {
         return PresignUploadResponseSchema.parse(raw);
     }
     async uploadFile(presignedUrl, buffer, contentType) {
-        const res = await fetch(presignedUrl, {
-            method: 'PUT',
-            body: new Uint8Array(buffer),
-            headers: { 'Content-Type': contentType }
+        const maskedUrl = maskPresignedUrl(presignedUrl);
+        await withRetry(async () => {
+            const res = await fetch(presignedUrl, {
+                method: 'PUT',
+                body: new Uint8Array(buffer),
+                headers: { 'Content-Type': contentType }
+            });
+            if (!res.ok) {
+                throw new PixeyeError(res.status, maskedUrl, await res.text());
+            }
+        }, isRetryableHttpError, {
+            maxAttempts: 3,
+            baseDelayMs: 1000,
+            onRetry: (attempt, err) => {
+                console.warn(`[pixeye] Upload retry ${attempt}/3: ${err.message}`);
+            }
         });
-        if (!res.ok) {
-            throw new PixeyeError(res.status, presignedUrl, await res.text());
-        }
     }
     async submitShard(opts) {
         const raw = await this.request(`/api/v1/builds/${opts.buildId}/shards`, {

package/dist/index.d.ts

@@ -7,4 +7,6 @@ export { detectBaseBranchFromGit, detectCIEnvironment } from './ci.js';
 export type { DiscoveredFile } from './discover.js';
 export { discoverScreenshots } from './discover.js';
 export { runParallel } from './parallel.js';
+export type { RetryOptions } from './retry.js';
+export { isRetryableHttpError, maskPresignedUrl, withRetry } from './retry.js';
 export { DEFAULT_SERVER_URL, DEFAULT_UPLOAD_CONCURRENCY } from './constants.js';

package/dist/index.js

@@ -4,5 +4,6 @@ export { detectBaseBranchFromGit, detectCIEnvironment } from './ci.js';
 export { discoverScreenshots } from './discover.js';
 // Parallel execution
 export { runParallel } from './parallel.js';
+export { isRetryableHttpError, maskPresignedUrl, withRetry } from './retry.js';
 // Constants
 export { DEFAULT_SERVER_URL, DEFAULT_UPLOAD_CONCURRENCY } from './constants.js';

package/dist/retry.d.ts

@@ -0,0 +1,14 @@
+export interface RetryOptions {
+    maxAttempts?: number;
+    baseDelayMs?: number;
+    onRetry?: (attempt: number, error: Error) => void;
+}
+/**
+ * Retry an async function with exponential backoff + jitter.
+ * Only retries on errors where shouldRetry returns true.
+ */
+export declare const withRetry: <T>(fn: () => Promise<T>, shouldRetry: (error: unknown) => boolean, opts?: RetryOptions) => Promise<T>;
+/** Returns true for HTTP 429/5xx responses or transient network errors. */
+export declare const isRetryableHttpError: (error: unknown) => boolean;
+/** Mask presigned URL signature for safe error logging. */
+export declare const maskPresignedUrl: (url: string) => string;

package/dist/retry.js

@@ -0,0 +1,40 @@
+/**
+ * Retry an async function with exponential backoff + jitter.
+ * Only retries on errors where shouldRetry returns true.
+ */
+export const withRetry = async (fn, shouldRetry, opts = {}) => {
+    const maxAttempts = opts.maxAttempts ?? 3;
+    const baseDelayMs = opts.baseDelayMs ?? 1000;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (attempt === maxAttempts || !shouldRetry(error)) {
+                throw error;
+            }
+            // Exponential backoff with equal jitter (half deterministic + half random)
+            const exponential = baseDelayMs * Math.pow(2, attempt - 1);
+            const delay = exponential * (0.5 + 0.5 * Math.random());
+            opts.onRetry?.(attempt, error instanceof Error ? error : new Error(String(error)));
+            await new Promise(r => setTimeout(r, delay));
+        }
+    }
+    throw new Error('Unreachable');
+};
+const TRANSIENT_NETWORK_RE = /fetch failed|ECONNRESET|ETIMEDOUT|ECONNREFUSED|ENOTFOUND|EPIPE|socket hang up/i;
+/** Returns true for HTTP 429/5xx responses or transient network errors. */
+export const isRetryableHttpError = (error) => {
+    // Check status code first (authoritative when present)
+    const status = error?.status;
+    if (status !== undefined) {
+        return status === 429 || (status >= 500 && status < 600);
+    }
+    // Fall back to message-based detection for genuine network errors (no HTTP response)
+    if (error instanceof Error && TRANSIENT_NETWORK_RE.test(error.message)) {
+        return true;
+    }
+    return false;
+};
+/** Mask presigned URL signature for safe error logging. */
+export const maskPresignedUrl = (url) => url.split('?')[0] + '?[signature-masked]';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixeyedev/core",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "private": false,
   "type": "module",
   "files": [