@myapihq/cli 1.3.0 → 1.3.2

package/dist/commands/container.d.ts

@@ -13,4 +13,5 @@ export declare function get(id: string, flags: Flags): Promise<void>;
 export declare function del(id: string, flags: Flags): Promise<void>;
 export declare function deploy(id: string, image: string, flags: Flags): Promise<void>;
 export declare function logs(id: string, flags: Flags): Promise<void>;
+export declare function domain(id: string, domainArg: string | undefined, flags: Flags): Promise<void>;
 export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/container.js

@@ -10,6 +10,8 @@ export const EXPOSES = [
     'DELETE /container/orgs/{org_id}/containers/{id}',
     'POST /container/orgs/{org_id}/containers/{id}/deploy',
     'GET /container/orgs/{org_id}/containers/{id}/logs',
+    'POST /container/orgs/{org_id}/containers/{id}/domain',
+    'DELETE /container/orgs/{org_id}/containers/{id}/domain',
 ];
 export const SCHEMA = {
     name: 'string',
@@ -22,6 +24,7 @@ export const SCHEMA = {
     port: 'number',
     env: 'string',
     tail: 'number',
+    remove: 'boolean',
 };
 const CONTAINER_TYPES = ['service', 'worker', 'job'];
 // Mirrors validateName in myapi-hq/internal/routes/container/crud.go —
@@ -146,6 +149,8 @@ export async function get(id, flags) {
     if (c.port)
         info(`Port:            ${c.port}`);
     info(`URL:             ${c.url || '(not deployed)'}`);
+    if (c.custom_domain)
+        info(`Custom domain:   ${c.custom_domain}`);
     info(`Created:         ${c.created_at}`);
     info(`Updated:         ${c.updated_at}`);
 }
@@ -198,6 +203,31 @@ export async function logs(id, flags) {
         info(`${e.timestamp}  ${(e.severity || '').padEnd(8)} ${e.text}`);
     }
 }
+// domain binds (or, with --remove, unbinds) a custom domain on a deployed
+// container. The parent domain must be MyAPI-managed.
+export async function domain(id, domainArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi container domain <id> <domain> [--org <id>]');
+    if (!id)
+        error('Missing id.\nUsage: myapi container domain <id> <domain>   (or --remove to unbind)');
+    if (flags.remove) {
+        await sdkContainer.unbindDomain(config.api_key, orgId, id);
+        success(`Removed custom domain from container ${id}`);
+        return;
+    }
+    if (!domainArg) {
+        error('Missing <domain>.\nUsage: myapi container domain <id> <domain>\n   or: myapi container domain <id> --remove');
+    }
+    const binding = await sdkContainer.bindDomain(config.api_key, orgId, id, domainArg);
+    if (flags.json) {
+        printJson(binding);
+        return;
+    }
+    success(`Custom domain bound: ${binding.custom_domain}`);
+    info(`Container:  ${binding.container_id}`);
+    info(`Origin:     ${binding.origin}`);
+    info(`Status:     ${binding.status}`);
+}
 // ── Dispatcher ───────────────────────────────────────────────────────────────
 const SUBCOMMAND_USAGE = {
     'create': `myapi container create --name <name> [--type service|worker|job] [--cron <expr>]
@@ -229,6 +259,15 @@ Example:
 
 Recent Cloud Run runtime logs, newest first. --tail caps the count
 (default 100, max 1000).`,
+    'domain': `myapi container domain <id> <domain> [--org <id>] [--json]
+       myapi container domain <id> --remove [--org <id>]
+
+Binds a custom domain to a deployed container, served over HTTPS via
+Cloudflare. The domain's MyAPI-managed parent domain must already be
+registered. --remove unbinds it.
+
+Example:
+  myapi container domain <id> app.synthesisdaily.com`,
     'delete': 'myapi container delete <id> [--org <id>]',
 };
 export async function run(subcommand, args, flags) {
@@ -245,6 +284,7 @@ Subcommands:
   list                 List containers in your org
   get <id>             Inspect a container
   logs <id>            Show recent runtime logs (--tail <n>)
+  domain <id> <domain> Bind a custom domain (--remove to unbind)
   delete <id>          Soft-delete and revoke its scoped API key
 
 All commands accept --org <id> (or set default: myapi config set-org <id>).`);
@@ -264,6 +304,7 @@ All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         case 'list': return list(flags);
         case 'get': return get(args[0], flags);
         case 'logs': return logs(args[0], flags);
+        case 'domain': return domain(args[0], args[1], flags);
         case 'delete': return del(args[0], flags);
         default: error(`Unknown subcommand: ${subcommand}. Run "myapi container --help" for a list of valid subcommands.`);
     }

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',
 ];
@@ -57,7 +57,7 @@ export const SUBCOMMANDS = {
     config: ['view', 'set-org', 'set-funnel', 'set-domain'],
     fn: ['create', 'deploy', 'env', 'runs', 'list', 'get', 'delete'],
     payments: ['connect', 'status', 'charge', 'list', 'get', 'refund'],
-    container: ['create', 'deploy', 'list', 'get', 'logs', 'delete'],
+    container: ['create', 'deploy', 'list', 'get', 'logs', 'domain', 'delete'],
     git: ['create', 'list', 'get', 'delete', 'refs', 'log', 'show', 'tree', 'blob', 'diff', 'commit', 'create-branch', 'delete-branch', 'tag', 'merge', 'repack'],
     queue: ['create', 'list', 'get', 'enqueue', 'jobs', 'job'],
     task: ['create', 'list', 'get', 'claim', 'extend', 'resolve', 'fail', 'cancel'],

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/dist/sdk-container.test.js

@@ -126,7 +126,7 @@ describe('container.getContainerLogs', () => {
     });
 });
 describe('container.EXPOSES', () => {
-    it('covers the 6 container endpoints', () => {
+    it('covers the 8 container endpoints', () => {
         expect(container.EXPOSES).toEqual([
             'POST /container/orgs/{org_id}/containers',
             'GET /container/orgs/{org_id}/containers',
@@ -134,6 +134,40 @@ describe('container.EXPOSES', () => {
             'DELETE /container/orgs/{org_id}/containers/{id}',
             'POST /container/orgs/{org_id}/containers/{id}/deploy',
             'GET /container/orgs/{org_id}/containers/{id}/logs',
+            'POST /container/orgs/{org_id}/containers/{id}/domain',
+            'DELETE /container/orgs/{org_id}/containers/{id}/domain',
         ]);
     });
 });
+describe('container custom domain', () => {
+    it('bindDomain POSTs {domain} and returns the binding', async () => {
+        fetchMock.mockResolvedValueOnce(ok({
+            container_id: C_ID, custom_domain: 'app.synthesisdaily.com',
+            origin: 'svc-abc.run.app', status: 'active',
+        }));
+        const b = await container.bindDomain(API_KEY, ORG_ID, C_ID, 'app.synthesisdaily.com');
+        expect(b.status).toBe('active');
+        expect(b.origin).toBe('svc-abc.run.app');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toBe(`https://api.myapihq.com/container/orgs/${ORG_ID}/containers/${C_ID}/domain`);
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ domain: 'app.synthesisdaily.com' });
+    });
+    it('bindDomain surfaces 422 when the container is not deployed', async () => {
+        fetchMock.mockResolvedValueOnce(fail('container_not_deployed', 'container not deployed', 422));
+        await expect(container.bindDomain(API_KEY, ORG_ID, C_ID, 'app.x.com'))
+            .rejects.toMatchObject({ status: 422 });
+    });
+    it('bindDomain surfaces 409 when a domain is already bound', async () => {
+        fetchMock.mockResolvedValueOnce(fail('domain_conflict', 'domain already bound', 409));
+        await expect(container.bindDomain(API_KEY, ORG_ID, C_ID, 'app.x.com'))
+            .rejects.toMatchObject({ status: 409 });
+    });
+    it('unbindDomain DELETEs the domain endpoint', async () => {
+        fetchMock.mockResolvedValueOnce(new Response(null, { status: 204 }));
+        await container.unbindDomain(API_KEY, ORG_ID, C_ID);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toBe(`https://api.myapihq.com/container/orgs/${ORG_ID}/containers/${C_ID}/domain`);
+        expect(init.method).toBe('DELETE');
+    });
+});

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

@@ -15,6 +15,8 @@ Handles domain registration, assignment to orgs, and edge (CDN/security) setting
 <!-- llm:start -->
 Domains are how you take a funnel from `your-org.makeautonomous.com` to `your-real-brand.com`. The flow is: check availability, register (deducts credits), assign to an org, watch status until DNS propagates. From that point, your org's funnel serves at `https://yourdomain.com`. SSL provisions automatically a few minutes after status flips to `active`.
 
+A registered domain isn't only for funnels: a **deployed container** can be served on a custom domain or subdomain too — bind it with `myapi container domain <id> <domain>` (see `my-container-api`). Funnels are static sites; containers are dynamic apps. Either way, the parent domain must be registered here first.
+
 You can also import existing domains (without re-registering) and tune CDN/security settings per-domain.
 
 Without a domain, funnels still work on the free `*.makeautonomous.com` preview subdomain.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@myapihq/cli",
   "license": "Apache-2.0",
-  "version": "1.3.0",
+  "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.0"
+    "@myapihq/sdk": "^1.3.2"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",