ugly-app 0.1.1069 → 0.1.1071

package/src/cli/publish/providers/cloudflare.ts

@@ -25,8 +25,14 @@
  */
 
 import { PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
-import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { createReadStream, readdirSync, statSync } from 'node:fs';
+import { uploadFiles, type UploadOptions } from '../assetUpload.js';
+import {
+  fetchWithUploadAuth,
+  type UploadTokenProvider,
+} from '../uploadAuth.js';
 import path from 'node:path';
+import { finished } from 'node:stream/promises';
 
 import { PublishError, publishErrorFromResponse } from '../errors.js';
 import { projectPackageManager, pmExec } from '../packageManager.js';
@@ -46,7 +52,7 @@ const CLOUDFLARE_API_BASE = 'https://api.cloudflare.com/client/v4';
  * runs this BEFORE the script upload, so a partial asset upload is
  * recoverable (re-deploy and the stragglers get retried).
  */
-export interface UploadR2AssetsArgs {
+export interface UploadR2AssetsArgs extends UploadOptions {
   endpoint: string;
   accessKeyId: string;
   secretAccessKey: string;
@@ -60,11 +66,8 @@ export interface UploadR2AssetsArgs {
   /**
    * Keys already present in the bucket that must NOT be re-uploaded.
    *
-   * Only ever populated for content-addressed keys (the `static/` prefix),
-   * where the key IS the content — so "already there" means "already correct".
-   * `builds/{buildId}/…` keys are new every deploy and never appear here.
-   * Without this a CDN-hosted bundle is re-PUT in full on every deploy even
-   * though not a byte changed.
+   * Populated after comparing remote size and single-part MD5 against local
+   * bytes. Stable names and Vite assets can both be skipped safely.
    */
   skipKeys?: ReadonlySet<string>;
 }
@@ -390,6 +393,18 @@ function walkFiles(dir: string, base: string = dir): string[] {
   return out;
 }
 
+function stagedUploadFiles(directory: string, skipKeys?: ReadonlySet<string>) {
+  const all = walkFiles(directory);
+  const pending = all
+    .filter((rel) => !skipKeys?.has(rel.split(path.sep).join('/')))
+    .map((rel) => ({
+      key: rel.split(path.sep).join('/'),
+      full: path.join(directory, rel),
+      bytes: statSync(path.join(directory, rel)).size,
+    }));
+  return { pending, skipped: all.length - pending.length };
+}
+
 export async function uploadR2Assets(
   args: UploadR2AssetsArgs,
 ): Promise<{ uploaded: number; bytes: number }> {
@@ -428,40 +443,44 @@ export async function uploadR2Assets(
     forcePathStyle: true,
   });
 
-  const files = walkFiles(r2UploadDir);
-  let uploaded = 0;
-  let bytes = 0;
-  // Sequential keeps memory usage flat and is fast enough for the
-  // typical SPA bundle (a few dozen files).
-  for (const rel of files) {
-    const key = rel.split(path.sep).join('/');
-    if (skipKeys?.has(key)) continue;
-    const full = path.join(r2UploadDir, rel);
-    const body = readFileSync(full);
-    try {
-      await s3.send(
-        new PutObjectCommand({
-          Bucket: bucket,
-          Key: key,
-          Body: body,
-          ContentType: guessContentType(rel),
-          CacheControl: 'public, max-age=31536000, immutable',
-        }),
-      );
-    } catch (err) {
-      throw new PublishError(
-        `failed to upload ${key}: ${(err as Error).message}`,
-        {
-          provider: 'cloudflare',
-          step: 'uploadR2Assets',
-          cause: err,
-        },
-      );
-    }
-    uploaded++;
-    bytes += body.byteLength;
+  const files = stagedUploadFiles(r2UploadDir, skipKeys);
+  try {
+    return await uploadFiles(
+      files.pending,
+      files.skipped,
+      async (file) => {
+        const body = createReadStream(file.full);
+        const closed = finished(body).catch(() => {});
+        try {
+          await s3.send(
+            new PutObjectCommand({
+              Bucket: bucket,
+              Key: file.key,
+              Body: body,
+              ContentLength: file.bytes,
+              ContentType: guessContentType(file.key),
+              CacheControl: 'public, max-age=31536000, immutable',
+            }),
+          );
+        } catch (err) {
+          throw new PublishError(
+            `failed to upload ${file.key}: ${(err as Error).message}`,
+            {
+              provider: 'cloudflare',
+              step: 'uploadR2Assets',
+              cause: err,
+            },
+          );
+        } finally {
+          body.destroy();
+          await closed;
+        }
+      },
+      args,
+    );
+  } finally {
+    s3.destroy();
   }
-  return { uploaded, bytes };
 }
 
 export interface CloudflareProvisionResult {
@@ -844,84 +863,96 @@ async function sleepBackoff(
   attempt: number,
   hintSec?: string | null,
 ): Promise<void> {
-  const ms = Number.isFinite(Number(hintSec))
-    ? Number(hintSec) * 1000
-    : Math.min(2 ** attempt * 500, 8000);
+  const seconds = hintSec?.trim() ? Number(hintSec) : NaN;
+  const ms =
+    Number.isFinite(seconds) && seconds >= 0
+      ? Math.min(seconds * 1000, 60000)
+      : Math.min(2 ** attempt * 500, 8000);
   await new Promise((r) => setTimeout(r, ms));
 }
 
-export async function uploadR2AssetsViaApi(args: {
-  token: string;
-  accountId: string;
-  bucket: string;
-  r2UploadDir: string;
-  /** See `UploadR2AssetsArgs.skipKeys` — content-addressed keys already present. */
-  skipKeys?: ReadonlySet<string>;
-}): Promise<{ uploaded: number; bytes: number }> {
-  const { token, accountId, bucket, r2UploadDir, skipKeys } = args;
+export async function uploadR2AssetsViaApi(
+  args: UploadOptions & {
+    token: string;
+    getToken?: UploadTokenProvider;
+    accountId: string;
+    bucket: string;
+    r2UploadDir: string;
+    /** Keys verified to contain the same bytes. Force-upload passes an empty set. */
+    skipKeys?: ReadonlySet<string>;
+  },
+): Promise<{ uploaded: number; bytes: number }> {
+  const { accountId, bucket, r2UploadDir, skipKeys } = args;
   try {
     statSync(r2UploadDir);
   } catch {
     return { uploaded: 0, bytes: 0 };
   }
-  const files = walkFiles(r2UploadDir);
-  let uploaded = 0;
-  let bytes = 0;
-  for (const rel of files) {
-    const key = rel.split(path.sep).join('/');
-    if (skipKeys?.has(key)) continue;
-    const full = path.join(r2UploadDir, rel);
-    const body = readFileSync(full);
-    // A first-time upload can be many hundreds of objects, and Cloudflare
-    // rate-limits it — observed on ugly-meal, where fixing publicDir meant
-    // shipping every icon/image/audio file for the first time and the run died
-    // partway through on a 429. An upload that aborts midway leaves the build
-    // prefix incomplete, so retry rather than fail: 429 and 5xx are the API
-    // asking us to wait, and a dropped connection is not a real error either.
-    let res: Response | undefined;
-    for (let attempt = 0; ; attempt++) {
-      const canRetry = attempt < R2_PUT_MAX_RETRIES;
-      try {
-        res = await globalThis.fetch(
-          `${CLOUDFLARE_API_BASE}/accounts/${accountId}/r2/buckets/${bucket}/objects/${encodeURIComponent(
-            key,
-          )}`,
-          {
-            method: 'PUT',
-            headers: {
-              'Authorization': `Bearer ${token}`,
-              'Content-Type': guessContentType(full),
-              // Must match the S3 path above. Without it the stored object has
-              // no cache-control, and an R2 CUSTOM DOMAIN then refuses to
-              // edge-cache it — `cf-cache-status: DYNAMIC` on every request, so
-              // a CDN-hosted bundle silently reverts to hitting R2 for every
-              // byte. Only bites projects with no captured S3 keys, which is
-              // why it went unnoticed until world3 (328 MB, all uncached).
-              'Cache-Control': 'public, max-age=31536000, immutable',
+  const files = stagedUploadFiles(r2UploadDir, skipKeys);
+  // Reject before starting any writes. Use S3 for larger individual objects.
+  for (const file of files.pending) {
+    if (file.bytes > 300 * 1024 * 1024)
+      throw new Error(
+        `${file.key} exceeds the 300 MiB REST upload limit; use S3 or split the asset`,
+      );
+  }
+  return uploadFiles(
+    files.pending,
+    files.skipped,
+    async (file) => {
+      for (let attempt = 0; ; attempt++) {
+        const canRetry = attempt < R2_PUT_MAX_RETRIES;
+        let res: Response;
+        let stream: ReturnType<typeof createReadStream> | undefined;
+        const closed: Promise<void>[] = [];
+        try {
+          res = await fetchWithUploadAuth(
+            `${CLOUDFLARE_API_BASE}/accounts/${accountId}/r2/buckets/${bucket}/objects/${encodeURIComponent(file.key)}`,
+            () => {
+              stream?.destroy();
+              stream = createReadStream(file.full);
+              closed.push(finished(stream).catch(() => {}));
+              return {
+                method: 'PUT',
+                headers: {
+                  'Content-Type': guessContentType(file.key),
+                  'Content-Length': String(file.bytes),
+                  'Cache-Control': 'public, max-age=31536000, immutable',
+                },
+                body: stream as unknown as BodyInit,
+                duplex: 'half',
+                signal: AbortSignal.timeout(5 * 60 * 1000),
+              };
             },
-            body,
-          },
-        );
-      } catch (err) {
-        if (!canRetry) throw err;
-        await sleepBackoff(attempt);
-        continue;
-      }
-      if (res.ok) break;
-      if ((res.status === 429 || res.status >= 500) && canRetry) {
-        await sleepBackoff(attempt, res.headers.get('retry-after'));
-        continue;
+            args,
+          );
+        } catch (error) {
+          if (!canRetry) throw error;
+          await sleepBackoff(attempt);
+          continue;
+        } finally {
+          stream?.destroy();
+          await Promise.all(closed);
+        }
+        if (res.ok) {
+          await res.body?.cancel();
+          return;
+        }
+        if ((res.status === 429 || res.status >= 500) && canRetry) {
+          const delay = res.headers.get('retry-after');
+          await res.body?.cancel();
+          await sleepBackoff(attempt, delay);
+          continue;
+        }
+        throw await publishErrorFromResponse(res, {
+          provider: 'cloudflare-r2',
+          step: 'uploadR2AssetsViaApi',
+          message: `failed to PUT r2 object "${file.key}"`,
+        });
       }
-      throw await publishErrorFromResponse(res, {
-        provider: 'cloudflare-r2',
-        step: 'uploadR2AssetsViaApi',
-        message: `failed to PUT r2 object "${key}"`,
-      });
-    }
-    uploaded++;
-    bytes += body.byteLength;
-  }
-  return { uploaded, bytes };
+    },
+    args,
+  );
 }
 
 /**

package/src/cli/publish/staticOps.test.ts

@@ -24,7 +24,12 @@ describe('createApiR2Ops', () => {
           JSON.stringify({
             success: true,
             result: [
-              { key: 'static/a', last_modified: '2026-07-01T00:00:00Z' },
+              {
+                key: 'static/a',
+                last_modified: '2026-07-01T00:00:00Z',
+                etag: '"f00"',
+                size: 123,
+              },
             ],
             result_info: { cursor: 'CUR1', is_truncated: true },
           }),
@@ -48,10 +53,32 @@ describe('createApiR2Ops', () => {
     const ops = createApiR2Ops({ token: 't', accountId: 'acct', bucket: 'b' });
     const objs = await ops.list('static/');
     expect(objs.map((o) => o.key)).toEqual(['static/a', 'static/b']);
+    expect(objs[0]).toMatchObject({ etag: '"f00"', size: 123 });
     expect(fetchMock).toHaveBeenCalledTimes(2);
     expect(String(fetchMock.mock.calls[1]![0])).toContain('cursor=CUR1');
   });
 
+  it('recovers listing authentication before computing unchanged files', async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(new Response('', { status: 401 }))
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify({ result: [] }), { status: 200 }),
+      );
+    vi.stubGlobal('fetch', fetchMock);
+    const getToken = vi.fn(async (stale?: string) => (stale ? 'new' : 'old'));
+    const ops = createApiR2Ops({
+      token: 'old',
+      getToken,
+      accountId: 'acct',
+      bucket: 'b',
+    });
+    expect(await ops.list('static/')).toEqual([]);
+    expect(
+      new Headers(fetchMock.mock.calls[1]![1].headers).get('Authorization'),
+    ).toBe('Bearer new');
+  });
+
   it('rejects a file over the REST single-PUT cap with an actionable message', async () => {
     vi.stubGlobal('fetch', vi.fn());
     const ops = createApiR2Ops({ token: 't', accountId: 'acct', bucket: 'b' });

package/src/cli/publish/staticOps.ts

@@ -23,6 +23,8 @@ import {
 import { createReadStream, readFileSync } from 'fs';
 import type { R2Ops, RemoteObject } from './staticSync.js';
 
+import { fetchWithUploadAuth, type UploadTokenProvider } from './uploadAuth.js';
+
 const CLOUDFLARE_API_BASE = 'https://api.cloudflare.com/client/v4';
 
 /** Cloudflare's REST object endpoint rejects a single PUT beyond this. */
@@ -102,6 +104,8 @@ function createOpsFromClient(s3: S3Client, bucket: string): R2Ops {
             out.push({
               key: o.Key,
               lastModified: o.LastModified ?? new Date(0),
+              etag: o.ETag,
+              size: o.Size,
             });
           }
         }
@@ -188,12 +192,15 @@ export function createClientR2Ops(client: S3Client, bucket: string): R2Ops {
 
 export function createApiR2Ops(args: {
   token: string;
+  getToken?: UploadTokenProvider;
   accountId: string;
   bucket: string;
 }): R2Ops {
   const { token, accountId, bucket } = args;
   const base = `${CLOUDFLARE_API_BASE}/accounts/${accountId}/r2/buckets/${bucket}`;
   const auth = { Authorization: `Bearer ${token}` };
+  const request = (url: string, init: RequestInit) =>
+    fetchWithUploadAuth(url, () => init, args);
 
   return {
     async list(prefix) {
@@ -203,17 +210,24 @@ export function createApiR2Ops(args: {
         const url =
           `${base}/objects?prefix=${encodeURIComponent(prefix)}&per_page=1000` +
           (cursor ? `&cursor=${encodeURIComponent(cursor)}` : '');
-        const res = await globalThis.fetch(url, { headers: auth });
+        const res = await request(url, { headers: auth });
         if (!res.ok) {
           throw new Error(`r2 list ${prefix} failed: ${res.status}`);
         }
         const body = (await res.json()) as {
-          result?: { key: string; last_modified?: string }[];
+          result?: {
+            key: string;
+            last_modified?: string;
+            etag?: string;
+            size?: number;
+          }[];
           result_info?: { cursor?: string; is_truncated?: boolean };
         };
         for (const o of body.result ?? []) {
           out.push({
             key: o.key,
+            etag: o.etag,
+            size: o.size,
             lastModified: o.last_modified
               ? new Date(o.last_modified)
               : new Date(0),
@@ -227,27 +241,23 @@ export function createApiR2Ops(args: {
     },
 
     async getText(key) {
-      const res = await globalThis.fetch(
-        `${base}/objects/${encodeURIComponent(key)}`,
-        { headers: auth },
-      );
+      const res = await request(`${base}/objects/${encodeURIComponent(key)}`, {
+        headers: auth,
+      });
       if (!res.ok) return null;
       return await res.text();
     },
 
     async put(key, body, contentType) {
-      const res = await globalThis.fetch(
-        `${base}/objects/${encodeURIComponent(key)}`,
-        {
-          method: 'PUT',
-          headers: {
-            ...auth,
-            'Content-Type': contentType,
-            'Cache-Control': 'no-cache',
-          },
-          body: asBody(body),
+      const res = await request(`${base}/objects/${encodeURIComponent(key)}`, {
+        method: 'PUT',
+        headers: {
+          ...auth,
+          'Content-Type': contentType,
+          'Cache-Control': 'no-cache',
         },
-      );
+        body: asBody(body),
+      });
       if (!res.ok) {
         throw new Error(`r2 put ${key} failed: ${res.status}`);
       }
@@ -262,18 +272,15 @@ export function createApiR2Ops(args: {
             `project so publish uses the S3 path (5 GB limit), or split the file.`,
         );
       }
-      const res = await globalThis.fetch(
-        `${base}/objects/${encodeURIComponent(key)}`,
-        {
-          method: 'PUT',
-          headers: {
-            ...auth,
-            'Content-Type': contentType,
-            'Cache-Control': IMMUTABLE,
-          },
-          body: asBody(readFileSync(absPath)),
+      const res = await request(`${base}/objects/${encodeURIComponent(key)}`, {
+        method: 'PUT',
+        headers: {
+          ...auth,
+          'Content-Type': contentType,
+          'Cache-Control': IMMUTABLE,
         },
-      );
+        body: asBody(readFileSync(absPath)),
+      });
       if (!res.ok) {
         throw new Error(`r2 put ${key} failed: ${res.status}`);
       }
@@ -303,10 +310,10 @@ export function createApiR2Ops(args: {
           const canRetry = attempt < DELETE_MAX_RETRIES;
           let res: Response;
           try {
-            res = await globalThis.fetch(
-              `${base}/objects/${encodeURIComponent(key)}`,
-              { method: 'DELETE', headers: auth },
-            );
+            res = await request(`${base}/objects/${encodeURIComponent(key)}`, {
+              method: 'DELETE',
+              headers: auth,
+            });
           } catch (err) {
             if (!canRetry) throw err;
             await new Promise((r) => setTimeout(r, backoff(attempt)));

package/src/cli/publish/staticSync.ts

@@ -26,6 +26,8 @@ const DAY_MS = 24 * 60 * 60 * 1000;
 export interface RemoteObject {
   key: string;
   lastModified: Date;
+  etag?: string | undefined;
+  size?: number | undefined;
 }
 
 /** The bucket operations the sync needs. Adapters live in the provider layer. */

package/src/cli/publish/uploadAuth.test.ts

@@ -0,0 +1,76 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+vi.mock('../auth/cloudflareOauth.js', () => ({
+  getFreshCloudflareCredentials: vi.fn(),
+  forceRefreshCloudflareCredentials: vi.fn(),
+}));
+import {
+  getFreshCloudflareCredentials,
+  forceRefreshCloudflareCredentials,
+} from '../auth/cloudflareOauth.js';
+import { createUploadTokenProvider } from './uploadAuth.js';
+const credential = (token: string, accountId = 'account') => ({
+  accessToken: token,
+  accountId,
+  expiresAt: Date.now() + 3600000,
+});
+afterEach(() => vi.resetAllMocks());
+describe('upload OAuth recovery', () => {
+  it('shares a refresh across concurrent 401s and persists once', async () => {
+    vi.mocked(getFreshCloudflareCredentials).mockResolvedValue(
+      credential('old'),
+    );
+    vi.mocked(forceRefreshCloudflareCredentials).mockImplementation(
+      async () => {
+        await new Promise((r) => setTimeout(r, 5));
+        return credential('new');
+      },
+    );
+    const persist = vi.fn();
+    const token = createUploadTokenProvider('old', 'account', persist);
+    expect(
+      await Promise.all([
+        token('old'),
+        token('old'),
+        token('old'),
+        token('old'),
+      ]),
+    ).toEqual(['new', 'new', 'new', 'new']);
+    expect(forceRefreshCloudflareCredentials).toHaveBeenCalledTimes(1);
+    expect(persist).toHaveBeenCalledExactlyOnceWith('new');
+  });
+  it('adopts a credential already refreshed by another deploy', async () => {
+    vi.mocked(getFreshCloudflareCredentials).mockResolvedValue(
+      credential('new'),
+    );
+    const persist = vi.fn();
+    const token = createUploadTokenProvider('old', 'account', persist);
+    expect(await token('old')).toBe('new');
+    expect(forceRefreshCloudflareCredentials).not.toHaveBeenCalled();
+    expect(persist).toHaveBeenCalledWith('new');
+  });
+  it('does not replace a project token with another account credential', async () => {
+    vi.mocked(getFreshCloudflareCredentials).mockResolvedValue(
+      credential('other', 'other-account'),
+    );
+    const persist = vi.fn();
+    const token = createUploadTokenProvider('project', 'account', persist);
+    expect(await token('project')).toBe('project');
+    expect(persist).not.toHaveBeenCalled();
+    expect(forceRefreshCloudflareCredentials).not.toHaveBeenCalled();
+  });
+  it('still refreshes a 401 that arrived during a proactive credential read', async () => {
+    vi.mocked(getFreshCloudflareCredentials).mockImplementation(async () => {
+      await new Promise((r) => setTimeout(r, 5));
+      return credential('old');
+    });
+    vi.mocked(forceRefreshCloudflareCredentials).mockResolvedValue(
+      credential('new'),
+    );
+    const token = createUploadTokenProvider('old', 'account', vi.fn());
+    const proactive = token();
+    const rejected = token('old');
+    expect(await proactive).toBe('old');
+    expect(await rejected).toBe('new');
+    expect(forceRefreshCloudflareCredentials).toHaveBeenCalledTimes(1);
+  });
+});

package/src/cli/publish/uploadAuth.ts

@@ -0,0 +1,69 @@
+import {
+  forceRefreshCloudflareCredentials,
+  getFreshCloudflareCredentials,
+} from '../auth/cloudflareOauth.js';
+
+export type UploadTokenProvider = (staleToken?: string) => Promise<string>;
+
+/** Use the existing locked OAuth refresh path; never switch Cloudflare accounts. */
+export function createUploadTokenProvider(
+  initialToken: string,
+  accountId: string,
+  persist: (token: string) => Promise<void>,
+): UploadTokenProvider {
+  let current = initialToken;
+  let pending: Promise<string> | undefined;
+  return async (staleToken) => {
+    // A proactive read may already be in flight when a PUT returns 401. Wait
+    // for it, then still refresh if it left us with the rejected credential.
+    if (pending) await pending;
+    if (staleToken && staleToken !== current) return current;
+    if (!pending) {
+      pending = (async () => {
+        let cf = await getFreshCloudflareCredentials({ awaitRefresh: true });
+        if (cf?.accountId !== accountId) return current;
+        if (staleToken && cf.accessToken === staleToken) {
+          cf = await forceRefreshCloudflareCredentials(staleToken, {
+            awaitRefresh: true,
+          });
+        }
+        if (cf?.accountId === accountId && cf.accessToken !== current) {
+          await persist(cf.accessToken);
+          current = cf.accessToken;
+        }
+        return current;
+      })();
+    }
+    const active = pending;
+    try {
+      return await active;
+    } finally {
+      if (pending === active) pending = undefined;
+    }
+  };
+}
+
+/** Body factory lets authentication retries reopen a consumed upload stream. */
+export async function fetchWithUploadAuth(
+  url: string,
+  init: () => RequestInit,
+  auth: { token: string; getToken?: UploadTokenProvider },
+): Promise<Response> {
+  let token = auth.getToken ? await auth.getToken() : auth.token;
+  const send = () => {
+    const options = init();
+    const headers = new Headers(options.headers);
+    headers.set('Authorization', `Bearer ${token}`);
+    return globalThis.fetch(url, { ...options, headers });
+  };
+  let response = await send();
+  if (response.status === 401 && auth.getToken) {
+    const fresh = await auth.getToken(token);
+    if (fresh !== token) {
+      await response.body?.cancel();
+      token = fresh;
+      response = await send();
+    }
+  }
+  return response;
+}

package/src/cli/version.ts

@@ -1,2 +1,2 @@
 // Auto-generated by prebuild — do not edit manually
-export const CLI_VERSION = "0.1.1069";
+export const CLI_VERSION = "0.1.1071";