shiply-cli 0.18.3 → 0.20.0

package/dist/bundle.js

@@ -1,18 +1,25 @@
-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 { 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.
- *  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) {
+/** 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',
@@ -22,16 +29,24 @@ async function bundleWorker(entryAbs, wrapDefaultFetch = false) {
         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] });
+    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/`,
@@ -42,12 +57,19 @@ async function bundleWorker(entryAbs, wrapDefaultFetch = false) {
  *  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) {
+export async function prepareBundle(sourceDir, ssr, extras = {}) {
     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, extras);
+        return out;
+    }
     // Bundle the worker entry into one self-contained ESM module.
-    await writeFile(join(bundleDir, 'index.js'), await bundleWorker(join(sourceDir, ssr.workerEntry), ssr.wrapDefaultFetch));
+    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.
@@ -65,9 +87,72 @@ export async function prepareBundle(sourceDir, ssr) {
         modules: ['index.js'],
         compatibilityDate: ssr.compatibilityDate ?? BUNDLE_COMPAT_DATE,
         compatibilityFlags: ssr.compatibilityFlags,
+        isr: extras.isr,
     });
     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, extras = {}) {
+    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,
+        isr: extras.isr,
+    });
+    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));
+    // Drop an undefined `isr` so static/non-Next bundles keep a clean manifest.
+    const { isr, ...rest } = m;
+    const doc = isr ? { v: 1, ...rest, isr } : { v: 1, ...rest };
+    await writeFile(join(out, '.shiply', 'bundle.json'), JSON.stringify(doc, null, 2));
 }

package/dist/functions.js

@@ -161,6 +161,62 @@ async function removeFnCmd(argv, inherited) {
     }
     console.log(`✔ removed worker for ${slug} — static-only routing restored`);
 }
+// --- shiply logs ------------------------------------------------------------
+const LOGS_USAGE = [
+    'Usage: shiply logs <slug> [--limit N] [--since MIN] [--json]',
+    '       shiply logs <slug>               # 50 newest events from the last 60 min',
+    '       shiply logs <slug> --since 1440  # last 24h (max 10080 = 7 days)',
+    '       shiply logs <slug> --limit 200 --json',
+].join('\n');
+/** Render one log event as a single tail-style line. Pure → unit-testable. */
+export function formatLogLine(e) {
+    const ts = new Date(e.timestamp).toISOString();
+    const lvl = (e.level || 'info').toUpperCase().padEnd(5);
+    const status = e.statusCode ? ` ${e.statusCode}` : '';
+    const outcome = e.outcome && e.outcome !== 'ok' ? ` !${e.outcome}` : '';
+    const timing = e.wallTimeMs != null ? `  (${e.cpuTimeMs ?? '?'}ms cpu / ${e.wallTimeMs}ms wall)` : '';
+    return `${ts}  ${lvl} ${e.message}${status}${outcome}${timing}`;
+}
+/** Render a logs payload to the lines `shiply logs` prints: oldest→newest
+ *  (tail-style, newest at the bottom) + a footer, or a single empty-window hint.
+ *  The input is newest-first (the API + core both guarantee it), so we reverse.
+ *  Pure → unit-testable without spawning the process. */
+export function formatLogs(logs, scriptName, slug) {
+    if (logs.length === 0) {
+        return [
+            `no logs for ${slug} in the window — the function may not have been hit recently (try --since 1440)`,
+        ];
+    }
+    const lines = [...logs].reverse().map(formatLogLine);
+    lines.push(`\n— ${logs.length} event${logs.length === 1 ? '' : 's'} from ${scriptName}`);
+    return lines;
+}
+/** `shiply logs <slug>` — read recent runtime logs for a site's per-site Worker
+ *  (Cloudflare Workers Observability, 7-day retention). Prints chronological
+ *  (newest at the bottom, tail-style); `--json` dumps the raw payload. */
+export async function runLogs(argv, inherited = {}) {
+    const { rest, flags } = readFlags(argv, inherited);
+    const slug = rest[0];
+    if (!slug) {
+        console.error(LOGS_USAGE);
+        process.exit(1);
+    }
+    const apiKey = await getApiKey(flags, 'logs');
+    const base = resolveBase(flags.base);
+    const qs = new URLSearchParams();
+    if (inherited.limit)
+        qs.set('limit', inherited.limit);
+    if (inherited.since)
+        qs.set('since', inherited.since);
+    const suffix = qs.toString() ? `?${qs.toString()}` : '';
+    const r = await api(`${base}/api/v1/sites/${slug}/logs${suffix}`, { headers: headers(apiKey) });
+    if (flags.json) {
+        console.log(JSON.stringify(r, null, 2));
+        return;
+    }
+    for (const line of formatLogs(r.logs, r.scriptName, slug))
+        console.log(line);
+}
 // --- shiply secret ----------------------------------------------------------
 const SECRET_USAGE = [
     'Usage: shiply secret <set|ls|rm> <slug> [args] [--json]',

package/dist/index.js

@@ -10,6 +10,7 @@ import { runDetect } from './detect.js';
 import { resolvePayloadDir } from './framework.js';
 import { detectSsr } from './ssr-adapters.js';
 import { prepareBundle } from './bundle.js';
+import { detectIsr } from './isr.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';
@@ -18,7 +19,7 @@ import { runProject } from './projects.js';
 import { runListing } from './listings.js';
 import { runSendingDomain } from './sending-domains.js';
 import { contractAmend, contractDraft, contractList, contractPdf, contractRetract, contractSend, contractShow, } from './contract.js';
-import { runCron, runFunction, runSecret } from './functions.js';
+import { runCron, runFunction, runLogs, runSecret } from './functions.js';
 import { runEmail } from './email.js';
 import { runMailbox } from './mailbox.js';
 import { loadApiKey, saveApiKey } from './config.js';
@@ -96,6 +97,9 @@ Usage:
                                               in your worker on next deploy/restart.
   shiply cron <ls|set|rm> <slug>              Manage cron triggers on the deployed worker
                                               shiply cron set <slug> /api/cron/foo "0 9 * * *"
+  shiply logs <slug> [--limit N] [--since MIN]  Read recent runtime logs for the site's worker
+                                              (Cloudflare Workers Observability, 7-day retention).
+                                              Newest at the bottom; --since in minutes; --json for raw.
   shiply contract <list|draft|show|send|pdf|amend|retract>
                                               Customer contracts — full lifecycle CLI (B14).
                                               list <project-id> — parent + amendments table
@@ -197,7 +201,7 @@ async function main() {
     // `--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 BARE_JSON_CMDS = new Set(['status', 'publish', 'update', 'logs']);
     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 (bareJsonFlag) {
@@ -235,6 +239,7 @@ async function main() {
             'no-confetti': { type: 'boolean' },
             json: { type: 'string' },
             limit: { type: 'string' },
+            since: { type: 'string' },
             cursor: { type: 'string' },
             where: { type: 'string' },
             scope: { type: 'string' },
@@ -283,12 +288,22 @@ async function main() {
             let spa;
             let stateDir;
             if (ssr) {
-                stagingDir = await prepareBundle(dir, ssr);
+                // Next ISR demand instrument: measure whether this app asks to
+                // revalidate (no infra is provisioned for it yet — those routes serve as
+                // live SSR). Records the signal in the bundle for the server-side count
+                // and tells the user plainly. Only Next emits a prerender manifest.
+                const isr = ssr.framework === 'next' ? ((await detectIsr(dir)) ?? undefined) : undefined;
+                stagingDir = await prepareBundle(dir, ssr, { isr });
                 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)
+                if (!bareJsonFlag) {
                     console.log(`✔ ${ssr.framework} (SSR) detected — deploying worker bundle`);
+                    if (isr && isr.timeBased > 0) {
+                        console.log(`ℹ Next ISR/revalidate detected on ${isr.timeBased} route(s) (e.g. ${isr.routes[0]}) — ` +
+                            `shiply serves these as live SSR (re-rendered each request) for now; persistent ISR caching is on the roadmap.`);
+                    }
+                }
             }
             else {
                 const resolved = await resolvePayloadDir(dir, { framework: values.framework });
@@ -744,6 +759,18 @@ async function main() {
             });
             break;
         }
+        case 'logs': {
+            // `--json` on `logs` is a BARE flag — stripped from rawArgv before parseArgs
+            // (see BARE_JSON_CMDS), so detect it via bareJsonFlag, not values.json.
+            await runLogs(positionals.slice(1), {
+                base: values.base,
+                key: values.key,
+                json: bareJsonFlag || (typeof values.json === 'string' && values.json.length > 0),
+                limit: values.limit,
+                since: values.since,
+            });
+            break;
+        }
         case 'cron': {
             await runCron(positionals.slice(1), {
                 base: values.base,

package/dist/isr.js

@@ -0,0 +1,50 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const ROUTE_SAMPLE_CAP = 20;
+/** Parse a Next `prerender-manifest.json` and count routes that want time-based
+ *  revalidation. Pure + total: any malformed/empty input yields zero demand so a
+ *  publish can never break on it. On-demand revalidation (revalidateTag/Path) is
+ *  NOT separately detected here — it doesn't live in the prerender manifest. */
+export function scanIsr(prerenderManifestJson) {
+    let doc;
+    try {
+        doc = JSON.parse(prerenderManifestJson);
+    }
+    catch {
+        return { timeBased: 0, routes: [] };
+    }
+    const buckets = [
+        doc?.routes,
+        doc?.dynamicRoutes,
+    ];
+    const hits = new Set();
+    for (const bucket of buckets) {
+        if (!bucket || typeof bucket !== 'object')
+            continue;
+        for (const [route, meta] of Object.entries(bucket)) {
+            const r = meta?.initialRevalidateSeconds;
+            if (typeof r === 'number' && Number.isFinite(r) && r > 0)
+                hits.add(route);
+        }
+    }
+    const routes = [...hits].sort();
+    return { timeBased: routes.length, routes: routes.slice(0, ROUTE_SAMPLE_CAP) };
+}
+/** Read a built Next app's prerender manifest and scan it for ISR demand.
+ *  Returns null when there's no manifest (not a Next build, or build skipped it).
+ *  Never throws. */
+export async function detectIsr(dir) {
+    // `next build` always writes `.next/prerender-manifest.json`; OpenNext keeps
+    // `.next` alongside its `.open-next` output. Check both, source-of-truth first.
+    for (const rel of ['.next/prerender-manifest.json', '.open-next/.next/prerender-manifest.json']) {
+        let text;
+        try {
+            text = await readFile(join(dir, rel), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        return scanIsr(text);
+    }
+    return null;
+}

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,
         };
     }
@@ -49,12 +51,77 @@ export async function detectSsr(dir) {
             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)))
@@ -75,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.3",
+  "version": "0.20.0",
   "description": "Publish static sites to shiply.now from the command line — instant web hosting for agents.",
   "license": "MIT",
   "type": "module",

package/skill/SKILL.md

@@ -557,7 +557,7 @@ secret names (values set via CLI/MCP, never reach the publish payload).
 | `remove_function` | Strip function + secrets + crons; fall back to static |
 | `set_secret` / `list_secrets` / `remove_secret` | Manage CF Worker secrets |
 | `set_cron` / `list_crons` / `remove_cron` | Manage cron triggers |
-| `get_function_logs` | Deep-link to CF dashboard for live tail |
+| `get_function_logs` | Read recent runtime logs (CF Observability, 7-day, newest-first) + a dashboard deep-link |
 
 ### CLI
 
@@ -567,11 +567,12 @@ shiply function deploy <slug>               # alternative: upload worker.js with
 shiply function deploy <slug> --ts          # uploads worker.ts (server-side compile)
 shiply secret set <slug> STRIPE_KEY sk_xxx  # set secret value
 shiply cron set <slug> /api/daily "0 9 * * *"
+shiply logs <slug>                          # recent worker logs (newest-first); --limit N --since MIN --json
 ```
 
 ### REST
 
-`POST/GET/DELETE /api/v1/sites/{slug}/function` · `POST/GET /api/v1/sites/{slug}/secrets` · `DELETE /api/v1/sites/{slug}/secrets/{name}` · `GET/POST/DELETE /api/v1/sites/{slug}/crons`
+`POST/GET/DELETE /api/v1/sites/{slug}/function` · `POST/GET /api/v1/sites/{slug}/secrets` · `DELETE /api/v1/sites/{slug}/secrets/{name}` · `GET/POST/DELETE /api/v1/sites/{slug}/crons` · `GET /api/v1/sites/{slug}/logs?limit&since`
 
 ### Limits + plan