shiply-cli 0.16.0 → 0.18.0

package/dist/bundle.js

@@ -0,0 +1,63 @@
+import { cp, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } 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. */
+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 });
+        }
+        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,
+        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/confetti.js

@@ -26,3 +26,8 @@ export function confetti(message = '⛵  SITE IS LIVE  ⛵') {
     }
     return out;
 }
+/** Celebrate only on an interactive terminal and only when not opted out.
+ *  Piped / redirected stdout (agents, CI, scrapers) never gets ANSI confetti. */
+export function shouldCelebrate(noConfetti, isTty = process.stdout.isTTY) {
+    return !noConfetti && isTty === true;
+}

package/dist/ignore.js

@@ -0,0 +1,65 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+function globBody(glob, anchored) {
+    // Escape regex specials, but keep * and / for glob expansion.
+    let g = glob.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    g = g
+        .replace(/\*\*\//g, '(?:.+/)?') // **/ → any number of leading dirs
+        .replace(/\*\*/g, '.*') // ** → anything, crosses slashes
+        .replace(/\*/g, '[^/]*'); // * → anything but a slash
+    return anchored ? `^${g}` : `(?:^|/)${g}`;
+}
+function parseRule(raw) {
+    let pattern = raw.trim();
+    const negate = pattern.startsWith('!');
+    if (negate)
+        pattern = pattern.slice(1);
+    const dirOnly = pattern.endsWith('/');
+    if (dirOnly)
+        pattern = pattern.slice(0, -1);
+    const anchored = pattern.startsWith('/');
+    if (anchored)
+        pattern = pattern.slice(1);
+    const body = globBody(pattern, anchored);
+    // re: matches the path itself OR anything beneath it.
+    // descendantRe: matches ONLY things strictly beneath the named path. A
+    // dir-only rule uses re for directories (and their subtrees) but descendantRe
+    // for files, so a FILE that merely shares the dir's name is kept.
+    return {
+        re: new RegExp(`${body}(?:/|$)`),
+        descendantRe: new RegExp(`${body}/`),
+        negate,
+        dirOnly,
+    };
+}
+/** Compile .shiplyignore lines (a documented gitignore subset) into a matcher.
+ *  Supported: # comments, blank lines, trailing-slash dir-only rules,
+ *  leading-slash root anchoring, * and ** globs, and ! negation. Last match wins. */
+export function compileIgnore(lines) {
+    const rules = lines
+        .map((l) => l.replace(/\r$/, ''))
+        .filter((l) => l.trim() !== '' && !l.trimStart().startsWith('#'))
+        .map(parseRule);
+    return (relPath, isDir) => {
+        let excluded = false;
+        for (const r of rules) {
+            // A dir-only rule excludes the directory itself (and its subtree) but, for
+            // a plain file, only when that file lives BENEATH the named directory —
+            // never a file that merely shares the directory's name.
+            const re = r.dirOnly && !isDir ? r.descendantRe : r.re;
+            if (re.test(relPath))
+                excluded = !r.negate;
+        }
+        return excluded;
+    };
+}
+/** Load `.shiplyignore` from the publish root; null when absent. */
+export async function loadIgnore(dir) {
+    try {
+        const raw = await readFile(join(dir, '.shiplyignore'), 'utf8');
+        return compileIgnore(raw.split('\n'));
+    }
+    catch {
+        return null;
+    }
+}

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 { confetti } from './confetti.js';
+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';
@@ -23,8 +26,11 @@ import { loginViaDeviceFlow } from './login.js';
 import { api, ApiError, DEFAULT_BASE, publish, resolveBase } from './publish.js';
 import { installSkill } from './skill.js';
 import { readState, writeState } from './state.js';
+import { readPreview, writePreview } from './previews.js';
 import { checkReadiness, targetToHostname } from './status.js';
 import { runStatus } from './status-cmd.js';
+import { sitesLs, sitesPromote, sitesRm, sitesRollback } from './sites.js';
+import { verifySite } from './verify.js';
 // Resolve the package.json beside the compiled dist/ so `shiply --version`
 // can print the running CLI version (works in dev tsc output + npm install).
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -47,10 +53,13 @@ const HELP = `shiply — instant static hosting for agents (https://shiply.now)
 Usage:
   shiply publish <dir> [options]              Publish a directory, print the live URL.
                                               Re-running UPDATES the same site (state in .shiply.json)
+  shiply publish <dir> --as <name>            Stable preview: reuse the same URL across iterations
   shiply update <dir>                         Same as publish when .shiply.json exists
   shiply status <slug-or-domain> [--wait]     SSL + readiness check (agent-friendly output)
                                               (no arg → account/plan status, see below)
   shiply duplicate <slug>                     Server-side copy of an owned site → new URL
+  shiply promote <preview-slug> --to <dest-slug>
+                                              Copy the exact previewed bytes into a production site (no rebuild)
   shiply detect [dir]                         Diagnose: print framework + dir that would upload
                                               (no upload — use --framework=<name> to test an override)
   shiply drive <ls|put|get|rm|publish>        Private cloud storage (drive publish → live site)
@@ -140,11 +149,13 @@ Options:
   --base <url>           API origin (default: ${DEFAULT_BASE})
   --wait                 (status) poll until the site is ready
   --timeout <seconds>    (status --wait) give up after this long (default 300)
+  --json                 (publish/update) print one JSON line {slug,siteUrl,…}, no decoration
   --json <body>          (data insert) JSON object to insert
   --limit <N>            (data query) max records to return (default 50)
   --cursor <iso>         (data query) pagination cursor from previous response
   --where <json>         (data query) client-side filter, e.g. '{"email":"a@b.co"}'
   --yes                  (data wipe-collection) skip the safety prompt
+  --as <name>            (publish) stable named preview — same URL every iteration
   --no-confetti          Celebrate quietly
 
 \`shiply status\` prints stable machine-readable markers for agents:
@@ -173,7 +184,7 @@ async function reportReadiness(host, celebrate) {
     else {
         console.log(`✖ site: not ready${r.http.status ? ` (HTTP ${r.http.status})` : r.http.error ? ` — ${r.http.error}` : ''}`);
     }
-    if (r.ready && celebrate)
+    if (r.ready && celebrate && shouldCelebrate(false))
         console.log(confetti());
     return r.ready;
 }
@@ -183,17 +194,23 @@ async function main() {
     // Detect the bare flag in raw argv BEFORE parseArgs sees it; strip the
     // token so the parser doesn't complain about a missing string value.
     const rawArgv = process.argv.slice(2);
-    const statusJsonFlag = rawArgv[0] === 'status' && rawArgv.includes('--json') &&
+    // `--json` is a STRING option (data-insert body). For commands where it's a
+    // boolean flag (status/publish/update), detect a BARE --json (no following
+    // value) in raw argv and strip it before parseArgs sees it.
+    const BARE_JSON_CMDS = new Set(['status', 'publish', 'update']);
+    const bareJsonFlag = BARE_JSON_CMDS.has(rawArgv[0]) && rawArgv.includes('--json') &&
         !rawArgv.some((a, i) => a === '--json' && typeof rawArgv[i + 1] === 'string' && !rawArgv[i + 1].startsWith('-'));
-    if (statusJsonFlag) {
+    if (bareJsonFlag) {
         const idx = rawArgv.indexOf('--json');
         rawArgv.splice(idx, 1);
     }
+    const statusJsonFlag = bareJsonFlag && rawArgv[0] === 'status';
     const { values, positionals } = parseArgs({
         args: rawArgv,
         allowPositionals: true,
         options: {
             spa: { type: 'boolean' },
+            'no-ssr': { type: 'boolean' },
             framework: { type: 'string' },
             'claim-token': { type: 'string' },
             key: { type: 'string' },
@@ -201,6 +218,7 @@ async function main() {
             base: { type: 'string' },
             email: { type: 'string' },
             name: { type: 'string' },
+            as: { type: 'string' },
             wait: { type: 'boolean' },
             'new-site': { type: 'boolean' },
             project: { type: 'boolean' },
@@ -253,81 +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) {
-                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);
-            let claimToken = values['claim-token'] ?? state?.claimToken;
-            let slug = 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 } : {}),
-            });
-            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 (!values['no-confetti'])
-                        console.log(confetti(`⛵  ${host} IS LIVE  ⛵`));
+                // 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,
+                });
+                await writeState(stateDir, {
+                    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 } : {}),
+                    });
+                }
+                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) {
@@ -378,6 +448,50 @@ async function main() {
             console.log(`\n  ${out.siteUrl}\n`);
             return;
         }
+        case 'ls': {
+            const apiKey = values.key ?? (await loadApiKey());
+            if (!apiKey)
+                throw new Error('ls needs an API key — run `shiply login` first');
+            await sitesLs({ base: values.base, apiKey });
+            return;
+        }
+        case 'rm': {
+            if (!dir)
+                throw new Error('usage: shiply rm <slug> --yes');
+            const apiKey = values.key ?? (await loadApiKey());
+            if (!apiKey)
+                throw new Error('rm needs an API key — run `shiply login` first');
+            await sitesRm({ base: values.base, apiKey }, dir, { yes: Boolean(values.yes) });
+            return;
+        }
+        case 'rollback': {
+            if (!dir)
+                throw new Error('usage: shiply rollback <slug> [versionId]  (omit versionId to list versions)');
+            const apiKey = values.key ?? (await loadApiKey());
+            if (!apiKey)
+                throw new Error('rollback needs an API key — run `shiply login` first');
+            await sitesRollback({ base: values.base, apiKey }, dir, positionals[2]);
+            return;
+        }
+        case 'verify': {
+            if (!dir)
+                throw new Error('usage: shiply verify <slug>');
+            // exit 0 when LIVE, 1 when PENDING — same contract as `status`, so an agent
+            // can chain `shiply verify <slug> && <next step>` safely.
+            const ready = await verifySite({ base: values.base }, dir);
+            process.exitCode = ready ? 0 : 1;
+            return;
+        }
+        case 'promote': {
+            const dest = values.to;
+            if (!dir || !dest)
+                throw new Error('usage: shiply promote <preview-slug> --to <dest-slug>');
+            const apiKey = values.key ?? (await loadApiKey());
+            if (!apiKey)
+                throw new Error('promote needs an API key — run `shiply login` first');
+            await sitesPromote({ base: values.base, apiKey }, dir, dest);
+            return;
+        }
         case 'detect': {
             await runDetect(dir ?? '.', { framework: values.framework });
             return;

package/dist/manifest.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { readdir, readFile } from 'node:fs/promises';
 import { extname, join } from 'node:path';
+import { loadIgnore } from './ignore.js';
 const MIME = {
     '.html': 'text/html',
     '.htm': 'text/html',
@@ -40,22 +41,30 @@ const SKIP_DIRS = new Set(['node_modules']);
  *  config directory (proxy.json, data.json), which the server consumes. */
 export async function buildManifest(dir) {
     const out = [];
-    await walk(dir, '', out);
+    const ignore = await loadIgnore(dir);
+    await walk(dir, '', out, ignore);
     return out.sort((a, b) => a.path.localeCompare(b.path));
 }
-async function walk(abs, rel, out) {
+async function walk(abs, rel, out, ignore) {
     const entries = await readdir(abs, { withFileTypes: true });
     for (const e of entries) {
         if (e.name === '.shiply' && e.isDirectory() && rel === '') {
-            await walk(join(abs, e.name), '.shiply', out);
+            // The .shiply/ config dir (proxy.json, data.json) is fully exempt from
+            // .shiplyignore — the server needs it, and a broad user rule like
+            // `*.json` must not be able to silently drop the site's own config.
+            // Pass a null matcher so nothing under .shiply/ is ignore-filtered.
+            await walk(join(abs, e.name), '.shiply', out, null);
             continue;
         }
         if (e.name.startsWith('.') || SKIP_DIRS.has(e.name))
             continue;
         const childAbs = join(abs, e.name);
         const childRel = rel ? `${rel}/${e.name}` : e.name;
+        // .shiplyignore: skip matched paths (and whole subtrees for dir matches).
+        if (ignore?.(childRel, e.isDirectory()))
+            continue;
         if (e.isDirectory()) {
-            await walk(childAbs, childRel, out);
+            await walk(childAbs, childRel, out, ignore);
         }
         else if (e.isFile()) {
             const buf = await readFile(childAbs);

package/dist/previews.js

@@ -0,0 +1,26 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+const registryPath = (home) => join(home, '.shiply', 'previews.json');
+async function readAll(home) {
+    try {
+        return JSON.parse(await readFile(registryPath(home), 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** Look up the slug/credentials previously bound to a `--as <name>` alias. */
+export async function readPreview(name, home = homedir()) {
+    const all = await readAll(home);
+    return all[name] ?? null;
+}
+/** Remember the slug a `--as <name>` alias published to, so the next publish
+ *  with the same name UPDATES the same URL (stable preview). */
+export async function writePreview(name, entry, home = homedir()) {
+    const all = await readAll(home);
+    all[name] = entry;
+    const path = registryPath(home);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(all, null, 2)}\n`);
+}

package/dist/sites.js

@@ -0,0 +1,70 @@
+import { api, resolveBase } from './publish.js';
+const headers = (apiKey) => ({
+    'content-type': 'application/json',
+    authorization: `Bearer ${apiKey}`,
+});
+export async function sitesLs(ctx) {
+    const base = resolveBase(ctx.base);
+    const { sites } = await api(`${base}/api/v1/publishes`, {
+        headers: headers(ctx.apiKey),
+    });
+    if (sites.length === 0) {
+        console.log('  no sites yet — run `shiply publish <dir>` to create one');
+        return;
+    }
+    for (const s of sites) {
+        const title = s.title ? `  ${s.title}` : '';
+        console.log(`  ${s.slug}  [${s.status}]  https://${s.slug}.shiply.now${title}`);
+    }
+}
+export async function sitesRm(ctx, slug, opts) {
+    if (!opts.yes) {
+        console.error(`  refusing — \`shiply rm\` PERMANENTLY deletes ${slug} and its files. Re-run with --yes to confirm.`);
+        return;
+    }
+    const base = resolveBase(ctx.base);
+    await api(`${base}/api/v1/publish/${slug}`, {
+        method: 'DELETE',
+        headers: headers(ctx.apiKey),
+    });
+    console.log(`✔ deleted ${slug}`);
+}
+export async function sitesRollback(ctx, slug, versionId) {
+    const base = resolveBase(ctx.base);
+    // No versionId → print the version history so the agent can pick one.
+    if (!versionId) {
+        const detail = await api(`${base}/api/v1/publish/${slug}`, { headers: headers(ctx.apiKey) });
+        const finalized = detail.versions.filter((v) => v.status === 'finalized');
+        if (finalized.length === 0) {
+            console.log('  no finalized versions to roll back to');
+            return;
+        }
+        console.log(`  versions for ${slug} (newest first):`);
+        for (const v of finalized) {
+            const mark = v.id === detail.currentVersionId ? '  ← current (live)' : '';
+            console.log(`    ${v.id}  ${v.fileCount} files  ${v.finalizedAt ?? ''}${mark}`);
+        }
+        console.log(`\n  roll back with: shiply rollback ${slug} <versionId>`);
+        return;
+    }
+    const res = await api(`${base}/api/v1/publish/${slug}/rollback`, {
+        method: 'POST',
+        headers: headers(ctx.apiKey),
+        body: JSON.stringify({ versionId }),
+    });
+    if (!res.changed) {
+        console.log(`  ${slug} is already serving ${versionId} — nothing to do`);
+        return;
+    }
+    console.log(`✔ rolled ${res.slug} to ${res.currentVersionId} — live now`);
+}
+export async function sitesPromote(ctx, srcSlug, destSlug) {
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/publish/${srcSlug}/promote`, {
+        method: 'POST',
+        headers: headers(ctx.apiKey),
+        body: JSON.stringify({ destSlug }),
+    });
+    console.log(`✔ promoted ${r.sourceSlug} → ${r.slug} (${r.filesCount} files) — live now`);
+    console.log(`\n  https://${r.slug}.shiply.now\n`);
+}

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/dist/verify.js

@@ -0,0 +1,26 @@
+// packages/cli/src/verify.ts
+import { api, resolveBase } from './publish.js';
+/** Edge-check a shiply slug: SSL, HTTP reachability, and a rendered thumbnail.
+ *  Headless agents use this to confirm what they shipped is actually serving.
+ *  Returns true when LIVE, false when PENDING — the caller sets the exit code
+ *  (0 / 1) so `shiply verify <slug> && <next>` only proceeds once it's serving. */
+export async function verifySite(ctx, slug) {
+    if (slug.includes('.')) {
+        throw new Error(`verify takes a shiply slug, not a hostname — for custom domains use \`shiply status ${slug}\``);
+    }
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/sites/${slug}/verify`, {
+        headers: { 'content-type': 'application/json' },
+    });
+    const sslLine = r.ssl.valid
+        ? `valid${r.ssl.issuer ? ` (${r.ssl.issuer}` : ''}${r.ssl.daysLeft !== undefined ? `, ${r.ssl.daysLeft}d left)` : r.ssl.issuer ? ')' : ''}`
+        : `not ready${r.ssl.error ? ` — ${r.ssl.error}` : ''}`;
+    console.log(`${r.status === 'LIVE' ? '✔' : '…'} ${slug}.shiply.now — ${r.status}`);
+    console.log(`  ssl:  ${sslLine}`);
+    console.log(`  http: ${r.http.ok ? `ok (HTTP ${r.http.status})` : `not ready${r.http.status ? ` (HTTP ${r.http.status})` : r.http.error ? ` — ${r.http.error}` : ''}`}`);
+    if (r.thumbnailUrl)
+        console.log(`  shot: ${r.thumbnailUrl}`);
+    // Stable machine marker for agents/scrapers (mirrors SITE_READY in `status`).
+    console.log(`VERIFY status=${r.status} http=${r.http.status ?? 0} ssl=${r.ssl.valid ? 'valid' : 'pending'}${r.thumbnailUrl ? ` thumb=${r.thumbnailUrl}` : ''}`);
+    return r.status === 'LIVE';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shiply-cli",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "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

@@ -18,7 +18,7 @@ description: Publish static sites to the web instantly with shiply.now and manag
 > fresh — your cached copy may be missing features like databases, projects,
 > marketplace, or sending domains.
 >
-> **Last updated: 2026-06-22**
+> **Last updated: 2026-06-23**
 
 ---
 
@@ -144,6 +144,57 @@ 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
+Bearer API key. Great for agents that ship iteratively and need to keep their
+subdomains tidy.
+
+```bash
+shiply ls                                   # list your sites: slug, status, URL
+shiply rm <slug> --yes                      # PERMANENTLY delete a site + its files (--yes required)
+shiply rollback <slug>                      # list finalized versions (current one marked)
+shiply rollback <slug> <versionId>          # re-point the site to that version — live instantly
+shiply verify <slug>                        # edge SSL + HTTP + thumbnail readiness check
+shiply publish <dir> --as <name>            # STABLE preview: same URL every iteration (local alias)
+shiply promote <preview-slug> --to <dest-slug>   # copy the preview's exact live bytes onto a prod site
+shiply publish <dir> --json                 # one machine-readable JSON line, no confetti/banners
+```
+
+- **`shiply verify <slug>`** prints a human report PLUS a stable machine marker
+  line `VERIFY status=LIVE http=200 ssl=valid thumb=…` (or `status=PENDING`).
+  Headless agents should parse that `VERIFY status=…` line — it's the
+  contract, like `SITE_READY` in `status`.
+- **`shiply publish <dir> --as <name>`** gives a stable preview URL that the
+  next publish with the same `--as <name>` reuses — no more changing URLs or
+  orphaned scratch sites across iterations, independent of the source dir.
+- **`shiply promote <preview-slug> --to <dest-slug>`** copies the *exact bytes*
+  you previewed onto an existing owned destination site (keeps its slug,
+  domains, access) — atomic preview→production, no rebuild.
+- **`--json`** on `publish`/`update` emits a single JSON line
+  `{slug,siteUrl,siteId,uploaded,skipped,anonymous,expiresAt,updated}` and
+  suppresses all human output + confetti — use it in scripts/agents.
+- **`.shiplyignore`** in the publish root excludes files from upload
+  (documented gitignore subset: `# comments`, `secret.txt`, `internal/`,
+  `*.log`, `/anchored`, `**` globs, `!negation`). Keep `.env`, notes, and
+  internal files out of the published bytes.
+
+To verify captured signups/form data without the dashboard, the data
+subcommands already exist: `shiply data list <slug>` (collections + counts),
+`shiply data query <slug> <coll> [--limit N] [--where '<json>']`, and
+`shiply data export <slug> <coll> [--out file.ndjson]`. Confetti is
+suppressed automatically on non-TTY stdout; `--no-confetti` forces it off.
+
 ### 3. Raw HTTP (no installs)
 ```
 1. POST https://shiply.now/api/v1/publish