@myapihq/cli 1.1.0-wip.4 → 1.2.0

package/dist/commands/org.js

@@ -4,6 +4,17 @@ import { success, error, printTable, printJson, info } from '../output.js';
 import { confirm } from '../prompt.js';
 import { formatDate, pollJob } from '../utils.js';
 import { requireOrg, requireArg } from '../helpers.js';
+export const EXPOSES = [
+    'POST /hq/orgs',
+    'GET /hq/orgs',
+    'GET /hq/orgs/{org_id}',
+    'PATCH /hq/orgs/{org_id}',
+    'DELETE /hq/orgs/{org_id}',
+    'POST /hq/org-imports',
+    'GET /hq/org-imports/{import_id}',
+    'POST /hq/org-imports/{import_id}/confirm',
+    'GET /funnel/orgs/{org_id}/funnels',
+];
 export const SCHEMA = {
     name: 'string',
     tagline: 'string',
@@ -107,6 +118,38 @@ export async function del(id, _flags) {
     await hq.deleteOrg(config.api_key, id);
     success(`Org ${id} deleted`);
 }
+// Update one or more fields of an org. At least one --flag must be supplied;
+// otherwise we have nothing to send (the SDK accepts a partial payload but
+// PATCH with an empty body would be a wasted round-trip and a confusing
+// no-op for the user).
+export async function update(restArgs, flags) {
+    const config = requireConfig();
+    const orgId = restArgs[0] || flags.org || config.default_org;
+    if (!orgId)
+        error('Missing org id. Usage: myapi org update <id> [--field <value> ...]\n(Or set a default: myapi config set-org <id>)');
+    const payload = {};
+    if (flags.name)
+        payload.name = flags.name;
+    if (flags.tagline)
+        payload.tagline = flags.tagline;
+    if (flags.description)
+        payload.description = flags.description;
+    if (flags['business-sector'])
+        payload.business_sector = flags['business-sector'];
+    if (flags['logo-url'])
+        payload.logo_url = flags['logo-url'];
+    if (Object.keys(payload).length === 0) {
+        error('No update flags provided. Pass at least one of: --name, --tagline, --description, --business-sector, --logo-url.');
+    }
+    const updated = await hq.updateOrg(config.api_key, orgId, payload);
+    if (flags.json) {
+        printJson(updated);
+        return;
+    }
+    success(`Org ${updated.id} updated`);
+    const fields = Object.keys(payload).map(k => `${k} = ${payload[k]}`);
+    info(`  ${fields.join('\n  ')}`);
+}
 export async function importOrg(args, flags) {
     const config = requireConfig();
     const domain = args[0] || config.default_domain;
@@ -131,6 +174,16 @@ export async function importOrg(args, flags) {
 // ── Dispatcher ───────────────────────────────────────────────────────────────
 const SUBCOMMAND_USAGE = {
     'list': 'myapi org list [--json]',
+    'update': `myapi org update [<id>] [--name <str>] [--tagline <str>] [--description <str>] [--business-sector <str>] [--logo-url <url>] [--json]
+
+Updates one or more fields of an organization. Specify the org by positional
+argument, --org <id>, or fall back to the default org from your config.
+At least one update flag must be provided.
+
+Examples:
+  myapi org update --tagline "Now with even more cowbell"
+  myapi org update abc-123 --name "Acme Inc" --description "Updated tagline"
+  myapi org update --logo-url https://example.com/logo.png --json`,
     'create': `myapi org create <name> [--tagline <str>] [--description <str>] [--business-sector <str>] [--logo-url <url>] [--yes] [--json]
        myapi org create --name <name> [...]
 
@@ -166,6 +219,7 @@ export async function run(subcommand, args, flags) {
 Subcommands:
   list        List organizations
   create      Create an organization (e.g. myapi org create "Name" --yes)
+  update      Update an organization's fields (name, tagline, description, etc.)
   get         Get details of an organization
   delete      Delete an organization
   sync-brand  Sync brand info (name, logo, description) from an existing website`);
@@ -183,6 +237,7 @@ Subcommands:
     switch (subcommand) {
         case 'list': return list(flags);
         case 'create': return create(args, flags);
+        case 'update': return update(args, flags);
         case 'get': return get(args[0], flags);
         case 'delete': return del(args[0], flags);
         case 'sync-brand': return importOrg(args, flags);

package/dist/commands/people.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/people.js

@@ -0,0 +1,136 @@
+import { people as sdkPeople } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { error, printTable, info, printJson } from '../output.js';
+import { requireOrg, requireArg } from '../helpers.js';
+export const EXPOSES = [
+    'POST /people/orgs/{org_id}/search',
+    'GET /people/orgs/{org_id}/{person_id}',
+];
+export const SCHEMA = {
+    org: 'string',
+    // Goldfox filter dimensions
+    confidence: 'string',
+    country: 'string',
+    'country-consistent': 'boolean',
+    'email-type': 'string',
+    'has-c-level': 'boolean',
+    'has-careers-page': 'boolean',
+    'has-decision-maker': 'boolean',
+    'has-investors-page': 'boolean',
+    'has-shop-page': 'boolean',
+    'is-registered-entity': 'boolean',
+    keyword: 'string',
+    'min-headcount': 'number',
+    'min-link-confidence': 'number',
+    'min-source-count': 'number',
+    seniority: 'string',
+    'tld-class': 'string',
+    limit: 'number',
+    offset: 'number',
+};
+// `--industry saas,fintech` → ['saas', 'fintech']. Returns undefined for
+// empty/missing so we don't send empty arrays to the backend.
+function csv(v) {
+    if (typeof v !== 'string' || v.trim() === '')
+        return undefined;
+    return v.split(',').map(s => s.trim()).filter(Boolean);
+}
+function buildFilter(flags) {
+    return {
+        confidence: csv(flags.confidence),
+        country: csv(flags.country),
+        country_consistent: typeof flags['country-consistent'] === 'boolean' ? flags['country-consistent'] : undefined,
+        email_type: csv(flags['email-type']),
+        has_c_level: typeof flags['has-c-level'] === 'boolean' ? flags['has-c-level'] : undefined,
+        has_careers_page: typeof flags['has-careers-page'] === 'boolean' ? flags['has-careers-page'] : undefined,
+        has_decision_maker: typeof flags['has-decision-maker'] === 'boolean' ? flags['has-decision-maker'] : undefined,
+        has_investors_page: typeof flags['has-investors-page'] === 'boolean' ? flags['has-investors-page'] : undefined,
+        has_shop_page: typeof flags['has-shop-page'] === 'boolean' ? flags['has-shop-page'] : undefined,
+        is_registered_entity: typeof flags['is-registered-entity'] === 'boolean' ? flags['is-registered-entity'] : undefined,
+        keyword: typeof flags.keyword === 'string' ? flags.keyword : undefined,
+        min_headcount: typeof flags['min-headcount'] === 'number' ? flags['min-headcount'] : undefined,
+        min_link_confidence: typeof flags['min-link-confidence'] === 'number' ? flags['min-link-confidence'] : undefined,
+        min_source_count: typeof flags['min-source-count'] === 'number' ? flags['min-source-count'] : undefined,
+        seniority: csv(flags.seniority),
+        tld_class: csv(flags['tld-class']),
+        limit: typeof flags.limit === 'number' ? flags.limit : undefined,
+        offset: typeof flags.offset === 'number' ? flags.offset : undefined,
+    };
+}
+async function search(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi people search [filters...] [--org <id>]');
+    const filter = buildFilter(flags);
+    const res = await sdkPeople.searchPeople(config.api_key, orgId, filter);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    info(`${res.people.length} of ${res.total} people${res.has_more ? ' (more available — pass --offset)' : ''}`);
+    printTable(res.people.map(p => ({
+        id: p.id,
+        name: p.full_name,
+        email: p.email ?? '',
+        domain: p.company?.domain ?? '',
+        country: p.location?.country ?? '',
+        link_conf: typeof p.link_confidence === 'number' ? p.link_confidence.toFixed(2) : '',
+    })), { flags, empty: 'No people matched. Try fewer filters.' });
+}
+async function get(personId, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi people get <person_id> [--org <id>]');
+    requireArg(personId, 'person_id', 'myapi people get <person_id> [--org <id>]');
+    const res = await sdkPeople.getPerson(config.api_key, orgId, personId);
+    printJson(res);
+}
+const SUBCOMMAND_USAGE = {
+    'search': `myapi people search [--confidence <csv>] [--country <csv>] [--country-consistent]
+       [--email-type <csv>] [--seniority <csv>] [--tld-class <csv>]
+       [--has-c-level] [--has-careers-page] [--has-decision-maker]
+       [--has-investors-page] [--has-shop-page] [--is-registered-entity]
+       [--keyword <text>] [--min-headcount N] [--min-link-confidence 0..1]
+       [--min-source-count N] [--limit N] [--offset N] [--org <id>]
+
+Goldfox-sourced filters; OR within an array, AND across fields.
+Empty filter returns all rows with default confidence=high.
+
+Values:
+  --confidence    high (default), low, very_low
+  --seniority     c_level, vp_director, manager, senior_ic, ic
+  --email-type    corporate, freemail, role_based, other_corporate
+  --tld-class     cctld, generic, vanity, low_trust, other
+  --country       ISO 3166-1 alpha-2 (US, DE, GB, ...)
+  --keyword       substring match on domain only (not name/title)
+
+Examples:
+  myapi people search --seniority c_level,vp_director --country US
+  myapi people search --email-type corporate --has-decision-maker --min-source-count 3
+  myapi people search --confidence high,low --country DE --tld-class cctld`,
+    'get': 'myapi people get <person_id> [--org <id>]',
+};
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi people <subcommand>
+
+Subcommands:
+  search    Filter people across the Goldfox database
+  get       Get a single person (with embedded company)
+
+All commands accept --org <id> (or set a default: myapi config set-org <id>).
+Filter shape is shared with company + audience — see myapi audience --help.`);
+        return;
+    }
+    if (flags.help) {
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi people --help" for the list.`);
+        return;
+    }
+    switch (subcommand) {
+        case 'search': return search(flags);
+        case 'get': return get(args[0], flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi people --help" for valid subcommands.`);
+    }
+}

package/dist/commands/pixel.d.ts

@@ -1,3 +1,11 @@
-export declare function interactions(flags: Record<string, string | boolean>): Promise<void>;
-export declare function identity(pixelId: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>): Promise<void>;
+import type { Exposes } from '../exposes.js';
+import type { Flags } from '../helpers.js';
+import type { FlagSchema } from '../flags.js';
+export declare const SCHEMA: FlagSchema;
+export declare const EXPOSES: Exposes;
+export declare function interactions(flags: Flags): Promise<void>;
+export declare function visits(flags: Flags): Promise<void>;
+export declare function events(flags: Flags): Promise<void>;
+export declare function audience(flags: Flags): Promise<void>;
+export declare function identity(pixelId: string, flags: Flags): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/pixel.js

@@ -1,6 +1,23 @@
 import { pixel as sdkPixel } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { error, printTable, info, printJson } from '../output.js';
+export const SCHEMA = {
+    org: 'string',
+    website: 'string',
+    'campaign-id': 'string',
+    domain: 'string',
+    from: 'string',
+    to: 'string',
+    limit: 'number',
+    offset: 'number',
+};
+export const EXPOSES = [
+    'GET /pixel/orgs/{org_id}/interactions',
+    'GET /pixel/orgs/{org_id}/visits',
+    'GET /pixel/orgs/{org_id}/events',
+    'GET /pixel/orgs/{org_id}/identity/{pixel_id}',
+    'GET /pixel/orgs/{org_id}/audience/get_geo_sample',
+];
 export async function interactions(flags) {
     const config = requireConfig();
     const orgId = flags.org || config.default_org;
@@ -34,6 +51,73 @@ export async function interactions(flags) {
         info(`Total Visits: ${res.total_visits} | Total Events: ${res.total_events} | Showing: ${res.limit} | Offset: ${res.offset}`);
     }
 }
+// Page-visit timeline scoped to a website (host).
+export async function visits(flags) {
+    const config = requireConfig();
+    const orgId = flags.org || config.default_org;
+    if (!orgId)
+        error("Missing org id. Usage: myapi pixel visits --website <domain> [--org <id>]\n(Or set defaults via: myapi config set-org <id>)");
+    if (!flags.website)
+        error("Missing required arg: --website <domain>. Visits are scoped to a host.");
+    const params = {
+        website: flags.website,
+    };
+    if (flags.from)
+        params.from = flags.from;
+    if (flags.to)
+        params.to = flags.to;
+    if (flags.limit)
+        params.limit = parseInt(flags.limit, 10);
+    if (flags.offset)
+        params.offset = parseInt(flags.offset, 10);
+    const res = await sdkPixel.getVisits(config.api_key, orgId, params);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    printTable(res.visits);
+    info(`Total: ${res.total} | Showing: ${res.limit} | Offset: ${res.offset}`);
+}
+// Engagement events (open / click / page_visit / sent) — filterable by
+// campaign or by domain.
+export async function events(flags) {
+    const config = requireConfig();
+    const orgId = flags.org || config.default_org;
+    if (!orgId)
+        error("Missing org id. Usage: myapi pixel events [--campaign-id <id> | --domain <domain>] [--org <id>]\n(Or set defaults via: myapi config set-org <id>)");
+    const params = {};
+    if (flags['campaign-id'])
+        params.campaign_id = flags['campaign-id'];
+    if (flags.domain)
+        params.domain = flags.domain;
+    if (flags.from)
+        params.from = flags.from;
+    if (flags.to)
+        params.to = flags.to;
+    if (flags.limit)
+        params.limit = parseInt(flags.limit, 10);
+    if (flags.offset)
+        params.offset = parseInt(flags.offset, 10);
+    if (!params.campaign_id && !params.domain) {
+        error("You must provide at least one filter: --campaign-id or --domain.");
+    }
+    const res = await sdkPixel.getEvents(config.api_key, orgId, params);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    printTable(res.events);
+    info(`Total: ${res.total} | Showing: ${res.limit} | Offset: ${res.offset}`);
+}
+// Geographic distribution sample of the org's pixel audience.
+export async function audience(flags) {
+    const config = requireConfig();
+    const orgId = flags.org || config.default_org;
+    if (!orgId)
+        error("Missing org id. Usage: myapi pixel audience [--org <id>]\n(Or set defaults via: myapi config set-org <id>)");
+    const res = await sdkPixel.getGeoSample(config.api_key, orgId);
+    printJson(res);
+}
 export async function identity(pixelId, flags) {
     const config = requireConfig();
     const orgId = flags.org || config.default_org;
@@ -46,6 +130,9 @@ export async function identity(pixelId, flags) {
 // ── Dispatcher ───────────────────────────────────────────────────────────────
 const SUBCOMMAND_USAGE = {
     'interactions': 'myapi pixel interactions [--website <domain>] [--campaign-id <id>] [--domain <domain>] [--from <iso8601>] [--to <iso8601>] [--limit <num>] [--offset <num>] [--org <id>] [--json]',
+    'visits': 'myapi pixel visits --website <domain> [--from <iso8601>] [--to <iso8601>] [--limit <num>] [--offset <num>] [--org <id>] [--json]',
+    'events': 'myapi pixel events [--campaign-id <id>] [--domain <domain>] [--from <iso8601>] [--to <iso8601>] [--limit <num>] [--offset <num>] [--org <id>] [--json]',
+    'audience': 'myapi pixel audience [--org <id>]',
     'identity': 'myapi pixel identity <pixel_id> [--org <id>]',
 };
 export async function run(subcommand, args, flags) {
@@ -55,6 +142,9 @@ export async function run(subcommand, args, flags) {
 Subcommands:
   interactions   Get a unified timeline of visits and events
                  (requires at least one filter: --website, --campaign-id, or --domain)
+  visits         Page-visit timeline scoped to a website host
+  events         Engagement events (sent / open / click / page_visit) by campaign or domain
+  audience       Geographic distribution sample of your pixel audience
   identity       Resolve the identity graph (emails, IPs, profiles) for a pixel ID
 
 All commands accept --org <id> (or set default: myapi config set-org <id>).`);
@@ -70,6 +160,9 @@ All commands accept --org <id> (or set default: myapi config set-org <id>).`);
     }
     switch (subcommand) {
         case 'interactions': return interactions(flags);
+        case 'visits': return visits(flags);
+        case 'events': return events(flags);
+        case 'audience': return audience(flags);
         case 'identity': return identity(args[0], flags);
         default: error(`Unknown subcommand: ${subcommand}. Run "myapi pixel --help" for a list of valid subcommands.`);
     }

package/dist/commands/setup.d.ts

@@ -1,4 +1,6 @@
 import type { Flags } from '../helpers.js';
+import type { Exposes } from '../exposes.js';
+export declare const EXPOSES: Exposes;
 export declare function installSkills(): Promise<void>;
 export declare function importKey(apiKey: string, flags: Flags): Promise<void>;
 export declare function setup(flags?: Flags): Promise<void>;

package/dist/commands/setup.js

@@ -5,6 +5,35 @@ import { loadConfig, saveConfig, addAccount, loadFullConfig } from '../config.js
 import { info, success } from '../output.js';
 import { ask, confirm } from '../prompt.js';
 import { hq, funnel as sdkFunnel } from '@myapihq/sdk';
+import { emitSkillsInstall } from '../telemetry.js';
+// Resolved at first call from package.json; used by the telemetry payload.
+// Inlined as a getter so import order doesn't matter (package.json is read
+// in index.ts at startup, but installSkills can be called from outside that
+// path).
+let _cliVersion = null;
+function getCliVersion() {
+    if (_cliVersion !== null)
+        return _cliVersion;
+    try {
+        const pkgUrl = new URL('../../package.json', import.meta.url);
+        _cliVersion = JSON.parse(fs.readFileSync(pkgUrl, 'utf-8')).version || 'unknown';
+    }
+    catch {
+        _cliVersion = 'unknown';
+    }
+    return _cliVersion;
+}
+export const EXPOSES = [
+    'POST /hq/account/anonymous',
+    'POST /hq/account/send-code',
+    'POST /hq/account/verify-code',
+    'GET /hq/account/me',
+    'GET /hq/orgs',
+    'GET /funnel/orgs/{org_id}/funnels',
+    // installSkills() emits the skills.install telemetry event via
+    // ../telemetry.ts; that's an outbound POST to this endpoint.
+    'POST /v1/integrations/skills-install',
+];
 // ---------------------------------------------------------------------------
 // Skills installation
 // ---------------------------------------------------------------------------
@@ -38,24 +67,40 @@ export async function installSkills() {
     // Symlink each skill into agent config directories. Surface failures so
     // users can fix permission issues — skills that didn't install will not
     // be available to the agent and "skills installed" would otherwise lie.
+    const agentsTargeted = [];
     for (const [agent, dir] of Object.entries(AGENT_DIRS)) {
         try {
             fs.mkdirSync(dir, { recursive: true });
             for (const skill of skills) {
                 const link = path.join(dir, skill);
                 const target = path.join(SKILLS_CANONICAL, skill);
-                // Only remove if it's already a symlink we own. Avoids clobbering a
-                // user-authored skill that happens to share the same `my-X-api/`
-                // name. ENOENT here just means "nothing to clean up".
+                // Clean up an existing entry if it's unambiguously ours, so re-runs
+                // are idempotent. Three cases:
+                //   - symlink:  always safe to replace (we made it).
+                //   - directory containing only SKILL.md: legacy pre-symlink install
+                //     style; safe to replace.
+                //   - anything else (regular file, dir with extra content, etc.):
+                //     leave it alone so a user-authored skill that happens to share
+                //     a `my-X-api/` name doesn't get clobbered. The symlinkSync
+                //     below will then fail with EEXIST and surface to the user.
+                // ENOENT from lstat just means "nothing there".
                 try {
                     const stat = fs.lstatSync(link);
-                    if (stat.isSymbolicLink())
+                    if (stat.isSymbolicLink()) {
                         fs.rmSync(link, { force: true });
+                    }
+                    else if (stat.isDirectory()) {
+                        const entries = fs.readdirSync(link);
+                        if (entries.length === 0 || (entries.length === 1 && entries[0] === 'SKILL.md')) {
+                            fs.rmSync(link, { recursive: true, force: true });
+                        }
+                    }
                 }
                 catch { /* ENOENT: nothing there */ }
                 fs.symlinkSync(target, link);
             }
             info(`  ✓ ${agent}`);
+            agentsTargeted.push(agent);
         }
         catch (err) {
             // Skip agents not installed on this machine (ENOENT on parent dir is OK).
@@ -68,6 +113,12 @@ export async function installSkills() {
             info(`  ✗ ${agent}: ${err.message || code} (${dir})`);
         }
     }
+    // Emit telemetry — fire-and-forget, never blocks. See packages/cli/src/telemetry.ts.
+    // Skipped silently if user isn't authenticated (e.g. install-skills run before
+    // auth setup). When at least one agent dir was successfully written.
+    if (agentsTargeted.length > 0) {
+        emitSkillsInstall(agentsTargeted, getCliVersion());
+    }
 }
 // ---------------------------------------------------------------------------
 // Shared helpers
@@ -194,7 +245,7 @@ export async function setup(flags = {}) {
         const activeType = existing.is_anonymous ? 'anonymous' : 'registered';
         const othersNote = total > 1 ? ` · ${total - 1} more saved` : '';
         info(`› Connected: ${activeLabel} (${activeType})${othersNote}`);
-        const add = await confirm('› Connect a new account? (y/N) ', false);
+        const add = await confirm('› Connect a new account? (Y/n) ', true);
         if (!add) {
             if (!existing.skills_installed) {
                 const wants = await resolveSkillsPreference(flags);
@@ -227,6 +278,7 @@ export async function setup(flags = {}) {
     }
     else {
         info('› Continuing as anonymous — sites ship to *.makeautonomous.com');
+        info('  (Anonymous accounts have $0 credit. Link an email anytime to unlock $5 free credit and paid actions: myapi auth link <email>)');
         const data = await anonymousFlow();
         apiKey = data.api_key;
         accountId = data.account_id;

package/dist/commands/status.d.ts

@@ -0,0 +1,7 @@
+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 STATUS_HELP = "Usage: myapi status [--org <id>] [--json]\n\nSingle-screen view of your account and what's running in the default org:\nidentity, balance, free-tier usage, plus resource counts across domains,\nfunnels, campaigns, webhooks, and workflows. Useful before a\nco-build session or when checking \"what's mid-flight\" without running six\nlist commands.\n\nEach section is best-effort \u2014 a failing service is shown as \"\u2014\", not an\nerror, so the rest of the snapshot still prints.\n";
+export declare function run(_subcommand: string | undefined, _args: string[], flags?: Flags): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,154 @@
+import { hq, domain, funnel, email, webhook, workflow, MyApiError } from '@myapihq/sdk';
+// listMailboxes is omitted from this view: the backend requires a domain or
+// filter, so there is no global "all mailboxes in this org" call. Use
+// `myapi email mailbox list --domain <d>` for per-domain detail.
+import { loadConfig } from '../config.js';
+import { info, error, printJson } from '../output.js';
+export const EXPOSES = [
+    'GET /hq/billing/balance',
+    'GET /hq/account/free-tier',
+    'GET /domain/orgs/{org_id}/domains',
+    'GET /funnel/orgs/{org_id}/funnels',
+    'GET /email/orgs/{org_id}/campaigns',
+    'GET /webhook/orgs/{org_id}/endpoints',
+    'GET /workflow/orgs/{org_id}/workflows',
+];
+export const SCHEMA = {
+    org: 'string',
+};
+export const STATUS_HELP = `Usage: myapi status [--org <id>] [--json]
+
+Single-screen view of your account and what's running in the default org:
+identity, balance, free-tier usage, plus resource counts across domains,
+funnels, campaigns, webhooks, and workflows. Useful before a
+co-build session or when checking "what's mid-flight" without running six
+list commands.
+
+Each section is best-effort — a failing service is shown as "—", not an
+error, so the rest of the snapshot still prints.
+`;
+function unwrap(r) {
+    return r.status === 'fulfilled' ? r.value : null;
+}
+export async function run(_subcommand, _args, flags = {}) {
+    if (flags.help) {
+        info(STATUS_HELP);
+        return;
+    }
+    const config = loadConfig();
+    if (!config?.api_key)
+        error('Not configured. Run: myapi auth setup');
+    const orgId = flags.org ?? config.default_org;
+    // Account-level info works without an org; org-scoped resources are skipped if none set.
+    const orgKnown = Boolean(orgId);
+    // Account-level (always fetched).
+    const accountResults = await Promise.allSettled([
+        hq.getBalance(config.api_key),
+        hq.getFreeTier(config.api_key),
+    ]);
+    const balance = unwrap(accountResults[0]);
+    // The backend currently returns an array of { service, used, allowance }
+    // per-service entries. The SDK type lies about this (claims scalar) — same
+    // bug surfaces in `whoami`. Treat as unknown here and narrow at render time.
+    const freeTier = unwrap(accountResults[1]);
+    // Catch a server-side rejection across any best-effort probe so we can flag
+    // the snapshot as untrustworthy rather than silently printing local config.
+    const keyRejected = accountResults.some(r => r.status === 'rejected' && r.reason instanceof MyApiError && r.reason.status === 401);
+    // Org-scoped (skipped if no default org set).
+    let domains = null, funnels = null, campaigns = null, webhooks = null, workflows = null;
+    if (orgKnown) {
+        const orgResults = await Promise.allSettled([
+            domain.listDomains(config.api_key, orgId),
+            funnel.listFunnels(config.api_key, orgId),
+            email.listCampaigns(config.api_key, orgId),
+            webhook.listEndpoints(config.api_key, orgId),
+            workflow.listWorkflows(config.api_key, orgId),
+        ]);
+        domains = unwrap(orgResults[0]);
+        funnels = unwrap(orgResults[1]);
+        campaigns = unwrap(orgResults[2]);
+        webhooks = unwrap(orgResults[3]);
+        workflows = unwrap(orgResults[4]);
+    }
+    if (flags.json) {
+        printJson({
+            account: {
+                email: config.email ?? null,
+                account_id: config.account_id,
+                type: config.is_anonymous ? 'anonymous' : 'registered',
+                default_org: orgId ?? null,
+                default_funnel: config.default_funnel ?? null,
+                key_rejected: keyRejected,
+            },
+            balance,
+            free_tier: freeTier,
+            org_resources: orgKnown ? {
+                domains, funnels, campaigns, webhooks, workflows,
+            } : null,
+        });
+        return;
+    }
+    if (keyRejected) {
+        info('⚠ The backend rejected your API key. Values may be stale — run: myapi auth setup');
+        info('');
+    }
+    // ── Identity ──────────────────────────────────────────────────────────────
+    if (config.email)
+        info(`Email:    ${config.email}`);
+    info(`Account:  ${config.account_id}`);
+    info(`Org:      ${orgId ?? '(none — run: myapi config set-org <id>)'}`);
+    info(`Funnel:   ${config.default_funnel ?? '(none)'}`);
+    info(`Type:     ${config.is_anonymous ? 'anonymous' : 'registered'}`);
+    info(`Balance:  ${balance ? `${balance.balance_display}  |  Credits: ${balance.credits_display}` : '—'}`);
+    if (config.is_anonymous) {
+        info('          → Link an email to unlock $5 free credit + paid actions: myapi auth link <email>');
+    }
+    if (Array.isArray(freeTier) && freeTier.length > 0) {
+        const parts = freeTier
+            .filter((e) => e && typeof e.service === 'string')
+            .map((e) => `${e.service} ${e.used ?? 0}/${e.allowance ?? '?'}`);
+        if (parts.length > 0)
+            info(`FreeTier: ${parts.join(' · ')}`);
+    }
+    // ── Resources ─────────────────────────────────────────────────────────────
+    info('');
+    info('Resources:');
+    if (!orgKnown) {
+        info('  (set a default org to see domains/funnels/campaigns/webhooks/workflows)');
+        return;
+    }
+    if (domains) {
+        const verified = domains.filter(d => /verified|active|ready/i.test(d.status)).length;
+        const pending = domains.length - verified;
+        const pendingStr = pending > 0 ? `, ${pending} pending` : '';
+        info(`  Domains:   ${domains.length} (${verified} verified${pendingStr})`);
+    }
+    else
+        info('  Domains:   —');
+    info(`  Funnels:   ${funnels ? funnels.length : '—'}`);
+    if (campaigns) {
+        // Campaigns: backend statuses include 'draft', 'active', 'paused', 'completed'.
+        // Surface counts for the two states that matter mid-flight.
+        const active = campaigns.filter(c => /active|running/i.test(c.status)).length;
+        const paused = campaigns.filter(c => /paused/i.test(c.status)).length;
+        const extras = [
+            active > 0 ? `${active} active` : null,
+            paused > 0 ? `${paused} paused` : null,
+        ].filter(Boolean).join(', ');
+        info(`  Campaigns: ${campaigns.length}${extras ? ` (${extras})` : ''}`);
+    }
+    else
+        info('  Campaigns: —');
+    info(`  Webhooks:  ${webhooks ? webhooks.length : '—'}`);
+    if (workflows) {
+        const enabled = workflows.filter(w => w.enabled).length;
+        const disabled = workflows.length - enabled;
+        const extras = [
+            enabled > 0 ? `${enabled} enabled` : null,
+            disabled > 0 ? `${disabled} disabled` : null,
+        ].filter(Boolean).join(', ');
+        info(`  Workflows: ${workflows.length}${extras ? ` (${extras})` : ''}`);
+    }
+    else
+        info('  Workflows: —');
+}

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