@myapihq/cli 2.26.0 → 2.26.1

package/dist/commands/org-create-default.test.d.ts

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

package/dist/commands/org-create-default.test.js

@@ -0,0 +1,108 @@
+// `org create --yes` used to re-point the whole machine.
+//
+// --yes meant two things at once: skip the "set as default?" prompt, AND make
+// the new org the default. Since `org create --name X --yes` is the documented
+// non-interactive form, every scripted or agent-driven org creation retargeted
+// the machine's default org — so a throwaway org made by one project became the
+// target of every bare command in every other project on that laptop.
+//
+// That is the cross-project collision customers report, arriving through a door
+// nobody was watching: they were told to stop using `config set-org`, and
+// `org create --yes` kept doing it to them anyway. It moved my own default org
+// twice in one day, once while I was building the fix for the other door.
+//
+// The two meanings are now separate, and the interesting assertions are about
+// what does NOT happen.
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+const ORG_A = 'aaaaaaaa-1111-4111-8111-aaaaaaaaaaaa';
+const NEW_ORG = 'nnnnnnnn-2222-4222-8222-nnnnnnnnnnnn';
+const sdk = vi.hoisted(() => ({
+    hq: { createOrg: vi.fn() },
+    funnel: { listFunnels: vi.fn() },
+}));
+vi.mock('@myapihq/sdk', () => sdk);
+const saved = vi.hoisted(() => []);
+let stored;
+vi.mock('../config.js', () => ({
+    requireConfig: () => ({ ...stored }),
+    loadConfig: () => ({ ...stored }),
+    saveConfig: (c) => { saved.push(c); },
+    CONFIG_DIR: '/tmp/nowhere',
+}));
+const confirmMock = vi.hoisted(() => vi.fn());
+vi.mock('../prompt.js', () => ({
+    confirm: confirmMock,
+    isNonInteractive: () => false,
+}));
+let printed;
+beforeEach(async () => {
+    saved.length = 0;
+    printed = [];
+    vi.clearAllMocks();
+    stored = { api_key: 'hq_live_test', account_id: 'acct' };
+    sdk.hq.createOrg.mockResolvedValue({ id: NEW_ORG, name: 'Throwaway' });
+    sdk.funnel.listFunnels.mockResolvedValue([]);
+    const output = await import('../output.js');
+    const cap = ((m) => { printed.push(String(m)); });
+    vi.spyOn(output, 'info').mockImplementation(cap);
+    vi.spyOn(output, 'success').mockImplementation(cap);
+    vi.spyOn(output, 'printJson').mockImplementation(cap);
+    vi.spyOn(output, 'error').mockImplementation(((m) => {
+        printed.push(String(m));
+        throw new Error('__EXIT__');
+    }));
+});
+afterEach(() => vi.restoreAllMocks());
+async function createOrg(flags) {
+    const { create } = await import('./org.js');
+    try {
+        await create(['Throwaway'], flags);
+    }
+    catch (e) {
+        if (e?.message !== '__EXIT__')
+            throw e;
+    }
+}
+describe('org create and the machine default', () => {
+    it('--yes does NOT re-point an existing default', async () => {
+        stored.default_org = ORG_A;
+        await createOrg({ yes: true });
+        expect(saved).toEqual([]);
+    });
+    it('says the default is unchanged, rather than saying nothing', async () => {
+        // Silence is what let a throwaway org take over a machine without anyone
+        // noticing which command did it.
+        stored.default_org = ORG_A;
+        stored.org_names = { [ORG_A]: 'Real Work' };
+        await createOrg({ yes: true });
+        const out = printed.join('\n');
+        expect(out).toMatch(/default org is unchanged/i);
+        expect(out).toContain('Real Work');
+        expect(out).toContain(`myapi init --org ${NEW_ORG}`);
+    });
+    it('--set-default re-points it, because that was asked for by name', async () => {
+        stored.default_org = ORG_A;
+        await createOrg({ yes: true, 'set-default': true });
+        expect(saved.at(-1)).toMatchObject({ default_org: NEW_ORG });
+    });
+    it('sets the default when there is none, since nothing can be clobbered', async () => {
+        // A user with no default cannot run an org-scoped command at all, so the
+        // first org is pure gain.
+        await createOrg({ yes: true });
+        expect(saved.at(-1)).toMatchObject({ default_org: NEW_ORG });
+        expect(printed.join('\n')).toMatch(/no default org/i);
+    });
+    it('still asks when interactive without --yes, and honours a no', async () => {
+        stored.default_org = ORG_A;
+        confirmMock.mockResolvedValue(false);
+        await createOrg({});
+        expect(confirmMock).toHaveBeenCalled();
+        expect(saved).toEqual([]);
+    });
+    it('honours a yes at the prompt', async () => {
+        stored.default_org = ORG_A;
+        confirmMock.mockResolvedValue(true);
+        await createOrg({});
+        expect(saved.at(-1)).toMatchObject({ default_org: NEW_ORG });
+    });
+});

package/dist/commands/org.js

@@ -21,6 +21,9 @@ export const SCHEMA = {
     description: 'string',
     'business-sector': 'string',
     'logo-url': 'string',
+    // Setting the machine's default org is now something you ask for, not
+    // something --yes does to you on the way past.
+    'set-default': 'boolean',
     org: 'string',
 };
 const SYNC_BRAND_TIMEOUT_MS = 5 * 60 * 1000;
@@ -45,11 +48,23 @@ export async function create(restArgs, flags) {
             info(`Preview domain: https://${org.preview_subdomain}.makeautonomous.com`);
         }
     }
-    // Never re-point the CLI's defaults on a silent fallback: in non-interactive
-    // contexts (CI, agent pipelines) only --yes may switch the default org —
-    // an unanswered prompt must not count as consent.
-    const setDefault = !!flags.yes ||
-        (!isNonInteractive() && await confirm('› Set as default org and funnel? (Y/n) ', true));
+    // `--yes` used to mean two things: skip the prompt, AND make this the default
+    // org. Since `org create --name X --yes` is the documented non-interactive
+    // form, every scripted or agent-driven org creation silently re-pointed the
+    // machine's default — so a throwaway org created by one project became the
+    // target of every bare command in every other project on that machine. That
+    // is the cross-project collision customers report, arriving through a door
+    // nobody was watching. I did it to my own default org twice in one day.
+    //
+    // Now the two are separate:
+    //   - no default yet   → set it. First org, nothing to clobber, and a user
+    //                        with no default cannot run an org-scoped command.
+    //   - --set-default    → set it, because it was asked for by name.
+    //   - interactive      → ask, as before. A prompt is consent.
+    //   - --yes with an existing default → leave it alone and say so.
+    const hasDefault = !!config.default_org;
+    const setDefault = !!flags['set-default'] || !hasDefault ||
+        (!flags.yes && !isNonInteractive() && await confirm('› Set as default org and funnel? (Y/n) ', true));
     let funnelId;
     if (setDefault) {
         config.default_org = org.id;
@@ -59,8 +74,18 @@ export async function create(restArgs, flags) {
             funnelId = funnels[0].id;
         }
         saveConfig(config);
-        if (!flags.json)
+        if (!flags.json) {
             success(`Default org${funnelId ? ' and funnel' : ''} updated.`);
+            if (!hasDefault)
+                info('  (you had no default org — set because an org-scoped command needs one)');
+        }
+    }
+    else if (!flags.json && hasDefault) {
+        // Say what did NOT happen. Silence here is what let a throwaway org take
+        // over a machine without anyone noticing which command did it.
+        const name = config.org_names?.[config.default_org] ?? config.default_org;
+        info(`  Your default org is unchanged (${name}).`);
+        info(`  Work in the new one with: myapi init --org ${org.id}   (binds this directory only)`);
     }
     if (flags.json) {
         const result = { id: org.id, name: org.name };
@@ -232,16 +257,25 @@ 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]
+    'create': `myapi org create <name> [--tagline <str>] [--description <str>] [--business-sector <str>] [--logo-url <url>] [--yes] [--set-default] [--json]
        myapi org create --name <name> [...]
 
 Creates a new organization. A funnel (website) is automatically created alongside it.
-Pass --yes to skip the "set as default?" prompt (useful in CI / agent workflows).
+
+--yes skips the "set as default?" prompt and leaves your default org ALONE.
+--set-default points your machine's default at the new org.
+
+They are separate because they used to be the same flag: every scripted
+\`org create --yes\` re-pointed the whole machine, so a throwaway org created by
+one project became the target of bare commands in every other project.
+
+To work in the new org without touching anything else, bind the directory:
+  myapi init --org <new-org-id>
 
 Examples:
   myapi org create "Acme Inc"
-  myapi org create "Acme Inc" --yes
-  myapi org create --name "Acme Inc" --yes`,
+  myapi org create "Acme Inc" --yes                 # default org untouched
+  myapi org create "Acme Inc" --yes --set-default`,
     'get': 'myapi org get <id> [--json]',
     'delete': `myapi org delete <id> [--yes]
 

package/dist/index.js

@@ -518,7 +518,7 @@ Commands:
   install-skills  Install or update the MyAPI skills pack for AI agents
   llm             Run LLM completions and embeddings (chat + embed, with usage/cost)
   login           Sign in via your browser — Google or email code (preview: --mock)
-  org             Manage organizations (tip: myapi org create "name" --yes to auto-set as default)
+  org             Manage organizations (create, list, delete; --set-default to re-point the machine)
   payments        Take payments with Stripe Checkout (connect, charge, refund)
   people          Search the contact database (filter by industry, seniority, country, ...)
   pixel           Read pixel analytics: visits, events, identity resolution

package/dist/regression-register.test.d.ts

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

package/dist/regression-register.test.js

@@ -0,0 +1,71 @@
+// Every customer incident names the guard that fails if it comes back — and
+// this checks the guard is really there.
+//
+// A register that nobody verifies is worse than none: it reads as "we checked,
+// we know" while the test it names has been renamed, skipped or deleted. That
+// exact rot has already happened three times in this repo's linters, in the
+// form of waivers claiming gaps that were closed.
+//
+// So the register is only as good as this file. It asserts, for every entry:
+// the guard file exists, it still contains the named assertion, and that
+// assertion is not skipped. Entries with no guard must say why, so a gap is
+// counted rather than quietly absent.
+//
+// What it deliberately does NOT claim: that we have thought of everything. It
+// covers incidents customers have already hit. The unknown ones are the
+// probe's job (scripts/probe/probe.mjs) — this is memory, that is discovery.
+import { describe, it, expect } from 'vitest';
+import { readFileSync, existsSync } from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const REPO_ROOT = fileURLToPath(new URL('../../../', import.meta.url));
+const REGISTER = path.join(REPO_ROOT, 'regressions.json');
+const register = JSON.parse(readFileSync(REGISTER, 'utf-8'));
+describe('the regression register', () => {
+    it('has entries (or it is a file that proves nothing)', () => {
+        expect(register.incidents.length).toBeGreaterThanOrEqual(9);
+    });
+    it.each(register.incidents.map(i => [i.id, i]))('%s — its guard exists and still asserts it', (_id, incident) => {
+        const guardPath = path.join(REPO_ROOT, incident.guard.file);
+        expect(existsSync(guardPath), `${incident.guard.file} is named as the guard for ` +
+            `"${incident.id}" and does not exist. Either restore it, or move the incident to ` +
+            '"unguarded" with the reason — silently dropping the guard is how a fixed bug ' +
+            'comes back.').toBe(true);
+        const source = readFileSync(guardPath, 'utf-8');
+        expect(source.includes(incident.guard.test), `${incident.guard.file} no longer contains "${incident.guard.test}".\n` +
+            `That assertion is the only thing standing between this customer and:\n  ` +
+            `${incident.symptom}\n` +
+            'Renaming it is fine — update regressions.json to match.').toBe(true);
+    });
+    it.each(register.incidents.map(i => [i.id, i]))('%s — its guard is not skipped', (_id, incident) => {
+        const source = readFileSync(path.join(REPO_ROOT, incident.guard.file), 'utf-8');
+        // A skipped guard is the worst shape: present, green, and asserting
+        // nothing. Cheaper to catch here than to discover from a repeat report.
+        const skipped = new RegExp(`(it|test|describe)\\.(skip|todo)\\(\\s*['\`"]${escapeRe(incident.guard.test)}`).test(source) || /describe\.skip\(/.test(source);
+        expect(skipped, `the guard for "${incident.id}" is skipped`).toBe(false);
+    });
+    it('every incident says who it cost and what it cost them', () => {
+        // The register is read when someone is deciding whether a behaviour is safe
+        // to change. Without the cost it reads as a list of trivia, and gets
+        // treated like one.
+        const thin = register.incidents.filter(i => !i.symptom?.trim() || !i.cost?.trim() || !i.customer?.trim());
+        expect(thin.map(i => i.id)).toEqual([]);
+    });
+    it('every unguarded gap explains itself, so none is silent', () => {
+        const unexplained = (register.unguarded ?? []).filter(u => !u.why_no_guard_here?.trim());
+        expect(unexplained.map(u => u.id)).toEqual([]);
+    });
+    it('reports how much is NOT guarded here, rather than only what is', () => {
+        // Printed on every run. A register that only ever shows its green half
+        // teaches the reader it is complete, which is the one thing it is not.
+        const gaps = register.unguarded ?? [];
+        // eslint-disable-next-line no-console
+        console.log(`  regression register: ${register.incidents.length} incident(s) guarded here, ` +
+            `${gaps.length} not (${gaps.filter(g => g.cross_repo).length} guarded in myapi-hq, ` +
+            `${gaps.filter(g => !g.cross_repo).length} not guarded anywhere).`);
+        expect(Array.isArray(gaps)).toBe(true);
+    });
+});
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

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

@@ -1,10 +1,10 @@
 ---
 name: my-api-hq
-version: 1.3.1
+version: 1.3.2
 description: >
   Auth, organizations, and billing hub. Start here to get an api_key and org_id — every other service depends on both.
 triggers: [api key, account, organization, org, billing, balance, topup, credits, setup, defaults, brand, sync brand, doctor, health check, is my org healthy]
-checksum: sha256-f8e308fd3cd4b0ed4097e6f54c620e49cfe59c5b4275cfea4c1a0e18dd78f5e4
+checksum: sha256-d09b77d74b93ca44d7b913fce6b684a6dda21d0dff9efe2686143abffeb217ee
 ---
 
 # MyApiHQ
@@ -26,7 +26,7 @@ An anonymous account upgrades any time with `myapi account link <email>`; the cr
 
 ### Health check
 
-`myapi doctor` runs an org-wide consistency check across every slot, plus customer-perspective DNS/HTTP probes from your machine. It returns per-section findings (`✓` pass / `⚠` warning / `✗` critical) with remediation hints; add `--json` for machine output. The exit code is non-zero **only** on customer-actionable criticals — platform-side issues the MyAPI team is already handling are surfaced with an `ℹ` marker but don't fail the run. Run it to self-check before building (is the org set up?) and after (did everything wire up?).
+`myapi doctor` runs an org-wide consistency check across every slot, plus customer-perspective DNS/HTTP probes from your machine. Per-section findings (`✓` / `⚠` / `✗`) with remediation hints; `--json` for machine output. Exit is non-zero **only** on customer-actionable criticals — platform-side issues show as `ℹ` and do not fail the run, so it works as a CI gate.
 <!-- llm:end -->
 
 ## Commands
@@ -57,6 +57,7 @@ An anonymous account upgrades any time with `myapi account link <email>`; the cr
 | `myapi account mailing-address ["<address>"]` | Get or set the account's CAN-SPAM mailing address (required for email send) |
 | `myapi init --org <id>` | Bind this directory to one org: locked key + `.myapi.json` (`--force` re-binds). Use instead of `config set-org` when a machine has more than one project |
 | `myapi config set-org <id>` / `set-funnel <id>` / `set-domain <name>` | Set machine-wide CLI defaults (single-project machines only) |
+| `myapi org create <name> --yes` | Create an org; your default org is untouched (`--set-default` re-points it) |
 | `myapi install-skills` | Install agent skills into ~/.claude/, ~/.gemini/, ~/.cursor/ |
 | `myapi doctor [--verbose] [--json]` | Org-wide health check: config/integrity findings + DNS/HTTP probes |
 <!-- generated:end -->

package/package.json

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