ugly-app 0.1.1069 → 0.1.1071

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

@@ -0,0 +1,258 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import os from 'node:os';
+import { createServer } from 'node:http';
+import { once } from 'node:events';
+import type { AddressInfo } from 'node:net';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { unchangedUploadKeys, uploadFiles } from './assetUpload.js';
+import { uploadR2AssetsViaApi } from './providers/cloudflare.js';
+
+const dirs: string[] = [];
+function stage(files: Record<string, string>) {
+  const dir = mkdtempSync(path.join(os.tmpdir(), 'publish-assets-'));
+  dirs.push(dir);
+  for (const [key, text] of Object.entries(files)) {
+    const file = path.join(dir, key);
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, text);
+  }
+  return dir;
+}
+const md5 = (text: string) => createHash('md5').update(text).digest('hex');
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.useRealTimers();
+  for (const dir of dirs.splice(0))
+    rmSync(dir, { recursive: true, force: true });
+});
+
+describe('resumable asset uploads', () => {
+  it('skips matching Vite and stable names but never changed, missing or multipart objects', async () => {
+    const dir = stage({
+      'static/game-C5-_7PKy.js': 'same',
+      'static/char.ugm': 'same',
+      'static/changed.fbx': 'NEW!',
+      'static/multipart.bin': 'same',
+      'static/no-size': 'same',
+    });
+    const keys = [
+      'static/game-C5-_7PKy.js',
+      'static/char.ugm',
+      'static/changed.fbx',
+      'static/multipart.bin',
+      'static/no-size',
+      'static/missing',
+    ];
+    const remote = keys.map((key) => ({
+      key,
+      lastModified: new Date(),
+      size: 4,
+      etag: '"' + md5('same') + '"',
+    }));
+    remote[3]!.etag = md5('same') + '-2';
+    const result = await unchangedUploadKeys(dir, [
+      ...remote.filter((o) => o.key !== 'static/no-size'),
+      { key: 'static/no-size', lastModified: new Date(), etag: md5('same') },
+    ]);
+    expect([...result]).toEqual(keys.slice(0, 2));
+  });
+
+  it('runs a bounded pool and drains active uploads before surfacing failure', async () => {
+    const files = Array.from({ length: 8 }, (_, i) => ({
+      key: String(i),
+      full: String(i),
+      bytes: 1,
+    }));
+    let active = 0,
+      peak = 0;
+    const started: string[] = [];
+    await expect(
+      uploadFiles(
+        files,
+        0,
+        async (file) => {
+          active++;
+          peak = Math.max(peak, active);
+          started.push(file.key);
+          try {
+            if (file.key === '0') throw Error('failed');
+            await new Promise((r) => setTimeout(r, 15));
+          } finally {
+            active--;
+          }
+        },
+        { concurrency: 3, onProgress: () => {} },
+      ),
+    ).rejects.toThrow('failed');
+    expect(peak).toBeLessThanOrEqual(3);
+    expect(started).toHaveLength(3);
+    expect(active).toBe(0);
+  });
+
+  it('streams parallel PUTs, skips verified files, and exposes useful progress', async () => {
+    const dir = stage(
+      Object.fromEntries(
+        Array.from({ length: 9 }, (_, i) => [
+          'static/file' + i + '.js',
+          'body' + i,
+        ]),
+      ),
+    );
+    let active = 0,
+      peak = 0;
+    const received = new Map<string, string>();
+    const progress = vi.fn();
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async (url: string, init: RequestInit) => {
+        active++;
+        peak = Math.max(peak, active);
+        expect(init.body).not.toBeInstanceOf(Buffer);
+        const parts: Buffer[] = [];
+        for await (const part of init.body as unknown as AsyncIterable<Buffer>)
+          parts.push(part);
+        await new Promise((r) => setTimeout(r, 5));
+        received.set(
+          decodeURIComponent(url.split('/objects/')[1]!),
+          Buffer.concat(parts).toString(),
+        );
+        active--;
+        return new Response('', { status: 200 });
+      }),
+    );
+    const result = await uploadR2AssetsViaApi({
+      token: 'token',
+      accountId: 'account',
+      bucket: 'bucket',
+      r2UploadDir: dir,
+      skipKeys: new Set(['static/file0.js']),
+      onProgress: progress,
+    });
+    expect(result).toEqual({ uploaded: 8, bytes: 40 });
+    expect(peak).toBe(4);
+    expect(received.size).toBe(8);
+    expect(received.get('static/file8.js')).toBe('body8');
+    expect(progress).toHaveBeenLastCalledWith({
+      total: 8,
+      uploaded: 8,
+      bytes: 40,
+      totalBytes: 40,
+      skipped: 1,
+    });
+  });
+
+  it('reopens the complete stream on 401 and uses the refreshed token', async () => {
+    const dir = stage({ 'static/game.js': 'full stream' });
+    const bodies: string[] = [];
+    const tokens: string[] = [];
+    const getToken = vi.fn(async (stale?: string) => (stale ? 'fresh' : 'old'));
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async (_url: string, init: RequestInit) => {
+        tokens.push(new Headers(init.headers).get('Authorization')!);
+        const parts: Buffer[] = [];
+        for await (const part of init.body as unknown as AsyncIterable<Buffer>)
+          parts.push(part);
+        bodies.push(Buffer.concat(parts).toString());
+        return new Response('', { status: bodies.length === 1 ? 401 : 200 });
+      }),
+    );
+    await uploadR2AssetsViaApi({
+      token: 'old',
+      getToken,
+      accountId: 'a',
+      bucket: 'b',
+      r2UploadDir: dir,
+      onProgress: () => {},
+    });
+    expect(tokens).toEqual(['Bearer old', 'Bearer fresh']);
+    expect(bodies).toEqual(['full stream', 'full stream']);
+    expect(getToken).toHaveBeenCalledWith('old');
+  });
+
+  it('sends complete bodies through real HTTP streaming and retries a rejected request', async () => {
+    const text = 'voxel'.repeat(30000);
+    const dir = stage({ 'static/kit.bin': text });
+    const received: string[] = [];
+    const server = createServer(async (req, res) => {
+      const parts: Buffer[] = [];
+      for await (const part of req) parts.push(part as Buffer);
+      received.push(Buffer.concat(parts).toString());
+      res.writeHead(received.length === 1 ? 401 : 200);
+      res.end();
+    });
+    server.listen(0, '127.0.0.1');
+    await once(server, 'listening');
+    const nativeFetch = globalThis.fetch;
+    vi.stubGlobal('fetch', (_url: string, init: RequestInit) =>
+      nativeFetch(
+        `http://127.0.0.1:${(server.address() as AddressInfo).port}/upload`,
+        init,
+      ),
+    );
+    try {
+      await uploadR2AssetsViaApi({
+        token: 'old',
+        getToken: async (stale) => (stale ? 'new' : 'old'),
+        accountId: 'a',
+        bucket: 'b',
+        r2UploadDir: dir,
+        onProgress: () => {},
+      });
+      expect(received).toEqual([text, text]);
+    } finally {
+      server.closeAllConnections();
+      await new Promise<void>((resolve, reject) =>
+        server.close((error) => (error ? reject(error) : resolve())),
+      );
+    }
+  });
+
+  it('does not loop on a revoked credential or permanent permission failure', async () => {
+    const dir = stage({ 'static/a.js': 'a' });
+    const fetch = vi.fn(
+      async () =>
+        new Response(JSON.stringify({ errors: [{ message: 'denied' }] }), {
+          status: 401,
+        }),
+    );
+    vi.stubGlobal('fetch', fetch);
+    await expect(
+      uploadR2AssetsViaApi({
+        token: 'revoked',
+        getToken: async () => 'revoked',
+        accountId: 'a',
+        bucket: 'b',
+        r2UploadDir: dir,
+        onProgress: () => {},
+      }),
+    ).rejects.toThrow(/failed to PUT/);
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('backs off on 503 without Retry-After instead of retrying immediately', async () => {
+    const dir = stage({ 'static/a.js': 'a' });
+    const attempts: number[] = [];
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async (_url: string, init: RequestInit) => {
+        for await (const _chunk of init.body as unknown as AsyncIterable<Buffer>) {
+          /* consume stream */
+        }
+        attempts.push(Date.now());
+        return new Response('', { status: attempts.length === 1 ? 503 : 200 });
+      }),
+    );
+    await uploadR2AssetsViaApi({
+      token: 't',
+      accountId: 'a',
+      bucket: 'b',
+      r2UploadDir: dir,
+      onProgress: () => {},
+    });
+    expect(attempts).toHaveLength(2);
+    expect(attempts[1]! - attempts[0]!).toBeGreaterThanOrEqual(450);
+  });
+});

package/src/cli/publish/assetUpload.ts

@@ -0,0 +1,107 @@
+import { createReadStream, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import type { RemoteObject } from './staticSync.js';
+
+/** Compare bytes, not filename conventions. Multipart ETags are not MD5s. */
+export async function unchangedUploadKeys(
+  directory: string,
+  remote: readonly RemoteObject[],
+): Promise<Set<string>> {
+  const unchanged = new Set<string>();
+  for (const object of remote) {
+    const etag = object.etag?.replace(/^"|"$/g, '').toLowerCase();
+    if (!etag || !/^[a-f0-9]{32}$/.test(etag) || object.size === undefined)
+      continue;
+    const file = path.resolve(directory, object.key);
+    const relative = path.relative(path.resolve(directory), file);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) continue;
+    let stat;
+    try {
+      stat = await fs.stat(file);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') continue;
+      throw error;
+    }
+    if (!stat.isFile() || stat.size !== object.size) continue;
+    const hash = createHash('md5');
+    for await (const chunk of createReadStream(file))
+      hash.update(chunk as Buffer);
+    if (hash.digest('hex') === etag) unchanged.add(object.key);
+  }
+  return unchanged;
+}
+
+export interface UploadFile {
+  key: string;
+  full: string;
+  bytes: number;
+}
+export interface UploadProgress {
+  total: number;
+  uploaded: number;
+  bytes: number;
+  totalBytes: number;
+  skipped: number;
+}
+export interface UploadOptions {
+  /** Four streams by default; capped to avoid API/memory pressure. */
+  concurrency?: number;
+  onProgress?: (progress: UploadProgress) => void;
+}
+
+/** Stop admitting new files on failure, and settle every active upload before returning. */
+export async function uploadFiles(
+  files: readonly UploadFile[],
+  skipped: number,
+  upload: (file: UploadFile) => Promise<void>,
+  options: UploadOptions = {},
+): Promise<{ uploaded: number; bytes: number }> {
+  const concurrency = Math.max(
+    1,
+    Math.min(8, Math.floor(options.concurrency ?? 4) || 4),
+  );
+  const progress: UploadProgress = {
+    total: files.length,
+    uploaded: 0,
+    bytes: 0,
+    totalBytes: files.reduce((sum, f) => sum + f.bytes, 0),
+    skipped,
+  };
+  const report = () => {
+    if (options.onProgress) options.onProgress({ ...progress });
+    else
+      console.log(
+        `[publish-assets] ${progress.uploaded}/${progress.total} files, ` +
+          `${(progress.bytes / 1048576).toFixed(1)}/${(progress.totalBytes / 1048576).toFixed(1)} MiB uploaded; ${skipped} unchanged`,
+      );
+  };
+  report();
+  const timer = setInterval(report, 10000);
+  timer.unref();
+  let next = 0;
+  let failed = false;
+  let failure: unknown;
+  try {
+    await Promise.all(
+      Array.from({ length: Math.min(concurrency, files.length) }, async () => {
+        while (!failed && next < files.length) {
+          const file = files[next++]!;
+          try {
+            await upload(file);
+            progress.uploaded++;
+            progress.bytes += file.bytes;
+          } catch (error) {
+            if (!failed) failure = error;
+            failed = true;
+          }
+        }
+      }),
+    );
+    if (failed) throw failure;
+    report();
+    return { uploaded: progress.uploaded, bytes: progress.bytes };
+  } finally {
+    clearInterval(timer);
+  }
+}

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

@@ -0,0 +1,55 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const { send, destroy } = vi.hoisted(() => ({
+  send: vi.fn(),
+  destroy: vi.fn(),
+}));
+vi.mock('@aws-sdk/client-s3', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@aws-sdk/client-s3')>()),
+  S3Client: class {
+    send = send;
+    destroy = destroy;
+  },
+}));
+import { uploadR2Assets } from './providers/cloudflare.js';
+afterEach(() => vi.resetAllMocks());
+it('uses bounded streams and closes the S3 client after all uploads settle', async () => {
+  const dir = mkdtempSync(path.join(os.tmpdir(), 's3-upload-'));
+  for (let i = 0; i < 6; i++)
+    writeFileSync(path.join(dir, `${i}.bin`), `kit${i}`);
+  let active = 0,
+    peak = 0;
+  const bodies: string[] = [];
+  send.mockImplementation(async (command) => {
+    active++;
+    peak = Math.max(peak, active);
+    const parts: Buffer[] = [];
+    for await (const part of command.input.Body) parts.push(part);
+    const body = Buffer.concat(parts);
+    expect(command.input.ContentLength).toBe(body.length);
+    bodies.push(body.toString());
+    await new Promise((r) => setTimeout(r, 5));
+    active--;
+  });
+  try {
+    expect(
+      await uploadR2Assets({
+        endpoint: 'https://r2.example',
+        accessKeyId: 'a',
+        secretAccessKey: 's',
+        bucket: 'b',
+        r2UploadDir: dir,
+        skipKeys: new Set(['0.bin']),
+        onProgress: () => {},
+      }),
+    ).toEqual({ uploaded: 5, bytes: 20 });
+    expect(peak).toBe(4);
+    expect(active).toBe(0);
+    expect(bodies.sort()).toEqual(['kit1', 'kit2', 'kit3', 'kit4', 'kit5']);
+    expect(destroy).toHaveBeenCalledOnce();
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/cli/publish/orchestrator.ts

@@ -46,6 +46,8 @@ import { projectPackageManager } from './packageManager.js';
 import type { RecipeDoc, RecipeStep } from './types.js';
 import { promises as dnsPromises } from 'node:dns';
 import { getFreshCloudflareCredentials } from '../auth/cloudflareOauth.js';
+import { unchangedUploadKeys } from './assetUpload.js';
+import { createUploadTokenProvider } from './uploadAuth.js';
 import { getNeonCredentials } from '../auth/credentials.js';
 import {
   importTs,
@@ -56,7 +58,6 @@ import {
 } from '../uglyappConfig.js';
 import {
   DEFAULT_STATIC_DIR,
-  isContentAddressedKey,
   runBuildStatic,
   scanStaticDir,
   STATIC_PREFIX,
@@ -2437,18 +2438,26 @@ export async function runPublish(
               'workers-deploy: missing upstream provisioning state',
             );
           }
-          const cloudflareToken = await getSecret(
+          let cloudflareToken = await getSecret(
             `cloudflare:token:${input.projectId}`,
           );
           if (!cloudflareToken) {
             throw new Error('workers-deploy: missing cloudflare:token secret');
           }
-          // Content-addressed keys already in the bucket. A CDN-hosted bundle
-          // keeps the SAME keys across deploys (that's the point), so without
-          // this the r2-upload pass below re-PUTs the whole bundle every time
-          // even though nothing changed. `builds/{buildId}/…` keys are new
-          // each deploy and are never in this set.
-          const alreadyPresentStatic = new Set<string>();
+          const getUploadToken = createUploadTokenProvider(
+            cloudflareToken,
+            state.cloudflare.accountId,
+            async (token) => {
+              await setSecret(`cloudflare:token:${input.projectId}`, token);
+              cloudflareToken = token;
+            },
+          );
+          cloudflareToken = await getUploadToken();
+          const r2UploadDir = path.join(
+            input.projectPath,
+            'dist/worker/r2-upload',
+          );
+          let alreadyPresentStatic = new Set<string>();
           // Escape hatch: re-PUT every static object even though the key is
           // already there. Needed when the OBJECT METADATA has to change —
           // content-addressed keys mean the bytes are right, so presence alone
@@ -2475,24 +2484,20 @@ export async function runPublish(
                   })
                 : createApiR2Ops({
                     token: cloudflareToken,
+                    getToken: getUploadToken,
                     accountId: state.cloudflare.accountId,
                     bucket: state.cloudflare.bucket,
                   });
-            for (const o of await probe.list(STATIC_PREFIX)) {
-              // ⚠️ PRESENCE SKIPS CONTENT-ADDRESSED KEYS ONLY. Their md5
-              // fragment pins the bytes (`staticKeyFor`), so an existing key
-              // is provably the same object. A STABLE key — the character
-              // kit's `anims/*.fbx`, UGMs, anything `staticKeyFor` never
-              // named — keeps one name across byte changes, and skipping it
-              // on presence meant a replaced FBX never reached the CDN
-              // (found when a new T-Pose deployed "successfully" and the CDN
-              // kept serving the old one). Stable keys re-PUT every deploy;
-              // that is the price of a key that does not name its bytes.
-              if (isContentAddressedKey(o.key)) alreadyPresentStatic.add(o.key);
-            }
-          } catch {
-            // Listing is an optimisation. If it fails, upload everything —
-            // slower, still correct.
+            alreadyPresentStatic = await unchangedUploadKeys(
+              r2UploadDir,
+              await probe.list(STATIC_PREFIX),
+            );
+          } catch (error) {
+            // Listing/hashing is an optimisation; fail safely by uploading.
+            if (!forceStatic)
+              console.warn(
+                `[publish-assets] Cannot compare remote assets; uploading all: ${(error as Error).message}`,
+              );
           }
 
           const scriptBody = await fs.readFile(
@@ -2505,10 +2510,6 @@ export async function runPublish(
           // /{buildId}/* directly from R2. The build:workers step
           // staged everything under `dist/worker/r2-upload/` with
           // paths that mirror their R2 keys exactly.
-          const r2UploadDir = path.join(
-            input.projectPath,
-            'dist/worker/r2-upload',
-          );
           // Upload assets to R2. Preferred path: the Cloudflare REST object
           // API authenticated with the same Bearer token (no S3 keys, fully
           // non-interactive). If a project still has captured S3 keys (legacy
@@ -2561,6 +2562,7 @@ export async function runPublish(
           } else {
             r2Result = await cloudflare.uploadR2AssetsViaApi({
               token: cloudflareToken,
+              getToken: getUploadToken,
               accountId: state.cloudflare.accountId,
               bucket: state.cloudflare.bucket,
               r2UploadDir,
@@ -2575,6 +2577,8 @@ export async function runPublish(
             );
           }
 
+          cloudflareToken = await getUploadToken();
+
           // ── Content-addressed static assets ─────────────────────────
           // These do NOT go through the Worker. The bucket gets its own
           // custom domain so Cloudflare's CDN serves them directly: a Worker
@@ -2598,6 +2602,7 @@ export async function runPublish(
                 })
               : createApiR2Ops({
                   token: cloudflareToken,
+                  getToken: getUploadToken,
                   accountId: state.cloudflare.accountId,
                   bucket: state.cloudflare.bucket,
                 });