@myapihq/cli 1.2.6 → 1.2.8

package/dist/commands/update.js

@@ -1,6 +1,7 @@
 import { execSync } from 'child_process';
-import { existsSync } from 'fs';
-import { loadConfig } from '../config.js';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { loadConfig, CONFIG_DIR } from '../config.js';
 import { info, success, banner } from '../output.js';
 import { installSkills } from './setup.js';
 // `myapi update` only talks to the npm registry to check for new CLI versions
@@ -8,6 +9,33 @@ import { installSkills } from './setup.js';
 export const EXPOSES = [];
 const REGISTRY_URL = 'https://registry.npmjs.org/@myapihq/cli/latest';
 const PACKUMENT_URL = 'https://registry.npmjs.org/@myapihq/cli';
+// The update check hits the npm registry. Caching its result means at most
+// one network round-trip per TTL window instead of one on every command —
+// the dominant cost in CLI startup latency.
+const UPDATE_CACHE_FILE = join(CONFIG_DIR, 'update-check.json');
+const CHECK_TTL_MS = 6 * 60 * 60 * 1000; // 6 hours
+function readUpdateCache() {
+    try {
+        return JSON.parse(readFileSync(UPDATE_CACHE_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeUpdateCache(cache) {
+    try {
+        if (!existsSync(CONFIG_DIR))
+            mkdirSync(CONFIG_DIR, { recursive: true });
+        writeFileSync(UPDATE_CACHE_FILE, JSON.stringify(cache));
+    }
+    catch { /* best-effort — a write failure just means we re-check sooner */ }
+}
+// The last-known published version, read from cache with no network call.
+// `myapi --version` uses this so it can flag an available update without the
+// ~1s registry round-trip blocking the output.
+export function cachedLatestVersion() {
+    return readUpdateCache()?.latest ?? null;
+}
 // Verify the version is listed in the full packument — the same data source
 // `npm install` consults. The /latest endpoint and the tarball URL are on
 // different CDN caches and can update before the packument does, causing
@@ -48,42 +76,48 @@ function npmInstallArgs(version) {
     }
 }
 // checkForUpdate runs silently in the background on every command.
-// Auto-installs if a newer version is available.
+// Auto-installs if a newer version is available. The registry is consulted
+// at most once per CHECK_TTL_MS; runs within that window reuse the cache.
 // Suppress entirely with MYAPI_NO_UPDATE=1 or when stdout is not a TTY.
 export async function checkForUpdate(currentVersion) {
     if (process.env.MYAPI_NO_UPDATE === '1' || !process.stdout.isTTY)
         return;
+    const cache = readUpdateCache();
+    let latest = cache?.latest;
+    if (!cache || Date.now() - cache.checkedAt >= CHECK_TTL_MS) {
+        try {
+            const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(3000) });
+            if (res.ok)
+                latest = (await res.json()).version ?? latest;
+        }
+        catch {
+            // Network errors are silently ignored — keep the last known `latest`.
+        }
+        // Record the attempt regardless of outcome so a slow or unreachable
+        // registry isn't re-hit on the very next command.
+        writeUpdateCache({ checkedAt: Date.now(), latest });
+    }
+    if (!latest || !isNewer(latest, currentVersion))
+        return;
+    // Verify the version is actually installable before attempting install —
+    // the /latest endpoint can report a new version before the packument
+    // (which `npm install` consults) has propagated through the CDN.
+    if (!(await isVersionInstallable(latest)))
+        return;
+    banner(`\n› New version available (${currentVersion} → ${latest}) — installing…`);
     try {
-        const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(3000) });
-        if (!res.ok)
-            return;
-        const data = await res.json();
-        const latest = data.version;
-        if (latest && isNewer(latest, currentVersion)) {
-            // Verify the version is actually installable before attempting install —
-            // the /latest endpoint can report a new version before the packument
-            // (which `npm install` consults) has propagated through the CDN.
-            if (!(await isVersionInstallable(latest)))
-                return;
-            banner(`\n› New version available (${currentVersion} → ${latest}) — installing…`);
-            try {
-                const { bin, args } = npmInstallArgs(latest);
-                execSync(`"${bin}" ${args.map(a => `"${a}"`).join(' ')}`, { stdio: 'pipe' });
-                const config = loadConfig();
-                if (config?.skills_installed) {
-                    await installSkills();
-                }
-                banner(`› Updated to ${latest} — active after this command completes.\n`);
-            }
-            catch (installErr) {
-                const msg = installErr?.stderr?.toString?.() || installErr?.message || String(installErr);
-                banner(`› Auto-update failed: ${msg.trim()}`);
-                banner(`› Run manually: npm install -g @myapihq/cli@latest`);
-            }
+        const { bin, args } = npmInstallArgs(latest);
+        execSync(`"${bin}" ${args.map(a => `"${a}"`).join(' ')}`, { stdio: 'pipe' });
+        const config = loadConfig();
+        if (config?.skills_installed) {
+            await installSkills();
         }
+        banner(`› Updated to ${latest} — active after this command completes.\n`);
     }
-    catch {
-        // Network errors are silently ignored.
+    catch (installErr) {
+        const msg = installErr?.stderr?.toString?.() || installErr?.message || String(installErr);
+        banner(`› Auto-update failed: ${msg.trim()}`);
+        banner(`› Run manually: npm install -g @myapihq/cli@latest`);
     }
 }
 // myapi update — explicit update, same logic as auto-update.
@@ -100,8 +134,10 @@ export async function update(flags = {}) {
             throw new Error(`registry returned ${res.status}`);
         const data = await res.json();
         latest = data.version ?? '';
-        if (latest)
+        if (latest) {
+            writeUpdateCache({ checkedAt: Date.now(), latest });
             info(`› Installing @myapihq/cli@${latest}…`);
+        }
     }
     catch { /* proceed anyway */ }
     try {
@@ -116,19 +152,6 @@ export async function update(flags = {}) {
     await installSkills();
     success('Up to date.');
 }
-// latestVersion fetches the current published version for --version display.
-export async function latestVersion() {
-    try {
-        const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(3000) });
-        if (!res.ok)
-            return null;
-        const data = await res.json();
-        return data.version ?? null;
-    }
-    catch {
-        return null;
-    }
-}
 // Stable-only semver comparison (1.2.3). Prerelease versions (1.2.3-wip.0)
 // produce NaN in the patch slot, and `n > NaN` is always false — which is
 // what we want: a prerelease user should not be auto-rolled back to stable.

package/dist/commands/webhook.js

@@ -25,7 +25,16 @@ export async function list(flags) {
         printJson(endpoints);
         return;
     }
-    printTable(endpoints, {
+    // Curated columns: org_id is the query scope (identical every row), and
+    // url is mechanically derivable from slug — both omitted here to keep the
+    // table token-dense. `myapi webhook get <id>` shows the full record.
+    printTable(endpoints.map(e => ({
+        id: e.id,
+        name: e.name,
+        slug: e.slug,
+        crm_email_path: e.crm_email_path ?? '',
+        created_at: e.created_at,
+    })), {
         flags,
         empty: 'No webhook endpoints yet. Create one with: myapi webhook create --name <name>',
     });

package/dist/completion.d.ts

@@ -1,3 +1,5 @@
-export declare function initCompletion(): void;
+export declare const COMMANDS: string[];
+export declare const SUBCOMMANDS: Record<string, string[]>;
+export declare function handleCompletionRequest(): void;
 export declare function installCompletion(): void;
 export declare function uninstallCompletion(): void;

package/dist/completion.js

@@ -1,24 +1,46 @@
-// Shell autocomplete via omelette. Quietly active on every CLI run — when
-// the shell invokes us with the magic completion env vars, omelette's
-// init() handles the request and exits before we hit normal command
-// dispatch. On any other run, init() returns immediately.
+// Shell tab-completion — hand-rolled, zero third-party dependencies.
 //
-// User installs the shell hook with `myapi completion install` (or
-// uninstalls with `myapi completion uninstall`). Supports bash, zsh, and
-// fish (handled internally by omelette).
+// This previously used the `omelette` package. It was removed for
+// supply-chain safety: `myapi` is installed globally and reads the user's
+// live API key from ~/.myapi/config.json on every run, so an unmaintained
+// dependency on this path is an unacceptable compromise vector — one bad
+// release would exfiltrate every user's key. This module reproduces only
+// what we used (completion-request handling + shell init-file wiring) as
+// audited first-party code.
 //
-// The tree below mirrors the dispatcher in index.ts and the per-command
-// switch statements. When you add a new top-level command or subcommand,
-// extend it here too — there's no automatic discovery.
-import omelette from 'omelette';
-const TREE = {
-    auth: ['link', 'switch', 'whoami', 'config', 'registrant'],
-    registrant: ['set', 'get', 'clear'],
+// Protocol: the shell init snippet generated below calls back
+//   myapi --comp{bash,zsh,fish} --compgen <cword> <prev> <line>
+// We parse <line>, compute the candidate list, print it newline-separated,
+// and exit. The shell itself narrows the list to the partial word.
+//
+// This module is imported lazily (see index.ts) — only when argv carries a
+// --comp* marker — so it never loads on a normal command run.
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const PROGRAM = 'myapi';
+const COMPLETION_DIR = path.join(os.homedir(), '.myapi');
+const BLOCK_BEGIN = `# begin ${PROGRAM} completion`;
+const BLOCK_END = `# end ${PROGRAM} completion`;
+// Top-level commands — what `myapi <TAB>` offers. Kept honest by
+// test/smoke/completion.test.ts, which fails if a command in `myapi --help`
+// is missing here.
+export const COMMANDS = [
+    'audience', 'auth', 'billing', 'company', 'completion', 'config', 'container',
+    'crm', 'database', 'domain', 'email', 'fn', 'funnel', 'help', 'image',
+    'install-skills', 'keys', 'llm', 'org', 'payments', 'people', 'pixel',
+    'setup', 'status', 'storage', 'update', 'url', 'webhook', 'whoami',
+    'workflow',
+];
+// command → subcommands, for `myapi <command> <TAB>`. Mirrors each
+// command's dispatcher; commands absent here take no subcommand.
+export const SUBCOMMANDS = {
+    auth: ['setup', 'import-key', 'whoami', 'link', 'switch', 'install-skills', 'config', 'registrant', 'api-keys'],
     org: ['create', 'delete', 'get', 'import', 'list', 'sync-brand', 'update'],
-    billing: ['balance', 'history', 'setup', 'topup'],
-    domain: ['assign', 'check', 'list', 'register', 'renew', 'settings', 'status', 'unassign', 'update-settings'],
-    funnel: ['create', 'delete', 'get', 'list', 'pages', 'push', 'verify'],
-    webhook: ['create', 'delete', 'delivery', 'list'],
+    billing: ['balance', 'history', 'usage', 'setup', 'topup', 'spend-cap'],
+    domain: ['assign', 'check', 'email-setup', 'import', 'list', 'records', 'register', 'renew', 'retry-provisioning', 'settings', 'status'],
+    funnel: ['create', 'delete', 'get', 'list', 'pages', 'publish', 'push', 'verify'],
+    webhook: ['create', 'delete', 'delivery', 'list', 'update'],
     workflow: ['create', 'delete', 'disable', 'enable', 'get', 'get-run', 'list', 'runs', 'update'],
     email: ['mailbox', 'message', 'warmup', 'template', 'campaign', 'verify'],
     image: ['delete', 'generate', 'get', 'get-url', 'list', 'models'],
@@ -30,49 +52,132 @@ const TREE = {
     llm: ['complete', 'embed', 'models'],
     database: ['namespaces', 'create', 'delete-namespace', 'keys', 'get', 'set', 'del'],
     crm: ['contacts', 'companies'],
-    contacts: ['list', 'search', 'create', 'get', 'update', 'delete', 'restore', 'promote', 'events'],
-    companies: ['list', 'search', 'create', 'get', 'update', 'delete', 'restore', 'promote'],
     url: ['shorten'],
-    keys: ['create', 'list', 'revoke'],
-    'api-keys': ['create', 'list', 'revoke'],
+    keys: ['create', 'list', 'revoke', 'revoke-all'],
     config: ['view', 'set-org', 'set-funnel', 'set-domain'],
-    setup: [],
-    'import-key': [],
-    whoami: [],
-    status: [],
-    'install-skills': [],
-    update: [],
+    fn: ['create', 'deploy', 'env', 'runs', 'list', 'get', 'delete'],
+    payments: ['connect', 'status', 'charge', 'list', 'get', 'refund'],
+    container: ['create', 'deploy', 'list', 'get', 'logs', 'delete'],
     completion: ['install', 'uninstall'],
-    help: [],
 };
-const TOP_LEVEL = Object.keys(TREE).sort();
-const completion = omelette('myapi <command> <subcommand>');
-completion.on('command', ({ reply }) => reply(TOP_LEVEL));
-completion.on('subcommand', ({ before, reply, line }) => {
-    // omelette's `before` is the LAST word of the line, not the previous
-    // word. When the user has started typing a partial subcommand (e.g.
-    // "myapi audience l"), `before` is "l", not "audience" — so a naive
-    // `TREE[before]` returns undefined and tab completion silently fails.
-    // Detect the real parent command by checking whether the line ends in
-    // whitespace (no partial in flight → use `before`) vs. mid-word (partial
-    // in flight → use the previous word from the line).
-    const endsInSpace = /\s$/.test(line);
-    const parent = endsInSpace
-        ? before
-        : (line.trim().split(/\s+/).slice(-2, -1)[0] ?? before);
-    reply(TREE[parent] ?? []);
-});
-// Quiet no-op when shell isn't asking for completion. The first thing
-// index.ts should do is call this — omelette will short-circuit and
-// process.exit if a completion request is in flight.
-export function initCompletion() {
-    completion.init();
+// ── Completion request handling ──────────────────────────────────────────────
+// Entry point for a shell-initiated completion request. index.ts calls this
+// (via a lazy import) whenever argv carries a --comp* marker. Always exits.
+export function handleCompletionRequest() {
+    const argv = process.argv;
+    // `myapi --completion[-fish]` — emit the shell init script (zsh/fish
+    // source it live; bash sources the copy written by installCompletion).
+    if (argv.includes('--completion')) {
+        process.stdout.write(shellScript());
+        process.exit(0);
+    }
+    if (argv.includes('--completion-fish')) {
+        process.stdout.write(fishScript());
+        process.exit(0);
+    }
+    // `myapi --comp{bash,zsh} --compgen <cword> <prev> <line...>`
+    const gen = argv.indexOf('--compgen');
+    if (gen < 0)
+        process.exit(0);
+    // zsh's cursor index is one higher than bash's for the same position.
+    const isZsh = argv.includes('--compzsh');
+    const cword = (parseInt(argv[gen + 1], 10) || 0) - (isZsh ? 1 : 0);
+    const line = argv.slice(gen + 3).join(' ');
+    const words = line.trim().split(/\s+/);
+    let candidates = [];
+    if (cword <= 1)
+        candidates = COMMANDS;
+    else if (cword === 2)
+        candidates = SUBCOMMANDS[words[1]] ?? [];
+    // Print the full list; the shell narrows it to the partial word.
+    process.stdout.write(candidates.join(os.EOL) + os.EOL);
+    process.exit(0);
+}
+// ── Shell init scripts ───────────────────────────────────────────────────────
+// bash + zsh completion function. The `if compdef / elif complete` guard
+// picks the right registration at source time, so one script serves both.
+function shellScript() {
+    return `### ${PROGRAM} completion ###
+if type compdef &>/dev/null; then
+  _${PROGRAM}_completion() {
+    compadd -- \`${PROGRAM} --compzsh --compgen "$CURRENT" "\${words[CURRENT-1]}" "$BUFFER"\`
+  }
+  compdef _${PROGRAM}_completion ${PROGRAM}
+elif type complete &>/dev/null; then
+  _${PROGRAM}_completion() {
+    local cur="\${COMP_WORDS[COMP_CWORD]}" prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    COMPREPLY=( $(compgen -W '$(${PROGRAM} --compbash --compgen "$COMP_CWORD" "$prev" "$COMP_LINE")' -- "$cur") )
+  }
+  complete -F _${PROGRAM}_completion ${PROGRAM}
+fi
+`;
+}
+function fishScript() {
+    return `### ${PROGRAM} completion ###
+function _${PROGRAM}_completion
+  ${PROGRAM} --compfish --compgen (count (commandline -poc)) (commandline -pt) (commandline -pb)
+end
+complete -f -c ${PROGRAM} -a '(_${PROGRAM}_completion)'
+`;
+}
+// ── Install / uninstall ──────────────────────────────────────────────────────
+function activeShell() {
+    const s = process.env.SHELL ?? '';
+    if (s.includes('zsh'))
+        return 'zsh';
+    if (s.includes('fish'))
+        return 'fish';
+    if (s.includes('bash'))
+        return 'bash';
+    throw new Error(`Could not detect a supported shell (SHELL="${s}"). Supported: bash, zsh, fish.`);
+}
+function initFile(shell) {
+    const home = os.homedir();
+    if (shell === 'zsh')
+        return path.join(home, '.zshrc');
+    if (shell === 'fish')
+        return path.join(home, '.config', 'fish', 'config.fish');
+    return path.join(home, process.platform === 'darwin' ? '.bash_profile' : '.bashrc');
+}
+// The source line appended to the shell's rc file.
+function initBlock(shell) {
+    let cmd;
+    if (shell === 'bash')
+        cmd = `source "${path.join(COMPLETION_DIR, 'completion.sh')}"`;
+    else if (shell === 'zsh')
+        cmd = `. <(${PROGRAM} --completion)`;
+    else
+        cmd = `${PROGRAM} --completion-fish | source`;
+    return `\n${BLOCK_BEGIN}\n${cmd}\n${BLOCK_END}\n`;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-// Wire/unwire the shell rc snippet. Omelette writes a single eval line
-// into ~/.bashrc / ~/.zshrc / ~/.config/fish/config.fish.
 export function installCompletion() {
-    completion.setupShellInitFile();
+    const shell = activeShell();
+    // bash can't reliably source a process substitution from .bashrc, so the
+    // script is written to a file the rc line sources.
+    if (shell === 'bash') {
+        fs.mkdirSync(COMPLETION_DIR, { recursive: true });
+        fs.writeFileSync(path.join(COMPLETION_DIR, 'completion.sh'), shellScript());
+    }
+    const file = initFile(shell);
+    const existing = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+    if (existing.includes(BLOCK_BEGIN))
+        return; // idempotent — already installed
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, initBlock(shell));
 }
 export function uninstallCompletion() {
-    completion.cleanupShellInitFile();
+    const shell = activeShell();
+    const file = initFile(shell);
+    if (fs.existsSync(file)) {
+        const cleaned = fs.readFileSync(file, 'utf8').replace(new RegExp(`\\n?${escapeRe(BLOCK_BEGIN)}[\\s\\S]*?${escapeRe(BLOCK_END)}\\n?`, 'g'), '');
+        fs.writeFileSync(file, cleaned);
+    }
+    if (shell === 'bash') {
+        const sh = path.join(COMPLETION_DIR, 'completion.sh');
+        if (fs.existsSync(sh))
+            fs.unlinkSync(sh);
+    }
 }

package/dist/exposes.test.js

@@ -39,6 +39,7 @@ const COMMAND_MODULES = [
     './commands/workflow.js',
     './commands/fn.js',
     './commands/payments.js',
+    './commands/container.js',
 ];
 const ENDPOINT_PATTERN = /^(GET|POST|PATCH|PUT|DELETE) \/[A-Za-z0-9_\-./{}]*$/;
 describe('every CLI command exports a typed EXPOSES array (S-101)', () => {

package/dist/index.js

@@ -31,7 +31,7 @@ import * as databaseCmd from './commands/database.js';
 import * as crmCmd from './commands/crm/index.js';
 import * as fnCmd from './commands/fn.js';
 import * as paymentsCmd from './commands/payments.js';
-import { initCompletion, installCompletion, uninstallCompletion } from './completion.js';
+import * as containerCmd from './commands/container.js';
 // Each command file declares the value flags it understands. We union them
 // into a single schema for the upfront parse, so adding a new value flag in
 // one command means editing one file (its SCHEMA), not a global allowlist.
@@ -59,6 +59,7 @@ const COMBINED_SCHEMA = {
     ...workflowCmd.SCHEMA,
     ...fnCmd.SCHEMA,
     ...paymentsCmd.SCHEMA,
+    ...containerCmd.SCHEMA,
     // Top-level flags
     version: 'boolean',
     V: 'boolean',
@@ -114,12 +115,20 @@ function friendlyError(err) {
     return base;
 }
 async function main() {
-    // Shell autocomplete: if invoked by the shell with completion env vars,
-    // omelette short-circuits before normal dispatch. Always cheap on a real run.
-    initCompletion();
+    // Shell tab-completion: when the shell invokes us for completion it passes
+    // a --comp* marker. Handle it via a lazily-imported module so completion
+    // code (and its file I/O) never loads on a normal command run.
+    if (process.argv.some(a => a === '--compgen' || a === '--completion' || a === '--completion-fish')) {
+        const { handleCompletionRequest } = await import('./completion.js');
+        handleCompletionRequest(); // computes candidates / emits the script, then exits
+        return;
+    }
     const { args, flags } = parseFlags(process.argv.slice(2), COMBINED_SCHEMA);
     if (flags.version || flags.v || flags.V) {
-        const latest = await updateCmd.latestVersion();
+        // Read the last-known published version from cache — no network call, so
+        // `myapi --version` stays instant. The cache is refreshed by the
+        // background update check on regular commands.
+        const latest = updateCmd.cachedLatestVersion();
         const updateNote = latest && updateCmd.isNewer(latest, pkg.version)
             ? ` (update available: ${latest})`
             : '';
@@ -207,6 +216,9 @@ async function main() {
             case 'payments':
                 await paymentsCmd.run(subcommand, restArgs, flags);
                 break;
+            case 'container':
+                await containerCmd.run(subcommand, restArgs, flags);
+                break;
             // Convenience aliases
             case 'setup':
                 await setupCmd.setup(flags);
@@ -231,20 +243,20 @@ async function main() {
                 await setupCmd.installSkills();
                 success('› Skills installed.');
                 break;
-            case 'completion':
-                // Order matters: omelette's setup/cleanup helpers call process.exit()
-                // unconditionally, so anything we want to show has to print first.
+            case 'completion': {
+                const { installCompletion, uninstallCompletion } = await import('./completion.js');
                 if (subcommand === 'uninstall') {
-                    success('› Removing completion from shell init file…');
-                    info('  Restart your shell (or `source ~/.bashrc` / `~/.zshrc`) to take effect.');
                     uninstallCompletion();
+                    success('› Completion removed from your shell init file.');
+                    info('  Restart your shell (or re-source your rc file) for it to take effect.');
                 }
                 else {
-                    success('› Installing tab completion…');
-                    info('  Restart your shell (or `source ~/.bashrc` / `~/.zshrc`) to enable.');
                     installCompletion();
+                    success('› Tab completion installed.');
+                    info('  Restart your shell (or re-source your rc file) to enable it.');
                 }
                 break;
+            }
             case 'help':
                 await dispatchHelp(subcommand);
                 break;
@@ -329,6 +341,7 @@ const HELP_TARGETS = {
     crm: f => crmCmd.run(undefined, [], f),
     fn: f => fnCmd.run(undefined, [], f),
     payments: f => paymentsCmd.run(undefined, [], f),
+    container: f => containerCmd.run(undefined, [], f),
     org: f => orgCmd.run(undefined, [], f),
     billing: f => billingCmd.run(undefined, [], f),
     keys: f => keysCmd.run(undefined, [], f),
@@ -371,6 +384,7 @@ Commands:
   domain          Manage domain configurations
   funnel          Manage websites (publish pages, custom domains, funnels)
   fn              Create and deploy functions on the edge runtime
+  container       Run containers — services, workers, and scheduled jobs
   payments        Take payments with Stripe Checkout (connect, charge, refund)
   webhook         Manage inbound webhook endpoints and inspect deliveries
   email           Manage mailboxes, send/read email, templates, and campaigns

package/dist/sdk-billing-usage.test.d.ts

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

package/dist/sdk-billing-usage.test.js

@@ -0,0 +1,74 @@
+// SDK-level unit tests for hq.getBillingUsage — the spend-by-service
+// rollup backed by the backend's detailed metering
+// (GET /hq/billing/usage). Mocks global fetch — does NOT hit the network.
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { hq } from '@myapihq/sdk';
+const API_KEY = 'myapi_test_abc';
+let fetchMock;
+function ok(data, status = 200) {
+    return new Response(JSON.stringify({ success: true, data, meta: {} }), {
+        status,
+        headers: { 'content-type': 'application/json' },
+    });
+}
+function fail(code, message, status = 400) {
+    return new Response(JSON.stringify({ success: false, error: { code, message }, meta: {} }), {
+        status,
+        headers: { 'content-type': 'application/json' },
+    });
+}
+const SAMPLE = {
+    period: 'month',
+    since: '2026-05-01T00:00:00Z',
+    services: [
+        { service: 'llm', requests: 1240, cost_display: '$3.10' },
+        { service: 'image', requests: 22, cost_display: '$0.44' },
+    ],
+    total_display: '$3.54',
+};
+beforeEach(() => {
+    fetchMock = vi.fn();
+    globalThis.fetch = fetchMock;
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+describe('hq.getBillingUsage', () => {
+    it('GETs /hq/billing/usage with bearer auth and no query by default', async () => {
+        fetchMock.mockResolvedValueOnce(ok(SAMPLE));
+        const res = await hq.getBillingUsage(API_KEY);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toMatch(/\/hq\/billing\/usage$/);
+        expect(init.method).toBe('GET');
+        expect(init.headers.Authorization).toBe(`Bearer ${API_KEY}`);
+        expect(res.total_display).toBe('$3.54');
+        expect(res.services).toHaveLength(2);
+        expect(res.services[0]).toEqual({ service: 'llm', requests: 1240, cost_display: '$3.10' });
+    });
+    it('appends ?period=30d when the trailing-30-days window is requested', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ ...SAMPLE, period: '30d' }));
+        await hq.getBillingUsage(API_KEY, '30d');
+        expect(fetchMock.mock.calls[0][0]).toMatch(/\/hq\/billing\/usage\?period=30d$/);
+    });
+    it('sends period=month explicitly when asked', async () => {
+        fetchMock.mockResolvedValueOnce(ok(SAMPLE));
+        await hq.getBillingUsage(API_KEY, 'month');
+        expect(fetchMock.mock.calls[0][0]).toMatch(/\?period=month$/);
+    });
+    it('returns an empty services list cleanly (no spend in the window)', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ period: 'month', since: '2026-05-01T00:00:00Z', services: [], total_display: '$0.00' }));
+        const res = await hq.getBillingUsage(API_KEY);
+        expect(res.services).toEqual([]);
+        expect(res.total_display).toBe('$0.00');
+    });
+    it('surfaces a bad period (400) as a typed MyApiError', async () => {
+        fetchMock.mockResolvedValueOnce(fail('bad_request', "period must be 'month' or '30d'", 400));
+        await expect(hq.getBillingUsage(API_KEY, 'month'))
+            .rejects.toMatchObject({ name: 'MyApiError', status: 400 });
+    });
+});
+describe('hq.EXPOSES', () => {
+    it('lists GET /hq/billing/usage', () => {
+        expect(hq.EXPOSES).toContain('GET /hq/billing/usage');
+    });
+});

package/dist/sdk-container.test.d.ts

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