openpen 0.2.0

package/dist/utils/http.js

@@ -0,0 +1,92 @@
+/**
+ * Low-level HTTP helpers wrapping native fetch
+ */
+import { verbose } from './logger.js';
+export async function sendRequest(opts) {
+    const { url, method, headers = {}, body, timeout = 10000 } = opts;
+    const reqHeaders = {
+        'User-Agent': 'openpen/0.1.0',
+        ...headers,
+    };
+    if (body && !reqHeaders['Content-Type']) {
+        reqHeaders['Content-Type'] = 'application/json';
+    }
+    verbose(`  -> ${method} ${url}`);
+    const start = Date.now();
+    const res = await fetch(url, {
+        method,
+        headers: reqHeaders,
+        body: body || undefined,
+        signal: AbortSignal.timeout(timeout),
+        redirect: 'follow',
+    });
+    const responseTime = Date.now() - start;
+    const responseBody = await res.text();
+    const responseHeaders = {};
+    for (const [k, v] of res.headers) {
+        responseHeaders[k] = v;
+    }
+    verbose(`  <- ${res.status} (${responseTime}ms, ${responseBody.length} bytes)`);
+    return {
+        request: {
+            url,
+            method,
+            headers: reqHeaders,
+            body,
+        },
+        response: {
+            statusCode: res.status,
+            headers: responseHeaders,
+            bodySnippet: responseBody.slice(0, 500),
+            responseTime,
+        },
+        rawHeaders: res.headers,
+    };
+}
+/**
+ * Simple concurrency limiter
+ */
+export class Semaphore {
+    max;
+    queue = [];
+    active = 0;
+    constructor(max) {
+        this.max = max;
+    }
+    async acquire() {
+        if (this.active < this.max) {
+            this.active++;
+            return;
+        }
+        return new Promise(resolve => {
+            this.queue.push(() => {
+                this.active++;
+                resolve();
+            });
+        });
+    }
+    release() {
+        this.active--;
+        const next = this.queue.shift();
+        if (next)
+            next();
+    }
+}
+/**
+ * Simple rate limiter (token bucket)
+ */
+export class RateLimiter {
+    lastTime = 0;
+    minInterval;
+    constructor(maxPerSecond) {
+        this.minInterval = 1000 / maxPerSecond;
+    }
+    async wait() {
+        const now = Date.now();
+        const elapsed = now - this.lastTime;
+        if (elapsed < this.minInterval) {
+            await new Promise(r => setTimeout(r, this.minInterval - elapsed));
+        }
+        this.lastTime = Date.now();
+    }
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Verbosity-aware logger
+ */
+export declare function setVerbose(v: boolean): void;
+export declare function info(msg: string): void;
+export declare function verbose(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function error(msg: string): void;

package/dist/utils/logger.js

@@ -0,0 +1,20 @@
+/**
+ * Verbosity-aware logger
+ */
+let verboseMode = false;
+export function setVerbose(v) {
+    verboseMode = v;
+}
+export function info(msg) {
+    console.log(msg);
+}
+export function verbose(msg) {
+    if (verboseMode)
+        console.log(msg);
+}
+export function warn(msg) {
+    console.error(`[!] ${msg}`);
+}
+export function error(msg) {
+    console.error(`[ERROR] ${msg}`);
+}

package/dist/ws/checks.d.ts

@@ -0,0 +1,18 @@
+/**
+ * WebSocket security checks
+ * Built-in protocol tests for common WS vulnerabilities
+ */
+import type { WsTestResult } from '../types.js';
+export interface WsCheckInfo {
+    id: string;
+    name: string;
+    description: string;
+}
+type WsCheck = {
+    info: WsCheckInfo;
+    run: (url: string, timeout: number) => Promise<WsTestResult>;
+};
+export declare function getAllWsChecks(): WsCheck[];
+export declare function getWsChecksByIds(ids: string[]): WsCheck[];
+export declare function listWsChecks(): WsCheckInfo[];
+export {};