shiply-cli 0.18.1 → 0.18.3

package/dist/bundle.js

@@ -1,6 +1,6 @@
 import { cp, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
-import { join } 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
@@ -8,10 +8,12 @@ const BUNDLE_COMPAT_DATE = '2025-05-05';
  *  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],
+/** esbuild-bundle a worker entry into one self-contained ESM module.
+ *  When `wrapDefaultFetch` is set, the entry exports a NAMED `fetch` (Qwik's
+ *  Pages adapter); we bundle a synthetic entry that re-exports it as the Workers
+ *  `export default { fetch }` shape. */
+async function bundleWorker(entryAbs, wrapDefaultFetch = false) {
+    const common = {
         bundle: true,
         format: 'esm',
         platform: 'neutral',
@@ -19,7 +21,17 @@ async function bundleWorker(entryAbs) {
         external: WORKER_EXTERNALS,
         write: false,
         logLevel: 'silent',
-    });
+    };
+    const result = wrapDefaultFetch
+        ? await build({
+            ...common,
+            stdin: {
+                contents: `import { fetch } from ${JSON.stringify(entryAbs.split('\\').join('/'))}\nexport default { fetch }\n`,
+                resolveDir: dirname(entryAbs),
+                loader: 'js',
+            },
+        })
+        : await build({ ...common, entryPoints: [entryAbs] });
     return result.outputFiles[0].text;
 }
 /** Stage a temp publish dir: a single bundled worker under `.shiply/bundle/`,
@@ -34,22 +46,19 @@ 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.tier0) {
-        // Tier 0: bundle the wrangler `main` entry; optional static assets dir.
-        await writeFile(join(bundleDir, 'index.js'), await bundleWorker(join(ssr.assetsDir, ssr.workerMain)));
-        if (ssr.staticDir) {
-            await cp(join(sourceDir, ssr.staticDir), out, { recursive: true });
+    // Bundle the worker entry into one self-contained ESM module.
+    await writeFile(join(bundleDir, 'index.js'), await bundleWorker(join(sourceDir, ssr.workerEntry), ssr.wrapDefaultFetch));
+    // 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.
+    if (ssr.assetsDir) {
+        const assetsAbs = join(sourceDir, ssr.assetsDir);
+        await cp(assetsAbs, out, { recursive: true });
+        const entryRel = relative(assetsAbs, join(sourceDir, ssr.workerEntry));
+        if (entryRel && !entryRel.startsWith('..') && !isAbsolute(entryRel)) {
+            await rm(join(out, entryRel.split(/[\\/]/)[0]), { recursive: true, force: true });
         }
     }
-    else {
-        // Tier 1: bundle the adapter's worker entry into one module, then copy the
-        // rest of the output dir as static assets (minus the now-bundled entry).
-        await writeFile(join(bundleDir, 'index.js'), await bundleWorker(join(ssr.assetsDir, ssr.entry)));
-        await cp(ssr.assetsDir, out, { recursive: true });
-        // Drop the original worker entry (file, or Astro's `_worker.js/` dir) so it
-        // isn't double-served as a static asset.
-        await rm(join(out, ssr.entry.split('/')[0]), { recursive: true, force: true });
-    }
     await writeManifest(out, {
         framework: ssr.framework,
         entry: 'index.js',

package/dist/ssr-adapters.js

@@ -1,5 +1,5 @@
-import { readFile, readdir, stat } from 'node:fs/promises';
-import { join, relative } from 'node:path';
+import { readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
 import { parse as parseToml } from 'smol-toml';
 const NODE_COMPAT = ['nodejs_compat'];
 const exists = (p) => stat(p).then(() => true, () => false);
@@ -12,55 +12,72 @@ async function deps(dir) {
         return {};
     }
 }
-/** Recursively list every file under `root`, as posix paths relative to `base`. */
-async function listFiles(root, base = root) {
-    const out = [];
-    for (const e of await readdir(root, { withFileTypes: true })) {
-        const abs = join(root, e.name);
-        if (e.isDirectory())
-            out.push(...(await listFiles(abs, base)));
-        else
-            out.push(relative(base, abs).split('\\').join('/'));
-    }
-    return out;
-}
-/** Detect a built SSR project (Cloudflare-adapter output or a wrangler worker)
- *  in `dir`. Returns null for plain static dirs. */
+/** Detect a built SSR project in `dir` (framework adapter output or a wrangler
+ *  worker). Returns null for plain static dirs. Framework-specific detectors
+ *  run before the generic wrangler one. */
 export async function detectSsr(dir) {
     const d = await deps(dir);
-    // Tier 1: SvelteKit (single _worker.js + sibling assets)
-    if ('@sveltejs/adapter-cloudflare' in d) {
-        const out = join(dir, '.svelte-kit', 'cloudflare');
-        if (await exists(join(out, '_worker.js'))) {
-            return {
-                framework: 'sveltekit',
-                assetsDir: out,
-                entry: '_worker.js',
-                modules: ['_worker.js'],
-                compatibilityFlags: NODE_COMPAT,
-            };
-        }
+    // SvelteKit — adapter-cloudflare: `_worker.js` + sibling assets.
+    if ('@sveltejs/adapter-cloudflare' in d && (await exists(join(dir, '.svelte-kit/cloudflare/_worker.js')))) {
+        return {
+            framework: 'sveltekit',
+            workerEntry: '.svelte-kit/cloudflare/_worker.js',
+            assetsDir: '.svelte-kit/cloudflare',
+            compatibilityFlags: NODE_COMPAT,
+        };
     }
-    // Tier 1: Astro (dist/_worker.js/ multi-module + dist assets)
-    if ('@astrojs/cloudflare' in d) {
-        const out = join(dir, 'dist');
-        const workerDir = join(out, '_worker.js');
-        if (await exists(join(workerDir, 'index.js'))) {
-            const modules = (await listFiles(workerDir))
-                .filter((p) => p.endsWith('.js'))
-                .map((p) => `_worker.js/${p}`);
-            return {
-                framework: 'astro',
-                assetsDir: out,
-                entry: '_worker.js/index.js',
-                modules,
-                compatibilityFlags: NODE_COMPAT,
-            };
-        }
+    // Astro — @astrojs/cloudflare: `dist/_worker.js/index.js` + dist assets.
+    if ('@astrojs/cloudflare' in d && (await exists(join(dir, 'dist/_worker.js/index.js')))) {
+        return {
+            framework: 'astro',
+            workerEntry: 'dist/_worker.js/index.js',
+            assetsDir: 'dist',
+            compatibilityFlags: NODE_COMPAT,
+        };
     }
-    // Tier 0: generic Cloudflare Worker via wrangler config
+    // Nitro (Nuxt, SolidStart, Analog, TanStack, …) — cloudflare preset:
+    // `.output/server/index.mjs` worker + `.output/public/` assets (separate 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,
+            compatibilityFlags: NODE_COMPAT,
+        };
+    }
+    // Generic Cloudflare Worker via a wrangler config (Hono, itty, raw fetch).
     return detectWrangler(dir);
 }
+async function detectNitro(dir) {
+    const nitroJson = join(dir, '.output', 'nitro.json');
+    if (!(await exists(nitroJson)))
+        return null;
+    let preset = '';
+    try {
+        preset = String(JSON.parse(await readFile(nitroJson, 'utf8')).preset ?? '');
+    }
+    catch {
+        return null;
+    }
+    // 'cloudflare-module' / 'cloudflare_module' / 'cloudflare-pages' all start with it.
+    if (!preset.startsWith('cloudflare'))
+        return null;
+    if (!(await exists(join(dir, '.output/server/index.mjs'))))
+        return null;
+    return {
+        framework: 'nitro',
+        workerEntry: '.output/server/index.mjs',
+        assetsDir: '.output/public',
+        compatibilityFlags: NODE_COMPAT,
+    };
+}
 async function detectWrangler(dir) {
     let cfg = null;
     if (await exists(join(dir, 'wrangler.toml'))) {
@@ -79,10 +96,8 @@ async function detectWrangler(dir) {
     const staticDir = cfg.assets?.directory ?? cfg.site?.bucket;
     return {
         framework: 'cloudflare-worker',
-        assetsDir: dir,
-        tier0: true,
-        workerMain: cfg.main,
-        staticDir: typeof staticDir === 'string' ? staticDir : undefined,
+        workerEntry: cfg.main,
+        assetsDir: typeof staticDir === 'string' ? staticDir : undefined,
         compatibilityDate: typeof cfg.compatibility_date === 'string' ? cfg.compatibility_date : undefined,
         compatibilityFlags: Array.isArray(cfg.compatibility_flags) && cfg.compatibility_flags.length
             ? cfg.compatibility_flags

package/package.json

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