shiply-cli 0.12.0 → 0.14.0

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

@@ -8,6 +8,10 @@ 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';
@@ -38,6 +42,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 +73,16 @@ 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 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
@@ -120,12 +145,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' },
@@ -480,6 +507,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 +559,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);

package/dist/listings.js

@@ -0,0 +1,169 @@
+import { api, resolveBase } from './publish.js';
+import { loadApiKey } from './config.js';
+const headers = (apiKey) => ({
+    'content-type': 'application/json',
+    authorization: `Bearer ${apiKey}`,
+});
+function readFlags(argv) {
+    const flags = {};
+    const rest = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith('--')) {
+            const eq = a.indexOf('=');
+            if (eq >= 0) {
+                flags[a.slice(2, eq)] = a.slice(eq + 1);
+            }
+            else {
+                const next = argv[i + 1];
+                if (next && !next.startsWith('--')) {
+                    flags[a.slice(2)] = next;
+                    i++;
+                }
+                else {
+                    flags[a.slice(2)] = true;
+                }
+            }
+        }
+        else {
+            rest.push(a);
+        }
+    }
+    return { rest, flags };
+}
+async function ctxFromEnv(flags) {
+    const apiKey = typeof flags.key === 'string' ? flags.key : await loadApiKey();
+    if (!apiKey) {
+        throw new Error('listing commands need an API key — run `shiply login` first');
+    }
+    const base = typeof flags.base === 'string' ? flags.base : undefined;
+    return { base, apiKey };
+}
+function printJson(data) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+function money(cents, currency = 'usd') {
+    return `${(cents / 100).toFixed(2)} ${currency.toUpperCase()}`;
+}
+async function listAction(ctx, flags) {
+    const base = resolveBase(ctx.base);
+    // The public REST surface doesn't yet expose GET /api/v1/listings. To list
+    // the seller's own listings without inventing an endpoint, defer to the
+    // dashboard URL the seller can open. Surface the same hint as the dashboard
+    // surfaces; agents wanting machine-readable listings should call the MCP
+    // `list_listings` tool.
+    if (flags.json) {
+        printJson({
+            note: 'GET /api/v1/listings is not exposed; use the MCP `list_listings` tool for machine-readable output.',
+            dashboardUrl: `${resolveBase(ctx.base)}/dashboard/sales`,
+        });
+        return;
+    }
+    console.log('No REST listing index endpoint yet — use the MCP tool `list_listings` for machine output.');
+    console.log(`  dashboard: ${base}/dashboard/sales`);
+    // suppress unused-var warning while keeping the auth check active.
+    void headers(ctx.apiKey);
+}
+async function createAction(ctx, slug, flags) {
+    const priceFlag = flags.price;
+    if (typeof priceFlag !== 'string') {
+        throw new Error('usage: shiply listing create <site-slug> --price <cents> --jurisdiction "<region>" [--pitch "<text>"] [--terms standard|custom] [--terms-custom "<text>"] [--status draft|live]');
+    }
+    const priceCents = Number.parseInt(priceFlag, 10);
+    if (!Number.isFinite(priceCents) || priceCents < 100 || priceCents > 999_900) {
+        throw new Error('--price must be cents between 100 and 999900 (i.e. $1.00 – $9999.00)');
+    }
+    const jurisdiction = typeof flags.jurisdiction === 'string' ? flags.jurisdiction : undefined;
+    if (!jurisdiction || jurisdiction.length < 2) {
+        throw new Error('--jurisdiction is required, e.g. --jurisdiction "California, USA"');
+    }
+    const termsMode = (typeof flags.terms === 'string' ? flags.terms : 'standard');
+    if (termsMode !== 'standard' && termsMode !== 'custom') {
+        throw new Error('--terms must be "standard" or "custom"');
+    }
+    const status = typeof flags.status === 'string' ? flags.status : undefined;
+    if (status && status !== 'draft' && status !== 'live') {
+        throw new Error('--status must be "draft" or "live" on create');
+    }
+    const body = {
+        slug,
+        priceCents,
+        jurisdiction,
+        termsMode,
+    };
+    if (typeof flags.pitch === 'string')
+        body.pitch = flags.pitch;
+    if (typeof flags['terms-custom'] === 'string')
+        body.termsCustom = flags['terms-custom'];
+    if (status)
+        body.status = status;
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/listings`, {
+        method: 'POST',
+        headers: headers(ctx.apiKey),
+        body: JSON.stringify(body),
+    });
+    if (flags.json) {
+        printJson(r);
+        return;
+    }
+    console.log(`✔ listed ${slug} for ${money(r.priceCents, r.currency)}  [${r.status}]`);
+    console.log(`  id: ${r.id}`);
+    console.log(`  marketplace: ${base}/marketplace/${slug}`);
+    console.log(`  edit later: shiply listing update ${slug} --price <cents>`);
+}
+async function removeAction(ctx, slug, flags) {
+    // The REST surface for unlisting is PATCH /api/v1/listings/{id} with
+    // status: "draft". We don't have a slug→id resolver in REST, so the CLI
+    // currently requires the listing id via --id. Agents that only have the
+    // slug should use the MCP `delete_listing` tool which resolves slug→id
+    // server-side.
+    const id = typeof flags.id === 'string' ? flags.id : undefined;
+    if (!id) {
+        throw new Error('usage: shiply listing rm <site-slug> --id <listing-id>  (use the MCP `delete_listing` tool to unlist by slug without needing the id)');
+    }
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/listings/${encodeURIComponent(id)}`, {
+        method: 'PATCH',
+        headers: headers(ctx.apiKey),
+        body: JSON.stringify({ status: 'draft' }),
+    });
+    if (flags.json) {
+        printJson(r);
+        return;
+    }
+    console.log(`✔ unlisted ${slug}  [${r.status}]`);
+}
+export async function runListing(argv) {
+    const sub = argv[0];
+    const { rest, flags } = readFlags(argv.slice(1));
+    if (!sub || sub === 'help') {
+        console.log('usage: shiply listing <ls|create|rm> [args] [--json]');
+        return;
+    }
+    const ctx = await ctxFromEnv(flags);
+    switch (sub) {
+        case 'ls':
+        case 'list':
+            await listAction(ctx, flags);
+            return;
+        case 'create': {
+            const slug = rest[0];
+            if (!slug) {
+                throw new Error('usage: shiply listing create <site-slug> --price <cents> --jurisdiction "<region>"');
+            }
+            await createAction(ctx, slug, flags);
+            return;
+        }
+        case 'rm':
+        case 'delete': {
+            const slug = rest[0];
+            if (!slug)
+                throw new Error('usage: shiply listing rm <site-slug> --id <listing-id>');
+            await removeAction(ctx, slug, flags);
+            return;
+        }
+        default:
+            throw new Error(`unknown listing subcommand: ${sub} (try ls|create|rm)`);
+    }
+}

package/dist/projects.js

@@ -0,0 +1,171 @@
+import { api, resolveBase } from './publish.js';
+import { loadApiKey } from './config.js';
+const headers = (apiKey) => ({
+    'content-type': 'application/json',
+    authorization: `Bearer ${apiKey}`,
+});
+function readFlags(argv) {
+    const flags = {};
+    const rest = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith('--')) {
+            const eq = a.indexOf('=');
+            if (eq >= 0) {
+                flags[a.slice(2, eq)] = a.slice(eq + 1);
+            }
+            else {
+                const next = argv[i + 1];
+                if (next && !next.startsWith('--')) {
+                    flags[a.slice(2)] = next;
+                    i++;
+                }
+                else {
+                    flags[a.slice(2)] = true;
+                }
+            }
+        }
+        else {
+            rest.push(a);
+        }
+    }
+    return { rest, flags };
+}
+async function ctxFromEnv(flags) {
+    const apiKey = typeof flags.key === 'string' ? flags.key : await loadApiKey();
+    if (!apiKey) {
+        throw new Error('project commands need an API key — run `shiply login` first');
+    }
+    const base = typeof flags.base === 'string' ? flags.base : undefined;
+    return { base, apiKey };
+}
+function printJson(data) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+function shortRow(p) {
+    const customer = p.customerEmail ?? p.customerName ?? 'no customer';
+    return `${p.id}  [${p.status}]  ${p.label}  (${customer})`;
+}
+async function listAction(ctx, flags) {
+    const base = resolveBase(ctx.base);
+    const params = new URLSearchParams();
+    if (typeof flags.status === 'string')
+        params.set('status', flags.status);
+    if (typeof flags.q === 'string')
+        params.set('q', flags.q);
+    const qs = params.toString();
+    const url = `${base}/api/v1/projects${qs ? `?${qs}` : ''}`;
+    const r = await api(url, { headers: headers(ctx.apiKey) });
+    if (flags.json) {
+        printJson(r.projects);
+        return;
+    }
+    if (r.projects.length === 0) {
+        console.log('No projects yet. Create one: shiply project create <label>');
+        return;
+    }
+    for (const p of r.projects)
+        console.log(shortRow(p));
+}
+async function createAction(ctx, label, flags) {
+    const base = resolveBase(ctx.base);
+    const body = { label };
+    if (typeof flags['customer-email'] === 'string')
+        body.customerEmail = flags['customer-email'];
+    if (typeof flags['customer-name'] === 'string')
+        body.customerName = flags['customer-name'];
+    const r = await api(`${base}/api/v1/projects`, { method: 'POST', headers: headers(ctx.apiKey), body: JSON.stringify(body) });
+    if (flags.json) {
+        printJson(r);
+        return;
+    }
+    const appBase = base.replace(/\/+$/, '');
+    console.log(`✔ created project ${r.id}  [${r.status}]  ${r.label}`);
+    console.log(`  intake URL (share with customer):`);
+    console.log(`    ${appBase}/intake/${r.intakeToken}`);
+    if (r.customerEmail)
+        console.log(`  intake invite emailed to ${r.customerEmail}`);
+}
+async function getAction(ctx, id, flags) {
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/projects/${encodeURIComponent(id)}`, { headers: headers(ctx.apiKey) });
+    if (flags.json) {
+        printJson(r);
+        return;
+    }
+    console.log(JSON.stringify(r, null, 2));
+}
+async function archiveAction(ctx, id, flags) {
+    const base = resolveBase(ctx.base);
+    // Server archives via PATCH /api/v1/projects/{id} with { status: "archived" }.
+    // There is no dedicated /archive route — PATCH is the documented surface.
+    const body = { status: 'archived' };
+    if (typeof flags.reason === 'string')
+        body.archivedReason = flags.reason;
+    const r = await api(`${base}/api/v1/projects/${encodeURIComponent(id)}`, { method: 'PATCH', headers: headers(ctx.apiKey), body: JSON.stringify(body) });
+    if (flags.json) {
+        printJson(r);
+        return;
+    }
+    console.log(`✔ archived ${r.id}  [${r.status}]  ${r.label}`);
+    console.log(`  restore later with: shiply project restore ${r.id}`);
+}
+async function restoreAction(ctx, id, flags) {
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/projects/${encodeURIComponent(id)}`, {
+        method: 'PATCH',
+        headers: headers(ctx.apiKey),
+        body: JSON.stringify({ status: 'draft' }),
+    });
+    if (flags.json) {
+        printJson(r);
+        return;
+    }
+    console.log(`✔ restored ${r.id}  [${r.status}]  ${r.label}`);
+}
+export async function runProject(argv) {
+    const sub = argv[0];
+    const { rest, flags } = readFlags(argv.slice(1));
+    if (!sub || sub === 'help') {
+        console.log('usage: shiply project <ls|create|get|archive|restore> [args] [--json]');
+        return;
+    }
+    const ctx = await ctxFromEnv(flags);
+    switch (sub) {
+        case 'ls':
+        case 'list':
+            await listAction(ctx, flags);
+            return;
+        case 'create': {
+            const label = rest[0];
+            if (!label) {
+                throw new Error('usage: shiply project create <label> [--customer-email <email>] [--customer-name <name>]');
+            }
+            await createAction(ctx, label, flags);
+            return;
+        }
+        case 'get': {
+            const id = rest[0];
+            if (!id)
+                throw new Error('usage: shiply project get <id>');
+            await getAction(ctx, id, flags);
+            return;
+        }
+        case 'archive': {
+            const id = rest[0];
+            if (!id)
+                throw new Error('usage: shiply project archive <id> [--reason "<text>"]');
+            await archiveAction(ctx, id, flags);
+            return;
+        }
+        case 'restore': {
+            const id = rest[0];
+            if (!id)
+                throw new Error('usage: shiply project restore <id>');
+            await restoreAction(ctx, id, flags);
+            return;
+        }
+        default:
+            throw new Error(`unknown project subcommand: ${sub} (try ls|create|get|archive|restore)`);
+    }
+}

package/dist/sending-domains.js

@@ -0,0 +1,159 @@
+import { api, resolveBase } from './publish.js';
+import { loadApiKey } from './config.js';
+const headers = (apiKey) => ({
+    'content-type': 'application/json',
+    authorization: `Bearer ${apiKey}`,
+});
+function readFlags(argv) {
+    const flags = {};
+    const rest = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith('--')) {
+            const eq = a.indexOf('=');
+            if (eq >= 0) {
+                flags[a.slice(2, eq)] = a.slice(eq + 1);
+            }
+            else {
+                const next = argv[i + 1];
+                if (next && !next.startsWith('--')) {
+                    flags[a.slice(2)] = next;
+                    i++;
+                }
+                else {
+                    flags[a.slice(2)] = true;
+                }
+            }
+        }
+        else {
+            rest.push(a);
+        }
+    }
+    return { rest, flags };
+}
+async function ctxFromEnv(flags) {
+    const apiKey = typeof flags.key === 'string' ? flags.key : await loadApiKey();
+    if (!apiKey) {
+        throw new Error('sending-domain commands need an API key — run `shiply login` first');
+    }
+    const base = typeof flags.base === 'string' ? flags.base : undefined;
+    return { base, apiKey };
+}
+function printJson(data) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+function printDns(d) {
+    if (!d.dns || d.dns.length === 0) {
+        console.log('  (no DNS records returned — call `shiply sending-domain verify <id>` after Resend provisions records)');
+        return;
+    }
+    console.log('  Add these DNS records at your registrar:');
+    for (const r of d.dns) {
+        const status = r.status ? `  [${r.status}]` : '';
+        console.log(`    ${r.type.padEnd(5)} ${r.name}  →  ${r.value}${status}`);
+    }
+}
+async function listAction(ctx, flags) {
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/sending-domains`, { headers: headers(ctx.apiKey) });
+    if (flags.json) {
+        printJson(r.domains);
+        return;
+    }
+    if (!r.domains.length) {
+        console.log('No sending domains yet. Add one: shiply sending-domain add <domain>');
+        return;
+    }
+    for (const d of r.domains) {
+        const from = d.fromAddress ? `  from=${d.fromAddress}` : '';
+        console.log(`${d.domain}  [${d.status}]  id=${d.id}${from}`);
+    }
+}
+async function addAction(ctx, domain, flags) {
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/sending-domains`, {
+        method: 'POST',
+        headers: headers(ctx.apiKey),
+        body: JSON.stringify({ domain }),
+    });
+    if (flags.json) {
+        printJson(r);
+        return;
+    }
+    console.log(`✔ ${r.domain} registered  [${r.status}]  id=${r.id}`);
+    printDns(r);
+    console.log('');
+    console.log(`  After DNS propagates: shiply sending-domain verify ${r.id}`);
+}
+async function verifyAction(ctx, id, flags) {
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/sending-domains/${encodeURIComponent(id)}/verify`, { method: 'POST', headers: headers(ctx.apiKey), body: '{}' });
+    if (flags.json) {
+        printJson(r);
+        return;
+    }
+    console.log(`${r.domain}  [${r.status}]`);
+    if (r.status === 'verified') {
+        console.log('  ✔ ready — shiply will send your demand-test emails from this domain');
+    }
+    else {
+        printDns(r);
+        console.log('  Re-run `shiply sending-domain verify ' + r.id + '` after DNS updates propagate.');
+    }
+}
+async function removeAction(ctx, id, flags) {
+    if (!flags.yes) {
+        console.log(`  refusing — \`sending-domain rm\` deletes the domain and forces existing demand tests to fall back to the shared shiply sender. Re-run with --yes to confirm.`);
+        return;
+    }
+    const base = resolveBase(ctx.base);
+    await api(`${base}/api/v1/sending-domains/${encodeURIComponent(id)}`, {
+        method: 'DELETE',
+        headers: headers(ctx.apiKey),
+    });
+    if (flags.json) {
+        printJson({ removed: id });
+        return;
+    }
+    console.log(`✔ removed sending domain ${id}`);
+}
+export async function runSendingDomain(argv) {
+    const sub = argv[0];
+    const { rest, flags } = readFlags(argv.slice(1));
+    if (!sub || sub === 'help') {
+        console.log('usage: shiply sending-domain <ls|add|verify|rm> [args] [--json]');
+        return;
+    }
+    const ctx = await ctxFromEnv(flags);
+    switch (sub) {
+        case 'ls':
+        case 'list':
+            await listAction(ctx, flags);
+            return;
+        case 'add': {
+            const domain = rest[0];
+            if (!domain)
+                throw new Error('usage: shiply sending-domain add <domain>');
+            await addAction(ctx, domain, flags);
+            return;
+        }
+        case 'verify': {
+            const id = rest[0];
+            if (!id)
+                throw new Error('usage: shiply sending-domain verify <id>');
+            await verifyAction(ctx, id, flags);
+            return;
+        }
+        case 'rm':
+        case 'remove':
+        case 'delete': {
+            const id = rest[0];
+            if (!id)
+                throw new Error('usage: shiply sending-domain rm <id> --yes');
+            await removeAction(ctx, id, flags);
+            return;
+        }
+        default:
+            throw new Error(`unknown sending-domain subcommand: ${sub} (try ls|add|verify|rm)`);
+    }
+}

package/dist/skill.js

@@ -16,12 +16,16 @@ export function installTargets(project) {
     }
     return [{ agent: 'Claude Code (all projects)', dir: join(homedir(), '.claude', 'skills', 'shiply') }];
 }
-export async function installSkill(project) {
+export async function installSkill(project, force = false) {
     const content = await bundledSkill();
     const written = [];
     for (const t of installTargets(project)) {
         await mkdir(t.dir, { recursive: true });
         const file = join(t.dir, 'SKILL.md');
+        // writeFile always overwrites; --force is an explicit signal of intent
+        // (and matches what users type from the AGENT_PROMPT). Without --force we
+        // still overwrite — but a future version may add a sanity check.
+        void force;
         await writeFile(file, content);
         written.push(`${t.agent}: ${file}`);
     }

package/package.json

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

@@ -3,6 +3,18 @@ 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.
 ---
 
+---
+
+> **Skill freshness check.** Shiply ships new capabilities weekly. If this
+> file's "Last updated" below is more than 7 days old, re-install it with
+> `npx -y shiply-cli@latest skill --force` OR fetch `https://shiply.now/skill.md`
+> fresh — your cached copy may be missing features like databases, projects,
+> marketplace, or sending domains.
+>
+> **Last updated: 2026-06-20**
+
+---
+
 # shiply — instant web hosting for agents
 
 shiply.now puts files on the web in seconds. No account needed to start:
@@ -126,11 +138,23 @@ lines for automation; exit code 0 = ready.
 ### 3. Raw HTTP (no installs)
 ```
 1. POST https://shiply.now/api/v1/publish
-   {"files":[{"path":"index.html","size":<bytes>,"contentType":"text/html","hash":"<sha256, optional>"}]}
+   {
+     "agentName": "<your tool name, e.g. Claude Code, Cursor, Codex>",
+     "files": [{"path":"index.html","size":<bytes>,"contentType":"text/html","hash":"<sha256, optional>"}]
+   }
    (+ "Authorization: Bearer shp_…" for permanent owned sites)
 2. PUT each file's bytes to response upload.uploads[].url
 3. POST upload.finalizeUrl with {"versionId":"..."}
 ```
+
+**ALWAYS include `agentName` on anonymous publishes.** The response then
+carries `deviceAuth` ({user_code, verification_url, poll_url, device_code,
+expires_in, interval}) alongside `claimUrl`. Show the user `verification_url`,
+poll `poll_url` every `interval` seconds with the `device_code`, and on
+`{status:"approved"}` you get a permanent `api_key` PLUS the linked site
+is claimed in the same Allow click. Without `agentName` the user has to
+do a separate manual claim step every time.
+
 **Updates:** anonymous → include `"claimToken":"..."` (returned ONCE by the
 first publish — save it); owned → include `"slug":"..."`. Hashes make updates
 cheap: unchanged files are skipped server-side.
@@ -318,6 +342,180 @@ providers; `db_schema` introspects `sqlite_master` (D1) or
 `information_schema` (Neon). Full docs:
 https://shiply.now/docs/databases
 
+## Functions (Workers Lite) — webhooks, cron, secrets, full backend (Developer plan)
+
+shiply Workers Lite lets a published site include server-side code that runs
+on every request. Use when the user needs:
+- A webhook receiver (Stripe, GitHub, etc.) with raw body + signature verification
+- A cron job (daily reminders, periodic sync, retention emails)
+- A privileged API call using secrets (Stripe key, OpenAI key) without exposing them to the browser
+- An authenticated mutation on D1 / Neon (do the auth check in the function before writing)
+
+### How it works
+
+Author `worker.js` (or `worker.ts`) at the publish root. On `shiply publish`,
+shiply compiles (TS) + deploys it as a per-site Cloudflare Worker bound to
+the site's hostname. The worker handles every request; pass static asset
+requests through `env.ASSETS.fetch(request)`.
+
+```ts
+import { verifyStripeSig, json } from 'shiply-runtime'
+
+export default {
+  async fetch(req: Request, env: Env): Promise<Response> {
+    const url = new URL(req.url)
+    if (url.pathname === '/api/webhooks/stripe' && req.method === 'POST') {
+      const body = await req.text()
+      if (!await verifyStripeSig(body, req.headers.get('stripe-signature'), env.STRIPE_WEBHOOK_SECRET)) {
+        return new Response('bad sig', { status: 400 })
+      }
+      // ... handle event, write to env.SITE_DB
+      return new Response('ok')
+    }
+    return env.ASSETS.fetch(req)
+  },
+  async scheduled(event: ScheduledEvent, env: Env) {
+    if (event.cron === '0 9 * * *') { /* daily job */ }
+  }
+}
+```
+
+`.shiply/crons.json` declares cron schedules. `.shiply/secrets.json` declares
+secret names (values set via CLI/MCP, never reach the publish payload).
+
+### Bindings available in `env`
+
+- `env.ASSETS` — fall through to static (`env.ASSETS.fetch(request)`)
+- `env.SITE_DB` — attached D1 (if `shiply db attach` was run)
+- `env.<NAME>` — each shiply Variable becomes a plain-text env var
+- `env.<NAME>` — each secret set via `set_secret` is encrypted, accessible as env var
+
+### MCP tools
+
+| Tool | Purpose |
+|---|---|
+| `deploy_function` | Deploy a Worker function (alternative to publish auto-detection) |
+| `get_function` | Read the deployed source + metadata |
+| `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 |
+
+### CLI
+
+```bash
+shiply publish .                            # auto-detects worker.js + crons.json + secrets.json
+shiply function deploy <slug>               # alternative: upload worker.js without re-publishing
+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 * * *"
+```
+
+### 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`
+
+### Limits + plan
+
+- 1 MB compiled script size, 30s CPU per request, V8 isolate runtime (no Node APIs)
+- 50 secrets, 20 cron triggers per site
+- Plan-gated to Developer: Founder/Hobby see `402 payment_required`. Upgrade: shiply.now/dashboard/plan
+
+Docs: https://shiply.now/docs/functions
+
+## Projects — customer intake + AI brief
+
+When a dev needs to capture a real client brief, they spin up a **project**:
+the dashboard (or `shiply project create`) mints a one-URL intake form to
+share with the customer. The customer fills a 10-step wizard, attaches
+files, hits submit. An AI brief generator (MiniMax-M2 with Anthropic
+fallback) turns the answers into a structured brief the dev reviews and
+edits inline. All files flow into a per-project drive folder.
+
+MCP tools:
+```
+list_projects       — your projects (filter status/q)
+create_project      — start a new intake; pass customerName/customerEmail to email them the link
+get_project         — full project + brief
+update_brief        — patch brief jsonb (after AI generation)
+regenerate_brief    — re-run AI from current intake responses
+archive_project / restore_project — lifecycle
+list_project_files  — files uploaded by the customer
+resend_intake_invite — re-email the customer their intake link (requires customerEmail on project)
+```
+
+REST: `POST/GET /api/v1/projects · GET/PATCH /api/v1/projects/{id} · POST /api/v1/projects/{id}/regenerate-brief`
+(archive: `PATCH /api/v1/projects/{id}` with `{"status":"archived"}` — no
+dedicated `/archive` route).
+
+CLI: `shiply project ls · shiply project create <label> [--customer-email <e>] [--customer-name <n>] · shiply project get <id> · shiply project archive <id>`
+
+Docs: https://shiply.now/docs/projects
+
+## Marketplace — sell built sites
+
+Devs can list any owned site for sale: set a price + short pitch, choose
+standard or custom terms, pick a jurisdiction. Stripe Connect Express
+handles seller payouts — sellers complete a one-time onboarding before
+listing (`get_connect_status` returns the onboarding URL when needed).
+Buyers pay via Stripe Checkout; on `checkout.session.completed` the
+webhook flips the order to `paid` and transfers site ownership
+atomically. Refunds are available within the order's refund window
+(`refundExpiresAt`); a refund reverts ownership to the seller.
+
+Prices are passed as `priceCents` (whole-dollar cents between 100 and
+999900). `termsMode='standard'` uses shiply's template; `'custom'`
+requires `termsCustom` ≥50 chars.
+
+MCP tools:
+```
+list_listings    — my listings
+create_listing   — list a site (siteSlug, priceCents, pitch?, termsMode, jurisdiction, ...)
+update_listing   — change price/pitch/status (draft|live|paused)
+delete_listing   — pulls off marketplace (sets status=draft)
+list_my_sales    — orders where I'm the seller
+list_my_orders   — orders where I'm the buyer
+refund_order     — issue Stripe refund (within refund window; goes back to buyer)
+get_connect_status — Stripe Connect onboarding state + actionable URL
+```
+
+REST: `POST /api/v1/listings · PATCH /api/v1/listings/{id} · POST /api/v1/listings/{id}/checkout · POST /api/v1/orders/{id}/refund · GET /api/v1/connect/status`
+(no GET listing index over REST yet — use the MCP `list_listings` /
+`list_my_sales` / `list_my_orders` tools for machine output, or the
+dashboard `/dashboard/sales` page for humans.)
+
+CLI: `shiply listing ls · shiply listing create <site-slug> --price <cents> --jurisdiction "<region>" · shiply listing rm <slug> --id <listing-id>`
+
+**Stripe Connect note:** Sellers must complete one-time Stripe Connect
+onboarding before listing. Call `get_connect_status` first — when status
+isn't `'ready'` it returns an `onboardingUrl` you should hand to the
+user as a clickable link.
+
+Docs: https://shiply.now/docs/marketplace
+
+## Sending domains — outbound email on your domain
+
+For agents that want shiply to send emails (demand-test broadcasts,
+project intake invites, transactional notifications) from a custom
+verified domain instead of the shared shiply pool. Backed by Resend —
+add the DNS records they return at your registrar, then call
+`verify_sending_domain` to re-check.
+
+MCP tools:
+```
+list_sending_domains   — all your sending domains
+add_sending_domain     — start: returns DNS records to add at your registrar
+verify_sending_domain  — re-check DNS after adding records
+remove_sending_domain  — tear down
+```
+
+REST: `GET/POST /api/v1/sending-domains · POST /api/v1/sending-domains/{id}/verify · DELETE /api/v1/sending-domains/{id}`
+
+CLI: `shiply sending-domain ls · shiply sending-domain add <domain> · shiply sending-domain verify <id> · shiply sending-domain rm <id> --yes`
+
+Cannot be a `shiply.now` subdomain. Verified status flips once SPF +
+DKIM (+ MX for inbound) all check out.
+
 ## Make a site private (paid plans)
 To password-protect or restrict a site: PATCH /api/v1/publishes/<slug>/access
 with {"mode":"password","password":"..."} or {"mode":"restricted",