fix(vibe-publish): preserve HTTP status/body when wrapping errors

Error wrapping was losing HTTP status (like 401) making isAuthError
detection fail. The fix ensures status and body are copied to the
outer error in createCapsule, uploadFile, publishCapsule, and
publishVibe.

This allows withAuthRetry to properly detect 401 errors and trigger
token refresh even when errors are wrapped.

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: Braden-sui

lib/vibe-publish.js

@@ -205,13 +205,17 @@ export const createCapsule = async ({
       throw err;
     }
 
-    throw createError({
+    // Preserve status and body on the outer error for auth detection
+    const wrappedErr = createError({
       ...CapsuleCreateError,
       message: `Failed to create capsule: ${err.message}`,
       cause: err,
       url,
       title,
     });
+    if (err.status !== undefined) wrappedErr.status = err.status;
+    if (err.body !== undefined) wrappedErr.body = err.body;
+    throw wrappedErr;
   }
 };
 
@@ -384,14 +388,18 @@ export const uploadFile = async ({
       });
     }
 
-    throw createError({
+    // Preserve status and body on the outer error for auth detection
+    const wrappedErr = createError({
       ...FileUploadError,
       message: `Failed to upload file '${filePath}': ${err.message}`,
       cause: err,
       url,
       path: filePath,
       capsuleId,
     });
+    if (err.status !== undefined) wrappedErr.status = err.status;
+    if (err.body !== undefined) wrappedErr.body = err.body;
+    throw wrappedErr;
   }
 };
 
@@ -484,13 +492,17 @@ export const publishCapsule = async ({
       throw err;
     }
 
-    throw createError({
+    // Preserve status and body on the outer error for auth detection
+    const wrappedErr = createError({
       ...CapsulePublishError,
       message: `Failed to publish capsule: ${err.message}`,
       cause: err,
       url,
       capsuleId,
     });
+    if (err.status !== undefined) wrappedErr.status = err.status;
+    if (err.body !== undefined) wrappedErr.body = err.body;
+    throw wrappedErr;
   }
 };
 
@@ -734,13 +746,19 @@ export const publishVibe = async ({
     const errCode = err.cause?.code || err.code;
     const recoveryData = extractRecoveryData(err, files.length);
 
-    throw createError({
+    // Preserve status and body on the outer error for auth detection
+    // isAuthError checks err.status === 401, so we must copy it up
+    const wrappedErr = createError({
       ...PublishFailed,
       message: `Publish failed: ${err.message}`,
       cause: err,
       title,
       ...recoveryData,
     });
+    // Copy HTTP-related properties for error handlers (e.g., isAuthError, withAuthRetry)
+    if (err.status !== undefined) wrappedErr.status = err.status;
+    if (err.body !== undefined) wrappedErr.body = err.body;
+    throw wrappedErr;
   }
 };
 

lib/vibe-publish.test.js

@@ -1223,4 +1223,43 @@ describe("publishVibe - partial failure scenarios", () => {
       expected: "CAPSULE_CREATE_ERROR",
     });
   });
+
+  test("preserves HTTP 401 status for isAuthError detection", async () => {
+    // Mock create capsule - fails with 401
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 401,
+      text: async () => JSON.stringify({ error: "Unauthorized" }),
+    });
+
+    let error;
+    try {
+      await publishVibe({
+        apiBase: "http://localhost:8787",
+        token: "expired-token",
+        title: "Test Vibe",
+        files: [{ path: "App.tsx", content: "content" }],
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    // The wrapped error should still be detectable as an auth error
+    // isAuthError checks err.status === 401
+    assert({
+      given: "API returns 401 unauthorized",
+      should: "have status preserved for isAuthError detection",
+      actual: isAuthError(error),
+      expected: true,
+    });
+
+    // Also verify the error has PUBLISH_FAILED code
+    assert({
+      given: "API returns 401 unauthorized",
+      should: "throw PUBLISH_FAILED error",
+      actual: error?.cause?.code,
+      expected: "PUBLISH_FAILED",
+    });
+  });
+
 });