@myapihq/cli 1.0.79 → 1.0.82

package/dist/commands/domain.js

@@ -35,9 +35,9 @@ export async function check(domainArg, flags) {
 export async function register(domainArg, flags) {
     const config = requireConfig();
     const orgId = flags.org || config.default_org;
-    const domain = domainArg || config.default_domain;
+    const domain = domainArg;
     if (!orgId || !domain)
-        error("Missing required arguments.\nUsage: myapi domain register <domain> --org <id> [--years <num>]\n(Set defaults: myapi auth config set-org <id> / myapi auth config set-domain <domain>)");
+        error("Missing required arguments.\nUsage: myapi domain register <domain> --org <id> [--years <num>]");
     const years = parseInt(flags.years) || 1;
     const res = await sdkDomain.registerDomain(config.api_key, orgId, domain, years);
     success(`Registered ${domain}!`);
@@ -65,18 +65,18 @@ export async function list(flags) {
 export async function assign(domainArg, flags) {
     const config = requireConfig();
     const orgId = flags.org || config.default_org;
-    const domain = domainArg || config.default_domain;
+    const domain = domainArg;
     if (!orgId || !domain)
-        error("Missing required arguments.\nUsage: myapi domain assign <domain> --org <id>\n(Set defaults: myapi auth config set-org <id> / myapi auth config set-domain <domain>)");
+        error("Missing required arguments.\nUsage: myapi domain assign <domain> --org <id>");
     await sdkDomain.assignDomain(config.api_key, orgId, domain);
     success(`Assigned ${domain} to org ${orgId}`);
 }
 export async function unassign(domainArg, flags) {
     const config = requireConfig();
     const orgId = flags.org || config.default_org;
-    const domain = domainArg || config.default_domain;
+    const domain = domainArg;
     if (!orgId || !domain)
-        error("Missing required arguments.\nUsage: myapi domain unassign <domain> --org <id>\n(Set defaults: myapi auth config set-org <id> / myapi auth config set-domain <domain>)");
+        error("Missing required arguments.\nUsage: myapi domain unassign <domain> --org <id>");
     await sdkDomain.unassignDomain(config.api_key, orgId, domain);
     success(`Unassigned ${domain} from org ${orgId}`);
 }

package/dist/commands/funnel.js

@@ -42,16 +42,19 @@ export async function get(id, flags) {
     const orgId = flags.org || config.default_org;
     if (!orgId || !id)
         error("Missing required arguments.\nUsage: myapi funnel get <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
-    const funnel = await sdkFunnel.getFunnel(config.api_key, orgId, id);
+    const raw = await sdkFunnel.getFunnel(config.api_key, orgId, id);
+    const funnel = raw.funnel ?? raw;
+    const subdomain_url = raw.subdomain_url ?? funnel.subdomain_url;
+    const domain_url = raw.domain_url ?? funnel.domain_url;
     if (flags.json) {
-        printJson(funnel);
+        printJson(raw);
         return;
     }
     info(`ID:          ${funnel.id}`);
-    if (funnel.domain_url)
-        info(`Domain:      ${funnel.domain_url}`);
-    else if (funnel.subdomain_url)
-        info(`Preview:     ${funnel.subdomain_url}`);
+    if (domain_url)
+        info(`Domain:      ${domain_url}`);
+    if (subdomain_url)
+        info(`Preview:     ${subdomain_url}`);
     if (funnel.created_at)
         info(`Created:     ${formatDate(funnel.created_at)}`);
     if (funnel.updated_at)

package/dist/commands/setup.js

@@ -99,7 +99,7 @@ async function anonymousFlow() {
 // myapi auth import-key <key> — non-interactively import a raw API key.
 export async function importKey(apiKey, flags) {
     if (flags.help || !apiKey) {
-        info('Usage: myapi auth import-key <api_key> [--install-skills] [--no-skills]\n\nImports an existing API key non-interactively. Use this in CI, Docker, or any\nenvironment where the interactive "myapi auth setup" flow is not practical.\n\nThe key is validated against the API before being saved. Your default org and\nfunnel are auto-detected from the account and written to the local config.\n\nFlags:\n  --install-skills   Also install the MyAPI skills pack for AI agents after importing\n  --no-skills        Skip skills installation even if previously installed\n\nExamples:\n  myapi auth import-key hqlive_xxxxxxxxxxxxxxxxxxxx\n  myapi auth import-key hqlive_xxxxxxxxxxxxxxxxxxxx --install-skills');
+        info('Usage: myapi auth import-key <api_key> [--install-skills] [--no-skills]\n\nImports an existing API key non-interactively. Use this in CI, Docker, or any\nenvironment where the interactive "myapi auth setup" flow is not practical.\n\nThe key is validated against the API before being saved. Your default org and\nfunnel are auto-detected from the account and written to the local config.\n\nFlags:\n  --install-skills   Also install the MyAPI skills pack for AI agents after importing\n  --no-skills        Skip skills installation even if previously installed\n\nExamples:\n  myapi auth import-key hq_live_xxxxxxxxxxxxxxxxxxxx\n  myapi auth import-key hq_live_xxxxxxxxxxxxxxxxxxxx --install-skills');
         return;
     }
     const auth = { Authorization: `Bearer ${apiKey}` };

package/dist/index.js

@@ -93,7 +93,7 @@ async function main() {
                     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 hqlive_xxxxxxxxxxxxxxxxxxxx');
+                        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]) {
@@ -166,7 +166,7 @@ async function main() {
                 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 hqlive_xxxxxxxxxxxxxxxxxxxx\n\nAlias for: myapi auth api-keys');
+                    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')

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

@@ -1,116 +1,82 @@
 ---
 name: my-api-hq
 description: >
-  Core Identity and Billing hub. Manage auth, organizations (get org_id), and billing (checkout/topup).
+  Auth, organizations, and billing hub. Start here to get an api_key and org_id — every other service depends on both.
 ---
 
-# MyApiHQ Skill
-Root entry point for the ecosystem. All other skills require an `api_key` and often an `org_id` from here.
+# MyApiHQ
 
-## Platform Conventions
+The root service. It manages accounts, API keys, organizations, and billing. No other service works without credentials from here.
 
-### Response Envelope
-Every response across all services is wrapped in:
-```json
-{
-  "success": true,
-  "data": { ... },
-  "error": null,
-  "meta": { "request_id": "...", "latency_ms": 12, "service": "...", "version": "v1" }
-}
-```
-On error, `success` is `false`, `data` is `null`, and `error` contains a string error code or object. Always check `success` before reading `data`.
+## How It Fits Together
 
-### Pagination
-List endpoints accept `?limit=` and `?offset=` and return `total`, `limit`, `offset` in the body.
+```
+myapihq  ──►  org_id + api_key
+                  │
+          ┌───────┴────────┐
+     mydomainapi       myfunnelapi
+     (domains)         (websites)
+```
 
-## Authentication & Key Management
+- **mydomainapi** needs an `org_id` to register or manage domains.
+- **myfunnelapi** needs an `org_id` to create funnels; a registered domain makes the funnel live on your custom URL.
 
-You need to go to myapihq.com and register an account. Generate an api key and export it to pass it to the agent (as env).
+## Quick Start (CLI)
 
-### Account Login
+```bash
+myapi auth setup          # interactive setup: creates account, generates api_key, sets defaults
+myapi org create --name "Acme" --yes   # creates an org and sets it as default
+myapi org list            # see all orgs and their IDs
 ```
-POST /hq/account/login
-{ "email": "...", "password": "..." }
-→ { "data": { "token": "<JWT>" } }
-```
-Errors: `401` wrong password.
 
-**Refresh Token:**
-```
-POST /hq/account/refresh
-```
+After `myapi auth setup` your `api_key` and default `org_id` are stored locally. Most commands pick them up automatically.
 
-**Google OAuth:**
-- `GET /hq/auth/google/redirect` — Initiates Google OAuth flow.
-- `GET /hq/auth/google/callback` — OAuth callback.
+## Organizations
 
-### API Key Management
-**Generate Persistent Key:**
-```
-POST /hq/account/create/key
-Authorization: Bearer <JWT from login>
-{ "name": "MyKey" }
-→ { "data": { "api_key": "hq_live_...", "id": "...", "prefix": "..." } }
-```
-Errors: `401` no auth.
+An org is the container for everything else — domains, funnels, brand settings.
 
-Use `Authorization: Bearer <api_key>` for all subsequent requests across the entire ecosystem.
+| CLI command | What it does |
+|---|---|
+| `myapi org create --name "..."` | Create a new org (add `--yes` to auto-set as default) |
+| `myapi org sync-brand <domain>` | Scrape a live site and auto-fill brand info into an existing org |
+| `myapi org list` | List all orgs (`*` marks the default) |
+| `myapi org get [id]` | Inspect one org (defaults to current default org) |
+| `myapi org delete <id>` | Delete org and cascade |
 
-**List Keys:** `GET /hq/account/keys`
+`org sync-brand` is async — it scrapes the site and updates the org's name, logo, and description. You need an existing org first (`org create`).
 
-**Revoke Key:** `DELETE /hq/account/delete/key/{id}`
+Each org gets a free preview subdomain (`*.makeautonomous.com`) you can use before registering a custom domain.
 
-### Cross-Session Storage
-**Always persist credentials immediately.** Write a `.env` file:
-```
-MYAPI_API_KEY=hq_live_...
-MYAPI_ACCOUNT_ID=...
-```
-Also save to agent memory if your runtime supports it (e.g., Claude Code memory). On every new session, check for credentials before creating a new account.
+## API Keys
 
-## Organization Management
-**You MUST create an org to get an `org_id` for other APIs.**
+Keys have the format `hq_live_...` and are used as `Authorization: Bearer <api_key>` across all services.
 
-### Create Org (sync)
-```
-POST /hq/orgs
-{ "name": "Acme Inc" (required), "tagline", "description", "business_sector",
-  "logo_url", "favicon_url", "og_image_url",
-  "color_palette": { "primary": "#hex", ... },
-  "font_family", "imagery_style", "headline", "subheadline", "cta_text",
-  "value_propositions": ["..."],
-  "social_links": { "twitter": "url", ... },
-  "canonical_url", "privacy_policy_url", "cookie_policy_url", "terms_url",
-  "gdpr_enabled": false, "default_language": "en", "tracking": {} }
-→ { "data": { "id": "<org_id>", ... } }
+```bash
+myapi keys list
+myapi keys create
+myapi keys revoke <id>
 ```
-Errors: `400` invalid_json · `422` name_required, invalid_field:color_palette, invalid_field:value_propositions, invalid_field:social_links, invalid_field:tracking · `402` insufficient balance (org creation has a cost on paid plan).
 
-### Async Brand Import
-```
-POST /hq/org-imports
-{ "org_id": "<id>" (required), "domain": "example.com" (required), "auto_accept": false }
-→ { "data": { "job_id": "...", "status": "pending" } }
+## Billing
 
-GET /hq/org-imports/{job_id}
-→ Poll until status = "awaiting_confirm". Returns brand_preview.
+All services consume credits. Check balance and top up here.
 
-POST /hq/org-imports/{job_id}/confirm
-{ ...optional overrides matching POST /hq/orgs payload... }
-→ { "data": { "id": "<org_id>", ... } }
+```bash
+myapi billing balance
+myapi billing topup <amount>   # e.g. myapi billing topup 20
+myapi billing history
 ```
 
-### Manage Orgs
-- `GET /hq/orgs` — list all orgs.
-- `GET /hq/orgs/{id}` — get org details. Errors: `404` org_not_found.
-- `PATCH /hq/orgs/{id}` — partial update, same fields as create. Errors: `400` invalid_json · `404` org_not_found · `422` invalid_field:*.
-- `DELETE /hq/orgs/{id}` — delete org and cascade. Errors: `404` org_not_found.
+If any service returns `402`, run `myapi billing balance` and top up before retrying.
 
-## Billing
-- **Setup Payment Method:** You need to do this from the myapihq dashboard directly.
-- **Check Balance:** `GET /hq/billing/balance` → `{ "data": { "balance_cents": 1000, "balance_display": "$10.00", "credits_cents": 500, "credits_display": "$5.00", "has_payment_method": true } }`.
-- **Billing History:** `GET /hq/billing/history`
-- **Top Up:** `POST /hq/billing/topup` — `{ "amount_cents": 1000 }` → `{ "data": { "new_balance_cents": 2000, "new_balance_display": "$20.00" } }`.
+## Config Defaults
+
+Set defaults once to skip `--org` on every command:
+
+```bash
+myapi auth config set-org <org_id>
+myapi auth config set-domain <domain>
+myapi auth config show
+```
 
-**On 402 from any service:** check balance and top up here before retrying.
+Run `myapi --help` or `myapi <command> --help` for full flag reference.

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

@@ -1,83 +1,62 @@
 ---
 name: my-domain-api
 description: >
-  Register new domains, check availability and pricing, import existing domains, and manage edge settings. Use this before creating mailboxes or funnels — both require an owned domain.
+  Register new domains and manage edge settings. Required before a funnel can go live on a custom URL.
 ---
 
-# MyDomainAPI Skill
+# MyDomainAPI
 
-## Quick Start
-1. `GET /domain/orgs/{org_id}/list?filter=all` — lists domains owned by your account. `filter` can be `all`, `unassigned`, or `org` (default).
-2. `GET /domain/orgs/{org_id}/check/available/{domain}` — confirm availability and price.
-3. `POST /domain/orgs/{org_id}/register` with `domain` and optional `years`.
-4. Proceed to `my-email-api` for mailboxes or `my-funnel-api` for a website.
+Handles domain registration, assignment to orgs, and edge (CDN/security) settings. DNS is fully managed — you never touch nameservers manually.
 
-DNS is fully managed by the platform — enabling seamless email deliverability, tracking pixel, and edge delivery integration. Manual DNS record management is not exposed.
+## How It Fits Together
 
-## Dependencies & Backlinks
-- **Auth & Billing:** 401/402 → fall back to `my-api-hq`.
-- **Next Steps:** After registration → `my-email-api` for mailboxes or `my-funnel-api` for a website.
+- Requires `api_key` and `org_id` from **myapihq**.
+- A domain assigned to an org is the prerequisite for a **myfunnelapi** funnel to be reachable at a custom URL.
+- Without a domain, funnels still work on the free `*.makeautonomous.com` preview subdomain.
 
-## Authentication
-`Authorization: Bearer <api_key>` (from `my-api-hq`).
+## Typical Flow
 
-## Endpoints
-
-### Check Availability
-```
-GET /domain/orgs/{org_id}/check/available/{domain}
-→ { "available": true, "price_cents": 1200 }
+```bash
+myapi domain check example.com          # check availability + price
+myapi domain register example.com       # register it (deducts credits)
+myapi domain assign example.com         # assign to your default org
+myapi domain status example.com         # watch until status = active
 ```
-Errors: `400` INVALID_DOMAIN, TLD_NOT_SUPPORTED.
 
-### Register Domain
-```
-POST /domain/orgs/{org_id}/register
-{ "domain": "example.com", "years": 1 }
-→ { "domain": "...", "status": "provisioning", "domain_id": "..." }
-```
-Errors: `400` invalid request, INVALID_DOMAIN, TLD_NOT_SUPPORTED · `409` DOMAIN_ALREADY_OWNED, DOMAIN_UNAVAILABLE · `402` INSUFFICIENT_BALANCE (includes `required_cents`) or UPGRADE_REQUIRED (free account) · `403` `already_owned` flag is not permitted.
+After `status` shows `active`, your funnel will be live at `https://example.com`. SSL provisioning takes a few extra minutes after activation.
 
-### Import Existing Domain
-```
-POST /domain/orgs/{org_id}/import
-{ "domain": "example.com", "namecheap_api_user": "optional", "namecheap_api_key": "optional" }
-```
-Sets up DNS and email infrastructure automatically. Optionally updates Namecheap NS if credentials are provided.
-Errors: `402` insufficient balance.
+## All Commands
 
-To use Namecheap automation: go to **Profile > Tools > Namecheap API Access**, generate an API Key, and whitelist the MyAPI-HQ server IP — otherwise the API calls will be rejected.
+| Command | What it does |
+|---|---|
+| `myapi domain check <domain>` | Check availability and yearly price |
+| `myapi domain register <domain> [--years N]` | Register a new domain (explicit domain required) |
+| `myapi domain list [--filter all\|unassigned\|org]` | List domains in your account |
+| `myapi domain assign <domain>` | Assign domain to the default (or `--org`) org (explicit domain required) |
+| `myapi domain unassign <domain>` | Remove domain from its org (explicit domain required) |
+| `myapi domain status <domain>` | Check registration + DNS propagation status |
+| `myapi domain settings <domain>` | View edge/CDN settings |
+| `myapi domain update-settings <domain>` | Update edge settings (security level, browser check, cache purge) |
 
-### List & Status
-```
-GET /domain/orgs/{org_id}/list
-GET /domain/orgs/{org_id}/{domain}/status
-```
-Errors (status): `404` DOMAIN_NOT_FOUND.
+`register`, `assign`, and `unassign` always require an explicit domain argument — they do not fall back to any stored default, to prevent accidental destructive actions.
 
-### Assign / Unassign Domain
-```
-POST /domain/orgs/{org_id}/{domain}/assign
-{ "org_id": "<target_org_id>" } // Pass null to unassign
-```
-Associates a domain already in the account with a specific organization, or removes it from its current organization if `org_id` is null.
-Errors: `404` DOMAIN_NOT_FOUND · `422` ORG_NOT_FOUND.
+## Edge Settings
 
-### Edge Settings
+Fine-tune CDN/security behavior per domain:
 
-**Update:**
+```bash
+myapi domain update-settings example.com \
+  --security=essentially_off \
+  --browser-check=off \
+  --purge-cache
 ```
-POST /domain/orgs/{org_id}/{domain}/settings
-{
-  "security_level": "essentially_off",  // essentially_off | medium | high | under_attack
-  "browser_check": "off",               // on | off
-  "purge_cache": true
-}
-```
-*To allow AI training bots and crawlers: set `security_level: "essentially_off"` and `browser_check: "off"`.*
 
-**Get:**
-```
-GET /domain/orgs/{org_id}/{domain}/settings
-→ { "domain": "...", "security_level": "...", "browser_check": "...", "ai_bots_protection": "disabled", "is_robots_txt_managed": false }
-```
+Security levels: `essentially_off` · `low` · `medium` · `high` · `under_attack`.  
+Set `essentially_off` + `browser-check=off` to allow AI crawlers and training bots through without challenge pages.
+
+## Notes
+
+- All commands default to `--org` from your saved config. Set it once with `myapi auth config set-org <id>`.
+- `402` errors mean insufficient credits — run `myapi billing topup <amount>`.
+
+Run `myapi domain --help` or `myapi domain <subcommand> --help` for full flag reference.

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

@@ -1,35 +1,70 @@
 ---
-name: my-funnel-api:funnel
+name: my-funnel-api
 description: >
-  A lean CRUD and CDN Publishing API. Manage funnel configurations, push raw HTML pages, and deploy static assets to the edge KV.
+  Create and publish websites (funnels) to the edge. Push raw HTML to any slug and it goes live instantly on your org's domain or preview subdomain.
 ---
 
-# MyFunnelAPI Skill
+# MyFunnelAPI
 
-## 1. Funnel Management (Authenticated)
-These endpoints manage the database records and structural configuration of funnels.
+A funnel is a website tied to an org. You push raw HTML pages to slugs and they are served from the edge immediately — no build pipeline, no deploy queue.
 
-- `GET /funnel/orgs/{org_id}/funnels`
-  Lists all funnels for the specified organization.
-- `POST /funnel/orgs/{org_id}/funnels`
-  Creates a new funnel entry. Expects basic configuration metadata (name, domain, etc.). Body: `{ "domain": "example.com" }`
-- `GET /funnel/orgs/{org_id}/funnels/{id}`
-  Retrieves the metadata and configuration details of a specific funnel.
-- `DELETE /funnel/orgs/{org_id}/funnels/{id}`
-  Deletes a funnel from the database and automatically purges all of its preview and published pages from the edge KV cache.
+## How It Fits Together
 
-## 2. Publishing & Edge Deployment (Authenticated)
-These endpoints interact with the edge KV cache to push HTML/JS content to the edge domains. As soon as you push a page, it is live.
+- Requires `api_key` and `org_id` from **myapihq**.
+- Works out of the box on the free preview subdomain (`*.makeautonomous.com`).
+- To serve on a custom domain, register and assign a domain via **mydomainapi** first.
 
-- `POST /funnel/orgs/{org_id}/funnels/{id}/push-page`
-  Deploys raw HTML to a specific slug on the live funnel (e.g., pushing custom HTML to /contact). Body: `{"slug": "/route", "html": "..."}`.
-- `POST /funnel/orgs/{org_id}/funnels/{id}/verify`
-  Pre-publish verification. Validates syntax and structure of raw HTML or an existing page slug.
+## Typical Flow
 
-## 3. Public Proxies (Unauthenticated)
-These endpoints are called directly by the end-users' browsers (via the deployed static HTML). They do not require API keys. They are stateless and act as routing proxies to the Webhook API.
+```bash
+myapi funnel create                      # creates a funnel under your default org
+echo '<h1>Hello</h1>' | myapi funnel push /   # pushes HTML to /
+myapi funnel list                        # see all funnels and their preview URLs
+```
 
-- `POST /funnel/funnels/{id}/submit/{slug...}`
-  The endpoint for HTML form submissions. Validates the JSON payload, returns a 200 OK to the browser, and asynchronously POSTs the data to the organization's matching webhook (or fallback webhook).
-- `POST /funnel/funnels/{id}/event`
-  The endpoint for analytics and tracking scripts. Proxies click events, pageviews, and pixel tracking data to the configured webhook endpoints. Includes built-in rate limiting (max 60 req/min per funnel).
+After `funnel create`, the CLI prints a preview URL. After `push`, the page is immediately live.
+
+## All Commands
+
+| Command | What it does |
+|---|---|
+| `myapi funnel create` | Create a new funnel in the default org |
+| `myapi funnel list` | List all funnels with their preview/domain URLs |
+| `myapi funnel get <id>` | Inspect a funnel's metadata and preview URL |
+| `myapi funnel delete <id>` | Delete funnel and purge all its edge pages |
+| `myapi funnel push [slug]` | Push HTML from stdin to a slug path |
+
+## Pushing Pages
+
+The `push` command reads HTML from stdin and deploys it to a slug. The funnel is resolved from your saved default (`myapi auth config set-funnel <id>`) or `--funnel <id>`.
+
+```bash
+# push to /
+cat index.html | myapi funnel push /
+
+# push to /contact
+cat contact.html | myapi funnel push /contact
+
+# push to / using explicit funnel
+cat index.html | myapi funnel push / --funnel <funnel_id>
+
+# pipe from a generator
+my-html-gen | myapi funnel push /landing
+```
+
+Omitting `[slug]` defaults to `/`.
+
+## Form Submissions & Analytics
+
+Funnels include two public proxy endpoints your HTML can call directly (no API key needed):
+
+- **Form submit:** `POST /funnel/funnels/{id}/submit/{slug}` — validates payload and forwards to your org's configured webhook.
+- **Analytics/tracking:** `POST /funnel/funnels/{id}/event` — proxies pageviews, clicks, and pixel events to your webhook. Rate-limited to 60 req/min per funnel.
+
+## Notes
+
+- Default org and funnel are stored in config. Set them once with `myapi auth config set-org <id>` to skip `--org` on every command.
+- Deleting a funnel purges all its edge pages immediately.
+- `402` errors mean insufficient credits — run `myapi billing topup <amount>`.
+
+Run `myapi funnel --help` or `myapi funnel <subcommand> --help` for full flag reference.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myapihq/cli",
-  "version": "1.0.79",
+  "version": "1.0.82",
   "description": "MyAPI command-line interface",
   "type": "module",
   "files": [