shiply-cli 0.12.1 → 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/functions.js

@@ -0,0 +1,342 @@
+/** CLI for shiply Workers Lite — function deploy, secrets, crons.
+ *
+ *  Reads --base / --key / --json / --ts from the argv tail the way
+ *  projects.ts and listings.ts do (ad-hoc parser) so the top-level
+ *  `parseArgs` in index.ts doesn't have to know about each one. */
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { loadApiKey } from './config.js';
+import { api, resolveBase } from './publish.js';
+const headers = (apiKey) => ({
+    'content-type': 'application/json',
+    authorization: `Bearer ${apiKey}`,
+});
+/** Strip --flag / --flag=value / --flag value out of argv, returning the
+ *  remaining positionals and a typed flag bag. Mirrors the helper in
+ *  projects.ts so the dispatch pattern stays consistent across subcommands.
+ *  Top-level flags (consumed by index.ts parseArgs before we got here)
+ *  are merged in via the `inherited` arg. */
+function readFlags(argv, inherited = {}) {
+    const raw = {};
+    const rest = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith('--')) {
+            const eq = a.indexOf('=');
+            if (eq >= 0) {
+                raw[a.slice(2, eq)] = a.slice(eq + 1);
+            }
+            else {
+                const next = argv[i + 1];
+                if (next && !next.startsWith('--')) {
+                    raw[a.slice(2)] = next;
+                    i++;
+                }
+                else {
+                    raw[a.slice(2)] = true;
+                }
+            }
+        }
+        else {
+            rest.push(a);
+        }
+    }
+    // `--ts` and `--json` are flags; --base/--key carry values.
+    // If the user passes `--ts something`, our naive parser captures
+    // `something` as the value — re-classify so it stays a positional.
+    const flags = {
+        base: (typeof raw.base === 'string' ? raw.base : undefined) ?? inherited.base,
+        key: (typeof raw.key === 'string' ? raw.key : undefined) ?? inherited.key,
+        json: Boolean(raw.json) || Boolean(inherited.json),
+        ts: Boolean(raw.ts) || Boolean(inherited.ts),
+    };
+    if (typeof raw.ts === 'string')
+        rest.unshift(raw.ts);
+    if (typeof raw.json === 'string')
+        rest.unshift(raw.json);
+    return { rest, flags };
+}
+async function getApiKey(flags, what) {
+    const k = flags.key ?? (await loadApiKey());
+    if (!k)
+        throw new Error(`${what} commands need an API key — run \`shiply login\` first`);
+    return k;
+}
+// --- shiply function --------------------------------------------------------
+const FUNCTION_USAGE = [
+    'Usage: shiply function <deploy|get|rm> <slug> [--ts] [--json]',
+    '       shiply function deploy <slug>            # uploads worker.js from CWD',
+    '       shiply function deploy <slug> --ts       # uploads worker.ts from CWD',
+    '       shiply function get <slug>',
+    '       shiply function rm <slug>',
+].join('\n');
+export async function runFunction(argv, inherited = {}) {
+    const action = argv[0];
+    const rest = argv.slice(1);
+    switch (action) {
+        case 'deploy':
+            return deployCmd(rest, inherited);
+        case 'get':
+            return getFnCmd(rest, inherited);
+        case 'rm':
+        case 'remove':
+        case 'delete':
+            return removeFnCmd(rest, inherited);
+        default:
+            console.error(FUNCTION_USAGE);
+            process.exit(1);
+    }
+}
+async function deployCmd(argv, inherited) {
+    const { rest, flags } = readFlags(argv, inherited);
+    const slug = rest[0];
+    if (!slug) {
+        console.error(FUNCTION_USAGE);
+        process.exit(1);
+    }
+    const apiKey = await getApiKey(flags, 'function');
+    const base = resolveBase(flags.base);
+    const lang = flags.ts ? 'ts' : 'js';
+    const filename = lang === 'ts' ? 'worker.ts' : 'worker.js';
+    let source;
+    try {
+        source = await readFile(join(process.cwd(), filename), 'utf8');
+    }
+    catch (e) {
+        throw new Error(`couldn't read ${filename} from ${process.cwd()} — ${e.message}\n  hint: cd into the directory containing your ${filename}, or pass --ts if the file is worker.ts`);
+    }
+    const row = await api(`${base}/api/v1/sites/${slug}/function`, {
+        method: 'POST',
+        headers: headers(apiKey),
+        body: JSON.stringify({ source, lang }),
+    });
+    if (flags.json) {
+        console.log(JSON.stringify(row, null, 2));
+        return;
+    }
+    console.log(`✔ deployed worker for ${slug}`);
+    console.log(`  script: ${row.cfScriptName}`);
+    console.log(`  version: ${row.version.slice(0, 12)}`);
+    console.log(`  source: ${filename} (${lang})`);
+    console.log(`  routes: requests to https://${slug}.shiply.now/* now hit your worker first`);
+}
+async function getFnCmd(argv, inherited) {
+    const { rest, flags } = readFlags(argv, inherited);
+    const slug = rest[0];
+    if (!slug) {
+        console.error(FUNCTION_USAGE);
+        process.exit(1);
+    }
+    const apiKey = await getApiKey(flags, 'function');
+    const base = resolveBase(flags.base);
+    const row = await api(`${base}/api/v1/sites/${slug}/function`, {
+        headers: headers(apiKey),
+    });
+    if (flags.json) {
+        console.log(JSON.stringify(row, null, 2));
+        return;
+    }
+    console.log(`${slug}  [${row.sourceLang}]  version ${row.version.slice(0, 12)}`);
+    console.log(`  script: ${row.cfScriptName}`);
+    console.log(`  deployed: ${row.deployedAt}`);
+    console.log(`  updated:  ${row.updatedAt}`);
+    console.log(`  source: ${row.source.length} bytes`);
+}
+async function removeFnCmd(argv, inherited) {
+    const { rest, flags } = readFlags(argv, inherited);
+    const slug = rest[0];
+    if (!slug) {
+        console.error(FUNCTION_USAGE);
+        process.exit(1);
+    }
+    const apiKey = await getApiKey(flags, 'function');
+    const base = resolveBase(flags.base);
+    await api(`${base}/api/v1/sites/${slug}/function`, {
+        method: 'DELETE',
+        headers: headers(apiKey),
+    });
+    if (flags.json) {
+        console.log(JSON.stringify({ ok: true }));
+        return;
+    }
+    console.log(`✔ removed worker for ${slug} — static-only routing restored`);
+}
+// --- shiply secret ----------------------------------------------------------
+const SECRET_USAGE = [
+    'Usage: shiply secret <set|ls|rm> <slug> [args] [--json]',
+    '       shiply secret set <slug> <NAME> <VALUE>',
+    '       shiply secret ls <slug>',
+    '       shiply secret rm <slug> <NAME>',
+].join('\n');
+export async function runSecret(argv, inherited = {}) {
+    const action = argv[0];
+    const rest = argv.slice(1);
+    switch (action) {
+        case 'set':
+            return setSecretCmd(rest, inherited);
+        case 'ls':
+        case 'list':
+            return lsSecretsCmd(rest, inherited);
+        case 'rm':
+        case 'remove':
+        case 'delete':
+            return rmSecretCmd(rest, inherited);
+        default:
+            console.error(SECRET_USAGE);
+            process.exit(1);
+    }
+}
+async function setSecretCmd(argv, inherited) {
+    const { rest, flags } = readFlags(argv, inherited);
+    const [slug, name, value] = rest;
+    if (!slug || !name || !value) {
+        console.error(SECRET_USAGE);
+        process.exit(1);
+    }
+    const apiKey = await getApiKey(flags, 'secret');
+    const base = resolveBase(flags.base);
+    await api(`${base}/api/v1/sites/${slug}/secrets`, {
+        method: 'POST',
+        headers: headers(apiKey),
+        body: JSON.stringify({ name, value }),
+    });
+    if (flags.json) {
+        console.log(JSON.stringify({ ok: true, name }));
+        return;
+    }
+    console.log(`✔ set ${name} on ${slug}`);
+    console.log(`  available as env.${name} in your worker on next deploy/restart`);
+}
+async function lsSecretsCmd(argv, inherited) {
+    const { rest, flags } = readFlags(argv, inherited);
+    const slug = rest[0];
+    if (!slug) {
+        console.error(SECRET_USAGE);
+        process.exit(1);
+    }
+    const apiKey = await getApiKey(flags, 'secret');
+    const base = resolveBase(flags.base);
+    const r = await api(`${base}/api/v1/sites/${slug}/secrets`, { headers: headers(apiKey) });
+    if (flags.json) {
+        console.log(JSON.stringify(r, null, 2));
+        return;
+    }
+    if (!r.secrets.length) {
+        console.log(`no secrets on ${slug} yet`);
+        console.log(`  set one: shiply secret set ${slug} STRIPE_SECRET_KEY sk_test_…`);
+        return;
+    }
+    for (const s of r.secrets) {
+        console.log(`${s.name}${s.updatedAt ? `  (updated ${s.updatedAt})` : ''}`);
+    }
+}
+async function rmSecretCmd(argv, inherited) {
+    const { rest, flags } = readFlags(argv, inherited);
+    const [slug, name] = rest;
+    if (!slug || !name) {
+        console.error(SECRET_USAGE);
+        process.exit(1);
+    }
+    const apiKey = await getApiKey(flags, 'secret');
+    const base = resolveBase(flags.base);
+    await api(`${base}/api/v1/sites/${slug}/secrets/${encodeURIComponent(name)}`, {
+        method: 'DELETE',
+        headers: headers(apiKey),
+    });
+    if (flags.json) {
+        console.log(JSON.stringify({ ok: true, name }));
+        return;
+    }
+    console.log(`✔ removed secret ${name} from ${slug}`);
+}
+// --- shiply cron ------------------------------------------------------------
+const CRON_USAGE = [
+    'Usage: shiply cron <ls|set|rm> <slug> [args] [--json]',
+    '       shiply cron ls <slug>',
+    '       shiply cron set <slug> <path> "<schedule>"',
+    '         e.g. shiply cron set my-site /api/cron/digest "0 9 * * *"',
+    '       shiply cron rm <slug> <path>',
+].join('\n');
+export async function runCron(argv, inherited = {}) {
+    const action = argv[0];
+    const rest = argv.slice(1);
+    switch (action) {
+        case 'ls':
+        case 'list':
+            return lsCronsCmd(rest, inherited);
+        case 'set':
+        case 'add':
+            return setCronCmd(rest, inherited);
+        case 'rm':
+        case 'remove':
+        case 'delete':
+            return rmCronCmd(rest, inherited);
+        default:
+            console.error(CRON_USAGE);
+            process.exit(1);
+    }
+}
+async function lsCronsCmd(argv, inherited) {
+    const { rest, flags } = readFlags(argv, inherited);
+    const slug = rest[0];
+    if (!slug) {
+        console.error(CRON_USAGE);
+        process.exit(1);
+    }
+    const apiKey = await getApiKey(flags, 'cron');
+    const base = resolveBase(flags.base);
+    const r = await api(`${base}/api/v1/sites/${slug}/crons`, { headers: headers(apiKey) });
+    if (flags.json) {
+        console.log(JSON.stringify(r, null, 2));
+        return;
+    }
+    if (!r.crons.length) {
+        console.log(`no crons on ${slug} yet`);
+        console.log(`  add one: shiply cron set ${slug} /api/cron/digest "0 9 * * *"`);
+        return;
+    }
+    for (const c of r.crons) {
+        console.log(`${c.schedule}  →  ${c.path}`);
+    }
+}
+async function setCronCmd(argv, inherited) {
+    const { rest, flags } = readFlags(argv, inherited);
+    const [slug, path, schedule] = rest;
+    if (!slug || !path || !schedule) {
+        console.error(CRON_USAGE);
+        process.exit(1);
+    }
+    const apiKey = await getApiKey(flags, 'cron');
+    const base = resolveBase(flags.base);
+    await api(`${base}/api/v1/sites/${slug}/crons`, {
+        method: 'POST',
+        headers: headers(apiKey),
+        body: JSON.stringify({ path, schedule }),
+    });
+    if (flags.json) {
+        console.log(JSON.stringify({ ok: true, path, schedule }));
+        return;
+    }
+    console.log(`✔ scheduled "${schedule}" → ${path} on ${slug}`);
+    console.log(`  Cloudflare will POST to your worker at this path on the schedule`);
+}
+async function rmCronCmd(argv, inherited) {
+    const { rest, flags } = readFlags(argv, inherited);
+    const [slug, path] = rest;
+    if (!slug || !path) {
+        console.error(CRON_USAGE);
+        process.exit(1);
+    }
+    const apiKey = await getApiKey(flags, 'cron');
+    const base = resolveBase(flags.base);
+    await api(`${base}/api/v1/sites/${slug}/crons`, {
+        method: 'DELETE',
+        headers: headers(apiKey),
+        body: JSON.stringify({ path }),
+    });
+    if (flags.json) {
+        console.log(JSON.stringify({ ok: true, path }));
+        return;
+    }
+    console.log(`✔ removed cron ${path} from ${slug}`);
+}

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';
@@ -8,12 +11,34 @@ 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';
 import { domainAdd, domainConnect, domainLs, domainSubAdd, domainSync } from './domain.js';
+import { runProject } from './projects.js';
+import { runListing } from './listings.js';
+import { runSendingDomain } from './sending-domains.js';
+import { runCron, runFunction, runSecret } from './functions.js';
 import { loadApiKey, saveApiKey } from './config.js';
 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 { 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:
@@ -21,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)
@@ -38,6 +64,25 @@ Usage:
   shiply domain connect <domain>              One-click OAuth DNS setup (Cloudflare/Domain Connect)
   shiply domain sub add <host> --site <slug>  Map a subdomain (e.g. app.example.com) to a slug
   shiply domain sync <domain>                 Re-sync DNS records for a connected domain
+  shiply project <ls|create|get|archive|restore>
+                                              Customer-intake projects + AI brief generator
+  shiply project create <label> [--customer-email <e>] [--customer-name <n>]
+                                              Returns the intake URL to share with the customer
+  shiply listing <ls|create|rm>               Marketplace listings (sell built sites)
+  shiply listing create <site-slug> --price <cents> --jurisdiction "<region>"
+                                              Requires Stripe Connect onboarding (see MCP get_connect_status)
+  shiply sending-domain <ls|add|verify|rm>    Outbound email on a verified domain (Resend-backed)
+  shiply sending-domain add <domain>          Returns DNS records to add at your registrar
+  shiply sending-domain verify <id>           Re-check DNS after adding records
+  shiply function <deploy|get|rm> <slug>      Deploy a Cloudflare Worker for your site (Workers Lite).
+                                              Reads worker.js from CWD; pass --ts for worker.ts.
+                                              Deploys + binds routes so https://<slug>.shiply.now/*
+                                              hits your code BEFORE static fallback. Developer plan.
+  shiply secret <set|ls|rm> <slug>            Manage worker secrets (Stripe keys, API tokens, etc.)
+                                              shiply secret set <slug> NAME VALUE — becomes env.NAME
+                                              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 data init [dir]                      Scaffold a starter .shiply/data.json in <dir> (default cwd)
   shiply data list <slug>                     List collections on a site with counts
   shiply data query <slug> <coll> [--limit N] [--cursor C] [--where '<json>']
@@ -50,14 +95,18 @@ 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 skill [--project]                    Install the shiply skill for your AI agent
+  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)
   shiply login [--name <label>]               Open a browser, click Allow → key saved
                                               (--email <addr> falls back to legacy 6-digit code)
   shiply help
 
 Options:
   --spa                  Single-page app mode (unknown paths fall back to index.html)
+  --ts                   (function deploy) read worker.ts instead of worker.js
   --framework <name>     Force the detector (e.g. hugo, nuxt, vite) for non-standard layouts
   --claim-token <tok>    Update a specific anonymous site (overrides .shiply.json)
   --new-site             Ignore .shiply.json and create a fresh site
@@ -106,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' },
@@ -120,12 +181,14 @@ async function main() {
             wait: { type: 'boolean' },
             'new-site': { type: 'boolean' },
             project: { type: 'boolean' },
+            force: { type: 'boolean' },
             timeout: { type: 'string' },
             out: { type: 'string', short: 'o' },
             site: { type: 'string' },
             binding: { type: 'string' },
             params: { type: 'string' },
             postgres: { type: 'boolean' },
+            ts: { type: 'boolean' },
             'preview-branch': { type: 'string' },
             yes: { type: 'boolean' },
             'no-confetti': { type: 'boolean' },
@@ -134,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;
@@ -221,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}/ …`);
@@ -480,6 +555,43 @@ async function main() {
                     throw new Error('usage: shiply db <create|ls|sql|migrate|delete|attach|branch|branches|delete-branch|merge>');
             }
         }
+        case 'project': {
+            await runProject(positionals.slice(1));
+            break;
+        }
+        case 'listing': {
+            await runListing(positionals.slice(1));
+            break;
+        }
+        case 'sending-domain': {
+            await runSendingDomain(positionals.slice(1));
+            break;
+        }
+        case 'function': {
+            await runFunction(positionals.slice(1), {
+                base: values.base,
+                key: values.key,
+                json: typeof values.json === 'string' && values.json.length > 0,
+                ts: Boolean(values.ts),
+            });
+            break;
+        }
+        case 'secret': {
+            await runSecret(positionals.slice(1), {
+                base: values.base,
+                key: values.key,
+                json: typeof values.json === 'string' && values.json.length > 0,
+            });
+            break;
+        }
+        case 'cron': {
+            await runCron(positionals.slice(1), {
+                base: values.base,
+                key: values.key,
+                json: typeof values.json === 'string' && values.json.length > 0,
+            });
+            break;
+        }
         case 'claim': {
             if (dir !== 'verify') {
                 console.error('Usage: shiply claim verify <SHIPLY-XXXXXXXX>');
@@ -495,12 +607,11 @@ async function main() {
             process.exit(r.ok ? 0 : 1);
         }
         case 'skill': {
-            const written = await installSkill(Boolean(values.project));
+            const written = await installSkill(Boolean(values.project), Boolean(values.force));
             for (const w of written)
                 console.log(`✔ skill installed — ${w}`);
-            console.log('  Your agent now knows how to publish, update (same URL!), check SSL, and more.');
-            console.log('  Restart the agent session to pick it up. Re-run after CLI upgrades.');
-            return;
+            console.log('\nThe skill instructs your agent how to publish, manage sites, query databases, run demand tests, drive customer-intake projects, list/sell sites in the marketplace, manage inbox + sending domains, and more.');
+            break;
         }
         case 'login': {
             const base = resolveBase(values.base);