@myapihq/cli 1.0.84 → 1.1.0-wip.0

package/dist/index.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
-// manually maintained — do not regenerate from scripts/generate-indexes.js
-import { parseArgs } from './utils.js';
 import { error, info, success } from './output.js';
 import { loadConfig } from './config.js';
 import { MyApiError } from '@myapihq/sdk';
 import * as fs from 'fs';
+import { parseFlags } from './flags.js';
 const pkgPath = new URL('../package.json', import.meta.url);
 const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
 import * as keysCmd from './commands/keys.js';
@@ -14,8 +13,29 @@ import * as setupCmd from './commands/setup.js';
 import * as updateCmd from './commands/update.js';
 import * as domainCmd from './commands/domain.js';
 import * as funnelCmd from './commands/funnel.js';
+import * as webhookCmd from './commands/webhook.js';
+import * as workflowCmd from './commands/workflow.js';
+import * as emailCmd from './commands/email.js';
 import * as authCmd from './commands/auth.js';
 import * as configCmd from './commands/config.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.
+const COMBINED_SCHEMA = {
+    ...authCmd.SCHEMA,
+    ...billingCmd.SCHEMA,
+    ...configCmd.SCHEMA,
+    ...domainCmd.SCHEMA,
+    ...emailCmd.SCHEMA,
+    ...funnelCmd.SCHEMA,
+    ...keysCmd.SCHEMA,
+    ...orgCmd.SCHEMA,
+    ...webhookCmd.SCHEMA,
+    ...workflowCmd.SCHEMA,
+    // Top-level flags
+    version: 'boolean',
+    V: 'boolean',
+};
 const ERROR_MESSAGES = {
     DOMAIN_NOT_FOUND: 'Domain not found.',
     INVALID_DOMAIN: 'Invalid domain name.',
@@ -43,7 +63,7 @@ function friendlyError(code) {
     return ERROR_MESSAGES[code] || code;
 }
 async function main() {
-    const { args, flags } = parseArgs(process.argv.slice(2));
+    const { args, flags } = parseFlags(process.argv.slice(2), COMBINED_SCHEMA);
     if (flags.version || flags.v || flags.V) {
         const latest = await updateCmd.latestVersion();
         const updateNote = latest && updateCmd.isNewer(latest, pkg.version)
@@ -71,89 +91,16 @@ async function main() {
     try {
         switch (command) {
             case 'auth':
-                if (!subcommand || (flags.help && !subcommand)) {
-                    info('Usage: myapi auth <subcommand>\n\nSubcommands:\n  setup           Configure your account\n  import-key      Import an existing API key non-interactively\n  whoami          Show current account · supports --json\n  link [email]    Upgrade anonymous account to registered (or add a second session)\n                  Use myapi auth setup to create a completely new account\n  switch [index]  Switch active account by index or email\n  config          Manage CLI defaults (org, funnel, domain) · supports set-org / set-funnel / set-domain\n  install-skills  Install or update the MyAPI skills pack for AI agents\n  api-keys        Manage API keys · list / create / revoke\n  keys            Alias for api-keys');
-                    break;
-                }
-                if (subcommand === 'setup')
-                    await setupCmd.setup(flags);
-                else if (subcommand === 'import-key')
-                    await setupCmd.importKey(restArgs[0], flags);
-                else if (subcommand === 'whoami')
-                    await authCmd.whoami(flags);
-                else if (subcommand === 'link')
-                    await authCmd.link(flags, restArgs[0]);
-                else if (subcommand === 'switch')
-                    await authCmd.switchCmd(flags, restArgs[0]);
-                else if (subcommand === 'install-skills') {
-                    if (flags.help) {
-                        info('Usage: myapi auth install-skills\n\nInstalls the MyAPI skills pack for AI coding agents (Claude, Gemini, Cursor).\n\nThis command writes skill definition files to:\n  ~/.agents/skills/myapi/\n\nAnd creates symlinks in the appropriate agent config directories:\n  ~/.claude/  (Claude)\n  ~/.gemini/  (Gemini)\n  ~/.cursor/  (Cursor, if detected)\n\nThese files teach agents how to use the MyAPI CLI and API directly.\nRun this command again to update existing skills to the latest version.');
-                        break;
-                    }
-                    await setupCmd.installSkills();
-                    success('› Skills installed.');
-                }
-                else if (subcommand === 'config')
-                    await configCmd.run(restArgs[0], restArgs.slice(1), flags);
-                else if (subcommand === 'api-keys') {
-                    if (flags.help && !restArgs[0]) {
-                        info('Usage: myapi auth api-keys <subcommand>\n\nManage programmatic API keys for your account. API keys are used to authenticate\nrequests to the MyAPI SDK and REST API.\n\nSubcommands:\n  list             List all API keys with their IDs and creation dates\n  create           Create a new API key (the key value is shown once)\n  revoke <id>      Permanently revoke an API key by ID\n\nExamples:\n  myapi auth api-keys list\n  myapi auth api-keys create\n  myapi auth api-keys revoke hq_live_xxxxxxxxxxxxxxxxxxxx');
-                        break;
-                    }
-                    if (!restArgs[0]) {
-                        info('Run: myapi auth api-keys --help');
-                        break;
-                    }
-                    if (restArgs[0] === 'create')
-                        await keysCmd.createNew(flags);
-                    else if (restArgs[0] === 'list')
-                        await keysCmd.list(flags);
-                    else if (restArgs[0] === 'revoke')
-                        await keysCmd.revoke(restArgs[1], flags);
-                }
-                else
-                    info('Unknown subcommand. Run: myapi auth --help');
+                await dispatchAuth(subcommand, restArgs, flags);
                 break;
             case 'update':
                 await updateCmd.update(flags);
                 break;
             case 'org':
-                if (!subcommand || (flags.help && !subcommand)) {
-                    info('Usage: myapi org <subcommand>\n\nSubcommands:\n  list        List organizations\n  create      Create an organization · myapi org create "Name" --yes\n  get         Get details of an organization\n  delete      Delete an organization\n  sync-brand  Sync brand info (name, logo, description) from an existing website into an org');
-                    break;
-                }
-                if (subcommand === 'list')
-                    await orgCmd.list(flags);
-                else if (subcommand === 'create')
-                    await orgCmd.create(restArgs, flags);
-                else if (subcommand === 'get')
-                    await orgCmd.get(restArgs[0], flags);
-                else if (subcommand === 'delete')
-                    await orgCmd.del(restArgs[0], flags);
-                else if (subcommand === 'sync-brand')
-                    await orgCmd.importOrg(restArgs, flags);
-                else if (subcommand === 'import') {
-                    process.stderr.write('› Note: "org import" is deprecated — use "org sync-brand" instead.\n');
-                    await orgCmd.importOrg(restArgs, flags);
-                }
-                else
-                    printHelp();
+                await orgCmd.run(subcommand, restArgs, flags);
                 break;
             case 'billing':
-                if (!subcommand || (flags.help && !subcommand)) {
-                    info('Usage: myapi billing <subcommand>\n\nSubcommands:\n  balance    Check balance\n  history    View billing history\n  topup      Top up your balance\n  setup      Setup a payment method');
-                    break;
-                }
-                if (subcommand === 'balance')
-                    await billingCmd.balance(flags);
-                else if (subcommand === 'history')
-                    await billingCmd.history(flags);
-                else if (subcommand === 'topup')
-                    await billingCmd.topup(restArgs[0], flags);
-                else if (subcommand === 'setup')
-                    await billingCmd.setup(flags);
-                else
-                    printHelp();
+                await billingCmd.run(subcommand, restArgs, flags);
                 break;
             case 'domain':
                 await domainCmd.run(subcommand, restArgs, flags);
@@ -161,6 +108,15 @@ async function main() {
             case 'funnel':
                 await funnelCmd.run(subcommand, restArgs, flags);
                 break;
+            case 'webhook':
+                await webhookCmd.run(subcommand, restArgs, flags);
+                break;
+            case 'workflow':
+                await workflowCmd.run(subcommand, restArgs, flags);
+                break;
+            case 'email':
+                await emailCmd.run(subcommand, restArgs, flags);
+                break;
             // Convenience aliases
             case 'setup':
                 await setupCmd.setup(flags);
@@ -169,45 +125,21 @@ async function main() {
                 await authCmd.whoami(flags);
                 break;
             case 'keys':
-                if (!subcommand || (flags.help && !subcommand)) {
-                    info('Usage: myapi keys <subcommand>\n\nManage programmatic API keys for your account. API keys are used to authenticate\nrequests to the MyAPI SDK and REST API.\n\nSubcommands:\n  list             List all API keys with their IDs and creation dates\n  create           Create a new API key (the key value is shown once)\n  revoke <id>      Permanently revoke an API key by ID\n\nExamples:\n  myapi keys list\n  myapi keys create\n  myapi keys revoke hq_live_xxxxxxxxxxxxxxxxxxxx\n\nAlias for: myapi auth api-keys');
-                    break;
-                }
-                if (subcommand === 'create')
-                    await keysCmd.createNew(flags);
-                else if (subcommand === 'list')
-                    await keysCmd.list(flags);
-                else if (subcommand === 'revoke')
-                    await keysCmd.revoke(restArgs[0], flags);
+                await keysCmd.run(subcommand, restArgs, flags);
                 break;
             case 'config':
                 await configCmd.run(subcommand, restArgs, { ...flags, _via: 'config' });
                 break;
             case 'install-skills':
                 if (flags.help) {
-                    info('Usage: myapi install-skills\n\nAlias for: myapi auth install-skills');
+                    info(authCmd.INSTALL_SKILLS_HELP);
                     break;
                 }
                 await setupCmd.installSkills();
                 success('› Skills installed.');
                 break;
             case 'help':
-                if (subcommand === 'funnel')
-                    await funnelCmd.run(undefined, [], { help: true });
-                else if (subcommand === 'domain')
-                    await domainCmd.run(undefined, [], { help: true });
-                else if (subcommand === 'auth')
-                    info('Usage: myapi auth <subcommand>\n\nSubcommands:\n  setup           Configure your account\n  import-key      Import an existing API key non-interactively\n  whoami          Show current account · supports --json\n  link [email]    Upgrade anonymous account to registered (or add a second session)\n  switch [index]  Switch active account by index or email\n  config          Manage CLI defaults (org, funnel, domain)\n  install-skills  Install or update the MyAPI skills pack for AI agents\n  api-keys        Manage API keys · list / create / revoke');
-                else if (subcommand === 'org')
-                    info('Usage: myapi org <subcommand>\n\nSubcommands:\n  list        List organizations\n  create      Create an organization · myapi org create "Name" --yes\n  get         Get details of an organization\n  delete      Delete an organization\n  sync-brand  Sync brand info from an existing website into an org');
-                else if (subcommand === 'billing')
-                    info('Usage: myapi billing <subcommand>\n\nSubcommands:\n  balance    Check balance\n  history    View billing history\n  topup      Top up your balance\n  setup      Setup a payment method');
-                else if (subcommand === 'keys')
-                    info('Usage: myapi keys <subcommand>\n\nSubcommands:\n  list             List all API keys\n  create           Create a new API key\n  revoke <id>      Revoke an API key\n\nAlias for: myapi auth api-keys');
-                else if (subcommand)
-                    info(`Run: myapi ${subcommand} --help`);
-                else
-                    printHelp();
+                await dispatchHelp(subcommand);
                 break;
             default:
                 error(`Unknown command: ${command}. Run "myapi" for available commands.`);
@@ -223,7 +155,7 @@ async function main() {
                 else if (err.code === 'NO_PAYMENT_METHOD')
                     error('No payment method on file. Run: myapi billing setup');
                 else
-                    error(`Insufficient balance. Run: myapi billing topup <amount>`);
+                    error('Insufficient balance. Run: myapi billing topup <amount>');
             }
             else
                 error(friendlyError(err.code) || err.message);
@@ -233,6 +165,57 @@ async function main() {
         }
     }
 }
+async function dispatchAuth(subcommand, restArgs, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(authCmd.HELP);
+        return;
+    }
+    switch (subcommand) {
+        case 'setup': return setupCmd.setup(flags);
+        case 'import-key': return setupCmd.importKey(restArgs[0], flags);
+        case 'whoami': return authCmd.whoami(flags);
+        case 'link': return authCmd.link(flags, restArgs[0]);
+        case 'switch': return authCmd.switchCmd(flags, restArgs[0]);
+        case 'install-skills':
+            if (flags.help) {
+                info(authCmd.INSTALL_SKILLS_HELP);
+                return;
+            }
+            await setupCmd.installSkills();
+            success('› Skills installed.');
+            return;
+        case 'config': return configCmd.run(restArgs[0], restArgs.slice(1), flags);
+        case 'api-keys':
+        case 'keys': return keysCmd.runApiKeys(restArgs[0], restArgs.slice(1), flags);
+        default: info('Unknown subcommand. Run: myapi auth --help');
+    }
+}
+const HELP_TARGETS = {
+    funnel: f => funnelCmd.run(undefined, [], f),
+    domain: f => domainCmd.run(undefined, [], f),
+    webhook: f => webhookCmd.run(undefined, [], f),
+    workflow: f => workflowCmd.run(undefined, [], f),
+    email: f => emailCmd.run(undefined, [], f),
+    org: f => orgCmd.run(undefined, [], f),
+    billing: f => billingCmd.run(undefined, [], f),
+    keys: f => keysCmd.run(undefined, [], f),
+    config: f => configCmd.run(undefined, [], f),
+};
+async function dispatchHelp(target) {
+    if (!target) {
+        printHelp();
+        return;
+    }
+    if (target === 'auth') {
+        info(authCmd.HELP);
+        return;
+    }
+    const handler = HELP_TARGETS[target];
+    if (handler)
+        await handler({ help: true });
+    else
+        info(`Run: myapi ${target} --help`);
+}
 function printHelp() {
     const config = loadConfig();
     const quickStart = config?.api_key
@@ -252,6 +235,9 @@ Commands:
   update       Update CLI and skills to the latest version
   domain       Manage domain configurations
   funnel       Manage websites (publish pages, custom domains, funnels)
+  webhook      Manage inbound webhook endpoints and inspect deliveries
+  email        Manage mailboxes, send/read email, templates, and campaigns
+  workflow     Run actions (send email, post to Slack) when a webhook fires
 
 Aliases:
   whoami          → myapi auth whoami

package/dist/output.d.ts

@@ -1,6 +1,15 @@
+export type TableFlags = {
+    json?: boolean | string | number;
+} & Record<string, unknown>;
 export declare function success(message: string): void;
 export declare function error(message: string): never;
 export declare function info(message: string): void;
 export declare function banner(message: string): void;
 export declare function printJson(data: unknown): void;
-export declare function printTable(rows: Record<string, unknown>[]): void;
+export interface PrintTableOptions {
+    /** Pass `flags` so `--json` (any truthy form) routes to JSON output. */
+    flags?: TableFlags;
+    /** Hint shown when the table is empty (instead of "No data found."). */
+    empty?: string;
+}
+export declare function printTable(rows: Record<string, unknown>[], opts?: PrintTableOptions): void;

package/dist/output.js

@@ -15,19 +15,17 @@ export function banner(message) {
 export function printJson(data) {
     console.log(JSON.stringify(data, null, 2));
 }
-export function printTable(rows) {
-    if (process.argv.includes('--json')) {
+export function printTable(rows, opts = {}) {
+    if (opts.flags && opts.flags.json) {
         printJson(rows);
         return;
     }
     if (rows.length === 0) {
-        console.log("No data found.");
+        console.log(opts.empty ?? 'No data found.');
         return;
     }
     const columns = Object.keys(rows[0]);
-    const colWidths = columns.map(col => {
-        return Math.max(col.length, ...rows.map(row => String(row[col] ?? '').length));
-    });
+    const colWidths = columns.map(col => Math.max(col.length, ...rows.map(row => String(row[col] ?? '').length)));
     const printRow = (row) => {
         console.log(row.map((cell, i) => cell.padEnd(colWidths[i] + 2)).join(''));
     };

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 --domain yourdomain.com --username hello
+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.

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

@@ -0,0 +1,106 @@
+---
+name: my-email-api
+description: >
+  Send transactional and bulk email from your own domain. Create mailboxes, send/receive messages, generate AI templates, run drip campaigns, and manage warmup.
+---
+
+# MyEmailAPI
+
+Account-scoped email infrastructure tied to your registered domains. Mailboxes belong to domains; sending and receiving work without per-org plumbing. Templates and campaigns are org-scoped (one campaign belongs to one org).
+
+## How It Fits Together
+
+- Requires `api_key` from **myapihq** and a registered domain via **mydomainapi**.
+- Mailboxes live on a domain (e.g. `hello@yourdomain.com`).
+- Sending must be activated per-mailbox (`mailbox activate-sending`) before transactional sends or campaigns.
+- Templates and campaigns require `org_id` (set a default with `myapi auth config set-org`).
+
+## Quick Start
+
+```bash
+# 1. Create a mailbox on your registered domain
+myapi email mailbox create --domain yourdomain.com --username hello --display-name "Hello"
+
+# 2. Activate sending (required before send/campaign)
+myapi email mailbox activate-sending --address hello@yourdomain.com
+
+# 3. Send a transactional email
+myapi email message send \
+  --from hello@yourdomain.com \
+  --to recipient@example.com \
+  --subject "Hi" \
+  --body "Test message"
+
+# 4. Read inbox / outbox
+myapi email message inbox hello@yourdomain.com
+myapi email message outbox hello@yourdomain.com
+```
+
+## Command Map
+
+| Namespace | Subcommands | Purpose |
+|---|---|---|
+| `email mailbox` | `create`, `list`, `activate-sending` | Create and manage mailboxes on your domains |
+| `email message` | `send`, `status`, `sent`, `inbox`, `outbox`, `get` | Transactional send + read |
+| `email warmup` | `start`, `stats`, `pause`, `resume`, `stop` | IP/domain warmup for sending reputation |
+| `email template` | `generate`, `list`, `edit`, `send-test`, `delete` | AI-generated HTML templates (org-scoped) |
+| `email campaign` | `create`, `list`, `get`, `update`, `upload-contacts`, `start`, `pause`, `resume`, `stats` | Drip campaigns (org-scoped) |
+
+## Templates (AI-generated)
+
+```bash
+# Generate a template — polls the LLM job (up to 90s)
+myapi email template generate \
+  --prompt "A welcome email with our brand colors and a CTA to /onboarding" \
+  --name welcome-v1
+
+# List, edit, delete
+myapi email template list
+myapi email template edit <id> --prompt "Make the CTA larger and red"
+myapi email template send-test <id> --to me@yourdomain.com
+myapi email template delete <id>
+```
+
+## Campaigns
+
+Campaigns send a template to a contact list at a per-day rate.
+
+```bash
+# 1. Create a campaign linked to an existing template + sender mailbox
+myapi email campaign create \
+  --name "Welcome series" \
+  --template-id <template_id> \
+  --from hello@yourdomain.com \
+  --per-day 50
+
+# 2. Upload contacts
+myapi email campaign upload-contacts <campaign_id> \
+  --emails "alice@example.com,bob@example.com"
+
+# 3. Start (only after upload-contacts has finished processing)
+myapi email campaign start <campaign_id>
+
+# 4. Monitor
+myapi email campaign stats <campaign_id>
+myapi email campaign pause <campaign_id>
+myapi email campaign resume <campaign_id>
+```
+
+## Warmup
+
+Warmup gradually ramps mailbox sending to build reputation with inbox providers. Recommended before high-volume campaigns.
+
+```bash
+myapi email warmup start --address hello@yourdomain.com
+myapi email warmup stats --address hello@yourdomain.com
+myapi email warmup pause --address hello@yourdomain.com
+```
+
+## Notes
+
+- A single mailbox is uniquely identified by its address (`username@domain`).
+- Sending must be activated explicitly — newly-created mailboxes can receive but not send.
+- Templates and campaigns are org-scoped. Set a default org once: `myapi auth config set-org <id>`.
+- Domain assignment to org is enforced at unassign time: an active or paused campaign sending from a mailbox on the domain will block `domain unassign` with `DOMAIN_IN_USE`.
+
+Run `myapi email --help` or `myapi email <namespace> --help` for full flag reference.

package/dist/skills/my-email-api/claude/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "my-email-api",
+  "description": "Send transactional and bulk email from your own domain. Mailboxes, AI templates, drip campaigns, and warmup.",
+  "version": "1.0.0",
+  "published": true
+}

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

@@ -0,0 +1,40 @@
+---
+# my-webhook-api
+
+Inbound HTTP endpoints that receive POSTs from third-party services and store every delivery for inspection. Pair with my-workflow-api to react to incoming events.
+
+## What it does
+
+- Create per-org webhook endpoints with unique inbound URLs
+- Store every inbound delivery (body + headers)
+- Inspect individual deliveries by id
+- Bind webhooks to workflows for event-driven actions
+
+## Quickstart
+
+```bash
+# Create an endpoint
+myapi webhook create --name "stripe-events"
+# → prints: Inbound URL: https://api.myapihq.com/webhook/in/<slug>
+
+# POST to it from anywhere
+curl -X POST <inbound-url> -d '{"event":"x"}'
+
+# List + inspect
+myapi webhook list
+myapi webhook delivery <delivery_id>
+```
+
+## Authentication
+
+```bash
+export MYAPI_KEY=mak_...
+```
+
+Requires `api_key` and `org_id` from **myapihq**.
+
+## Documentation
+
+Full command reference and workflow integration: see `SKILL.md`.
+
+Run `myapi webhook --help` for inline reference.

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

@@ -0,0 +1,65 @@
+---
+name: my-webhook-api
+description: >
+  Inbound webhook endpoints. Receive HTTP POSTs from third parties (forms, Stripe, GitHub, etc.) and either inspect the deliveries directly or wire them to a workflow.
+---
+
+# MyWebhookAPI
+
+Per-org HTTP endpoints that accept inbound POSTs and durably store every delivery. A webhook on its own is a passive receiver — pair it with **myworkflowapi** to react to incoming events (send email, post to Slack, etc.).
+
+## How It Fits Together
+
+- Requires `api_key` and `org_id` from **myapihq**.
+- Each endpoint has a unique inbound URL (returned at create time).
+- Deliveries are stored verbatim — full request body + headers — for inspection.
+- `myworkflowapi` workflows bind to a webhook endpoint via its `id`.
+
+## Quick Start
+
+```bash
+# 1. Create a webhook endpoint
+myapi webhook create --name "stripe-events" --description "Stripe payment events"
+# → prints: Inbound URL: https://api.myapihq.com/webhook/in/<slug>
+
+# 2. POST to the inbound URL from your service
+curl -X POST https://api.myapihq.com/webhook/in/<slug> \
+  -H "Content-Type: application/json" \
+  -d '{"event":"payment.succeeded"}'
+
+# 3. List endpoints / inspect a delivery
+myapi webhook list
+myapi webhook delivery <delivery_id>
+```
+
+## All Commands
+
+| Command | What it does |
+|---|---|
+| `myapi webhook create` | Create an endpoint, returns id + inbound URL |
+| `myapi webhook list` | List all endpoints in your org |
+| `myapi webhook delete <id>` | Delete an endpoint and all its deliveries |
+| `myapi webhook delivery <delivery_id>` | Get the full payload + headers for one delivery |
+
+## Wiring to a Workflow
+
+Webhooks become useful when a workflow fires on each inbound POST. See **myworkflowapi**:
+
+```bash
+# Create the webhook
+WID=$(myapi webhook create --name "leads" --json | jq -r .id)
+
+# Bind a workflow that sends an email each time the webhook fires
+myapi workflow create \
+  --name "Notify on lead" \
+  --endpoint-id $WID \
+  --steps '[{"type":"send_email","to":"sales@yourdomain.com","subject":"New lead"}]'
+```
+
+## Notes
+
+- The inbound URL is public — anyone with the URL can POST to it. Treat the slug as a secret.
+- Deliveries are kept indefinitely. Delete the endpoint to purge them.
+- Failed workflow runs do not affect the delivery record — the inbound POST is always saved.
+
+Run `myapi webhook --help` for full flag reference.

package/dist/skills/my-webhook-api/claude/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "my-webhook-api",
+  "description": "Receive inbound HTTP webhooks. Per-org endpoints with full delivery history.",
+  "version": "1.0.0",
+  "published": true
+}

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

@@ -0,0 +1,37 @@
+---
+# my-workflow-api
+
+Run a chain of actions (send email, post to Slack, call an HTTP endpoint) every time an inbound webhook fires. No backend required.
+
+## What it does
+
+- Bind ordered step chains to webhook endpoints
+- Steps can: send transactional email, hit Slack, call any HTTP URL
+- Template values from the inbound webhook payload (`{{ payload.field }}`)
+- Per-run status tracking (attempt, error, started/finished timestamps)
+- Enable/disable without losing config
+
+## Quickstart
+
+```bash
+# Create a webhook + workflow that sends Slack on every POST
+WID=$(myapi webhook create --name "leads" --json | jq -r .id)
+myapi workflow create \
+  --name "Slack on lead" \
+  --endpoint-id $WID \
+  --steps '[{"type":"slack","webhook_url":"..."}]'
+```
+
+## Authentication
+
+```bash
+export MYAPI_KEY=mak_...
+```
+
+Requires `api_key` + `org_id` from **myapihq**, and a webhook endpoint id from **mywebhookapi**.
+
+## Documentation
+
+Full command reference, step types, and templating: see `SKILL.md`.
+
+Run `myapi workflow --help` for inline reference.