shiply-cli 0.12.1 → 0.14.1

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/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.12.1",
+  "version": "0.14.1",
   "description": "Publish static sites to shiply.now from the command line — instant web hosting for agents.",
   "license": "MIT",
   "type": "module",