shiply-cli 0.14.0 → 0.14.1

package/dist/db.js

@@ -55,6 +55,11 @@ export async function dbCreate(ctx, name, opts) {
         console.log(`  recorded in .shiply.json — next publish will attach to ${existing.slug}`);
     }
 }
+function fmtSize(bytes) {
+    return bytes < 1024 * 1024
+        ? `${(bytes / 1024).toFixed(1)} KB`
+        : `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
 export async function dbLs(ctx) {
     const base = resolveBase(ctx.base);
     const r = await api(`${base}/api/v1/databases`, {
@@ -64,11 +69,30 @@ export async function dbLs(ctx) {
         console.log('No databases yet. Create one: shiply db create <name>');
         return;
     }
-    for (const d of r.databases) {
-        const size = d.sizeBytes < 1024 * 1024
-            ? `${(d.sizeBytes / 1024).toFixed(1)} KB`
-            : `${(d.sizeBytes / 1024 / 1024).toFixed(1)} MB`;
-        console.log(`${d.name}  [${d.provider}]  ${size}${d.siteId ? '' : '  (unbound)'}`);
+    // 4-column table: Name | Provider | Size | Attached Site. Pad to the widest
+    // value in each column so the eye can scan straight down — cheap and faster
+    // than spinning a table library for ≤plan-cap rows.
+    const cols = r.databases.map((d) => ({
+        name: d.name,
+        provider: `[${d.provider}]`,
+        size: fmtSize(d.sizeBytes),
+        site: d.attachedSite
+            ? d.attachedSite.slug
+            : d.siteId
+                ? '(attached)'
+                : '(unbound)',
+    }));
+    const widths = {
+        name: Math.max('NAME'.length, ...cols.map((c) => c.name.length)),
+        provider: Math.max('PROVIDER'.length, ...cols.map((c) => c.provider.length)),
+        size: Math.max('SIZE'.length, ...cols.map((c) => c.size.length)),
+    };
+    // Header row keeps the output friendly for humans without breaking grep —
+    // single space + '#' prefix would have been cute but inconsistent with `db
+    // branches` and `drive ls`. We just lean on padding.
+    console.log(`${'NAME'.padEnd(widths.name)}  ${'PROVIDER'.padEnd(widths.provider)}  ${'SIZE'.padEnd(widths.size)}  ATTACHED SITE`);
+    for (const c of cols) {
+        console.log(`${c.name.padEnd(widths.name)}  ${c.provider.padEnd(widths.provider)}  ${c.size.padEnd(widths.size)}  ${c.site}`);
     }
 }
 export async function dbSql(ctx, idOrName, sql, paramsJson) {

package/dist/index.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+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 { runDetect } from './detect.js';
@@ -18,6 +21,24 @@ import { api, ApiError, DEFAULT_BASE, publish, resolveBase } from './publish.js'
 import { installSkill } from './skill.js';
 import { readState, writeState } from './state.js';
 import { checkReadiness, targetToHostname } from './status.js';
+import { runStatus } from './status-cmd.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));
+function readPkgVersion() {
+    for (const candidate of [join(HERE, '..', 'package.json'), join(HERE, 'package.json')]) {
+        try {
+            const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
+            if (pkg.version)
+                return pkg.version;
+        }
+        catch {
+            /* keep looking */
+        }
+    }
+    return '0.0.0';
+}
+const VERSION = readPkgVersion();
 const HELP = `shiply — instant static hosting for agents (https://shiply.now)
 
 Usage:
@@ -25,6 +46,7 @@ Usage:
                                               Re-running UPDATES the same site (state in .shiply.json)
   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 detect [dir]                         Diagnose: print framework + dir that would upload
                                               (no upload — use --framework=<name> to test an override)
@@ -73,6 +95,8 @@ Usage:
                                               Delete every record in a collection
   shiply claim verify <code>                  Confirm a pairing code from /claim/<slug>?pair=1
                                               (uses .shiply.json from CWD)
+  shiply status [--json]                      With no arg: print account plan + capabilities +
+                                              upgrade URL (pass --json for raw API output)
   shiply skill [--project] [--force]          Install the shiply skill for your AI agent
                                               (global ~/.claude/skills, or ./.claude/skills with --project)
                                               (--force overwrites an existing skill — recommended weekly)
@@ -131,7 +155,19 @@ async function reportReadiness(host, celebrate) {
     return r.ready;
 }
 async function main() {
+    // `shiply status --json` is a flag (raw account/plan status to stdout).
+    // But the global `--json` parseArgs option is a string (data-insert body).
+    // 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') &&
+        !rawArgv.some((a, i) => a === '--json' && typeof rawArgv[i + 1] === 'string' && !rawArgv[i + 1].startsWith('-'));
+    if (statusJsonFlag) {
+        const idx = rawArgv.indexOf('--json');
+        rawArgv.splice(idx, 1);
+    }
     const { values, positionals } = parseArgs({
+        args: rawArgv,
         allowPositionals: true,
         options: {
             spa: { type: 'boolean' },
@@ -161,9 +197,14 @@ async function main() {
             cursor: { type: 'string' },
             where: { type: 'string' },
             help: { type: 'boolean', short: 'h' },
+            version: { type: 'boolean', short: 'v' },
         },
     });
     const [cmd, dir] = positionals;
+    if (values.version || cmd === 'version' || cmd === '--version') {
+        console.log(VERSION);
+        return;
+    }
     if (values.help || !cmd || cmd === 'help') {
         process.stdout.write(HELP);
         return;
@@ -248,8 +289,15 @@ async function main() {
             return;
         }
         case 'status': {
-            if (!dir)
-                throw new Error('usage: shiply status <slug-or-domain> [--wait]');
+            if (!dir) {
+                // No positional → account/plan status. Reads the saved API key.
+                await runStatus({
+                    base: values.base,
+                    key: values.key,
+                    json: statusJsonFlag || (typeof values.json === 'string' && values.json.length > 0),
+                });
+                return;
+            }
             const host = targetToHostname(dir);
             const celebrate = !values['no-confetti'];
             console.log(`checking https://${host}/ …`);

package/dist/status-cmd.js

@@ -0,0 +1,117 @@
+import { loadApiKey } from './config.js';
+import { api, resolveBase } from './publish.js';
+// Minimal ANSI helpers — match the rest of the CLI's "spare colors, never
+// rainbow" tone (see drive/db output).
+const isTty = process.stdout.isTTY;
+const ansi = {
+    green: (s) => (isTty ? `\x1b[32m${s}\x1b[0m` : s),
+    red: (s) => (isTty ? `\x1b[31m${s}\x1b[0m` : s),
+    dim: (s) => (isTty ? `\x1b[2m${s}\x1b[0m` : s),
+    bold: (s) => (isTty ? `\x1b[1m${s}\x1b[0m` : s),
+};
+function fmtLimit(n) {
+    if (n === null || n === undefined)
+        return 'unlimited';
+    return String(n);
+}
+/** Turn `databases_neon_postgres` → `Neon Postgres`-ish: replace _ with space,
+ *  capitalise words, leave acronyms (D1, MCP, URL) upper. Keep it simple. */
+function humanise(key) {
+    const acronyms = new Set(['d1', 'mcp', 'url', 'api']);
+    return key
+        .split('_')
+        .map((w) => (acronyms.has(w) ? w.toUpperCase() : w.charAt(0).toUpperCase() + w.slice(1)))
+        .join(' ');
+}
+export async function runStatus(opts) {
+    const apiKey = opts.key ?? (await loadApiKey());
+    if (!apiKey) {
+        console.error('✖ shiply status needs an API key — run `shiply login` first');
+        process.exitCode = 1;
+        return;
+    }
+    const base = resolveBase(opts.base);
+    let raw;
+    try {
+        raw = await api(`${base}/api/v1/status`, {
+            headers: { authorization: `Bearer ${apiKey}` },
+        });
+    }
+    catch (e) {
+        // Surface 404 cleanly while the sibling /status endpoint rolls out — old
+        // server versions will respond with "HTTP 404" and the user just sees a
+        // friendly hint instead of a stack-style error.
+        const msg = e instanceof Error ? e.message : String(e);
+        if (/404|not.found/i.test(msg)) {
+            console.error('✖ this shiply server does not expose /api/v1/status yet');
+            console.error('  upgrade your CLI or check https://shiply.now');
+            process.exitCode = 1;
+            return;
+        }
+        throw e;
+    }
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(raw, null, 2)}\n`);
+        return;
+    }
+    console.log(ansi.bold('shiply status'));
+    console.log('');
+    // Plan + identity
+    if (raw.plan) {
+        const sub = raw.plan.subscription_status ? ` (${raw.plan.subscription_status})` : '';
+        console.log(`Plan: ${raw.plan.name}${sub}`);
+    }
+    if (raw.user?.email)
+        console.log(`Email: ${raw.user.email}`);
+    if (raw.user)
+        console.log(`Handle: ${raw.user.handle ?? '(none)'}`);
+    console.log('');
+    // Capabilities — iterate in server order; tolerate unknown keys.
+    if (raw.capabilities) {
+        console.log(ansi.bold('Capabilities:'));
+        const entries = Object.entries(raw.capabilities);
+        const labels = entries.map(([k]) => humanise(k));
+        const labelWidth = Math.max(...labels.map((l) => l.length));
+        for (let i = 0; i < entries.length; i++) {
+            const [, cap] = entries[i];
+            const mark = cap.available ? ansi.green('✓') : ansi.red('✗');
+            const label = labels[i].padEnd(labelWidth, ' ');
+            const hint = [];
+            if (cap.plan_required)
+                hint.push(`${cap.plan_required}+`);
+            if (cap.limit !== undefined && cap.limit !== null)
+                hint.push(`limit: ${cap.limit}`);
+            if (cap.note)
+                hint.push(cap.note);
+            const tail = hint.length > 0 ? ansi.dim(`  — ${hint.join(' · ')}`) : '';
+            console.log(`  ${mark} ${label}${tail}`);
+        }
+        console.log('');
+    }
+    // Limits
+    if (raw.limits) {
+        console.log(ansi.bold('Limits:'));
+        for (const [k, v] of Object.entries(raw.limits)) {
+            console.log(`  ${humanise(k)}: ${fmtLimit(v)}`);
+        }
+        console.log('');
+    }
+    // Blocked-features summary + upgrade hint
+    const blocked = raw.blocked_features ?? [];
+    if (blocked.length > 0) {
+        console.log(`${blocked.length} feature${blocked.length === 1 ? '' : 's'} need${blocked.length === 1 ? 's' : ''} an upgrade:`);
+        const labels = blocked.map(humanise);
+        const labelWidth = Math.max(...labels.map((l) => l.length));
+        for (let i = 0; i < blocked.length; i++) {
+            const key = blocked[i];
+            const req = raw.capabilities?.[key]?.plan_required ?? 'higher plan';
+            console.log(`  ${ansi.red('✗')} ${labels[i].padEnd(labelWidth, ' ')}  ${ansi.dim(`— requires ${req}`)}`);
+        }
+        console.log('');
+        if (raw.plan?.upgrade_url)
+            console.log(`Upgrade at: ${raw.plan.upgrade_url}`);
+    }
+    else {
+        console.log('Nothing blocked. You have full access.');
+    }
+}

package/package.json

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

@@ -263,7 +263,7 @@ rest and surfaced to the site's Worker as `env.DATABASE_URL`.
 
 ### D1 (default)
 ```bash
-shiply db create app                      # provision a D1 (binding APP_DB)
+shiply db create app                      # provision a D1 (binding SITE_DB)
 shiply db ls                              # list (name, provider, size, attached site)
 shiply db sql app "SELECT 1"              # one-shot query against your account
 shiply db sql app "SELECT * FROM t WHERE id=?1" --params '[42]'
@@ -277,7 +277,7 @@ Run `shiply db create` inside a publish directory: it records the new
 it. Site code then calls the shim:
 
 ```js
-fetch('/_shiply/db/APP_DB/query', {
+fetch('/_shiply/db/SITE_DB/query', {
   method: 'POST',
   headers: { 'content-type': 'application/json' },
   body: JSON.stringify({ sql: 'SELECT * FROM posts', params: [] }),