@modelriver/cli 1.0.0 → 1.2.0

package/README.md

@@ -54,6 +54,7 @@ For convenience, the CLI supports short aliases:
 | `forward` | `f` | Forward using saved config |
 | `trigger` | `t` | Send async request |
 | `websocket` | `ws` | Test WebSocket connection |
+| `test-webhook` | - | Test webhook delivery end-to-end |
 
 Example:
 ```bash
@@ -257,6 +258,33 @@ Channel Details
 > Or use "modelriver websocket" to connect and receive responses
 ```
 
+### `modelriver test-webhook` - Test Webhook Delivery End-to-End
+
+Test the complete webhook flow - creates a webhook, makes an async request, and waits for the webhook response:
+
+```bash
+# Start local server and test webhook delivery
+modelriver test-webhook --workflow my-workflow --message "Test"
+
+# Use custom webhook URL (e.g., your local server or webhook.site)
+modelriver test-webhook --workflow my-workflow --message "Test" --webhook-url http://localhost:4000/webhook/modelriver
+
+# With custom secret and port
+modelriver test-webhook --workflow my-workflow --message "Test" --port 3002 --secret my-secret
+
+# Verbose output
+modelriver test-webhook --workflow my-workflow --message "Test" --verbose
+```
+
+**Options:**
+- `-w, --workflow <name>` - Workflow name (required)
+- `-m, --message <text>` - Test message
+- `-P, --payload <json>` - Custom JSON payload
+- `-u, --webhook-url <url>` - Webhook URL (starts local server on --port if not provided)
+- `-s, --secret <secret>` - Webhook secret (auto-generated if not provided)
+- `-p, --port <port>` - Local server port (default: 3001)
+- `-v, --verbose` - Verbose output
+
 ### `modelriver webhook list` - List Webhooks
 
 List all webhooks for your project.
@@ -375,12 +403,16 @@ Set the API key via:
 
 The CLI uses these ModelRiver API endpoints:
 
-- `POST /v1/ai/async` - Create async request (production)
-- `POST /api/v1/ai/async` - Create async request (dev/test)
-- `POST /v1/ai/reconnect` - Get reconnect token (production)
-- `POST /api/v1/ai/reconnect` - Get reconnect token (dev/test)
-- `GET /v1/webhooks` - List webhooks (production)
-- `GET /api/v1/webhooks` - List webhooks (dev/test)
+**Production** (`https://api.modelriver.com`):
+- `POST /v1/ai/async` - Create async AI request
+- `POST /v1/ai/reconnect` - Get reconnect token for existing channel
+- `GET /v1/webhooks` - List all webhooks
+- `POST /v1/webhooks` - Create a new webhook
+- `DELETE /v1/webhooks/:id` - Delete a webhook
+- `POST /v1/cli/connect` - Connect CLI and get WebSocket token
+
+**Development** (localhost or custom API URL):
+- Same endpoints but with `/api/v1` prefix instead of `/v1`
 
 ## Development
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelriver/cli",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "ModelRiver CLI for testing webhooks and WebSockets from production",
   "main": "src/index.js",
   "bin": {

package/src/commands/forward.js

@@ -52,6 +52,7 @@ async function forwardCommand(options) {
         apiKey,
         apiUrl: config.getApiUrl(),
         port: targetPort,
+        forwardUrl: forwardUrl,
         forward: true,
         print: true,
         verbose

package/src/commands/listen.js

@@ -4,9 +4,10 @@ const CLIWebSocketClient = require('../lib/cli-websocket-client');
 const WebhookVerifier = require('../lib/webhook-verifier');
 const Logger = require('../utils/logger');
 const Formatter = require('../utils/formatter');
+const { parseForwardUrl } = require('../utils/url-helpers');
 
 async function listenCommand(options) {
-  let { apiKey, apiUrl, print, port, verbose, forward } = options;
+  let { apiKey, apiUrl, print, port, verbose, forward, forwardUrl } = options;
   const forwardOnly = forward === true;
 
   const spinner = Logger.spinner('Setting up webhook forwarding...');
@@ -206,16 +207,25 @@ async function listenCommand(options) {
 
       // Forward to local server
       const http = require('http');
+      const https = require('https');
       const postData = JSON.stringify({
         channel_id,
         timestamp,
         data
       });
 
-      const options = {
+      // Parse the forward URL or use localhost defaults
+      const parsedUrl = parseForwardUrl(forwardUrl) || {
         hostname: 'localhost',
         port: localPort,
-        path: '/webhook',
+        path: '/webhook/modelriver',
+        protocol: 'http'
+      };
+
+      const options = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port,
+        path: parsedUrl.path,
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
@@ -226,15 +236,19 @@ async function listenCommand(options) {
         }
       };
 
-      const req = http.request(options, (res) => {
+      // Use https or http based on protocol
+      const requestModule = parsedUrl.protocol === 'https' ? https : http;
+      const targetUrl = `${parsedUrl.protocol}://${parsedUrl.hostname}:${parsedUrl.port}${parsedUrl.path}`;
+
+      const req = requestModule.request(options, (res) => {
         // Webhook forwarded successfully
         if (print) {
-          Logger.info(`  → Forwarded to local server (status: ${res.statusCode})`);
+          Logger.info(`  → Forwarded to ${targetUrl} (status: ${res.statusCode})`);
         }
       });
 
       req.on('error', (error) => {
-        Logger.error(`Failed to forward webhook to local server: ${error.message}`);
+        Logger.error(`Failed to forward webhook to ${targetUrl}: ${error.message}`);
       });
 
       req.write(postData);

package/src/index.js

@@ -15,7 +15,7 @@ const program = new Command();
 program
   .name('modelriver')
   .description('ModelRiver CLI for testing webhooks and WebSockets from production')
-  .version('1.0.0');
+  .version('1.1.0');
 
 // Global options
 program

package/src/utils/url-helpers.js

@@ -91,8 +91,29 @@ function isValidApiKeyFormat(apiKey) {
     return apiKey.startsWith('mr_live_') || apiKey.startsWith('mr_test_');
 }
 
+/**
+ * Parse a forward URL into its components
+ * @param {string} url - The URL to parse
+ * @returns {object|null} - Object with hostname, port, path, protocol or null if invalid
+ */
+function parseForwardUrl(url) {
+    if (!url) return null;
+    try {
+        const urlObj = new URL(url);
+        return {
+            hostname: urlObj.hostname,
+            port: parseInt(urlObj.port, 10) || (urlObj.protocol === 'https:' ? 443 : 80),
+            path: urlObj.pathname || '/webhook/modelriver',
+            protocol: urlObj.protocol.replace(':', '')
+        };
+    } catch (error) {
+        return null;
+    }
+}
+
 module.exports = {
     normalizeWebhookUrl,
     extractPort,
-    isValidApiKeyFormat
+    isValidApiKeyFormat,
+    parseForwardUrl
 };

package/src/utils/url-helpers.test.js

@@ -1,5 +1,5 @@
 // Tests for URL helper utilities
-const { normalizeWebhookUrl, extractPort, isValidApiKeyFormat } = require('./url-helpers');
+const { normalizeWebhookUrl, extractPort, isValidApiKeyFormat, parseForwardUrl } = require('./url-helpers');
 
 describe('URL Helpers', () => {
     describe('normalizeWebhookUrl', () => {
@@ -81,4 +81,54 @@ describe('URL Helpers', () => {
             expect(isValidApiKeyFormat(undefined)).toBe(false);
         });
     });
+
+    describe('parseForwardUrl', () => {
+        it('should parse localhost URL with port', () => {
+            const result = parseForwardUrl('http://localhost:4000/webhook/modelriver');
+            expect(result).toEqual({
+                hostname: 'localhost',
+                port: 4000,
+                path: '/webhook/modelriver',
+                protocol: 'http'
+            });
+        });
+
+        it('should parse external URL with port', () => {
+            const result = parseForwardUrl('http://myserver.com:3001/webhook/modelriver');
+            expect(result).toEqual({
+                hostname: 'myserver.com',
+                port: 3001,
+                path: '/webhook/modelriver',
+                protocol: 'http'
+            });
+        });
+
+        it('should default to port 80 for http without explicit port', () => {
+            const result = parseForwardUrl('http://example.com/webhook/modelriver');
+            expect(result.port).toBe(80);
+            expect(result.hostname).toBe('example.com');
+        });
+
+        it('should default to port 443 for https without explicit port', () => {
+            const result = parseForwardUrl('https://example.com/webhook/modelriver');
+            expect(result.port).toBe(443);
+            expect(result.protocol).toBe('https');
+        });
+
+        it('should handle URLs with different paths', () => {
+            const result = parseForwardUrl('http://localhost:5000/custom/path');
+            expect(result.path).toBe('/custom/path');
+        });
+
+        it('should return null for empty or falsy input', () => {
+            expect(parseForwardUrl('')).toBeNull();
+            expect(parseForwardUrl(null)).toBeNull();
+            expect(parseForwardUrl(undefined)).toBeNull();
+        });
+
+        it('should return null for invalid URLs', () => {
+            expect(parseForwardUrl('not-a-url')).toBeNull();
+            expect(parseForwardUrl('just-text')).toBeNull();
+        });
+    });
 });