shiply-cli 0.18.2 → 0.19.0

package/dist/bundle.js

@@ -1,17 +1,26 @@
-import { cp, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import { cp, mkdir, mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
+import { builtinModules } from 'node:module';
 import { tmpdir } from 'node:os';
-import { isAbsolute, join, relative } from 'node:path';
+import { dirname, isAbsolute, join, relative } from 'node:path';
 import { build } from 'esbuild';
 const BUNDLE_COMPAT_DATE = '2025-05-05';
-/** Cloudflare runtime built-ins (`cloudflare:workers`, …) and `node:*` (provided
- *  by `nodejs_compat`) resolve at the edge — they must stay external. Everything
- *  else, including the framework server code that an adapter's `_worker.js`
- *  imports from OUTSIDE its output dir, gets inlined. */
-const WORKER_EXTERNALS = ['cloudflare:*', 'node:*'];
-/** esbuild-bundle a worker entry into one self-contained ESM module. */
-async function bundleWorker(entryAbs) {
-    const result = await build({
-        entryPoints: [entryAbs],
+/** Cloudflare runtime built-ins (`cloudflare:workers`, …) and Node builtins
+ *  (provided by `nodejs_compat`) resolve at the edge — they must stay external.
+ *  Node builtins must be matched both `node:`-prefixed AND BARE (`require('fs')`):
+ *  OpenNext / Next.js imports them bare, which `node:*` alone doesn't catch.
+ *  Derived from `builtinModules` so it stays correct across Node versions. Safe
+ *  for every framework — `platform: 'neutral'` never inlines builtins anyway.
+ *  Everything else (framework server code an adapter imports) gets inlined. */
+const WORKER_EXTERNALS = [
+    'cloudflare:*',
+    'node:*',
+    ...builtinModules.flatMap((m) => [m, `${m}/*`]),
+];
+/** esbuild-bundle a worker entry into one self-contained ESM module, optionally
+ *  wrapping it (named-fetch → default, and/or asset-first) via a synthetic entry. */
+async function bundleWorker(entryAbs, opts = {}) {
+    const common = {
         bundle: true,
         format: 'esm',
         platform: 'neutral',
@@ -19,7 +28,25 @@ async function bundleWorker(entryAbs) {
         external: WORKER_EXTERNALS,
         write: false,
         logLevel: 'silent',
-    });
+    };
+    if (!opts.wrapDefaultFetch && !opts.assetFirst) {
+        const result = await build({ ...common, entryPoints: [entryAbs] });
+        return result.outputFiles[0].text;
+    }
+    const spec = JSON.stringify(entryAbs.split('\\').join('/'));
+    const importLine = opts.wrapDefaultFetch ? `import { fetch as __inner } from ${spec}` : `import __handler from ${spec}`;
+    const innerCall = opts.wrapDefaultFetch ? `__inner(request, env, ctx)` : `__handler.fetch(request, env, ctx)`;
+    // Asset-first, but ONLY for paths whose last segment has a file extension
+    // (real static files like /assets/x.js, /_next/static/y.css). Extension-less
+    // paths (/, /about, /api/x) go straight to SSR — otherwise env.ASSETS returns
+    // shiply-static's directory LISTING (a 200) for "/" and we'd serve that
+    // instead of the SSR page. The 404-fallthrough still covers extensioned
+    // dynamic routes (e.g. a generated /sitemap.xml that isn't a static file).
+    const assetGuard = opts.assetFirst
+        ? `const __seg = (new URL(request.url)).pathname.split('/').pop() || '';\n    if (__seg.includes('.') && env && env.ASSETS) { const __a = await env.ASSETS.fetch(request); if (__a.status !== 404) return __a }\n    `
+        : ``;
+    const contents = `${importLine}\nexport default { async fetch(request, env, ctx) {\n    ${assetGuard}return ${innerCall}\n  } }\n`;
+    const result = await build({ ...common, stdin: { contents, resolveDir: dirname(entryAbs), loader: 'js' } });
     return result.outputFiles[0].text;
 }
 /** Stage a temp publish dir: a single bundled worker under `.shiply/bundle/`,
@@ -34,8 +61,15 @@ export async function prepareBundle(sourceDir, ssr) {
     const out = await mkdtemp(join(tmpdir(), 'shiply-bundle-'));
     const bundleDir = join(out, '.shiply', 'bundle');
     await mkdir(bundleDir, { recursive: true });
+    if (ssr.bundleWith === 'wrangler') {
+        await stageWranglerBundle(sourceDir, ssr, out, bundleDir);
+        return out;
+    }
     // Bundle the worker entry into one self-contained ESM module.
-    await writeFile(join(bundleDir, 'index.js'), await bundleWorker(join(sourceDir, ssr.workerEntry)));
+    await writeFile(join(bundleDir, 'index.js'), await bundleWorker(join(sourceDir, ssr.workerEntry), {
+        wrapDefaultFetch: ssr.wrapDefaultFetch,
+        assetFirst: ssr.assetFirst,
+    }));
     // Copy static assets, if any. The worker entry may live inside the assets dir
     // (SvelteKit, Astro) or in a sibling (Nitro's .output/server vs .output/public);
     // when inside, drop it so it isn't double-served.
@@ -56,6 +90,64 @@ export async function prepareBundle(sourceDir, ssr) {
     });
     return out;
 }
+/** Next.js (OpenNext) path: let wrangler bundle the worker (its nodejs-compat
+ *  bundler converts dynamic require('node:*') to top-level imports — esbuild
+ *  can't), then deploy that worker multi-module with a hand-written asset-first
+ *  entry. Two modules: index.js (entry) imports ./worker.js (wrangler's bundle). */
+async function stageWranglerBundle(sourceDir, ssr, out, bundleDir) {
+    const wtmp = await mkdtemp(join(tmpdir(), 'shiply-wrangler-'));
+    // `--dry-run` bundles without deploying (no CF auth needed). Local wrangler
+    // (OpenNext projects depend on it) is preferred via npx. shell:true → npx.cmd on Windows.
+    const res = spawnSync('npx', ['wrangler', 'deploy', '--dry-run', '--outdir', wtmp], {
+        cwd: sourceDir,
+        encoding: 'utf8',
+        shell: true,
+        env: { ...process.env, CLOUDFLARE_API_TOKEN: process.env.CLOUDFLARE_API_TOKEN ?? 'dry-run' },
+    });
+    const workerPath = join(wtmp, 'worker.js');
+    const built = await stat(workerPath).then((s) => s.isFile(), () => false);
+    if (!built) {
+        throw new Error(`wrangler could not bundle the ${ssr.framework} worker (is wrangler installed in the project?).\n` +
+            `${(res.stderr || res.stdout || '').slice(0, 1200)}`);
+    }
+    await cp(workerPath, join(bundleDir, 'worker.js'));
+    // Asset-first entry that defers to wrangler's worker. Hand-written (not
+    // esbuild) so we never re-process wrangler's correctly-bundled output.
+    // OpenNext's worker ALSO calls env.ASSETS itself and treats any non-404 as an
+    // asset — but shiply-static returns a 200 directory LISTING for index-less
+    // dirs (e.g. "/"), which OpenNext would serve instead of SSR. So we hand it a
+    // GUARDED env.ASSETS that turns an extension-less HTML 200 (a listing) into a
+    // 404, making OpenNext SSR those paths. Real assets (with a file extension)
+    // pass through unchanged.
+    const entry = `import __h from './worker.js'\n` +
+        `const __ext = (u) => { try { return ((new URL(u)).pathname.split('/').pop() || '').includes('.') } catch { return false } };\n` +
+        `function __guard(env) {\n` +
+        `  if (!env || !env.ASSETS) return env;\n` +
+        `  const A = { fetch: async (req, ...a) => {\n` +
+        `    const url = typeof req === 'string' ? req : req.url;\n` +
+        `    const r = await env.ASSETS.fetch(req, ...a);\n` +
+        `    if (r.status === 200 && !__ext(url) && (r.headers.get('content-type') || '').includes('text/html')) return new Response(null, { status: 404 });\n` +
+        `    return r;\n` +
+        `  } };\n` +
+        `  return new Proxy(env, { get: (t, p) => (p === 'ASSETS' ? A : t[p]) });\n` +
+        `}\n` +
+        `export default { async fetch(request, env, ctx) {\n` +
+        `    const __seg = (new URL(request.url)).pathname.split('/').pop() || '';\n` +
+        `    if (__seg.includes('.') && env && env.ASSETS) { const __a = await env.ASSETS.fetch(request); if (__a.status !== 404) return __a }\n` +
+        `    return __h.fetch(request, __guard(env), ctx)\n` +
+        `  } }\n`;
+    await writeFile(join(bundleDir, 'index.js'), entry);
+    if (ssr.assetsDir)
+        await cp(join(sourceDir, ssr.assetsDir), out, { recursive: true });
+    await writeManifest(out, {
+        framework: ssr.framework,
+        entry: 'index.js',
+        modules: ['index.js', 'worker.js'],
+        compatibilityDate: ssr.compatibilityDate ?? BUNDLE_COMPAT_DATE,
+        compatibilityFlags: ssr.compatibilityFlags,
+    });
+    await rm(wtmp, { recursive: true, force: true });
+}
 async function writeManifest(out, m) {
     await writeFile(join(out, '.shiply', 'bundle.json'), JSON.stringify({ v: 1, ...m }, null, 2));
 }

package/dist/ssr-adapters.js

@@ -23,6 +23,7 @@ export async function detectSsr(dir) {
             framework: 'sveltekit',
             workerEntry: '.svelte-kit/cloudflare/_worker.js',
             assetsDir: '.svelte-kit/cloudflare',
+            assetFirst: true,
             compatibilityFlags: NODE_COMPAT,
         };
     }
@@ -32,6 +33,7 @@ export async function detectSsr(dir) {
             framework: 'astro',
             workerEntry: 'dist/_worker.js/index.js',
             assetsDir: 'dist',
+            assetFirst: true,
             compatibilityFlags: NODE_COMPAT,
         };
     }
@@ -40,9 +42,86 @@ export async function detectSsr(dir) {
     const nitro = await detectNitro(dir);
     if (nitro)
         return nitro;
+    // Qwik City — cloudflare-pages adapter: `server/entry.cloudflare-pages.js`
+    // (named `fetch` export) + `dist/` client assets. Entry is self-contained.
+    if ('@builder.io/qwik-city' in d &&
+        (await exists(join(dir, 'server/entry.cloudflare-pages.js')))) {
+        return {
+            framework: 'qwik',
+            workerEntry: 'server/entry.cloudflare-pages.js',
+            assetsDir: 'dist',
+            wrapDefaultFetch: true,
+            assetFirst: true,
+            compatibilityFlags: NODE_COMPAT,
+        };
+    }
+    // React Router v7 (framework mode) — @cloudflare/vite-plugin output. MUST run
+    // before detectWrangler: the input wrangler.json `main` points at the SOURCE
+    // worker (workers/app.ts importing `virtual:react-router/server-build`), which
+    // is NOT esbuild-bundleable; the deployable entry is the built build/server/index.js.
+    const reactRouter = await detectReactRouter(dir, d);
+    if (reactRouter)
+        return reactRouter;
+    // Next.js — @opennextjs/cloudflare (OpenNext). Build emits `.open-next/worker.js`
+    // (default-export `{ fetch }`) + `.open-next/assets/`. MUST run before
+    // detectWrangler (OpenNext also ships a wrangler.jsonc with `main` set). Requires
+    // the bundle.ts builtinModules externals (OpenNext imports node builtins by bare
+    // name). Build with `assets.run_worker_first: true` so the worker self-serves
+    // assets via env.ASSETS (shiply's service-binding model). ISR (R2/D1/DO) deferred.
+    if ('@opennextjs/cloudflare' in d && (await exists(join(dir, '.open-next/worker.js')))) {
+        return {
+            framework: 'next',
+            workerEntry: '.open-next/worker.js',
+            assetsDir: '.open-next/assets',
+            // OpenNext's worker uses dynamic require('node:*') → must be wrangler-bundled
+            // (esbuild shims it). The wrangler path applies asset-first in its own entry.
+            bundleWith: 'wrangler',
+            compatibilityFlags: ['nodejs_compat', 'global_fetch_strictly_public'],
+            // OpenNext imports `node:http`, which `nodejs_compat` only provides at a
+            // compat date >= ~2025-09 (verified: 2025-03-25 fails "No such module
+            // node:http", 2025-09-01 succeeds). OpenNext's own config bakes an older
+            // date that passes `wrangler --dry-run` (which doesn't validate runtime
+            // modules) but fails the real Workers upload — so we override it here.
+            compatibilityDate: '2025-09-01',
+        };
+    }
     // Generic Cloudflare Worker via a wrangler config (Hono, itty, raw fetch).
     return detectWrangler(dir);
 }
+/** React Router v7 framework mode (@react-router/dev + @cloudflare/vite-plugin).
+ *  Anchors on the BUILT artifacts — `build/server/index.js` (the Vite virtual
+ *  resolved) + `build/client` assets — never the un-bundleable source worker. */
+async function detectReactRouter(dir, d) {
+    if (!('@react-router/dev' in d) || !('@cloudflare/vite-plugin' in d))
+        return null;
+    if (!(await exists(join(dir, 'build/server/index.js'))))
+        return null;
+    if (!(await exists(join(dir, 'build/server/wrangler.json'))))
+        return null;
+    if (!(await exists(join(dir, 'build/client'))))
+        return null;
+    // Pull compat date from the build snapshot; fall back to a known-good modern
+    // date (>= the 2024-09-23 modern-nodejs_compat cutoff). The snapshot's
+    // assets.directory is an OS-specific '..\\client' string — never use it;
+    // hardcode build/client relative to the project dir.
+    let compatibilityDate = '2025-10-08';
+    try {
+        const wj = JSON.parse(await readFile(join(dir, 'build/server/wrangler.json'), 'utf8'));
+        if (typeof wj.compatibility_date === 'string')
+            compatibilityDate = wj.compatibility_date;
+    }
+    catch {
+        /* keep default */
+    }
+    return {
+        framework: 'react-router',
+        workerEntry: 'build/server/index.js',
+        assetsDir: 'build/client',
+        assetFirst: true,
+        compatibilityDate,
+        compatibilityFlags: NODE_COMPAT,
+    };
+}
 async function detectNitro(dir) {
     const nitroJson = join(dir, '.output', 'nitro.json');
     if (!(await exists(nitroJson)))
@@ -63,6 +142,7 @@ async function detectNitro(dir) {
         framework: 'nitro',
         workerEntry: '.output/server/index.mjs',
         assetsDir: '.output/public',
+        assetFirst: true,
         compatibilityFlags: NODE_COMPAT,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shiply-cli",
-  "version": "0.18.2",
+  "version": "0.19.0",
   "description": "Publish static sites to shiply.now from the command line — instant web hosting for agents.",
   "license": "MIT",
   "type": "module",