@moxxy/cli 1.2.10 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moxxy/cli",
-  "version": "1.2.10",
+  "version": "1.3.0",
   "description": "CLI for the Moxxy agentic framework — manage agents, skills, plugins, channels, and vaults from the terminal",
   "type": "module",
   "license": "MIT",

package/src/api-client.js

@@ -256,6 +256,23 @@ export class ApiClient {
     return this.request(`/v1/agents/${encodeURIComponent(agentName)}/mcp/${encodeURIComponent(serverId)}/test`, 'POST');
   }
 
+  async listWebhooks(agentName) {
+    const payload = await this.request(`/v1/agents/${encodeURIComponent(agentName)}/webhooks`, 'GET');
+    return Array.isArray(payload) ? payload : [];
+  }
+
+  async createWebhook(agentName, config) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentName)}/webhooks`, 'POST', config);
+  }
+
+  async updateWebhook(agentName, slug, patch) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentName)}/webhooks/${encodeURIComponent(slug)}`, 'PATCH', patch);
+  }
+
+  async deleteWebhook(agentName, slug) {
+    return this.request(`/v1/agents/${encodeURIComponent(agentName)}/webhooks/${encodeURIComponent(slug)}`, 'DELETE');
+  }
+
   async listTemplates() {
     return this.request('/v1/templates', 'GET');
   }

package/src/cli.js

@@ -11,6 +11,7 @@ import { runVault } from './commands/vault.js';
 import { runHeartbeat } from './commands/heartbeat.js';
 import { runChannel } from './commands/channel.js';
 import { runMcp } from './commands/mcp.js';
+import { runWebhooks } from './commands/webhooks.js';
 import { runEvents } from './commands/events.js';
 import { runDoctor } from './commands/doctor.js';
 import { runUpdate } from './commands/update.js';
@@ -77,6 +78,10 @@ Usage:
   moxxy mcp add --agent <name> --id <id> --transport sse --url <url>
   moxxy mcp remove --agent <name> --id <id>         Remove an MCP server
   moxxy mcp test --agent <name> --id <id>           Test an MCP server
+  moxxy webhooks list --agent <name>                List webhooks for an agent
+  moxxy webhooks add --agent <name> --label <l> [--secret <s>] [--event_filter <ef>] [--body <b>]
+  moxxy webhooks update --agent <name> --slug <s> [--label <l>] [--enabled <bool>] [--event_filter <ef>] [--body <b>]
+  moxxy webhooks remove --agent <name> --slug <s>   Remove a webhook
   moxxy plugin list                                  List installed plugins
   moxxy plugin install <package>                     Install a plugin
   moxxy plugin start <name>                          Start a plugin
@@ -169,6 +174,10 @@ async function routeCommand(client, command, rest) {
     case 'mcp':
       await runMcp(client, rest);
       break;
+    case 'webhooks':
+    case 'webhook':
+      await runWebhooks(client, rest);
+      break;
     case 'plugin':
       await runPlugin(client, rest);
       break;
@@ -247,6 +256,7 @@ async function main() {
     integrations: [
       { value: 'channel',   label: 'Channel',   hint: 'manage Telegram/Discord channels' },
       { value: 'mcp',       label: 'MCP',       hint: 'manage MCP servers for agents' },
+      { value: 'webhooks',  label: 'Webhooks',  hint: 'manage inbound webhooks for agents' },
       { value: 'heartbeat', label: 'Heartbeat', hint: 'schedule heartbeat rules' },
     ],
     providers: [

package/src/commands/webhooks.js

@@ -0,0 +1,238 @@
+/**
+ * Webhook commands: list/add/update/remove.
+ */
+import { parseFlags } from './auth.js';
+import { isInteractive, handleCancel, withSpinner, showResult, pickAgent, p } from '../ui.js';
+
+function parseBool(val) {
+  if (val === undefined || val === null) return undefined;
+  const s = String(val).toLowerCase();
+  if (['true', '1', 'yes', 'on'].includes(s)) return true;
+  if (['false', '0', 'no', 'off'].includes(s)) return false;
+  return undefined;
+}
+
+export async function runWebhooks(client, args) {
+  let [action, ...rest] = args;
+  const flags = parseFlags(rest);
+
+  if (!['list', 'add', 'update', 'remove'].includes(action) && isInteractive()) {
+    action = await p.select({
+      message: 'Webhook action',
+      options: [
+        { value: 'list',   label: 'List webhooks',  hint: 'show webhooks for an agent' },
+        { value: 'add',    label: 'Add webhook',    hint: 'register a new inbound webhook' },
+        { value: 'update', label: 'Update webhook', hint: 'change label/body/filter/enabled' },
+        { value: 'remove', label: 'Remove webhook', hint: 'delete an inbound webhook' },
+      ],
+    });
+    handleCancel(action);
+  }
+
+  switch (action) {
+    case 'list': {
+      let agentName = flags.agent;
+      if (!agentName && isInteractive()) {
+        agentName = await pickAgent(client, 'Select agent');
+      }
+      if (!agentName) throw new Error('Required: --agent');
+
+      const webhooks = isInteractive()
+        ? await withSpinner('Fetching webhooks...', () =>
+            client.listWebhooks(agentName), 'Webhooks loaded.')
+        : await client.listWebhooks(agentName);
+
+      if (isInteractive()) {
+        if (Array.isArray(webhooks) && webhooks.length > 0) {
+          for (const w of webhooks) {
+            const state = w.enabled ? 'enabled' : 'disabled';
+            const filter = w.event_filter ? ` filter=${w.event_filter}` : '';
+            p.log.info(`  ${w.slug}  [${state}]${filter}  ${w.url}`);
+          }
+        } else {
+          p.log.warn('No webhooks configured for this agent.');
+        }
+      } else {
+        console.log(JSON.stringify(webhooks, null, 2));
+      }
+      return webhooks;
+    }
+
+    case 'add': {
+      let agentName = flags.agent;
+      let label = flags.label;
+
+      if ((!agentName || !label) && isInteractive()) {
+        if (!agentName) {
+          agentName = await pickAgent(client, 'Select agent for webhook');
+        }
+
+        if (!label) {
+          label = handleCancel(await p.text({
+            message: 'Webhook label',
+            placeholder: 'GitHub Push Events',
+            validate: (val) => { if (!val) return 'Label is required'; },
+          }));
+        }
+
+        const body = { label };
+
+        const secret = flags.secret || handleCancel(await p.text({
+          message: 'HMAC secret (optional, leave empty for token-only)',
+          placeholder: '',
+        }));
+        if (secret) body.secret = secret;
+
+        const eventFilter = flags.event_filter || handleCancel(await p.text({
+          message: 'Event filter (optional, comma-separated)',
+          placeholder: 'push,pull_request',
+        }));
+        if (eventFilter) body.event_filter = eventFilter;
+
+        const taskBody = flags.body || handleCancel(await p.text({
+          message: 'Task instructions (optional markdown with {{placeholders}})',
+          placeholder: 'Parse commits from {{body.commits}}...',
+        }));
+        if (taskBody) body.body = taskBody;
+
+        const result = await withSpinner('Creating webhook...', () =>
+          client.createWebhook(agentName, body), 'Webhook created.');
+
+        showResult('Webhook Created', {
+          Agent: agentName,
+          Label: label,
+          Slug: result.slug,
+          URL: result.url,
+          Token: result.token,
+        });
+
+        return result;
+      }
+
+      if (!agentName || !label) {
+        throw new Error('Required: --agent, --label');
+      }
+
+      const body = { label };
+      if (flags.secret) body.secret = flags.secret;
+      if (flags.event_filter) body.event_filter = flags.event_filter;
+      if (flags.body) body.body = flags.body;
+
+      const result = await client.createWebhook(agentName, body);
+      console.log(JSON.stringify(result, null, 2));
+      return result;
+    }
+
+    case 'update': {
+      let agentName = flags.agent;
+      let slug = flags.slug;
+
+      if ((!agentName || !slug) && isInteractive()) {
+        if (!agentName) {
+          agentName = await pickAgent(client, 'Select agent');
+        }
+
+        if (!slug) {
+          const webhooks = await withSpinner('Fetching webhooks...', () =>
+            client.listWebhooks(agentName), 'Webhooks loaded.');
+          if (!Array.isArray(webhooks) || webhooks.length === 0) {
+            p.log.warn('No webhooks to update.');
+            return;
+          }
+          slug = handleCancel(await p.select({
+            message: 'Select webhook to update',
+            options: webhooks.map(w => ({
+              value: w.slug,
+              label: w.label,
+              hint: w.enabled ? 'enabled' : 'disabled',
+            })),
+          }));
+        }
+      }
+
+      if (!agentName || !slug) throw new Error('Required: --agent, --slug');
+
+      const patch = {};
+      if (flags.label !== undefined) patch.label = flags.label;
+      if (flags.event_filter !== undefined) patch.event_filter = flags.event_filter;
+      if (flags.body !== undefined) patch.body = flags.body;
+      const enabled = parseBool(flags.enabled);
+      if (enabled !== undefined) patch.enabled = enabled;
+
+      if (Object.keys(patch).length === 0) {
+        throw new Error('Nothing to update. Pass at least one of: --label, --event_filter, --body, --enabled');
+      }
+
+      const result = isInteractive()
+        ? await withSpinner('Updating webhook...', () =>
+            client.updateWebhook(agentName, slug, patch), 'Webhook updated.')
+        : await client.updateWebhook(agentName, slug, patch);
+
+      if (isInteractive()) {
+        showResult('Webhook Updated', {
+          Agent: agentName,
+          Slug: result.slug,
+          Label: result.label,
+          Enabled: String(result.enabled),
+        });
+      } else {
+        console.log(JSON.stringify(result, null, 2));
+      }
+      return result;
+    }
+
+    case 'remove': {
+      let agentName = flags.agent;
+      let slug = flags.slug;
+
+      if ((!agentName || !slug) && isInteractive()) {
+        if (!agentName) {
+          agentName = await pickAgent(client, 'Select agent');
+        }
+
+        if (!slug) {
+          const webhooks = await withSpinner('Fetching webhooks...', () =>
+            client.listWebhooks(agentName), 'Webhooks loaded.');
+          if (!Array.isArray(webhooks) || webhooks.length === 0) {
+            p.log.warn('No webhooks to remove.');
+            return;
+          }
+          slug = handleCancel(await p.select({
+            message: 'Select webhook to remove',
+            options: webhooks.map(w => ({
+              value: w.slug,
+              label: w.label,
+              hint: w.enabled ? 'enabled' : 'disabled',
+            })),
+          }));
+        }
+
+        const confirmed = await p.confirm({
+          message: `Remove webhook "${slug}"?`,
+          initialValue: false,
+        });
+        handleCancel(confirmed);
+        if (!confirmed) {
+          p.log.info('Cancelled.');
+          return;
+        }
+
+        await withSpinner('Removing webhook...', () =>
+          client.deleteWebhook(agentName, slug), 'Webhook removed.');
+        return;
+      }
+
+      if (!agentName || !slug) throw new Error('Required: --agent, --slug');
+
+      await client.deleteWebhook(agentName, slug);
+      console.log(`Webhook ${slug} removed.`);
+      break;
+    }
+
+    default: {
+      const { showHelp } = await import('../help.js');
+      showHelp('webhooks', p);
+      break;
+    }
+  }
+}

package/src/help.js

@@ -339,6 +339,33 @@ Examples:
   moxxy mcp remove --agent my-agent --id fs-server
   moxxy mcp test --agent my-agent --id fs-server`,
 
+  webhooks: `Usage: moxxy webhooks <action> [options]
+
+Manage inbound webhooks for agents. External services POST JSON to the
+returned URL; the webhook body (with {{placeholder}} variables) becomes the
+agent's task when the webhook fires.
+
+Actions:
+  list      List webhooks for an agent
+  add       Register a new inbound webhook
+  update    Update a webhook's label, body, filter, or enabled flag
+  remove    Delete a webhook
+
+Options:
+  --agent <name>           Agent name
+  --label <label>          Webhook label (add/update)
+  --slug <slug>             Webhook slug (update/remove; derived from label)
+  --secret <secret>         Optional HMAC-SHA256 secret (add)
+  --event_filter <csv>      Comma-separated event filter (add/update)
+  --body <markdown>         Task instructions with {{placeholders}} (add/update)
+  --enabled <bool>          Enable/disable flag (update)
+
+Examples:
+  moxxy webhooks list --agent my-agent
+  moxxy webhooks add --agent my-agent --label "GitHub Push" --secret s3cret --event_filter push
+  moxxy webhooks update --agent my-agent --slug github-push --enabled false
+  moxxy webhooks remove --agent my-agent --slug github-push`,
+
   plugin: `Usage: moxxy plugin <action> [options]
 
 Manage CLI plugins that extend Moxxy functionality.