openpen 0.2.0

package/dist/ws/engine.js

@@ -0,0 +1,139 @@
+/**
+ * WebSocket test engine
+ * Handles connections, message exchange, and response collection
+ */
+import WebSocket from 'ws';
+/**
+ * Open a WebSocket connection to the target
+ */
+export function connect(url, options = {}) {
+    const timeout = options.timeout || 5000;
+    return new Promise((resolve, reject) => {
+        const ws = new WebSocket(url, {
+            headers: options.headers || {},
+            handshakeTimeout: timeout,
+        });
+        const conn = {
+            ws,
+            messages: [],
+            connected: false,
+        };
+        const timer = setTimeout(() => {
+            if (!conn.connected) {
+                ws.terminate();
+                reject(new Error(`Connection timeout after ${timeout}ms`));
+            }
+        }, timeout);
+        ws.on('open', () => {
+            clearTimeout(timer);
+            conn.connected = true;
+            resolve(conn);
+        });
+        ws.on('message', (data) => {
+            conn.messages.push({
+                direction: 'received',
+                data: data.toString(),
+                timestamp: Date.now(),
+            });
+        });
+        ws.on('close', (code, reason) => {
+            conn.connected = false;
+            conn.closedCode = code;
+            conn.closedReason = reason.toString();
+        });
+        ws.on('error', (err) => {
+            clearTimeout(timer);
+            if (!conn.connected) {
+                reject(err);
+            }
+        });
+    });
+}
+/**
+ * Send a message and wait for a response
+ */
+export function sendAndWait(conn, data, options = {}) {
+    const timeout = options.timeout || 3000;
+    const startIdx = conn.messages.length;
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            conn.ws.removeListener('message', onMessage);
+            resolve(null);
+        }, timeout);
+        const check = () => {
+            for (let i = startIdx; i < conn.messages.length; i++) {
+                const msg = conn.messages[i];
+                if (msg.direction === 'received') {
+                    if (!options.matchFn || options.matchFn(msg.data)) {
+                        clearTimeout(timer);
+                        conn.ws.removeListener('message', onMessage);
+                        resolve(msg.data);
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        const onMessage = () => { check(); };
+        conn.ws.on('message', onMessage);
+        conn.messages.push({
+            direction: 'sent',
+            data,
+            timestamp: Date.now(),
+        });
+        conn.ws.send(data);
+        // Check messages already received
+        check();
+    });
+}
+/**
+ * Send raw data (string or buffer) without recording
+ */
+export function sendRaw(conn, data) {
+    conn.ws.send(data);
+}
+/**
+ * Close a connection gracefully
+ */
+export function close(conn) {
+    return new Promise((resolve) => {
+        if (!conn.connected) {
+            resolve();
+            return;
+        }
+        conn.ws.on('close', () => resolve());
+        conn.ws.close();
+        setTimeout(() => resolve(), 1000);
+    });
+}
+/**
+ * Wait for a specific number of messages or timeout
+ */
+export function waitForMessages(conn, count, timeout = 3000) {
+    const startIdx = conn.messages.length;
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            resolve(conn.messages.slice(startIdx));
+        }, timeout);
+        const check = () => {
+            const received = conn.messages.slice(startIdx).filter(m => m.direction === 'received');
+            if (received.length >= count) {
+                clearTimeout(timer);
+                resolve(conn.messages.slice(startIdx));
+            }
+        };
+        conn.ws.on('message', () => check());
+        check();
+    });
+}
+/**
+ * Try to parse a message as JSON
+ */
+export function parseJson(data) {
+    try {
+        return { parsed: true, value: JSON.parse(data) };
+    }
+    catch (e) {
+        return { parsed: false, error: e.message };
+    }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "openpen",
+  "version": "0.2.0",
+  "description": "Open source CLI for API fuzzing and penetration testing",
+  "type": "module",
+  "bin": {
+    "openpen": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "test": "node --test dist/**/*.test.js"
+  },
+  "keywords": [
+    "api",
+    "security",
+    "fuzzing",
+    "pentest",
+    "owasp"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tjamescouch/openpen"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.0.0",
+    "commander": "^12.0.0",
+    "yaml": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.0.0",
+    "typescript": "^5.3.0"
+  }
+}