@modelriver/cli 1.0.0

package/src/commands/websocket.js

@@ -0,0 +1,249 @@
+const ApiClient = require('../lib/api-client');
+const WebSocketClient = require('../lib/websocket-client');
+const config = require('../lib/config');
+const Logger = require('../utils/logger');
+const Formatter = require('../utils/formatter');
+
+/**
+ * Normalize WebSocket URL for production environments
+ * Converts ws:// to wss:// for port 443 or production domains
+ */
+function normalizeWebSocketUrl(url) {
+  if (!url) return url;
+
+  try {
+    // Handle URLs like 'ws://api.modelriver.com:443/socket'
+    // Convert to 'wss://api.modelriver.com/socket'
+    const wsUrl = new URL(url);
+
+    // If port is 443, use wss:// and remove port
+    if (wsUrl.port === '443') {
+      wsUrl.protocol = 'wss:';
+      wsUrl.port = ''; // Remove port for standard https
+    }
+
+    // If it's a production domain (ends with modelriver.com), ensure wss://
+    if (wsUrl.hostname.endsWith('modelriver.com') && wsUrl.protocol === 'ws:') {
+      wsUrl.protocol = 'wss:';
+    }
+
+    return wsUrl.toString().replace(/\/$/, ''); // Remove trailing slash
+  } catch (e) {
+    // If URL parsing fails, return original
+    return url;
+  }
+}
+
+async function websocketCommand(options) {
+  const { workflow, message, payload, channelId, projectId, apiKey, apiUrl, verbose } = options;
+
+  let wsToken, websocketChannel, websocketUrl, channelIdToUse, projectIdToUse;
+
+  try {
+    const apiClient = new ApiClient(apiKey, apiUrl);
+
+    if (channelId && projectId) {
+      // Connect to existing channel
+      const spinner = Logger.spinner('Getting reconnect token...');
+      spinner.start();
+
+      try {
+        const reconnectResponse = await apiClient.reconnectAsync(channelId);
+        wsToken = reconnectResponse.ws_token;
+        websocketChannel = reconnectResponse.websocket_channel;
+        websocketUrl = normalizeWebSocketUrl(reconnectResponse.websocket_url || config.getWebSocketUrl());
+        channelIdToUse = channelId;
+        projectIdToUse = projectId;
+
+        spinner.succeed(`Reconnect token obtained for channel ${channelId}`);
+      } catch (error) {
+        spinner.fail('Failed to get reconnect token');
+        Logger.error(error.response?.data?.message || error.message);
+        process.exit(1);
+      }
+    } else if (workflow) {
+      // Make async request first
+      const spinner = Logger.spinner('Making async request...');
+      spinner.start();
+
+      try {
+        const requestPayload = payload
+          ? JSON.parse(payload)
+          : {
+            workflow,
+            messages: [{ role: 'user', content: message || 'Test from CLI' }]
+          };
+
+        if (verbose) {
+          Logger.info(`\n> API URL: ${apiClient.apiUrl}`);
+          Logger.info(`> Workflow: ${workflow}`);
+          Logger.info(`> Payload: ${JSON.stringify(requestPayload, null, 2)}`);
+        }
+
+        const response = await apiClient.createAsyncRequest(requestPayload);
+
+        wsToken = response.ws_token;
+        websocketChannel = response.websocket_channel;
+        websocketUrl = normalizeWebSocketUrl(response.websocket_url || config.getWebSocketUrl());
+        channelIdToUse = response.channel_id;
+        projectIdToUse = response.project_id;
+
+        spinner.succeed(`Request queued: ${channelIdToUse}`);
+        Logger.info(`\n> Channel ID: ${channelIdToUse}`);
+        Logger.info(`> Project ID: ${projectIdToUse}`);
+      } catch (error) {
+        spinner.fail('Failed to create async request');
+
+        if (error.response) {
+          // HTTP error response
+          const status = error.response.status;
+          let data = error.response.data;
+
+          // Handle case where response.data is a plain string
+          if (typeof data === 'string') {
+            data = { message: data };
+          }
+
+          Logger.error(`Request failed with status code ${status}`);
+
+          // Log full response for debugging
+          if (verbose) {
+            Logger.info(`\nFull error response: ${JSON.stringify(data, null, 2)}`);
+            Logger.info(`Response headers: ${JSON.stringify(error.response.headers, null, 2)}`);
+          }
+
+          if (data?.error) {
+            Logger.error(`Error: ${data.error}`);
+          }
+          if (data?.message) {
+            Logger.error(`Message: ${data.message}`);
+          }
+          if (data?.details) {
+            Logger.error(`Details: ${data.details}`);
+          }
+
+          // If response is just "Forbidden" string, provide more context
+          if (typeof error.response.data === 'string' && error.response.data === 'Forbidden') {
+            Logger.warning('\nReceived plain "Forbidden" response - this may indicate:');
+            Logger.warning('- Host header mismatch (API expects specific host)');
+            Logger.warning('- Route not matching expected pattern');
+            Logger.warning('- Middleware blocking the request');
+          }
+
+          if (status === 403) {
+            Logger.warning('\nPossible causes:');
+            Logger.warning('1. API key is invalid or revoked');
+            Logger.warning('2. API key does not have access to this project');
+            Logger.warning('3. Workflow does not exist or is not accessible');
+            Logger.warning('4. API key does not have required providers enabled');
+            Logger.warning('\nTo fix:');
+            Logger.warning('- Verify your API key in the ModelRiver dashboard');
+            Logger.warning('- Check that the workflow name is correct (case-sensitive)');
+            Logger.warning('- Ensure the API key has access to the project');
+            Logger.warning('- Run with --verbose to see full error details');
+          } else if (status === 401) {
+            Logger.error('Authentication failed - API key is invalid or missing');
+            Logger.warning('Check that MODELRIVER_API_KEY is set correctly');
+          }
+        } else if (error.request) {
+          Logger.error('No response received from server');
+          Logger.error('Check your network connection and API URL');
+          if (verbose) {
+            Logger.info(`Request was: ${error.config?.method?.toUpperCase()} ${error.config?.url}`);
+          }
+        } else {
+          Logger.error(`Error: ${error.message}`);
+        }
+
+        process.exit(1);
+      }
+    } else {
+      Logger.error('Error: --workflow or (--channel-id and --project-id) required');
+      process.exit(1);
+    }
+
+    // Connect to WebSocket
+    const connectSpinner = Logger.spinner('Connecting to WebSocket...');
+    connectSpinner.start();
+
+    if (verbose) {
+      Logger.info(`\n> WebSocket URL: ${websocketUrl.replace(wsToken, '***')}`);
+      Logger.info(`> Channel: ${websocketChannel}`);
+    }
+
+    const wsClient = new WebSocketClient(websocketUrl, wsToken, verbose);
+
+    try {
+      await wsClient.connect();
+      connectSpinner.succeed('WebSocket connected');
+
+      // Join channel
+      const joinSpinner = Logger.spinner('Joining channel...');
+      joinSpinner.start();
+
+      try {
+        await wsClient.joinChannel(websocketChannel);
+        joinSpinner.succeed('Channel joined');
+        Logger.warning('\n> Waiting for response...\n');
+      } catch (error) {
+        joinSpinner.fail('Failed to join channel');
+        Logger.error(error.message);
+        wsClient.close();
+        process.exit(1);
+      }
+
+      // Set up response listener BEFORE waiting (to catch responses that arrive quickly)
+      let responseReceived = false;
+      
+      // Timeout after 5 minutes
+      const timeoutId = setTimeout(() => {
+        if (!responseReceived) {
+          Logger.error('\n❌ Timeout: No response received after 5 minutes');
+          Logger.error('   Possible causes:');
+          Logger.error('   1. Workflow is still processing (try waiting longer)');
+          Logger.error('   2. Workflow failed on the server (check server logs)');
+          Logger.error('   3. Server did not broadcast the response');
+          wsClient.close();
+          process.exit(1);
+        }
+      }, 5 * 60 * 1000);
+
+      wsClient.onResponse((payload) => {
+        responseReceived = true;
+        clearTimeout(timeoutId);
+        Logger.success('\n✅ Response received:\n');
+        console.log(Formatter.json(payload));
+        wsClient.close();
+        process.exit(0);
+      });
+
+      if (verbose) {
+        Logger.info('✅ Response listener registered and ready');
+        Logger.info('⏳ Waiting for server to send "response" event...');
+        Logger.info('   (This may take a while for production workflows)');
+      }
+
+      wsClient.onClose(() => {
+        clearTimeout(timeoutId);
+        if (!responseReceived) {
+          Logger.warning('\n> WebSocket closed before response received');
+          Logger.warning('   The server may have closed the connection without sending a response.');
+          Logger.warning('   Check server logs or try the request again.');
+        }
+      });
+
+    } catch (error) {
+      connectSpinner.fail('WebSocket connection failed');
+      Logger.error(error.message);
+      process.exit(1);
+    }
+
+  } catch (error) {
+    Logger.error(`Unexpected error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { websocketCommand };
+
+

package/src/index.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const { loginCommand } = require('./commands/login');
+const { listenCommand } = require('./commands/listen');
+const { forwardCommand } = require('./commands/forward');
+const { websocketCommand } = require('./commands/websocket');
+const { triggerCommand } = require('./commands/trigger');
+const { testWebhookCommand } = require('./commands/test-webhook');
+const { listWebhooks, verifyWebhook } = require('./commands/webhook');
+const config = require('./lib/config');
+
+const program = new Command();
+
+program
+  .name('modelriver')
+  .description('ModelRiver CLI for testing webhooks and WebSockets from production')
+  .version('1.0.0');
+
+// Global options
+program
+  .option('-k, --api-key <key>', 'ModelRiver API key (or set MODELRIVER_API_KEY)')
+  .option('--api-url <url>', 'API base URL (default: https://api.modelriver.com)')
+  .option('-p, --project-id <id>', 'Project ID (or set MODELRIVER_PROJECT_ID)');
+
+// Login command - interactive setup
+program
+  .command('login')
+  .description('Configure your ModelRiver API key and forward URL interactively')
+  .action((options) => {
+    loginCommand(options);
+  });
+
+// Listen command with alias 'l'
+program
+  .command('listen')
+  .alias('l')
+  .description('Forward webhooks from production to local server via WebSocket')
+  .option('-k, --api-key <key>', 'ModelRiver API key (or set MODELRIVER_API_KEY)')
+  .option('--api-url <url>', 'API base URL (default: https://api.modelriver.com)')
+  .option('-p, --port <port>', 'Local server port (default: 3001)')
+  .option('-f, --forward', 'Forward to external server (do not start internal server)')
+  .option('--print', 'Print webhook payloads to console')
+  .option('-v, --verbose', 'Verbose output')
+  .action((options) => {
+    listenCommand({
+      ...options,
+      apiKey: options.apiKey || program.opts().apiKey,
+      apiUrl: options.apiUrl || program.opts().apiUrl
+    });
+  });
+
+// Forward command with alias 'f' - simplified webhook forwarding
+program
+  .command('forward')
+  .alias('f')
+  .description('Forward webhooks using saved configuration (shortcut for listen --forward --print)')
+  .option('-p, --port <port>', 'Override target port')
+  .option('-v, --verbose', 'Verbose output')
+  .action((options) => {
+    forwardCommand(options);
+  });
+
+// WebSocket command with alias 'ws'
+program
+  .command('websocket')
+  .alias('ws')
+  .description('Test WebSocket connection to production')
+  .option('-w, --workflow <name>', 'Workflow name')
+  .option('-m, --message <text>', 'Test message')
+  .option('-P, --payload <json>', 'Custom JSON payload')
+  .option('-c, --channel-id <id>', 'Existing channel ID (requires --project-id)')
+  .option('-v, --verbose', 'Verbose output')
+  .action((options) => {
+    websocketCommand({
+      ...options,
+      apiKey: options.apiKey || program.opts().apiKey,
+      apiUrl: options.apiUrl || program.opts().apiUrl,
+      projectId: options.projectId || program.opts().projectId
+    });
+  });
+
+// Test Webhook command
+program
+  .command('test-webhook')
+  .description('Test webhook delivery - creates webhook, makes request, waits for response')
+  .option('-w, --workflow <name>', 'Workflow name')
+  .option('-m, --message <text>', 'Test message')
+  .option('-P, --payload <json>', 'Custom JSON payload')
+  .option('-u, --webhook-url <url>', 'Webhook URL (if not provided, starts local server on --port)')
+  .option('-s, --secret <secret>', 'Webhook secret (optional, auto-generated if not provided)')
+  .option('-p, --port <port>', 'Local server port when using local server (default: 3001)')
+  .option('-v, --verbose', 'Verbose output')
+  .action((options) => {
+    testWebhookCommand({
+      ...options,
+      apiKey: options.apiKey || program.opts().apiKey,
+      apiUrl: options.apiUrl || program.opts().apiUrl
+    });
+  });
+
+// Trigger command with alias 't'
+program
+  .command('trigger')
+  .alias('t')
+  .description('Send test async request')
+  .option('-w, --workflow <name>', 'Workflow name')
+  .option('-m, --message <text>', 'Test message')
+  .option('-P, --payload <json>', 'Custom JSON payload')
+  .option('-u, --webhook-url <url>', 'Webhook URL to receive response')
+  .option('--print-channel', 'Print channel details')
+  .action((options) => {
+    triggerCommand({
+      ...options,
+      apiKey: options.apiKey || program.opts().apiKey,
+      apiUrl: options.apiUrl || program.opts().apiUrl
+    });
+  });
+
+// Webhook commands
+const webhookCmd = program
+  .command('webhook')
+  .description('Webhook management commands (read-only and verification)');
+
+webhookCmd
+  .command('list')
+  .description('List all webhooks')
+  .option('-v, --verbose', 'Show detailed information')
+  .action((options) => {
+    listWebhooks({
+      ...options,
+      apiKey: options.apiKey || program.opts().apiKey,
+      apiUrl: options.apiUrl || program.opts().apiUrl
+    });
+  });
+
+webhookCmd
+  .command('verify')
+  .description('Verify webhook signature')
+  .requiredOption('-p, --payload <file|json>', 'Payload file path or JSON string')
+  .requiredOption('-s, --signature <sig>', 'X-ModelRiver-Signature header value')
+  .requiredOption('-t, --timestamp <ts>', 'X-ModelRiver-Timestamp header value')
+  .requiredOption('--secret <secret>', 'Webhook secret')
+  .action(verifyWebhook);
+
+// Parse arguments
+program.parse();
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}
+
+

package/src/lib/api-client.js

@@ -0,0 +1,173 @@
+const axios = require('axios');
+const config = require('./config');
+
+class ApiClient {
+  constructor(apiKey = null, apiUrl = null) {
+    this.apiKey = apiKey || config.getApiKey();
+    this.apiUrl = (apiUrl || config.getApiUrl()).replace(/\/$/, '');
+
+    if (!this.apiKey) {
+      throw new Error('API key is required. Set MODELRIVER_API_KEY env var or use --api-key flag.');
+    }
+
+    // Validate API key format
+    if (!this.apiKey.startsWith('mr_live_') && !this.apiKey.startsWith('mr_test_')) {
+      throw new Error('Invalid API key format. API keys must start with "mr_live_" or "mr_test_".');
+    }
+
+    // Determine API path: /v1 in production (api.modelriver.com), /api/v1 in dev/test
+    try {
+      const apiUrlObj = new URL(this.apiUrl);
+      const isProduction = apiUrlObj.hostname === 'api.modelriver.com' ||
+        apiUrlObj.hostname.endsWith('.modelriver.com');
+      this.apiPath = isProduction ? '/v1' : '/api/v1';
+    } catch (e) {
+      // Fallback to dev path if URL parsing fails
+      this.apiPath = '/api/v1';
+    }
+
+    // Debug: Log API key info if DEBUG is set
+    if (process.env.DEBUG) {
+      console.log('[DEBUG] API Key (first 30 chars):', this.apiKey ? this.apiKey.substring(0, 30) + '...' : 'NOT SET');
+      console.log('[DEBUG] Authorization header will be:', this.apiKey ? `Bearer ${this.apiKey.substring(0, 30)}...` : 'NOT SET');
+    }
+
+    this.client = axios.create({
+      baseURL: this.apiUrl,
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json'
+      },
+      validateStatus: function (status) {
+        return status < 500; // Don't throw on 4xx errors, we'll handle them
+      }
+    });
+  }
+
+
+  /**
+   * Create async AI request
+   * @param {object} payload - Request payload {workflow, messages, format?}
+   * @returns {Promise<object>} - Response with channel_id, ws_token, etc.
+   */
+  async createAsyncRequest(payload) {
+    const response = await this.client.post(`${this.apiPath}/ai/async`, payload);
+
+    // Check for error status codes
+    if (response.status >= 400) {
+      const error = new Error(`Request failed with status ${response.status}`);
+      error.response = response;
+      throw error;
+    }
+
+    return response.data;
+  }
+
+  /**
+   * Get reconnect token for existing channel
+   * @param {string} channelId - Channel ID
+   * @returns {Promise<object>} - Response with ws_token
+   */
+  async reconnectAsync(channelId) {
+    const response = await this.client.post(`${this.apiPath}/ai/reconnect`, {
+      channel_id: channelId
+    });
+    return response.data;
+  }
+
+  /**
+   * List all webhooks for the project
+   * @returns {Promise<Array>} - Array of webhook objects
+   */
+  async listWebhooks() {
+    const response = await this.client.get(`${this.apiPath}/webhooks`);
+    return response.data.webhooks || [];
+  }
+
+  /**
+   * Get a specific webhook
+   * @param {string} webhookId - Webhook ID
+   * @returns {Promise<object>} - Webhook object
+   */
+  async getWebhook(webhookId) {
+    const response = await this.client.get(`${this.apiPath}/webhooks/${webhookId}`);
+    return response.data;
+  }
+
+  /**
+   * Create a new webhook
+   * @param {object} webhook - {url, description?, secret?}
+   * @returns {Promise<object>} - Created webhook with secret
+   */
+  async createWebhook(webhook) {
+    const response = await this.client.post(`${this.apiPath}/webhooks`, webhook);
+    return response.data;
+  }
+
+  /**
+   * Update a webhook
+   * @param {string} webhookId - Webhook ID
+   * @param {object} updates - {url?, description?, enabled?, secret?}
+   * @returns {Promise<object>} - Updated webhook
+   */
+  async updateWebhook(webhookId, updates) {
+    const response = await this.client.put(`${this.apiPath}/webhooks/${webhookId}`, updates);
+    return response.data;
+  }
+
+  /**
+   * Delete a webhook
+   * @param {string} webhookId - Webhook ID
+   * @returns {Promise<void>}
+   */
+  async deleteWebhook(webhookId) {
+    await this.client.delete(`${this.apiPath}/webhooks/${webhookId}`);
+  }
+
+  /**
+   * Connect CLI and get WebSocket token
+   * @returns {Promise<object>} - {ws_token, websocket_url, project_id, user_id, channel}
+   */
+  async connectCLI() {
+    try {
+      const url = `${this.apiPath}/cli/connect`;
+      
+      // Debug: Log the request details
+      if (process.env.DEBUG || this.verbose) {
+        console.log('[DEBUG] Making request to:', `${this.apiUrl}${url}`);
+        console.log('[DEBUG] API Key (first 30 chars):', this.apiKey ? this.apiKey.substring(0, 30) + '...' : 'NOT SET');
+        console.log('[DEBUG] Authorization header:', this.apiKey ? `Bearer ${this.apiKey.substring(0, 30)}...` : 'NOT SET');
+      }
+
+      const response = await this.client.post(url, {});
+      
+      if (response.status >= 400) {
+        const errorMsg = response.data?.error || response.data?.message || `HTTP ${response.status}`;
+        const error = new Error(`Failed to connect CLI: ${errorMsg}`);
+        error.response = response;
+        throw error;
+      }
+
+      return response.data;
+    } catch (error) {
+      // Handle network errors or axios errors
+      if (error.response) {
+        // Server responded with error
+        const errorMsg = error.response.data?.error || error.response.data?.message || `HTTP ${error.response.status}`;
+        const newError = new Error(`Failed to connect CLI: ${errorMsg}`);
+        newError.response = error.response;
+        throw newError;
+      } else if (error.request) {
+        // Request was made but no response received
+        throw new Error(`Failed to connect CLI: No response from server. Is the backend running?`);
+      } else {
+        // Something else happened
+        throw new Error(`Failed to connect CLI: ${error.message}`);
+      }
+    }
+  }
+}
+
+module.exports = ApiClient;
+
+

package/src/lib/api-client.test.js

@@ -0,0 +1,101 @@
+// 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('ApiClient', () => {
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+        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 env vars first
+        delete process.env.MODELRIVER_API_KEY;
+        // Then set a valid API key for tests that need it
+        process.env.MODELRIVER_API_KEY = 'mr_live_validtestkey123';
+    });
+
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+
+    describe('constructor validation', () => {
+        it('should throw error when API key is missing', () => {
+            delete process.env.MODELRIVER_API_KEY;
+            const ApiClient = require('./api-client');
+
+            expect(() => new ApiClient(null, 'https://api.modelriver.com'))
+                .toThrow('API key is required');
+        });
+
+        it('should throw error for invalid API key format', () => {
+            const ApiClient = require('./api-client');
+
+            expect(() => new ApiClient('invalid-key-format', 'https://api.modelriver.com'))
+                .toThrow('Invalid API key format');
+        });
+
+        it('should accept mr_live_ prefixed keys', () => {
+            const ApiClient = require('./api-client');
+
+            expect(() => new ApiClient('mr_live_abc123', 'https://api.modelriver.com'))
+                .not.toThrow();
+        });
+
+        it('should accept mr_test_ prefixed keys', () => {
+            const ApiClient = require('./api-client');
+
+            expect(() => new ApiClient('mr_test_abc123', 'https://api.modelriver.com'))
+                .not.toThrow();
+        });
+    });
+
+    describe('apiPath detection', () => {
+        it('should use /v1 for production URLs', () => {
+            const ApiClient = require('./api-client');
+            const client = new ApiClient('mr_live_test123', 'https://api.modelriver.com');
+
+            expect(client.apiPath).toBe('/v1');
+        });
+
+        it('should use /v1 for *.modelriver.com subdomains', () => {
+            const ApiClient = require('./api-client');
+            const client = new ApiClient('mr_live_test123', 'https://staging.modelriver.com');
+
+            expect(client.apiPath).toBe('/v1');
+        });
+
+        it('should use /api/v1 for localhost', () => {
+            const ApiClient = require('./api-client');
+            const client = new ApiClient('mr_live_test123', 'http://localhost:4000');
+
+            expect(client.apiPath).toBe('/api/v1');
+        });
+
+        it('should use /api/v1 for non-production URLs', () => {
+            const ApiClient = require('./api-client');
+            const client = new ApiClient('mr_live_test123', 'http://my-dev-server.local');
+
+            expect(client.apiPath).toBe('/api/v1');
+        });
+    });
+
+    describe('URL normalization', () => {
+        it('should strip trailing slashes from API URL', () => {
+            const ApiClient = require('./api-client');
+            const client = new ApiClient('mr_live_test123', 'https://api.modelriver.com/');
+
+            expect(client.apiUrl).toBe('https://api.modelriver.com');
+        });
+    });
+});