@myapihq/cli 2.7.2 → 2.8.0

package/dist/commands/feedback.d.ts

@@ -0,0 +1,10 @@
+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 list(flags: Flags): Promise<void>;
+export declare function create(bodyArg: string | undefined, flags: Flags): Promise<void>;
+export declare function resolve(id: string, flags: Flags): Promise<void>;
+export declare function widget(sub: string | undefined, arg: string | undefined, flags: Flags): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/feedback.js

@@ -0,0 +1,173 @@
+// `myapi feedback` — collect what the people using your product tell you.
+//
+// The slot shipped on 2026-07-28 with five endpoints and no CLI. A primitive
+// with no surface is one nobody finds, which is the failure this repo spent a
+// week fixing: two customers concluded a shipped capability did not exist
+// because nothing they read mentioned it.
+import { feedback as sdkFeedback } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, info, printTable, printJson, banner } from '../output.js';
+import { formatDate } from '../utils.js';
+import { requireOrg, requireArg, confirmDestructive } from '../helpers.js';
+export const EXPOSES = [
+    'GET /feedback/orgs/{org_id}/items',
+    'POST /feedback/orgs/{org_id}/items',
+    'POST /feedback/orgs/{org_id}/items/{id}/resolve',
+    'POST /feedback/orgs/{org_id}/widgets',
+    'DELETE /feedback/orgs/{org_id}/widgets/{id}',
+];
+export const SCHEMA = {
+    kind: 'string',
+    status: 'string',
+    body: 'string',
+    'page-url': 'string',
+    route: 'string',
+    origins: 'string',
+};
+const KINDS = ['bug', 'idea', 'praise', 'confusion', 'other'];
+export async function list(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi feedback list [--kind <k>] [--status open|resolved] [--org <id>]');
+    if (flags.kind !== undefined && !KINDS.includes(flags.kind)) {
+        error(`Invalid --kind "${flags.kind}". Use one of: ${KINDS.join(', ')}.`);
+    }
+    if (flags.status !== undefined && flags.status !== 'open' && flags.status !== 'resolved') {
+        error(`Invalid --status "${flags.status}". Use "open" or "resolved".`);
+    }
+    const page = await sdkFeedback.listFeedback(config.api_key, orgId, {
+        kind: flags.kind,
+        status: flags.status,
+        limit: typeof flags.limit === 'number' ? flags.limit : undefined,
+        offset: typeof flags.offset === 'number' ? flags.offset : undefined,
+    });
+    if (flags.json) {
+        printJson(page);
+        return;
+    }
+    // `total` here is the match count, not the page size — the platform states
+    // that explicitly, having been bitten by the opposite in CRM search.
+    const shown = page.items?.length ?? 0;
+    info(shown === page.total ? `${shown} item${shown === 1 ? '' : 's'}` : `${shown} of ${page.total} items`);
+    printTable((page.items ?? []).map(i => ({
+        id: i.id,
+        kind: i.kind,
+        status: i.status,
+        body: i.body.length > 60 ? `${i.body.slice(0, 57)}…` : i.body,
+        route: i.route ?? i.page_url ?? '',
+        created: i.created_at ? formatDate(i.created_at) : '',
+    })), { flags, empty: 'No feedback yet. Put a widget on a page: myapi feedback widget create <name>' });
+    if (page.has_more)
+        info('More available — raise --limit or pass --offset.');
+}
+export async function create(bodyArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi feedback create "<text>" --kind <k> [--org <id>]');
+    const body = bodyArg ?? flags.body;
+    requireArg(body, 'text', 'myapi feedback create "<text>" --kind bug');
+    const kind = flags.kind ?? 'other';
+    if (!KINDS.includes(kind)) {
+        error(`Invalid --kind "${kind}". Use one of: ${KINDS.join(', ')}.\n\n→ Kind is what the PERSON says it is. "bug" is a claim that the product is broken; do not infer it from the wording.`);
+    }
+    const item = await sdkFeedback.createFeedback(config.api_key, orgId, {
+        kind: kind,
+        body: body,
+        page_url: typeof flags['page-url'] === 'string' ? flags['page-url'] : undefined,
+        route: typeof flags.route === 'string' ? flags.route : undefined,
+    });
+    if (flags.json) {
+        printJson(item);
+        return;
+    }
+    success(`Recorded ${item.kind}: ${item.id}`);
+}
+export async function resolve(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi feedback resolve <id> [--org <id>]');
+    if (!id)
+        error('Missing id.\nUsage: myapi feedback resolve <id>');
+    await sdkFeedback.resolveFeedback(config.api_key, orgId, id);
+    // Already-resolved and not-found answer identically, so this is not proof
+    // the id existed. Say so rather than implying a state change happened.
+    success(`Resolved ${id}`);
+    info('(An unknown id answers the same way, so this is not confirmation the item existed.)');
+}
+export async function widget(sub, arg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi feedback widget create <name> | revoke <id>');
+    if (sub === 'create') {
+        requireArg(arg, 'name', 'myapi feedback widget create <name> [--origins a.com,b.com]');
+        const origins = typeof flags.origins === 'string'
+            ? flags.origins.split(',').map(s => s.trim()).filter(Boolean)
+            : undefined;
+        const w = await sdkFeedback.createWidget(config.api_key, orgId, arg, origins);
+        if (flags.json) {
+            printJson(w);
+            return;
+        }
+        success(`Widget created: ${w.id}`);
+        info(`Key:  ${w.key}`);
+        info('');
+        // Saying this plainly matters: a value that looks like a credential and is
+        // not one gets treated as a secret, and then nobody puts it in the page.
+        info('This key is PUBLIC. It ships in your page source and authenticates nobody —');
+        info('it names your org so a visitor can submit without signing in.');
+        if (!origins?.length) {
+            banner('No --origins set, so any site can post through this key. Set them unless that is intended.');
+        }
+        return;
+    }
+    if (sub === 'revoke') {
+        requireArg(arg, 'id', 'myapi feedback widget revoke <id>');
+        await confirmDestructive(flags, `revoke widget ${arg} (submissions with it stop immediately)`, 'myapi feedback widget revoke <id> [--yes] [--org <id>]');
+        await sdkFeedback.revokeWidget(config.api_key, orgId, arg);
+        success(`Widget ${arg} revoked`);
+        info('Feedback already collected through it is kept.');
+        return;
+    }
+    error('Usage: myapi feedback widget create <name> [--origins <list>]\n       myapi feedback widget revoke <id>');
+}
+const SUBCOMMAND_USAGE = {
+    'list': `myapi feedback list [--kind bug|idea|praise|confusion|other] [--status open|resolved]
+       [--limit N] [--offset N] [--org <id>] [--json]
+
+Newest first. \`total\` is the number of matches, not the page size.`,
+    'create': `myapi feedback create "<text>" --kind <k> [--page-url <url>] [--route <path>] [--org <id>]
+
+--kind is what the person reporting says it is, not what the text sounds like.`,
+    'resolve': 'myapi feedback resolve <id> [--org <id>]',
+    'widget': `myapi feedback widget create <name> [--origins a.com,b.com] [--org <id>]
+       myapi feedback widget revoke <id> [--yes] [--org <id>]
+
+The key a widget mints is PUBLIC — it ships in page source and authenticates
+nobody. --origins stops another site posting through it.`,
+};
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi feedback <subcommand>
+
+Collect feedback from the people using what you built. A widget key lets a
+page submit without a credential; you list, filter and resolve the results.
+
+Subcommands:
+  create "<text>"      Record one piece of feedback (--kind bug|idea|praise|confusion|other)
+  list                 List feedback, newest first (--kind, --status, --limit, --offset)
+  resolve <id>         Close a piece of feedback
+  widget create <name> Mint a PUBLIC widget key for a site (--origins to restrict)
+  widget revoke <id>   Revoke a widget key; collected feedback is kept
+
+All commands accept --org <id> (or set default: myapi config set-org <id>).`);
+        return;
+    }
+    if (flags.help) {
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        info(usage ? `Usage: ${usage}` : `Unknown subcommand: ${subcommand}. Run "myapi feedback --help" for the list.`);
+        return;
+    }
+    switch (subcommand) {
+        case 'create': return create(args[0], flags);
+        case 'list': return list(flags);
+        case 'resolve': return resolve(args[0], flags);
+        case 'widget': return widget(args[0], args[1], flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi feedback --help" for a list of valid subcommands.`);
+    }
+}

package/dist/commands/flag-reachability.test.d.ts

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

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

@@ -0,0 +1,274 @@
+// Does the flag REACH the call, or does it only parse?
+//
+// This file exists because of a bug we shipped and a customer found.
+//
+// `container deploy --no-promote` was wired to the pre-built-image path and
+// not to the `--source` path. `deployContainerSource()` was called without the
+// options object, so on a source build the flag was accepted and silently
+// discarded. Both flags were declared in the command schema, so the
+// foreign-flag check stayed quiet too. A team deployed with it, the build took
+// 100% of traffic anyway, and they reported it.
+//
+// The tests we had at the time all passed. They tested `_parseSmoke` (a pure
+// parser) and `deployContainer` (the SDK function). Nothing tested the CLI
+// handler, so nothing noticed that one of its two branches never passed the
+// options along. The backend hit the identical shape the same day and put it
+// better than we can:
+//
+//   "Counting call sites proves the helper is CALLED, not that it is REACHED."
+//
+// Ours is: testing the parser proves the flag PARSES, not that it is SENT.
+//
+// So this file tests HANDLERS, with the SDK mocked, asserting what actually
+// arrives at the boundary. Every case below is a real field report. When you
+// add a flag that changes a request, add a case here — a unit test on its
+// parser is not cover.
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+const ORG = '11111111-1111-4111-8111-111111111111';
+// The SDK is mocked wholesale so we can see exactly what the handler passes.
+// Typed loosely on purpose: the later describes assign whole slot objects
+// (sdk.task = {...}) and TS would otherwise reject each one. The assertions
+// still check real shapes.
+const sdk = vi.hoisted(() => ({
+    container: {
+        deployContainer: vi.fn(),
+        deployContainerSource: vi.fn(),
+        getContainerLogs: vi.fn(),
+        listContainers: vi.fn(),
+        getContainer: vi.fn(),
+        listRevisions: vi.fn(),
+        promoteRevision: vi.fn(),
+        createContainer: vi.fn(),
+    },
+    crm: { searchContacts: vi.fn(), searchCompanies: 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
+    // export rather than a missing mock — so they are enumerated explicitly.
+    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',
+}));
+let exitError;
+beforeEach(async () => {
+    exitError = null;
+    vi.clearAllMocks();
+    const output = await import('../output.js');
+    vi.spyOn(output, 'error').mockImplementation(((m) => {
+        exitError = m;
+        throw new Error('__EXIT__');
+    }));
+    vi.spyOn(output, 'info').mockImplementation(() => { });
+    vi.spyOn(output, 'success').mockImplementation(() => { });
+    vi.spyOn(output, 'printTable').mockImplementation(() => { });
+    vi.spyOn(output, 'printJson').mockImplementation(() => { });
+    vi.spyOn(output, 'banner').mockImplementation(() => { });
+});
+afterEach(() => vi.restoreAllMocks());
+// Runs a handler and swallows the synthetic exit thrown by a mocked error().
+async function run(fn) {
+    try {
+        await fn();
+    }
+    catch (e) {
+        if (e?.message !== '__EXIT__')
+            throw e;
+    }
+}
+describe('container deploy — the flag must be refused on BOTH paths', () => {
+    // The original bug: this branch dropped the options entirely. Now the flags
+    // are refused platform-wide, and the refusal has to fire here too — a
+    // refusal wired to one branch is the same defect wearing a different hat.
+    it('refuses --no-promote on the --source path, and never calls the SDK', async () => {
+        const { deploy } = await import('./container.js');
+        await run(() => deploy('c1', '', { source: './app', 'no-promote': true, org: ORG }));
+        expect(exitError).toMatch(/not honoured yet/);
+        expect(sdk.container.deployContainerSource).not.toHaveBeenCalled();
+        expect(sdk.container.deployContainer).not.toHaveBeenCalled();
+    });
+    it('refuses --smoke on the --source path', async () => {
+        const { deploy } = await import('./container.js');
+        await run(() => deploy('c1', '', { source: './app', smoke: 'GET / contains x', org: ORG }));
+        expect(exitError).toMatch(/not honoured yet/);
+        expect(sdk.container.deployContainerSource).not.toHaveBeenCalled();
+    });
+    it('refuses --no-promote on the image path', async () => {
+        const { deploy } = await import('./container.js');
+        await run(() => deploy('c1', 'img:v1', { 'no-promote': true, org: ORG }));
+        expect(exitError).toMatch(/not honoured yet/);
+        expect(sdk.container.deployContainer).not.toHaveBeenCalled();
+    });
+    // The refusal must not become a blanket block on deploying at all.
+    it('still deploys normally when neither flag is passed', async () => {
+        sdk.container.deployContainer.mockResolvedValue({
+            container_id: 'c1', revision_id: 'r1', url: 'https://x', status: 'active', scoped_api_key: 'k',
+        });
+        const { deploy } = await import('./container.js');
+        await run(() => deploy('c1', 'img:v1', { org: ORG }));
+        expect(exitError).toBeNull();
+        expect(sdk.container.deployContainer).toHaveBeenCalledWith('hq_live_test', ORG, 'c1', 'img:v1');
+    });
+});
+describe('crm pagination — --offset must reach the SDK', () => {
+    // Reported by a customer as returning page one forever. The API ignored it
+    // at the time; once fixed, the CLI had to actually send it, and only a
+    // handler-level test proves that.
+    beforeEach(() => {
+        sdk.crm.searchContacts.mockResolvedValue({ contacts: [], total: 0, has_more: false });
+        sdk.crm.searchCompanies.mockResolvedValue({ companies: [], total: 0, has_more: false });
+    });
+    it('passes --offset through on contacts list', async () => {
+        const { run: crmRun } = await import('./crm/index.js');
+        await run(() => crmRun('contacts', ['list'], { offset: 25, limit: 10, org: ORG }));
+        expect(sdk.crm.searchContacts).toHaveBeenCalledWith('hq_live_test', ORG, expect.objectContaining({ offset: 25, limit: 10 }));
+    });
+    it('passes --offset through on contacts search, alongside filters', async () => {
+        const { run: crmRun } = await import('./crm/index.js');
+        await run(() => crmRun('contacts', ['search'], { offset: 5, origin: 'webhook', org: ORG }));
+        expect(sdk.crm.searchContacts).toHaveBeenCalledWith('hq_live_test', ORG, expect.objectContaining({ offset: 5 }));
+    });
+    it('passes --offset through on companies', async () => {
+        const { run: crmRun } = await import('./crm/index.js');
+        await run(() => crmRun('companies', ['list'], { offset: 7, org: ORG }));
+        expect(sdk.crm.searchCompanies).toHaveBeenCalledWith('hq_live_test', ORG, expect.objectContaining({ offset: 7 }));
+    });
+    // The deprecated spelling must still reach the request, or the alias is a
+    // promise we are not keeping.
+    it('still honours the deprecated --source spelling for provenance', async () => {
+        const { run: crmRun } = await import('./crm/index.js');
+        await run(() => crmRun('contacts', ['search'], { source: 'goldfox', org: ORG }));
+        expect(sdk.crm.searchContacts).toHaveBeenCalledWith('hq_live_test', ORG, expect.objectContaining({ source: ['goldfox'] }));
+    });
+});
+describe('container logs — --scope must reach the SDK', () => {
+    it('sends scope=all when asked', async () => {
+        sdk.container.getContainerLogs.mockResolvedValue([]);
+        const { logs } = await import('./container.js');
+        await run(() => logs('c1', { scope: 'all', tail: 500, org: ORG }));
+        expect(sdk.container.getContainerLogs).toHaveBeenCalledWith('hq_live_test', ORG, 'c1', 500, 'all');
+    });
+    it('sends no scope by default, rather than the string "container"', async () => {
+        sdk.container.getContainerLogs.mockResolvedValue([]);
+        const { logs } = await import('./container.js');
+        await run(() => logs('c1', { org: ORG }));
+        expect(sdk.container.getContainerLogs).toHaveBeenCalledWith('hq_live_test', ORG, 'c1', undefined, undefined);
+    });
+    it('refuses an invalid scope instead of passing it on', async () => {
+        const { logs } = await import('./container.js');
+        await run(() => logs('c1', { scope: 'everything', org: ORG }));
+        expect(exitError).toMatch(/Invalid --scope/);
+        expect(sdk.container.getContainerLogs).not.toHaveBeenCalled();
+    });
+});
+describe('container create — --health-check is validated before the call', () => {
+    it('refuses /healthz client-side and never calls the SDK', async () => {
+        const { create } = await import('./container.js');
+        await run(() => create('probe', { 'health-check': '/healthz', org: ORG }));
+        expect(exitError).toMatch(/intercepts \/healthz/);
+        expect(sdk.container.createContainer).not.toHaveBeenCalled();
+    });
+    it('refuses a path that is not a path', async () => {
+        const { create } = await import('./container.js');
+        await run(() => create('probe', { 'health-check': 'livez', org: ORG }));
+        expect(exitError).toMatch(/must be a path/);
+        expect(sdk.container.createContainer).not.toHaveBeenCalled();
+    });
+});
+// ── Wider coverage ──────────────────────────────────────────────────────────
+//
+// The cases above are the ones a customer found. These are the same class of
+// risk elsewhere: a flag that changes WHAT GETS WRITTEN, where losing it in
+// transit produces a wrong record rather than an error.
+//
+// Coverage is partial and worth stating: this file exercises 8 commands of the
+// 32 that take flags. It covers the ones where a dropped flag is silent and
+// consequential. `list`/`get` verbs are omitted deliberately — a dropped
+// filter there is visible in the output, which is a different and much
+// cheaper failure.
+describe('task create — flags that change the stored record', () => {
+    beforeEach(() => { sdk.task = { createTask: vi.fn().mockResolvedValue({ id: 't1' }), listTasks: vi.fn().mockResolvedValue([]) }; });
+    it('sends --dedup-key, which is what makes creation idempotent', async () => {
+        const { create } = await import('./task.js');
+        await run(() => create('do a thing', { 'dedup-key': 'evt-123', org: ORG }));
+        expect(sdk.task.createTask).toHaveBeenCalledWith('hq_live_test', ORG, expect.objectContaining({ dedupKey: 'evt-123' }));
+    });
+    it('sends --origin, and still honours the deprecated --source', async () => {
+        const { create } = await import('./task.js');
+        await run(() => create('x', { origin: 'agent', org: ORG }));
+        expect(sdk.task.createTask).toHaveBeenCalledWith('hq_live_test', ORG, expect.objectContaining({ source: 'agent' }));
+        vi.clearAllMocks();
+        await run(() => create('x', { source: 'legacy', org: ORG }));
+        expect(sdk.task.createTask).toHaveBeenCalledWith('hq_live_test', ORG, expect.objectContaining({ source: 'legacy' }));
+    });
+});
+describe('webhook create — the CRM ingest path must survive', () => {
+    beforeEach(() => { sdk.webhook = { createEndpoint: vi.fn().mockResolvedValue({ id: 'w1', url: 'u' }) }; });
+    // Losing this silently means submissions stop becoming contacts, with no
+    // error anywhere — the endpoint keeps accepting deliveries.
+    it('sends --crm-email-path', async () => {
+        const { create } = await import('./webhook.js');
+        await run(() => create('stripe', { 'crm-email-path': 'data.object.customer_email', org: ORG }));
+        const [, , , opts] = sdk.webhook.createEndpoint.mock.calls[0];
+        expect(opts).toMatchObject({ crm_email_path: 'data.object.customer_email' });
+    });
+    it('sends --forward-url', async () => {
+        const { create } = await import('./webhook.js');
+        await run(() => create('gh', { 'forward-url': 'https://example.com/hook', org: ORG }));
+        const [, , , opts] = sdk.webhook.createEndpoint.mock.calls[0];
+        expect(opts).toMatchObject({ forward_url: 'https://example.com/hook' });
+    });
+});
+describe('audience create — --from selects the dataset', () => {
+    beforeEach(() => { sdk.audience = { createAudience: vi.fn().mockResolvedValue({ id: 'a1', member_count: 0 }) }; });
+    // Picking the wrong dataset builds an audience of the wrong KIND of record.
+    // Nothing errors; the list is simply of companies when you wanted people.
+    it('sends --from', async () => {
+        const { run: audRun } = await import('./audience.js');
+        await run(() => audRun('create', ['my-list'], { from: 'company', filter: '{}', org: ORG }));
+        expect(sdk.audience.createAudience).toHaveBeenCalledWith('hq_live_test', ORG, expect.objectContaining({ source: 'company' }));
+    });
+    it('still honours the deprecated --source spelling', async () => {
+        const { run: audRun } = await import('./audience.js');
+        await run(() => audRun('create', ['my-list'], { source: 'people', filter: '{}', org: ORG }));
+        expect(sdk.audience.createAudience).toHaveBeenCalledWith('hq_live_test', ORG, expect.objectContaining({ source: 'people' }));
+    });
+});
+describe('git commit — authorship must not silently default', () => {
+    beforeEach(() => {
+        sdk.git = {
+            commit: vi.fn().mockResolvedValue({ sha: 'abc1234' }),
+            // The handler resolves the branch tip before committing; without this it
+            // refuses rather than guessing a base, which is the right behaviour and
+            // has to be satisfied to reach the call we are testing.
+            listRefs: vi.fn().mockResolvedValue({ branches: [{ name: 'main', sha: 'base123' }] }),
+        };
+    });
+    // Without these every agent-written commit is attributed to the key's
+    // account — wrong quietly rather than loudly.
+    it('sends --author-name and --author-email', async () => {
+        const { commit } = await import('./git.js');
+        await run(() => commit('repo', {
+            branch: 'main', message: 'm',
+            changes: '[{"path":"a.txt","content":"hi"}]',
+            'author-name': 'Ada', 'author-email': 'ada@example.com', org: ORG,
+        }));
+        expect(sdk.git.commit).toHaveBeenCalled();
+        const payload = sdk.git.commit.mock.calls[0][3];
+        expect(payload.author).toMatchObject({ name: 'Ada', email: 'ada@example.com' });
+    });
+    it('omits author entirely when neither flag is given', async () => {
+        const { commit } = await import('./git.js');
+        await run(() => commit('repo', {
+            branch: 'main', message: 'm', changes: '[{"path":"a.txt","content":"hi"}]', org: ORG,
+        }));
+        expect(sdk.git.commit.mock.calls[0][3].author).toBeUndefined();
+    });
+});

package/dist/commands/llm.d.ts

@@ -3,4 +3,5 @@ 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 _parseJsonObjectFlag(raw: unknown, flagName: string): Record<string, unknown> | undefined;
 export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/llm.js

@@ -24,6 +24,9 @@ export const SCHEMA = {
     schema: 'string',
     style: 'string',
     kind: 'string',
+    facts: 'string',
+    directives: 'string',
+    // Deprecated alias for --facts; undocumented, removable next minor.
     context: 'string',
     prompt: 'string',
     tier: 'string',
@@ -103,21 +106,33 @@ function parseSchemaFlag(flags) {
         return null;
     }
 }
-function parseContextFlag(flags) {
-    if (typeof flags.context !== 'string' || !flags.context)
+// --facts is referent data quoted into the prompt as reference; --directives
+// are writer controls (tone, max_words, format). The platform split them
+// because they are trusted differently, and `--context` predated the split.
+export function _parseJsonObjectFlag(raw, flagName) {
+    if (typeof raw !== 'string' || !raw)
         return undefined;
     try {
-        const parsed = JSON.parse(flags.context);
-        if (typeof parsed === 'object' && parsed !== null)
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
             return parsed;
-        error('--context must be a JSON object');
+        }
+        error(`${flagName} must be a JSON object`);
         return undefined;
     }
     catch {
-        error('--context must be valid JSON');
+        error(`${flagName} must be valid JSON`);
         return undefined;
     }
 }
+function parseContextFlag(flags) {
+    // --facts wins; --context is the old spelling and still works.
+    return _parseJsonObjectFlag(flags.facts, '--facts')
+        ?? _parseJsonObjectFlag(flags.context, '--context');
+}
+function parseDirectivesFlag(flags) {
+    return _parseJsonObjectFlag(flags.directives, '--directives');
+}
 function tierFromFlag(flags) {
     if (typeof flags.tier !== 'string' || !flags.tier)
         return undefined;
@@ -269,7 +284,7 @@ async function summarize(inputArg, flags) {
 }
 async function draft(inputArg, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi llm draft --kind <what> [--prompt "<instructions>"] [--context <json>] ["<source text>"] [--tier <t>] [--org <id>]');
+    const orgId = requireOrg(flags, config, 'myapi llm draft --kind <what> [--prompt "<instructions>"] [--facts <json>] ["<source text>"] [--tier <t>] [--org <id>]');
     if (typeof flags.kind !== 'string' || !flags.kind) {
         error('Missing required flag: --kind <email|message|reply|...>');
         return;
@@ -281,12 +296,13 @@ async function draft(inputArg, flags) {
     const promptText = typeof flags.prompt === 'string' ? flags.prompt : '';
     const ctx = parseContextFlag(flags);
     if (!input.trim() && !promptText.trim() && (!ctx || Object.keys(ctx).length === 0)) {
-        error('draft needs at least one of: <source text> (arg or --file), --prompt, or --context.');
+        error('draft needs at least one of: <source text> (arg or --file), --prompt, or --facts.');
     }
     const res = await retryFunds(() => sdkLlm.draft(config.api_key, orgId, {
         input: input || undefined,
         kind,
-        context: ctx,
+        facts: ctx,
+        directives: parseDirectivesFlag(flags),
         prompt: promptText || undefined,
         tier: tierFromFlag(flags),
     }));

package/dist/completion.js

@@ -29,7 +29,7 @@ export const COMMANDS = [
     'account', 'audience', 'auth', 'billing', 'company', 'completion', 'config', 'container',
     'crm', 'database', 'domain', 'email', 'fn', 'funnel', 'git', 'help', 'image',
     'doctor', 'install-skills', 'keys', 'llm', 'login', 'org', 'payments', 'people', 'pixel',
-    'queue', 'setup', 'status', 'storage', 'task', 'update', 'url', 'webhook', 'whoami',
+    'feedback', 'queue', 'setup', 'status', 'storage', 'task', 'update', 'url', 'webhook', 'whoami',
     'workflow',
 ];
 // command → subcommands, for `myapi <command> <TAB>`. Mirrors each
@@ -61,6 +61,7 @@ export const SUBCOMMANDS = {
     payments: ['connect', 'status', 'charge', 'list', 'get', 'refund'],
     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'],
+    feedback: ['create', 'list', 'resolve', 'widget'],
     queue: ['create', 'list', 'get', 'delete', 'enqueue', 'jobs', 'job'],
     task: ['create', 'list', 'get', 'claim', 'extend', 'resolve', 'fail', 'cancel'],
     completion: ['install', 'uninstall'],

package/dist/exposes.test.js

@@ -42,6 +42,7 @@ const COMMAND_MODULES = [
     './commands/payments.js',
     './commands/container.js',
     './commands/git.js',
+    './commands/feedback.js',
     './commands/queue.js',
     './commands/task.js',
     './commands/doctor.js',

package/dist/index.js

@@ -41,6 +41,7 @@ import * as paymentsCmd from './commands/payments.js';
 import * as containerCmd from './commands/container.js';
 import * as gitCmd from './commands/git.js';
 import * as queueCmd from './commands/queue.js';
+import * as feedbackCmd from './commands/feedback.js';
 import * as taskCmd from './commands/task.js';
 import * as doctorCmd from './commands/doctor.js';
 import * as loginCmd from './commands/login.js';
@@ -85,6 +86,7 @@ const COMMAND_SCHEMAS = {
     people: peopleCmd.SCHEMA,
     pixel: pixelCmd.SCHEMA,
     queue: queueCmd.SCHEMA,
+    feedback: feedbackCmd.SCHEMA,
     status: statusCmd.SCHEMA,
     storage: storageCmd.SCHEMA,
     task: taskCmd.SCHEMA,
@@ -134,6 +136,7 @@ const COMBINED_SCHEMA = {
     ...containerCmd.SCHEMA,
     ...gitCmd.SCHEMA,
     ...queueCmd.SCHEMA,
+    ...feedbackCmd.SCHEMA,
     ...taskCmd.SCHEMA,
     ...doctorCmd.SCHEMA,
     ...loginCmd.SCHEMA,
@@ -258,6 +261,9 @@ async function main() {
             case 'queue':
                 await queueCmd.run(subcommand, restArgs, flags);
                 break;
+            case 'feedback':
+                await feedbackCmd.run(subcommand, restArgs, flags);
+                break;
             case 'task':
                 await taskCmd.run(subcommand, restArgs, flags);
                 break;
@@ -463,6 +469,7 @@ Commands:
   doctor          Org-wide consistency check — funnels, webhooks, domains, containers
   domain          Manage domain configurations
   email           Manage mailboxes, send/read email, templates, and campaigns
+  feedback        Collect feedback from the people using what you built
   fn              Create and deploy functions on the edge runtime
   funnel          Manage websites (publish pages, custom domains, funnels)
   git             Hosted git repositories — repos, commits, branches, history

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

@@ -4,7 +4,7 @@ version: 1.0.0
 description: >
   Deploy JavaScript functions to the MyAPI edge runtime. Register a function, upload a single-file JS bundle, get a live HTTP invocation URL or run it on a cron schedule. Each function gets a scoped capability key for cross-slot calls.
 triggers: [function, deploy function, edge function, serverless, cloudflare worker, cron, scoped api key, capability key, invocation url, bundle]
-checksum: sha256-1ef76e07c9fb4f295b491224261b5719314f15d3645c32e6e7b443a7fdaf95c6
+checksum: sha256-a29b3c96645c59317c0896c9a886d9904bdb2ebde9eb8582d0cb7071d0b9ac2c
 ---
 
 # MyFunctionAPI
@@ -129,4 +129,10 @@ curl -H "Authorization: Bearer $SCOPED_KEY" \
 - Deploy rotates the scoped API key on every call — re-capture the printed value if other systems use it.
 - `myapi fn env <id> --set KEY=VALUE,OTHER=VALUE` sets several secrets in one call instead of one command each.
 
+**`--scope` is create-only, so treat it as permanent.** There is no
+`fn scope --add`. Adding a slot later means delete + recreate, which mints a
+**new function id and a new invocation URL**, breaking every reference already
+handed out — docs, front-end config, webhooks, anything given to a third
+party. Decide the full slot list before you publish the URL.
+
 Run `myapi fn --help` or `myapi fn <subcommand> --help` for full flag reference.

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

@@ -7,7 +7,7 @@ description: >
   (classify / extract / summarize / draft) that hide the model behind a
   task. Pricing in cents per 1M tokens; charged from your MyAPI balance.
 triggers: [llm, completion, chat, embed, embedding, inference, classify, extract, summarize, draft, qwen]
-checksum: sha256-6c399da099802637c68eda61ba85a23286ff3dca8f50c391e80ab442777c17c4
+checksum: sha256-2a9070e118134aea98a1be986d29f9c4e3a969aa960e7dfc87137bbc490ac04e
 ---
 
 # MyLLMAPI
@@ -21,9 +21,9 @@ Pricing is cents per 1M tokens at the actual upstream rate, debited from your My
 
 ## Capabilities
 <!-- llm:start -->
-Use this for workflow tasks — summarize a doc, classify an inbound email, extract structured data, draft a reply. The reply goes to stdout; a one-line usage footer (tokens + cost + finish reason) goes to stderr, so `myapi llm complete ... | jq` and similar pipelines work as expected.
+For workflow tasks — summarize, classify, extract, draft. The reply goes to stdout and the usage footer (tokens, cost, finish reason) to stderr, so `myapi llm complete ... | jq` works.
 
-**Don't use this as your own model.** If you're an agent reading this, you already have a more capable model than what's exposed here. Reach for the LLM verbs when you're scripting a recurring step where a small/cheap model is the right tool — not for one-shot reasoning you can just do yourself.
+**Don't use this as your own model.** If you are an agent reading this, you already have a more capable model. Reach for the LLM verbs when scripting a recurring step where a small, cheap model is the right tool — not for one-shot reasoning you can do yourself.
 
 Reach for raw `complete` when shape matters (you build the `messages` array and set `max_tokens`/`temperature`/`stop`); reach for a verb when you want a *result* and don't care which model produced it.
 
@@ -88,7 +88,7 @@ The model/provider is **never** named in the verb response — the verb is the c
 
 ### OpenAI-compatible drop-in
 
-`POST /llm/orgs/{org_id}/chat/completions` (and `/v1/chat/completions` alias) accepts the OpenAI request shape and returns the OpenAI response shape — **no envelope**. Same catalog and pricing as raw `complete`. Use it when existing OpenAI SDK / LangChain / any `base_url`-configurable tooling should point at MyAPI without rewriting.
+`POST /llm/orgs/{org_id}/chat/completions` (alias `/v1/chat/completions`) takes and returns the OpenAI shape — **no envelope**. Same catalog and pricing as `complete`. Use it when an existing OpenAI SDK or LangChain integration should point at MyAPI unchanged.
 
 ```python
 from openai import OpenAI
@@ -160,3 +160,16 @@ INTENT=$(printf '%s' "$BODY" | myapi llm classify - \
 - **Self-hosted raw, server-picked verbs.** Raw runs on MyAPI's TPU; verbs route wherever the server picks.
 - **Cost + latency.** `usage.cost_cents` is authoritative — no markup. Varies by tier: 200–600 ms to first token, 1–3 s end-to-end.
 - **Live catalog, no streaming, no BYOK.** Don't hard-code ids — `models` is truth (CLI auto-picks if `--model` omitted). Full reply only.
+
+## `--facts` vs `--directives` on draft
+
+`--facts '<json>'` is referent data, quoted as reference and never as
+instructions (recipient, dates, amounts). `--directives '<json>'` is writer
+controls only: tone, max_words, format, style. They are trusted differently.
+
+```bash
+myapi llm draft --kind email --prompt "the invoice is due" \
+  --facts '{"to":"Ada"}' --directives '{"tone":"warm"}'
+```
+
+`--context` is the old name for `--facts`; accepted, deprecated upstream.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@myapihq/cli",
   "license": "Apache-2.0",
-  "version": "2.7.2",
+  "version": "2.8.0",
   "description": "MyAPI command-line interface",
   "repository": {
     "type": "git",
@@ -38,11 +38,15 @@
     "audit:doctor": "npm run build && node scripts/audit-doctor.js",
     "lint:docs": "node scripts/lint-docs.js",
     "lint:skill-coverage": "node scripts/lint-skill-coverage.js",
+    "bench:discoverability": "node scripts/bench-discoverability.js",
+    "lint:claims": "node scripts/verify-claims.js --lint",
+    "verify:claims": "npm run build && node scripts/verify-claims.js",
+    "audit:fields": "npm run build && node scripts/audit-field-honoured.js",
     "lint:skills": "node scripts/copy-skills.js && node scripts/lint-skills.js",
     "lint:skills:strict": "node scripts/copy-skills.js && node scripts/lint-skills.js --strict"
   },
   "dependencies": {
-    "@myapihq/sdk": "^2.7.2"
+    "@myapihq/sdk": "^2.8.0"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",