@myapihq/cli 1.2.0 → 1.2.2

package/dist/commands/domain.d.ts

@@ -5,6 +5,7 @@ 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>;

package/dist/commands/domain.js

@@ -23,6 +23,8 @@ 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.
@@ -36,6 +38,14 @@ export const SCHEMA = {
     'registrant-postal-code': 'string',
     'registrant-country': 'string',
     'registrant-organization': 'string',
+    // DNS records sub-surface
+    type: 'string',
+    name: 'string',
+    content: 'string',
+    ttl: 'number',
+    priority: 'number',
+    proxied: 'boolean',
+    yes: 'boolean',
 };
 export async function check(domainArg, flags) {
     const config = requireConfig();
@@ -78,6 +88,41 @@ export async function register(domainArg, flags) {
 }
 // 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>]');
@@ -124,21 +169,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();
@@ -164,6 +243,157 @@ export async function updateSettings(domainArg, flags) {
     const res = await sdkDomain.updateDomainSettings(config.api_key, orgId, domain, payload);
     success(`Updated settings for ${domain}!\n${JSON.stringify(res, null, 2)}`);
 }
+// ── DNS records sub-surface (`myapi domain records ...`) ────────────────────
+const ALLOWED_RECORD_TYPES = new Set(['A', 'AAAA', 'CNAME', 'MX', 'TXT']);
+function parseRecordType(raw, where) {
+    if (typeof raw !== 'string' || !ALLOWED_RECORD_TYPES.has(raw.toUpperCase())) {
+        error(`${where}: --type must be one of A, AAAA, CNAME, MX, TXT (got: ${raw ?? '(missing)'}).`);
+    }
+    return raw.toUpperCase();
+}
+function recordRow(r) {
+    return {
+        id: r.id,
+        type: r.type,
+        name: r.name,
+        content: r.content,
+        ttl: r.ttl === 1 ? 'auto' : String(r.ttl),
+        priority: r.priority ?? '—',
+        proxied: r.proxied === null ? '—' : (r.proxied ? 'yes' : 'no'),
+    };
+}
+async function recordsList(domainArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi domain records list <domain> [--type <T>] [--org <id>]');
+    const domain = requireDomain(domainArg, flags, config, 'myapi domain records list <domain> [--type <T>] [--org <id>]');
+    const type = flags.type ? parseRecordType(flags.type, 'records list') : undefined;
+    const records = await sdkDomain.listDnsRecords(config.api_key, orgId, domain, type);
+    if (flags.json) {
+        printJson(records);
+        return;
+    }
+    printTable(records.map(recordRow), { flags, empty: 'No records in this zone.' });
+}
+async function recordsGet(domainArg, recordId, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi domain records get <domain> <record-id> [--org <id>]');
+    const domain = requireDomain(domainArg, flags, config, 'myapi domain records get <domain> <record-id> [--org <id>]');
+    if (!recordId)
+        error('Missing record id.\nUsage: myapi domain records get <domain> <record-id>');
+    const r = await sdkDomain.getDnsRecord(config.api_key, orgId, domain, recordId);
+    if (flags.json) {
+        printJson(r);
+        return;
+    }
+    printJson(r);
+}
+async function recordsCreate(domainArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi domain records create <domain> --type <T> --name <n> --content <c> [...]');
+    const domain = requireDomain(domainArg, flags, config, 'myapi domain records create <domain> --type <T> --name <n> --content <c> [...]');
+    const type = parseRecordType(flags.type, 'records create');
+    const name = typeof flags.name === 'string' ? flags.name : '';
+    const content = typeof flags.content === 'string' ? flags.content : '';
+    if (!name)
+        error('Missing --name. For apex, pass --name=@ or --name=<domain>.');
+    if (!content)
+        error('Missing --content.');
+    const input = { type, name, content };
+    if (typeof flags.ttl === 'number')
+        input.ttl = flags.ttl;
+    if (typeof flags.priority === 'number')
+        input.priority = flags.priority;
+    if (typeof flags.proxied === 'boolean')
+        input.proxied = flags.proxied;
+    if (type === 'MX' && input.priority === undefined)
+        error('Missing --priority. Required for MX records (typical value: 10).');
+    const r = await sdkDomain.createDnsRecord(config.api_key, orgId, domain, input);
+    success(`Created ${r.type} record ${r.id}`);
+    printJson(r);
+}
+async function recordsUpdate(domainArg, recordId, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi domain records update <domain> <record-id> [--content ...] [...]');
+    const domain = requireDomain(domainArg, flags, config, 'myapi domain records update <domain> <record-id> [--content ...] [...]');
+    if (!recordId)
+        error('Missing record id.\nUsage: myapi domain records update <domain> <record-id> [flags]');
+    const patch = {};
+    if (typeof flags.name === 'string')
+        patch.name = flags.name;
+    if (typeof flags.content === 'string')
+        patch.content = flags.content;
+    if (typeof flags.ttl === 'number')
+        patch.ttl = flags.ttl;
+    if (typeof flags.priority === 'number')
+        patch.priority = flags.priority;
+    if (typeof flags.proxied === 'boolean')
+        patch.proxied = flags.proxied;
+    if (Object.keys(patch).length === 0)
+        error('Nothing to update. Pass at least one of --name, --content, --ttl, --priority, --proxied.');
+    const r = await sdkDomain.updateDnsRecord(config.api_key, orgId, domain, recordId, patch);
+    success(`Updated record ${r.id}`);
+    printJson(r);
+}
+async function recordsDelete(domainArg, recordId, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi domain records delete <domain> <record-id> [--yes] [--org <id>]');
+    const domain = requireDomain(domainArg, flags, config, 'myapi domain records delete <domain> <record-id> [--yes] [--org <id>]');
+    if (!recordId)
+        error('Missing record id.\nUsage: myapi domain records delete <domain> <record-id> [--yes]');
+    if (!flags.yes) {
+        info(`About to delete record ${recordId} from ${domain}. Re-run with --yes to confirm.`);
+        return;
+    }
+    await sdkDomain.deleteDnsRecord(config.api_key, orgId, domain, recordId);
+    success(`Deleted record ${recordId}`);
+}
+const RECORDS_HELP = `Usage: myapi domain records <subcommand> <domain> [...]
+
+Subcommands:
+  list <domain> [--type A|AAAA|CNAME|MX|TXT]
+  get <domain> <record-id>
+  create <domain> --type <T> --name <n> --content <c> [--ttl <n>]
+                                                       [--priority <n>] [--proxied]
+  update <domain> <record-id> [--content ...] [--ttl ...] [--priority ...] [--proxied]
+  delete <domain> <record-id> [--yes]
+
+Name normalization:
+  --name=@                       Apex (e.g. example.com)
+  --name=mail                    Host-only — backend appends the zone
+  --name=mail.example.com        FQDN
+  --name=""                      Apex (empty == @)
+
+Notes:
+  --ttl defaults to 1 (Cloudflare "automatic"). Explicit range: [60, 86400].
+  --priority is required for MX (typical: 10).
+  --proxied (CF "orange-cloud") applies to A/AAAA/CNAME only.
+
+Examples:
+  Fix the broken SPF on x80security.com:
+    myapi domain records list x80security.com --type TXT
+    myapi domain records delete x80security.com <bad-record-id> --yes
+    myapi domain records create x80security.com --type TXT --name @ \\
+      --content 'v=spf1 include:_spf.mailersend.net include:_spf.google.com ~all'
+    myapi domain records create x80security.com --type TXT --name @ \\
+      --content 'google-site-verification=...'`;
+async function recordsRun(sub, args, flags) {
+    if (!sub || (flags.help && !sub)) {
+        info(RECORDS_HELP);
+        return;
+    }
+    if (flags.help) {
+        info(RECORDS_HELP);
+        return;
+    }
+    switch (sub) {
+        case 'list': return recordsList(args[0], flags);
+        case 'get': return recordsGet(args[0], args[1], flags);
+        case 'create': return recordsCreate(args[0], flags);
+        case 'update': return recordsUpdate(args[0], args[1], flags);
+        case 'delete': return recordsDelete(args[0], args[1], flags);
+        default: error(`Unknown records subcommand: ${sub}. Run "myapi domain records --help".`);
+    }
+}
 // ── Dispatcher ───────────────────────────────────────────────────────────────
 const SUBCOMMAND_USAGE = {
     'list': `myapi domain list [--filter=all|unassigned|org] [--org <id>] [--json]
@@ -203,6 +433,20 @@ Registrant (required at every register call):
 
 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).
@@ -217,11 +461,17 @@ 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).
 Use "myapi domain update-settings" to change them.`,
+    'records': RECORDS_HELP,
     'update-settings': `myapi domain update-settings <domain> [--security=<level>] [--browser-check=on|off] [--purge-cache] [--org <id>]
 
   --security=<level>       essentially_off | low | medium | high | under_attack  (default: medium)
@@ -239,12 +489,14 @@ 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
   settings         Get edge/CDN settings
   update-settings  Update edge/CDN settings
+  records          Manage DNS records in the zone (list / get / create / update / delete)
 
 Tip: Set defaults with "myapi config set-org <id>" / "set-domain <domain>" to skip flags on every command.`);
         return;
@@ -261,12 +513,14 @@ 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);
         case 'settings': return settings(args[0], flags);
         case 'update-settings': return updateSettings(args[0], flags);
+        case 'records': return recordsRun(args[0], args.slice(1), flags);
         default: error(`Unknown subcommand: ${subcommand}. Run "myapi domain --help" for a list of valid subcommands.`);
     }
 }

package/dist/index.js

@@ -82,6 +82,13 @@ const ERROR_MESSAGES = {
     INSUFFICIENT_BALANCE: 'Insufficient balance. Run: myapi billing topup <amount>',
     INVALID_AMOUNT: 'Amount out of range. Maximum single top-up is $100. Run: myapi billing topup <amount>',
     SERVICE_NOT_LAUNCHED: 'This service is disabled pre-launch. Track availability via: myapi status',
+    RECORD_NOT_FOUND: 'DNS record not found in this zone.',
+    INVALID_RECORD_TYPE: 'Unsupported record type. Allowed: A, AAAA, CNAME, MX, TXT.',
+    MX_PRIORITY_REQUIRED: 'MX records require --priority (typical value: 10).',
+    INVALID_TTL: 'Invalid TTL. Use the auto sentinel (1) or a value between 60 and 86400 seconds.',
+    INVALID_RECORD_CONTENT: 'Invalid record content for this type.',
+    RECORD_LIMIT_EXCEEDED: 'Cloudflare per-zone record limit reached.',
+    CF_API_ERROR: 'Cloudflare API error. The backend will surface a `cf_message` field with the underlying detail.',
     // invalid_json_response intentionally absent — the SDK's MyApiError now
     // builds a useful detailed message for that case (status + URL + body
     // snippet), and friendlyError(err.code) would override it.

package/dist/skills/my-domain-api/SKILL.md

@@ -50,9 +50,15 @@ Resolution at register time (highest wins): `--registrant-json` → per-field fl
 | `myapi domain list [--filter all\|unassigned\|org]` | List domains in your account |
 | `myapi domain assign <domain>` | Assign domain to your default (or `--org`) org |
 | `myapi domain unassign <domain>` | Remove domain from its org |
-| `myapi domain status <domain>` | Registration + DNS propagation status |
+| `myapi domain import <domain>` | Bring-your-own-domain. Snapshots current DNS, returns nameservers to set at your existing registrar — no registrar credentials needed |
+| `myapi domain status <domain> [--watch]` | Registration + DNS propagation status. `--watch` polls until terminal (10s × 30 → 30s × 60) |
 | `myapi domain settings <domain>` | View edge/CDN settings |
 | `myapi domain update-settings <domain>` | Change security level, browser check, purge cache |
+| `myapi domain records list <domain> [--type T]` | List DNS records in the zone |
+| `myapi domain records get <domain> <id>` | Fetch one record |
+| `myapi domain records create <domain> --type T --name n --content c` | Create a record (priority required for MX) |
+| `myapi domain records update <domain> <id> [--content c] [...]` | Update a record (type cannot change) |
+| `myapi domain records delete <domain> <id> --yes` | Delete a record |
 <!-- generated:end -->
 
 ## Examples
@@ -73,6 +79,18 @@ myapi domain renew example.com
 # Tune the edge for AI bot traffic
 myapi domain update-settings example.com \
   --security=essentially_off --browser-check=off --purge-cache
+
+# Bring an existing domain — works with any registrar (Namecheap, GoDaddy, CF Registrar, etc.)
+myapi domain import example.com
+# → Returns nameservers; set them at your current registrar.
+myapi domain status example.com --watch
+# → Polls until active. Backend live-checks Cloudflare each poll.
+
+# Fix a record after import (e.g. clean up SPF)
+myapi domain records list example.com --type TXT
+myapi domain records delete example.com <bad-id> --yes
+myapi domain records create example.com --type TXT --name @ \
+  --content 'v=spf1 include:_spf.google.com ~all'
 ```
 
 Security levels: `essentially_off` · `low` · `medium` · `high` · `under_attack`.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@myapihq/cli",
   "license": "Apache-2.0",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "MyAPI command-line interface",
   "type": "module",
   "files": [
@@ -27,7 +27,7 @@
     "lint:changelog": "node ../../scripts/lint-changelog.js"
   },
   "dependencies": {
-    "@myapihq/sdk": "^1.2.0",
+    "@myapihq/sdk": "^1.2.2",
     "omelette": "^0.4.17"
   },
   "devDependencies": {

package/dist/commands/verify.d.ts

@@ -1,7 +0,0 @@
-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 const VERIFY_HELP = "Usage: myapi verify <email> [--org <id>] [--json]\n\nSync single-address email verification. Cheap layer only: syntax + DNS +\nMicrosoft GetCredentialType. Returns a verdict in <1s for ~50% of inputs;\nthe rest get verdict='unknown' with smtp_recommended=true.\n\nVerdicts:\n  deliverable    high-confidence \u2014 the address accepts mail\n  undeliverable  high-confidence \u2014 syntax bad, DNS missing, or Microsoft rejects\n  unknown        not enough signal; consider an SMTP probe (not in this API)\n\nUse --json for the full check breakdown (syntax / DNS / Microsoft probes).\n";
-export declare function run(arg: string | undefined, _rest: string[], flags?: Flags): Promise<void>;

package/dist/commands/verify.js

@@ -1,56 +0,0 @@
-import { email as sdkEmail } from '@myapihq/sdk';
-import { requireConfig } from '../config.js';
-import { error, info, printJson } from '../output.js';
-import { requireOrg } from '../helpers.js';
-export const EXPOSES = [
-    'POST /email/orgs/{org_id}/verify',
-];
-export const SCHEMA = {
-    org: 'string',
-};
-export const VERIFY_HELP = `Usage: myapi verify <email> [--org <id>] [--json]
-
-Sync single-address email verification. Cheap layer only: syntax + DNS +
-Microsoft GetCredentialType. Returns a verdict in <1s for ~50% of inputs;
-the rest get verdict='unknown' with smtp_recommended=true.
-
-Verdicts:
-  deliverable    high-confidence — the address accepts mail
-  undeliverable  high-confidence — syntax bad, DNS missing, or Microsoft rejects
-  unknown        not enough signal; consider an SMTP probe (not in this API)
-
-Use --json for the full check breakdown (syntax / DNS / Microsoft probes).
-`;
-export async function run(arg, _rest, flags = {}) {
-    if (flags.help) {
-        info(VERIFY_HELP);
-        return;
-    }
-    if (!arg)
-        error('Missing required argument <email>.\nUsage: myapi verify <email> [--org <id>] [--json]');
-    const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi verify <email> [--org <id>]');
-    const res = await sdkEmail.verifyEmail(config.api_key, orgId, arg);
-    if (flags.json) {
-        printJson(res);
-        return;
-    }
-    // Compact human render. The verdict + confidence is the headline; the
-    // checks block is verbose enough that we hide it behind --json.
-    const verdictLabel = res.verdict === 'deliverable' ? '✓ deliverable'
-        : res.verdict === 'undeliverable' ? '✗ undeliverable'
-            : '? unknown';
-    info(`Email:      ${res.email}`);
-    info(`Verdict:    ${verdictLabel}  (confidence ${res.confidence.toFixed(2)})`);
-    info(`SMTP next:  ${res.smtp_recommended ? 'yes — consider an SMTP probe' : 'no — verdict is definitive'}`);
-    info(`Took:       ${res.elapsed_ms}ms`);
-    if (res.checks.syntax.detail)
-        info(`Syntax:     ${res.checks.syntax.detail}`);
-    if (res.checks.dns && res.checks.dns.mx_records && res.checks.dns.mx_records.length > 0) {
-        const mx = res.checks.dns.mx_records.filter(Boolean);
-        if (mx.length > 0)
-            info(`MX:         ${mx.slice(0, 3).join(', ')}${mx.length > 3 ? ` (+${mx.length - 3} more)` : ''}`);
-    }
-    if (res.checks.microsoft)
-        info(`Microsoft:  ${res.checks.microsoft.verdict}`);
-}