shiply-cli 0.14.4 → 0.15.0

package/dist/contract.js

@@ -0,0 +1,143 @@
+/** B14 — `shiply contract <subcommand>` — CLI parity with the contract REST
+ *  + MCP surface shipped in B1-B13. The 7 subcommands cover the full contract
+ *  lifecycle: list / draft / show / send / pdf / amend / retract.
+ *
+ *  Every endpoint here is dev-only (Bearer auth via `~/.shiply/credentials`).
+ *  Customer-side reads happen through the intake portal cookie, not the CLI. */
+import { writeFile } from 'node:fs/promises';
+import { api, ApiError, resolveBase } from './publish.js';
+const headers = (apiKey) => ({
+    'content-type': 'application/json',
+    authorization: `Bearer ${apiKey}`,
+});
+function fmtMoney(cents, currency) {
+    if (cents === null || cents === undefined)
+        return '—';
+    const cur = currency ?? 'USD';
+    const sign = cents < 0 ? '-' : '';
+    const abs = Math.abs(cents);
+    const whole = Math.floor(abs / 100);
+    const frac = String(abs % 100).padStart(2, '0');
+    return `${sign}${cur} ${whole}.${frac}`;
+}
+function kind(c) {
+    return c.parentContractId ? 'amendment' : 'parent';
+}
+export async function contractList(ctx, projectId) {
+    if (!projectId)
+        throw new Error('usage: shiply contract list <project-id>');
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/projects/${encodeURIComponent(projectId)}/contracts`, { headers: headers(ctx.apiKey) });
+    if (!r.parent) {
+        console.log('No contract yet for this project. Draft one: shiply contract draft ' + projectId);
+        return;
+    }
+    const p = r.parent;
+    console.log(`Parent  ${p.id}  [${p.status}]  ${fmtMoney(p.feeCents, p.currency)}  scope="${(p.scopeSummary ?? '').slice(0, 60)}${(p.scopeSummary ?? '').length > 60 ? '…' : ''}"`);
+    if (p.sentAt)
+        console.log(`  sent     ${p.sentAt}`);
+    if (p.signedAt)
+        console.log(`  signed   ${p.signedAt}`);
+    for (const a of r.amendments) {
+        console.log(`Amend   ${a.id}  [${a.status}]  Δ${fmtMoney(a.feeDeltaCents, a.currency ?? p.currency)}  scope="${(a.scopeDelta ?? '').slice(0, 60)}${(a.scopeDelta ?? '').length > 60 ? '…' : ''}"`);
+        if (a.sentAt)
+            console.log(`  sent     ${a.sentAt}`);
+        if (a.signedAt)
+            console.log(`  signed   ${a.signedAt}`);
+    }
+}
+export async function contractDraft(ctx, projectId) {
+    if (!projectId)
+        throw new Error('usage: shiply contract draft <project-id>');
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/projects/${encodeURIComponent(projectId)}/contract`, { method: 'POST', headers: headers(ctx.apiKey), body: '{}' });
+    console.log(`✔ draft contract ${r.contract.id} created`);
+    console.log('  edit fields via the dashboard, then: shiply contract send ' + r.contract.id);
+}
+export async function contractShow(ctx, contractId) {
+    if (!contractId)
+        throw new Error('usage: shiply contract show <contract-id>');
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/contracts/${encodeURIComponent(contractId)}`, { headers: headers(ctx.apiKey) });
+    console.log(JSON.stringify(r.contract, null, 2));
+}
+export async function contractSend(ctx, contractId) {
+    if (!contractId)
+        throw new Error('usage: shiply contract send <contract-id>');
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/contracts/${encodeURIComponent(contractId)}/send`, { method: 'POST', headers: headers(ctx.apiKey), body: '{}' });
+    const k = kind(r.contract);
+    console.log(`✔ ${k} ${r.contract.id} sent — status=${r.contract.status}`);
+    if (r.contract.sentAt)
+        console.log(`  sent at ${r.contract.sentAt}`);
+    console.log('  customer receives an email + sees it on the intake portal');
+}
+export async function contractPdf(ctx, contractId, outPath) {
+    if (!contractId)
+        throw new Error('usage: shiply contract pdf <contract-id> -o file.pdf');
+    if (!outPath)
+        throw new Error('--out / -o <file.pdf> is required for shiply contract pdf');
+    const base = resolveBase(ctx.base);
+    const url = `${base}/api/v1/contracts/${encodeURIComponent(contractId)}/pdf`;
+    const res = await fetch(url, { headers: { authorization: `Bearer ${ctx.apiKey}` } });
+    if (!res.ok) {
+        // Use the same ApiError envelope the rest of the CLI does so 409
+        // contract_not_signed surfaces with a useful message + exit 1.
+        const body = await res.json().catch(() => ({}));
+        const err = body.error;
+        throw new ApiError(err?.code ?? 'http_error', err?.message ?? `HTTP ${res.status}`, res.status);
+    }
+    const bytes = new Uint8Array(await res.arrayBuffer());
+    await writeFile(outPath, bytes);
+    // Quick magic-bytes sanity check — `%PDF-` at the start of a real PDF.
+    const head = String.fromCharCode(...bytes.subarray(0, 5));
+    const looksLikePdf = head === '%PDF-';
+    console.log(`✔ wrote ${outPath} (${bytes.byteLength} bytes${looksLikePdf ? ', %PDF- header' : ', WARNING: not a PDF header'})`);
+}
+export async function contractAmend(ctx, contractId, opts) {
+    if (!contractId)
+        throw new Error('usage: shiply contract amend <contract-id> --scope "…" [--fee-delta N] [--target-date YYYY-MM-DD]');
+    if (!opts.scope)
+        throw new Error('--scope "<change description>" is required');
+    const base = resolveBase(ctx.base);
+    const body = { scopeDelta: opts.scope };
+    if (opts.feeDelta !== undefined) {
+        const n = Number(opts.feeDelta);
+        if (!Number.isFinite(n) || !Number.isInteger(n)) {
+            throw new Error('--fee-delta must be an integer (cents — use a negative number to discount)');
+        }
+        body.feeDeltaCents = n;
+    }
+    if (opts.targetDate)
+        body.targetCompletionDate = opts.targetDate;
+    const r = await api(`${base}/api/v1/contracts/${encodeURIComponent(contractId)}/amend`, { method: 'POST', headers: headers(ctx.apiKey), body: JSON.stringify(body) });
+    console.log(`✔ amendment ${r.contract.id} drafted against parent ${contractId}`);
+    console.log(`  Δscope    : ${r.contract.scopeDelta ?? '—'}`);
+    console.log(`  Δfee      : ${fmtMoney(r.contract.feeDeltaCents, null)}`);
+    if (r.contract.targetCompletionDate)
+        console.log(`  new target: ${r.contract.targetCompletionDate}`);
+    // Spec says: amend auto-sends unless the dev wants a beat. The default is
+    // to send immediately so the contract reaches the customer in one command;
+    // pass --keep-as-draft on `shiply contract retract` style usage if the dev
+    // wants to hold. Here we send unconditionally — amendments are a quick fix
+    // path, and the customer-portal preview is non-binding until signed.
+    const sent = await api(`${base}/api/v1/contracts/${encodeURIComponent(r.contract.id)}/send`, { method: 'POST', headers: headers(ctx.apiKey), body: '{}' });
+    console.log(`✔ amendment ${sent.contract.id} sent — status=${sent.contract.status}`);
+}
+export async function contractRetract(ctx, contractId, opts) {
+    if (!contractId)
+        throw new Error('usage: shiply contract retract <contract-id> [--keep-as-draft]');
+    const base = resolveBase(ctx.base);
+    const r = await api(`${base}/api/v1/contracts/${encodeURIComponent(contractId)}/retract`, {
+        method: 'POST',
+        headers: headers(ctx.apiKey),
+        body: JSON.stringify({ recoverAsDraft: Boolean(opts.keepAsDraft) }),
+    });
+    if (opts.keepAsDraft) {
+        console.log(`✔ contract ${contractId} retracted to draft — edit + re-send when ready`);
+    }
+    else {
+        console.log(`✔ contract ${contractId} retracted (status=${r.contract.status})`);
+    }
+    console.log('  project state reverted to brief_ready');
+}

package/dist/domain.js

@@ -1,4 +1,5 @@
 import { api, resolveBase } from './publish.js';
+import { PSL_RULES } from './psl.data.js';
 const headers = (apiKey) => ({ 'content-type': 'application/json', authorization: `Bearer ${apiKey}` });
 const enc = (d) => encodeURIComponent(d);
 export async function domainLs(ctx) {
@@ -24,40 +25,72 @@ export async function domainConnect(ctx, domain) {
     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}`);
 }
-/** Common 2-label public suffixes. Not exhaustive — but covers the registrar
- *  ccTLDs we've seen in the wild (au, uk, nz, za, br, in, jp, kr, mx, co...).
- *  For anything else we fall back to the last-two-labels heuristic, which is
- *  correct for the vast majority of TLDs. A future improvement is to ship the
- *  Public Suffix List as data; this keeps the CLI bundle tiny. */
-const TWO_LABEL_SUFFIXES = new Set([
-    'com.au', 'net.au', 'org.au', 'edu.au', 'gov.au', 'id.au',
-    'co.uk', 'org.uk', 'me.uk', 'gov.uk', 'ac.uk', 'net.uk',
-    'co.nz', 'net.nz', 'org.nz', 'govt.nz',
-    'co.za', 'org.za', 'web.za',
-    'com.br', 'net.br', 'org.br', 'gov.br',
-    'co.in', 'net.in', 'org.in', 'gov.in',
-    'co.jp', 'or.jp', 'ne.jp', 'go.jp', 'ac.jp',
-    'co.kr', 'or.kr', 'ne.kr', 'go.kr',
-    'com.mx', 'org.mx', 'gob.mx',
-    'co.id', 'or.id', 'ac.id', 'go.id',
-    'com.sg', 'org.sg', 'edu.sg', 'gov.sg',
-    'com.hk', 'org.hk', 'edu.hk', 'gov.hk',
-    'com.tw', 'org.tw', 'gov.tw',
-]);
-/** Split hostname into (parent, subdomain) using a small Public Suffix List.
- *  parts.slice(-2).join('.') is wrong for `paidsooner.com.au` (treats `com.au`
- *  as the parent — that bug shipped phantom state to prod). */
+/** Index the PSL into three buckets for O(1) lookup. Exception rules ('!foo')
+ *  win over wildcard rules ('*.foo') which win over plain rules ('foo'). */
+const PSL_EXACT = new Set();
+const PSL_WILDCARD = new Set();
+const PSL_EXCEPTION = new Set();
+for (const rule of PSL_RULES) {
+    if (rule.startsWith('!'))
+        PSL_EXCEPTION.add(rule.slice(1));
+    else if (rule.startsWith('*.'))
+        PSL_WILDCARD.add(rule.slice(2));
+    else
+        PSL_EXACT.add(rule);
+}
+/** Find the longest matching public suffix for a hostname, applying the full
+ *  PSL algorithm: exception rules win, then wildcards, then longest exact
+ *  match. Returns the suffix as a dotted string (e.g. 'com.au', 'co.uk').
+ *  Returns null if no rule matches (hostname has only a single label, or it's
+ *  IDN/punycode outside the ICANN list). */
+export function findPublicSuffix(hostname) {
+    const labels = hostname.toLowerCase().split('.');
+    // Walk from most-specific (full hostname) to least-specific (TLD).
+    for (let i = 0; i < labels.length; i++) {
+        const candidate = labels.slice(i).join('.');
+        // 1. Exception rule wins → suffix is candidate minus its first label.
+        if (PSL_EXCEPTION.has(candidate)) {
+            return labels.slice(i + 1).join('.') || null;
+        }
+    }
+    for (let i = 0; i < labels.length; i++) {
+        const candidate = labels.slice(i).join('.');
+        // 2. Exact match.
+        if (PSL_EXACT.has(candidate))
+            return candidate;
+        // 3. Wildcard: parent of candidate (everything after candidate's first
+        //    label) is in the wildcard set.
+        if (i + 1 < labels.length) {
+            const parent = labels.slice(i + 1).join('.');
+            if (PSL_WILDCARD.has(parent))
+                return candidate;
+        }
+    }
+    return null;
+}
+/** Split hostname into (registrable domain, subdomain) using the full PSL.
+ *  The registrable domain is the public suffix plus one extra label.
+ *  E.g. `www.example.co.uk` → suffix `co.uk`, domain `example.co.uk`, sub `www`.
+ *  `foo.city.kawasaki.jp` → exception `!city.kawasaki.jp` makes the suffix
+ *  `kawasaki.jp`, so domain is `city.kawasaki.jp` and sub is `foo`.
+ *  Falls back to the last-two-labels heuristic if the hostname is below the
+ *  PSL coverage (no matching rule). */
 export function splitRegistrable(hostname) {
-    const parts = hostname.toLowerCase().split('.');
-    // Try a 2-label public suffix first (e.g. com.au, co.uk).
-    if (parts.length >= 3) {
-        const twoLabel = parts.slice(-2).join('.');
-        if (TWO_LABEL_SUFFIXES.has(twoLabel)) {
-            const domain = parts.slice(-3).join('.');
-            const subdomain = parts.slice(0, -3).join('.') || '@';
-            return { domain, subdomain };
+    const host = hostname.toLowerCase().replace(/\.$/, '');
+    const parts = host.split('.');
+    const suffix = findPublicSuffix(host);
+    if (suffix) {
+        const suffixLabels = suffix.split('.').length;
+        // Registrable domain = public suffix + one more label.
+        if (parts.length <= suffixLabels) {
+            // Hostname IS the public suffix — not registrable on its own.
+            return { domain: host, subdomain: '@' };
         }
+        const domain = parts.slice(-(suffixLabels + 1)).join('.');
+        const subdomain = parts.slice(0, -(suffixLabels + 1)).join('.') || '@';
+        return { domain, subdomain };
     }
+    // No PSL hit — fall back to last-two-labels.
     const domain = parts.slice(-2).join('.');
     const subdomain = parts.slice(0, -2).join('.') || '@';
     return { domain, subdomain };

package/dist/index.js

@@ -14,6 +14,7 @@ import { domainAdd, domainConnect, domainLs, domainPrimary, domainSubAdd, domain
 import { runProject } from './projects.js';
 import { runListing } from './listings.js';
 import { runSendingDomain } from './sending-domains.js';
+import { contractAmend, contractDraft, contractList, contractPdf, contractRetract, contractSend, contractShow, } from './contract.js';
 import { runCron, runFunction, runSecret } from './functions.js';
 import { loadApiKey, saveApiKey } from './config.js';
 import { loginViaDeviceFlow } from './login.js';
@@ -84,6 +85,15 @@ Usage:
                                               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 contract <list|draft|show|send|pdf|amend|retract>
+                                              Customer contracts — full lifecycle CLI (B14).
+                                              list <project-id> — parent + amendments table
+                                              draft <project-id> — creates a draft you can edit
+                                              show <contract-id> — prints the full row as JSON
+                                              send <contract-id> — emails it to the customer
+                                              pdf <contract-id> -o file.pdf — signed PDF download
+                                              amend <id> --scope "…" [--fee-delta N] [--target-date YYYY-MM-DD]
+                                              retract <id> [--keep-as-draft] — undo a sent contract
   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>']
@@ -197,6 +207,10 @@ async function main() {
             limit: { type: 'string' },
             cursor: { type: 'string' },
             where: { type: 'string' },
+            scope: { type: 'string' },
+            'fee-delta': { type: 'string' },
+            'target-date': { type: 'string' },
+            'keep-as-draft': { type: 'boolean' },
             help: { type: 'boolean', short: 'h' },
             version: { type: 'boolean', short: 'v' },
         },
@@ -601,6 +615,57 @@ async function main() {
             });
             break;
         }
+        case 'contract': {
+            const apiKey = values.key ?? (await loadApiKey());
+            if (!apiKey)
+                throw new Error('contract commands need an API key — run `shiply login` first');
+            const cctx = { base: values.base, apiKey };
+            const sub = dir; // positionals[1]
+            const arg = positionals[2]; // contract or project id
+            switch (sub) {
+                case 'list':
+                    if (!arg)
+                        throw new Error('usage: shiply contract list <project-id>');
+                    await contractList(cctx, arg);
+                    return;
+                case 'draft':
+                    if (!arg)
+                        throw new Error('usage: shiply contract draft <project-id>');
+                    await contractDraft(cctx, arg);
+                    return;
+                case 'show':
+                    if (!arg)
+                        throw new Error('usage: shiply contract show <contract-id>');
+                    await contractShow(cctx, arg);
+                    return;
+                case 'send':
+                    if (!arg)
+                        throw new Error('usage: shiply contract send <contract-id>');
+                    await contractSend(cctx, arg);
+                    return;
+                case 'pdf':
+                    if (!arg)
+                        throw new Error('usage: shiply contract pdf <contract-id> -o file.pdf');
+                    await contractPdf(cctx, arg, values.out);
+                    return;
+                case 'amend':
+                    if (!arg)
+                        throw new Error('usage: shiply contract amend <contract-id> --scope "…" [--fee-delta N] [--target-date YYYY-MM-DD]');
+                    await contractAmend(cctx, arg, {
+                        scope: values.scope,
+                        feeDelta: values['fee-delta'],
+                        targetDate: values['target-date'],
+                    });
+                    return;
+                case 'retract':
+                    if (!arg)
+                        throw new Error('usage: shiply contract retract <contract-id> [--keep-as-draft]');
+                    await contractRetract(cctx, arg, { keepAsDraft: Boolean(values['keep-as-draft']) });
+                    return;
+                default:
+                    throw new Error('usage: shiply contract <list|draft|show|send|pdf|amend|retract>');
+            }
+        }
         case 'claim': {
             if (dir !== 'verify') {
                 console.error('Usage: shiply claim verify <SHIPLY-XXXXXXXX>');