@myapihq/cli 1.2.8 → 1.3.0

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

@@ -27,9 +27,9 @@ const BLOCK_END = `# end ${PROGRAM} completion`;
 // 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',
+    'crm', 'database', 'domain', 'email', 'fn', 'funnel', 'git', 'help', 'image',
+    '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
@@ -58,6 +58,9 @@ export const SUBCOMMANDS = {
     fn: ['create', 'deploy', 'env', 'runs', 'list', 'get', 'delete'],
     payments: ['connect', 'status', 'charge', 'list', 'get', 'refund'],
     container: ['create', 'deploy', 'list', 'get', 'logs', '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

@@ -40,6 +40,9 @@ const COMMAND_MODULES = [
     './commands/fn.js',
     './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

@@ -32,6 +32,9 @@ import * as crmCmd from './commands/crm/index.js';
 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.
@@ -60,6 +63,9 @@ const COMBINED_SCHEMA = {
     ...fnCmd.SCHEMA,
     ...paymentsCmd.SCHEMA,
     ...containerCmd.SCHEMA,
+    ...gitCmd.SCHEMA,
+    ...queueCmd.SCHEMA,
+    ...taskCmd.SCHEMA,
     // Top-level flags
     version: 'boolean',
     V: 'boolean',
@@ -219,6 +225,15 @@ async function main() {
             case 'container':
                 await containerCmd.run(subcommand, restArgs, flags);
                 break;
+            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);
@@ -342,6 +357,9 @@ const HELP_TARGETS = {
     fn: f => fnCmd.run(undefined, [], f),
     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),
@@ -385,6 +403,9 @@ Commands:
   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
+  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-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-email-verify-bulk.test.d.ts

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

package/dist/sdk-email-verify-bulk.test.js

@@ -0,0 +1,57 @@
+// SDK-level unit tests for async bulk email verification —
+// email.verifyBulk + email.getVerifyJob. Mocks global fetch — no network.
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { email } from '@myapihq/sdk';
+const API_KEY = 'myapi_test_abc';
+const ORG = '11111111-1111-4111-8111-111111111111';
+let fetchMock;
+function ok(data) {
+    return new Response(JSON.stringify({ success: true, data, meta: {} }), {
+        status: 200, 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.verifyBulk', () => {
+    it('POSTs {emails} and returns the job', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ job_id: 'j1', status: 'pending', total: 2, catch_all: true }));
+        const job = await email.verifyBulk(API_KEY, ORG, ['a@x.com', 'b@y.com']);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toContain(`/email/orgs/${ORG}/verify-bulk`);
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ emails: ['a@x.com', 'b@y.com'] });
+        expect(job.job_id).toBe('j1');
+    });
+    it('passes catch_all through when set', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ job_id: 'j1', status: 'pending', total: 1 }));
+        await email.verifyBulk(API_KEY, ORG, ['a@x.com'], false);
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ emails: ['a@x.com'], catch_all: false });
+    });
+    it('surfaces TOO_MANY_EMAILS (422)', async () => {
+        fetchMock.mockResolvedValueOnce(fail('TOO_MANY_EMAILS', 422));
+        await expect(email.verifyBulk(API_KEY, ORG, ['a@x.com']))
+            .rejects.toMatchObject({ code: 'TOO_MANY_EMAILS', status: 422 });
+    });
+});
+describe('email.getVerifyJob', () => {
+    it('GETs /verify-jobs/{id} and returns status + results', async () => {
+        fetchMock.mockResolvedValueOnce(ok({
+            job_id: 'j1', status: 'done', total: 1, completed: 1,
+            results: [{ email: 'a@x.com', verdict: 'deliverable', confidence: 0.9, source: 'smtp' }],
+        }));
+        const job = await email.getVerifyJob(API_KEY, ORG, 'j1');
+        expect(job.status).toBe('done');
+        expect(job.results?.[0].verdict).toBe('deliverable');
+        expect(fetchMock.mock.calls[0][0]).toContain(`/email/orgs/${ORG}/verify-jobs/j1`);
+    });
+    it('surfaces JOB_NOT_FOUND (404)', async () => {
+        fetchMock.mockResolvedValueOnce(fail('JOB_NOT_FOUND', 404));
+        await expect(email.getVerifyJob(API_KEY, ORG, 'nope'))
+            .rejects.toMatchObject({ code: 'JOB_NOT_FOUND', status: 404 });
+    });
+});

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

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

package/dist/sdk-git.test.js

@@ -0,0 +1,115 @@
+// SDK-level unit tests for the git module. Verifies URL/body shape,
+// envelope-unwrapping, path encoding, and error handling against
+// myapi-hq/internal/routes/git/. Mocks global fetch — no network.
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { git } 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('git repos', () => {
+    it('createRepo POSTs {name, default_branch?}', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ name: 'app', default_branch: 'main' }, 201));
+        await git.createRepo(API_KEY, ORG, 'app', 'trunk');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toContain(`/git/orgs/${ORG}/repos`);
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ name: 'app', default_branch: 'trunk' });
+    });
+    it('createRepo omits default_branch when not given', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ name: 'app', default_branch: 'main' }, 201));
+        await git.createRepo(API_KEY, ORG, 'app');
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ name: 'app' });
+    });
+    it('listRepos unwraps the {repos:[...]} envelope to an array', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ repos: [{ name: 'a' }, { name: 'b' }] }));
+        expect(await git.listRepos(API_KEY, ORG)).toEqual([{ name: 'a' }, { name: 'b' }]);
+    });
+    it('getRepo GETs /repos/{repo}', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ name: 'app', default_branch: 'main', branches: 2, tags: 1 }));
+        const r = await git.getRepo(API_KEY, ORG, 'app');
+        expect(r.branches).toBe(2);
+        expect(fetchMock.mock.calls[0][0]).toContain(`/git/orgs/${ORG}/repos/app`);
+    });
+    it('deleteRepo DELETEs and surfaces 404', async () => {
+        fetchMock.mockResolvedValueOnce(new Response(null, { status: 204 }));
+        await git.deleteRepo(API_KEY, ORG, 'app');
+        expect(fetchMock.mock.calls[0][1].method).toBe('DELETE');
+        fetchMock.mockResolvedValueOnce(fail('repository not found', 404));
+        await expect(git.deleteRepo(API_KEY, ORG, 'gone')).rejects.toMatchObject({ status: 404 });
+    });
+});
+describe('git history & content', () => {
+    it('listCommits passes ref/limit as query and unwraps {commits}', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ commits: [{ sha: 'abc', message: 'init' }] }));
+        const commits = await git.listCommits(API_KEY, ORG, 'app', { ref: 'dev', limit: 10 });
+        expect(commits).toHaveLength(1);
+        const url = fetchMock.mock.calls[0][0];
+        expect(url).toMatch(/\/commits\?/);
+        expect(url).toContain('ref=dev');
+        expect(url).toContain('limit=10');
+    });
+    it('getDiff requires base+head and unwraps {diff}', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ diff: '--- a\n+++ b\n' }));
+        const d = await git.getDiff(API_KEY, ORG, 'app', 'main', 'dev');
+        expect(d).toBe('--- a\n+++ b\n');
+        const url = fetchMock.mock.calls[0][0];
+        expect(url).toContain('base=main');
+        expect(url).toContain('head=dev');
+    });
+    it('listTree unwraps {entries} and adds ?path when scoped', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ entries: [{ name: 'a.js', type: 'file' }] }));
+        await git.listTree(API_KEY, ORG, 'app', 'main', 'src');
+        expect(fetchMock.mock.calls[0][0]).toMatch(/\/tree\/main\?path=src$/);
+    });
+    it('readBlob encodes path segments but keeps the slashes', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ path: 'src/a b.js', size: 3, content_base64: 'eA==' }));
+        await git.readBlob(API_KEY, ORG, 'app', 'main', 'src/a b.js');
+        // slashes survive (catch-all route), spaces within a segment are encoded
+        expect(fetchMock.mock.calls[0][0]).toMatch(/\/blob\/main\/src\/a%20b\.js$/);
+    });
+});
+describe('git writes', () => {
+    it('commit POSTs the full payload', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ sha: 'def', tree: 't', branch: 'main' }, 201));
+        const res = await git.commit(API_KEY, ORG, 'app', {
+            branch: 'main', message: 'add', changes: [{ path: 'x', content: 'hi' }],
+        });
+        expect(res.sha).toBe('def');
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body).changes).toHaveLength(1);
+    });
+    it('createBranch POSTs {name, from}', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ name: 'feature' }, 201));
+        await git.createBranch(API_KEY, ORG, 'app', 'feature', 'main');
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ name: 'feature', from: 'main' });
+    });
+    it('merge POSTs {target, source} and surfaces NOT_FAST_FORWARD (422)', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ sha: 'ff' }));
+        expect((await git.merge(API_KEY, ORG, 'app', 'main', 'dev')).sha).toBe('ff');
+        fetchMock.mockResolvedValueOnce(fail('NOT_FAST_FORWARD', 422));
+        await expect(git.merge(API_KEY, ORG, 'app', 'main', 'dev')).rejects.toMatchObject({ status: 422 });
+    });
+    it('repack POSTs and returns the pack counts', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ packs_before: 5, packs_after: 1, objects: 200 }));
+        const r = await git.repack(API_KEY, ORG, 'app');
+        expect(r).toEqual({ packs_before: 5, packs_after: 1, objects: 200 });
+    });
+});
+describe('git.EXPOSES', () => {
+    it('covers all 16 git endpoints', () => {
+        expect(git.EXPOSES).toHaveLength(16);
+        expect(git.EXPOSES).toContain('POST /git/orgs/{org_id}/repos/{repo}/commits');
+        expect(git.EXPOSES).toContain('GET /git/orgs/{org_id}/repos/{repo}/blob/{ref}/{path}');
+    });
+});

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 {};

package/dist/sdk-task.test.js

@@ -0,0 +1,110 @@
+// SDK-level unit tests for the task module. Verifies URL/body shape,
+// envelope-unwrapping, the list meta {shown,total_open}, the separate body
+// tier, and lease modeling against myapi-hq/internal/routes/task/.
+// Mocks global fetch — no network.
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { task } 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('task create / list', () => {
+    it('createTask POSTs {description} plus only the set optional fields', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ id: 't1', description: 'do x', status: 'open' }, 201));
+        await task.createTask(API_KEY, ORG, {
+            description: 'do x', importance: 'high', dependsOn: ['t0'],
+            resolveOn: { event_type: 'payment.succeeded', field: 'id', value: '42' },
+        });
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toContain(`/task/orgs/${ORG}/tasks`);
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({
+            description: 'do x', importance: 'high', depends_on: ['t0'],
+            resolve_on: { event_type: 'payment.succeeded', field: 'id', value: '42' },
+        });
+    });
+    it('listTasks reads tasks + data.meta {shown, total_open}', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ tasks: [{ id: 't1', description: 'a', score: 9 }], meta: { shown: 1, total_open: 12 } }));
+        const res = await task.listTasks(API_KEY, ORG);
+        expect(res.tasks).toHaveLength(1);
+        expect(res.meta).toEqual({ shown: 1, total_open: 12 });
+    });
+    it('listTasks passes filter options as query params', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ tasks: [], meta: { shown: 0, total_open: 0 } }));
+        await task.listTasks(API_KEY, ORG, { status: 'open', limit: 5 });
+        const url = fetchMock.mock.calls[0][0];
+        expect(url).toContain('status=open');
+        expect(url).toContain('limit=5');
+    });
+});
+describe('task get / body tier', () => {
+    it('getTask GETs /tasks/{id} and does NOT touch the body endpoint', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ id: 't1', description: 'a', status: 'open' }));
+        await task.getTask(API_KEY, ORG, 't1');
+        const url = fetchMock.mock.calls[0][0];
+        expect(url).toContain(`/task/orgs/${ORG}/tasks/t1`);
+        expect(url).not.toMatch(/\/body$/);
+    });
+    it('getTaskBody fetches the /body tier and unwraps {task_id, body}', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ task_id: 't1', body: '# context' }));
+        expect(await task.getTaskBody(API_KEY, ORG, 't1')).toBe('# context');
+        expect(fetchMock.mock.calls[0][0]).toMatch(/\/tasks\/t1\/body$/);
+    });
+});
+describe('task lifecycle', () => {
+    it('claimTask POSTs {lease_seconds, worker} and returns the full task', async () => {
+        fetchMock.mockResolvedValueOnce(ok({
+            id: 't1', description: 'a', status: 'claimed',
+            lease_expires_at: '2026-05-19T10:10:00Z', claimed_by: 'agent-7',
+        }));
+        const t = await task.claimTask(API_KEY, ORG, 't1', { leaseSeconds: 600, worker: 'agent-7' });
+        expect(t.status).toBe('claimed');
+        expect(t.lease_expires_at).toBe('2026-05-19T10:10:00Z');
+        expect(t.claimed_by).toBe('agent-7');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toMatch(/\/tasks\/t1\/claim$/);
+        expect(JSON.parse(init.body)).toEqual({ lease_seconds: 600, worker: 'agent-7' });
+    });
+    it('extendTask POSTs to /extend', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ id: 't1', description: 'a', status: 'claimed' }));
+        await task.extendTask(API_KEY, ORG, 't1', { leaseSeconds: 300 });
+        expect(fetchMock.mock.calls[0][0]).toMatch(/\/tasks\/t1\/extend$/);
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ lease_seconds: 300 });
+    });
+    it('resolveTask POSTs to /resolve', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ id: 't1', description: 'a', status: 'resolved' }));
+        await task.resolveTask(API_KEY, ORG, 't1');
+        expect(fetchMock.mock.calls[0][0]).toMatch(/\/tasks\/t1\/resolve$/);
+    });
+    it('failTask POSTs {reason} to /fail', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ id: 't1', description: 'a', status: 'failed' }));
+        await task.failTask(API_KEY, ORG, 't1', 'blocked on legal');
+        expect(fetchMock.mock.calls[0][0]).toMatch(/\/tasks\/t1\/fail$/);
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ reason: 'blocked on legal' });
+    });
+    it('cancelTask DELETEs the task and surfaces 404', async () => {
+        fetchMock.mockResolvedValueOnce(new Response(null, { status: 204 }));
+        await task.cancelTask(API_KEY, ORG, 't1');
+        expect(fetchMock.mock.calls[0][1].method).toBe('DELETE');
+        fetchMock.mockResolvedValueOnce(fail('task not found', 404));
+        await expect(task.cancelTask(API_KEY, ORG, 'gone')).rejects.toMatchObject({ status: 404 });
+    });
+});
+describe('task.EXPOSES', () => {
+    it('covers all 9 task endpoints', () => {
+        expect(task.EXPOSES).toHaveLength(9);
+        expect(task.EXPOSES).toContain('GET /task/orgs/{org_id}/tasks/{id}/body');
+        expect(task.EXPOSES).toContain('POST /task/orgs/{org_id}/tasks/{id}/claim');
+    });
+});

package/dist/skills/my-email-api/README.md

@@ -0,0 +1,45 @@
+---
+# my-email-api
+
+Send transactional email and run drip campaigns from mailboxes on your own registered domains. Includes AI template generation, warmup, and inbox/outbox reading.
+
+## What it does
+
+- Create mailboxes on your registered domains
+- Send transactional emails (one-shot or templated)
+- Read inbox, outbox, sent history, and per-message status
+- Generate HTML email templates with AI from a prompt
+- Run paced drip campaigns against uploaded contact lists
+- Manage IP/domain warmup for sender reputation
+
+## Quickstart
+
+```bash
+# Create a mailbox + activate sending
+myapi email mailbox create hello@yourdomain.com
+myapi email mailbox activate-sending --address hello@yourdomain.com
+
+# Send
+myapi email message send \
+  --from hello@yourdomain.com \
+  --to recipient@example.com \
+  --subject "Hi" \
+  --body "Test"
+```
+
+## Authentication
+
+```bash
+export MYAPI_KEY=mak_...
+```
+
+Requires:
+- An `api_key` from **myapihq**
+- A registered domain via **mydomainapi**, assigned to your org
+- Default `org_id` (for templates/campaigns) — set with `myapi auth config set-org <id>`
+
+## Documentation
+
+Full command reference and flow diagrams: see `SKILL.md`.
+
+Run `myapi email --help` for inline reference.