@myapihq/cli 1.3.1 → 1.3.2

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

@@ -0,0 +1,154 @@
+// `myapi doctor` — thin client over the backend's GET /hq/orgs/{org_id}/doctor.
+//
+// The backend computes the heavy reference-integrity / orphan / activity
+// checks across slots and returns a structured report. The CLI's job is:
+//   1. fetch the report,
+//   2. augment with *customer-perspective* probes the backend structurally
+//      can't run (today: DNS resolution from the user's network),
+//   3. render with section grouping, color, and exit codes for CI.
+import { promises as dns } from 'node:dns';
+import { hq as sdkHq } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { info, error, printJson } from '../output.js';
+import { requireOrg } from '../helpers.js';
+export const EXPOSES = [
+    'GET /hq/orgs/{org_id}/doctor',
+];
+export const SCHEMA = {};
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+const C = useColor ? {
+    ok: '\x1b[32m', warn: '\x1b[33m', err: '\x1b[31m',
+    dim: '\x1b[2m', bold: '\x1b[1m', reset: '\x1b[0m',
+} : { ok: '', warn: '', err: '', dim: '', bold: '', reset: '' };
+const MARK = {
+    ok: `${C.ok}✓${C.reset}`,
+    warn: `${C.warn}⚠${C.reset}`,
+    crit: `${C.err}✗${C.reset}`,
+};
+function rule(width = 60) {
+    return `${C.dim}${'─'.repeat(width)}${C.reset}`;
+}
+function fmtIssue(i) {
+    const head = `  ${MARK[i.severity] ?? '·'} ${i.message}`;
+    return i.hint ? `${head}\n    ${C.dim}→ ${i.hint}${C.reset}` : head;
+}
+// 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
+// different epistemic signal worth surfacing on top of the backend's view.
+async function dnsProbeSection(report) {
+    const names = new Set();
+    for (const s of report.sections) {
+        for (const i of s.issues) {
+            if (i.entity?.slot === 'domain' && i.entity.name)
+                names.add(i.entity.name);
+        }
+    }
+    if (names.size === 0)
+        return null;
+    const issues = [];
+    await Promise.all([...names].map(async (name) => {
+        try {
+            const ips = await dns.resolve4(name);
+            issues.push({
+                id: `dns_local_ok/${name}`,
+                severity: 'ok',
+                scope: `local/${name}`,
+                entity: { slot: 'domain', id: '', name },
+                category: 'network',
+                message: `${name} resolves from your network${ips.length ? ` (${ips[0]}${ips.length > 1 ? ` +${ips.length - 1}` : ''})` : ''}`,
+            });
+        }
+        catch (e) {
+            issues.push({
+                id: `dns_local_fail/${name}`,
+                severity: 'warn',
+                scope: `local/${name}`,
+                entity: { slot: 'domain', id: '', name },
+                category: 'network',
+                message: `${name} did not resolve from your network`,
+                hint: e?.code || e?.message || String(e),
+            });
+        }
+    }));
+    const warns = issues.filter(i => i.severity === 'warn').length;
+    return {
+        name: 'local network',
+        summary: warns ? `${warns} resolution failure${warns === 1 ? '' : 's'}` : `${issues.length} domain${issues.length === 1 ? '' : 's'} resolved`,
+        issues,
+    };
+}
+export async function run(_subcommand, _args, flags) {
+    if (flags.help) {
+        info(HELP);
+        return;
+    }
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi doctor [--json] [--verbose]');
+    const apiKey = config.api_key;
+    const verbose = !!flags.verbose;
+    const wantJson = !!flags.json;
+    let report;
+    try {
+        report = await sdkHq.getDoctor(apiKey, orgId);
+    }
+    catch (e) {
+        error(`doctor endpoint failed: ${e?.message ?? String(e)}`);
+    }
+    const localSection = await dnsProbeSection(report);
+    if (localSection)
+        report.sections.push(localSection);
+    // Re-tally totals after local augmentation.
+    const totals = { ok: 0, warn: 0, crit: 0 };
+    for (const s of report.sections)
+        for (const i of s.issues)
+            totals[i.severity]++;
+    if (wantJson) {
+        printJson({ ...report, totals });
+        return;
+    }
+    info(`${C.bold}Org doctor${C.reset}  ${C.dim}· org ${report.org_id}${C.reset}  ${C.dim}· ${report.generated_at}${C.reset}`);
+    for (const s of report.sections) {
+        info('');
+        info(`${C.bold}# ${s.name}${C.reset}  ${C.dim}· ${s.summary}${C.reset}`);
+        for (const i of s.issues) {
+            if (!verbose && i.severity === 'ok')
+                continue;
+            info(fmtIssue(i));
+        }
+    }
+    info('');
+    info(rule(60));
+    if (totals.crit) {
+        info(`${MARK.crit} ${totals.crit} critical, ${MARK.warn} ${totals.warn} warning${totals.warn === 1 ? '' : 's'}`);
+        process.exitCode = 1;
+    }
+    else if (totals.warn) {
+        info(`${MARK.warn} ${totals.warn} warning${totals.warn === 1 ? '' : 's'}, no critical issues`);
+    }
+    else {
+        info(`${MARK.ok} ${totals.ok} check${totals.ok === 1 ? '' : 's'} passed`);
+    }
+    if (!verbose)
+        info(`${C.dim}(--verbose to show passing checks · --json for machine-readable)${C.reset}`);
+}
+const HELP = `Usage: myapi doctor [--verbose] [--json] [--org <id>]
+
+Org-wide consistency check. Fetches the structured report from the backend
+(GET /hq/orgs/{org_id}/doctor) and augments it with customer-perspective
+probes (DNS resolution from this machine's network).
+
+Sections returned by the backend today:
+  funnels, webhooks, workflows, domains, containers, emails, payments
+
+Local additions:
+  network    — DNS resolution from your egress for each domain mentioned.
+
+Exit codes:
+  0  no critical issues (warnings allowed)
+  1  one or more critical issues
+
+Options:
+  --verbose    Show passing checks too.
+  --json       Machine-readable output.
+  --org <id>   Override the default org.`;

package/dist/completion.js

@@ -28,7 +28,7 @@ const BLOCK_END = `# end ${PROGRAM} completion`;
 export const COMMANDS = [
     'audience', 'auth', 'billing', 'company', 'completion', 'config', 'container',
     'crm', 'database', 'domain', 'email', 'fn', 'funnel', 'git', 'help', 'image',
-    'install-skills', 'keys', 'llm', 'org', 'payments', 'people', 'pixel', 'queue',
+    'doctor', 'install-skills', 'keys', 'llm', 'org', 'payments', 'people', 'pixel', 'queue',
     'setup', 'status', 'storage', 'task', 'update', 'url', 'webhook', 'whoami',
     'workflow',
 ];

package/dist/exposes.test.js

@@ -43,6 +43,7 @@ const COMMAND_MODULES = [
     './commands/git.js',
     './commands/queue.js',
     './commands/task.js',
+    './commands/doctor.js',
 ];
 const ENDPOINT_PATTERN = /^(GET|POST|PATCH|PUT|DELETE) \/[A-Za-z0-9_\-./{}]*$/;
 describe('every CLI command exports a typed EXPOSES array (S-101)', () => {

package/dist/index.js

@@ -35,6 +35,7 @@ import * as containerCmd from './commands/container.js';
 import * as gitCmd from './commands/git.js';
 import * as queueCmd from './commands/queue.js';
 import * as taskCmd from './commands/task.js';
+import * as doctorCmd from './commands/doctor.js';
 // Each command file declares the value flags it understands. We union them
 // into a single schema for the upfront parse, so adding a new value flag in
 // one command means editing one file (its SCHEMA), not a global allowlist.
@@ -66,6 +67,7 @@ const COMBINED_SCHEMA = {
     ...gitCmd.SCHEMA,
     ...queueCmd.SCHEMA,
     ...taskCmd.SCHEMA,
+    ...doctorCmd.SCHEMA,
     // Top-level flags
     version: 'boolean',
     V: 'boolean',
@@ -234,6 +236,9 @@ async function main() {
             case 'task':
                 await taskCmd.run(subcommand, restArgs, flags);
                 break;
+            case 'doctor':
+                await doctorCmd.run(subcommand, restArgs, flags);
+                break;
             // Convenience aliases
             case 'setup':
                 await setupCmd.setup(flags);
@@ -360,6 +365,7 @@ const HELP_TARGETS = {
     git: f => gitCmd.run(undefined, [], f),
     queue: f => queueCmd.run(undefined, [], f),
     task: f => taskCmd.run(undefined, [], f),
+    doctor: f => doctorCmd.run(undefined, [], f),
     org: f => orgCmd.run(undefined, [], f),
     billing: f => billingCmd.run(undefined, [], f),
     keys: f => keysCmd.run(undefined, [], f),
@@ -406,6 +412,7 @@ Commands:
   git             Hosted git repositories — repos, commits, branches, history
   queue           Durable job queue — enqueue work, retried against an HTTP consumer
   task            Agent-task queue — file, claim, and resolve units of work
+  doctor          Org-wide consistency check — funnels, webhooks, domains, containers
   payments        Take payments with Stripe Checkout (connect, charge, refund)
   webhook         Manage inbound webhook endpoints and inspect deliveries
   email           Manage mailboxes, send/read email, templates, and campaigns

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@myapihq/cli",
   "license": "Apache-2.0",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "MyAPI command-line interface",
   "type": "module",
   "files": [
@@ -29,7 +29,7 @@
     "lint:changelog": "node ../../scripts/lint-changelog.js"
   },
   "dependencies": {
-    "@myapihq/sdk": "^1.3.1"
+    "@myapihq/sdk": "^1.3.2"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",