@myapihq/cli 1.3.6 → 1.3.11

package/dist/commands/account.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 SCHEMA: FlagSchema;
+export declare const EXPOSES: Exposes;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/account.js

@@ -0,0 +1,75 @@
+// `myapi account` — account-scoped operations.
+//
+// Today: mailing-address (CAN-SPAM compliance for transactional email).
+// Future home for any other account-level reads/writes that don't fit
+// `billing` (which owns money) or `keys` (which owns auth credentials).
+import { hq as sdkHq } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, info, printJson } from '../output.js';
+export const SCHEMA = {};
+export const EXPOSES = [
+    'GET /hq/account/mailing-address',
+    'PATCH /hq/account/mailing-address',
+];
+const SUBCOMMAND_USAGE = {
+    'mailing-address': `myapi account mailing-address                       Show current value (null if unset)
+myapi account mailing-address "<address>"            Set the mailing address
+
+The mailing address is required for transactional email (CAN-SPAM):
+\`email message send\` returns MAILING_ADDRESS_REQUIRED until this is set.
+Pass the full postal address as a single string — e.g.
+"123 Main St, Springfield, IL 62701, USA".`,
+};
+async function mailingAddress(args, flags) {
+    const config = requireConfig();
+    // Positional arg present → set. Absent → get.
+    const value = args[0];
+    if (value === undefined) {
+        const res = await sdkHq.getMailingAddress(config.api_key);
+        if (flags.json) {
+            printJson(res);
+            return;
+        }
+        if (res.mailing_address) {
+            info(`Mailing address: ${res.mailing_address}`);
+        }
+        else {
+            info('Mailing address: (not set)');
+            info('Set it with: myapi account mailing-address "<address>"');
+            info('Required for: myapi email message send (CAN-SPAM).');
+        }
+        return;
+    }
+    // Reject obviously bad inputs early — the backend would 400 anyway.
+    const trimmed = value.trim();
+    if (!trimmed) {
+        error('Mailing address must be a non-empty string. Example: "123 Main St, Springfield, IL 62701, USA".');
+    }
+    const res = await sdkHq.setMailingAddress(config.api_key, trimmed);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    success(`Mailing address set: ${res.mailing_address}`);
+}
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi account <subcommand>
+
+Subcommands:
+  mailing-address    Get or set the account's mailing address (CAN-SPAM)`);
+        return;
+    }
+    if (flags.help) {
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi account --help" for the list.`);
+        return;
+    }
+    switch (subcommand) {
+        case 'mailing-address': return mailingAddress(args, flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi account --help" for the list.`);
+    }
+}

package/dist/commands/config.js

@@ -51,8 +51,8 @@ export async function setFunnel(id, _flags, via = 'auth config') {
     if (!orgId)
         error('No default organization set. Run: myapi auth config set-org <id>');
     info('› Validating…');
-    const rawFunnel = await sdkFunnel.getFunnel(config.api_key, orgId, id);
-    const funnelId = rawFunnel.funnel?.id ?? rawFunnel.id;
+    const { funnel } = await sdkFunnel.getFunnel(config.api_key, orgId, id);
+    const funnelId = funnel.id;
     config.default_funnel = funnelId;
     saveConfig(config);
     success(`Default funnel set to: ${funnelId}`);

package/dist/commands/crm/companies.js

@@ -10,6 +10,7 @@ export const EXPOSES = [
     'GET /crm/orgs/{org_id}/companies/{id}',
     'PATCH /crm/orgs/{org_id}/companies/{id}',
     'DELETE /crm/orgs/{org_id}/companies/{id}',
+    'POST /crm/orgs/{org_id}/companies/{id}/restore',
 ];
 export const SCHEMA = {};
 function csv(v) {

package/dist/commands/crm/contacts.js

@@ -10,6 +10,7 @@ export const EXPOSES = [
     'GET /crm/orgs/{org_id}/contacts/{id}',
     'PATCH /crm/orgs/{org_id}/contacts/{id}',
     'DELETE /crm/orgs/{org_id}/contacts/{id}',
+    'POST /crm/orgs/{org_id}/contacts/{id}/restore',
     'GET /crm/orgs/{org_id}/contacts/{id}/events',
 ];
 export const SCHEMA = {};

package/dist/commands/doctor-setup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/doctor-setup.test.js

@@ -0,0 +1,74 @@
+// Unit tests for the doctor's `setup` section augmentation (2026-06-05).
+// Exercises the re-interpretation of backend sections — when the
+// `domains` or `emails` sections come back empty (zero-state), the
+// `setup` augmentation should escalate to actionable warns.
+import { describe, it, expect } from 'vitest';
+import { _setupSection } from './doctor.js';
+function mkReport(sections) {
+    return {
+        org_id: 'org-test',
+        generated_at: '2026-06-05T00:00:00Z',
+        sections,
+        totals: { ok: 0, warn: 0, crit: 0 },
+    };
+}
+function empty(name) {
+    return { name, summary: 'no resources', issues: [] };
+}
+function populated(name) {
+    return { name, summary: 'all checks passed', issues: [{
+                id: 'x', severity: 'ok', scope: name, message: 'something',
+            }] };
+}
+describe('_setupSection', () => {
+    it('returns null when both domains + emails sections are populated', () => {
+        expect(_setupSection(mkReport([populated('domains'), populated('emails')]))).toBeNull();
+    });
+    it('emits both warns when both sections are empty', () => {
+        const s = _setupSection(mkReport([empty('domains'), empty('emails')]));
+        expect(s).not.toBeNull();
+        expect(s.issues.map(i => i.severity)).toEqual(['warn', 'warn']);
+        expect(s.issues[0].message).toMatch(/No domain registered/);
+        expect(s.issues[1].message).toMatch(/No email inbox configured/);
+        expect(s.summary).toBe('2 setup gaps');
+    });
+    it('emits one warn when only emails is empty', () => {
+        const s = _setupSection(mkReport([populated('domains'), empty('emails')]));
+        expect(s).not.toBeNull();
+        expect(s.issues).toHaveLength(1);
+        expect(s.issues[0].scope).toBe('setup/email-inbox');
+        expect(s.summary).toBe('1 setup gap');
+    });
+    it('emits one warn when only domains is empty', () => {
+        const s = _setupSection(mkReport([empty('domains'), populated('emails')]));
+        expect(s).not.toBeNull();
+        expect(s.issues).toHaveLength(1);
+        expect(s.issues[0].scope).toBe('setup/domain');
+    });
+    it('returns null when the backend omits both sections entirely', () => {
+        // If a future backend drops these sections, we shouldn't fabricate
+        // warns out of nothing. Silence is the safe default.
+        expect(_setupSection(mkReport([populated('funnels')]))).toBeNull();
+    });
+    it('attaches actionable hints', () => {
+        const s = _setupSection(mkReport([empty('domains'), empty('emails')]));
+        expect(s.issues[0].hint).toMatch(/myapi domain register/);
+        expect(s.issues[1].hint).toMatch(/myapi email mailbox create/);
+    });
+    it('emits a mailing-address warn when ctx.mailingAddress is null', () => {
+        const s = _setupSection(mkReport([populated('domains'), populated('emails')]), { mailingAddress: null });
+        expect(s).not.toBeNull();
+        expect(s.issues).toHaveLength(1);
+        expect(s.issues[0].scope).toBe('setup/mailing-address');
+        expect(s.issues[0].hint).toMatch(/myapi account mailing-address/);
+    });
+    it('does NOT emit mailing-address warn when set', () => {
+        const s = _setupSection(mkReport([populated('domains'), populated('emails')]), { mailingAddress: '1 Test St, Paris' });
+        expect(s).toBeNull();
+    });
+    it('stays silent when mailing-address fetch failed (undefined)', () => {
+        // undefined = "unknown, infra blip" — don't false-alarm.
+        const s = _setupSection(mkReport([populated('domains'), populated('emails')]), { mailingAddress: undefined });
+        expect(s).toBeNull();
+    });
+});

package/dist/commands/doctor.d.ts

@@ -1,6 +1,11 @@
+import { hq as sdkHq } from '@myapihq/sdk';
 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 interface SetupContext {
+    mailingAddress?: string | null;
+}
+export declare function _setupSection(report: sdkHq.DoctorReport, ctx?: SetupContext): sdkHq.DoctorSection | null;
 export declare function run(_subcommand: string | undefined, _args: string[], flags: Flags): Promise<void>;

package/dist/commands/doctor.js

@@ -27,6 +27,8 @@ export const EXPOSES = [
     'GET /container/orgs/{org_id}/containers',
     'GET /funnel/orgs/{org_id}/funnels',
     'GET /funnel/orgs/{org_id}/funnels/{funnel_id}/pages',
+    // Best-effort read for the setup-gap mailing_address check (CAN-SPAM).
+    'GET /hq/account/mailing-address',
 ];
 export const SCHEMA = {};
 const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
@@ -58,6 +60,54 @@ function fmtIssue(i) {
     const head = `  ${MARK[i.severity] ?? '·'} ${label}${i.message}`;
     return i.hint ? `${head}\n    ${C.dim}→ ${i.hint}${C.reset}` : head;
 }
+export function _setupSection(report, ctx = {}) {
+    const byName = new Map();
+    for (const s of report.sections)
+        byName.set(s.name, s);
+    const issues = [];
+    const dom = byName.get('domains');
+    if (dom && dom.issues.length === 0) {
+        issues.push({
+            id: localIssueId('setup_no_domain', report.org_id),
+            severity: 'warn',
+            scope: 'setup/domain',
+            category: 'setup',
+            message: 'No domain registered for this org',
+            hint: 'Register one with: myapi domain register <domain> && myapi domain assign <domain>',
+        });
+    }
+    const em = byName.get('emails');
+    if (em && em.issues.length === 0) {
+        issues.push({
+            id: localIssueId('setup_no_mailbox', report.org_id),
+            severity: 'warn',
+            scope: 'setup/email-inbox',
+            category: 'setup',
+            message: 'No email inbox configured',
+            hint: 'Create one with: myapi email mailbox create <username>@<your-domain>',
+        });
+    }
+    // Account-scoped (so use report.org_id only for the dedup id, not as
+    // entity scope). Hard-gates every transactional `email send` —
+    // backend returns MAILING_ADDRESS_REQUIRED until set.
+    if (ctx.mailingAddress === null) {
+        issues.push({
+            id: localIssueId('setup_no_mailing_address', report.org_id),
+            severity: 'warn',
+            scope: 'setup/mailing-address',
+            category: 'setup',
+            message: 'Account has no mailing address (CAN-SPAM)',
+            hint: 'Set one with: myapi account mailing-address "<full postal address>"',
+        });
+    }
+    if (issues.length === 0)
+        return null;
+    return {
+        name: 'setup',
+        summary: `${issues.length} setup gap${issues.length === 1 ? '' : 's'}`,
+        issues,
+    };
+}
 // Local DNS-resolution probe for every distinct domain the report names.
 // The backend can verify domain provisioning state from its own egress;
 // this checks whether the operator's network reaches them today — a
@@ -207,7 +257,26 @@ export async function run(_subcommand, _args, flags) {
         error(`doctor endpoint failed: ${e?.message ?? String(e)}`);
     }
     // Local augmentation, appended after the backend's sections by design —
-    // see the file header on why client-observed checks stay grouped at the end.
+    // see the file header on why client-observed checks stay grouped at the
+    // end. `setup` re-interprets the backend's own sections (zero-state →
+    // warn) and comes first; `local network` + `reachability` are liveness
+    // probes that follow.
+    //
+    // Best-effort fetch the account-scoped mailing_address — `null` if
+    // unset, `undefined` if the call fails (transient / permissions / 404
+    // on older backends). `null` triggers the warn; `undefined` is silent
+    // so we don't false-alarm on infra blips.
+    let mailingAddress;
+    try {
+        const res = await sdkHq.getMailingAddress(apiKey);
+        mailingAddress = res?.mailing_address ?? null;
+    }
+    catch {
+        mailingAddress = undefined;
+    }
+    const setup = _setupSection(report, { mailingAddress });
+    if (setup)
+        report.sections.push(setup);
     const localSection = await dnsProbeSection(report);
     if (localSection)
         report.sections.push(localSection);
@@ -266,6 +335,9 @@ Sections returned by the backend today:
   funnels, webhooks, workflows, domains, containers, emails, payments
 
 Local additions:
+  setup         — Flags zero-state config the backend currently reports as
+                  "no resources": no domain registered, no email inbox.
+                  Warnings, not critical — the org may not need them yet.
   local network — DNS resolution from your egress for each domain mentioned.
   reachability  — HTTP GET to every container URL and funnel page; surfaces
                   the status code. Failures are warnings, never critical —

package/dist/commands/domain.d.ts

@@ -13,6 +13,7 @@ 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 mailServerResync(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

@@ -1,4 +1,4 @@
-import { domain as sdkDomain } from '@myapihq/sdk';
+import { domain as sdkDomain, email as sdkEmail } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, info, printTable, printJson } from '../output.js';
 import { formatDate } from '../utils.js';
@@ -16,6 +16,12 @@ export const EXPOSES = [
     'GET /domain/orgs/{org_id}/{domain}/status',
     'POST /domain/orgs/{org_id}/{domain}/email-infra',
     'POST /domain/orgs/{org_id}/{domain}/retry-provisioning',
+    // Mail-server (Stalwart) reprovisioning — distinct from DNS/cert
+    // retry-provisioning above. Call when mailbox-create returns
+    // DOMAIN_NOT_MAIL_READY / MAILBOX_PROVISION_FAILED, or when inbox
+    // reads return "mail server error" on a domain whose
+    // email_infra_ready=true.
+    'POST /email/orgs/{org_id}/domains/{domain}/mail-server-resync',
     'GET /domain/orgs/{org_id}/{domain}/records',
     'POST /domain/orgs/{org_id}/{domain}/records',
     'GET /domain/orgs/{org_id}/{domain}/records/{record_id}',
@@ -312,6 +318,24 @@ export async function retryProvisioning(domainArg, flags) {
         info(res.next_step);
     info(`Track with: myapi domain status ${domain} --watch`);
 }
+// Re-runs mail-server (Stalwart) provisioning for a domain. Distinct from
+// retry-provisioning above — that re-runs the DNS / cert side; this one
+// re-runs the IMAP/SMTP / mail-store side. Idempotent. Use when:
+//   - `email mailbox create` returns DOMAIN_NOT_MAIL_READY / MAILBOX_PROVISION_FAILED
+//   - `email message inbox <addr>` returns "mail server error" on a domain
+//     whose `email_infra_ready=true` according to `domain list`.
+export async function mailServerResync(domainArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi domain mail-server-resync <domain> [--org <id>]');
+    const domain = requireDomain(domainArg, flags, config, 'myapi domain mail-server-resync <domain> [--org <id>]');
+    const res = await sdkEmail.mailServerResync(config.api_key, orgId, domain);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    success(`Mail-server resync triggered for ${domain}`);
+    info('Retry mailbox-create / inbox reads in a few seconds.');
+}
 export async function settings(domainArg, flags) {
     const config = requireConfig();
     const orgId = requireOrg(flags, config, 'myapi domain settings <domain> [--org <id>]');
@@ -591,6 +615,17 @@ Re-runs domain provisioning when status=infra_error and error_detail.retryable=t
 The CLI surfaces the retry hint automatically when status renders infra_error.
 
 After triggering retry, poll: myapi domain status <domain> --watch`,
+    'mail-server-resync': `myapi domain mail-server-resync <domain> [--org <id>]
+
+Re-runs the mail-server (Stalwart) provisioning for a domain. Distinct
+from "retry-provisioning" — that re-runs the DNS / cert side; this one
+re-runs the IMAP / SMTP / mail-store side. Idempotent.
+
+Use when:
+  - "email mailbox create" returns DOMAIN_NOT_MAIL_READY or MAILBOX_PROVISION_FAILED
+  - "email message inbox <addr>" returns "mail server error" but
+    "domain list" shows email_infra_ready=true for that domain
+  - The fix-path called out in backend-email-postdeploy-findings-2026-06-05`,
     '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)
@@ -610,6 +645,7 @@ Subcommands:
   email-setup      Opt in to MyAPI-managed email on a subdomain (default: mail.<domain>)
   import           Bring your own domain (BYOD) — registrar-agnostic
   list             List domains
+  mail-server-resync  Re-run Stalwart mail-server provisioning for a domain (fixes inbox/create on broken domains)
   records          Manage DNS records in the zone (list / get / create / update / delete)
   register         Register a domain
   renew            Renew a registered domain for another period
@@ -643,6 +679,7 @@ Tip: Set defaults with "myapi config set-org <id>" / "set-domain <domain>" to sk
         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 'mail-server-resync': return mailServerResync(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/commands/email/mailbox.js

@@ -4,6 +4,7 @@ import { success, error, printTable, info } from '../../output.js';
 export const EXPOSES = [
     'POST /email/mailboxes/create',
     'GET /email/mailboxes',
+    'DELETE /email/mailboxes/{address}',
     'PUT /email/mailboxes/{address}/forwarding',
     'DELETE /email/mailboxes/{address}/forwarding',
     'POST /email/sending/activate',
@@ -70,6 +71,17 @@ async function clearForwarding(address, _flags) {
     await sdkEmail.deleteForwarding(config.api_key, address);
     success(`Forwarding cleared for ${address}`);
 }
+async function del(address, _flags) {
+    const config = requireConfig();
+    if (!address)
+        error('Missing required arguments.\nUsage: myapi email mailbox delete <user@domain>');
+    // Backend is idempotent — 204 whether or not the mailbox existed. So we
+    // don't pre-check existence; just call delete and report success. The
+    // 409 MAILBOX_IN_USE case bubbles up as an API error with a clear
+    // pointer to pause the campaign first.
+    await sdkEmail.deleteMailbox(config.api_key, address);
+    success(`Mailbox deleted: ${address}`);
+}
 const USAGE = {
     'create': `myapi email mailbox create <user@domain> [--display-name <name>]
        myapi email mailbox create --username <u> --domain <d> [--display-name <name>]
@@ -83,6 +95,11 @@ matches the rest of the CLI ("first required arg is positional").`,
                         org (orphaned mailboxes — domain was unassigned
                         without first deleting them).`,
     'activate-sending': 'myapi email mailbox activate-sending --address <email>',
+    'delete': `myapi email mailbox delete <user@domain>
+
+Idempotent — returns success whether or not the mailbox existed.
+Refuses with MAILBOX_IN_USE when an active or paused campaign still
+sends from this address; pause/delete the campaign first.`,
     'set-forwarding': `myapi email mailbox set-forwarding <user@domain> <forward-to@domain>
 
 Redirects a copy of every incoming message to an external address
@@ -97,6 +114,7 @@ Subcommands:
   activate-sending   Activate outbound sending for a mailbox
   clear-forwarding   Stop forwarding for a mailbox
   create             Create a mailbox (positional <user@domain> or --username/--domain)
+  delete             Delete a mailbox (idempotent; rejects if a campaign still uses it)
   list               List mailboxes on a domain (--domain) or orphaned ones (--filter unassigned)
   set-forwarding     Forward a copy of incoming mail to an external address`);
         return;
@@ -112,6 +130,7 @@ Subcommands:
     switch (sub) {
         case 'create': return create(args[0], flags);
         case 'list': return list(flags);
+        case 'delete': return del(args[0], flags);
         case 'activate-sending': return activateSending(flags);
         case 'set-forwarding': return setForwarding(args[0], args[1], flags);
         case 'clear-forwarding': return clearForwarding(args[0], flags);

package/dist/commands/funnel.d.ts

@@ -9,6 +9,7 @@ export declare function get(id: string, flags: Flags): Promise<void>;
 export declare function del(id: string, flags: Flags): Promise<void>;
 export declare function pages(funnelArg: string, flags: Flags): Promise<void>;
 export declare function push(slug: string, flags: Flags): Promise<void>;
+export declare function formCmd(funnelArg: string | undefined, flags: Flags): Promise<void>;
 export declare function verify(slug: string, flags: Flags): Promise<void>;
 export declare function publish(dir: string, flags: Flags): Promise<void>;
 export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;