@myapihq/cli 1.2.9 → 1.3.1

package/dist/commands/task.js

@@ -0,0 +1,288 @@
+import { task as sdkTask } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, printTable, info, printJson } from '../output.js';
+import { formatDate } from '../utils.js';
+import { requireOrg, requireArg } from '../helpers.js';
+import * as fs from 'fs';
+export const EXPOSES = [
+    'POST /task/orgs/{org_id}/tasks',
+    'GET /task/orgs/{org_id}/tasks',
+    'GET /task/orgs/{org_id}/tasks/{id}',
+    'DELETE /task/orgs/{org_id}/tasks/{id}',
+    'GET /task/orgs/{org_id}/tasks/{id}/body',
+    'POST /task/orgs/{org_id}/tasks/{id}/claim',
+    'POST /task/orgs/{org_id}/tasks/{id}/extend',
+    'POST /task/orgs/{org_id}/tasks/{id}/fail',
+    'POST /task/orgs/{org_id}/tasks/{id}/resolve',
+];
+export const SCHEMA = {
+    body: 'string',
+    importance: 'string',
+    due: 'string',
+    assignee: 'string',
+    tag: 'string',
+    'depends-on': 'string',
+    'dedup-key': 'string',
+    'resolve-on': 'string',
+    source: 'string',
+    status: 'string',
+    limit: 'number',
+    lease: 'number',
+    worker: 'string',
+    reason: 'string',
+};
+// The backend's fixed importance enum — validated client-side so a typo
+// fails before the network call.
+export const TASK_IMPORTANCE = ['low', 'normal', 'high', 'critical'];
+// Parses --resolve-on "<event_type>[:<field>=<value>]" into a matcher.
+// Returns the parsed object, or a string error message.
+export function _parseResolveOn(raw) {
+    const trimmed = raw.trim();
+    if (trimmed === '')
+        return '--resolve-on cannot be empty.';
+    const colon = trimmed.indexOf(':');
+    if (colon === -1)
+        return { event_type: trimmed };
+    const eventType = trimmed.slice(0, colon);
+    const rest = trimmed.slice(colon + 1);
+    if (eventType === '')
+        return '--resolve-on must start with an event type, e.g. payment.succeeded:amount=100';
+    const eq = rest.indexOf('=');
+    if (eq === -1) {
+        return `--resolve-on field match must look like field=value — got "${rest}".`;
+    }
+    return { event_type: eventType, field: rest.slice(0, eq), value: rest.slice(eq + 1) };
+}
+// Parses a comma-separated --tag / --depends-on flag into a clean array.
+export function _splitList(raw) {
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return undefined;
+    return raw.split(',').map(s => s.trim()).filter(Boolean);
+}
+// --body accepts inline text or @path to read a Markdown file.
+function resolveBody(raw) {
+    if (raw.startsWith('@')) {
+        const path = raw.slice(1);
+        try {
+            return fs.readFileSync(path, 'utf-8');
+        }
+        catch (e) {
+            error(`Could not read --body file "${path}": ${e?.message ?? e}`);
+        }
+    }
+    return raw;
+}
+// ── Create / list ────────────────────────────────────────────────────────────
+export async function create(description, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi task create "<description>" [--org <id>]');
+    requireArg(description, 'description', 'myapi task create "<description>"');
+    let resolveOn;
+    if (typeof flags['resolve-on'] === 'string') {
+        const parsed = _parseResolveOn(flags['resolve-on']);
+        if (typeof parsed === 'string')
+            error(parsed);
+        resolveOn = parsed;
+    }
+    let body;
+    if (typeof flags.body === 'string')
+        body = resolveBody(flags.body);
+    else if (flags.body === true)
+        error('--body needs a value: inline Markdown or @path-to-file.');
+    let importance;
+    if (typeof flags.importance === 'string') {
+        if (!TASK_IMPORTANCE.includes(flags.importance)) {
+            error(`Invalid --importance "${flags.importance}". Must be one of: ${TASK_IMPORTANCE.join(', ')}.`);
+        }
+        importance = flags.importance;
+    }
+    const t = await sdkTask.createTask(config.api_key, orgId, {
+        description,
+        body,
+        importance,
+        dueAt: typeof flags.due === 'string' ? flags.due : undefined,
+        assignee: typeof flags.assignee === 'string' ? flags.assignee : undefined,
+        tags: _splitList(flags.tag),
+        dependsOn: _splitList(flags['depends-on']),
+        dedupKey: typeof flags['dedup-key'] === 'string' ? flags['dedup-key'] : undefined,
+        resolveOn,
+        source: typeof flags.source === 'string' ? flags.source : undefined,
+    });
+    if (flags.json) {
+        printJson(t);
+        return;
+    }
+    success(`Task created: ${t.id}`);
+    info(`Status: ${t.status}`);
+    if (t.assignee)
+        info(`Assignee: ${t.assignee} (magic link emailed)`);
+}
+export async function list(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi task list [--org <id>]');
+    const res = await sdkTask.listTasks(config.api_key, orgId, {
+        status: typeof flags.status === 'string' ? flags.status : undefined,
+        tag: typeof flags.tag === 'string' ? flags.tag : undefined,
+        importance: typeof flags.importance === 'string' ? flags.importance : undefined,
+        assignee: typeof flags.assignee === 'string' ? flags.assignee : undefined,
+        source: typeof flags.source === 'string' ? flags.source : undefined,
+        limit: typeof flags.limit === 'number' ? flags.limit : undefined,
+    });
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    printTable(res.tasks.map(t => ({
+        id: t.id,
+        score: t.score,
+        description: t.description,
+    })), { flags, empty: 'No open tasks.' });
+    info('');
+    info(`Showing ${res.meta.shown} of ${res.meta.total_open} open task(s).`);
+}
+// ── Read ─────────────────────────────────────────────────────────────────────
+export async function get(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi task get <id> [--body] [--org <id>]');
+    requireArg(id, 'id', 'myapi task get <id>');
+    const t = await sdkTask.getTask(config.api_key, orgId, id);
+    // --body opts in to the separate body tier — never fetched implicitly.
+    const wantBody = flags.body === true || typeof flags.body === 'string';
+    const body = wantBody ? await sdkTask.getTaskBody(config.api_key, orgId, id) : undefined;
+    if (flags.json) {
+        printJson(wantBody ? { ...t, body } : t);
+        return;
+    }
+    info(`Task:        ${t.id}`);
+    info(`Status:      ${t.status}`);
+    info(`Description: ${t.description}`);
+    if (t.importance)
+        info(`Importance:  ${t.importance}`);
+    if (t.due_at)
+        info(`Due:         ${formatDate(t.due_at)}`);
+    if (t.assignee)
+        info(`Assignee:    ${t.assignee}`);
+    if (t.tags?.length)
+        info(`Tags:        ${t.tags.join(', ')}`);
+    if (t.depends_on?.length)
+        info(`Depends on:  ${t.depends_on.join(', ')}`);
+    if (t.claimed_by)
+        info(`Claimed by:  ${t.claimed_by}`);
+    if (t.lease_expires_at)
+        info(`Lease until: ${formatDate(t.lease_expires_at)}`);
+    if (wantBody) {
+        info('');
+        info('── body ──');
+        info(body ?? '');
+    }
+}
+// ── Lifecycle ────────────────────────────────────────────────────────────────
+export async function claim(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi task claim <id> [--lease <seconds>] [--worker <name>] [--org <id>]');
+    requireArg(id, 'id', 'myapi task claim <id>');
+    const t = await sdkTask.claimTask(config.api_key, orgId, id, {
+        leaseSeconds: typeof flags.lease === 'number' ? flags.lease : undefined,
+        worker: typeof flags.worker === 'string' ? flags.worker : undefined,
+    });
+    if (flags.json) {
+        printJson(t);
+        return;
+    }
+    success(`Claimed task ${t.id}`);
+    if (t.lease_expires_at)
+        info(`Lease expires: ${formatDate(t.lease_expires_at)} — heartbeat with: myapi task extend ${t.id}`);
+}
+export async function extend(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi task extend <id> [--lease <seconds>] [--org <id>]');
+    requireArg(id, 'id', 'myapi task extend <id>');
+    const t = await sdkTask.extendTask(config.api_key, orgId, id, {
+        leaseSeconds: typeof flags.lease === 'number' ? flags.lease : undefined,
+    });
+    if (flags.json) {
+        printJson(t);
+        return;
+    }
+    success(`Extended lease on task ${t.id}`);
+    if (t.lease_expires_at)
+        info(`Lease expires: ${formatDate(t.lease_expires_at)}`);
+}
+export async function resolve(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi task resolve <id> [--org <id>]');
+    requireArg(id, 'id', 'myapi task resolve <id>');
+    await sdkTask.resolveTask(config.api_key, orgId, id);
+    success(`Resolved task ${id}`);
+}
+export async function fail(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi task fail <id> --reason "<why>" [--org <id>]');
+    requireArg(id, 'id', 'myapi task fail <id> --reason "<why>"');
+    const reason = flags.reason;
+    if (typeof reason !== 'string' || reason.trim() === '') {
+        error('Missing --reason.\nUsage: myapi task fail <id> --reason "<why>"');
+    }
+    await sdkTask.failTask(config.api_key, orgId, id, reason);
+    success(`Failed task ${id}`);
+}
+export async function cancel(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi task cancel <id> [--org <id>]');
+    requireArg(id, 'id', 'myapi task cancel <id>');
+    await sdkTask.cancelTask(config.api_key, orgId, id);
+    success(`Cancelled task ${id}`);
+}
+// ── Dispatcher ───────────────────────────────────────────────────────────────
+const SUBCOMMAND_USAGE = {
+    'create': 'myapi task create "<description>" [--body <md|@file>] [--importance <i>] [--due <rfc3339>] [--assignee <email>] [--tag <t,t>] [--depends-on <id,id>] [--dedup-key <k>] [--resolve-on <event[:field=value]>] [--source <s>] [--org <id>]',
+    'list': 'myapi task list [--status <s>] [--tag <t>] [--importance <i>] [--assignee <email>] [--source <s>] [--limit <n>] [--org <id>] [--json]',
+    'get': 'myapi task get <id> [--body] [--org <id>] [--json]\n\n--body additionally fetches the Markdown body tier (a separate read).',
+    'claim': 'myapi task claim <id> [--lease <seconds>] [--worker <name>] [--org <id>]',
+    'extend': 'myapi task extend <id> [--lease <seconds>] [--org <id>]',
+    'resolve': 'myapi task resolve <id> [--org <id>]',
+    'fail': 'myapi task fail <id> --reason "<why>" [--org <id>]',
+    'cancel': 'myapi task cancel <id> [--org <id>]',
+};
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi task <subcommand>
+
+An agent-task queue — the agent-loop hot path. Tasks are ranked by score,
+claimed under a lease, then resolved, failed, or cancelled.
+
+  create "<description>"  File a task (--body, --importance, --assignee, --resolve-on, ...)
+  list                    Top open tasks, ranked (--status, --tag, --limit)
+  get <id>                Show a task; --body also fetches the Markdown body tier
+  claim <id>              Take an atomic lease (default 10 min)
+  extend <id>             Heartbeat a live claim
+  resolve <id>            Resolve a task (terminal) — unblocks dependents
+  fail <id>               Fail a task (terminal) — requires --reason
+  cancel <id>             Cancel a task (terminal, distinct from fail)
+
+The agent loop is: list → get <id> --body → claim → resolve.
+For durable machine work (retried HTTP jobs), see: myapi queue --help
+
+All commands accept --org <id> (or set default: myapi config set-org <id>).`);
+        return;
+    }
+    if (flags.help) {
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi task --help" for the list.`);
+        return;
+    }
+    switch (subcommand) {
+        case 'create': return create(args[0], flags);
+        case 'list': return list(flags);
+        case 'get': return get(args[0], flags);
+        case 'claim': return claim(args[0], flags);
+        case 'extend': return extend(args[0], flags);
+        case 'resolve': return resolve(args[0], flags);
+        case 'fail': return fail(args[0], flags);
+        case 'cancel': return cancel(args[0], flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi task --help" for a list of valid subcommands.`);
+    }
+}

package/dist/commands/workflow-validation.test.js

@@ -120,6 +120,33 @@ describe('_validateSteps — http_request / http (2026-05-15)', () => {
             .toMatch(/"headers" value for "X-Token" must be a string/);
     });
 });
+describe('_validateSteps — enqueue_job / enqueue (2026-05-19)', () => {
+    const VALID_ENQUEUE = { type: 'enqueue_job', queue: 'thumbnails' };
+    it('accepts the canonical type name', () => {
+        expect(_validateSteps([VALID_ENQUEUE])).toBeNull();
+    });
+    it('accepts the `enqueue` alias', () => {
+        expect(_validateSteps([{ ...VALID_ENQUEUE, type: 'enqueue' }])).toBeNull();
+    });
+    it('accepts a string payload with templating', () => {
+        expect(_validateSteps([{ ...VALID_ENQUEUE, payload: '{"email":"{{ payload.email }}"}' }])).toBeNull();
+    });
+    it('accepts dedup_key and delay_seconds', () => {
+        expect(_validateSteps([{ ...VALID_ENQUEUE, dedup_key: 'k1', delay_seconds: 30 }])).toBeNull();
+    });
+    it('rejects when queue is missing', () => {
+        expect(_validateSteps([{ type: 'enqueue_job' }]))
+            .toMatch(/missing required field "queue"/);
+    });
+    it('rejects a non-string payload', () => {
+        expect(_validateSteps([{ ...VALID_ENQUEUE, payload: { not: 'a string' } }]))
+            .toMatch(/"payload" must be a string/);
+    });
+    it('rejects a non-number delay_seconds', () => {
+        expect(_validateSteps([{ ...VALID_ENQUEUE, delay_seconds: '30' }]))
+            .toMatch(/"delay_seconds" must be a number/);
+    });
+});
 describe('_validateSteps — mixed-type pipelines', () => {
     it('accepts an http_request after a send_email (pipeline shape)', () => {
         expect(_validateSteps([

package/dist/commands/workflow.js

@@ -26,7 +26,9 @@ export const SCHEMA = {
 //
 // 2026-05-15: backend added `http_request` (alias `http`). See
 // myapi-hq/internal/routes/workflow/execute.go.
-const SUPPORTED_STEP_TYPES = ['send_email', 'email', 'slack_message', 'slack', 'http_request', 'http'];
+// 2026-05-19: `enqueue_job` (alias `enqueue`) added — hands durable work to
+// my-queue-api. Backend step pending; see the orchestration cross-repo prompt.
+const SUPPORTED_STEP_TYPES = ['send_email', 'email', 'slack_message', 'slack', 'http_request', 'http', 'enqueue_job', 'enqueue'];
 const HTTP_METHODS = new Set(['GET', 'POST', 'PATCH', 'PUT', 'DELETE']);
 const SLACK_HOOK_RE = /^https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9_-]+\/[A-Za-z0-9_-]+\/[A-Za-z0-9_-]+/;
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -110,6 +112,20 @@ export function _validateSteps(steps) {
                 }
             }
         }
+        if (s.type === 'enqueue_job' || s.type === 'enqueue') {
+            if (!s.queue || typeof s.queue !== 'string') {
+                return `${where} (${s.type}): missing required field "queue" (the target queue name).`;
+            }
+            if (s.payload !== undefined && typeof s.payload !== 'string') {
+                return `${where} (${s.type}): "payload" must be a string (template substitutions supported).`;
+            }
+            if (s.dedup_key !== undefined && typeof s.dedup_key !== 'string') {
+                return `${where} (${s.type}): "dedup_key" must be a string.`;
+            }
+            if (s.delay_seconds !== undefined && typeof s.delay_seconds !== 'number') {
+                return `${where} (${s.type}): "delay_seconds" must be a number.`;
+            }
+        }
     }
     return null;
 }

package/dist/completion.js

@@ -28,8 +28,8 @@ const BLOCK_END = `# end ${PROGRAM} completion`;
 export const COMMANDS = [
     'audience', 'auth', 'billing', 'company', 'completion', 'config', 'container',
     'crm', 'database', 'domain', 'email', 'fn', 'funnel', 'git', 'help', 'image',
-    'install-skills', 'keys', 'llm', 'org', 'payments', 'people', 'pixel',
-    'setup', 'status', 'storage', 'update', 'url', 'webhook', 'whoami',
+    'install-skills', 'keys', 'llm', 'org', 'payments', 'people', 'pixel', 'queue',
+    'setup', 'status', 'storage', 'task', 'update', 'url', 'webhook', 'whoami',
     'workflow',
 ];
 // command → subcommands, for `myapi <command> <TAB>`. Mirrors each
@@ -57,8 +57,10 @@ export const SUBCOMMANDS = {
     config: ['view', 'set-org', 'set-funnel', 'set-domain'],
     fn: ['create', 'deploy', 'env', 'runs', 'list', 'get', 'delete'],
     payments: ['connect', 'status', 'charge', 'list', 'get', 'refund'],
-    container: ['create', 'deploy', 'list', 'get', 'logs', 'delete'],
+    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'],
+    queue: ['create', 'list', 'get', 'enqueue', 'jobs', 'job'],
+    task: ['create', 'list', 'get', 'claim', 'extend', 'resolve', 'fail', 'cancel'],
     completion: ['install', 'uninstall'],
 };
 // ── Completion request handling ──────────────────────────────────────────────

package/dist/exposes.test.js

@@ -41,6 +41,8 @@ const COMMAND_MODULES = [
     './commands/payments.js',
     './commands/container.js',
     './commands/git.js',
+    './commands/queue.js',
+    './commands/task.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

@@ -33,6 +33,8 @@ import * as fnCmd from './commands/fn.js';
 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 taskCmd from './commands/task.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.
@@ -62,6 +64,8 @@ const COMBINED_SCHEMA = {
     ...paymentsCmd.SCHEMA,
     ...containerCmd.SCHEMA,
     ...gitCmd.SCHEMA,
+    ...queueCmd.SCHEMA,
+    ...taskCmd.SCHEMA,
     // Top-level flags
     version: 'boolean',
     V: 'boolean',
@@ -224,6 +228,12 @@ async function main() {
             case 'git':
                 await gitCmd.run(subcommand, restArgs, flags);
                 break;
+            case 'queue':
+                await queueCmd.run(subcommand, restArgs, flags);
+                break;
+            case 'task':
+                await taskCmd.run(subcommand, restArgs, flags);
+                break;
             // Convenience aliases
             case 'setup':
                 await setupCmd.setup(flags);
@@ -348,6 +358,8 @@ const HELP_TARGETS = {
     payments: f => paymentsCmd.run(undefined, [], f),
     container: f => containerCmd.run(undefined, [], f),
     git: f => gitCmd.run(undefined, [], f),
+    queue: f => queueCmd.run(undefined, [], f),
+    task: f => taskCmd.run(undefined, [], f),
     org: f => orgCmd.run(undefined, [], f),
     billing: f => billingCmd.run(undefined, [], f),
     keys: f => keysCmd.run(undefined, [], f),
@@ -392,6 +404,8 @@ Commands:
   fn              Create and deploy functions on the edge runtime
   container       Run containers — services, workers, and scheduled jobs
   git             Hosted git repositories — repos, commits, branches, history
+  queue           Durable job queue — enqueue work, retried against an HTTP consumer
+  task            Agent-task queue — file, claim, and resolve units of work
   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-container.test.js

@@ -126,7 +126,7 @@ describe('container.getContainerLogs', () => {
     });
 });
 describe('container.EXPOSES', () => {
-    it('covers the 6 container endpoints', () => {
+    it('covers the 8 container endpoints', () => {
         expect(container.EXPOSES).toEqual([
             'POST /container/orgs/{org_id}/containers',
             'GET /container/orgs/{org_id}/containers',
@@ -134,6 +134,40 @@ describe('container.EXPOSES', () => {
             'DELETE /container/orgs/{org_id}/containers/{id}',
             'POST /container/orgs/{org_id}/containers/{id}/deploy',
             'GET /container/orgs/{org_id}/containers/{id}/logs',
+            'POST /container/orgs/{org_id}/containers/{id}/domain',
+            'DELETE /container/orgs/{org_id}/containers/{id}/domain',
         ]);
     });
 });
+describe('container custom domain', () => {
+    it('bindDomain POSTs {domain} and returns the binding', async () => {
+        fetchMock.mockResolvedValueOnce(ok({
+            container_id: C_ID, custom_domain: 'app.synthesisdaily.com',
+            origin: 'svc-abc.run.app', status: 'active',
+        }));
+        const b = await container.bindDomain(API_KEY, ORG_ID, C_ID, 'app.synthesisdaily.com');
+        expect(b.status).toBe('active');
+        expect(b.origin).toBe('svc-abc.run.app');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toBe(`https://api.myapihq.com/container/orgs/${ORG_ID}/containers/${C_ID}/domain`);
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ domain: 'app.synthesisdaily.com' });
+    });
+    it('bindDomain surfaces 422 when the container is not deployed', async () => {
+        fetchMock.mockResolvedValueOnce(fail('container_not_deployed', 'container not deployed', 422));
+        await expect(container.bindDomain(API_KEY, ORG_ID, C_ID, 'app.x.com'))
+            .rejects.toMatchObject({ status: 422 });
+    });
+    it('bindDomain surfaces 409 when a domain is already bound', async () => {
+        fetchMock.mockResolvedValueOnce(fail('domain_conflict', 'domain already bound', 409));
+        await expect(container.bindDomain(API_KEY, ORG_ID, C_ID, 'app.x.com'))
+            .rejects.toMatchObject({ status: 409 });
+    });
+    it('unbindDomain DELETEs the domain endpoint', async () => {
+        fetchMock.mockResolvedValueOnce(new Response(null, { status: 204 }));
+        await container.unbindDomain(API_KEY, ORG_ID, C_ID);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toBe(`https://api.myapihq.com/container/orgs/${ORG_ID}/containers/${C_ID}/domain`);
+        expect(init.method).toBe('DELETE');
+    });
+});

package/dist/sdk-email-forwarding.test.d.ts

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

package/dist/sdk-email-forwarding.test.js

@@ -0,0 +1,48 @@
+// SDK-level unit tests for mailbox forwarding —
+// email.setForwarding + email.deleteForwarding. Mocks fetch — no network.
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { email } 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, status) {
+    return new Response(JSON.stringify({ success: false, error: { code, message: code }, meta: {} }), {
+        status, headers: { 'content-type': 'application/json' },
+    });
+}
+beforeEach(() => { fetchMock = vi.fn(); globalThis.fetch = fetchMock; });
+afterEach(() => { vi.restoreAllMocks(); });
+describe('email.setForwarding', () => {
+    it('PUTs {forward_to} to the mailbox forwarding endpoint', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ address: 'a@x.com', forward_to: 'b@y.com' }));
+        const res = await email.setForwarding(API_KEY, 'a@x.com', 'b@y.com');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toContain('/email/mailboxes/a%40x.com/forwarding');
+        expect(init.method).toBe('PUT');
+        expect(JSON.parse(init.body)).toEqual({ forward_to: 'b@y.com' });
+        expect(res.forward_to).toBe('b@y.com');
+    });
+    it('surfaces FORWARD_LOOP (400)', async () => {
+        fetchMock.mockResolvedValueOnce(fail('FORWARD_LOOP', 400));
+        await expect(email.setForwarding(API_KEY, 'a@x.com', 'a@x.com'))
+            .rejects.toMatchObject({ code: 'FORWARD_LOOP', status: 400 });
+    });
+});
+describe('email.deleteForwarding', () => {
+    it('DELETEs the forwarding endpoint and resolves on 204', async () => {
+        fetchMock.mockResolvedValueOnce(new Response(null, { status: 204 }));
+        await email.deleteForwarding(API_KEY, 'a@x.com');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toContain('/email/mailboxes/a%40x.com/forwarding');
+        expect(init.method).toBe('DELETE');
+    });
+    it('surfaces MAILBOX_NOT_OWNED (403)', async () => {
+        fetchMock.mockResolvedValueOnce(fail('MAILBOX_NOT_OWNED', 403));
+        await expect(email.deleteForwarding(API_KEY, 'a@x.com'))
+            .rejects.toMatchObject({ code: 'MAILBOX_NOT_OWNED', status: 403 });
+    });
+});

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

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

package/dist/sdk-queue.test.js

@@ -0,0 +1,86 @@
+// SDK-level unit tests for the queue module. Verifies URL/body shape,
+// envelope-unwrapping, query params, and error handling against
+// myapi-hq/internal/routes/queue/. Mocks global fetch — no network.
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { queue } from '@myapihq/sdk';
+const API_KEY = 'myapi_test_abc';
+const ORG = '11111111-1111-4111-8111-111111111111';
+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, status) {
+    return new Response(JSON.stringify({ success: false, error: { code, message: code }, meta: {} }), {
+        status, headers: { 'content-type': 'application/json' },
+    });
+}
+beforeEach(() => { fetchMock = vi.fn(); globalThis.fetch = fetchMock; });
+afterEach(() => { vi.restoreAllMocks(); });
+describe('queue queues', () => {
+    it('createQueue POSTs {name, consumer_url} and optional policy fields', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ name: 'q', consumer_url: 'https://c', max_attempts: 5, max_concurrency: 5 }, 201));
+        await queue.createQueue(API_KEY, ORG, {
+            name: 'q', consumerUrl: 'https://c', maxAttempts: 3, maxConcurrency: 2,
+        });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toContain(`/queue/orgs/${ORG}/queues`);
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({
+            name: 'q', consumer_url: 'https://c', max_attempts: 3, max_concurrency: 2,
+        });
+    });
+    it('createQueue omits unset optional fields', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ name: 'q', consumer_url: 'https://c', max_attempts: 5, max_concurrency: 5 }, 201));
+        await queue.createQueue(API_KEY, ORG, { name: 'q', consumerUrl: 'https://c' });
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ name: 'q', consumer_url: 'https://c' });
+    });
+    it('listQueues unwraps the {queues:[...]} envelope to an array', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ queues: [{ name: 'a' }, { name: 'b' }] }));
+        expect(await queue.listQueues(API_KEY, ORG)).toEqual([{ name: 'a' }, { name: 'b' }]);
+    });
+    it('getQueue GETs /queues/{name}', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ name: 'q', consumer_url: 'https://c', max_attempts: 5, max_concurrency: 5 }));
+        const q = await queue.getQueue(API_KEY, ORG, 'q');
+        expect(q.max_attempts).toBe(5);
+        expect(fetchMock.mock.calls[0][0]).toContain(`/queue/orgs/${ORG}/queues/q`);
+    });
+});
+describe('queue jobs', () => {
+    it('enqueueJob POSTs payload/dedup_key/delay_seconds/depends_on', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ id: 'j1', queue: 'q', status: 'pending', attempts: 0 }, 201));
+        await queue.enqueueJob(API_KEY, ORG, 'q', {
+            payload: { x: 1 }, dedupKey: 'k', delaySeconds: 30, dependsOn: ['j0'],
+        });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toContain(`/queue/orgs/${ORG}/queues/q/jobs`);
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({
+            payload: { x: 1 }, dedup_key: 'k', delay_seconds: 30, depends_on: ['j0'],
+        });
+    });
+    it('listJobs unwraps {jobs} and passes status/limit as query', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ jobs: [{ id: 'j1', status: 'dead' }] }));
+        const jobs = await queue.listJobs(API_KEY, ORG, 'q', { status: 'dead', limit: 50 });
+        expect(jobs).toHaveLength(1);
+        const url = fetchMock.mock.calls[0][0];
+        expect(url).toMatch(/\/jobs\?/);
+        expect(url).toContain('status=dead');
+        expect(url).toContain('limit=50');
+    });
+    it('getJob GETs /jobs/{id} and surfaces 404', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ id: 'j1', queue: 'q', status: 'succeeded', attempts: 1 }));
+        expect((await queue.getJob(API_KEY, ORG, 'j1')).status).toBe('succeeded');
+        expect(fetchMock.mock.calls[0][0]).toContain(`/queue/orgs/${ORG}/jobs/j1`);
+        fetchMock.mockResolvedValueOnce(fail('job not found', 404));
+        await expect(queue.getJob(API_KEY, ORG, 'gone')).rejects.toMatchObject({ status: 404 });
+    });
+});
+describe('queue.EXPOSES', () => {
+    it('covers all 6 queue endpoints', () => {
+        expect(queue.EXPOSES).toHaveLength(6);
+        expect(queue.EXPOSES).toContain('POST /queue/orgs/{org_id}/queues/{name}/jobs');
+        expect(queue.EXPOSES).toContain('GET /queue/orgs/{org_id}/jobs/{id}');
+    });
+});

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

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