@myapihq/cli 1.2.9 → 1.3.1

package/dist/commands/container.d.ts

@@ -13,4 +13,5 @@ export declare function get(id: string, flags: Flags): Promise<void>;
 export declare function del(id: string, flags: Flags): Promise<void>;
 export declare function deploy(id: string, image: string, flags: Flags): Promise<void>;
 export declare function logs(id: string, flags: Flags): Promise<void>;
+export declare function domain(id: string, domainArg: string | undefined, flags: Flags): Promise<void>;
 export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/container.js

@@ -10,6 +10,8 @@ export const 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',
 ];
 export const SCHEMA = {
     name: 'string',
@@ -22,6 +24,7 @@ export const SCHEMA = {
     port: 'number',
     env: 'string',
     tail: 'number',
+    remove: 'boolean',
 };
 const CONTAINER_TYPES = ['service', 'worker', 'job'];
 // Mirrors validateName in myapi-hq/internal/routes/container/crud.go —
@@ -146,6 +149,8 @@ export async function get(id, flags) {
     if (c.port)
         info(`Port:            ${c.port}`);
     info(`URL:             ${c.url || '(not deployed)'}`);
+    if (c.custom_domain)
+        info(`Custom domain:   ${c.custom_domain}`);
     info(`Created:         ${c.created_at}`);
     info(`Updated:         ${c.updated_at}`);
 }
@@ -198,6 +203,31 @@ export async function logs(id, flags) {
         info(`${e.timestamp}  ${(e.severity || '').padEnd(8)} ${e.text}`);
     }
 }
+// domain binds (or, with --remove, unbinds) a custom domain on a deployed
+// container. The parent domain must be MyAPI-managed.
+export async function domain(id, domainArg, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi container domain <id> <domain> [--org <id>]');
+    if (!id)
+        error('Missing id.\nUsage: myapi container domain <id> <domain>   (or --remove to unbind)');
+    if (flags.remove) {
+        await sdkContainer.unbindDomain(config.api_key, orgId, id);
+        success(`Removed custom domain from container ${id}`);
+        return;
+    }
+    if (!domainArg) {
+        error('Missing <domain>.\nUsage: myapi container domain <id> <domain>\n   or: myapi container domain <id> --remove');
+    }
+    const binding = await sdkContainer.bindDomain(config.api_key, orgId, id, domainArg);
+    if (flags.json) {
+        printJson(binding);
+        return;
+    }
+    success(`Custom domain bound: ${binding.custom_domain}`);
+    info(`Container:  ${binding.container_id}`);
+    info(`Origin:     ${binding.origin}`);
+    info(`Status:     ${binding.status}`);
+}
 // ── Dispatcher ───────────────────────────────────────────────────────────────
 const SUBCOMMAND_USAGE = {
     'create': `myapi container create --name <name> [--type service|worker|job] [--cron <expr>]
@@ -229,6 +259,15 @@ Example:
 
 Recent Cloud Run runtime logs, newest first. --tail caps the count
 (default 100, max 1000).`,
+    'domain': `myapi container domain <id> <domain> [--org <id>] [--json]
+       myapi container domain <id> --remove [--org <id>]
+
+Binds a custom domain to a deployed container, served over HTTPS via
+Cloudflare. The domain's MyAPI-managed parent domain must already be
+registered. --remove unbinds it.
+
+Example:
+  myapi container domain <id> app.synthesisdaily.com`,
     'delete': 'myapi container delete <id> [--org <id>]',
 };
 export async function run(subcommand, args, flags) {
@@ -245,6 +284,7 @@ Subcommands:
   list                 List containers in your org
   get <id>             Inspect a container
   logs <id>            Show recent runtime logs (--tail <n>)
+  domain <id> <domain> Bind a custom domain (--remove to unbind)
   delete <id>          Soft-delete and revoke its scoped API key
 
 All commands accept --org <id> (or set default: myapi config set-org <id>).`);
@@ -264,6 +304,7 @@ All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         case 'list': return list(flags);
         case 'get': return get(args[0], flags);
         case 'logs': return logs(args[0], flags);
+        case 'domain': return domain(args[0], args[1], flags);
         case 'delete': return del(args[0], flags);
         default: error(`Unknown subcommand: ${subcommand}. Run "myapi container --help" for a list of valid subcommands.`);
     }

package/dist/commands/email/mailbox.js

@@ -4,6 +4,8 @@ import { success, error, printTable, info } from '../../output.js';
 export const EXPOSES = [
     'POST /email/mailboxes/create',
     'GET /email/mailboxes',
+    'PUT /email/mailboxes/{address}/forwarding',
+    'DELETE /email/mailboxes/{address}/forwarding',
     'POST /email/sending/activate',
 ];
 async function create(addressArg, flags) {
@@ -52,6 +54,22 @@ async function activateSending(flags) {
     const res = await sdkEmail.activateSending(config.api_key, address);
     success(`Sending activated: ${address} (${res.emails_quota_remaining} emails/day quota)`);
 }
+async function setForwarding(address, forwardTo, _flags) {
+    const config = requireConfig();
+    if (!address || !forwardTo) {
+        error('Missing required arguments.\nUsage: myapi email mailbox set-forwarding <user@domain> <forward-to@domain>');
+    }
+    const res = await sdkEmail.setForwarding(config.api_key, address, forwardTo);
+    success(`Forwarding set: ${res.address} → ${res.forward_to}`);
+    info('A copy of every incoming message is redirected; the original is kept in the mailbox.');
+}
+async function clearForwarding(address, _flags) {
+    const config = requireConfig();
+    if (!address)
+        error('Missing required arguments.\nUsage: myapi email mailbox clear-forwarding <user@domain>');
+    await sdkEmail.deleteForwarding(config.api_key, address);
+    success(`Forwarding cleared for ${address}`);
+}
 const USAGE = {
     'create': `myapi email mailbox create <user@domain> [--display-name <name>]
        myapi email mailbox create --username <u> --domain <d> [--display-name <name>]
@@ -65,6 +83,11 @@ matches the rest of the CLI ("first required arg is positional").`,
                         org (orphaned mailboxes — domain was unassigned
                         without first deleting them).`,
     'activate-sending': 'myapi email mailbox activate-sending --address <email>',
+    'set-forwarding': `myapi email mailbox set-forwarding <user@domain> <forward-to@domain>
+
+Redirects a copy of every incoming message to an external address
+(server-side). The original is kept in the mailbox.`,
+    'clear-forwarding': 'myapi email mailbox clear-forwarding <user@domain>',
 };
 export async function run(sub, args, flags) {
     if (!sub || (flags.help && !sub)) {
@@ -73,7 +96,9 @@ export async function run(sub, args, flags) {
 Subcommands:
   create             Create a mailbox (positional <user@domain> or --username/--domain)
   list               List mailboxes on a domain (--domain) or orphaned ones (--filter unassigned)
-  activate-sending   Activate outbound sending for a mailbox`);
+  activate-sending   Activate outbound sending for a mailbox
+  set-forwarding     Forward a copy of incoming mail to an external address
+  clear-forwarding   Stop forwarding for a mailbox`);
         return;
     }
     if (flags.help) {
@@ -88,6 +113,8 @@ Subcommands:
         case 'create': return create(args[0], flags);
         case 'list': return list(flags);
         case 'activate-sending': return activateSending(flags);
+        case 'set-forwarding': return setForwarding(args[0], args[1], flags);
+        case 'clear-forwarding': return clearForwarding(args[0], flags);
         default: error(`Unknown subcommand: ${sub}. Run "myapi email mailbox --help" for the list.`);
     }
 }

package/dist/commands/queue-validation.test.d.ts

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

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

@@ -0,0 +1,38 @@
+// Unit tests for the queue CLI's pure validators.
+import { describe, it, expect } from 'vitest';
+import { _validateConsumerUrl, _parseDependsOn } from './queue.js';
+describe('_validateConsumerUrl', () => {
+    it.each([
+        'https://example.com/consume',
+        'http://example.com/consume',
+        'https://fn.myapi.com/org/fn_123',
+        'https://example.com:8443/path?q=v',
+    ])('accepts %s', (url) => {
+        expect(_validateConsumerUrl(url)).toBeNull();
+    });
+    it.each([
+        ['ftp://example.com', /http:\/\/ or https:\/\//],
+        ['javascript:alert(1)', /http:\/\/ or https:\/\//],
+        ['file:///etc/passwd', /http:\/\/ or https:\/\//],
+    ])('rejects non-http(s) %s', (url, re) => {
+        expect(_validateConsumerUrl(url)).toMatch(re);
+    });
+    it.each(['not a url', 'just-text', 'http//missing-colon'])('rejects malformed %s', (url) => {
+        expect(_validateConsumerUrl(url)).toMatch(/not a valid URL/);
+    });
+});
+describe('_parseDependsOn', () => {
+    it('returns undefined for empty / non-string input', () => {
+        expect(_parseDependsOn(undefined)).toBeUndefined();
+        expect(_parseDependsOn('')).toBeUndefined();
+        expect(_parseDependsOn('   ')).toBeUndefined();
+        expect(_parseDependsOn(true)).toBeUndefined();
+    });
+    it('splits a comma-separated list and trims', () => {
+        expect(_parseDependsOn('j1,j2,j3')).toEqual(['j1', 'j2', 'j3']);
+        expect(_parseDependsOn(' j1 , j2 ')).toEqual(['j1', 'j2']);
+    });
+    it('drops empty segments', () => {
+        expect(_parseDependsOn('j1,,j2,')).toEqual(['j1', 'j2']);
+    });
+});

package/dist/commands/queue.d.ts

@@ -0,0 +1,14 @@
+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 _validateConsumerUrl(url: string): string | null;
+export declare function _parseDependsOn(raw: unknown): string[] | undefined;
+export declare function create(name: string, flags: Flags): Promise<void>;
+export declare function list(flags: Flags): Promise<void>;
+export declare function get(name: string, flags: Flags): Promise<void>;
+export declare function enqueue(name: string, flags: Flags): Promise<void>;
+export declare function jobs(name: string, flags: Flags): Promise<void>;
+export declare function job(jobId: string, flags: Flags): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/queue.js

@@ -0,0 +1,215 @@
+import { queue as sdkQueue } 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';
+export const EXPOSES = [
+    'POST /queue/orgs/{org_id}/queues',
+    'GET /queue/orgs/{org_id}/queues',
+    'GET /queue/orgs/{org_id}/queues/{name}',
+    'POST /queue/orgs/{org_id}/queues/{name}/jobs',
+    'GET /queue/orgs/{org_id}/queues/{name}/jobs',
+    'GET /queue/orgs/{org_id}/jobs/{id}',
+];
+export const SCHEMA = {
+    name: 'string',
+    'consumer-url': 'string',
+    'max-attempts': 'number',
+    'max-concurrency': 'number',
+    payload: 'string',
+    'dedup-key': 'string',
+    delay: 'number',
+    'depends-on': 'string',
+    status: 'string',
+    limit: 'number',
+};
+// Pure validator — returns an error message or null. Mirrors
+// webhook.ts's _validateForwardUrl so it's unit-testable.
+export function _validateConsumerUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return `consumer URL "${url}" is not a valid URL.`;
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        return `consumer URL must use http:// or https:// — got "${url}".`;
+    }
+    return null;
+}
+// Parses a comma-separated --depends-on flag into a clean id array.
+export function _parseDependsOn(raw) {
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return undefined;
+    return raw.split(',').map(s => s.trim()).filter(Boolean);
+}
+// ── Queues ───────────────────────────────────────────────────────────────────
+export async function create(name, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi queue create <name> --consumer-url <url> [--org <id>]');
+    const queueName = name || flags.name;
+    requireArg(queueName, 'name', 'myapi queue create <name> --consumer-url <url>');
+    const consumerUrl = flags['consumer-url'];
+    if (typeof consumerUrl !== 'string' || consumerUrl === '') {
+        error('Missing --consumer-url.\nUsage: myapi queue create <name> --consumer-url <url> [--max-attempts <n>] [--max-concurrency <n>]');
+    }
+    const urlErr = _validateConsumerUrl(consumerUrl);
+    if (urlErr)
+        error(urlErr);
+    const q = await sdkQueue.createQueue(config.api_key, orgId, {
+        name: queueName,
+        consumerUrl,
+        maxAttempts: typeof flags['max-attempts'] === 'number' ? flags['max-attempts'] : undefined,
+        maxConcurrency: typeof flags['max-concurrency'] === 'number' ? flags['max-concurrency'] : undefined,
+    });
+    if (flags.json) {
+        printJson(q);
+        return;
+    }
+    success(`Queue created: ${q.name}`);
+    info(`Consumer:        ${q.consumer_url}`);
+    info(`Max attempts:    ${q.max_attempts}`);
+    info(`Max concurrency: ${q.max_concurrency}`);
+}
+export async function list(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi queue list [--org <id>]');
+    const queues = await sdkQueue.listQueues(config.api_key, orgId);
+    if (flags.json) {
+        printJson(queues);
+        return;
+    }
+    printTable(queues.map(q => ({ name: q.name })), {
+        flags,
+        empty: 'No queues yet. Create one with: myapi queue create <name> --consumer-url <url>',
+    });
+}
+export async function get(name, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi queue get <name> [--org <id>]');
+    requireArg(name, 'name', 'myapi queue get <name>');
+    const q = await sdkQueue.getQueue(config.api_key, orgId, name);
+    if (flags.json) {
+        printJson(q);
+        return;
+    }
+    info(`Name:            ${q.name}`);
+    info(`Consumer:        ${q.consumer_url}`);
+    info(`Max attempts:    ${q.max_attempts}`);
+    info(`Max concurrency: ${q.max_concurrency}`);
+}
+// ── Jobs ─────────────────────────────────────────────────────────────────────
+export async function enqueue(name, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi queue enqueue <name> --payload <json> [--org <id>]');
+    requireArg(name, 'name', 'myapi queue enqueue <name> --payload <json>');
+    let payload;
+    if (typeof flags.payload === 'string') {
+        try {
+            payload = JSON.parse(flags.payload);
+        }
+        catch (e) {
+            error(`--payload is not valid JSON: ${e?.message ?? e}`);
+        }
+    }
+    else if (flags.payload === true) {
+        error('--payload needs a JSON value, e.g. --payload \'{"order_id":42}\'');
+    }
+    const job = await sdkQueue.enqueueJob(config.api_key, orgId, name, {
+        payload,
+        dedupKey: typeof flags['dedup-key'] === 'string' ? flags['dedup-key'] : undefined,
+        delaySeconds: typeof flags.delay === 'number' ? flags.delay : undefined,
+        dependsOn: _parseDependsOn(flags['depends-on']),
+    });
+    if (flags.json) {
+        printJson(job);
+        return;
+    }
+    success(`Job enqueued: ${job.id}`);
+    info(`Status: ${job.status}`);
+}
+export async function jobs(name, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi queue jobs <name> [--status <s>] [--limit <n>] [--org <id>]');
+    requireArg(name, 'name', 'myapi queue jobs <name>');
+    const list = await sdkQueue.listJobs(config.api_key, orgId, name, {
+        status: typeof flags.status === 'string' ? flags.status : undefined,
+        limit: typeof flags.limit === 'number' ? flags.limit : undefined,
+    });
+    if (flags.json) {
+        printJson(list);
+        return;
+    }
+    printTable(list.map(j => ({
+        id: j.id,
+        status: j.status,
+        attempt: j.attempt,
+        created: j.created_at ? formatDate(j.created_at) : '',
+    })), { flags, empty: 'No jobs in this queue.' });
+}
+export async function job(jobId, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi queue job <job_id> [--org <id>]');
+    requireArg(jobId, 'job_id', 'myapi queue job <job_id>');
+    const j = await sdkQueue.getJob(config.api_key, orgId, jobId);
+    if (flags.json) {
+        printJson(j);
+        return;
+    }
+    info(`Job:      ${j.id}`);
+    info(`Queue:    ${j.queue_id}`);
+    info(`Status:   ${j.status}`);
+    info(`Attempt:  ${j.attempt} / ${j.max_attempts}`);
+    if (j.last_error)
+        info(`Error:    ${j.last_error}`);
+}
+// ── Dispatcher ───────────────────────────────────────────────────────────────
+const SUBCOMMAND_USAGE = {
+    'create': 'myapi queue create <name> --consumer-url <url> [--max-attempts <n>] [--max-concurrency <n>] [--org <id>]',
+    'list': 'myapi queue list [--org <id>] [--json]',
+    'get': 'myapi queue get <name> [--org <id>] [--json]',
+    'enqueue': 'myapi queue enqueue <name> --payload <json> [--dedup-key <k>] [--delay <seconds>] [--depends-on <id,id>] [--org <id>]',
+    'jobs': 'myapi queue jobs <name> [--status <s>] [--limit <n>] [--org <id>] [--json]',
+    'job': 'myapi queue job <job_id> [--org <id>] [--json]',
+};
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi queue <subcommand>
+
+A durable HTTP-consumer job queue — jobs are POSTed to the queue's
+consumer_url with retry/backoff, a concurrency cap, and a dependency DAG.
+
+Queues:
+  create <name>     Create a queue (--consumer-url, --max-attempts, --max-concurrency)
+  list              List queues
+  get <name>        Show a queue's policy
+
+Jobs:
+  enqueue <name>    Enqueue a job (--payload, --dedup-key, --delay, --depends-on)
+  jobs <name>       List a queue's jobs (--status, --limit)
+  job <job_id>      Show a single job's status
+
+For "needs a decision" work (agent/human), see: myapi task --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 queue --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 'enqueue': return enqueue(args[0], flags);
+        case 'jobs': return jobs(args[0], flags);
+        case 'job': return job(args[0], flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi queue --help" for a list of valid subcommands.`);
+    }
+}

package/dist/commands/task-validation.test.d.ts

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

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

@@ -0,0 +1,37 @@
+// Unit tests for the task CLI's pure parsers.
+import { describe, it, expect } from 'vitest';
+import { _parseResolveOn, _splitList } from './task.js';
+describe('_parseResolveOn', () => {
+    it('parses a bare event type', () => {
+        expect(_parseResolveOn('payment.succeeded')).toEqual({ event_type: 'payment.succeeded' });
+    });
+    it('parses event_type:field=value', () => {
+        expect(_parseResolveOn('payment.succeeded:order_id=o_42')).toEqual({
+            event_type: 'payment.succeeded', field: 'order_id', value: 'o_42',
+        });
+    });
+    it('keeps = signs inside the value', () => {
+        expect(_parseResolveOn('evt:token=a=b=c')).toEqual({
+            event_type: 'evt', field: 'token', value: 'a=b=c',
+        });
+    });
+    it('rejects an empty string', () => {
+        expect(_parseResolveOn('   ')).toMatch(/cannot be empty/);
+    });
+    it('rejects a leading colon (no event type)', () => {
+        expect(_parseResolveOn(':field=value')).toMatch(/must start with an event type/);
+    });
+    it('rejects a field match without =', () => {
+        expect(_parseResolveOn('evt:justfield')).toMatch(/field=value/);
+    });
+});
+describe('_splitList', () => {
+    it('returns undefined for empty / non-string input', () => {
+        expect(_splitList(undefined)).toBeUndefined();
+        expect(_splitList('')).toBeUndefined();
+        expect(_splitList(true)).toBeUndefined();
+    });
+    it('splits and trims, dropping empties', () => {
+        expect(_splitList('support, sales ,, billing')).toEqual(['support', 'sales', 'billing']);
+    });
+});

package/dist/commands/task.d.ts

@@ -0,0 +1,18 @@
+import { task as sdkTask } from '@myapihq/sdk';
+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 const TASK_IMPORTANCE: readonly ["low", "normal", "high", "critical"];
+export declare function _parseResolveOn(raw: string): sdkTask.ResolveOn | string;
+export declare function _splitList(raw: unknown): string[] | undefined;
+export declare function create(description: string, flags: Flags): Promise<void>;
+export declare function list(flags: Flags): Promise<void>;
+export declare function get(id: string, flags: Flags): Promise<void>;
+export declare function claim(id: string, flags: Flags): Promise<void>;
+export declare function extend(id: string, flags: Flags): Promise<void>;
+export declare function resolve(id: string, flags: Flags): Promise<void>;
+export declare function fail(id: string, flags: Flags): Promise<void>;
+export declare function cancel(id: string, flags: Flags): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;