shiply-cli 0.7.0 → 0.12.0

package/README.md

@@ -1,47 +1,104 @@
-# shiply-cli
-
-Publish static sites to [shiply.now](https://shiply.now) from the command line —
-instant web hosting built for agents.
-
-```bash
-npm install -g shiply-cli
-# or
-curl -fsSL https://shiply.now/install.sh | bash
-```
-
-## Usage
-
-```bash
-shiply publish ./dist          # publish a directory, print the live URL
-shiply publish ./dist          # run it AGAIN → updates the SAME site (no new subdomain)
-shiply publish ./dist --spa    # single-page app mode
-shiply login                   # email a 6-digit code, mint + save an API key
-shiply status <slug-or-domain> [--wait]      # SSL + readiness check — confetti when live 🎉
-```
-
-shiply remembers each directory's site in `.shiply.json` (slug + update token),
-so repeat publishes always hit the same URL. Use `--new-site` to start fresh;
-gitignore `.shiply.json` in public repos.
-
-`shiply status` prints stable `SSL_READY` / `SITE_READY` markers for agents and
-exits 0 only when the certificate is valid and the site serves. `--wait` polls
-until ready (great while a custom domain's certificate issues).
-
-Without an API key, sites are anonymous: live immediately at
-`https://<slug>.shiply.now/`, expire after 24 hours, and print a one-time
-`claimToken`/`claimUrl` so they can be updated or claimed into an account.
-
-With an API key (`shiply login`, `$SHIPLY_API_KEY`, or `--key`), sites are
-permanent and owned by your account.
-
-Unchanged files are hash-skipped on updates — only diffs are uploaded.
-
-## For agents
-
-- Machine guide: <https://shiply.now/llms.txt>
-- OpenAPI spec: <https://shiply.now/openapi.json>
-- Docs: <https://shiply.now/docs>
-
-## License
-
-MIT
+# shiply-cli
+
+Publish static sites to [shiply.now](https://shiply.now) from the command line —
+instant web hosting built for agents.
+
+```bash
+npm install -g shiply-cli
+# or
+curl -fsSL https://shiply.now/install.sh | bash
+```
+
+## Usage
+
+```bash
+shiply publish ./dist          # publish a directory, print the live URL
+shiply publish ./dist          # run it AGAIN → updates the SAME site (no new subdomain)
+shiply publish ./dist --spa    # single-page app mode
+shiply login                   # email a 6-digit code, mint + save an API key
+shiply status <slug-or-domain> [--wait]      # SSL + readiness check — confetti when live 🎉
+```
+
+shiply remembers each directory's site in `.shiply.json` (slug + update token),
+so repeat publishes always hit the same URL. Use `--new-site` to start fresh;
+gitignore `.shiply.json` in public repos.
+
+`shiply status` prints stable `SSL_READY` / `SITE_READY` markers for agents and
+exits 0 only when the certificate is valid and the site serves. `--wait` polls
+until ready (great while a custom domain's certificate issues).
+
+Without an API key, sites are anonymous: live immediately at
+`https://<slug>.shiply.now/`, expire after 24 hours, and print a one-time
+`claimToken`/`claimUrl` so they can be updated or claimed into an account.
+
+With an API key (`shiply login`, `$SHIPLY_API_KEY`, or `--key`), sites are
+permanent and owned by your account.
+
+Unchanged files are hash-skipped on updates — only diffs are uploaded.
+
+### shiply db
+
+Per-site SQL databases. Pick the engine that fits the job: **Cloudflare
+D1** (SQLite at the edge, free on every plan) or **Neon Postgres** (with
+copy-on-write branches, developer plan). Needs an API key.
+
+```bash
+shiply db create <name>                # D1 by default (binding <NAME>_DB)
+shiply db create <name> --postgres     # Neon Postgres (binding DATABASE_URL) — developer plan
+shiply db ls                           # list databases (name, provider, size, attached site)
+shiply db sql <name-or-id> "<query>"   # one-shot query; --params '[1,"a"]' for binds (D1 + Neon)
+shiply db migrate <name-or-id> <dir>   # apply every *.sql in dir, sorted
+shiply db attach <name-or-id> --site <slug>   # bind an existing DB to a site
+shiply db delete <name-or-id> --yes    # drop the database
+
+# Neon only — branching off main:
+shiply db branch <db> <branch-name>    # cheap, fast, copy-on-write branch
+shiply db branches <db>                # list branches of a Neon database
+shiply db delete-branch <name-or-id> --yes   # drop a branch + its compute endpoint
+shiply db merge <branch-name>          # no-op alias — prints the pg_dump migration tip
+```
+
+`shiply db create` inside a directory that already has a `.shiply.json`
+records the new `databaseId` there, so the next `shiply publish`
+auto-attaches it.
+
+- **D1**: pages query it through a built-in fetch shim at
+  `/_shiply/db/<binding>/query` — no API key in the browser.
+- **Neon**: the connection URI is AES-256-GCM encrypted at rest and
+  surfaced to your serving Worker as `env.DATABASE_URL`. Use it with
+  `@neondatabase/serverless`, `pg`, drizzle, etc.
+
+To bind a publish to a specific Neon branch instead of `main`, pass
+`shiply publish --preview-branch=<branchDbId>` — handy for preview
+deploys and safe schema rollouts.
+
+See <https://shiply.now/docs/databases> for the full reference (REST
+routes, per-DB MCP URL, plan caps, D1 caveats, the Neon branch flow).
+
+## Frameworks
+
+`shiply publish .` auto-detects the framework, runs the build if needed, and
+publishes the right output folder with the right flags. Supported:
+
+- **JS app frameworks** — Next.js (static export), Astro, SvelteKit, Vite
+  (React/Vue/Svelte/Solid/Qwik), Create React App, Nuxt (`nuxt generate`),
+  Remix (client build), SolidStart (static), Qwik City (static adapter).
+- **Doc sites** — Docusaurus, MkDocs.
+- **Static site generators** — Hugo, Jekyll, Eleventy, Hexo.
+- **Anything else** — generic fallback for any project that builds to
+  `dist/`, `build/`, `out/`, `_site/`, `public/`, or `.output/public/`.
+- **Plain HTML** — publishes as-is.
+
+Use `shiply detect` to preview which framework was matched, which build
+command will run, and which folder will be uploaded — without uploading
+anything. Override auto-detection with `--framework=<name>`.
+
+## For agents
+
+- Machine guide: <https://shiply.now/llms.txt>
+- OpenAPI spec: <https://shiply.now/openapi.json>
+- Docs: <https://shiply.now/docs>
+
+## License
+
+MIT

package/dist/claim.js

@@ -0,0 +1,32 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export async function runClaimVerify(args) {
+    const read = args.readManifest ?? (() => JSON.parse(readFileSync(join(process.cwd(), '.shiply.json'), 'utf8')));
+    const origin = args.origin ?? 'https://shiply.now';
+    let mf;
+    try {
+        mf = read();
+    }
+    catch {
+        return {
+            ok: false,
+            message: 'No .shiply.json in current directory. Run from the directory where you published, or rerun `shiply publish`.',
+        };
+    }
+    if (!mf.siteId || !mf.claimToken) {
+        return { ok: false, message: '.shiply.json is missing siteId or claimToken.' };
+    }
+    if (!/^SHIPLY-[A-Z2-7]{8}$/.test(args.code)) {
+        return { ok: false, message: 'Invalid code format. Expected SHIPLY-XXXXXXXX.' };
+    }
+    const res = await fetch(`${origin}/api/v1/claim/pair/${encodeURIComponent(args.code)}/verify`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ siteId: mf.siteId, claimToken: mf.claimToken }),
+    });
+    if (!res.ok) {
+        const body = (await res.json().catch(() => ({})));
+        return { ok: false, message: `verify failed: ${body.error?.message ?? res.status}` };
+    }
+    return { ok: true, message: 'Verified — switch back to your browser to finish claiming.' };
+}

package/dist/data-init.js

@@ -0,0 +1,33 @@
+import { access, mkdir, writeFile } from 'node:fs/promises';
+import { resolve, join } from 'node:path';
+const STARTER_MANIFEST = {
+    collections: {
+        messages: {
+            fields: {
+                name: { type: 'string', maxLength: 200 },
+                email: { type: 'email', required: true },
+                message: { type: 'string', maxLength: 2000, required: true },
+            },
+            access: { insert: 'public', read: 'owner' },
+            rateLimit: '10/hour/ip',
+        },
+    },
+};
+/** Write a starter .shiply/data.json into `dir`. Returns the absolute path
+ *  written. Throws if the file already exists. */
+export async function dataInit(dir) {
+    const base = resolve(dir);
+    const target = join(base, '.shiply', 'data.json');
+    try {
+        await access(target);
+        throw new Error(`.shiply/data.json already exists at ${target}`);
+    }
+    catch (e) {
+        // ENOENT is expected here — anything else (including our explicit throw above) re-throws.
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+    await mkdir(join(base, '.shiply'), { recursive: true });
+    await writeFile(target, JSON.stringify(STARTER_MANIFEST, null, 2) + '\n', 'utf8');
+    return target;
+}

package/dist/data.js

@@ -0,0 +1,99 @@
+import { createWriteStream } from 'node:fs';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { api, resolveBase } from './publish.js';
+const headers = (apiKey) => ({
+    'content-type': 'application/json',
+    authorization: `Bearer ${apiKey}`,
+});
+export async function dataList(ctx, slug) {
+    const base = resolveBase(ctx.base);
+    const res = await api(`${base}/api/v1/publishes/${slug}/data`, {
+        headers: headers(ctx.apiKey),
+    });
+    if (res.collections.length === 0) {
+        console.log('  (no collections yet — add `.shiply/data.json` to your site and run `shiply data init`)');
+        return;
+    }
+    for (const c of res.collections) {
+        console.log(`  ${c.collection}  (${c.count})`);
+    }
+}
+export async function dataQuery(ctx, slug, collection, opts) {
+    const base = resolveBase(ctx.base);
+    const params = new URLSearchParams();
+    if (opts.limit)
+        params.set('limit', String(opts.limit));
+    if (opts.cursor)
+        params.set('cursor', opts.cursor);
+    const q = params.toString() ? `?${params.toString()}` : '';
+    const page = await api(`${base}/api/v1/publishes/${slug}/data/${encodeURIComponent(collection)}${q}`, { headers: headers(ctx.apiKey) });
+    let records = page.records;
+    if (opts.where) {
+        let filter;
+        try {
+            filter = JSON.parse(opts.where);
+        }
+        catch {
+            throw new Error('--where must be valid JSON, e.g. \'{"email":"a@b.co"}\'');
+        }
+        records = records.filter((r) => Object.entries(filter).every(([k, v]) => r[k] === v));
+    }
+    if (records.length === 0) {
+        console.log('  (no records)');
+        return;
+    }
+    for (const r of records)
+        console.log(JSON.stringify(r, null, 2));
+    if (page.nextCursor) {
+        console.log(`\n  more — re-run with --cursor=${page.nextCursor}`);
+    }
+}
+export async function dataInsert(ctx, slug, collection, body, sitesDomain = 'shiply.now') {
+    // Inserts hit the PUBLIC visitor endpoint at the live site host. We don't
+    // send the Bearer key here — manifest's `access.insert` decides.
+    const url = `https://${slug}.${sitesDomain}/.shiply/data/${encodeURIComponent(collection)}`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    const json = (await res.json().catch(() => ({})));
+    if (!res.ok)
+        throw new Error(json.message ?? `HTTP ${res.status}`);
+    console.log(`✔ inserted ${json.id ?? ''} at ${json.createdAt ?? ''}`);
+}
+export async function dataExport(ctx, slug, collection, opts) {
+    const base = resolveBase(ctx.base);
+    const url = `${base}/api/v1/publishes/${slug}/data/${encodeURIComponent(collection)}/export`;
+    const res = await fetch(url, { headers: headers(ctx.apiKey) });
+    if (!res.ok) {
+        const body = (await res.json().catch(() => ({})));
+        throw new Error(body.error?.message ?? `HTTP ${res.status}`);
+    }
+    if (!res.body)
+        throw new Error('empty response body');
+    if (opts.out) {
+        await pipeline(Readable.fromWeb(res.body), createWriteStream(opts.out));
+        console.log(`✔ saved ${opts.out}`);
+    }
+    else {
+        // stream to stdout (one record per line, already \n-terminated by the server)
+        const reader = res.body.getReader();
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            process.stdout.write(value);
+        }
+    }
+}
+export async function dataWipeCollection(ctx, slug, collection, opts) {
+    if (!opts.yes) {
+        console.error(`  refusing — wipe-collection deletes EVERY record in "${collection}" on ${slug}. Re-run with --yes to confirm.`);
+        return;
+    }
+    const base = resolveBase(ctx.base);
+    const res = await api(`${base}/api/v1/publishes/${slug}/data/${encodeURIComponent(collection)}`, { method: 'DELETE', headers: headers(ctx.apiKey) });
+    console.log(`✔ wiped ${res.deleted} records from ${collection}`);
+}

package/dist/db.js

@@ -0,0 +1,225 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { api, resolveBase } from './publish.js';
+import { readState, writeState } from './state.js';
+const headers = (apiKey) => ({
+    'content-type': 'application/json',
+    authorization: `Bearer ${apiKey}`,
+});
+// A UUID can be used directly; anything else is treated as a name and resolved
+// via /databases (the table is capped per-owner so the round-trip is cheap).
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function resolveId(ctx, idOrName) {
+    if (UUID_RE.test(idOrName))
+        return idOrName;
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/databases`, { headers: headers(ctx.apiKey) });
+    const row = r.databases.find((d) => d.name === idOrName);
+    if (!row)
+        throw new Error(`no database "${idOrName}" — try \`shiply db ls\``);
+    return row.id;
+}
+export async function dbCreate(ctx, name, opts) {
+    const base = resolveBase(ctx.base);
+    const body = {
+        name,
+        siteSlug: opts.site,
+        binding: opts.binding,
+    };
+    if (opts.postgres)
+        body.provider = 'neon';
+    const r = await api(`${base}/api/v1/databases`, {
+        method: 'POST',
+        headers: headers(ctx.apiKey),
+        body: JSON.stringify(body),
+    });
+    const provider = r.provider ?? (opts.postgres ? 'neon' : 'd1');
+    console.log(`✔ created ${provider} database "${r.name}" (binding: ${r.binding})`);
+    console.log(`  id: ${r.id}`);
+    if (provider === 'neon') {
+        console.log(`  → published sites that select this database get env.${r.binding}`);
+        console.log(`     (Postgres connection string — use with \`pg\`, \`postgres\`, drizzle, etc.)`);
+        console.log(`  branch it: shiply db branch ${r.name} <branch-name>`);
+    }
+    else {
+        console.log(`  query it:  shiply db sql ${r.name} "SELECT 1"`);
+        console.log(`  MCP url:   https://shiply.now/api/mcp/db/${r.id}/mcp`);
+    }
+    // If we're inside a publish directory, record the new databaseId so the
+    // next `shiply publish` auto-attaches it. We don't create state when none
+    // exists — only enrich what's already there.
+    const cwd = opts.cwd ?? process.cwd();
+    const existing = await readState(cwd);
+    if (existing) {
+        await writeState(cwd, { ...existing, databaseId: r.id });
+        console.log(`  recorded in .shiply.json — next publish will attach to ${existing.slug}`);
+    }
+}
+export async function dbLs(ctx) {
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/databases`, {
+        headers: headers(ctx.apiKey),
+    });
+    if (!r.databases.length) {
+        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)'}`);
+    }
+}
+export async function dbSql(ctx, idOrName, sql, paramsJson) {
+    const id = await resolveId(ctx, idOrName);
+    const base = resolveBase(ctx.base);
+    let params = [];
+    if (paramsJson) {
+        try {
+            params = JSON.parse(paramsJson);
+        }
+        catch {
+            throw new Error('--params must be valid JSON, e.g. \'[1,"a"]\'');
+        }
+    }
+    const out = await api(`${base}/api/v1/databases/${id}/query`, {
+        method: 'POST',
+        headers: headers(ctx.apiKey),
+        body: JSON.stringify({ sql, params }),
+    });
+    console.log(JSON.stringify(out.results, null, 2));
+    console.log(`-- ${out.meta.rows_read} read, ${out.meta.rows_written} written, ${out.meta.duration}ms`);
+}
+export async function dbMigrate(ctx, idOrName, dir) {
+    const id = await resolveId(ctx, idOrName);
+    const base = resolveBase(ctx.base);
+    const entries = (await readdir(dir)).filter((f) => f.endsWith('.sql')).sort();
+    if (entries.length === 0) {
+        console.log(`no .sql files in ${dir}`);
+        return;
+    }
+    for (const file of entries) {
+        const sql = await readFile(join(dir, file), 'utf8');
+        process.stdout.write(`→ ${file}  `);
+        try {
+            await api(`${base}/api/v1/databases/${id}/query`, {
+                method: 'POST',
+                headers: headers(ctx.apiKey),
+                body: JSON.stringify({ sql }),
+            });
+            console.log('ok');
+        }
+        catch (e) {
+            console.log(`✖ ${e.message}`);
+            throw e;
+        }
+    }
+    console.log(`✔ ${entries.length} migrations applied`);
+}
+export async function dbDelete(ctx, idOrName, opts) {
+    if (!opts.yes) {
+        console.log(`  refusing — \`db delete\` drops the database "${idOrName}" and every row in it. Re-run with --yes to confirm.`);
+        return;
+    }
+    const id = await resolveId(ctx, idOrName);
+    const base = resolveBase(ctx.base);
+    await api(`${base}/api/v1/databases/${id}`, {
+        method: 'DELETE',
+        headers: headers(ctx.apiKey),
+    });
+    console.log(`✔ deleted database "${idOrName}"`);
+}
+export async function dbAttach(ctx, idOrName, siteSlug) {
+    const id = await resolveId(ctx, idOrName);
+    const base = resolveBase(ctx.base);
+    await api(`${base}/api/v1/databases/${id}/attach`, {
+        method: 'POST',
+        headers: headers(ctx.apiKey),
+        body: JSON.stringify({ siteSlug }),
+    });
+    console.log(`✔ ${idOrName} attached to ${siteSlug}`);
+}
+export async function dbBranch(ctx, parentNameOrId, branchName) {
+    const parentId = await resolveId(ctx, parentNameOrId);
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/databases/${parentId}/branches`, {
+        method: 'POST',
+        headers: headers(ctx.apiKey),
+        body: JSON.stringify({ name: branchName }),
+    });
+    const b = r.database;
+    console.log(`✔ branched ${parentNameOrId} → ${b.name} (binding: ${b.binding})`);
+    console.log(`  id: ${b.id}`);
+    console.log(`  → published sites that select this branch get env.${b.binding}`);
+    console.log(`  delete it: shiply db delete-branch ${b.name} --yes`);
+}
+export async function dbBranches(ctx, parentNameOrId) {
+    const parentId = await resolveId(ctx, parentNameOrId);
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/databases/${parentId}/branches`, { headers: headers(ctx.apiKey) });
+    if (!r.branches.length) {
+        console.log(`no branches on "${parentNameOrId}" yet`);
+        console.log(`  create one: shiply db branch ${parentNameOrId} <branch-name>`);
+        return;
+    }
+    for (const b of r.branches) {
+        const pg = b.meta?.pg_version ? `  pg${b.meta.pg_version}` : '';
+        console.log(`${b.name}  [${b.id}]${pg}`);
+    }
+}
+export async function dbDeleteBranch(ctx, branchIdOrName, opts) {
+    if (!opts.yes) {
+        console.log(`  refusing — \`db delete-branch\` drops the branch "${branchIdOrName}" and its Neon endpoint. Re-run with --yes to confirm.`);
+        return;
+    }
+    const base = resolveBase(ctx.base);
+    // Resolve to (parentId, branchId). UUID input: route by branchId in both
+    // URL segments — the server only consults :branchId for the actual delete.
+    // Name input: walk owned Neon parents and find the matching branch row.
+    let parentId;
+    let branchId;
+    if (UUID_RE.test(branchIdOrName)) {
+        parentId = branchIdOrName;
+        branchId = branchIdOrName;
+    }
+    else {
+        const list = await api(`${base}/api/v1/databases`, { headers: headers(ctx.apiKey) });
+        const neonParents = list.databases.filter((d) => (d.provider ?? 'd1') === 'neon');
+        let found = null;
+        for (const p of neonParents) {
+            const r = await api(`${base}/api/v1/databases/${p.id}/branches`, { headers: headers(ctx.apiKey) });
+            const hit = r.branches.find((b) => b.name === branchIdOrName || b.id === branchIdOrName);
+            if (hit) {
+                found = {
+                    parentId: hit.meta?.parent_database_id ?? p.id,
+                    branchId: hit.id,
+                };
+                break;
+            }
+        }
+        if (!found) {
+            throw new Error(`no branch "${branchIdOrName}" — try \`shiply db branches <db>\``);
+        }
+        parentId = found.parentId;
+        branchId = found.branchId;
+    }
+    await api(`${base}/api/v1/databases/${parentId}/branches/${branchId}`, {
+        method: 'DELETE',
+        headers: headers(ctx.apiKey),
+    });
+    console.log(`✔ deleted branch "${branchIdOrName}"`);
+}
+export async function dbMerge(_ctx, branchName) {
+    // Neon branches don't have a server-side "merge" — they're independent
+    // Postgres endpoints. The supported workflow is `pg_dump` from the branch
+    // and `psql` into main, or run schema migrations on both. We keep this
+    // command as a discoverable alias so agents reaching for `db merge` get
+    // pointed at the right pattern instead of a hard error.
+    console.log(`ℹ shiply db merge is a no-op — Neon branches don't merge.`);
+    console.log(`  branch: ${branchName}`);
+    console.log(`  to promote a branch's data into the parent:`);
+    console.log(`    pg_dump "$BRANCH_DATABASE_URL" | psql "$PARENT_DATABASE_URL"`);
+    console.log(`  to keep schemas aligned, run your migrations against both branches.`);
+    console.log(`  fetch the conn URI: bind the branch on a publish and read env.DATABASE_URL.`);
+}

package/dist/detect.js

@@ -0,0 +1,35 @@
+import { resolve } from 'node:path';
+import { detectFramework, detectBuiltOutput, resolvePayloadDir } from './framework.js';
+export async function runDetect(sourceDir, options = {}) {
+    const dir = resolve(sourceDir);
+    console.log(`source: ${dir}`);
+    if (options.framework) {
+        try {
+            const { dir: payload, hint } = await resolvePayloadDir(dir, options);
+            console.log(`override: --framework=${options.framework}`);
+            console.log(`framework: ${hint?.framework}`);
+            console.log(`upload:   ${payload}`);
+        }
+        catch (e) {
+            console.log(`error: ${e.message}`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const fw = await detectFramework(dir);
+    if (fw)
+        console.log(`framework: ${fw.framework}  →  outputDir: ${fw.outputDir}  (build: ${fw.buildCommand})`);
+    else
+        console.log('framework: (none detected)');
+    const builtFallback = await detectBuiltOutput(dir);
+    if (builtFallback)
+        console.log(`pre-built fallback: ${builtFallback.outputDir}/index.html ✓`);
+    try {
+        const { dir: payload, hint } = await resolvePayloadDir(dir);
+        console.log(`would upload: ${payload}  (${hint ? hint.framework : 'source as-is'})`);
+    }
+    catch (e) {
+        console.log(`would NOT upload: ${e.message}`);
+        process.exitCode = 1;
+    }
+}

package/dist/domain.js

@@ -0,0 +1,56 @@
+import { api, resolveBase } from './publish.js';
+const headers = (apiKey) => ({ 'content-type': 'application/json', authorization: `Bearer ${apiKey}` });
+const enc = (d) => encodeURIComponent(d);
+export async function domainLs(ctx) {
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/custom-domains`, { headers: headers(ctx.apiKey) });
+    if (!r.domains.length) {
+        console.log('No custom domains yet. Add one: shiply domain add <domain>');
+        return;
+    }
+    for (const d of r.domains) {
+        console.log(`${d.name}  [${d.provider}${d.connected ? ' · connected' : ''}]  ${d.status}`);
+        for (const s of d.subdomains)
+            console.log(`  ${s.hostname} → ${s.slug} (${s.status})`);
+    }
+}
+export async function domainAdd(ctx, domain) {
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/custom-domains`, { method: 'POST', headers: headers(ctx.apiKey), body: JSON.stringify({ domain }) });
+    console.log(`✔ ${r.domain} registered — provider: ${r.provider}${r.canAutoConnect ? ` (one-click: shiply domain connect ${r.domain})` : ' (manual DNS)'}`);
+}
+export async function domainConnect(ctx, domain) {
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/custom-domains/${enc(domain)}/connect`, { method: 'POST', headers: headers(ctx.apiKey), body: '{}' });
+    console.log(`Open this link in your browser to connect ${domain}:\n  ${r.url}`);
+}
+export async function domainSubAdd(ctx, hostname, slug) {
+    const parts = hostname.split('.');
+    // NOTE: naive registrable-domain split (last two labels) — wrong for multi-label TLDs like co.uk; the dashboard avoids this by passing the parent domain explicitly.
+    const domain = parts.slice(-2).join('.');
+    const subdomain = parts.slice(0, -2).join('.') || '@';
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/custom-domains/${enc(domain)}/subdomains`, { method: 'POST', headers: headers(ctx.apiKey), body: JSON.stringify({ subdomain, slug }) });
+    if (r.autoConnected) {
+        console.log(`✔ ${r.hostname} → ${slug} (DNS written automatically)`);
+    }
+    else {
+        console.log(`✔ ${r.hostname} → ${slug}. Add this DNS record:`);
+        for (const d of r.dns)
+            console.log(`  ${d.type}  ${d.host}  →  ${d.value}`);
+    }
+}
+export async function domainSync(ctx, domain) {
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/custom-domains/${enc(domain)}/sync-dns`, { method: 'POST', headers: headers(ctx.apiKey), body: '{}' });
+    if (r.connected) {
+        console.log('✔ synced:');
+        for (const x of r.report ?? [])
+            console.log(`  ${x.host}: ${x.action}`);
+    }
+    else {
+        console.log('Not connected — add these records manually:');
+        for (const d of r.records ?? [])
+            console.log(`  ${d.type}  ${d.host}  →  ${d.value}`);
+    }
+}