@myapihq/cli 1.1.0-wip.5 → 1.2.1

package/dist/commands/crm/index.js

@@ -0,0 +1,74 @@
+// `myapi crm <namespace> <subcommand>` — Two namespaces (contacts +
+// companies) each with the same shape: list / search / get / create /
+// update / delete / restore / promote. Contacts also have `events` to
+// inspect the timeline.
+import { error, info } from '../../output.js';
+import * as contacts from './contacts.js';
+import * as companies from './companies.js';
+// Dispatcher exports an empty EXPOSES; each subcommand file declares its own.
+export const EXPOSES = [];
+export const SCHEMA = {
+    org: 'string',
+    // Shared filter/payload flags across contacts + companies
+    email: 'string',
+    domain: 'string',
+    'first-name': 'string',
+    'last-name': 'string',
+    name: 'string',
+    stage: 'string',
+    source: 'string',
+    'company-id': 'string',
+    'custom-json': 'string',
+    'include-deleted': 'boolean',
+    'min-last-engagement-days': 'number',
+    'max-last-engagement-days': 'number',
+    limit: 'number',
+    offset: 'number',
+    cursor: 'string',
+    kind: 'string',
+};
+async function dispatchNamespace(ns, sub, rest, flags) {
+    switch (ns) {
+        case 'contacts': return contacts.run(sub, rest, flags);
+        case 'companies': return companies.run(sub, rest, flags);
+        default: error(`Unknown namespace: ${ns}. Run "myapi crm --help" for the list.`);
+    }
+}
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi crm <namespace> <subcommand>
+
+Namespaces:
+  contacts   The people you've engaged with (private to org)
+  companies  The companies you've engaged with (private to org)
+
+Each namespace shares the same subcommands:
+  list                       List with no filter (alias for search)
+  search                     Filter by stage / source / email / domain / engagement
+  get <id>                   Fetch one
+  create <email|domain> ...  Manually create
+  update <id> ...            Patch fields (stage, names, custom JSON)
+  delete <id>                Soft delete (events retained)
+  restore <id>               Restore a soft-deleted row
+  promote <goldfox_id>       Promote a Goldfox lead into your CRM
+
+Contacts also have:
+  events <id> [--kind <k>]   Inspect the contact's engagement timeline
+
+Examples:
+  myapi crm contacts list
+  myapi crm contacts search --stage qualified --source goldfox
+  myapi crm contacts promote p_MC0xMDUuY29t.0
+  myapi crm contacts update <id> --stage qualified
+  myapi crm contacts events <id> --kind webhook_received
+
+Auto-ingest: webhooks with a configurable email path land here as
+\`webhook_received\` events on a contact automatically. Email and pixel
+ingest are coming — see "myapi crm --help" later for the wiring.
+
+Org-scoped: all commands accept --org <id> (or set default: myapi config set-org <id>).
+Run "myapi crm <namespace> --help" for namespace-specific commands.`);
+        return;
+    }
+    return dispatchNamespace(subcommand, args[0], args.slice(1), flags);
+}

package/dist/commands/database.d.ts

@@ -0,0 +1,6 @@
+import type { FlagSchema } from '../flags.js';
+import { type Flags } from '../helpers.js';
+import type { Exposes } from '../exposes.js';
+export declare const EXPOSES: Exposes;
+export declare const SCHEMA: FlagSchema;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/database.js

@@ -0,0 +1,259 @@
+// `myapi database <subcommand>` — KV primitive with per-org namespaces.
+// Two resource groups: namespaces (container) and keys (the values).
+// Surface kept flat (not nested under `database namespaces ... keys ...`)
+// because most calls are key-level and we want tab-completion to land in
+// one hop.
+import * as fs from 'fs';
+import { database as sdk, MyApiError } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, info, printTable, printJson } from '../output.js';
+import { requireOrg, requireArg } from '../helpers.js';
+export const EXPOSES = [
+    'GET /database/orgs/{org_id}/namespaces',
+    'POST /database/orgs/{org_id}/namespaces',
+    'GET /database/orgs/{org_id}/namespaces/{ns}',
+    'DELETE /database/orgs/{org_id}/namespaces/{ns}',
+    'GET /database/orgs/{org_id}/namespaces/{ns}/keys',
+    'GET /database/orgs/{org_id}/namespaces/{ns}/keys/{key}',
+    'PUT /database/orgs/{org_id}/namespaces/{ns}/keys/{key}',
+    'DELETE /database/orgs/{org_id}/namespaces/{ns}/keys/{key}',
+];
+export const SCHEMA = {
+    org: 'string',
+    ns: 'string',
+    prefix: 'string',
+    cursor: 'string',
+    limit: 'number',
+    values: 'boolean',
+    file: 'string',
+    'if-match': 'string',
+};
+// `--values` for list-keys requires both `--values` and (for now) `=true`. We
+// accept the bare flag too because that's how every other boolean works.
+function wantValues(flags) {
+    return flags.values === true || flags.values === 'true';
+}
+// Resolve --ns flag. Required for every key-level op.
+function requireNs(flags, usage) {
+    const ns = typeof flags.ns === 'string' ? flags.ns : '';
+    if (!ns)
+        error(`Missing required flag: --ns <namespace>.\nUsage: ${usage}`);
+    return ns;
+}
+// Read a JSON value from one of: positional arg, --file, or stdin ('-').
+function readJsonValue(arg, flags, usage) {
+    let raw;
+    if (typeof flags.file === 'string' && flags.file) {
+        raw = fs.readFileSync(flags.file, 'utf-8');
+    }
+    else if (arg === '-') {
+        raw = fs.readFileSync(0, 'utf-8');
+    }
+    else if (arg !== undefined) {
+        raw = arg;
+    }
+    else {
+        error(`Missing required argument <value>.\nUsage: ${usage}`);
+    }
+    raw = raw.trim();
+    if (!raw)
+        error('Empty value.');
+    // Pre-flight size check — server caps at 256 KB.
+    if (Buffer.byteLength(raw, 'utf-8') > sdk.MAX_VALUE_BYTES) {
+        error(`Value exceeds ${sdk.MAX_VALUE_BYTES / 1024} KB limit. Use myapi storage for blobs.`);
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        error(`Value is not valid JSON: ${e.message}`);
+    }
+}
+// ── Namespaces ───────────────────────────────────────────────────────────
+async function nsList(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi database namespaces [--org <id>]');
+    const res = await sdk.listNamespaces(config.api_key, orgId);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    printTable(res.namespaces.map(n => ({
+        name: n.name,
+        keys: n.key_count,
+        created: n.created_at,
+    })), { flags, empty: 'No namespaces yet. Create one: myapi database create <name>' });
+}
+async function nsCreate(name, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi database create <name> [--org <id>]');
+    requireArg(name, 'name', 'myapi database create <name>');
+    const ns = await sdk.createNamespace(config.api_key, orgId, name);
+    if (flags.json) {
+        printJson(ns);
+        return;
+    }
+    success(`Namespace "${ns.name}" created.`);
+}
+async function nsDelete(name, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi database delete-namespace <name> [--org <id>]');
+    requireArg(name, 'name', 'myapi database delete-namespace <name>');
+    await sdk.deleteNamespace(config.api_key, orgId, name);
+    success(`Namespace "${name}" and all its keys deleted.`);
+}
+// ── Keys ─────────────────────────────────────────────────────────────────
+async function keysList(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi database keys --ns <ns> [--prefix <p>] [--limit N] [--values] [--cursor <c>] [--org <id>]');
+    const ns = requireNs(flags, 'myapi database keys --ns <ns> [--prefix <p>] [--limit N] [--values]');
+    const opts = {};
+    if (typeof flags.prefix === 'string')
+        opts.prefix = flags.prefix;
+    if (typeof flags.limit === 'number')
+        opts.limit = flags.limit;
+    if (typeof flags.cursor === 'string')
+        opts.cursor = flags.cursor;
+    if (wantValues(flags))
+        opts.values = true;
+    const res = await sdk.listKeys(config.api_key, orgId, ns, opts);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    if (res.keys.length === 0) {
+        info('No keys.');
+        return;
+    }
+    if (wantValues(flags)) {
+        for (const k of res.keys) {
+            info(`${k.key}  (etag=${k.etag})`);
+            info(`  ${JSON.stringify(k.value)}`);
+        }
+    }
+    else {
+        for (const k of res.keys)
+            info(k.key);
+    }
+    if (res.next_cursor)
+        info(`\n— More results — pass --cursor "${res.next_cursor}" to continue`);
+}
+async function keyGet(key, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi database get <key> --ns <ns> [--org <id>]');
+    const ns = requireNs(flags, 'myapi database get <key> --ns <ns>');
+    requireArg(key, 'key', 'myapi database get <key> --ns <ns>');
+    const entry = await sdk.getKey(config.api_key, orgId, ns, key);
+    if (flags.json) {
+        printJson(entry);
+        return;
+    }
+    info(JSON.stringify(entry.value));
+    process.stderr.write(`\n— etag=${entry.etag} · updated=${entry.updated_at}\n`);
+}
+async function keySet(key, valueArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi database set <key> <value-json> --ns <ns> [--if-match <etag>] [--file <path>] [--org <id>]');
+    const ns = requireNs(flags, 'myapi database set <key> <value-json> --ns <ns>');
+    requireArg(key, 'key', 'myapi database set <key> <value-json>');
+    const value = readJsonValue(valueArg, flags, 'myapi database set <key> <value-json> --ns <ns>');
+    const ifMatch = typeof flags['if-match'] === 'string' ? flags['if-match'] : undefined;
+    try {
+        const entry = await sdk.putKey(config.api_key, orgId, ns, key, value, ifMatch);
+        if (flags.json) {
+            printJson(entry);
+            return;
+        }
+        success(`Set ${ns}:${key}  (etag=${entry.etag})`);
+    }
+    catch (err) {
+        if (err instanceof MyApiError && err.code === 'ETAG_MISMATCH') {
+            error('etag mismatch — another writer updated this key. Re-read with: myapi database get');
+        }
+        throw err;
+    }
+}
+async function keyDel(key, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi database del <key> --ns <ns> [--if-match <etag>] [--org <id>]');
+    const ns = requireNs(flags, 'myapi database del <key> --ns <ns>');
+    requireArg(key, 'key', 'myapi database del <key>');
+    const ifMatch = typeof flags['if-match'] === 'string' ? flags['if-match'] : undefined;
+    try {
+        await sdk.deleteKey(config.api_key, orgId, ns, key, ifMatch);
+        success(`Deleted ${ns}:${key}`);
+    }
+    catch (err) {
+        if (err instanceof MyApiError && err.code === 'ETAG_MISMATCH') {
+            error('etag mismatch — another writer updated this key. Re-read with: myapi database get');
+        }
+        throw err;
+    }
+}
+// ── Dispatcher ───────────────────────────────────────────────────────────
+const SUBCOMMAND_USAGE = {
+    'namespaces': 'myapi database namespaces [--org <id>] [--json]',
+    'create': 'myapi database create <name> [--org <id>]',
+    'delete-namespace': `myapi database delete-namespace <name> [--org <id>]
+
+Deletes the namespace AND all keys in it. Irreversible.`,
+    'keys': `myapi database keys --ns <namespace> [--prefix <p>] [--limit N] [--values] [--cursor <c>] [--org <id>] [--json]
+
+Default render is one key per line. --values inlines each value alongside
+its key + etag. --cursor takes the next_cursor printed at the end of a
+previous page.`,
+    'get': `myapi database get <key> --ns <namespace> [--org <id>] [--json]
+
+Prints the value as compact JSON on stdout; etag + updated_at go to
+stderr so pipelines like \`myapi database get foo --ns x | jq\` work.`,
+    'set': `myapi database set <key> <value-json> --ns <namespace> [--if-match <etag>] [--file <path>] [--org <id>]
+
+  <value-json>   The value as a JSON literal (e.g. '{"foo":1}', '"bar"', 'true', '42')
+  --file <path>  Read the value from a file instead of the positional arg
+  Pass "-" as <value-json> to read from stdin
+  --if-match     Compare-and-swap. Pass the etag from a previous get; returns
+                 error if another writer updated the key in the meantime.
+
+  Value must be valid JSON and ≤ 256 KB serialized. For blobs use myapi storage.`,
+    'del': `myapi database del <key> --ns <namespace> [--if-match <etag>] [--org <id>]
+
+Delete a single key. CAS-protected via --if-match like set.`,
+};
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi database <subcommand>
+
+Namespaces:
+  namespaces                    List namespaces in the org
+  create <name>                 Create a namespace
+  delete-namespace <name>       Delete a namespace AND all its keys (irreversible)
+
+Keys (require --ns <namespace>):
+  keys                          List keys in a namespace
+  get <key>                     Get a key's value + etag
+  set <key> <value-json>        Set a key. Value is JSON; CAS via --if-match
+  del <key>                     Delete a key (CAS via --if-match)
+
+All commands accept --org <id> (or set default: myapi config set-org <id>).
+Values are JSON; per-key size cap is 256 KB. Use myapi storage for binary.`);
+        return;
+    }
+    if (flags.help) {
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi database --help" for the list.`);
+        return;
+    }
+    switch (subcommand) {
+        case 'namespaces': return nsList(flags);
+        case 'create': return nsCreate(args[0], flags);
+        case 'delete-namespace': return nsDelete(args[0], flags);
+        case 'keys': return keysList(flags);
+        case 'get': return keyGet(args[0], flags);
+        case 'set': return keySet(args[0], args[1], flags);
+        case 'del': return keyDel(args[0], flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi database --help" for valid subcommands.`);
+    }
+}

package/dist/commands/domain.d.ts

@@ -1,8 +1,12 @@
 import type { FlagSchema } from '../flags.js';
 import { type Flags } from '../helpers.js';
+import type { Exposes } from '../exposes.js';
+export declare const EXPOSES: Exposes;
 export declare const SCHEMA: FlagSchema;
 export declare function check(domainArg: string, flags: Flags): Promise<void>;
 export declare function register(domainArg: string, flags: Flags): Promise<void>;
+export declare function importCmd(domainArg: string, flags: Flags): Promise<void>;
+export declare function renew(domainArg: string, flags: Flags): Promise<void>;
 export declare function list(flags: Flags): Promise<void>;
 export declare function assign(domainArg: string, flags: Flags): Promise<void>;
 export declare function unassign(domainArg: string, flags: Flags): Promise<void>;

package/dist/commands/domain.js

@@ -2,7 +2,19 @@ import { domain as sdkDomain } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, info, printTable, printJson } from '../output.js';
 import { formatDate } from '../utils.js';
+import { resolveRegistrantForRegister } from '../registrant.js';
 import { requireOrg, requireDomain } from '../helpers.js';
+export const EXPOSES = [
+    'GET /domain/orgs/{org_id}/list',
+    'GET /domain/orgs/{org_id}/check/available/{name}',
+    'POST /domain/orgs/{org_id}/register',
+    'POST /domain/orgs/{org_id}/import',
+    'POST /domain/orgs/{org_id}/{domain}/assign',
+    'POST /domain/orgs/{org_id}/{domain}/renew',
+    'GET /domain/orgs/{org_id}/{domain}/settings',
+    'POST /domain/orgs/{org_id}/{domain}/settings',
+    'GET /domain/orgs/{org_id}/{domain}/status',
+];
 export const SCHEMA = {
     org: 'string',
     domain: 'string',
@@ -11,6 +23,21 @@ export const SCHEMA = {
     security: 'string',
     'browser-check': 'string',
     'purge-cache': 'boolean',
+    // Poll `status` until the domain reaches a terminal state.
+    'watch': 'boolean',
+    // WHOIS registrant — required by ICANN at register time. Resolution
+    // order is JSON > per-field flags > stored config > TTY prompt > error.
+    // See packages/cli/src/registrant.ts for the full flow.
+    'registrant-json': 'string',
+    'registrant-name': 'string',
+    'registrant-email': 'string',
+    'registrant-phone': 'string',
+    'registrant-street': 'string',
+    'registrant-city': 'string',
+    'registrant-state': 'string',
+    'registrant-postal-code': 'string',
+    'registrant-country': 'string',
+    'registrant-organization': 'string',
 };
 export async function check(domainArg, flags) {
     const config = requireConfig();
@@ -42,12 +69,61 @@ export async function register(domainArg, flags) {
     if (!domainArg)
         error('Missing required arguments.\nUsage: myapi domain register <domain> [--years <n>] [--org <id>]');
     const years = flags.years || 1;
-    await sdkDomain.registerDomain(config.api_key, orgId, domainArg, years);
+    // Required by ICANN; resolver throws a useful error if nothing's set up
+    // in non-interactive contexts, or runs an interactive prompt for humans.
+    const registrant = await resolveRegistrantForRegister(flags, config);
+    await sdkDomain.registerDomain(config.api_key, orgId, domainArg, { years, registrant });
     success(`Registered ${domainArg}!`);
     info(`Assign it to your org now:\n  myapi domain assign ${domainArg} --org ${orgId}`);
     info(`DNS propagation can take a few minutes — track it with: myapi domain status ${domainArg}`);
     info(`Your funnel will be live on https://${domainArg} once propagation completes.`);
 }
+// Renew a registered domain for one more registration period (typically 1 year).
+// Charged against the org's billing balance — surface a confirmation unless --yes.
+// BYOD: snapshot existing DNS records, create a CF zone, hand back the NS
+// values the customer needs to set at their current registrar. No registrar
+// credentials needed — backend is registrar-agnostic now.
+export async function importCmd(domainArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi domain import <domain> [--org <id>]');
+    if (!domainArg)
+        error('Missing required arguments.\nUsage: myapi domain import <domain> [--org <id>]');
+    const res = await sdkDomain.importDomain(config.api_key, orgId, domainArg);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    success(`Imported ${res.domain} (status: ${res.status})`);
+    info('');
+    info(`Nameservers (set these at your current registrar):`);
+    for (const ns of res.nameservers)
+        info(`  ${ns}`);
+    info('');
+    if (res.preserved_records.length > 0) {
+        info(`Preserved DNS records (${res.preserved_count} found — verify before the NS change):`);
+        printTable(res.preserved_records.map(r => ({ type: r.type, name: r.name, content: r.content, ttl: r.ttl })), { flags });
+        info('');
+    }
+    else {
+        info(`No DNS records detected via public probe — verify directly with your registrar before the NS change.`);
+        info('');
+    }
+    info(res.probe_warning);
+    info('');
+    info(res.next_step);
+    info('');
+    info(`After changing nameservers, watch activation with:`);
+    info(`  myapi domain status ${res.domain} --watch`);
+}
+export async function renew(domainArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi domain renew <domain> [--yes] [--org <id>]');
+    if (!domainArg)
+        error('Missing required arguments.\nUsage: myapi domain renew <domain> [--yes] [--org <id>]');
+    await sdkDomain.renewDomain(config.api_key, orgId, domainArg);
+    success(`Renewed ${domainArg}.`);
+    info(`Track expiry with: myapi domain status ${domainArg}`);
+}
 export async function list(flags) {
     const config = requireConfig();
     const orgId = requireOrg(flags, config, 'myapi domain list [--filter=all|unassigned|org] [--org <id>]');
@@ -85,21 +161,55 @@ export async function unassign(domainArg, flags) {
     await sdkDomain.unassignDomain(config.api_key, orgId, domainArg);
     success(`Unassigned ${domainArg} from org ${orgId}`);
 }
+// Terminal states — stop polling under --watch.
+const TERMINAL_STATUSES = new Set(['active', 'failed', 'error', 'expired']);
 export async function status(domainArg, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi domain status <domain> [--org <id>]');
-    const domain = requireDomain(domainArg, flags, config, 'myapi domain status <domain> [--org <id>]');
-    const res = await sdkDomain.getDomainStatus(config.api_key, orgId, domain);
-    if (flags.json) {
-        printJson(res);
+    const orgId = requireOrg(flags, config, 'myapi domain status <domain> [--org <id>] [--watch]');
+    const domain = requireDomain(domainArg, flags, config, 'myapi domain status <domain> [--org <id>] [--watch]');
+    if (!flags.watch) {
+        const res = await sdkDomain.getDomainStatus(config.api_key, orgId, domain);
+        if (flags.json) {
+            printJson(res);
+            return;
+        }
+        renderStatus(res);
         return;
     }
+    // Watch mode: 10s × 30 (5 min), then 30s × 60 (30 min). Total ~35 min budget.
+    // Backend live-checks CF on each poll for `pending_ns_change` rows, so polling
+    // both reports state AND triggers the flip to `provisioning`.
+    let lastStatus = '';
+    const schedule = [
+        { count: 30, intervalMs: 10_000 },
+        { count: 60, intervalMs: 30_000 },
+    ];
+    info(`Watching ${domain} — press Ctrl-C to stop.`);
+    for (const phase of schedule) {
+        for (let i = 0; i < phase.count; i++) {
+            const res = await sdkDomain.getDomainStatus(config.api_key, orgId, domain);
+            if (res.status !== lastStatus) {
+                renderStatus(res);
+                lastStatus = res.status;
+            }
+            if (TERMINAL_STATUSES.has(res.status))
+                return;
+            await new Promise(r => setTimeout(r, phase.intervalMs));
+        }
+    }
+    info(`Watch budget exhausted (~35 min). Rerun "myapi domain status ${domain} --watch" to keep waiting.`);
+}
+function renderStatus(res) {
     info(`Domain:  ${res.domain}`);
     info(`Status:  ${res.status}`);
     if (res.expires_at)
         info(`Expires: ${formatDate(res.expires_at)}`);
-    if (res.status === 'active')
+    if (res.status === 'pending_ns_change') {
+        info('Waiting for you to change nameservers at your current registrar. Each poll re-checks Cloudflare.');
+    }
+    if (res.status === 'active') {
         info('Note: if recently activated, the SSL certificate may still be provisioning — allow a few minutes before the site is reachable over HTTPS.');
+    }
 }
 export async function settings(domainArg, flags) {
     const config = requireConfig();
@@ -137,15 +247,54 @@ Note: --filter=all and --filter=unassigned are account-wide; --org is only used
 to authenticate the request.`,
     'check': 'myapi domain check <domain> [--org <id>] [--json]',
     'register': `myapi domain register <domain> [--years <num>] [--org <id>]
+       <registrant flags — see below>
 
   --years <num>   Number of years to register for (default: 1)
 
 Prerequisites:
   - Sufficient balance (myapi billing balance)
   - Domain available (myapi domain check <domain>)
+  - WHOIS registrant info (ICANN requirement — see below)
+
+Registrant (required at every register call):
+  Cheapest path: run \`myapi auth registrant set\` once. The CLI stores
+  your name/email/phone/address and auto-injects it on every register.
+
+  Per-call override (agent-friendly):
+    --registrant-json '{"name":"...", "email":"...", "phone":"+33...", "street":"...",
+                        "city":"...", "postal_code":"...", "country_code":"DE"}'
+    or per-field:
+    --registrant-name --registrant-email --registrant-phone --registrant-street
+    --registrant-city --registrant-postal-code --registrant-country
+    --registrant-state          (required for US/CA only)
+    --registrant-organization   (optional)
+
+  If no source provides it and the terminal is interactive, you'll be
+  prompted for the missing fields and offered to save them.
 
 After registering: myapi domain assign <domain>
 DNS propagation takes a few minutes — track it with: myapi domain status <domain>`,
+    'import': `myapi domain import <domain> [--org <id>] [--json]
+
+Bring your own domain (BYOD). Snapshots existing DNS records via a best-effort
+public probe and creates a Cloudflare zone for the domain. Returns the
+nameservers you need to set at your current registrar.
+
+No registrar credentials needed — works with any registrar (Namecheap, GoDaddy,
+Cloudflare Registrar, etc.).
+
+After running:
+  1. Verify the preserved-records table covers your MX/SPF/DKIM/DMARC etc.
+  2. At your current registrar, change the nameservers to the values returned.
+  3. Wait for propagation. Use "myapi domain status <domain> --watch" to track
+     activation — the backend live-checks Cloudflare each time you poll.`,
+    'renew': `myapi domain renew <domain> [--org <id>]
+
+Renews a registered domain for one more registration period (typically 1 year).
+Charged against the org's billing balance — confirm with "myapi billing balance"
+before running.
+
+Track expiry afterward with: myapi domain status <domain>`,
     'assign': `myapi domain assign <domain> [--org <id>]
 
 Assigns a registered domain to an org. Once assigned, your funnel is served at
@@ -153,7 +302,12 @@ https://<domain> after DNS propagation completes.
 
 To transfer to a different org: unassign first, then assign to the new org.`,
     'unassign': 'myapi domain unassign <domain> [--org <id>]',
-    'status': 'myapi domain status <domain> [--org <id>] [--json]',
+    'status': `myapi domain status <domain> [--org <id>] [--watch] [--json]
+
+  --watch   Poll until the domain reaches a terminal state (active / failed /
+            expired). Backoff: 10s × 30 then 30s × 60 (~35 min budget). Useful
+            after "myapi domain import" — each poll also live-checks Cloudflare,
+            so polling drives the flip from pending_ns_change → provisioning.`,
     'settings': `myapi domain settings <domain> [--org <id>]
 
 Gets current edge/CDN settings (security level, browser check, cache).
@@ -175,6 +329,8 @@ Subcommands:
   list             List domains
   check            Check domain availability
   register         Register a domain
+  import           Bring your own domain (BYOD) — registrar-agnostic
+  renew            Renew a registered domain for another period
   assign           Assign domain to an org
   unassign         Unassign domain from its current org
   status           Get domain status
@@ -196,6 +352,8 @@ Tip: Set defaults with "myapi config set-org <id>" / "set-domain <domain>" to sk
         case 'list': return list(flags);
         case 'check': return check(args[0], flags);
         case 'register': return register(args[0], flags);
+        case 'import': return importCmd(args[0], flags);
+        case 'renew': return renew(args[0], flags);
         case 'assign': return assign(args[0], flags);
         case 'unassign': return unassign(args[0], flags);
         case 'status': return status(args[0], flags);

package/dist/commands/email/campaign.d.ts

@@ -1,2 +1,4 @@
 import { type Flags } from '../../helpers.js';
+import type { Exposes } from '../../exposes.js';
+export declare const EXPOSES: Exposes;
 export declare function run(sub: string | undefined, args: string[], flags: Flags): Promise<void>;