@thomas.f/prnext 0.1.12-alpha → 0.1.15-alpha

package/runtime/cloud/state.mjs

@@ -0,0 +1,156 @@
+import { mkdir, lstat, readFile, realpath, writeFile, rm, chmod } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { createHash, randomBytes } from 'node:crypto';
+import { rename } from '../fs.mjs';
+
+// Resolve existing parents too when a destination has not been created yet.
+// On macOS, for example, /var and /private/var refer to the same directory.
+export async function prospectivePath(value) {
+  let parent = path.resolve(value);
+  const missing = [];
+  for (;;) {
+    try { return path.join(await realpath(parent), ...missing); }
+    catch (error) {
+      if (error.code !== 'ENOENT' || path.dirname(parent) === parent) throw error;
+      missing.unshift(path.basename(parent));
+      parent = path.dirname(parent);
+    }
+  }
+}
+
+export function cloudOrigin(value = 'https://app.prnext.dev') {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(
+      'Cloud server must be an HTTPS origin or a loopback HTTP origin.'
+    );
+  }
+  if (
+    url.username ||
+    url.password ||
+    url.pathname !== '/' ||
+    url.search ||
+    url.hash ||
+    !(
+      url.protocol === 'https:' ||
+      (url.protocol === 'http:' &&
+        ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname))
+    )
+  )
+    throw new Error(
+      'Cloud server must be an HTTPS origin or a loopback HTTP origin.'
+    );
+  return url.origin;
+}
+export async function readState(filename) {
+  try {
+    const info = await lstat(filename);
+    if (!info.isFile() || info.isSymbolicLink() || info.size > 65536)
+      throw new Error('Invalid PRNext Cloud state file.');
+    const value = JSON.parse(await readFile(filename, 'utf8'));
+    if (!value || Array.isArray(value) || typeof value !== 'object')
+      throw new Error('Invalid PRNext Cloud state file.');
+    return value;
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+export async function writeState(filename, data) {
+  const directory = path.dirname(filename);
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  const info = await lstat(directory);
+  if (info.isSymbolicLink() || !info.isDirectory())
+    throw new Error('PRNext Cloud state directory cannot be a link.');
+  await readState(filename);
+  if (process.platform !== 'win32') await chmod(directory, 0o700);
+  const temporary = `${filename}.${randomBytes(8).toString('hex')}.tmp`;
+  try {
+    await writeFile(temporary, JSON.stringify(data, null, 2) + '\n', {
+      flag: 'wx',
+      mode: 0o600
+    });
+    await rename(temporary, filename);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+export function credentialPath(origin, env = process.env) {
+  const directory = path.resolve(
+    env.PRNEXT_CLOUD_HOME || path.join(homedir(), '.prnext', 'cloud')
+  );
+  return path.join(
+    directory,
+    createHash('sha256').update(cloudOrigin(origin)).digest('hex') + '.json'
+  );
+}
+export const linkPath = (directory) =>
+  path.join(directory, '.prnext-cloud', 'project.json');
+export async function withStateLock(filename, task) {
+  await mkdir(path.dirname(filename), { recursive: true, mode: 0o700 });
+  if ((await lstat(path.dirname(filename))).isSymbolicLink())
+    throw new Error('Cloud state directory cannot be a link.');
+  const marker = { pid: process.pid, nonce: randomBytes(16).toString('hex') };
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await writeFile(filename, JSON.stringify(marker), {
+        flag: 'wx',
+        mode: 0o600
+      });
+      break;
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      const previous = await readState(filename);
+      let active = true;
+      if (Number.isSafeInteger(previous?.pid) && previous.pid > 0) {
+        try {
+          process.kill(previous.pid, 0);
+        } catch (failure) {
+          if (failure.code === 'ESRCH') active = false;
+        }
+      }
+      if (active || attempt > 0)
+        throw new Error(
+          'Another PRNext Cloud command is using this project. Wait for it to finish.'
+        );
+      if ((await readState(filename))?.nonce === previous.nonce)
+        await rm(filename);
+    }
+  }
+  try {
+    return await task();
+  } finally {
+    if ((await readState(filename))?.nonce === marker.nonce) await rm(filename);
+  }
+}
+export async function saveLink(directory, link) {
+  await writeState(linkPath(directory), link);
+  const gitignore = path.join(directory, '.gitignore');
+  let contents = '';
+  try {
+    const stat = await lstat(gitignore);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 65536)
+      throw new Error(
+        'Cannot safely update .gitignore; ignore .prnext-cloud/ manually.'
+      );
+    contents = await readFile(gitignore, 'utf8');
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  if (
+    !contents
+      .split(/\r?\n/)
+      .some((line) =>
+        ['.prnext-cloud/', '/.prnext-cloud/', '.prnext-cloud'].includes(line)
+      )
+  )
+    await writeFile(
+      gitignore,
+      contents +
+        (contents.endsWith('\n') || !contents ? '' : '\n') +
+        '.prnext-cloud/\n'
+    );
+}

package/runtime/cloud/upload.mjs

@@ -0,0 +1,48 @@
+import { open } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+
+// The checkpoint contains identifiers/checksums only, never source or env contents.
+export async function uploadSource(api, link, archive, {save, signal, log = () => {}}) {
+  const base = `/projects/${encodeURIComponent(link.projectId)}/uploads`;
+  const retry = async fn => {
+    for (let attempt=0;;attempt++) {
+      signal?.throwIfAborted();
+      try { return await fn(); }
+      catch (error) {
+        if (signal?.aborted || attempt >= 3 || error.status && ![408,429,500,502,503,504].includes(error.status) && error.code !== 'upload_busy') throw error;
+        await delay(500 * 2**attempt,undefined,{signal});
+      }
+    }
+  };
+  if (link.upload && link.upload.digest !== archive.digest) {
+    await api(`${base}/${link.upload.id}`,{method:'DELETE'}).catch(error => {if (![404,410].includes(error.status)) throw error;});
+    delete link.upload;
+  }
+  link.upload ||= {id:randomUUID(),digest:archive.digest};
+  await save(link);
+  let session;
+  try {
+    session = await retry(() => api(base,{method:'POST',body:{requestId:link.upload.id,bytes:archive.size,sourceBytes:archive.expandedBytes,digest:archive.digest}}));
+  } catch(error) {
+    if ([404,410].includes(error.status)) {delete link.upload;await save(link);}
+    throw error;
+  }
+  if (session.result) return session.result;
+  if (!Number.isSafeInteger(session.chunkBytes) || session.chunkBytes < 1 || session.chunkBytes > 4*1048576) throw new Error('Unsupported server upload chunk size.');
+  const parts = new Map(session.parts.map(p => [p.part,p.digest]));
+  const handle = await open(archive.path,'r');
+  try {
+    for (let offset=0,part=0;offset<archive.size;offset+=session.chunkBytes,part++) {
+      signal?.throwIfAborted();
+      const body = Buffer.alloc(Math.min(session.chunkBytes,archive.size-offset));
+      let read=0;
+      while (read<body.length) {const result=await handle.read(body,read,body.length-read,offset+read);if(!result.bytesRead)throw new Error('Temporary archive changed. Run the command again.');read+=result.bytesRead;}
+      const digest = createHash('sha256').update(body).digest('hex');
+      if (parts.has(part) && parts.get(part) !== digest) throw new Error('Resumed upload checksum differs. Cancel this upload and try again.');
+      if (!parts.has(part)) await retry(() => api(`${base}/${link.upload.id}/chunks/${part}`,{method:'PUT',body}));
+      log(`Uploading sources: ${Math.round(100*(offset+body.length)/archive.size)}%`);
+    }
+  } finally { await handle.close(); }
+  return retry(() => api(`${base}/${link.upload.id}/complete`,{method:'POST',body:{}}));
+}

package/runtime/html-envelope.mjs

@@ -1,5 +1,50 @@
 import { MAX_RESPONSE_BYTES } from './http.mjs';
 
+// A raw element cannot be interrupted with a Flight script. Keep its chunks
+// until its closing tag arrives, but only scan newly received characters.
+// Joining and rescanning a growing inline script on every chunk is quadratic.
+const whitespace = /\s/;
+function holdRaw(state, text) {
+  if (!text) return;
+  // Compact small chunks in tiers: even single-character input cannot retain
+  // millions of array entries. Each tier joins once per 64 chunks, rather
+  // than repeatedly copying the entire accumulated element.
+  for (let level = 0;; level++) {
+    const parts = state.parts[level] ??= [];
+    parts.push(text);
+    if (parts.length < 64) return;
+    text = parts.join('');
+    parts.length = 0;
+  }
+}
+function releaseRaw(state) {
+  const parts = [];
+  for (let level = state.parts.length - 1; level >= 0; level--) parts.push(...state.parts[level]);
+  return parts.join('');
+}
+function rawEnd(text, state, from = 0) {
+  let index = from;
+  while (index < text.length) {
+    if (!state.matched) {
+      const start = text.indexOf('<', index);
+      if (start < 0) return -1;
+      state.matched = 1;
+      index = start + 1;
+    } else if (state.matched < state.prefix.length) {
+      const code = text.charCodeAt(index);
+      if (state.matched === 1 ? code === 47 : (code | 32) === state.prefix.charCodeAt(state.matched)) {
+        state.matched++;
+        index++;
+      } else state.matched = 0;
+    } else if (text[index] === '>') {
+      return index + 1;
+    } else if (whitespace.test(text[index])) {
+      index++;
+    } else state.matched = 0;
+  }
+  return -1;
+}
+
 // Do not insert Flight/bootstrap scripts inside a split tag or raw-text element.
 // Scan by index: ordinary tags stay in one contiguous slice, instead of creating
 // a new tail and output string for every cell of a rendered table.
@@ -7,6 +52,7 @@ export function htmlEnvelope({ resumed = false } = {}) {
   let pending = '';
   let closing = '';
   let received = 0;
+  let rawPending;
   const rawStart = /<(script|style|textarea|title|svg|math)(?:\s|>)/iy;
   const rawEnds = new Map();
   const documentEnd = /<\/(body|html)\s*>/iy;
@@ -14,8 +60,17 @@ export function htmlEnvelope({ resumed = false } = {}) {
     append(text) {
       received += Buffer.byteLength(text);
       if (received > MAX_RESPONSE_BYTES) throw new Error('HTML response exceeds the 16 MiB PRNext limit');
+      let ready = '';
+      if (rawPending) {
+        const end = rawEnd(text, rawPending);
+        if (end < 0) { holdRaw(rawPending, text); return ''; }
+        holdRaw(rawPending, text.slice(0, end));
+        ready = releaseRaw(rawPending);
+        rawPending = undefined;
+        text = text.slice(end);
+      }
       pending += text;
-      let cursor = 0, output = 0, ready = '';
+      let cursor = 0, output = 0;
       while (cursor < pending.length) {
         const start = pending.indexOf('<', cursor);
         if (start < 0) { cursor = pending.length; break; }
@@ -25,12 +80,13 @@ export function htmlEnvelope({ resumed = false } = {}) {
           const comment = pending.indexOf('-->', start);
           if (comment >= 0) end = comment + 2;
         } else {
-          let quote;
           for (let index = start + 1; index < pending.length; index++) {
             const char = pending[index];
-            if (quote) { if (char === quote) quote = undefined; }
-            else if (char === '"' || char === "'") quote = char;
-            else if (char === '>') { end = index; break; }
+            if (char === '"' || char === "'") {
+              const close = pending.indexOf(char, index + 1);
+              if (close < 0) break;
+              index = close;
+            } else if (char === '>') { end = index; break; }
           }
         }
         if (end < 0) break;
@@ -49,7 +105,14 @@ export function htmlEnvelope({ resumed = false } = {}) {
           if (!pattern) { pattern = new RegExp(`</${name}\\s*>`, 'ig'); rawEnds.set(name, pattern); }
           pattern.lastIndex = end + 1;
           const match = pattern.exec(pending);
-          if (!match) break;
+          if (!match) {
+            rawPending = { prefix: `</${name}`, matched: 0, parts: [] };
+            holdRaw(rawPending, pending.slice(start));
+            rawEnd(pending, rawPending, end + 1);
+            ready += pending.slice(output, start);
+            pending = '';
+            return ready;
+          }
           cursor = pattern.lastIndex;
         } else {
           documentEnd.lastIndex = start;
@@ -66,7 +129,7 @@ export function htmlEnvelope({ resumed = false } = {}) {
       return ready;
     },
     finish() {
-      if (pending || !(resumed ? /^(?:<\/body><\/html>){1,2}$/i : /^<\/body><\/html>$/i).test(closing)) throw new Error('App Router root layout did not close its body and html elements');
+      if (pending || rawPending || !(resumed ? /^(?:<\/body><\/html>){1,2}$/i : /^<\/body><\/html>$/i).test(closing)) throw new Error('App Router root layout did not close its body and html elements');
       return resumed ? '</body></html>' : closing;
     },
   };

package/runtime/http.mjs

@@ -1,4 +1,7 @@
-import { IncomingMessage, validateHeaderName, validateHeaderValue } from 'node:http';
+import { createRequire } from 'node:module';
+// ESM node:http evaluates lazy WebSocket exports and initializes Undici.
+// Use the module object to avoid that startup cost while preserving HTTP patches.
+const http = createRequire(import.meta.url)('node:http');
 import { Duplex, Writable } from 'node:stream';
 import { revalidatePage } from './pages-revalidate.mjs';
 import { currentRequest } from '../compat/headers.cjs';
@@ -45,7 +48,7 @@ export function createRequest({ url, originalUrl, method = 'GET', headers = {},
   const visible = originalUrl ? new URL(originalUrl, parsed) : parsed;
   const socket = new Duplex({ read() {}, write(_chunk, _encoding, callback) { callback(); } });
   socket.remoteAddress = '127.0.0.1';
-  const request = new IncomingMessage(socket);
+  const request = new http.IncomingMessage(socket);
   request.method = method;
   request.url = `${visible.pathname}${visible.search}`;
   request.headers = Object.fromEntries(Object.entries(headers).map(([name, value]) => [name.toLowerCase(), value]));
@@ -85,9 +88,9 @@ export class CapturedResponse extends Writable {
   get finished() { return this.writableEnded; }
   setHeader(name, value) {
     if (this.headersSent) throw new Error('Cannot set headers after they are sent');
-    validateHeaderName(name);
+    http.validateHeaderName(name);
     const normalized = Array.isArray(value) ? value.map(String) : String(value);
-    for (const item of Array.isArray(normalized) ? normalized : [normalized]) validateHeaderValue(name, item);
+    for (const item of Array.isArray(normalized) ? normalized : [normalized]) http.validateHeaderValue(name, item);
     this._headers[name.toLowerCase()] = normalized;
     return this;
   }

package/runtime/middleware.mjs

@@ -12,7 +12,7 @@ installFetchCache();
 
 const FLIGHT_HEADERS = ['rsc', 'next-router-state-tree', 'x-prnext-router-state', 'next-router-prefetch', 'next-hmr-refresh', 'next-router-segment-prefetch'];
 const HOP_HEADERS = new Set(['connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization', 'te', 'trailer', 'transfer-encoding', 'upgrade', 'content-length']);
-const MAX_BODY = 8 * 1024 * 1024;
+const MAX_BODY = 32 * 1024 * 1024;
 const MAX_SCOPES = 32;
 const MAX_PROMISES = 128;
 const scopes = new Set();
@@ -133,9 +133,9 @@ export async function runMiddleware(options) {
         if (typeof handler !== 'function') throw new TypeError(`Middleware must export a ${exportName} function`);
         const init = { method: options.method || 'GET', headers, signal: controller.signal };
         if (!['GET', 'HEAD'].includes(init.method)) {
-          if (typeof options.body === 'string' && options.body.length > Math.ceil(MAX_BODY / 3) * 4) throw Object.assign(new Error('Middleware request exceeds the 8 MiB PRNext limit'), { statusCode: 413 });
+          if (typeof options.body === 'string' && options.body.length > Math.ceil(MAX_BODY / 3) * 4) throw Object.assign(new Error('Middleware request exceeds the 32 MiB PRNext limit'), { statusCode: 413 });
           const body = Buffer.isBuffer(options.body) ? options.body : Buffer.from(options.body || '', 'base64');
-          if (body.byteLength > MAX_BODY) throw Object.assign(new Error('Middleware request exceeds the 8 MiB PRNext limit'), { statusCode: 413 });
+          if (body.byteLength > MAX_BODY) throw Object.assign(new Error('Middleware request exceeds the 32 MiB PRNext limit'), { statusCode: 413 });
           if (body.byteLength) init.body = body;
         }
         const request = new NextRequest(exposedUrl, { ...init, nextConfig: options.manifest?.config });