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

package/dist/commands/funnel.js

@@ -108,13 +108,27 @@ 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>)`);
         }
     }
 }
@@ -149,6 +163,11 @@ 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

package/dist/commands/workflow.js

@@ -13,16 +13,56 @@ export const SCHEMA = {
 // 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(`step ${i}: must be a JSON object.`);
+            error(`${where}: must be a JSON object.`);
         if (!s.type)
-            error(`step ${i}: missing required field "type". Supported: ${SUPPORTED_STEP_TYPES.join(', ')}`);
+            error(`${where}: missing required field "type". Supported: ${SUPPORTED_STEP_TYPES.join(', ')}`);
         if (!SUPPORTED_STEP_TYPES.includes(s.type)) {
-            error(`step ${i}: unknown type "${s.type}". Supported: ${SUPPORTED_STEP_TYPES.join(', ')}`);
+            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".`);
+            }
         }
     });
 }
@@ -77,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);
@@ -107,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);
@@ -180,19 +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 | email   — fields: from, to, subject, body | template_id, template_vars
-  slack_message | slack — fields: webhook_url, text
+--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.
 
-Either alias works (e.g. type: "email" and type: "send_email" both run
-the same step). Field values support {{ payload.field }} templating to
-reference the incoming webhook payload, e.g. "to": "{{ payload.email }}".
-Unknown step types are rejected at create time, not at execute time.
+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/package.json

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