shiply-cli 0.18.0 → 0.18.2

package/dist/bundle.js

@@ -1,58 +1,56 @@
 import { cp, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { isAbsolute, join, relative } from 'node:path';
 import { build } from 'esbuild';
 const BUNDLE_COMPAT_DATE = '2025-05-05';
-/** Stage a temp publish dir: static assets at root, worker modules under
- *  `.shiply/bundle/`, plus `.shiply/bundle.json`. Returns the dir; the caller
- *  removes it after publish. The existing publish pipeline handles the rest. */
+/** 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],
+        bundle: true,
+        format: 'esm',
+        platform: 'neutral',
+        target: 'es2022',
+        external: WORKER_EXTERNALS,
+        write: false,
+        logLevel: 'silent',
+    });
+    return result.outputFiles[0].text;
+}
+/** Stage a temp publish dir: a single bundled worker under `.shiply/bundle/`,
+ *  static assets at the root, plus `.shiply/bundle.json`. Returns the dir; the
+ *  caller removes it after publish. The existing publish pipeline handles the rest.
+ *
+ *  BOTH tiers esbuild-bundle the entry. Adapter output (SvelteKit, Astro) is NOT
+ *  self-contained — `_worker.js` imports server code from sibling dirs
+ *  (`../output/server`, `../cloudflare-tmp`) — so we bundle it exactly as
+ *  `wrangler deploy` would, rather than upload it as-is. */
 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: esbuild-bundle the worker entry into one ESM module.
-        const result = await build({
-            entryPoints: [join(ssr.assetsDir, ssr.workerMain)],
-            bundle: true,
-            format: 'esm',
-            platform: 'neutral',
-            target: 'es2022',
-            write: false,
-            logLevel: 'silent',
-        });
-        await writeFile(join(bundleDir, 'index.js'), result.outputFiles[0].text);
-        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)));
+    // 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 });
         }
-        await writeManifest(out, {
-            framework: ssr.framework,
-            entry: 'index.js',
-            modules: ['index.js'],
-            compatibilityDate: ssr.compatibilityDate ?? BUNDLE_COMPAT_DATE,
-            compatibilityFlags: ssr.compatibilityFlags,
-        });
-        return out;
-    }
-    // Tier 1: copy the whole assets dir, then RELOCATE worker modules into
-    // .shiply/bundle/ so they aren't double-served as static assets.
-    await cp(ssr.assetsDir, out, { recursive: true });
-    for (const m of ssr.modules) {
-        const from = join(out, m);
-        const to = join(bundleDir, m);
-        await mkdir(dirname(to), { recursive: true });
-        await cp(from, to, { recursive: true });
-        await rm(from, { recursive: true, force: true });
-    }
-    // If the entry lived in a worker subdir (Astro's _worker.js/), drop the
-    // original subdir entirely so no leftover files are served as assets.
-    if (ssr.entry.includes('/')) {
-        await rm(join(out, ssr.entry.split('/')[0]), { recursive: true, force: true });
     }
     await writeManifest(out, {
         framework: ssr.framework,
-        entry: ssr.entry,
-        modules: ssr.modules,
+        entry: 'index.js',
+        modules: ['index.js'],
         compatibilityDate: ssr.compatibilityDate ?? BUNDLE_COMPAT_DATE,
         compatibilityFlags: ssr.compatibilityFlags,
     });

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,60 @@ 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;
+    // 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 +84,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.0",
+  "version": "0.18.2",
   "description": "Publish static sites to shiply.now from the command line — instant web hosting for agents.",
   "license": "MIT",
   "type": "module",