@myapihq/cli 2.23.3 → 2.25.0

package/dist/commands/container-patch-coverage.test.d.ts

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

package/dist/commands/container-patch-coverage.test.js

@@ -0,0 +1,111 @@
+// Every field PATCH accepts must be one a CLI verb can actually send.
+//
+// A container setting that can be given at creation and not changed afterwards
+// is not a missing convenience — it is a delete-and-recreate, and recreating a
+// container loses its URL, its scoped key and its custom domain binding.
+//
+// That has now happened twice. `env` was create-only, and a customer recreated
+// containers three times in a week to edit variables. Then `health_check` was
+// create-only, and a customer paid for a production swap to adopt a probe.
+// Both times the backend widened PATCH and the CLI did not follow, so the fix
+// reached nobody: the route accepted a field that no client ever sent, and
+// nothing on either side was red.
+//
+// So this is driven from the schema snapshot rather than a hand-kept list, and
+// it asserts on what arrives at the SDK boundary rather than on the shape of
+// our source — testing the parser proves the flag parses, not that it is sent.
+// When the backend adds a field to this PATCH body, this fails until a verb
+// can send it.
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFileSync } from 'node:fs';
+const ORG = '11111111-1111-4111-8111-111111111111';
+const sdk = vi.hoisted(() => ({
+    container: {
+        updateContainer: vi.fn(),
+        updateContainerEnv: vi.fn(),
+    },
+    withFundsRetry: vi.fn(async (f) => f()),
+    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',
+}));
+const SNAPSHOT = JSON.parse(readFileSync(new URL('../../schema-snapshot.json', import.meta.url), 'utf8'));
+const PATCH_ROUTE = '/container/orgs/{org_id}/containers/{id}';
+function patchBodyFields() {
+    const op = SNAPSHOT.paths?.[PATCH_ROUTE]?.patch;
+    const props = op?.requestBody?.content?.['application/json']?.schema?.properties;
+    return props ? Object.keys(props) : [];
+}
+const APPLIED = { set: [], removed: [], applied: true, env: {}, revision: 'rev-2' };
+beforeEach(async () => {
+    vi.clearAllMocks();
+    sdk.container.updateContainer.mockResolvedValue(APPLIED);
+    sdk.container.updateContainerEnv.mockResolvedValue(APPLIED);
+    const output = await import('../output.js');
+    vi.spyOn(output, 'error').mockImplementation(((m) => {
+        throw new Error('__EXIT__');
+    }));
+    vi.spyOn(output, 'info').mockImplementation(() => { });
+    vi.spyOn(output, 'success').mockImplementation(() => { });
+    vi.spyOn(output, 'printJson').mockImplementation(() => { });
+});
+afterEach(() => vi.restoreAllMocks());
+async function run(fn) {
+    try {
+        await fn();
+    }
+    catch (e) {
+        if (e?.message !== '__EXIT__')
+            throw e;
+    }
+}
+// Drives each verb that patches a container and collects the body keys that
+// actually reach the SDK.
+async function fieldsTheCliCanSend() {
+    const container = await import('./container.js');
+    const sent = new Set();
+    await run(() => container.run('env', ['c1'], { env: 'A=1', org: ORG }));
+    await run(() => container.run('health-check', ['c1', '/livez'], { org: ORG }));
+    for (const call of sdk.container.updateContainer.mock.calls) {
+        Object.keys(call[3] ?? {}).forEach(k => sent.add(k));
+    }
+    // The env shorthand takes the map itself rather than a patch object.
+    if (sdk.container.updateContainerEnv.mock.calls.length)
+        sent.add('env');
+    return sent;
+}
+describe('container PATCH coverage', () => {
+    it('the snapshot still describes this route (or the test measures nothing)', () => {
+        // Without this, a renamed route upstream would leave an empty field list
+        // and a permanently, silently green test.
+        expect(patchBodyFields().length).toBeGreaterThan(0);
+    });
+    it('every field PATCH accepts is one a CLI verb actually sends', async () => {
+        const sent = await fieldsTheCliCanSend();
+        const unreachable = patchBodyFields().filter(f => !sent.has(f));
+        expect(unreachable, `PATCH ${PATCH_ROUTE} accepts ${unreachable.join(', ')}, but no CLI ` +
+            'verb sends it. Until one does, changing that setting means deleting the ' +
+            'container and creating another — which loses the URL, the scoped key and ' +
+            'the custom domain.').toEqual([]);
+    });
+    it('clearing the probe sends the empty string the API defines for it', async () => {
+        // '' is how the API says "no probe". The verb spells it --clear so nobody
+        // has to discover that an empty string is the meaningful value, but the
+        // wire form still has to be right.
+        const container = await import('./container.js');
+        await run(() => container.run('health-check', ['c1'], { clear: true, org: ORG }));
+        expect(sdk.container.updateContainer).toHaveBeenCalledWith('hq_live_test', ORG, 'c1', { health_check: '' });
+    });
+    it('refuses /healthz before it costs a round trip', async () => {
+        const container = await import('./container.js');
+        await run(() => container.run('health-check', ['c1', '/healthz'], { org: ORG }));
+        expect(sdk.container.updateContainer).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/container.d.ts

@@ -12,7 +12,9 @@ export declare function splitEnvEntries(raw: string): string[];
 export declare function create(nameArg: string | undefined, flags: Flags): Promise<void>;
 export declare function list(flags: Flags): Promise<void>;
 export declare function get(id: string, flags: Flags): Promise<void>;
+export declare function healthCheck(id: string, flags: Flags): Promise<void>;
 export declare function del(id: string, flags: Flags): Promise<void>;
+export declare function _checkProbePath(hc: string): string;
 export declare function _isTarball(p: string): boolean;
 export declare function deploy(id: string, image: string, flags: Flags): Promise<void>;
 export declare function _parseSmoke(raw: string): sdkContainer.SmokeCheck;

package/dist/commands/container.js

@@ -34,6 +34,7 @@ export const SCHEMA = {
     scope: 'string',
     'no-promote': 'boolean',
     'health-check': 'string',
+    clear: 'boolean',
     smoke: 'string',
     remove: 'boolean',
     source: 'string',
@@ -147,15 +148,7 @@ export async function create(nameArg, flags) {
     if (typeof flags.port === 'number')
         payload.port = flags.port;
     if (typeof flags['health-check'] === 'string') {
-        const hc = flags['health-check'];
-        // The API refuses /healthz, but say so here rather than round-tripping:
-        // the reason is specific and worth stating where the user typed it.
-        if (/^\/?healthz\/?$/i.test(hc)) {
-            error('The runtime intercepts /healthz, so a probe against it never reaches your container —\nit would report healthy no matter what your code does. Use /livez, or any other path.');
-        }
-        if (!hc.startsWith('/'))
-            error(`--health-check must be a path starting with "/" — got "${hc}".`);
-        payload.health_check = hc;
+        payload.health_check = _checkProbePath(flags['health-check']);
     }
     // Repeatable, and create must agree with `container env` on what --env means.
     // If they disagree, a variable settable at creation cannot be changed
@@ -218,6 +211,7 @@ export async function get(id, flags) {
     if (c.port)
         info(`Port:            ${c.port}`);
     info(`URL:             ${c.url || '(not deployed)'}`);
+    info(`Startup probe:   ${c.health_check || '(none)'}`);
     if (c.egress)
         info(`Egress:          ${c.egress}`);
     if (c.custom_domain)
@@ -225,6 +219,39 @@ export async function get(id, flags) {
     info(`Created:         ${c.created_at}`);
     info(`Updated:         ${c.updated_at}`);
 }
+export async function healthCheck(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi container health-check <id> <path> [--clear]');
+    if (!id)
+        error('Missing id.\nUsage: myapi container health-check <id> /livez   (or --clear to remove it)');
+    const pathArg = typeof flags._probePath === 'string' ? flags._probePath : undefined;
+    if (flags.clear && pathArg) {
+        error('Pass a path or --clear, not both.');
+    }
+    if (!flags.clear && !pathArg) {
+        error('Nothing to change.\nUsage: myapi container health-check <id> /livez   (or --clear to remove the probe)');
+    }
+    // '' is how the API says "no probe" — the verb spells that --clear so nobody
+    // has to discover that an empty string is meaningful.
+    const value = flags.clear ? '' : _checkProbePath(pathArg);
+    info(value ? `› Setting startup probe to ${value}…` : '› Clearing the startup probe…');
+    const res = await sdkContainer.updateContainer(config.api_key, orgId, id, { health_check: value });
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    // Same distinction `container env` draws: stored and live are different
+    // states, and only one of them is what the caller asked for.
+    if (res.applied) {
+        success(`Redeployed on the same image — the probe is live${res.revision ? ` (${res.revision})` : ''}.`);
+    }
+    else {
+        info('  Stored. This container has no deployment yet, so it applies on your first deploy.');
+    }
+    info(value
+        ? `  The runtime now waits for ${value} to answer before sending traffic to a new revision.`
+        : '  No startup probe: a new revision takes traffic as soon as the runtime reports it started.');
+}
 export async function del(id, flags) {
     const config = requireConfig();
     const orgId = requireOrg(flags, config, 'myapi container delete <id> [--yes] [--org <id>]');
@@ -234,6 +261,22 @@ export async function del(id, flags) {
     await sdkContainer.deleteContainer(config.api_key, orgId, id);
     success(`Deleted container ${id} (org ${orgId})`);
 }
+// The probe path is validated in exactly one place because `create` and
+// `health-check` must agree on what a valid one is. When a setting is accepted
+// at creation and rejected (or unreachable) afterwards, changing it becomes a
+// delete-and-recreate — which costs the URL, the scoped key and the custom
+// domain. That is the bug this verb exists to close; it should not reappear as
+// a validation mismatch.
+export function _checkProbePath(hc) {
+    // The API refuses /healthz, but say so here rather than round-tripping:
+    // the reason is specific and worth stating where the user typed it.
+    if (/^\/?healthz\/?$/i.test(hc)) {
+        error('The runtime intercepts /healthz, so a probe against it never reaches your container —\nit would report healthy no matter what your code does. Use /livez, or any other path.');
+    }
+    if (!hc.startsWith('/'))
+        error(`A health check must be a path starting with "/" — got "${hc}".`);
+    return hc;
+}
 // _isTarball returns true if the path looks like an already-built tar archive
 // (so we upload it as-is instead of tarring a directory).
 export function _isTarball(p) {
@@ -711,6 +754,18 @@ domain's MyAPI-managed parent domain must already be registered.
 
 Example:
   myapi container domain <id> app.synthesisdaily.com`,
+    'health-check': `myapi container health-check <id> <path> [--clear] [--org <id>]
+
+Set or clear the startup probe on an existing container, rolling a new
+revision on the SAME image. No rebuild.
+
+The runtime waits for this path to answer before sending traffic to a new
+revision, so a bad deploy is caught before it takes any. Not /healthz — the
+runtime answers that before it reaches your container, so the probe would
+pass while your app is down.
+
+  myapi container health-check <id> /livez
+  myapi container health-check <id> --clear`,
     'delete': 'myapi container delete <id> [--org <id>]',
 };
 export async function run(subcommand, args, flags) {
@@ -814,6 +869,7 @@ All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         case 'revisions': return revisions(args[0], flags);
         case 'promote': return promote(args[0], args[1], flags);
         case 'domain': return domain(args[0], args[1], flags);
+        case 'health-check': return healthCheck(args[0], { ...flags, _probePath: args[1] });
         case 'delete': return del(args[0], flags);
         case 'rollback': return rollback(args[0], flags);
         default: error(`Unknown subcommand: ${subcommand}. Run "myapi container --help" for a list of valid subcommands.`);

package/dist/commands/crm/companies.js

@@ -97,9 +97,10 @@ async function get(id, flags) {
 }
 async function update(id, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi crm companies update <id> [--stage <s>] [--name <n>] [--custom-json <json>] [--org <id>]');
+    const orgId = requireOrg(flags, config, 'myapi crm companies update <id> [--domain <d>] [--stage <s>] [--name <n>] [--custom-json <json>] [--org <id>]');
     requireArg(id, 'id', 'myapi crm companies update <id>');
     const patch = {
+        domain: typeof flags.domain === 'string' ? flags.domain : undefined,
         name: typeof flags.name === 'string' ? flags.name : undefined,
         lifecycle_stage: typeof flags.stage === 'string' ? flags.stage : undefined,
         custom: parseCustom(flags['custom-json']),

package/dist/commands/crm/contacts.js

@@ -111,9 +111,10 @@ async function get(id, flags) {
 }
 async function update(id, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi crm contacts update <id> [--stage <s>] [--first-name <n>] [--last-name <n>] [--company-id <id>] [--custom-json <json>] [--org <id>]');
+    const orgId = requireOrg(flags, config, 'myapi crm contacts update <id> [--email <a>] [--stage <s>] [--first-name <n>] [--last-name <n>] [--company-id <id>] [--custom-json <json>] [--org <id>]');
     requireArg(id, 'id', 'myapi crm contacts update <id>');
     const patch = {
+        email: typeof flags.email === 'string' ? flags.email : undefined,
         first_name: typeof flags['first-name'] === 'string' ? flags['first-name'] : undefined,
         last_name: typeof flags['last-name'] === 'string' ? flags['last-name'] : undefined,
         company_id: typeof flags['company-id'] === 'string' ? flags['company-id'] : undefined,
@@ -125,6 +126,14 @@ async function update(id, flags) {
         printJson(c);
         return;
     }
+    // The API returns the row it re-read, so a change that did not take is
+    // visible here. Email is the one that can collide with another contact, and
+    // reporting "updated" for a write that did not happen is worse than the
+    // failure itself.
+    if (patch.email && c.email?.toLowerCase() !== patch.email.trim().toLowerCase()) {
+        error(`The email was NOT changed — it is still ${c.email}.\n` +
+            `Another contact in this org most likely already uses ${patch.email}.`);
+    }
     success(`Contact ${c.id} updated (stage=${c.lifecycle_stage})`);
 }
 async function del(id, flags) {

package/dist/commands/flag-reachability.test.js

@@ -40,7 +40,7 @@ const sdk = vi.hoisted(() => ({
         promoteRevision: vi.fn(),
         createContainer: vi.fn(),
     },
-    crm: { searchContacts: vi.fn(), searchCompanies: vi.fn() },
+    crm: { searchContacts: vi.fn(), searchCompanies: vi.fn(), updateContact: vi.fn(), updateCompany: vi.fn() },
     fn: { listFunctions: vi.fn() },
     // Top-level SDK exports the handlers reach for. Mocking the module
     // wholesale drops anything not listed, and the failure reads as a missing
@@ -295,3 +295,40 @@ describe('git commit — authorship must not silently default', () => {
         expect(sdk.git.commit.mock.calls[0][3].author).toBeUndefined();
     });
 });
+// A CRM contact's email is its identity: the field most likely to be wrong
+// after an import and the one that changes when someone switches employer.
+// `--email` was declared in the crm flag schema (create and the filters use
+// it), so it parsed on `contacts update` and was then dropped on the floor —
+// the patch object simply never read it. The only way to correct an address
+// was to delete the contact and create another, losing the timeline, the
+// campaign history and the audience it was promoted from.
+//
+// Found by asking the reverse of the usual question: not "does the API accept
+// everything we send", but "do we send everything the API accepts".
+describe('crm update — identity fields must REACH the patch', () => {
+    const CONTACT = { id: 'ct1', email: 'new@example.com', lifecycle_stage: 'lead' };
+    const COMPANY = { id: 'co1', domain: 'new.example.com', lifecycle_stage: 'lead' };
+    it('sends --email on contacts update', async () => {
+        sdk.crm.updateContact.mockResolvedValue(CONTACT);
+        const { run: crmRun } = await import('./crm/index.js');
+        await run(() => crmRun('contacts', ['update', 'ct1'], { email: 'new@example.com', org: ORG }));
+        expect(sdk.crm.updateContact).toHaveBeenCalledWith('hq_live_test', ORG, 'ct1', expect.objectContaining({ email: 'new@example.com' }));
+    });
+    it('sends --domain on companies update', async () => {
+        sdk.crm.updateCompany.mockResolvedValue(COMPANY);
+        const { run: crmRun } = await import('./crm/index.js');
+        await run(() => crmRun('companies', ['update', 'co1'], { domain: 'new.example.com', org: ORG }));
+        expect(sdk.crm.updateCompany).toHaveBeenCalledWith('hq_live_test', ORG, 'co1', expect.objectContaining({ domain: 'new.example.com' }));
+    });
+    // The backend applies each field with its own UPDATE and does not check the
+    // result, so an email colliding with another contact leaves the row
+    // unchanged and still answers 200. It re-reads the row before replying, so
+    // the truth is in the response — and reporting "updated" for a write that
+    // did not happen is worse than the failure.
+    it('refuses to report success when the email did not actually change', async () => {
+        sdk.crm.updateContact.mockResolvedValue({ ...CONTACT, email: 'old@example.com' });
+        const { run: crmRun } = await import('./crm/index.js');
+        await run(() => crmRun('contacts', ['update', 'ct1'], { email: 'new@example.com', org: ORG }));
+        expect(exitError).toMatch(/NOT changed/);
+    });
+});

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

@@ -1,10 +1,10 @@
 ---
 name: my-container-api
-version: 1.1.1
+version: 1.1.2
 description: >
   Run containers on demand — long-running services, background workers, and scheduled jobs. The heavier-duty sibling of edge functions, for native deps and long execution.
 triggers: [container, cloud run, dynamic app, custom domain app, service, worker, scheduled job, deploy container, docker image]
-checksum: sha256-80d64f6086e3d16549e530464b8188d9b9db2db5b54696e85c9ddde60d5b40a0
+checksum: sha256-0e1702e51e8d501edf48bdc4da92728d52e79c4273f534ba5ed41511b4803271
 ---
 
 # MyContainerAPI
@@ -19,9 +19,8 @@ The lifecycle is **create → deploy → (optionally) bind a custom domain**.
 - `deploy` takes **either** a pre-built image reference **or** a source
   directory. `--source ./dir` tars the directory, builds it server-side
   (typically ~4 minutes) and deploys the result — **no Docker on your machine,
-  no registry account, no image to push**. If you can write a Dockerfile you
-  can deploy; you do not need to be able to run one.
-- `domain` puts the container on a **custom domain** — how you serve a dynamic app at `app.yourbrand.com`.
+  no registry account, no image to push**.
+- `domain` puts the container on a **custom domain** — a dynamic app at `app.yourbrand.com`.
 
 ### Deploying safely
 
@@ -36,8 +35,8 @@ myapi container deploy <id> --source ./app --smoke 'GET / contains assets/'
 ```
 
 **Assert on content, not status.** A build whose frontend never bundled still
-binds its port and answers `200` — that is how a placeholder page reached
-production and served a dead page for fifteen minutes.
+binds its port and answers `200` — that is how a placeholder page served a dead
+page for fifteen minutes. Same reasoning as the startup probe below.
 
 **`--no-promote`** holds the revision back and prints a URL to test yourself,
 then `myapi container promote <id> <revision>`. Use it when the check is more
@@ -47,9 +46,10 @@ traffic is not withheld and the output says so.
 **`myapi container rollback <id>`** returns traffic to the previous ready
 revision in seconds, no rebuild.
 
-`--health-check /livez` at create makes the startup probe an HTTP request
-rather than a bare TCP connect. `/healthz` is refused — the runtime intercepts
-it, so the probe would never reach your container.
+`--health-check /livez` makes the startup probe an HTTP request, not a bare TCP
+connect — at create, or later with `myapi container health-check <id> /livez`
+(`--clear` removes it), which rolls a new revision on the same image.
+`/healthz` is refused: the runtime answers it before your container does.
 
 ### Custom domains (dynamic apps)
 

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

@@ -1,15 +1,15 @@
 ---
 name: my-crm-api
-version: 1.2.0
+version: 1.2.1
 description: >
   The canonical store of engaged contacts + companies for an org. Auto-ingests from inbound webhooks via a configurable dot-path. Fixed lifecycle_stage enum (cold | warm | qualified | customer | churned). Append-only event timeline with reserved kinds. Soft delete + restore. Promote-from-Goldfox closes the discovery → engagement loop.
 triggers: [crm, contact, company, lead, engagement, pipeline, lifecycle, qualified, customer, webhook ingest, promote]
-checksum: sha256-fab860f3f7592640ab15b4f91670cba8217330617d7c9e96dd8e9e5f76abb657
+checksum: sha256-8bc061c79940045d1f95ec4104a452c83342f9ebe2be3c0e087b4c4953524ce6
 ---
 
 # MyCRMAPI
 
-The store that closes the funnel. Without CRM the loop ends nowhere: discover people (Goldfox) → audience → email → pixel → form-fill via webhook → … nothing. People who *engage* live nowhere. CRM is where they land.
+The store that closes the funnel: discover people (Goldfox) → audience → email → pixel → form-fill via webhook → and then nowhere. CRM is where people who *engage* land.
 
 ## Capabilities
 <!-- llm:start -->
@@ -32,6 +32,10 @@ cold | warm | qualified | customer | churned
 
 Move stage with `myapi crm contacts update <id> --stage qualified`. Every stage change emits a `stage_changed` event with `{from, to}` so the timeline shows the journey.
 
+Correct an address with `--email` (companies: `--domain`) rather than recreating
+the record — a new contact has no timeline, no campaign history and no link to
+its source audience. A collision with another contact is refused.
+
 ### Contact sources (fixed enum)
 
 ```
@@ -54,7 +58,7 @@ Agents cannot write events directly — the enum is closed on purpose. For custo
 
 ### Auto-ingest
 
-- **Webhook** (live): set per endpoint via `crm_email_path`, a JSON dot-path. Default `"email"` ingests `{"email":"x@y.com"}`. For Stripe, set `data.object.customer_email`; for GitHub, `sender.email`. Empty string disables ingest.
+- **Webhook** (live): set per endpoint via `crm_email_path`, a JSON dot-path. Default `"email"`. Stripe: `data.object.customer_email`; GitHub: `sender.email`. Empty string disables ingest.
 
 Coming next:
 - **Email**: every `myapi email message send` writes `email_sent`; opens/clicks fire `email_opened`/`email_clicked`
@@ -66,7 +70,7 @@ An unknown email auto-creates the contact with `source=` the originating service
 
 ### Soft delete + restore
 
-`myapi crm contacts delete <id>` sets `deleted_at` but **keeps the event timeline**. By default soft-deleted contacts are excluded from search — pass `--include-deleted` to see them. Restore with `myapi crm contacts restore <id>`.
+`myapi crm contacts delete <id>` sets `deleted_at` but **keeps the event timeline**. Soft-deleted contacts are excluded from search unless you pass `--include-deleted`. Restore with `myapi crm contacts restore <id>`.
 
 ### Goldfox enrichment (deferred)
 
@@ -94,7 +98,7 @@ A promoted contact carries a `goldfox_person_id`; the embedded `goldfox_person`
 | `myapi crm contacts search [--stage ...] [--origin ...] [--email ...] [--min/max-last-engagement-days N]` | Filter contacts |
 | `myapi crm contacts create <email> [--first-name ...] [--last-name ...] [--stage ...] [--custom-json ...]` | Manually create (source='manual') |
 | `myapi crm contacts get <id>` | Fetch one contact (with embedded Goldfox enrichment when available) |
-| `myapi crm contacts update <id> [--stage ...] [...]` | Patch fields. Stage change emits `stage_changed` event |
+| `myapi crm contacts update <id> [--email <a>] [--stage ...] [...]` | Patch fields, `--email` included. Stage change emits `stage_changed` event |
 | `myapi crm contacts delete <id>` | Soft delete (events retained) |
 | `myapi crm contacts restore <id>` | Restore a soft-deleted contact |
 | `myapi crm contacts promote <goldfox_person_id>` | Idempotent Goldfox → CRM promote |
@@ -132,9 +136,11 @@ myapi crm contacts create alice@acme.com \
   --custom-json '{"intro_via":"riccardo","topic":"video editing"}'
 
 # Update stage as the deal progresses — emits a stage_changed event
-myapi crm contacts update <id> --stage qualified
 myapi crm contacts update <id> --stage customer
 
+# Fix a mistyped address without losing the timeline
+myapi crm contacts update <id> --email alice@acme.com
+
 # See the full engagement timeline
 myapi crm contacts events <id>
 
@@ -159,14 +165,13 @@ myapi crm contacts events <id> --kind webhook_received
 
 ## Notes
 
-- **Paginate with `--limit` + `--offset`.** `total` is the true match count
-  and the response carries `has_more`; branch on `has_more` rather than doing
-  arithmetic against `total`. (Both were broken until 2026-07-28. Cached
-  guidance saying the CRM cannot paginate is stale.)
-- **Reserved event kinds — no custom events in v1.** If an agent needs custom state per contact, use `myapi database` keyed by contact id. The curated timeline stays the authoritative engagement record.
-- **`external_id` on an event payload** is the backend's idempotency key — a duplicate of the action's natural id (`goldfox_person_id`, `delivery_id`). Read the semantic field instead; legacy `message_id` rows hold the same value.
+- **Paginate with `--limit` + `--offset`.** Branch on `has_more`, not on
+  arithmetic against `total`. (Cached guidance saying CRM cannot paginate is
+  stale — fixed 2026-07-28.)
+- **Reserved event kinds — no custom events in v1.** For custom per-contact state use `myapi database` keyed by contact id; the curated timeline stays authoritative.
+- **`external_id` on an event payload** is the backend's idempotency key, duplicating the action's natural id (`goldfox_person_id`, `delivery_id`). Read the semantic field instead.
 - **Only `webhook_received` fires today.** Email and pixel auto-ingest are coming; the CLI surface will not change.
-- **Free in v1.** Metered later if usage warrants.
+- **Free in v1.** Metered later if usage warrants it.
 
 ## HTTP (from deployed code)
 

package/package.json

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