@myapihq/cli 2.7.1 → 2.8.0

package/dist/commands/account.js

@@ -25,6 +25,21 @@ export const SCHEMA = {
     'no-skills': 'boolean',
     anonymous: 'boolean',
     anon: 'boolean',
+    // Flags belonging to SUBCOMMANDS of `account`. They have to be declared here
+    // because the foreign-flag check runs against the top-level command's schema
+    // and cannot see subcommand parsers. Omitting them made the CLI print
+    // "--registrant-json is not a flag of `myapi account` — the value was
+    // ignored" and then use the value anyway: a warning that was itself false,
+    // which is worse than the missing check it was added to provide.
+    '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-code': 'string',
 };
 export const HELP = `Usage: myapi account <subcommand>
 

package/dist/commands/audience.js

@@ -15,6 +15,8 @@ export const SCHEMA = {
     org: 'string',
     name: 'string',
     description: 'string',
+    from: 'string',
+    // Deprecated alias for --from; undocumented, removable next minor.
     source: 'string',
     filter: 'string',
     limit: 'number',
@@ -47,11 +49,11 @@ function summarizeAudience(a) {
 }
 async function create(nameArg, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi audience create <name> --source <people|company> --filter <json>');
+    const orgId = requireOrg(flags, config, 'myapi audience create <name> --from <people|company> --filter <json>');
     const name = nameArg || flags.name;
     if (!name)
-        error('Missing required argument <name>.\nUsage: myapi audience create <name> --source <people|company> --filter <json>');
-    const source = flags.source;
+        error('Missing required argument <name>.\nUsage: myapi audience create <name> --from <people|company> --filter <json>');
+    const source = (flags.from ?? flags.source);
     if (source !== 'people' && source !== 'company') {
         error(`--source must be "people" or "company" (got: ${source ?? '<missing>'}).`);
     }
@@ -76,7 +78,7 @@ async function list(flags) {
     }
     printTable(res.map(summarizeAudience), {
         flags,
-        empty: 'No audiences yet. Create one with: myapi audience create <name> --source <people|company> --filter <json>',
+        empty: 'No audiences yet. Create one with: myapi audience create <name> --from <people|company> --filter <json>',
     });
 }
 async function get(id, flags) {
@@ -168,7 +170,7 @@ async function refresh(id, flags) {
     success(`Refreshed. ${res.previous} → ${res.total} (${sign}${res.delta})`);
 }
 const SUBCOMMAND_USAGE = {
-    'create': `myapi audience create <name> --source <people|company> --filter <json> [--description <text>] [--org <id>]
+    'create': `myapi audience create <name> --from <people|company> --filter <json> [--description <text>] [--org <id>]
 
 The Goldfox filter shape is shared across people/company/audience:
   {

package/dist/commands/crm/companies.js

@@ -3,7 +3,7 @@ import { crm } from '@myapihq/sdk';
 import { requireConfig } from '../../config.js';
 import { success, error, info, printTable, printJson } from '../../output.js';
 import { requireOrg, requireArg } from '../../helpers.js';
-import { pageLine } from './pagination.js';
+import { pageLine, originFlag } from './pagination.js';
 export const EXPOSES = [
     'POST /crm/orgs/{org_id}/companies',
     'POST /crm/orgs/{org_id}/companies/promote',
@@ -32,7 +32,7 @@ function parseCustom(v) {
 function buildSearchFilter(flags) {
     return {
         lifecycle_stage: csv(flags.stage),
-        source: csv(flags.source),
+        source: csv(originFlag(flags)),
         domain: typeof flags.domain === 'string' ? flags.domain : undefined,
         include_deleted: flags['include-deleted'] === true || undefined,
         limit: typeof flags.limit === 'number' ? flags.limit : undefined,
@@ -144,11 +144,11 @@ async function promote(domain, flags) {
 // ── Dispatcher ──────────────────────────────────────────────────────────
 const SUBCOMMAND_USAGE = {
     list: 'myapi crm companies list [--limit N] [--offset N] [--org <id>] [--json]',
-    search: `myapi crm companies search [--stage <csv>] [--source <csv>] [--domain <d>]
+    search: `myapi crm companies search [--stage <csv>] [--origin <csv>] [--domain <d>]
        [--include-deleted] [--limit N] [--offset N] [--org <id>] [--json]
 
   --stage   cold, warm, qualified, customer, churned
-  --source  goldfox, email, pixel, webhook, manual`,
+  --origin  goldfox, email, pixel, webhook, manual`,
     create: 'myapi crm companies create <domain> [--name <n>] [--stage <s>] [--custom-json <json>] [--org <id>]',
     get: 'myapi crm companies get <id> [--org <id>]',
     update: 'myapi crm companies update <id> [--stage <s>] [--name <n>] [--custom-json <json>] [--org <id>]',

package/dist/commands/crm/contacts.js

@@ -3,7 +3,7 @@ import { crm } from '@myapihq/sdk';
 import { requireConfig } from '../../config.js';
 import { success, error, info, printTable, printJson } from '../../output.js';
 import { requireOrg, requireArg } from '../../helpers.js';
-import { pageLine } from './pagination.js';
+import { pageLine, originFlag } from './pagination.js';
 export const EXPOSES = [
     'POST /crm/orgs/{org_id}/contacts',
     'POST /crm/orgs/{org_id}/contacts/promote',
@@ -35,7 +35,7 @@ function parseCustom(v) {
 function buildSearchFilter(flags) {
     return {
         lifecycle_stage: csv(flags.stage),
-        source: csv(flags.source),
+        source: csv(originFlag(flags)),
         email: typeof flags.email === 'string' ? flags.email : undefined,
         company_id: typeof flags['company-id'] === 'string' ? flags['company-id'] : undefined,
         min_last_engagement_days: typeof flags['min-last-engagement-days'] === 'number' ? flags['min-last-engagement-days'] : undefined,
@@ -179,12 +179,12 @@ async function events(id, flags) {
 // ── Dispatcher ──────────────────────────────────────────────────────────
 const SUBCOMMAND_USAGE = {
     list: 'myapi crm contacts list [--limit N] [--offset N] [--org <id>] [--json]',
-    search: `myapi crm contacts search [--stage <csv>] [--source <csv>] [--email <e>]
+    search: `myapi crm contacts search [--stage <csv>] [--origin <csv>] [--email <e>]
        [--company-id <id>] [--min-last-engagement-days N] [--max-last-engagement-days N]
        [--include-deleted] [--limit N] [--offset N] [--org <id>] [--json]
 
   --stage     cold, warm, qualified, customer, churned
-  --source    goldfox, email, pixel, webhook, manual
+  --origin    goldfox, email, pixel, webhook, manual
 
   Engagement filters:
     --min-last-engagement-days N   contacts engaged within N days

package/dist/commands/crm/index.js

@@ -16,6 +16,9 @@ export const SCHEMA = {
     'last-name': 'string',
     name: 'string',
     stage: 'string',
+    origin: 'string',
+    // Deprecated alias for --origin. Kept so existing scripts keep working;
+    // undocumented, and removable no earlier than the next minor.
     source: 'string',
     'company-id': 'string',
     'custom-json': 'string',

package/dist/commands/crm/origin-flag.test.d.ts

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

package/dist/commands/crm/origin-flag.test.js

@@ -0,0 +1,38 @@
+// `--source` meant five different things across the CLI: a container build
+// context, a git merge branch, an audience dataset, a task origin, and a CRM
+// provenance enum. An agent that learned it in one place carried a wrong prior
+// into the others, and no linter could catch it — `--source` really is valid
+// for every one of those commands, so nothing was ever "unknown".
+//
+// It is `--origin` for provenance now (crm, task) and `--from` for the
+// audience dataset. `--source` keeps its container meaning, and stays on
+// `git merge` where `--target` anchors it and the pair is idiomatic.
+//
+// The old spellings still work, undocumented, so nobody's scripts break.
+import { describe, it, expect } from 'vitest';
+import { originFlag } from './pagination.js';
+describe('originFlag', () => {
+    it('reads the new flag', () => {
+        expect(originFlag({ origin: 'webhook' })).toBe('webhook');
+    });
+    it('still accepts the old one', () => {
+        expect(originFlag({ source: 'webhook' })).toBe('webhook');
+    });
+    // Someone mid-migration may have both in a script. The new name is the
+    // one they meant.
+    it('prefers --origin when both are given', () => {
+        expect(originFlag({ origin: 'manual', source: 'webhook' })).toBe('manual');
+    });
+    it('is undefined when neither is given', () => {
+        expect(originFlag({})).toBeUndefined();
+    });
+    // csv() downstream splits this; the helper must not mangle it.
+    it('passes a comma-separated list through untouched', () => {
+        expect(originFlag({ origin: 'goldfox,webhook' })).toBe('goldfox,webhook');
+    });
+    // An explicitly empty --origin is a real (if useless) input, and must not
+    // silently fall through to a stale --source in the same command.
+    it('does not fall back when --origin is present but empty', () => {
+        expect(originFlag({ origin: '', source: 'webhook' })).toBe('');
+    });
+});

package/dist/commands/crm/pagination.d.ts

@@ -1,3 +1,5 @@
+import { type Flags } from '../../helpers.js';
 import type { Exposes } from '../../exposes.js';
 export declare const EXPOSES: Exposes;
+export declare function originFlag(flags: Flags): string | boolean | number | undefined;
 export declare function pageLine(returned: number, total: number | undefined, hasMore: boolean | undefined, singular: string, plural: string): string;

package/dist/commands/crm/pagination.js

@@ -18,6 +18,15 @@
 // exempted, so the coverage gate's "every module states its surface" rule
 // stays absolute.
 export const EXPOSES = [];
+// --source meant five different things across the CLI: a build context, a
+// merge branch, a dataset, a task origin, and this — where a contact came
+// from. An agent that learned it once carried a wrong prior everywhere else,
+// and no linter could catch it because --source really is valid for each.
+//
+// It is --origin here now. The old name still works and is undocumented.
+export function originFlag(flags) {
+    return flags.origin !== undefined ? flags.origin : flags.source;
+}
 // "3 contacts" · "3 of 128 contacts" · "3 of 128 contacts (more available)".
 //
 // `total` is only rendered when the API supplied it, and the more-available

package/dist/commands/domain.js

@@ -89,6 +89,17 @@ export async function check(domainArg, flags) {
     else {
         const msg = typeof res.message === 'string' ? res.message : res.message ? JSON.stringify(res.message) : 'Not available';
         info(`${domain} — ${msg} ✗`);
+        // "This TLD is not currently supported" reads as a dead end, and a team
+        // building for Switzerland took it as one and settled for a .com. It is
+        // not: registering elsewhere and importing the nameservers gives the same
+        // DNS, SSL and mail behaviour, with no registrar credentials needed. The
+        // answer belongs in the same message as the refusal.
+        if (/TLD is not (currently )?supported|not supported/i.test(msg)) {
+            info('');
+            info(`→ You can still use ${domain} on MyAPI. Register it with any registrar,`);
+            info(`  point its nameservers at MyAPI, then:  myapi domain import ${domain}`);
+            info('  DNS, SSL and mail records work the same way afterwards.');
+        }
     }
 }
 export async function register(domainArg, flags) {

package/dist/commands/feedback.d.ts

@@ -0,0 +1,10 @@
+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 list(flags: Flags): Promise<void>;
+export declare function create(bodyArg: string | undefined, flags: Flags): Promise<void>;
+export declare function resolve(id: string, flags: Flags): Promise<void>;
+export declare function widget(sub: string | undefined, arg: string | undefined, flags: Flags): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/feedback.js

@@ -0,0 +1,173 @@
+// `myapi feedback` — collect what the people using your product tell you.
+//
+// The slot shipped on 2026-07-28 with five endpoints and no CLI. A primitive
+// with no surface is one nobody finds, which is the failure this repo spent a
+// week fixing: two customers concluded a shipped capability did not exist
+// because nothing they read mentioned it.
+import { feedback as sdkFeedback } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, info, printTable, printJson, banner } from '../output.js';
+import { formatDate } from '../utils.js';
+import { requireOrg, requireArg, confirmDestructive } from '../helpers.js';
+export const EXPOSES = [
+    'GET /feedback/orgs/{org_id}/items',
+    'POST /feedback/orgs/{org_id}/items',
+    'POST /feedback/orgs/{org_id}/items/{id}/resolve',
+    'POST /feedback/orgs/{org_id}/widgets',
+    'DELETE /feedback/orgs/{org_id}/widgets/{id}',
+];
+export const SCHEMA = {
+    kind: 'string',
+    status: 'string',
+    body: 'string',
+    'page-url': 'string',
+    route: 'string',
+    origins: 'string',
+};
+const KINDS = ['bug', 'idea', 'praise', 'confusion', 'other'];
+export async function list(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi feedback list [--kind <k>] [--status open|resolved] [--org <id>]');
+    if (flags.kind !== undefined && !KINDS.includes(flags.kind)) {
+        error(`Invalid --kind "${flags.kind}". Use one of: ${KINDS.join(', ')}.`);
+    }
+    if (flags.status !== undefined && flags.status !== 'open' && flags.status !== 'resolved') {
+        error(`Invalid --status "${flags.status}". Use "open" or "resolved".`);
+    }
+    const page = await sdkFeedback.listFeedback(config.api_key, orgId, {
+        kind: flags.kind,
+        status: flags.status,
+        limit: typeof flags.limit === 'number' ? flags.limit : undefined,
+        offset: typeof flags.offset === 'number' ? flags.offset : undefined,
+    });
+    if (flags.json) {
+        printJson(page);
+        return;
+    }
+    // `total` here is the match count, not the page size — the platform states
+    // that explicitly, having been bitten by the opposite in CRM search.
+    const shown = page.items?.length ?? 0;
+    info(shown === page.total ? `${shown} item${shown === 1 ? '' : 's'}` : `${shown} of ${page.total} items`);
+    printTable((page.items ?? []).map(i => ({
+        id: i.id,
+        kind: i.kind,
+        status: i.status,
+        body: i.body.length > 60 ? `${i.body.slice(0, 57)}…` : i.body,
+        route: i.route ?? i.page_url ?? '',
+        created: i.created_at ? formatDate(i.created_at) : '',
+    })), { flags, empty: 'No feedback yet. Put a widget on a page: myapi feedback widget create <name>' });
+    if (page.has_more)
+        info('More available — raise --limit or pass --offset.');
+}
+export async function create(bodyArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi feedback create "<text>" --kind <k> [--org <id>]');
+    const body = bodyArg ?? flags.body;
+    requireArg(body, 'text', 'myapi feedback create "<text>" --kind bug');
+    const kind = flags.kind ?? 'other';
+    if (!KINDS.includes(kind)) {
+        error(`Invalid --kind "${kind}". Use one of: ${KINDS.join(', ')}.\n\n→ Kind is what the PERSON says it is. "bug" is a claim that the product is broken; do not infer it from the wording.`);
+    }
+    const item = await sdkFeedback.createFeedback(config.api_key, orgId, {
+        kind: kind,
+        body: body,
+        page_url: typeof flags['page-url'] === 'string' ? flags['page-url'] : undefined,
+        route: typeof flags.route === 'string' ? flags.route : undefined,
+    });
+    if (flags.json) {
+        printJson(item);
+        return;
+    }
+    success(`Recorded ${item.kind}: ${item.id}`);
+}
+export async function resolve(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi feedback resolve <id> [--org <id>]');
+    if (!id)
+        error('Missing id.\nUsage: myapi feedback resolve <id>');
+    await sdkFeedback.resolveFeedback(config.api_key, orgId, id);
+    // Already-resolved and not-found answer identically, so this is not proof
+    // the id existed. Say so rather than implying a state change happened.
+    success(`Resolved ${id}`);
+    info('(An unknown id answers the same way, so this is not confirmation the item existed.)');
+}
+export async function widget(sub, arg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi feedback widget create <name> | revoke <id>');
+    if (sub === 'create') {
+        requireArg(arg, 'name', 'myapi feedback widget create <name> [--origins a.com,b.com]');
+        const origins = typeof flags.origins === 'string'
+            ? flags.origins.split(',').map(s => s.trim()).filter(Boolean)
+            : undefined;
+        const w = await sdkFeedback.createWidget(config.api_key, orgId, arg, origins);
+        if (flags.json) {
+            printJson(w);
+            return;
+        }
+        success(`Widget created: ${w.id}`);
+        info(`Key:  ${w.key}`);
+        info('');
+        // Saying this plainly matters: a value that looks like a credential and is
+        // not one gets treated as a secret, and then nobody puts it in the page.
+        info('This key is PUBLIC. It ships in your page source and authenticates nobody —');
+        info('it names your org so a visitor can submit without signing in.');
+        if (!origins?.length) {
+            banner('No --origins set, so any site can post through this key. Set them unless that is intended.');
+        }
+        return;
+    }
+    if (sub === 'revoke') {
+        requireArg(arg, 'id', 'myapi feedback widget revoke <id>');
+        await confirmDestructive(flags, `revoke widget ${arg} (submissions with it stop immediately)`, 'myapi feedback widget revoke <id> [--yes] [--org <id>]');
+        await sdkFeedback.revokeWidget(config.api_key, orgId, arg);
+        success(`Widget ${arg} revoked`);
+        info('Feedback already collected through it is kept.');
+        return;
+    }
+    error('Usage: myapi feedback widget create <name> [--origins <list>]\n       myapi feedback widget revoke <id>');
+}
+const SUBCOMMAND_USAGE = {
+    'list': `myapi feedback list [--kind bug|idea|praise|confusion|other] [--status open|resolved]
+       [--limit N] [--offset N] [--org <id>] [--json]
+
+Newest first. \`total\` is the number of matches, not the page size.`,
+    'create': `myapi feedback create "<text>" --kind <k> [--page-url <url>] [--route <path>] [--org <id>]
+
+--kind is what the person reporting says it is, not what the text sounds like.`,
+    'resolve': 'myapi feedback resolve <id> [--org <id>]',
+    'widget': `myapi feedback widget create <name> [--origins a.com,b.com] [--org <id>]
+       myapi feedback widget revoke <id> [--yes] [--org <id>]
+
+The key a widget mints is PUBLIC — it ships in page source and authenticates
+nobody. --origins stops another site posting through it.`,
+};
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi feedback <subcommand>
+
+Collect feedback from the people using what you built. A widget key lets a
+page submit without a credential; you list, filter and resolve the results.
+
+Subcommands:
+  create "<text>"      Record one piece of feedback (--kind bug|idea|praise|confusion|other)
+  list                 List feedback, newest first (--kind, --status, --limit, --offset)
+  resolve <id>         Close a piece of feedback
+  widget create <name> Mint a PUBLIC widget key for a site (--origins to restrict)
+  widget revoke <id>   Revoke a widget key; collected feedback is kept
+
+All commands accept --org <id> (or set default: myapi config set-org <id>).`);
+        return;
+    }
+    if (flags.help) {
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        info(usage ? `Usage: ${usage}` : `Unknown subcommand: ${subcommand}. Run "myapi feedback --help" for the list.`);
+        return;
+    }
+    switch (subcommand) {
+        case 'create': return create(args[0], flags);
+        case 'list': return list(flags);
+        case 'resolve': return resolve(args[0], flags);
+        case 'widget': return widget(args[0], args[1], flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi feedback --help" for a list of valid subcommands.`);
+    }
+}

package/dist/commands/flag-reachability.test.d.ts

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