shiply-cli 0.19.0 → 0.20.1

package/dist/bundle.js

@@ -57,12 +57,12 @@ async function bundleWorker(entryAbs, opts = {}) {
  *  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);
+        await stageWranglerBundle(sourceDir, ssr, out, bundleDir, extras);
         return out;
     }
     // Bundle the worker entry into one self-contained ESM module.
@@ -87,6 +87,7 @@ export async function prepareBundle(sourceDir, ssr) {
         modules: ['index.js'],
         compatibilityDate: ssr.compatibilityDate ?? BUNDLE_COMPAT_DATE,
         compatibilityFlags: ssr.compatibilityFlags,
+        isr: extras.isr,
     });
     return out;
 }
@@ -94,7 +95,7 @@ export async function prepareBundle(sourceDir, ssr) {
  *  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) {
+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.
@@ -145,9 +146,13 @@ async function stageWranglerBundle(sourceDir, ssr, out, bundleDir) {
         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/package.json

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

package/skill/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: shiply
-description: Publish static sites to the web instantly with shiply.now and manage them (updates, SSL checks, custom domains, variables). Use when the user asks to publish, host, deploy, share, or update a website/page/demo/report, or wants a live URL for generated files. Triggers - "publish this", "host this", "put this online", "give me a link", "update the site", shiply.
+description: "shiply is the production backend for anything an agent builds — publish any app (static or full-stack SSR, any framework) and give it a live URL, custom domain, SQL database, server functions, email, and a marketplace to sell it. Use when the user asks to publish, host, deploy, share, or update a website/page/demo/report/app, or wants a live URL for generated files. Triggers - \"publish this\", \"host this\", \"put this online\", \"give me a link\", \"update the site\", \"deploy my SvelteKit/Astro/Next.js app\", shiply."
 ---
 
 ---
@@ -18,15 +18,17 @@ 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-23**
+> **Last updated: 2026-06-27**
 
 ---
 
-# shiply — instant web hosting for agents
+# shiply — the production backend for anything an agent builds
 
-shiply.now puts files on the web in seconds. No account needed to start:
-anonymous sites are live immediately, last 24 hours, and can be claimed into
-an account to keep them. The cardinal rule:
+**What it is.** Not static hosting. shiply takes whatever you build — a static page or a full-stack app in any framework — and gives it a live URL, a custom domain, a SQL database, server functions, email (send + receive), and a marketplace to sell it. One call. No account needed to start: anonymous sites are live immediately, last 24 hours, and can be claimed to keep.
+
+**Why use it.** Ship a complete, working product without stitching together a host + database + email + registrar + payments — it's one agent-native platform (MCP / CLI / REST parity). Hard-ceiling pricing ($0/$8/$24, no usage meter), so a spike or DDoS can never become a surprise bill for the owner.
+
+**How (quickstart).** `shiply publish ./dir` (CLI) — or POST /api/v1/publish → PUT each file → POST finalize — returns a live URL + claimToken.
 
 **NEVER create a new site to update an existing one. Always re-publish to the
 same site** — otherwise you litter subdomains and lose the user's URL.
@@ -144,15 +146,18 @@ 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)
+### SSR / server frameworks (live: every major JS framework)
 
-`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).
+`shiply publish` auto-detects an SSR build and deploys the worker bundle with
+`nodejs_compat`, serving static assets from the edge. Live and verified on prod:
+SvelteKit (`@sveltejs/adapter-cloudflare`), Astro (`@astrojs/cloudflare`), Qwik
+City, the Nitro family (Nuxt, SolidStart, Analog, TanStack Start), React Router
+v7, and Next.js (via OpenNext) — plus wrangler workers (`wrangler.toml` with
+`main` — Hono, itty-router, raw `fetch`). **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 note: plain SSR works today; ISR / on-demand revalidate is not live yet,
+and Next 16 must build with `next build --webpack` (not Turbopack).
 
 ## Manage & verify sites (CLI)
 
@@ -557,7 +562,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 +572,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
 
@@ -762,14 +768,18 @@ MCP tool set_site_access does the same. Enforced before any content is served;
 changing settings signs current visitors out. Docs: /docs/access-control
 
 ## Any static site works — frameworks + SSGs auto-detected
-shiply hosts any static site. Publish the BUILD OUTPUT, never the source:
-run the build, then publish the output dir with SPA mode for client-routed
-apps. The CLI auto-detects 16+ frameworks and tells you the right command.
+shiply hosts any static site (and full SSR apps too — see the "SSR / server
+frameworks" section above). For a static build, publish the BUILD OUTPUT, never
+the source: run the build, then publish the output dir with SPA mode for
+client-routed apps. The CLI auto-detects 16+ frameworks and tells you the right command.
 Run `shiply detect` to preview what it found without uploading.
 - Vite (React/Vue/Svelte/Solid/Qwik): `npm run build` then `shiply publish dist --spa`
 - Create React App: `npm run build` then `shiply publish build --spa`
-- Next.js: set `output: "export"` in next.config, `npm run build`, then
-  `shiply publish out` (no --spa; export emits real HTML per route)
+- Next.js (static): set `output: "export"` in next.config, `npm run build`, then
+  `shiply publish out` (no --spa; export emits real HTML per route). For full
+  Next.js SSR (via OpenNext) instead, see the "SSR / server frameworks" section
+  above — plain SSR is live (ISR/revalidate not yet; Next 16 needs
+  `next build --webpack`).
 - Astro: `npm run build` then `shiply publish dist`
 - SvelteKit (adapter-static): `npm run build` then `shiply publish build --spa`
 - Nuxt: `npx nuxt generate` then `shiply publish .output/public`