@myapihq/cli 1.2.2 → 1.2.4

package/dist/commands/domain.d.ts

@@ -11,6 +11,8 @@ 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>;
 export declare function status(domainArg: string, flags: Flags): Promise<void>;
+export declare function emailSetup(domainArg: string, flags: Flags): Promise<void>;
+export declare function retryProvisioning(domainArg: string, flags: Flags): Promise<void>;
 export declare function settings(domainArg: string, flags: Flags): Promise<void>;
 export declare function updateSettings(domainArg: string, flags: Flags): Promise<void>;
 export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/domain.js

@@ -14,6 +14,8 @@ export const EXPOSES = [
     'GET /domain/orgs/{org_id}/{domain}/settings',
     'POST /domain/orgs/{org_id}/{domain}/settings',
     'GET /domain/orgs/{org_id}/{domain}/status',
+    'POST /domain/orgs/{org_id}/{domain}/email-infra',
+    'POST /domain/orgs/{org_id}/{domain}/retry-provisioning',
 ];
 export const SCHEMA = {
     org: 'string',
@@ -46,6 +48,8 @@ export const SCHEMA = {
     priority: 'number',
     proxied: 'boolean',
     yes: 'boolean',
+    // Email-infra opt-in
+    subdomain: 'string',
 };
 export async function check(domainArg, flags) {
     const config = requireConfig();
@@ -169,8 +173,10 @@ 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']);
+// Terminal states — stop polling under --watch. `infra_error` is included
+// because watching past it is pointless — the user has to act (retry or
+// contact support); a re-watch after retry is the natural next step.
+const TERMINAL_STATUSES = new Set(['active', 'failed', 'error', 'expired', 'infra_error']);
 export async function status(domainArg, flags) {
     const config = requireConfig();
     const orgId = requireOrg(flags, config, 'myapi domain status <domain> [--org <id>] [--watch]');
@@ -212,13 +218,63 @@ function renderStatus(res) {
     info(`Status:  ${res.status}`);
     if (res.expires_at)
         info(`Expires: ${formatDate(res.expires_at)}`);
+    if (res.dns_active !== undefined)
+        info(`DNS:     ${res.dns_active ? 'active' : 'pending'}`);
+    if (res.email_infra) {
+        const where = res.email_subdomain ? ` on ${res.email_subdomain}` : '';
+        info(`Email:   ${res.email_infra}${where}`);
+    }
     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 === 'infra_error' && res.error_detail) {
+        info(`  Failed step:  ${res.error_detail.failed_step}`);
+        info(`  Message:      ${res.error_detail.message}`);
+        if (res.error_detail.attempt_count !== undefined) {
+            const last = res.error_detail.last_attempt_at ? `; last try ${res.error_detail.last_attempt_at}` : '';
+            info(`  Attempts:     ${res.error_detail.attempt_count}${last}`);
+        }
+        if (res.error_detail.retryable) {
+            info(`  → myapi domain retry-provisioning ${res.domain}`);
+        }
+        else {
+            info('  Not retryable — contact support.');
+        }
+    }
     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.');
     }
 }
+// ── Email infra opt-in + retry-provisioning ──────────────────────────────────
+export async function emailSetup(domainArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi domain email-setup <domain> [--subdomain <label>] [--org <id>]');
+    const domain = requireDomain(domainArg, flags, config, 'myapi domain email-setup <domain> [--subdomain <label>] [--org <id>]');
+    const subdomain = typeof flags.subdomain === 'string' ? flags.subdomain : undefined;
+    const res = await sdkDomain.setupEmailInfra(config.api_key, orgId, domain, subdomain);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    success(`Email infra provisioning on ${res.email_subdomain} (state: ${res.email_infra})`);
+    if (res.next_step)
+        info(res.next_step);
+    info(`Track with: myapi domain status ${domain} --watch`);
+}
+export async function retryProvisioning(domainArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi domain retry-provisioning <domain> [--org <id>]');
+    const domain = requireDomain(domainArg, flags, config, 'myapi domain retry-provisioning <domain> [--org <id>]');
+    const res = await sdkDomain.retryProvisioning(config.api_key, orgId, domain);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    success(`Retry triggered for ${res.domain}`);
+    if (res.next_step)
+        info(res.next_step);
+    info(`Track with: myapi domain status ${domain} --watch`);
+}
 export async function settings(domainArg, flags) {
     const config = requireConfig();
     const orgId = requireOrg(flags, config, 'myapi domain settings <domain> [--org <id>]');
@@ -472,6 +528,24 @@ To transfer to a different org: unassign first, then assign to the new org.`,
 Gets current edge/CDN settings (security level, browser check, cache).
 Use "myapi domain update-settings" to change them.`,
     'records': RECORDS_HELP,
+    'email-setup': `myapi domain email-setup <domain> [--subdomain <label>] [--org <id>]
+
+Opts in to MyAPI-managed outbound email on a subdomain of the domain.
+The apex is never touched — this is safe to run on a domain whose apex
+email is served by Google Workspace / Microsoft 365 / your existing provider.
+
+Defaults the subdomain to "mail" (i.e. mail.<domain>). Pass --subdomain to
+override (e.g. --subdomain=notifications for notifications.<domain>).
+
+Backend provisions an SES identity on <subdomain>.<domain> and writes
+DKIM / SPF / DMARC records to the CF zone. Track readiness via:
+  myapi domain status <domain> --watch`,
+    'retry-provisioning': `myapi domain retry-provisioning <domain> [--org <id>]
+
+Re-runs domain provisioning when status=infra_error and error_detail.retryable=true.
+The CLI surfaces the retry hint automatically when status renders infra_error.
+
+After triggering retry, poll: myapi domain status <domain> --watch`,
     '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)
@@ -497,6 +571,8 @@ Subcommands:
   settings         Get edge/CDN settings
   update-settings  Update edge/CDN settings
   records          Manage DNS records in the zone (list / get / create / update / delete)
+  email-setup      Opt in to MyAPI-managed email on a subdomain (default: mail.<domain>)
+  retry-provisioning  Re-run provisioning when status=infra_error and the failure is retryable
 
 Tip: Set defaults with "myapi config set-org <id>" / "set-domain <domain>" to skip flags on every command.`);
         return;
@@ -521,6 +597,8 @@ Tip: Set defaults with "myapi config set-org <id>" / "set-domain <domain>" to sk
         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);
+        case 'email-setup': return emailSetup(args[0], flags);
+        case 'retry-provisioning': return retryProvisioning(args[0], flags);
         default: error(`Unknown subcommand: ${subcommand}. Run "myapi domain --help" for a list of valid subcommands.`);
     }
 }

package/dist/index.js

@@ -88,13 +88,26 @@ const ERROR_MESSAGES = {
     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.',
+    CF_API_ERROR: 'Cloudflare API error.',
     // 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.
 };
-function friendlyError(code) {
-    return ERROR_MESSAGES[code] || code;
+function friendlyError(err) {
+    const body = err.body ?? {};
+    // CF_API_ERROR: the cf_message already includes a "Cloudflare API error"
+    // prefix, so use it verbatim (with cf_status if present) instead of doubling.
+    if (err.code === 'CF_API_ERROR' && typeof body.cf_message === 'string') {
+        return typeof body.cf_status === 'number'
+            ? `${body.cf_message} (HTTP ${body.cf_status})`
+            : body.cf_message;
+    }
+    const base = ERROR_MESSAGES[err.code] || err.code;
+    // Generic fallback: append the backend's `message` when it adds info beyond
+    // the friendly mapping. Future per-service detail fields can be added here.
+    if (err.detail && err.detail !== base)
+        return `${base} — ${err.detail}`;
+    return base;
 }
 async function main() {
     // Shell autocomplete: if invoked by the shell with completion env vars,
@@ -250,7 +263,7 @@ async function main() {
                 }
             }
             else
-                error(friendlyError(err.code) || err.message);
+                error(friendlyError(err) || err.message);
         }
         else {
             // Don't JSON.stringify Error instances — that returns "{}" because

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

@@ -59,6 +59,8 @@ Resolution at register time (highest wins): `--registrant-json` → per-field fl
 | `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 |
+| `myapi domain email-setup <domain> [--subdomain <label>]` | Opt in to MyAPI-managed email on a subdomain (default: `mail.<domain>`). Apex is never touched |
+| `myapi domain retry-provisioning <domain>` | Re-run provisioning when status=infra_error and error_detail.retryable=true |
 <!-- generated:end -->
 
 ## Examples
@@ -91,6 +93,14 @@ 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'
+
+# Opt in to MyAPI email on a subdomain (apex Google Workspace stays untouched)
+myapi domain email-setup example.com                # → mail.example.com
+myapi domain email-setup example.com --subdomain=notifications
+
+# Recover from infra_error
+myapi domain status example.com                     # CLI prints the retry hint
+myapi domain retry-provisioning example.com
 ```
 
 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.2",
+  "version": "1.2.4",
   "description": "MyAPI command-line interface",
   "type": "module",
   "files": [
@@ -27,7 +27,7 @@
     "lint:changelog": "node ../../scripts/lint-changelog.js"
   },
   "dependencies": {
-    "@myapihq/sdk": "^1.2.2",
+    "@myapihq/sdk": "^1.2.4",
     "omelette": "^0.4.17"
   },
   "devDependencies": {