@modelriver/cli 1.1.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelriver/cli",
-  "version": "1.1.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/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();
+        });
+    });
 });