@myapihq/cli 1.1.0-wip.1 → 1.1.0-wip.3

package/dist/commands/email/mailbox.js

@@ -45,7 +45,7 @@ async function activateSending(flags) {
     if (!address)
         error('Missing required arguments.\nUsage: myapi email mailbox activate-sending --address <email>');
     const res = await sdkEmail.activateSending(config.api_key, address);
-    success(`Sending activated: ${address} (status: ${res.status})`);
+    success(`Sending activated: ${address} (${res.emails_quota_remaining} emails/day quota)`);
 }
 const USAGE = {
     'create': `myapi email mailbox create <user@domain> [--display-name <name>]

package/dist/commands/funnel.d.ts

@@ -6,5 +6,5 @@ export declare function create(flags: Flags): Promise<void>;
 export declare function get(id: string, flags: Flags): Promise<void>;
 export declare function del(id: string, flags: Flags): Promise<void>;
 export declare function push(slug: string, flags: Flags): Promise<void>;
-export declare function verify(id: string, flags: Flags): Promise<void>;
+export declare function verify(slug: string, flags: Flags): Promise<void>;
 export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/funnel.js

@@ -108,25 +108,48 @@ export async function push(slug, flags) {
     if (resolvedFromOrg) {
         info(`(Used the org's only funnel: ${funnelId}. Set a default with: myapi config set-funnel ${funnelId})`);
     }
-    if (result?.url) {
-        info(`Preview: ${result.url}`);
-    }
-    else {
+    let liveUrl = result?.url;
+    if (!liveUrl) {
         const org = await hq.getOrg(config.api_key, orgId);
         if (org.preview_subdomain) {
-            info(`Preview: https://${org.preview_subdomain}.makeautonomous.com${finalSlug}`);
+            liveUrl = `https://${org.preview_subdomain}.makeautonomous.com${finalSlug}`;
+        }
+    }
+    if (liveUrl)
+        info(`Preview: ${liveUrl}`);
+    // If we're still on the preview subdomain, hint at how to serve on a
+    // custom domain. Tailor the hint: if a default_domain is already
+    // configured (registered + meant to be used), suggest assigning it
+    // directly; otherwise point at register + assign.
+    const onPreview = liveUrl?.includes('.makeautonomous.com');
+    if (onPreview) {
+        const dom = config.default_domain;
+        if (dom) {
+            info(`(Serving on the preview subdomain. To serve on ${dom} instead: myapi domain assign ${dom})`);
+        }
+        else {
+            info(`(Serving on the preview subdomain. To serve on a custom domain: myapi domain register <domain> && myapi domain assign <domain>)`);
         }
     }
 }
-export async function verify(id, flags) {
+// Verify uses the same shape as push: slug positional (default '/'), funnel
+// resolved from --funnel / default / the org's only funnel.
+export async function verify(slug, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi funnel verify <id> [--slug <slug>] [--org <id>]');
-    if (!id)
-        error('Missing required arguments.\nUsage: myapi funnel verify <id> [--slug <slug>] [--org <id>]');
-    const opts = {};
-    if (flags.slug)
-        opts.slug = flags.slug;
-    const v = await sdkFunnel.verifyFunnel(config.api_key, orgId, id, opts);
+    const orgId = requireOrg(flags, config, 'myapi funnel verify [slug] [--funnel <id>] [--org <id>]');
+    const rawSlug = slug || flags.slug || '/';
+    const finalSlug = rawSlug.startsWith('/') ? rawSlug : `/${rawSlug}`;
+    let funnelId = flags.funnel || config.default_funnel;
+    if (!funnelId) {
+        const existing = await sdkFunnel.listFunnels(config.api_key, orgId);
+        if (existing.length === 0)
+            error('No funnel found for this org. Create one with: myapi funnel create');
+        if (existing.length > 1) {
+            error(`Multiple funnels exist for this org and no default is set.\nPick one with --funnel <id>, or set a default:\n  myapi config set-funnel <id>\n\nFunnels:\n${existing.map(f => `  ${f.id}`).join('\n')}`);
+        }
+        funnelId = existing[0].id;
+    }
+    const v = await sdkFunnel.verifyFunnel(config.api_key, orgId, funnelId, { slug: finalSlug });
     printJson(v);
 }
 // ── Dispatcher ───────────────────────────────────────────────────────────────
@@ -140,12 +163,26 @@ const SUBCOMMAND_USAGE = {
 Reads HTML from stdin and publishes to <slug> on your funnel. Funnel is resolved
 from --funnel, the default funnel, or (only if the org has exactly one) auto-picked.
 
+By default, your funnel is served on a preview subdomain (*.makeautonomous.com).
+To serve on your own domain, register and assign one with:
+  myapi domain register <domain>
+  myapi domain assign <domain>
+
 Examples:
   echo '<h1>Hello</h1>' | myapi funnel push /
   cat about.html | myapi funnel push /about
   myapi funnel push < index.html
   cat p.html | myapi funnel push /pricing --funnel <uuid>`,
-    'verify': 'myapi funnel verify <id> [--slug <slug>] [--org <id>]',
+    'verify': `myapi funnel verify [slug] [--funnel <id>] [--org <id>]
+
+Verifies the page at <slug> on a funnel. Slug defaults to '/'. Funnel is
+resolved from --funnel, the default funnel, or (only if the org has exactly
+one) auto-picked — same shape as "funnel push".
+
+Examples:
+  myapi funnel verify              # verifies '/' on the default funnel
+  myapi funnel verify /pricing
+  myapi funnel verify / --funnel <uuid>`,
 };
 export async function run(subcommand, args, flags) {
     if (!subcommand || (flags.help && !subcommand)) {

package/dist/commands/workflow.js

@@ -9,6 +9,63 @@ export const SCHEMA = {
     steps: 'string',
     'no-enable': 'boolean',
 };
+// Mirrors the backend's SupportedStepTypes list. Both alias and underscore
+// forms are accepted by the workflow runner. Keep this in sync if the
+// backend grows new step types.
+const SUPPORTED_STEP_TYPES = ['send_email', 'email', 'slack_message', 'slack'];
+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;
+// Per-step-type required fields. Validated client-side so typos and
+// hallucinated shapes fail fast, before the network call. Backend
+// performs the same validation as defense in depth.
+function validateSteps(steps) {
+    if (!Array.isArray(steps))
+        error('--steps must be a JSON array of step objects.');
+    if (steps.length === 0)
+        error('--steps cannot be an empty array.');
+    steps.forEach((s, i) => {
+        const where = `step ${i}`;
+        if (!s || typeof s !== 'object')
+            error(`${where}: must be a JSON object.`);
+        if (!s.type)
+            error(`${where}: missing required field "type". Supported: ${SUPPORTED_STEP_TYPES.join(', ')}`);
+        if (!SUPPORTED_STEP_TYPES.includes(s.type)) {
+            error(`${where}: unknown type "${s.type}". Supported: ${SUPPORTED_STEP_TYPES.join(', ')}`);
+        }
+        if (s.type === 'send_email' || s.type === 'email') {
+            const required = ['from', 'to', 'subject'];
+            for (const f of required) {
+                if (!s[f] || typeof s[f] !== 'string') {
+                    error(`${where} (${s.type}): missing required field "${f}".`);
+                }
+            }
+            const bodyForms = ['body', 'html', 'template_id'].filter(f => s[f] !== undefined && s[f] !== '');
+            if (bodyForms.length === 0) {
+                error(`${where} (${s.type}): must include exactly one of "body", "html", or "template_id".`);
+            }
+            if (bodyForms.length > 1) {
+                error(`${where} (${s.type}): can only use one of "body", "html", "template_id" — got: ${bodyForms.join(', ')}.`);
+            }
+            if (s.template_vars !== undefined && !s.template_id) {
+                error(`${where} (${s.type}): "template_vars" only makes sense with "template_id".`);
+            }
+            if (s.template_vars !== undefined && (typeof s.template_vars !== 'object' || Array.isArray(s.template_vars))) {
+                error(`${where} (${s.type}): "template_vars" must be a JSON object.`);
+            }
+        }
+        if (s.type === 'slack_message' || s.type === 'slack') {
+            if (!s.webhook_url || typeof s.webhook_url !== 'string') {
+                error(`${where} (${s.type}): missing required field "webhook_url".`);
+            }
+            if (!SLACK_HOOK_RE.test(s.webhook_url)) {
+                error(`${where} (${s.type}): "webhook_url" must look like https://hooks.slack.com/services/T.../B.../xxx — got "${s.webhook_url}".`);
+            }
+            if (!s.text || typeof s.text !== 'string') {
+                error(`${where} (${s.type}): missing required field "text".`);
+            }
+        }
+    });
+}
 function summarizeWorkflow(w) {
     return {
         id: w.id,
@@ -60,6 +117,9 @@ export async function create(nameArg, flags) {
     if (!name || !endpointId || !flags.steps) {
         error('Missing required arguments.\nUsage: myapi workflow create <name> --endpoint-id <id> --steps <json> [--no-enable] [--org <id>]\n   or: myapi workflow create --name <name> --endpoint-id <id> --steps <json> [--no-enable] [--org <id>]');
     }
+    if (!UUID_RE.test(endpointId)) {
+        error(`Invalid --endpoint-id "${endpointId}". Expected a webhook endpoint UUID.\nList your endpoints with: myapi webhook list`);
+    }
     let steps;
     try {
         steps = JSON.parse(flags.steps);
@@ -67,6 +127,7 @@ export async function create(nameArg, flags) {
     catch {
         error('Invalid JSON for --steps');
     }
+    validateSteps(steps);
     const wf = await sdkWorkflow.createWorkflow(config.api_key, orgId, {
         name,
         trigger_config: { endpoint_id: endpointId },
@@ -89,8 +150,13 @@ export async function update(id, flags) {
     const payload = {};
     if (typeof flags.name === 'string')
         payload.name = flags.name;
-    if (typeof flags['endpoint-id'] === 'string')
-        payload.trigger_config = { endpoint_id: flags['endpoint-id'] };
+    if (typeof flags['endpoint-id'] === 'string') {
+        const eid = flags['endpoint-id'];
+        if (!UUID_RE.test(eid)) {
+            error(`Invalid --endpoint-id "${eid}". Expected a webhook endpoint UUID.\nList your endpoints with: myapi webhook list`);
+        }
+        payload.trigger_config = { endpoint_id: eid };
+    }
     if (typeof flags.steps === 'string') {
         try {
             payload.steps = JSON.parse(flags.steps);
@@ -98,6 +164,7 @@ export async function update(id, flags) {
         catch {
             error('Invalid JSON for --steps');
         }
+        validateSteps(payload.steps);
     }
     if (!payload.name && !payload.trigger_config && !payload.steps) {
         error('Nothing to update. Provide at least one of --name, --endpoint-id, --steps.');
@@ -161,18 +228,48 @@ const SUBCOMMAND_USAGE = {
 
 Either form works; the positional name is the recommended shape.
 
---steps is a JSON array of step objects. Supported step types:
-  send_email   — fields: from, to, subject, body | template_id, template_vars
-  slack        — fields: webhook_url, text
-  http         — fields: method, url, body, headers
+--steps is a JSON array of step objects. Each step has a "type" field
+plus type-specific fields. Two types are supported today:
+
+  type: "send_email"  (alias: "email")
+    Required:
+      from           Sender mailbox address (must be activated for sending)
+      to             Recipient address (templating allowed)
+      subject        Email subject (templating allowed)
+    Body — exactly one of:
+      body           Plain text body
+      html           Raw HTML body
+      template_id    UUID of an AI-generated template (myapi email template
+                     generate). Recommended for nice-looking emails.
+    Optional:
+      template_vars  JSON object of variable substitutions, only with
+                     template_id (e.g. {"name": "{{ payload.name }}"}).
+
+  type: "slack_message"  (alias: "slack")
+    Required:
+      webhook_url    https://hooks.slack.com/services/T.../B.../xxx
+                     Get one from https://api.slack.com/apps → your app →
+                     Incoming Webhooks. Other URLs are rejected.
+      text           Message text (templating allowed)
+
+Templating: any string field can reference the incoming webhook payload
+with {{ payload.field }} (whitespace optional). Example:
+  "to": "{{ payload.email }}"  →  the email field from the form submission.
+
+Unknown step types AND missing/invalid fields are rejected at create
+time — you find out about typos before any workflow run happens.
 
-Field values support {{ payload.field }} templating to reference the
-incoming webhook payload, e.g. "to": "{{ payload.email }}".
+There is NO on-failure notification mechanism today. Inspect run history
+with: myapi workflow runs <id> · myapi workflow get-run <run_id>.
 
-Example — fire on every webhook POST, send a thank-you email:
+Examples:
+  # send a thank-you email using an AI template, then ping Slack
   myapi workflow create "Contact handler" --endpoint-id <wid> --steps '[
-    {"type":"send_email","from":"hello@x.com","to":"{{ payload.email }}",
-     "subject":"Thanks!","body":"We got your message."}
+    {"type":"email","from":"hello@x.com","to":"{{ payload.email }}",
+     "subject":"Thanks!","template_id":"<tid>",
+     "template_vars":{"name":"{{ payload.name }}"}},
+    {"type":"slack","webhook_url":"https://hooks.slack.com/services/T0/B0/xxx",
+     "text":"New: {{ payload.message }}"}
   ]'
 
 See the my-workflow-api skill for the full form-to-email recipe.`,

package/dist/flags.js

@@ -16,6 +16,7 @@ export function parseFlags(argv, schema = {}) {
     const merged = { ...GLOBAL_FLAGS, ...schema };
     const args = [];
     const flags = {};
+    const unknownFlags = [];
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
         if (arg === '-h') {
@@ -44,9 +45,24 @@ export function parseFlags(argv, schema = {}) {
             }
             const type = merged[key];
             // Unknown flags: tolerate as boolean (with --key=value still honored)
-            // so additions to the schema don't silently break someone's script.
+            // so additions to the schema don't silently break someone's script —
+            // BUT also collect them and emit a stderr warning at the end of
+            // parsing. Surfaces typos and AI-agent hallucinations like
+            // `--on-error <email>` without breaking back-compat.
             if (type === undefined) {
                 flags[key] = inlineValue ?? true;
+                unknownFlags.push(`--${key}`);
+                // If no inline value and the next token doesn't look like another
+                // flag, the user almost certainly intended it as the flag's value
+                // (e.g. `--on-error someone@x.com`). Consume it so it doesn't
+                // become a stray positional arg later.
+                if (inlineValue === undefined) {
+                    const next = argv[i + 1];
+                    if (next !== undefined && !next.startsWith('--') && !next.startsWith('-h') && !next.startsWith('-v')) {
+                        flags[key] = next;
+                        i++;
+                    }
+                }
                 continue;
             }
             if (type === 'boolean') {
@@ -84,5 +100,11 @@ export function parseFlags(argv, schema = {}) {
         }
         args.push(arg);
     }
+    // Surface unknown flags so typos and hallucinated flags don't silently
+    // disappear. Don't block — the value is still in `flags` for any handler
+    // that wants it — just print one line on stderr.
+    if (unknownFlags.length > 0 && !process.env.MYAPI_QUIET_UNKNOWN_FLAGS) {
+        process.stderr.write(`› Note: ignoring unknown flag(s): ${unknownFlags.join(', ')}\n`);
+    }
     return { args, flags };
 }

package/dist/index.js

@@ -58,6 +58,9 @@ const ERROR_MESSAGES = {
     RATE_LIMITED: 'Too many requests. Please wait a moment and try again.',
     INSUFFICIENT_BALANCE: 'Insufficient balance. Run: myapi billing topup <amount>',
     INVALID_AMOUNT: 'Amount out of range. Maximum single top-up is $100. Run: myapi billing topup <amount>',
+    // invalid_json_response intentionally absent — the SDK's MyApiError now
+    // builds a useful detailed message for that case (status + URL + body
+    // snippet), and friendlyError(err.code) would override it.
 };
 function friendlyError(code) {
     return ERROR_MESSAGES[code] || code;

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

@@ -6,7 +6,7 @@ Run a chain of actions (send email, post to Slack, call an HTTP endpoint) every
 ## What it does
 
 - Bind ordered step chains to webhook endpoints
-- Steps can: send transactional email, hit Slack, call any HTTP URL
+- Steps can: send transactional email, post to Slack
 - Template values from the inbound webhook payload (`{{ payload.field }}`)
 - Per-run status tracking (attempt, error, started/finished timestamps)
 - Enable/disable without losing config

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

@@ -51,25 +51,36 @@ myapi workflow get-run <run_id>
 
 `--steps` is a JSON array of step objects. Each step has a `type` and type-specific fields.
 
+Supported step types (alias forms in parentheses):
+
+| `type` | Aliases | Required fields |
+|---|---|---|
+| `send_email` | `email` | `from`, `to`, `subject`, plus one of `body` / `html` / `template_id` |
+| `slack_message` | `slack` | `webhook_url`, `text` |
+
 ```json
 [
   {
-    "type": "send_email",
+    "type": "email",
     "from": "hello@yourdomain.com",
     "to": "{{ payload.email }}",
     "subject": "Welcome, {{ payload.name }}",
     "template_id": "<template_id>"
   },
   {
-    "type": "http",
-    "method": "POST",
-    "url": "https://crm.example.com/contacts",
-    "body": "{{ payload | json }}"
+    "type": "slack",
+    "webhook_url": "https://hooks.slack.com/services/T.../B.../xxx",
+    "text": "New submission from {{ payload.name }}"
   }
 ]
 ```
 
-The webhook payload is available as `{{ payload }}` and individual fields as `{{ payload.fieldname }}`.
+Unknown step types are rejected at workflow create time, so typos surface
+immediately instead of after 3 failed retries during execution.
+
+The webhook payload is available as `{{ payload }}` and individual fields
+as `{{ payload.fieldname }}`. Whitespace inside the braces is fine —
+both `{{ payload.email }}` and `{{payload.email}}` work.
 
 ## End-to-end recipe — react to a contact form submission
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myapihq/cli",
-  "version": "1.1.0-wip.1",
+  "version": "1.1.0-wip.3",
   "description": "MyAPI command-line interface",
   "type": "module",
   "files": [