shiply-cli 0.17.0 → 0.18.1

package/dist/bundle.js

@@ -0,0 +1,64 @@
+import { cp, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } 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],
+        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: 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 });
+        }
+    }
+    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',
+        modules: ['index.js'],
+        compatibilityDate: ssr.compatibilityDate ?? BUNDLE_COMPAT_DATE,
+        compatibilityFlags: ssr.compatibilityFlags,
+    });
+    return out;
+}
+async function writeManifest(out, m) {
+    await writeFile(join(out, '.shiply', 'bundle.json'), JSON.stringify({ v: 1, ...m }, null, 2));
+}

package/dist/index.js

@@ -4,9 +4,12 @@ import { dirname, join } from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import { fileURLToPath } from 'node:url';
 import { parseArgs } from 'node:util';
+import { rm } from 'node:fs/promises';
 import { confetti, shouldCelebrate } from './confetti.js';
 import { runDetect } from './detect.js';
 import { resolvePayloadDir } from './framework.js';
+import { detectSsr } from './ssr-adapters.js';
+import { prepareBundle } from './bundle.js';
 import { runClaimVerify } from './claim.js';
 import { dbAttach, dbBranch, dbBranches, dbCreate, dbDelete, dbDeleteBranch, dbLs, dbMerge, dbMigrate, dbSql, } from './db.js';
 import { driveGet, driveLs, drivePublish, drivePut, driveRm } from './drive.js';
@@ -207,6 +210,7 @@ async function main() {
         allowPositionals: true,
         options: {
             spa: { type: 'boolean' },
+            'no-ssr': { type: 'boolean' },
             framework: { type: 'string' },
             'claim-token': { type: 'string' },
             key: { type: 'string' },
@@ -267,108 +271,133 @@ async function main() {
             if (!dir)
                 throw new Error(`usage: shiply ${cmd} <dir>`);
             const apiKey = values.anonymous ? undefined : (values.key ?? (await loadApiKey()));
-            // Any static site works — React/Vue/Astro/Hugo/Jekyll/etc — but you
-            // publish the BUILD OUTPUT, not the source. resolvePayloadDir picks the
-            // right dir (source as-is, a matched framework's build output, or a
-            // pre-built fallback like dist/).
-            const { dir: publishDir, hint } = await resolvePayloadDir(dir, { framework: values.framework });
-            const spa = values.spa ?? (hint?.spa ? true : undefined);
-            if (hint && publishDir !== dir && !bareJsonFlag) {
-                console.log(`✔ ${hint.framework} project detected — publishing ${publishDir}${hint.spa ? ' with SPA mode' : ''}`);
+            // SSR / worker-bundle lane: a built Cloudflare-adapter project (SvelteKit,
+            // Astro) or a wrangler worker (Hono/raw fetch) ships as a worker bundle.
+            // Skipped when --no-ssr or --framework (static override) is passed.
+            const ssr = values['no-ssr'] || values.framework ? null : await detectSsr(dir);
+            let stagingDir = null;
+            // Any static site works — publish the BUILD OUTPUT, not the source.
+            // resolvePayloadDir picks the right dir (source as-is, a matched
+            // framework's build output, or a pre-built fallback like dist/).
+            let publishDir;
+            let spa;
+            let stateDir;
+            if (ssr) {
+                stagingDir = await prepareBundle(dir, ssr);
+                publishDir = stagingDir;
+                spa = false; // SSR: an asset miss must 404 so the worker handles the route
+                stateDir = dir; // persist .shiply.json in the SOURCE dir, not the temp dir
+                if (!bareJsonFlag)
+                    console.log(`✔ ${ssr.framework} (SSR) detected — deploying worker bundle`);
             }
-            // same command, same URL: reuse this directory's site automatically
-            const state = await readState(publishDir);
-            // --as <name>: a stable named preview. The alias registry remembers which
-            // slug this name last published to, so the URL is reused every iteration —
-            // independent of which directory the bytes came from.
-            const aliasName = values.as;
-            const alias = aliasName ? await readPreview(aliasName) : null;
-            let claimToken = values['claim-token'] ?? alias?.claimToken ?? state?.claimToken;
-            let slug = (alias?.owned && apiKey ? alias.slug : undefined) ?? (state?.owned && apiKey ? state.slug : undefined);
-            if (values['new-site']) {
-                claimToken = values['claim-token'];
-                slug = undefined;
-            }
-            if (cmd === 'update' && !claimToken && !slug) {
-                throw new Error('nothing to update here — publish first (shiply remembers the site in .shiply.json), or pass --claim-token');
+            else {
+                const resolved = await resolvePayloadDir(dir, { framework: values.framework });
+                publishDir = resolved.dir;
+                spa = values.spa ?? (resolved.hint?.spa ? true : undefined);
+                stateDir = publishDir;
+                if (resolved.hint && publishDir !== dir && !bareJsonFlag) {
+                    console.log(`✔ ${resolved.hint.framework} project detected — publishing ${publishDir}${resolved.hint.spa ? ' with SPA mode' : ''}`);
+                }
             }
-            const updating = Boolean(claimToken || slug);
-            // Auto-attach a previously-created database on publish. Anonymous
-            // publishes can't attach (no auth subject) — silently skipped server-side.
-            const attachDatabaseId = state?.databaseId && apiKey ? state.databaseId : undefined;
-            // Opt-in: bind THIS publish version to a Neon branch's URI. Server
-            // validates ownership + that the branch lives under a project attached
-            // to this site; a bogus/foreign id silently falls back to the parent URI.
-            const previewBranchDbId = values['preview-branch'];
-            const res = await publish(publishDir, {
-                apiKey,
-                base: values.base,
-                spaMode: spa,
-                claimToken,
-                slug,
-                attachDatabaseId,
-                previewBranchDbId,
-            });
-            await writeState(publishDir, {
-                slug: res.slug,
-                siteUrl: res.siteUrl,
-                // siteId only present on 0.14.4+ servers — prefer the new response,
-                // fall back to a prior state file so re-publishes don't drop it.
-                ...(res.siteId ? { siteId: res.siteId } : state?.siteId ? { siteId: state.siteId } : {}),
-                ...(res.claimToken ? { claimToken: res.claimToken } : state?.claimToken && updating ? { claimToken: state.claimToken } : {}),
-                owned: !res.anonymous,
-                ...(state?.databaseId ? { databaseId: state.databaseId } : {}),
-            });
-            if (aliasName) {
-                await writePreview(aliasName, {
-                    slug: res.slug,
-                    owned: !res.anonymous,
-                    ...(res.siteId ? { siteId: res.siteId } : {}),
-                    ...(res.claimToken ? { claimToken: res.claimToken } : alias?.claimToken ? { claimToken: alias.claimToken } : {}),
+            try {
+                // same command, same URL: reuse this directory's site automatically
+                const state = await readState(stateDir);
+                // --as <name>: a stable named preview. The alias registry remembers which
+                // slug this name last published to, so the URL is reused every iteration —
+                // independent of which directory the bytes came from.
+                const aliasName = values.as;
+                const alias = aliasName ? await readPreview(aliasName) : null;
+                let claimToken = values['claim-token'] ?? alias?.claimToken ?? state?.claimToken;
+                let slug = (alias?.owned && apiKey ? alias.slug : undefined) ?? (state?.owned && apiKey ? state.slug : undefined);
+                if (values['new-site']) {
+                    claimToken = values['claim-token'];
+                    slug = undefined;
+                }
+                if (cmd === 'update' && !claimToken && !slug) {
+                    throw new Error('nothing to update here — publish first (shiply remembers the site in .shiply.json), or pass --claim-token');
+                }
+                const updating = Boolean(claimToken || slug);
+                // Auto-attach a previously-created database on publish. Anonymous
+                // publishes can't attach (no auth subject) — silently skipped server-side.
+                const attachDatabaseId = state?.databaseId && apiKey ? state.databaseId : undefined;
+                // Opt-in: bind THIS publish version to a Neon branch's URI. Server
+                // validates ownership + that the branch lives under a project attached
+                // to this site; a bogus/foreign id silently falls back to the parent URI.
+                const previewBranchDbId = values['preview-branch'];
+                const res = await publish(publishDir, {
+                    apiKey,
+                    base: values.base,
+                    spaMode: spa,
+                    claimToken,
+                    slug,
+                    attachDatabaseId,
+                    previewBranchDbId,
                 });
-            }
-            if (bareJsonFlag) {
-                // Single-line machine output — no banners, no confetti, no readiness chatter.
-                process.stdout.write(`${JSON.stringify({
+                await writeState(stateDir, {
                     slug: res.slug,
                     siteUrl: res.siteUrl,
-                    siteId: res.siteId ?? null,
-                    uploaded: res.uploaded,
-                    skipped: res.skipped,
-                    anonymous: res.anonymous,
-                    expiresAt: res.expiresAt,
-                    updated: updating,
-                })}\n`);
-                return;
-            }
-            const skipped = res.skipped > 0 ? ` (${res.skipped} unchanged, skipped)` : '';
-            console.log(`✔ ${updating ? `updated ${res.slug} in place` : 'published'} — ${res.uploaded} file${res.uploaded === 1 ? '' : 's'}${skipped}`);
-            console.log(`\n  ${res.siteUrl}\n`);
-            // confirm the site actually serves, then celebrate
-            try {
-                const host = new URL(res.siteUrl).hostname;
-                const live = await fetch(res.siteUrl, { method: 'GET', redirect: 'follow' });
-                void live.body?.cancel();
-                if (live.status < 400) {
-                    console.log(`SITE_READY url=${res.siteUrl} status=${live.status}`);
-                    if (shouldCelebrate(Boolean(values['no-confetti'])))
-                        console.log(confetti(`⛵  ${host} IS LIVE  ⛵`));
+                    // siteId only present on 0.14.4+ servers — prefer the new response,
+                    // fall back to a prior state file so re-publishes don't drop it.
+                    ...(res.siteId ? { siteId: res.siteId } : state?.siteId ? { siteId: state.siteId } : {}),
+                    ...(res.claimToken ? { claimToken: res.claimToken } : state?.claimToken && updating ? { claimToken: state.claimToken } : {}),
+                    owned: !res.anonymous,
+                    ...(state?.databaseId ? { databaseId: state.databaseId } : {}),
+                });
+                if (aliasName) {
+                    await writePreview(aliasName, {
+                        slug: res.slug,
+                        owned: !res.anonymous,
+                        ...(res.siteId ? { siteId: res.siteId } : {}),
+                        ...(res.claimToken ? { claimToken: res.claimToken } : alias?.claimToken ? { claimToken: alias.claimToken } : {}),
+                    });
                 }
+                if (bareJsonFlag) {
+                    // Single-line machine output — no banners, no confetti, no readiness chatter.
+                    process.stdout.write(`${JSON.stringify({
+                        slug: res.slug,
+                        siteUrl: res.siteUrl,
+                        siteId: res.siteId ?? null,
+                        uploaded: res.uploaded,
+                        skipped: res.skipped,
+                        anonymous: res.anonymous,
+                        expiresAt: res.expiresAt,
+                        updated: updating,
+                    })}\n`);
+                    return;
+                }
+                const skipped = res.skipped > 0 ? ` (${res.skipped} unchanged, skipped)` : '';
+                console.log(`✔ ${updating ? `updated ${res.slug} in place` : 'published'} — ${res.uploaded} file${res.uploaded === 1 ? '' : 's'}${skipped}`);
+                console.log(`\n  ${res.siteUrl}\n`);
+                // confirm the site actually serves, then celebrate
+                try {
+                    const host = new URL(res.siteUrl).hostname;
+                    const live = await fetch(res.siteUrl, { method: 'GET', redirect: 'follow' });
+                    void live.body?.cancel();
+                    if (live.status < 400) {
+                        console.log(`SITE_READY url=${res.siteUrl} status=${live.status}`);
+                        if (shouldCelebrate(Boolean(values['no-confetti'])))
+                            console.log(confetti(`⛵  ${host} IS LIVE  ⛵`));
+                    }
+                }
+                catch {
+                    /* serving check is best-effort */
+                }
+                if (!updating) {
+                    console.log(`  saved .shiply.json — run \`shiply publish ${dir}\` again to UPDATE this same site`);
+                    console.log(`  (gitignore .shiply.json if this folder is public — it can update the site)`);
+                }
+                if (res.anonymous) {
+                    console.log(`  anonymous site — expires ${res.expiresAt ?? 'in 24h'}`);
+                    if (res.claimUrl)
+                        console.log(`  claim it to KEEP it (free account): ${res.claimUrl}`);
+                    console.log(`  tip: run \`shiply login\` first to publish permanent sites`);
+                }
+                return;
             }
-            catch {
-                /* serving check is best-effort */
-            }
-            if (!updating) {
-                console.log(`  saved .shiply.json — run \`shiply publish ${dir}\` again to UPDATE this same site`);
-                console.log(`  (gitignore .shiply.json if this folder is public — it can update the site)`);
-            }
-            if (res.anonymous) {
-                console.log(`  anonymous site — expires ${res.expiresAt ?? 'in 24h'}`);
-                if (res.claimUrl)
-                    console.log(`  claim it to KEEP it (free account): ${res.claimUrl}`);
-                console.log(`  tip: run \`shiply login\` first to publish permanent sites`);
+            finally {
+                if (stagingDir)
+                    await rm(stagingDir, { recursive: true, force: true });
             }
-            return;
         }
         case 'status': {
             if (!dir) {

package/dist/ssr-adapters.js

@@ -0,0 +1,95 @@
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { parse as parseToml } from 'smol-toml';
+const NODE_COMPAT = ['nodejs_compat'];
+const exists = (p) => stat(p).then(() => true, () => false);
+async function deps(dir) {
+    try {
+        const pkg = JSON.parse(await readFile(join(dir, 'package.json'), 'utf8'));
+        return { ...pkg.dependencies, ...pkg.devDependencies };
+    }
+    catch {
+        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. */
+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,
+            };
+        }
+    }
+    // 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,
+            };
+        }
+    }
+    // Tier 0: generic Cloudflare Worker via wrangler config
+    return detectWrangler(dir);
+}
+async function detectWrangler(dir) {
+    let cfg = null;
+    if (await exists(join(dir, 'wrangler.toml'))) {
+        cfg = parseToml(await readFile(join(dir, 'wrangler.toml'), 'utf8'));
+    }
+    else {
+        for (const f of ['wrangler.json', 'wrangler.jsonc']) {
+            if (await exists(join(dir, f))) {
+                cfg = JSON.parse(stripJsonc(await readFile(join(dir, f), 'utf8')));
+                break;
+            }
+        }
+    }
+    if (!cfg || typeof cfg.main !== 'string')
+        return null;
+    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,
+        compatibilityDate: typeof cfg.compatibility_date === 'string' ? cfg.compatibility_date : undefined,
+        compatibilityFlags: Array.isArray(cfg.compatibility_flags) && cfg.compatibility_flags.length
+            ? cfg.compatibility_flags
+            : NODE_COMPAT,
+    };
+}
+/** Strip // and block comments so wrangler.jsonc parses with JSON.parse. */
+function stripJsonc(s) {
+    return s.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/.*$/gm, '$1');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shiply-cli",
-  "version": "0.17.0",
+  "version": "0.18.1",
   "description": "Publish static sites to shiply.now from the command line — instant web hosting for agents.",
   "license": "MIT",
   "type": "module",
@@ -31,8 +31,12 @@
   ],
   "homepage": "https://shiply.now",
   "devDependencies": {
+    "@types/node": "^22.15.0",
     "typescript": "^5.8.0",
-    "vitest": "^3.1.0",
-    "@types/node": "^22.15.0"
+    "vitest": "^3.1.0"
+  },
+  "dependencies": {
+    "esbuild": "^0.25.12",
+    "smol-toml": "^1.7.0"
   }
 }

package/skill/SKILL.md

@@ -144,6 +144,16 @@ so repeat publishes reuse the URL automatically. `--new-site` opts out.
 Gitignore `.shiply.json` in public repos. Parse `SITE_READY` / `SSL_READY`
 lines for automation; exit code 0 = ready.
 
+### SSR / server frameworks (live: SvelteKit, Astro, Hono/raw Workers)
+
+`shiply publish` auto-detects a built Cloudflare-adapter project (SvelteKit
+`@sveltejs/adapter-cloudflare`, Astro `@astrojs/cloudflare`) or a wrangler
+worker (`wrangler.toml` with `main` — Hono, itty-router, raw `fetch`) and
+deploys the worker bundle with `nodejs_compat`, serving static assets from the
+edge. **Build first** (`npm run build`), then `shiply publish .`. Requires
+sign-in + Developer plan. Force the static path with `--framework=<name>`, or
+skip SSR detection entirely with `--no-ssr`. Next.js: waitlist (not yet live).
+
 ## Manage & verify sites (CLI)
 
 List, delete, roll back, verify, and promote owned sites — all over the same