@modelriver/cli 1.0.0

package/src/lib/websocket-client.js

@@ -0,0 +1,225 @@
+const WebSocket = require('ws');
+
+class WebSocketClient {
+  constructor(websocketUrl, token, verbose = false) {
+    this.websocketUrl = websocketUrl;
+    this.token = token;
+    this.verbose = verbose;
+    this.ws = null;
+    this.channel = null;
+    this.listeners = {};
+    this.heartbeatInterval = null;
+    this.heartbeatRef = 0;
+  }
+
+  /**
+   * Connect to WebSocket
+   * @returns {Promise<void>}
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      const url = `${this.websocketUrl}/websocket?token=${encodeURIComponent(this.token)}`;
+
+      this.ws = new WebSocket(url);
+
+      this.ws.on('open', () => {
+        // Start sending heartbeats every 30 seconds (Phoenix default is 30s)
+        this.startHeartbeat();
+        resolve();
+      });
+
+      this.ws.on('error', (error) => {
+        this.stopHeartbeat();
+        reject(error);
+      });
+
+      this.ws.on('message', (data) => {
+        this.handleMessage(data);
+      });
+
+      this.ws.on('close', () => {
+        this.stopHeartbeat();
+        if (this.listeners.close) {
+          this.listeners.close();
+        }
+      });
+    });
+  }
+
+  /**
+   * Start sending Phoenix heartbeats
+   */
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.heartbeatRef++;
+        const heartbeat = JSON.stringify({
+          topic: 'phoenix',
+          event: 'heartbeat',
+          payload: {},
+          ref: `heartbeat-${this.heartbeatRef}`
+        });
+        this.ws.send(heartbeat);
+      }
+    }, 30000); // Every 30 seconds
+  }
+
+  /**
+   * Stop sending heartbeats
+   */
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+
+
+  /**
+   * Join a Phoenix channel
+   * @param {string} channelName - Channel name (e.g., "ai_response:project_id:channel_id")
+   * @returns {Promise<object>} - Join response
+   */
+  joinChannel(channelName) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        reject(new Error('WebSocket is not connected'));
+        return;
+      }
+
+      const joinRef = '1';
+      
+      const joinMsg = JSON.stringify({
+        topic: channelName,
+        event: 'phx_join',
+        payload: {},
+        ref: joinRef
+      });
+
+      let resolved = false;
+
+      // Set up a temporary listener for the join response
+      // This will process the response and then be removed
+      const handleJoinResponse = (data) => {
+        if (resolved) return;
+
+        try {
+          const msg = JSON.parse(data.toString());
+          // Look for the join response (phx_reply with our ref)
+          if (msg.event === 'phx_reply' && msg.ref === joinRef && msg.topic === channelName) {
+            resolved = true;
+            // Remove this listener - handleMessage() will continue processing other messages
+            this.ws.removeListener('message', handleJoinResponse);
+            
+            if (msg.payload.status === 'ok') {
+              this.channel = channelName;
+              resolve(msg.payload);
+            } else {
+              reject(new Error(`Failed to join channel: ${msg.payload.response || 'Unknown error'}`));
+            }
+          }
+        } catch (error) {
+          // Ignore parse errors, wait for next message
+        }
+      };
+
+      // Add listener for join response
+      // The handleMessage() listener in connect() will also be called, but won't match
+      this.ws.on('message', handleJoinResponse);
+      
+      this.ws.send(joinMsg);
+
+      // Timeout after 10 seconds
+      setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          this.ws.removeListener('message', handleJoinResponse);
+          reject(new Error('Channel join timeout'));
+        }
+      }, 10000);
+    });
+  }
+
+  /**
+   * Handle incoming WebSocket messages
+   * @param {Buffer} data - Message data
+   */
+  handleMessage(data) {
+    try {
+      const msgStr = data.toString();
+      const msg = JSON.parse(msgStr);
+
+      const Logger = require('../utils/logger'); // Lazy load to avoid circular dependency if any
+
+      // Log all events for debugging purposes (except heartbeats and phx_reply unless verbose)
+      if (this.verbose) {
+        // In verbose mode, log ALL messages including raw JSON
+        if (msg.event !== 'heartbeat') {
+          Logger.info(`\n📨 Received WebSocket message:`);
+          Logger.info(`   Event: ${msg.event}`);
+          Logger.info(`   Topic: ${msg.topic}`);
+          Logger.info(`   Payload keys: ${msg.payload ? Object.keys(msg.payload).join(', ') : 'none'}`);
+          if (msg.event === 'response') {
+            Logger.info(`   ✅ This is a RESPONSE event!`);
+          }
+        }
+      } else {
+        // In non-verbose mode, only log non-standard events
+        if (msg.event !== 'phx_reply' && msg.event !== 'heartbeat' && msg.event !== 'response') {
+          Logger.info(`received event: ${msg.event} on topic: ${msg.topic}`);
+        }
+      }
+
+      // Handle response events
+      if (msg.event === 'response') {
+        if (this.verbose) {
+          Logger.info(`\n✅ Processing response event...`);
+        }
+        if (this.listeners.response) {
+          this.listeners.response(msg.payload);
+        } else if (this.verbose) {
+          Logger.warning(`⚠️  Response event received but no listener registered!`);
+        }
+      } else if (msg.event === 'phx_reply') {
+        // Handle join responses
+        if (this.listeners.join) {
+          this.listeners.join(msg);
+        }
+      }
+    } catch (error) {
+      // Log parse errors in verbose mode
+      if (this.verbose) {
+        const Logger = require('../utils/logger');
+        Logger.warning(`Failed to parse WebSocket message: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Listen for response events
+   * @param {Function} callback - Callback function
+   */
+  onResponse(callback) {
+    this.listeners.response = callback;
+  }
+
+  /**
+   * Listen for close events
+   * @param {Function} callback - Callback function
+   */
+  onClose(callback) {
+    this.listeners.close = callback;
+  }
+
+  /**
+   * Close WebSocket connection
+   */
+  close() {
+    if (this.ws) {
+      this.ws.close();
+    }
+  }
+}
+
+module.exports = WebSocketClient;
+

package/src/utils/formatter.js

@@ -0,0 +1,43 @@
+class Formatter {
+  static json(data, indent = 2) {
+    return JSON.stringify(data, null, indent);
+  }
+
+  static table(headers, rows) {
+    // Simple table formatter
+    const maxWidths = headers.map((header, i) => {
+      const headerWidth = header.length;
+      const maxRowWidth = Math.max(
+        ...rows.map(row => String(row[i] || '').length)
+      );
+      return Math.max(headerWidth, maxRowWidth);
+    });
+
+    const formatRow = (row) => {
+      return row.map((cell, i) => {
+        const str = String(cell || '');
+        return str.padEnd(maxWidths[i]);
+      }).join('  ');
+    };
+
+    const headerRow = formatRow(headers);
+    const separator = headers.map((_, i) => '─'.repeat(maxWidths[i])).join('  ');
+    const dataRows = rows.map(formatRow);
+
+    return [headerRow, separator, ...dataRows].join('\n');
+  }
+
+  static timestamp(date = new Date()) {
+    return date.toISOString();
+  }
+
+  static formatDuration(ms) {
+    if (ms < 1000) return `${ms}ms`;
+    if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+    return `${(ms / 60000).toFixed(1)}m`;
+  }
+}
+
+module.exports = Formatter;
+
+

package/src/utils/formatter.test.js

@@ -0,0 +1,84 @@
+const Formatter = require('./formatter');
+
+describe('Formatter', () => {
+    describe('json', () => {
+        it('should format objects with default 2-space indentation', () => {
+            const obj = { name: 'test', value: 123 };
+            const result = Formatter.json(obj);
+
+            expect(result).toBe('{\n  "name": "test",\n  "value": 123\n}');
+        });
+
+        it('should format with custom indentation', () => {
+            const obj = { key: 'value' };
+            const result = Formatter.json(obj, 4);
+
+            expect(result).toBe('{\n    "key": "value"\n}');
+        });
+
+        it('should handle arrays', () => {
+            const arr = [1, 2, 3];
+            const result = Formatter.json(arr);
+
+            expect(result).toBe('[\n  1,\n  2,\n  3\n]');
+        });
+    });
+
+    describe('timestamp', () => {
+        it('should return ISO format string', () => {
+            const date = new Date('2024-01-09T12:00:00Z');
+            const result = Formatter.timestamp(date);
+
+            expect(result).toBe('2024-01-09T12:00:00.000Z');
+        });
+
+        it('should use current date when no argument provided', () => {
+            const result = Formatter.timestamp();
+
+            expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+        });
+    });
+
+    describe('formatDuration', () => {
+        it('should format milliseconds', () => {
+            expect(Formatter.formatDuration(500)).toBe('500ms');
+            expect(Formatter.formatDuration(999)).toBe('999ms');
+        });
+
+        it('should format seconds', () => {
+            expect(Formatter.formatDuration(1000)).toBe('1.0s');
+            expect(Formatter.formatDuration(5500)).toBe('5.5s');
+            expect(Formatter.formatDuration(59999)).toBe('60.0s');
+        });
+
+        it('should format minutes', () => {
+            expect(Formatter.formatDuration(60000)).toBe('1.0m');
+            expect(Formatter.formatDuration(90000)).toBe('1.5m');
+            expect(Formatter.formatDuration(300000)).toBe('5.0m');
+        });
+    });
+
+    describe('table', () => {
+        it('should format a simple table', () => {
+            const headers = ['Name', 'Age'];
+            const rows = [
+                ['Alice', 30],
+                ['Bob', 25]
+            ];
+            const result = Formatter.table(headers, rows);
+
+            expect(result).toContain('Name');
+            expect(result).toContain('Age');
+            expect(result).toContain('Alice');
+            expect(result).toContain('Bob');
+        });
+
+        it('should handle empty cells', () => {
+            const headers = ['A', 'B'];
+            const rows = [['value', null]];
+            const result = Formatter.table(headers, rows);
+
+            expect(result).toContain('value');
+        });
+    });
+});

package/src/utils/logger.js

@@ -0,0 +1,39 @@
+const chalk = require('chalk');
+const ora = require('ora');
+
+class Logger {
+  static success(message) {
+    console.log(chalk.green(`✓ ${message}`));
+  }
+
+  static error(message) {
+    console.error(chalk.red(`✗ ${message}`));
+  }
+
+  static info(message) {
+    console.log(chalk.blue(`ℹ ${message}`));
+  }
+
+  static warning(message) {
+    console.log(chalk.yellow(`⚠ ${message}`));
+  }
+
+  static log(message) {
+    console.log(message);
+  }
+
+  static spinner(message) {
+    // Handle both CommonJS and ESM exports
+    const oraInstance = typeof ora === 'function' ? ora : (ora.default || ora);
+    return oraInstance(message);
+  }
+
+  static section(title) {
+    console.log(chalk.cyan.bold(`\n${title}`));
+    console.log(chalk.gray('─'.repeat(title.length)));
+  }
+}
+
+module.exports = Logger;
+
+

package/src/utils/url-helpers.js

@@ -0,0 +1,98 @@
+/**
+ * URL helper utilities for ModelRiver CLI
+ */
+
+/**
+ * Normalize a webhook URL to ensure it ends with /webhook/modelriver
+ * @param {string} url - The input URL
+ * @returns {string} - Normalized URL with /webhook/modelriver path
+ */
+function normalizeWebhookUrl(url) {
+    if (!url) return url;
+
+    try {
+        const urlObj = new URL(url);
+        let pathname = urlObj.pathname;
+
+        // Remove trailing slash
+        pathname = pathname.replace(/\/$/, '');
+
+        // Normalize the path to end with /webhook/modelriver
+        if (!pathname || pathname === '') {
+            pathname = '/webhook/modelriver';
+        } else if (pathname === '/webhook' || pathname === '/webhook/') {
+            pathname = '/webhook/modelriver';
+        } else if (!pathname.endsWith('/webhook/modelriver')) {
+            // If path doesn't already end with /webhook/modelriver
+            if (pathname.endsWith('/modelriver')) {
+                // Already has /modelriver, check if it has /webhook before it
+                if (!pathname.includes('/webhook/modelriver')) {
+                    pathname = '/webhook/modelriver';
+                }
+            } else if (!pathname.includes('/webhook')) {
+                // No /webhook in path at all, append /webhook/modelriver
+                pathname = pathname + '/webhook/modelriver';
+            } else {
+                // Has /webhook but not /modelriver, append /modelriver
+                if (pathname.endsWith('/webhook')) {
+                    pathname = pathname + '/modelriver';
+                }
+            }
+        }
+
+        urlObj.pathname = pathname;
+        return urlObj.toString().replace(/\/$/, '');
+    } catch (error) {
+        // If URL parsing fails, try simple string manipulation
+        let result = url.replace(/\/$/, '');
+        if (!result.includes('/webhook/modelriver')) {
+            if (result.endsWith('/webhook')) {
+                result += '/modelriver';
+            } else {
+                result += '/webhook/modelriver';
+            }
+        }
+        return result;
+    }
+}
+
+/**
+ * Extract port from a URL
+ * @param {string} url - The URL to extract port from
+ * @returns {number|null} - Port number or null if not found
+ */
+function extractPort(url) {
+    try {
+        const urlObj = new URL(url);
+        if (urlObj.port) {
+            return parseInt(urlObj.port, 10);
+        }
+        // Return default port based on protocol
+        if (urlObj.protocol === 'https:') return 443;
+        if (urlObj.protocol === 'http:') return 80;
+        return null;
+    } catch (error) {
+        // Try regex for URLs without protocol
+        const match = url.match(/:(\d+)/);
+        if (match) {
+            return parseInt(match[1], 10);
+        }
+        return null;
+    }
+}
+
+/**
+ * Validate API key format
+ * @param {string} apiKey - The API key to validate
+ * @returns {boolean} - True if valid format
+ */
+function isValidApiKeyFormat(apiKey) {
+    if (!apiKey || typeof apiKey !== 'string') return false;
+    return apiKey.startsWith('mr_live_') || apiKey.startsWith('mr_test_');
+}
+
+module.exports = {
+    normalizeWebhookUrl,
+    extractPort,
+    isValidApiKeyFormat
+};

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

@@ -0,0 +1,84 @@
+// Tests for URL helper utilities
+const { normalizeWebhookUrl, extractPort, isValidApiKeyFormat } = require('./url-helpers');
+
+describe('URL Helpers', () => {
+    describe('normalizeWebhookUrl', () => {
+        it('should add /webhook/modelriver to base URL', () => {
+            expect(normalizeWebhookUrl('http://localhost:4000'))
+                .toBe('http://localhost:4000/webhook/modelriver');
+        });
+
+        it('should add /modelriver to URL ending with /webhook', () => {
+            expect(normalizeWebhookUrl('http://localhost:4000/webhook'))
+                .toBe('http://localhost:4000/webhook/modelriver');
+        });
+
+        it('should not modify URL already ending with /webhook/modelriver', () => {
+            expect(normalizeWebhookUrl('http://localhost:4000/webhook/modelriver'))
+                .toBe('http://localhost:4000/webhook/modelriver');
+        });
+
+        it('should handle trailing slashes', () => {
+            expect(normalizeWebhookUrl('http://localhost:4000/'))
+                .toBe('http://localhost:4000/webhook/modelriver');
+        });
+
+        it('should handle URLs with port', () => {
+            expect(normalizeWebhookUrl('http://localhost:3001'))
+                .toBe('http://localhost:3001/webhook/modelriver');
+        });
+
+        it('should handle https URLs', () => {
+            expect(normalizeWebhookUrl('https://myserver.com'))
+                .toBe('https://myserver.com/webhook/modelriver');
+        });
+
+        it('should return empty for falsy input', () => {
+            expect(normalizeWebhookUrl('')).toBeFalsy();
+            expect(normalizeWebhookUrl(null)).toBeFalsy();
+            expect(normalizeWebhookUrl(undefined)).toBeFalsy();
+        });
+    });
+
+    describe('extractPort', () => {
+        it('should extract port from URL with explicit port', () => {
+            expect(extractPort('http://localhost:4000')).toBe(4000);
+            expect(extractPort('http://localhost:3001/webhook')).toBe(3001);
+        });
+
+        it('should return 80 for http without port', () => {
+            expect(extractPort('http://example.com')).toBe(80);
+        });
+
+        it('should return 443 for https without port', () => {
+            expect(extractPort('https://example.com')).toBe(443);
+        });
+
+        it('should return null for invalid URLs', () => {
+            expect(extractPort('not-a-url')).toBeNull();
+            expect(extractPort('')).toBeNull();
+        });
+    });
+
+    describe('isValidApiKeyFormat', () => {
+        it('should accept mr_live_ prefixed keys', () => {
+            expect(isValidApiKeyFormat('mr_live_abc123xyz')).toBe(true);
+        });
+
+        it('should accept mr_test_ prefixed keys', () => {
+            expect(isValidApiKeyFormat('mr_test_abc123xyz')).toBe(true);
+        });
+
+        it('should reject keys without valid prefix', () => {
+            expect(isValidApiKeyFormat('invalid_key')).toBe(false);
+            expect(isValidApiKeyFormat('mr_invalid_key')).toBe(false);
+            expect(isValidApiKeyFormat('abc123')).toBe(false);
+        });
+
+        it('should reject empty or falsy keys', () => {
+            expect(isValidApiKeyFormat('')).toBe(false);
+            expect(isValidApiKeyFormat(null)).toBe(false);
+            expect(isValidApiKeyFormat(undefined)).toBe(false);
+        });
+    });
+});