@myapihq/cli 1.1.0-wip.4 → 1.2.0

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,11 @@
 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 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,19 @@ export const SCHEMA = {
     security: 'string',
     'browser-check': 'string',
     'purge-cache': '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 +67,26 @@ 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.
+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>]');
@@ -137,15 +176,40 @@ 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>`,
+    '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
@@ -175,6 +239,7 @@ Subcommands:
   list             List domains
   check            Check domain availability
   register         Register a domain
+  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 +261,7 @@ 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 '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>;

package/dist/commands/email/campaign.js

@@ -2,6 +2,19 @@ import { email as sdkEmail } from '@myapihq/sdk';
 import { requireConfig } from '../../config.js';
 import { success, error, printTable, printJson, info } from '../../output.js';
 import { requireOrg } from '../../helpers.js';
+export const EXPOSES = [
+    'POST /email/orgs/{org_id}/campaigns',
+    'GET /email/orgs/{org_id}/campaigns',
+    'GET /email/orgs/{org_id}/campaigns/{campaign_id}',
+    'PATCH /email/orgs/{org_id}/campaigns/{campaign_id}',
+    'POST /email/orgs/{org_id}/campaigns/{campaign_id}/contacts/upload-list',
+    'POST /email/orgs/{org_id}/campaigns/{campaign_id}/contacts/upload-file',
+    'GET /email/orgs/{org_id}/campaigns/{campaign_id}/contacts/status',
+    'POST /email/orgs/{org_id}/campaigns/{campaign_id}/start',
+    'POST /email/orgs/{org_id}/campaigns/{campaign_id}/pause',
+    'POST /email/orgs/{org_id}/campaigns/{campaign_id}/resume',
+    'GET /email/orgs/{org_id}/campaigns/{campaign_id}/stats',
+];
 async function create(nameArg, flags) {
     const config = requireConfig();
     const orgId = requireOrg(flags, config, 'myapi email campaign create <name> --template-id <id> --from <email> [--per-day <n>] [--org <id>]');
@@ -61,6 +74,23 @@ async function uploadContacts(id, flags) {
     const res = await sdkEmail.uploadContactList(config.api_key, orgId, id, emails);
     success(`Uploaded ${res.total} contacts (status: ${res.status})`);
 }
+async function uploadContactsFile(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email campaign upload-contacts-file <campaign_id> --file <path> [--org <id>]');
+    if (!id || !flags.file) {
+        error('Missing required arguments.\nUsage: myapi email campaign upload-contacts-file <campaign_id> --file <path> [--org <id>]');
+    }
+    // Defer fs require to keep the unimported-cost low for users who never
+    // touch this command. Plain JS readFile fits — the SDK accepts a Buffer.
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    const filePath = flags.file;
+    if (!fs.existsSync(filePath))
+        error(`File not found: ${filePath}`);
+    const buf = fs.readFileSync(filePath);
+    const res = await sdkEmail.uploadContactsFile(config.api_key, orgId, id, buf, path.basename(filePath));
+    success(`Uploaded ${res.total} contacts from ${filePath} (status: ${res.status})`);
+}
 async function start(id, flags) {
     const config = requireConfig();
     const orgId = requireOrg(flags, config, 'myapi email campaign start <id> [--org <id>]');
@@ -106,6 +136,7 @@ Either form works; the positional name is the recommended shape.`,
     'get': 'myapi email campaign get <id> [--org <id>]',
     'update': 'myapi email campaign update <id> [--name <str>] [--per-day <n>] [--org <id>]',
     'upload-contacts': 'myapi email campaign upload-contacts <campaign_id> --emails <a@x,b@y> [--org <id>]',
+    'upload-contacts-file': 'myapi email campaign upload-contacts-file <campaign_id> --file <path> [--org <id>]',
     'start': 'myapi email campaign start <id> [--org <id>]',
     'pause': 'myapi email campaign pause <id> [--org <id>]',
     'resume': 'myapi email campaign resume <id> [--org <id>]',
@@ -120,7 +151,8 @@ Subcommands:
   list                List campaigns
   get <id>            Get a single campaign
   update <id>         Patch name / per-day-limit
-  upload-contacts <id>  Upload contact list (--emails a@x,b@y)
+  upload-contacts <id>       Upload contact list (--emails a@x,b@y)
+  upload-contacts-file <id>  Upload contacts from a CSV file (--file path/to/contacts.csv)
   start <id>          Start a campaign
   pause <id>          Pause a campaign
   resume <id>         Resume a campaign
@@ -143,6 +175,7 @@ All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         case 'get': return get(args[0], flags);
         case 'update': return update(args[0], flags);
         case 'upload-contacts': return uploadContacts(args[0], flags);
+        case 'upload-contacts-file': return uploadContactsFile(args[0], flags);
         case 'start': return start(args[0], flags);
         case 'pause': return pause(args[0], flags);
         case 'resume': return resume(args[0], flags);

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

@@ -1,4 +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/email/index.js

@@ -2,11 +2,16 @@
 // namespace lives in its own file in this directory; this index just
 // routes to the right one and handles the deprecated flat aliases.
 import { error, info } from '../../output.js';
+// The email index is a dispatcher only; each subcommand file declares
+// its own EXPOSES. Empty here so the coverage tool can still introspect
+// every file uniformly.
+export const EXPOSES = [];
 import * as mailbox from './mailbox.js';
 import * as message from './message.js';
 import * as warmup from './warmup.js';
 import * as template from './template.js';
 import * as campaign from './campaign.js';
+import * as verify from './verify.js';
 export const SCHEMA = {
     org: 'string',
     domain: 'string',
@@ -27,6 +32,7 @@ export const SCHEMA = {
     name: 'string',
     emails: 'string',
     'per-day': 'number',
+    file: 'string',
 };
 // Old flat subcommand → [namespace, sub]. Kept so existing scripts/skills
 // don't break. Emits a one-line stderr deprecation note then runs the new
@@ -63,6 +69,7 @@ async function dispatchNamespace(ns, sub, restArgs, flags) {
         case 'warmup': return warmup.run(sub, restArgs, flags);
         case 'template': return template.run(sub, restArgs, flags);
         case 'campaign': return campaign.run(sub, restArgs, flags);
+        case 'verify': return verify.run(sub, restArgs, flags);
         default: error(`Unknown namespace: ${ns}. Run "myapi email --help" for the list.`);
     }
 }
@@ -76,12 +83,14 @@ Namespaces:
   warmup     Warmup controls (account-scoped) — start, pause, resume, stop, stats
   template   Email templates (org-scoped) — generate, list, edit, send-test, delete
   campaign   Email campaigns (org-scoped) — create, list, get, update, upload-contacts, start, pause, resume, stats
+  verify     Sync single-address email verification (org-scoped) — syntax + DNS + Microsoft probe
 
 Examples:
   myapi email mailbox create hello@example.com
   myapi email message send --from a@x --to b@y --subject hi --body "hello"
   myapi email template generate welcome --prompt "Welcome email"
   myapi email campaign create "Q2 Launch" --template-id <id> --from a@x
+  myapi email verify alice@example.com
 
 Org-scoped commands accept --org <id> (or set default: myapi config set-org <id>).
 Run "myapi email <namespace> --help" for namespace-specific commands.`);

package/dist/commands/email/mailbox.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>;

package/dist/commands/email/mailbox.js

@@ -1,6 +1,11 @@
 import { email as sdkEmail } from '@myapihq/sdk';
 import { requireConfig } from '../../config.js';
 import { success, error, printTable, info } from '../../output.js';
+export const EXPOSES = [
+    'POST /email/mailboxes/create',
+    'GET /email/mailboxes',
+    'POST /email/sending/activate',
+];
 async function create(addressArg, flags) {
     const config = requireConfig();
     // Convention: first required arg is positional. For mailboxes that's the

package/dist/commands/email/message.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>;

package/dist/commands/email/message.js

@@ -1,6 +1,14 @@
 import { email as sdkEmail } from '@myapihq/sdk';
 import { requireConfig } from '../../config.js';
 import { success, error, printTable, printJson, info } from '../../output.js';
+export const EXPOSES = [
+    'POST /email/send',
+    'GET /email/status/{message_id}',
+    'GET /email/sent',
+    'GET /email/inbox/{address}',
+    'GET /email/outbox/{address}',
+    'GET /email/message/{message_id}',
+];
 async function send(flags) {
     const config = requireConfig();
     if (!flags.from || !flags.to || !flags.subject) {

package/dist/commands/email/template.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>;