@modelriver/cli 1.0.0

package/src/lib/cli-websocket-client.js

@@ -0,0 +1,249 @@
+const WebSocket = require('ws');
+
+class CLIWebSocketClient {
+  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;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 5;
+    this.reconnectDelay = 1000; // Start with 1 second
+  }
+
+  /**
+   * Connect to WebSocket
+   * @returns {Promise<void>}
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      // Phoenix WebSocket endpoint requires /websocket suffix for raw WebSocket connections
+      let wsUrl = this.websocketUrl;
+      if (!wsUrl.endsWith('/websocket')) {
+        wsUrl = wsUrl.replace(/\/?$/, '/websocket');
+      }
+      const url = `${wsUrl}?token=${encodeURIComponent(this.token)}`;
+
+      if (this.verbose) {
+        const Logger = require('../utils/logger');
+        Logger.info(`Connecting to WebSocket: ${url.replace(this.token, 'TOKEN')}`);
+      }
+
+      this.ws = new WebSocket(url);
+
+      this.ws.on('open', () => {
+        this.reconnectAttempts = 0;
+        this.reconnectDelay = 1000;
+        this.startHeartbeat();
+        resolve();
+      });
+
+      this.ws.on('error', (error) => {
+        this.stopHeartbeat();
+        if (this.reconnectAttempts === 0) {
+          reject(error);
+        }
+      });
+
+      this.ws.on('message', (data) => {
+        this.handleMessage(data);
+      });
+
+      this.ws.on('close', (code, reason) => {
+        this.stopHeartbeat();
+        if (this.listeners.close) {
+          this.listeners.close(code, reason);
+        }
+        // Attempt reconnection if not intentional close
+        if (code !== 1000 && this.reconnectAttempts < this.maxReconnectAttempts) {
+          this.attemptReconnect();
+        }
+      });
+    });
+  }
+
+  /**
+   * Attempt to reconnect to WebSocket
+   */
+  attemptReconnect() {
+    this.reconnectAttempts++;
+    const delay = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1), 30000);
+
+    const Logger = require('../utils/logger');
+    Logger.warning(`WebSocket closed. Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
+
+    setTimeout(() => {
+      if (this.ws && this.ws.readyState === WebSocket.CLOSED) {
+        this.connect()
+          .then(() => {
+            Logger.success('WebSocket reconnected');
+            // Rejoin channel if we had one
+            if (this.channel) {
+              this.joinChannel(this.channel).catch(err => {
+                Logger.error(`Failed to rejoin channel: ${err.message}`);
+              });
+            }
+          })
+          .catch(err => {
+            Logger.error(`Reconnection failed: ${err.message}`);
+            if (this.reconnectAttempts < this.maxReconnectAttempts) {
+              this.attemptReconnect();
+            }
+          });
+      }
+    }, delay);
+  }
+
+  /**
+   * 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 (CLI webhook channel)
+   * @param {string} channelName - Channel name (e.g., "cli_webhooks:user_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;
+
+      const handleJoinResponse = (data) => {
+        if (resolved) return;
+
+        try {
+          const msg = JSON.parse(data.toString());
+          if (msg.event === 'phx_reply' && msg.ref === joinRef && msg.topic === channelName) {
+            resolved = true;
+            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
+        }
+      };
+
+      this.ws.on('message', handleJoinResponse);
+      this.ws.send(joinMsg);
+
+      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');
+
+      // Handle webhook events
+      if (msg.event === 'webhook') {
+        if (this.verbose) {
+          Logger.info(`\n📨 Webhook event received on channel: ${msg.topic}`);
+        }
+        if (this.listeners.webhook) {
+          this.listeners.webhook(msg.payload);
+        }
+      } else if (msg.event === 'phx_reply') {
+        // Handle join responses
+        if (this.listeners.join) {
+          this.listeners.join(msg);
+        }
+      } else if (this.verbose && msg.event !== 'heartbeat') {
+        Logger.info(`Received event: ${msg.event} on topic: ${msg.topic}`);
+      }
+    } catch (error) {
+      if (this.verbose) {
+        const Logger = require('../utils/logger');
+        Logger.warning(`Failed to parse WebSocket message: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Listen for webhook events
+   * @param {Function} callback - Callback function
+   */
+  onWebhook(callback) {
+    this.listeners.webhook = 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(1000, 'CLI shutdown');
+      this.stopHeartbeat();
+    }
+  }
+}
+
+module.exports = CLIWebSocketClient;
+

package/src/lib/config.js

@@ -0,0 +1,137 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class Config {
+  constructor() {
+    this.configFile = this.findConfigFile();
+    this.config = this.loadConfig();
+  }
+
+  findConfigFile() {
+    // Check for .modelriverrc in current directory
+    const localRc = path.join(process.cwd(), '.modelriverrc');
+    if (fs.existsSync(localRc)) {
+      return localRc;
+    }
+
+    // Check for ~/.modelriver/config.json
+    const homeConfig = path.join(os.homedir(), '.modelriver', 'config.json');
+    if (fs.existsSync(homeConfig)) {
+      return homeConfig;
+    }
+
+    return null;
+  }
+
+  loadConfig() {
+    if (!this.configFile) {
+      return {};
+    }
+
+    try {
+      const content = fs.readFileSync(this.configFile, 'utf8');
+      return JSON.parse(content);
+    } catch (error) {
+      return {};
+    }
+  }
+
+  get(key, defaultValue = null) {
+    // Priority: env var > config file > default
+    const envKey = `MODELRIVER_${key.toUpperCase().replace(/-/g, '_')}`;
+
+    if (process.env[envKey]) {
+      return process.env[envKey].trim();
+    }
+
+    const configKey = key.replace(/-/g, '_');
+    if (this.config[configKey]) {
+      return this.config[configKey].trim();
+    }
+
+    return defaultValue;
+  }
+
+  getApiKey() {
+    return this.get('api-key') || this.get('api_key');
+  }
+
+  getProjectId() {
+    return this.get('project-id') || this.get('project_id');
+  }
+
+  getApiUrl() {
+    return this.get('api-url', 'https://api.modelriver.com') || this.get('api_url', 'https://api.modelriver.com');
+  }
+
+  getForwardUrl() {
+    return this.get('forward-url') || this.get('forward_url');
+  }
+
+  getWebSocketUrl() {
+    const apiUrl = this.getApiUrl();
+    // Convert http:// to ws:// and https:// to wss://
+    if (apiUrl.startsWith('https://')) {
+      return apiUrl.replace('https://', 'wss://');
+    }
+    return apiUrl.replace('http://', 'ws://');
+  }
+
+  /**
+   * Get the path to the home config file
+   * @returns {string} - Path to ~/.modelriver/config.json
+   */
+  getHomeConfigPath() {
+    return path.join(os.homedir(), '.modelriver', 'config.json');
+  }
+
+  /**
+   * Save configuration to ~/.modelriver/config.json
+   * @param {object} configData - Configuration object to save
+   */
+  saveConfig(configData) {
+    const configDir = path.join(os.homedir(), '.modelriver');
+    const configPath = this.getHomeConfigPath();
+
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    // Load existing config and merge
+    let existingConfig = {};
+    if (fs.existsSync(configPath)) {
+      try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        existingConfig = JSON.parse(content);
+      } catch (error) {
+        // Ignore parse errors, start fresh
+      }
+    }
+
+    // Merge with new config data
+    const mergedConfig = { ...existingConfig, ...configData };
+
+    // Write to file
+    fs.writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2), 'utf8');
+
+    // Reload config
+    this.configFile = configPath;
+    this.config = mergedConfig;
+  }
+
+  /**
+   * Save a single configuration value
+   * @param {string} key - Configuration key
+   * @param {string} value - Configuration value
+   */
+  save(key, value) {
+    const configKey = key.replace(/-/g, '_');
+    this.saveConfig({ [configKey]: value });
+  }
+}
+
+module.exports = new Config();
+
+

package/src/lib/config.test.js

@@ -0,0 +1,98 @@
+// We need to test the Config class, but it's exported as a singleton instance.
+// We'll test the behavior through environment variables.
+
+// Mock fs to prevent reading from actual ~/.modelriver/config.json
+jest.mock('fs', () => ({
+    existsSync: jest.fn(() => false),
+    readFileSync: jest.fn(() => '{}'),
+    writeFileSync: jest.fn(),
+    mkdirSync: jest.fn(),
+}));
+
+describe('Config', () => {
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+        // Reset modules to get fresh Config instance
+        jest.resetModules();
+        // Re-apply the mock after resetModules
+        jest.doMock('fs', () => ({
+            existsSync: jest.fn(() => false),
+            readFileSync: jest.fn(() => '{}'),
+            writeFileSync: jest.fn(),
+            mkdirSync: jest.fn(),
+        }));
+        process.env = { ...originalEnv };
+        // Clear any config-related env vars
+        delete process.env.MODELRIVER_API_KEY;
+        delete process.env.MODELRIVER_API_URL;
+    });
+
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+
+    describe('getApiKey', () => {
+        it('should read API key from MODELRIVER_API_KEY env var', () => {
+            process.env.MODELRIVER_API_KEY = 'mr_live_test123';
+            const config = require('./config');
+
+            expect(config.getApiKey()).toBe('mr_live_test123');
+        });
+
+        it('should return undefined when API key not set', () => {
+            delete process.env.MODELRIVER_API_KEY;
+            const config = require('./config');
+
+            expect(config.getApiKey()).toBeFalsy();
+        });
+    });
+
+    describe('getApiUrl', () => {
+        it('should return default URL when not set', () => {
+            delete process.env.MODELRIVER_API_URL;
+            const config = require('./config');
+
+            expect(config.getApiUrl()).toBe('https://api.modelriver.com');
+        });
+
+        it('should read API URL from MODELRIVER_API_URL env var', () => {
+            process.env.MODELRIVER_API_URL = 'http://localhost:4000';
+            const config = require('./config');
+
+            expect(config.getApiUrl()).toBe('http://localhost:4000');
+        });
+    });
+
+    describe('getWebSocketUrl', () => {
+        it('should convert https:// to wss://', () => {
+            process.env.MODELRIVER_API_URL = 'https://api.modelriver.com';
+            const config = require('./config');
+
+            expect(config.getWebSocketUrl()).toBe('wss://api.modelriver.com');
+        });
+
+        it('should convert http:// to ws://', () => {
+            process.env.MODELRIVER_API_URL = 'http://localhost:4000';
+            const config = require('./config');
+
+            expect(config.getWebSocketUrl()).toBe('ws://localhost:4000');
+        });
+    });
+
+    describe('get', () => {
+        it('should prioritize env vars over defaults', () => {
+            process.env.MODELRIVER_CUSTOM_KEY = 'env-value';
+            const config = require('./config');
+
+            expect(config.get('custom-key', 'default-value')).toBe('env-value');
+        });
+
+        it('should return default when env var not set', () => {
+            delete process.env.MODELRIVER_MISSING_KEY;
+            const config = require('./config');
+
+            expect(config.get('missing-key', 'fallback')).toBe('fallback');
+        });
+    });
+});

package/src/lib/webhook-verifier.js

@@ -0,0 +1,56 @@
+const crypto = require('crypto');
+
+class WebhookVerifier {
+  /**
+   * Generate HMAC-SHA256 signature for webhook payload
+   * Matches backend implementation in lib/modelriver/workers/webhook_delivery_worker.ex
+   */
+  static generateSignature(payload, secret, timestamp) {
+    // Create signature payload: timestamp.json_payload
+    const jsonPayload = JSON.stringify(payload);
+    const signaturePayload = `${timestamp}.${jsonPayload}`;
+
+    // Generate HMAC-SHA256
+    const hmac = crypto.createHmac('sha256', secret);
+    hmac.update(signaturePayload);
+    return hmac.digest('hex');
+  }
+
+  /**
+   * Verify webhook signature
+   * @param {string} providedSignature - Signature from X-ModelRiver-Signature header
+   * @param {object} payload - The payload.data object from webhook body
+   * @param {string} secret - Webhook secret
+   * @param {string|number} timestamp - Timestamp from X-ModelRiver-Timestamp header
+   * @returns {boolean} - True if signature is valid
+   */
+  static verify(providedSignature, payload, secret, timestamp) {
+    const expectedSignature = this.generateSignature(payload, secret, timestamp);
+    return this.secureCompare(providedSignature, expectedSignature);
+  }
+
+  /**
+   * Constant-time comparison to prevent timing attacks
+   * Matches backend implementation
+   */
+  static secureCompare(left, right) {
+    if (typeof left !== 'string' || typeof right !== 'string') {
+      return false;
+    }
+
+    if (left.length !== right.length) {
+      return false;
+    }
+
+    let result = 0;
+    for (let i = 0; i < left.length; i++) {
+      result |= left.charCodeAt(i) ^ right.charCodeAt(i);
+    }
+
+    return result === 0;
+  }
+}
+
+module.exports = WebhookVerifier;
+
+

package/src/lib/webhook-verifier.test.js

@@ -0,0 +1,90 @@
+const WebhookVerifier = require('./webhook-verifier');
+
+describe('WebhookVerifier', () => {
+    const secret = 'test-secret-key-12345';
+    const timestamp = '1704825600';
+    const payload = { status: 'success', name: 'Test User' };
+
+    describe('generateSignature', () => {
+        it('should generate a consistent HMAC-SHA256 signature', () => {
+            const sig1 = WebhookVerifier.generateSignature(payload, secret, timestamp);
+            const sig2 = WebhookVerifier.generateSignature(payload, secret, timestamp);
+
+            expect(sig1).toBe(sig2);
+            expect(typeof sig1).toBe('string');
+            expect(sig1.length).toBe(64); // SHA256 hex is 64 chars
+        });
+
+        it('should produce different signatures for different payloads', () => {
+            const sig1 = WebhookVerifier.generateSignature(payload, secret, timestamp);
+            const sig2 = WebhookVerifier.generateSignature({ different: 'data' }, secret, timestamp);
+
+            expect(sig1).not.toBe(sig2);
+        });
+
+        it('should produce different signatures for different secrets', () => {
+            const sig1 = WebhookVerifier.generateSignature(payload, secret, timestamp);
+            const sig2 = WebhookVerifier.generateSignature(payload, 'different-secret', timestamp);
+
+            expect(sig1).not.toBe(sig2);
+        });
+
+        it('should produce different signatures for different timestamps', () => {
+            const sig1 = WebhookVerifier.generateSignature(payload, secret, timestamp);
+            const sig2 = WebhookVerifier.generateSignature(payload, secret, '1704825601');
+
+            expect(sig1).not.toBe(sig2);
+        });
+    });
+
+    describe('verify', () => {
+        it('should return true for valid signatures', () => {
+            const signature = WebhookVerifier.generateSignature(payload, secret, timestamp);
+            const isValid = WebhookVerifier.verify(signature, payload, secret, timestamp);
+
+            expect(isValid).toBe(true);
+        });
+
+        it('should return false for tampered payloads', () => {
+            const signature = WebhookVerifier.generateSignature(payload, secret, timestamp);
+            const tamperedPayload = { ...payload, name: 'Hacker' };
+            const isValid = WebhookVerifier.verify(signature, tamperedPayload, secret, timestamp);
+
+            expect(isValid).toBe(false);
+        });
+
+        it('should return false for wrong secret', () => {
+            const signature = WebhookVerifier.generateSignature(payload, secret, timestamp);
+            const isValid = WebhookVerifier.verify(signature, payload, 'wrong-secret', timestamp);
+
+            expect(isValid).toBe(false);
+        });
+
+        it('should return false for wrong timestamp', () => {
+            const signature = WebhookVerifier.generateSignature(payload, secret, timestamp);
+            const isValid = WebhookVerifier.verify(signature, payload, secret, 'wrong-timestamp');
+
+            expect(isValid).toBe(false);
+        });
+    });
+
+    describe('secureCompare', () => {
+        it('should return true for equal strings', () => {
+            expect(WebhookVerifier.secureCompare('abc123', 'abc123')).toBe(true);
+        });
+
+        it('should return false for different strings', () => {
+            expect(WebhookVerifier.secureCompare('abc123', 'xyz789')).toBe(false);
+        });
+
+        it('should return false for different length strings', () => {
+            expect(WebhookVerifier.secureCompare('short', 'muchlongerstring')).toBe(false);
+        });
+
+        it('should return false for non-string inputs', () => {
+            expect(WebhookVerifier.secureCompare(null, 'string')).toBe(false);
+            expect(WebhookVerifier.secureCompare('string', undefined)).toBe(false);
+            expect(WebhookVerifier.secureCompare(123, 456)).toBe(false);
+        });
+    });
+});