@myapihq/cli 2.25.0 → 2.25.2

package/dist/commands/container.js

@@ -786,6 +786,7 @@ Subcommands:
   domain <id> <domain> Bind a custom domain (--remove to unbind)
   env <id>             Change environment variables (merge; rolls a new revision)
   get <id>             Inspect a container
+  health-check <id>    Set or clear the startup probe (--clear); rolls a new revision
   list                 List containers in your org
   logs <id>            Show recent runtime logs (--tail <n>, --scope all) — see build-logs for build failures
   promote <id> <rev>   Move all traffic to a revision (seconds, no rebuild)

package/dist/commands/help-lists-every-verb.test.d.ts

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

package/dist/commands/help-lists-every-verb.test.js

@@ -0,0 +1,146 @@
+// A verb you cannot find is a verb you do not have.
+//
+// `container health-check` shipped dispatched, documented in SUBCOMMAND_USAGE,
+// covered by tests and named in the skill — and absent from the list that
+// `myapi container --help` prints. The only way to discover it was to already
+// know it existed. It was found by running the published binary after release,
+// which is not a mechanism.
+//
+// The existing help linter checks that listings are ALPHABETICAL. Nothing
+// checked that they are COMPLETE, so a new verb could be sorted correctly into
+// a list it was not in.
+//
+// This drives each command's own help output — the exact string the user sees,
+// not a listing block matched by a regex, because two earlier attempts at this
+// measured the wrong thing: one required a `Subcommands:` header that `task`
+// does not use, and one accepted an entry in SUBCOMMAND_USAGE, which is what
+// health-check already had while remaining invisible.
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const COMMANDS_DIR = fileURLToPath(new URL('.', import.meta.url));
+// Verbs deliberately absent from the printed list, each with a reason.
+// A hidden verb is a decision; an accidentally hidden one is the bug above.
+const HIDDEN_OK = {
+    'database.ts': {
+        keys: 'undocumented alias of `entries`, kept so existing scripts keep working; ' +
+            'the code says it goes no earlier than the next minor',
+    },
+    'org.ts': {
+        import: 'deprecated alias of `sync-brand`; still dispatches and prints a ' +
+            'deprecation notice, deliberately absent from the listing',
+    },
+};
+function moduleFiles() {
+    const out = [];
+    for (const entry of readdirSync(COMMANDS_DIR).sort()) {
+        const p = path.join(COMMANDS_DIR, entry);
+        if (statSync(p).isDirectory()) {
+            const idx = path.join(p, 'index.ts');
+            try {
+                statSync(idx);
+                out.push(`${entry}/index.ts`);
+            }
+            catch { /* no dispatcher */ }
+        }
+        else if (entry.endsWith('.ts') && !entry.includes('.test.')) {
+            out.push(entry);
+        }
+    }
+    return out;
+}
+// Only the TOP-LEVEL dispatcher's cases. A nested switch — `account registrant
+// set`, `domain records create`, `llm cache list` — belongs to a sub-verb that
+// the parent line documents inline, and counting those made the check report
+// three commands that are fine.
+function dispatchedVerbs(src) {
+    const start = src.indexOf('export async function run(');
+    if (start === -1)
+        return [];
+    let i = src.indexOf('{', start);
+    if (i === -1)
+        return [];
+    let depth = 0, end = src.length;
+    for (let j = i; j < src.length; j++) {
+        if (src[j] === '{')
+            depth++;
+        else if (src[j] === '}') {
+            depth--;
+            if (depth === 0) {
+                end = j;
+                break;
+            }
+        }
+    }
+    const body = src.slice(i, end);
+    return [...new Set([...body.matchAll(/case\s+'([a-z][a-z0-9-]*)'\s*:/g)].map(m => m[1]))];
+}
+let printed;
+beforeEach(async () => {
+    printed = [];
+    const output = await import('../output.js');
+    const capture = ((m) => { printed.push(String(m ?? '')); });
+    vi.spyOn(output, 'info').mockImplementation(capture);
+    vi.spyOn(output, 'success').mockImplementation(capture);
+    vi.spyOn(output, 'printJson').mockImplementation(capture);
+    vi.spyOn(output, 'error').mockImplementation(((m) => {
+        printed.push(String(m));
+        throw new Error('__EXIT__');
+    }));
+});
+afterEach(() => vi.restoreAllMocks());
+async function helpTextOf(file) {
+    const mod = await import(`./${file}`);
+    if (typeof mod.run !== 'function')
+        return '';
+    try {
+        await mod.run(undefined, [], {});
+    }
+    catch (e) {
+        if (e?.message !== '__EXIT__')
+            throw e;
+    }
+    return printed.join('\n');
+}
+describe('every dispatched verb appears in its command help', () => {
+    const files = moduleFiles();
+    it('no waiver claims to hide a verb that is listed anyway', async () => {
+        const stale = [];
+        for (const [file, waived] of Object.entries(HIDDEN_OK)) {
+            const help = await helpTextOf(file);
+            for (const verb of Object.keys(waived)) {
+                if (new RegExp(`^\\s+\`?${verb}\\b`, 'm').test(help))
+                    stale.push(`${file}: ${verb}`);
+            }
+            printed = [];
+        }
+        expect(stale, 'these are in the help now, so the waiver claims a gap that is ' +
+            'closed — delete the entry.').toEqual([]);
+    });
+    it('found command modules to check (or this test proves nothing)', () => {
+        expect(files.length).toBeGreaterThan(10);
+    });
+    for (const file of files) {
+        const src = readFileSync(path.join(COMMANDS_DIR, file), 'utf8');
+        const verbs = dispatchedVerbs(src);
+        if (!verbs.length)
+            continue;
+        it(`${file} lists all ${verbs.length} of its verbs`, async () => {
+            const help = await helpTextOf(file);
+            // A module whose bare `run()` does not print help has nothing to check
+            // here; its verbs are reachable from the parent listing.
+            if (!help.trim())
+                return;
+            const waived = HIDDEN_OK[file] ?? {};
+            const missing = verbs
+                .filter(v => !(v in waived))
+                // Listed means: named at the start of an indented line, the shape
+                // every command uses for its entries.
+                .filter(v => !new RegExp(`^\\s+\`?${v}\\b`, 'm').test(help));
+            expect(missing, `${file}: ${missing.join(', ')} dispatch but are not in the ` +
+                'help this command prints. A verb nobody can find is a verb nobody has — ' +
+                'add it to the listing, or to HIDDEN_OK with a reason.').toEqual([]);
+        });
+    }
+});

package/dist/commands/org-delete-confirm.test.d.ts

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

package/dist/commands/org-delete-confirm.test.js

@@ -0,0 +1,121 @@
+// `myapi org delete --yes` could not delete any org that owned anything.
+//
+// The API hard-deletes an org across 36 tables with no undo, so it refuses one
+// that still owns resources unless the caller names it back: `?confirm=<id>`.
+// That design is right. The SDK never sent the parameter, and the CLI's `--yes`
+// only skipped its own local prompt — so the call came back 409 CONFIRM_REQUIRED
+// with a message telling the user to "repeat the call with ?confirm=", which is
+// HTTP-shaped advice a CLI user cannot act on.
+//
+// Creating an org provisions a funnel, so an org is non-empty from birth. This
+// was not an edge case: the verb could not delete anything, while its own help
+// said `--yes` was all a non-interactive run needed.
+//
+// Found by the probe, on its own cleanup step, on its first run — which is the
+// argument for having a probe. It is invisible to the reverse request-field
+// linter because `confirm` is a query parameter, and that linter reads request
+// BODIES only; it says so in its own limits.
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+const ORG = '11111111-1111-4111-8111-111111111111';
+const sdk = vi.hoisted(() => ({
+    hq: { getOrg: vi.fn(), deleteOrg: vi.fn() },
+    MyApiError: class MyApiError extends Error {
+        code = '';
+        status = 0;
+    },
+}));
+vi.mock('@myapihq/sdk', () => sdk);
+vi.mock('../config.js', () => ({
+    requireConfig: () => ({ api_key: 'hq_live_test', default_org: ORG }),
+    loadConfig: () => ({ api_key: 'hq_live_test', default_org: ORG }),
+    CONFIG_DIR: '/tmp/nowhere',
+}));
+// Non-interactive, so `--yes` is the only way through and no prompt can hang.
+vi.mock('../prompt.js', () => ({
+    confirm: vi.fn(async () => false),
+    isNonInteractive: () => true,
+}));
+function confirmRequired(owns) {
+    const e = new Error('CONFIRM_REQUIRED');
+    e.code = 'CONFIRM_REQUIRED';
+    e.status = 409;
+    e.body = { code: 'CONFIRM_REQUIRED', owns };
+    return e;
+}
+let printed;
+let exitError;
+beforeEach(async () => {
+    printed = [];
+    exitError = null;
+    // resetAllMocks, not clearAllMocks: `clear` resets call counts but leaves
+    // queued mockRejectedValueOnce values in place. The "refuses without --yes"
+    // case never consumes its queued rejection — it stops at the local guard —
+    // so with `clear` that rejection leaked into the next test and made it see a
+    // retry that its own setup never asked for.
+    vi.resetAllMocks();
+    sdk.hq.getOrg.mockResolvedValue({ id: ORG, name: 'Probe' });
+    const output = await import('../output.js');
+    vi.spyOn(output, 'info').mockImplementation(((m) => { printed.push(String(m)); }));
+    vi.spyOn(output, 'success').mockImplementation(((m) => { printed.push(String(m)); }));
+    vi.spyOn(output, 'error').mockImplementation(((m) => {
+        exitError = String(m);
+        throw new Error('__EXIT__');
+    }));
+});
+afterEach(() => vi.restoreAllMocks());
+async function run(fn) {
+    try {
+        await fn();
+    }
+    catch (e) {
+        if (e?.message !== '__EXIT__')
+            throw e;
+    }
+}
+describe('org delete — the confirm gate', () => {
+    it('retries with confirm when the API asks, so --yes can actually delete', async () => {
+        sdk.hq.deleteOrg
+            .mockRejectedValueOnce(confirmRequired(['1 funnel', '1 CRM contact']))
+            .mockResolvedValueOnce(undefined);
+        const { del } = await import('./org.js');
+        await run(() => del(ORG, { yes: true }));
+        expect(sdk.hq.deleteOrg).toHaveBeenCalledTimes(2);
+        expect(sdk.hq.deleteOrg).toHaveBeenNthCalledWith(1, 'hq_live_test', ORG);
+        expect(sdk.hq.deleteOrg).toHaveBeenNthCalledWith(2, 'hq_live_test', ORG, { confirm: true });
+        expect(printed.join('\n')).toMatch(/Org .*deleted/);
+    });
+    it('shows what would be destroyed before destroying it', async () => {
+        // The refusal carries the inventory, and it is the ONLY place it can be
+        // seen — after the delete there is nothing left to look at.
+        sdk.hq.deleteOrg
+            .mockRejectedValueOnce(confirmRequired(['3 containers', '1 domain']))
+            .mockResolvedValueOnce(undefined);
+        const { del } = await import('./org.js');
+        await run(() => del(ORG, { yes: true }));
+        expect(printed.join('\n')).toContain('3 containers, 1 domain');
+    });
+    it('does not send confirm on the first attempt', async () => {
+        // An empty org deletes without ceremony; sending confirm unconditionally
+        // would turn the gate into decoration for every org.
+        sdk.hq.deleteOrg.mockResolvedValueOnce(undefined);
+        const { del } = await import('./org.js');
+        await run(() => del(ORG, { yes: true }));
+        expect(sdk.hq.deleteOrg).toHaveBeenCalledTimes(1);
+        expect(sdk.hq.deleteOrg).toHaveBeenCalledWith('hq_live_test', ORG);
+    });
+    it('refuses without --yes rather than confirming on the user behalf', async () => {
+        sdk.hq.deleteOrg.mockRejectedValueOnce(confirmRequired(['1 funnel']));
+        const { del } = await import('./org.js');
+        await run(() => del(ORG, {}));
+        // Non-interactive without --yes stops at the local guard, before any call.
+        expect(exitError).toMatch(/--yes/);
+    });
+    it('passes other errors through instead of retrying blind', async () => {
+        const boom = new Error('NOT_FOUND');
+        boom.code = 'NOT_FOUND';
+        sdk.hq.deleteOrg.mockRejectedValueOnce(boom);
+        const { del } = await import('./org.js');
+        await expect(del(ORG, { yes: true })).rejects.toThrow('NOT_FOUND');
+        expect(sdk.hq.deleteOrg).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/commands/org.js

@@ -135,7 +135,35 @@ export async function del(id, flags) {
         if (!ok)
             error('Aborted.');
     }
-    await hq.deleteOrg(config.api_key, id);
+    // First without confirm. The API refuses a non-empty org with an inventory of
+    // what would be destroyed, and that inventory is the only place it can be
+    // seen — after the delete there is nothing left to look at. So the refusal is
+    // not an error to route around; it is the thing worth showing.
+    try {
+        await hq.deleteOrg(config.api_key, id);
+    }
+    catch (e) {
+        const err = e;
+        if (err?.code !== 'CONFIRM_REQUIRED')
+            throw e;
+        // `body` is the backend's error object verbatim; CONFIRM_REQUIRED carries
+        // the inventory in `owns`.
+        const owns = Array.isArray(err.body?.owns) ? err.body.owns : undefined;
+        info(owns?.length
+            ? `This org still owns ${owns.join(', ')}. Deleting it destroys all of that permanently.`
+            : 'This org still owns resources. Deleting it destroys all of them permanently.');
+        if (!flags.yes) {
+            const ok = await confirm(`› Delete ${label} and everything it owns? (y/N) `, false);
+            if (!ok)
+                error('Aborted. Nothing was deleted.');
+        }
+        // --yes already means "I am not being asked again", and the inventory has
+        // been printed either way. Previously this path did not exist at all: the
+        // API told the caller to "repeat the call with ?confirm=", advice a CLI
+        // user could not act on, so `org delete --yes` could not delete any org
+        // that owned anything — which is every org, since create provisions a funnel.
+        await hq.deleteOrg(config.api_key, id, { confirm: true });
+    }
     success(`Org ${label} deleted`);
 }
 // Update one or more fields of an org. At least one --flag must be supplied;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@myapihq/cli",
   "license": "Apache-2.0",
-  "version": "2.25.0",
+  "version": "2.25.2",
   "description": "MyAPI command-line interface",
   "repository": {
     "type": "git",
@@ -46,7 +46,7 @@
     "lint:skills:strict": "node scripts/copy-skills.js && node scripts/lint-skills.js --strict"
   },
   "dependencies": {
-    "@myapihq/sdk": "^2.25.0"
+    "@myapihq/sdk": "^2.25.2"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",