simceptor-cli 1.0.0

package/bin/simceptor.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const WebSocket = require('ws');
+const axios = require('axios');
+
+program
+  .version('1.0.0')
+  .description('Simceptor Webhook Local Relayer CLI Client')
+  .command('listen')
+  .requiredOption('-t, --token <token>', 'Your Simceptor Personal Access Token (PAT)')
+  .option('-o, --to <url>', 'Local application target URL', 'http://localhost:3000')
+  .option('-s, --server <url>', 'Simceptor WebSocket server host URL', 'ws://localhost:8080')
+  .action((options) => {
+    const { token, to, server } = options;
+    
+    // Normalize target URL (ensure it starts with http:// or https://)
+    let toUrl = to.trim();
+    if (!toUrl.startsWith('http://') && !toUrl.startsWith('https://')) {
+      toUrl = 'http://' + toUrl;
+    }
+    
+    // Normalize server URL (ensure it starts with ws:// or wss://)
+    let serverUrl = server.trim();
+    if (!serverUrl.startsWith('ws://') && !serverUrl.startsWith('wss://')) {
+      if (serverUrl.startsWith('http://')) {
+        serverUrl = serverUrl.replace('http://', 'ws://');
+      } else if (serverUrl.startsWith('https://')) {
+        serverUrl = serverUrl.replace('https://', 'wss://');
+      } else {
+        serverUrl = 'ws://' + serverUrl;
+      }
+    }
+    
+    // Append relay path
+    if (!serverUrl.includes('/api/ws/webhook-relay')) {
+      serverUrl = serverUrl.replace(/\/+$/, '') + '/api/ws/webhook-relay';
+    }
+
+    const wsUrl = `${serverUrl}?token=${token}`;
+    console.log(`\n⚡ Simceptor Local Relayer starting...`);
+    console.log(`   - Server:      ${serverUrl}`);
+    console.log(`   - Forward To:  ${toUrl}\n`);
+
+    // Security check: Warn if using unencrypted ws:// on non-localhost remote servers
+    if (serverUrl.startsWith('ws://') && !serverUrl.includes('localhost') && !serverUrl.includes('127.0.0.1') && !serverUrl.includes('0.0.0.0')) {
+      console.warn(`⚠️  SECURITY WARNING: You are connecting using unencrypted WebSocket (ws://) to a remote host.`);
+      console.warn(`   Your Personal Access Token will be transmitted in plain text. Please use secure WebSocket (wss://) in production.`);
+    }
+    
+    let ws;
+    let reconnectTimeout;
+
+    function connect() {
+      console.log(`[${new Date().toLocaleTimeString()}] Connecting to Simceptor server...`);
+      
+      ws = new WebSocket(wsUrl);
+
+      ws.on('open', () => {
+        console.log(`\n🟢 Connected to Simceptor! Listening for local webhooks...`);
+      });
+
+      ws.on('message', async (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          
+          if (message.type === 'WEBHOOK') {
+            const { deliveryLogId, targetUrl, method, payload, headers, queryParams } = message;
+            
+            console.log(`\n[${new Date().toLocaleTimeString()}] 📥 Received Webhook for path: ${targetUrl.replace('simceptor://local', '')}`);
+            console.log(`   - Log ID:   ${deliveryLogId}`);
+            console.log(`   - Method:   ${method}`);
+            
+            // Construct local target URL
+            let finalLocalUrl;
+            try {
+              const urlObj = new URL(targetUrl.replace('simceptor://local', toUrl));
+              finalLocalUrl = urlObj.toString();
+            } catch (e) {
+              finalLocalUrl = toUrl + targetUrl.replace('simceptor://local', '');
+            }
+            
+            console.log(`   - Relaying to: ${finalLocalUrl}`);
+
+            // Parse headers
+            let reqHeaders = {
+              'Content-Type': 'application/json',
+              'X-Simceptor-Relayed': 'true'
+            };
+            if (headers) {
+              try {
+                const parsedHeaders = JSON.parse(headers);
+                reqHeaders = { ...reqHeaders, ...parsedHeaders };
+              } catch (e) {
+                // Ignore parsing errors
+              }
+            }
+
+            const startTime = Date.now();
+            let responseStatus = null;
+            let responseBody = null;
+            let errorMessage = null;
+
+            try {
+              const response = await axios({
+                method: method,
+                url: finalLocalUrl,
+                data: payload,
+                headers: reqHeaders,
+                timeout: 10000 // 10s timeout
+              });
+
+              responseStatus = response.status;
+              responseBody = typeof response.data === 'object' ? JSON.stringify(response.data) : String(response.data);
+              console.log(`🟢 Local server responded: ${response.status} OK (${Date.now() - startTime}ms)`);
+            } catch (err) {
+              errorMessage = err.message;
+              if (err.response) {
+                responseStatus = err.response.status;
+                responseBody = typeof err.response.data === 'object' ? JSON.stringify(err.response.data) : String(err.response.data);
+                console.log(`🔴 Local server error response: ${err.response.status} (${Date.now() - startTime}ms)`);
+              } else {
+                console.log(`🔴 Failed to connect to local server: ${err.message}`);
+              }
+            }
+
+            // Send ACK back
+            const ackMessage = {
+              type: 'ACK',
+              deliveryLogId: deliveryLogId,
+              statusCode: responseStatus,
+              responseBody: responseBody ? responseBody.substring(0, 5000) : null, // Truncate very long responses
+              errorMessage: errorMessage,
+              durationMs: Date.now() - startTime
+            };
+
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify(ackMessage));
+            }
+          }
+        } catch (e) {
+          console.error(`🔴 Error processing message:`, e);
+        }
+      });
+
+      ws.on('close', (code, reason) => {
+        console.log(`\n🔴 Connection closed (Code: ${code}). Reconnecting in 5 seconds...`);
+        reconnect();
+      });
+
+      ws.on('error', (err) => {
+        console.error(`\n⚠️ Connection error: ${err.message}`);
+      });
+    }
+
+    function reconnect() {
+      clearTimeout(reconnectTimeout);
+      reconnectTimeout = setTimeout(() => {
+        connect();
+      }, 5000);
+    }
+
+    connect();
+  });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "simceptor-cli",
+  "version": "1.0.0",
+  "description": "Simceptor Webhook Local Relayer CLI Client",
+  "main": "bin/simceptor.js",
+  "bin": {
+    "simceptor": "./bin/simceptor.js"
+  },
+  "scripts": {
+    "start": "node bin/simceptor.js"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "commander": "^11.1.0",
+    "ws": "^8.14.0"
+  }
+}