@j3r3mcdev/oast-server 1.1.1 → 1.1.3

package/dist/bootstrap.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("./core/logger");
+const storage_1 = require("./core/storage");
+const router_1 = require("./core/router");
+const server_1 = require("./core/server");
+// Listeners
+const api_listener_1 = require("./listeners/api/api.listener");
+const http_listener_1 = require("./listeners/http/http.listener");
+const dns_listener_1 = require("./listeners/dns/dns.listener");
+const smtp_listener_1 = require("./listeners/smtp/smtp.listener");
+const tcp_listener_1 = require("./listeners/tcp/tcp.listener");
+async function main() {
+    const logger = new logger_1.Logger({ context: "Bootstrap" });
+    // Core components
+    const storage = new storage_1.StorageManager({
+        logger: logger.withContext("Storage"),
+    });
+    const router = new router_1.CoreRouter(storage, {
+        logger: logger.withContext("CoreRouter"),
+    });
+    // ---------------------------
+    // LISTENERS
+    // ---------------------------
+    // API → (router, storage, options)
+    const apiListener = new api_listener_1.ApiListener(storage, {
+        port: 3100,
+        logger: logger.withContext("ApiListener"),
+    });
+    // HTTP → (router, options)
+    const httpListener = new http_listener_1.HttpListener(router, {
+        port: 8080,
+        logger: logger.withContext("HttpListener"),
+    });
+    // DNS → (router, options)
+    const dnsListener = new dns_listener_1.DnsListener(router, {
+        server: {},
+        logger: logger.withContext("DnsListener"),
+    });
+    const smtpListener = new smtp_listener_1.SmtpListener(router, {
+        server: {},
+        logger: logger.withContext("SmtpListener"),
+    });
+    // TCP → (router, storage, options)
+    const tcpListener = new tcp_listener_1.TcpListener(router, storage, {
+        port: 9000,
+        logger: logger.withContext("TcpListener"),
+    });
+    // ---------------------------
+    // CORE SERVER
+    // ---------------------------
+    const server = new server_1.CoreServer({
+        logger: logger.withContext("CoreServer"),
+        storage,
+        listeners: [
+            apiListener,
+            httpListener,
+            dnsListener,
+            smtpListener,
+            tcpListener,
+        ],
+    });
+    await server.start();
+    // Graceful shutdown
+    const shutdown = async () => {
+        logger.warn("Received shutdown signal, stopping server...");
+        await server.stop();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+main().catch((err) => {
+    console.error("Fatal error in bootstrap:", err);
+    process.exit(1);
+});

package/dist/core/__tests__/core-router.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/core-server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/event.normalizer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/event.router.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/logger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/storage-manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/event.normalizer.d.ts

@@ -0,0 +1,10 @@
+import { RawEvent, RawDnsEvent, RawSmtpEvent, RawTcpEvent, RawSsrfEvent, NormalizedHttpEvent, NormalizedDnsEvent, NormalizedSmtpEvent, NormalizedTcpEvent, NormalizedSsrfEvent, NormalizedWebhookEvent, RawWebhookEvent, NormalizedWebSocketEvent, RawWebSocketEvent } from "../types/event.types";
+export declare class EventNormalizer {
+    static normalizeDns(event: RawDnsEvent): NormalizedDnsEvent;
+    static normalizeHttp(event: RawEvent): NormalizedHttpEvent;
+    static normalizeSmtp(event: RawSmtpEvent): NormalizedSmtpEvent;
+    static normalizeTcp(event: RawTcpEvent): NormalizedTcpEvent;
+    static normalizeSsrf(raw: RawSsrfEvent): NormalizedSsrfEvent;
+    static normalizeWebhook(raw: RawWebhookEvent): NormalizedWebhookEvent;
+    static normalizeWebSocket(raw: RawWebSocketEvent): NormalizedWebSocketEvent;
+}

package/dist/core/event.router.d.ts

@@ -0,0 +1,7 @@
+import { Storage } from "../storage-adapters/storage.interface";
+import { RawEvent, NormalizedHttpEvent } from "../types/event.types";
+export declare class EventRouter {
+    private storage;
+    constructor(storage: Storage);
+    handleHttp(event: RawEvent): Promise<NormalizedHttpEvent>;
+}

package/dist/core/http/__tests__/adapter-node.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/body-parser-multipart.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/body-parser-raw.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/body-parser-text.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/compile-path.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/middleware-pipeline.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/request.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/response.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/router-match.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/adapter-node.d.ts

@@ -0,0 +1,8 @@
+import { MiddlewarePipeline } from "./middleware";
+import { Router } from "./router";
+export declare class NodeAdapter {
+    private router;
+    private pipeline;
+    constructor(router: Router, pipeline: MiddlewarePipeline);
+    handle(req: any, res: any): Promise<void>;
+}

package/dist/core/http/buildRequest.d.ts

@@ -0,0 +1,2 @@
+import { Request } from "./request";
+export declare function buildRequest(raw: any, params?: Record<string, string>): Request;

package/dist/core/http/compile-path.d.ts

@@ -0,0 +1,13 @@
+export declare function compilePath(path: string): ({
+    type: string;
+    value: string;
+    name?: undefined;
+} | {
+    type: string;
+    name: string;
+    value?: undefined;
+} | {
+    type: string;
+    value?: undefined;
+    name?: undefined;
+})[];

package/dist/core/http/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details?: any;
+    constructor(status: number, code: string, message: string, details?: any);
+}
+export declare class ErrorHandler {
+    static handle(err: unknown, res: any): void;
+}

package/dist/core/http/http-server.d.ts

@@ -0,0 +1,7 @@
+import { Router } from "./router";
+export declare class HttpServer {
+    private router;
+    private server;
+    constructor(router: Router);
+    start(port: number): void;
+}

package/dist/core/http/middleware.d.ts

@@ -0,0 +1,12 @@
+import { Request } from "./request";
+import { Response } from "./response";
+export type Middleware = (req: Request, res: Response, next: () => Promise<void>) => Promise<void> | void;
+export declare class MiddlewarePipeline {
+    private middlewares;
+    use(mw: Middleware): this;
+    run(req: Request, res: Response): Promise<void>;
+}
+export declare function bodyParserJson(req: Request, res: Response): Promise<void>;
+export declare function bodyParserRaw(req: Request, res: Response): Promise<void>;
+export declare function bodyParserText(req: Request, res: Response): Promise<void>;
+export declare function bodyParserMultipart(req: Request, res: Response): Promise<void>;

package/dist/core/http/request.d.ts

@@ -0,0 +1,35 @@
+export interface RequestContext {
+    [key: string]: any;
+}
+export declare class Request {
+    readonly method: string;
+    readonly path: string;
+    readonly headers: Record<string, string>;
+    readonly query: Record<string, string | string[]>;
+    readonly params: Record<string, string>;
+    body: any;
+    bodyRaw?: Buffer;
+    bodyText?: string;
+    files?: Array<{
+        fieldname: string;
+        filename: string;
+        contentType: string;
+        data: Buffer;
+    }>;
+    form?: Record<string, string>;
+    readonly ip: string;
+    readonly raw: any;
+    readonly context: RequestContext;
+    constructor(options: {
+        method: string;
+        path: string;
+        headers: Record<string, string>;
+        query?: Record<string, string | string[]>;
+        params?: Record<string, string>;
+        body?: any;
+        ip?: string;
+        raw?: any;
+        context?: RequestContext;
+    });
+    header(name: string): string | undefined;
+}

package/dist/core/http/response.d.ts

@@ -0,0 +1,17 @@
+export declare class Response {
+    private _status;
+    private _headers;
+    private _sent;
+    private _raw;
+    constructor(raw: any);
+    status(code: number): this;
+    header(name: string, value: string): this;
+    json(data: any): void;
+    text(data: string): void;
+    send(data: any): void;
+    stream(readable: NodeJS.ReadableStream): void;
+    sse(): void;
+    write(data: string): void;
+    end(): void;
+    private ensureNotSent;
+}

package/dist/core/http/router.d.ts

@@ -0,0 +1,28 @@
+import { Middleware } from "./middleware";
+export declare class Router {
+    private routes;
+    /**
+     * Enregistre une route avec middlewares optionnels :
+     * router.get("/x", mw1, mw2, handler)
+     */
+    register(method: string, path: string, ...middlewaresAndHandler: any[]): void;
+    /**
+     * Trouve la route et extrait les params
+     */
+    match(method: string, urlPath: string): {
+        handler: Function;
+        middlewares: Middleware[];
+        params: Record<string, string>;
+    } | null;
+    /**
+     * Ton moteur de matching existant — inchangé
+     */
+    private matchSegments;
+    get(path: string, ...middlewaresAndHandler: any[]): void;
+    post(path: string, ...middlewaresAndHandler: any[]): void;
+    put(path: string, ...middlewaresAndHandler: any[]): void;
+    delete(path: string, ...middlewaresAndHandler: any[]): void;
+    patch(path: string, ...middlewaresAndHandler: any[]): void;
+    options(path: string, ...middlewaresAndHandler: any[]): void;
+    head(path: string, ...middlewaresAndHandler: any[]): void;
+}

package/dist/core/id-generator.d.ts

@@ -0,0 +1,3 @@
+export declare class IdGenerator {
+    static generate(): string;
+}

package/dist/core/logger.d.ts

@@ -0,0 +1,29 @@
+export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";
+export interface LoggerOptions {
+    level?: LogLevel;
+    context?: string;
+    enabled?: boolean;
+    hooks?: Array<(entry: LogEntry) => void>;
+}
+export interface LogEntry {
+    timestamp: string;
+    level: LogLevel;
+    message: string;
+    context?: string;
+    data?: any;
+}
+export declare class Logger {
+    private level;
+    private context?;
+    private enabled;
+    private hooks;
+    constructor(options?: LoggerOptions);
+    private shouldLog;
+    private emit;
+    debug(msg: string, data?: any): void;
+    info(msg: string, data?: any): void;
+    warn(msg: string, data?: any): void;
+    error(msg: string, data?: any): void;
+    fatal(msg: string, data?: any): void;
+    withContext(context: string): Logger;
+}

package/dist/core/router.d.ts

@@ -0,0 +1,16 @@
+import { Storage } from "../storage-adapters/storage.interface";
+import { Logger } from "./logger";
+import { AnyNormalizedEvent } from "../types/event.types";
+export type RouterHook = (event: AnyNormalizedEvent) => void | Promise<void>;
+export interface RouterOptions {
+    logger?: Logger;
+    hooks?: RouterHook[];
+}
+export declare class CoreRouter {
+    private storage;
+    private logger;
+    private hooks;
+    constructor(storage: Storage, options?: RouterOptions);
+    dispatch(event: AnyNormalizedEvent): Promise<void>;
+    addHook(hook: RouterHook): void;
+}

package/dist/core/server.d.ts

@@ -0,0 +1,25 @@
+import { Logger } from "./logger";
+import { CoreRouter } from "./router";
+import { StorageManager } from "./storage";
+import { Listener } from "../listeners/listener.interface";
+export interface CoreServerOptions {
+    logger?: Logger;
+    storage?: StorageManager;
+    listeners?: Listener[];
+}
+export declare class CoreServer {
+    private logger;
+    private storage;
+    private router;
+    private listeners;
+    constructor(options?: CoreServerOptions);
+    getRouter(): CoreRouter;
+    getStorage(): StorageManager;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Méthode appelée par CoreRouter après chaque event normalisé.
+     * Permet de diffuser l’event aux listeners SSE (ApiListener).
+     */
+    broadcast(event: any): void;
+}

package/dist/core/storage.d.ts

@@ -0,0 +1,24 @@
+import { Storage } from "../storage-adapters/storage.interface";
+import { AnyNormalizedEvent } from "../types/event.types";
+import { Logger } from "./logger";
+export declare class StorageManager implements Storage {
+    private events;
+    private logger;
+    constructor(options?: {
+        logger?: Logger;
+    });
+    save(event: AnyNormalizedEvent): Promise<void>;
+    getEvent(id: string): Promise<AnyNormalizedEvent | null>;
+    listEvents(params: {
+        type?: string;
+        page?: number;
+        limit?: number;
+    }): Promise<AnyNormalizedEvent[]>;
+    getAll(): Promise<AnyNormalizedEvent[]>;
+    deleteEvent(id: string): Promise<boolean>;
+    clearEvents(): Promise<void>;
+    getStats(): Promise<{
+        total: number;
+        byType: Record<string, number>;
+    }>;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { ApiListener } from "./listeners/api/api.listener";
+export { HttpListener } from "./listeners/http/http.listener";
+export { DnsListener } from "./listeners/dns/dns.listener";
+export { SmtpListener } from "./listeners/smtp/smtp.listener";
+export { TcpListener } from "./listeners/tcp/tcp.listener";
+export { CoreServer } from "./core/server";
+export { CoreRouter } from "./core/router";
+export { StorageManager } from "./core/storage";
+export { Logger } from "./core/logger";

package/dist/index.js

@@ -1,76 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = require("./core/logger");
-const storage_1 = require("./core/storage");
-const router_1 = require("./core/router");
-const server_1 = require("./core/server");
-// Listeners
-const api_listener_1 = require("./listeners/api/api.listener");
-const http_listener_1 = require("./listeners/http/http.listener");
-const dns_listener_1 = require("./listeners/dns/dns.listener");
-const smtp_listener_1 = require("./listeners/smtp/smtp.listener");
-const tcp_listener_1 = require("./listeners/tcp/tcp.listener");
-async function main() {
-    const logger = new logger_1.Logger({ context: "Bootstrap" });
-    // Core components
-    const storage = new storage_1.StorageManager({
-        logger: logger.withContext("Storage"),
-    });
-    const router = new router_1.CoreRouter(storage, {
-        logger: logger.withContext("CoreRouter"),
-    });
-    // ---------------------------
-    // LISTENERS
-    // ---------------------------
-    // API → (router, storage, options)
-    const apiListener = new api_listener_1.ApiListener(storage, {
-        port: 3100,
-        logger: logger.withContext("ApiListener"),
-    });
-    // HTTP → (router, options)
-    const httpListener = new http_listener_1.HttpListener(router, {
-        port: 8080,
-        logger: logger.withContext("HttpListener"),
-    });
-    // DNS → (router, options)
-    const dnsListener = new dns_listener_1.DnsListener(router, {
-        server: {},
-        logger: logger.withContext("DnsListener"),
-    });
-    const smtpListener = new smtp_listener_1.SmtpListener(router, {
-        server: {},
-        logger: logger.withContext("SmtpListener"),
-    });
-    // TCP → (router, storage, options)
-    const tcpListener = new tcp_listener_1.TcpListener(router, storage, {
-        port: 9000,
-        logger: logger.withContext("TcpListener"),
-    });
-    // ---------------------------
-    // CORE SERVER
-    // ---------------------------
-    const server = new server_1.CoreServer({
-        logger: logger.withContext("CoreServer"),
-        storage,
-        listeners: [
-            apiListener,
-            httpListener,
-            dnsListener,
-            smtpListener,
-            tcpListener,
-        ],
-    });
-    await server.start();
-    // Graceful shutdown
-    const shutdown = async () => {
-        logger.warn("Received shutdown signal, stopping server...");
-        await server.stop();
-        process.exit(0);
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-}
-main().catch((err) => {
-    console.error("Fatal error in bootstrap:", err);
-    process.exit(1);
-});
+exports.Logger = exports.StorageManager = exports.CoreRouter = exports.CoreServer = exports.TcpListener = exports.SmtpListener = exports.DnsListener = exports.HttpListener = exports.ApiListener = void 0;
+var api_listener_1 = require("./listeners/api/api.listener");
+Object.defineProperty(exports, "ApiListener", { enumerable: true, get: function () { return api_listener_1.ApiListener; } });
+var http_listener_1 = require("./listeners/http/http.listener");
+Object.defineProperty(exports, "HttpListener", { enumerable: true, get: function () { return http_listener_1.HttpListener; } });
+var dns_listener_1 = require("./listeners/dns/dns.listener");
+Object.defineProperty(exports, "DnsListener", { enumerable: true, get: function () { return dns_listener_1.DnsListener; } });
+var smtp_listener_1 = require("./listeners/smtp/smtp.listener");
+Object.defineProperty(exports, "SmtpListener", { enumerable: true, get: function () { return smtp_listener_1.SmtpListener; } });
+var tcp_listener_1 = require("./listeners/tcp/tcp.listener");
+Object.defineProperty(exports, "TcpListener", { enumerable: true, get: function () { return tcp_listener_1.TcpListener; } });
+var server_1 = require("./core/server");
+Object.defineProperty(exports, "CoreServer", { enumerable: true, get: function () { return server_1.CoreServer; } });
+var router_1 = require("./core/router");
+Object.defineProperty(exports, "CoreRouter", { enumerable: true, get: function () { return router_1.CoreRouter; } });
+var storage_1 = require("./core/storage");
+Object.defineProperty(exports, "StorageManager", { enumerable: true, get: function () { return storage_1.StorageManager; } });
+var logger_1 = require("./core/logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });

package/dist/listeners/api/__tests__/api.controller.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/api/__tests__/api.extractor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/api/__tests__/api.listener.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/api/__tests__/api.routes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/api/__tests__/api.sse.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/api/api.controllers.d.ts

@@ -0,0 +1,9 @@
+import { ServerResponse } from "http";
+import { StorageManager } from "../../core/storage";
+export declare class ApiController {
+    static listEvents(url: URL, res: ServerResponse, storage: StorageManager): Promise<void>;
+    static getEvent(id: string, res: ServerResponse, storage: StorageManager): Promise<void>;
+    static deleteAll(res: ServerResponse, storage: StorageManager): Promise<void>;
+    static deleteOne(id: string, res: ServerResponse, storage: StorageManager): Promise<void>;
+    static stats(res: ServerResponse, storage: StorageManager): Promise<void>;
+}

package/dist/listeners/api/api.extractor.d.ts

@@ -0,0 +1,5 @@
+import { IncomingMessage } from "http";
+import { RawEvent } from "../../types/event.types";
+export declare class ApiExtractor {
+    static extract(req: IncomingMessage): Promise<RawEvent>;
+}

package/dist/listeners/api/api.listener.d.ts

@@ -0,0 +1,17 @@
+import { Logger } from "../../core/logger";
+import { StorageManager } from "../../core/storage";
+export interface ApiListenerOptions {
+    port: number;
+    logger?: Logger;
+}
+export declare class ApiListener {
+    private storage;
+    private options;
+    private logger;
+    private server;
+    private sse;
+    constructor(storage: StorageManager, options: ApiListenerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    broadcastEvent(event: any): void;
+}

package/dist/listeners/api/api.routes.d.ts

@@ -0,0 +1,5 @@
+import { IncomingMessage, ServerResponse } from "http";
+import { Logger } from "../../core/logger";
+import { StorageManager } from "../../core/storage";
+import { ApiSse } from "./api.sse";
+export declare function handleApiRequest(req: IncomingMessage, res: ServerResponse, storage: StorageManager, sse: ApiSse, logger: Logger): Promise<void>;

package/dist/listeners/api/api.sse.d.ts

@@ -0,0 +1,10 @@
+import { ServerResponse } from "http";
+import { Logger } from "../../core/logger";
+export declare class ApiSse {
+    private logger;
+    private clients;
+    constructor(logger: Logger);
+    handle(res: ServerResponse): void;
+    broadcast(event: any): void;
+    closeAll(): void;
+}

package/dist/listeners/dns/__tests__/dns.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/dns/dns.extractor.d.ts

@@ -0,0 +1,8 @@
+export declare class DnsExtractor {
+    static extract(packet: any): {
+        ip: any;
+        query: any;
+        type: any;
+        raw: any;
+    };
+}

package/dist/listeners/dns/dns.listener.d.ts

@@ -0,0 +1,15 @@
+import { Logger } from "../../core/logger";
+import { CoreRouter } from "../../core/router";
+export interface DnsListenerOptions {
+    server: any;
+    logger?: Logger;
+}
+export declare class DnsListener {
+    private router;
+    private options;
+    private logger;
+    constructor(router: CoreRouter, options: DnsListenerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleQuery;
+}

package/dist/listeners/http/__tests__/http.extractor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/http/__tests__/http.listener.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/listeners/http/http.extractor.d.ts

@@ -0,0 +1,11 @@
+export declare class HttpExtractor {
+    static extract(req: any): {
+        ip: any;
+        method: any;
+        path: any;
+        headers: any;
+        query: any;
+        body: any;
+        raw: any;
+    };
+}