@netkitty/analysis 1.0.0

package/dist/lib/streaming/worker/WorkerEndpoint.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerEndpoint = void 0;
+/**
+ * Worker side of the channel: registers request handlers (their return value, awaited, becomes the
+ * response) and can push notify messages back to the main thread. Shared by the real analysis worker
+ * and test workers, so the request/response wiring lives in one place. A thrown/rejected handler is
+ * reported as an error response rather than crashing the worker.
+ */
+class WorkerEndpoint {
+    #port;
+    #handlers = new Map();
+    constructor(port) {
+        this.#port = port;
+        this.#port.on('message', (message) => { void this.#onMessage(message); });
+    }
+    handle(method, handler) {
+        this.#handlers.set(method, handler);
+    }
+    notify(method, payload, transfer) {
+        this.#port.postMessage({ kind: 'notify', method: method, payload: payload }, transfer ? transfer : []);
+    }
+    async #onMessage(message) {
+        if (message.kind === 'request') {
+            const handler = this.#handlers.get(message.method);
+            if (!handler) {
+                this.#port.postMessage({ kind: 'response', id: message.id, ok: false, error: `no handler for method: ${message.method}` });
+                return;
+            }
+            try {
+                const result = await handler(message.payload);
+                this.#port.postMessage({ kind: 'response', id: message.id, ok: true, payload: result });
+            }
+            catch (error) {
+                this.#port.postMessage({ kind: 'response', id: message.id, ok: false, error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        else if (message.kind === 'notify') {
+            const handler = this.#handlers.get(message.method);
+            if (handler)
+                void handler(message.payload);
+        }
+    }
+}
+exports.WorkerEndpoint = WorkerEndpoint;

package/dist/lib/streaming/worker/WorkerMessage.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Wire protocol between the Analysis facade (main thread) and the analysis worker. Only the
+ * invoke/notify semantics are borrowed from capture's pipe layer; the transport is plain
+ * worker_threads / Web Worker postMessage, and ArrayBuffers ride the transfer list without copying.
+ */
+export type WorkerRequest = {
+    kind: 'request';
+    id: number;
+    method: string;
+    payload: unknown;
+};
+export type WorkerResponse = {
+    kind: 'response';
+    id: number;
+    ok: boolean;
+    payload?: unknown;
+    error?: string;
+};
+export type WorkerNotify = {
+    kind: 'notify';
+    method: string;
+    payload: unknown;
+};
+export type WorkerMessage = WorkerRequest | WorkerResponse | WorkerNotify;

package/dist/lib/streaming/worker/WorkerMessage.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/streaming/worker/analysisWorker.d.ts

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

package/dist/lib/streaming/worker/analysisWorker.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_worker_threads_1 = require("node:worker_threads");
+const WorkerEndpoint_1 = require("./WorkerEndpoint");
+const NodeFileReadBackend_1 = require("../backends/NodeFileReadBackend");
+const AnalysisWorkerCore_1 = require("./AnalysisWorkerCore");
+/**
+ * node analysis worker entrypoint: a WorkerEndpoint over the worker_threads parent port, and a backend
+ * factory that treats the source as a filesystem path. All handler logic lives in AnalysisWorkerCore.
+ */
+(0, AnalysisWorkerCore_1.installAnalysisHandlers)(new WorkerEndpoint_1.WorkerEndpoint(node_worker_threads_1.parentPort), (source) => new NodeFileReadBackend_1.NodeFileReadBackend(source));

package/dist/lib/streaming/worker/analysisWorkerBrowser.d.ts

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

package/dist/lib/streaming/worker/analysisWorkerBrowser.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const WebWorkerEndpoint_1 = require("./WebWorkerEndpoint");
+const BrowserFileReadBackend_1 = require("../backends/BrowserFileReadBackend");
+const AnalysisWorkerCore_1 = require("./AnalysisWorkerCore");
+(0, AnalysisWorkerCore_1.installAnalysisHandlers)(new WebWorkerEndpoint_1.WebWorkerEndpoint(self), (source) => {
+    if (source instanceof ArrayBuffer)
+        return new BrowserFileReadBackend_1.BrowserFileReadBackend(new Blob([source]));
+    if (source instanceof Uint8Array)
+        return new BrowserFileReadBackend_1.BrowserFileReadBackend(new Blob([source]));
+    return new BrowserFileReadBackend_1.BrowserFileReadBackend(source);
+});

package/dist/lib/streaming/worker/spawnNodeAnalysisChannel.d.ts

@@ -0,0 +1,7 @@
+import { IWorkerChannel } from '../interfaces/IWorkerChannel';
+/**
+ * node channel factory: spawns the analysis worker (sibling compiled .js) and wraps it in a
+ * NodeWorkerChannel. Loaded lazily by the Analysis facade so the facade itself never statically
+ * imports worker_threads and stays environment-agnostic.
+ */
+export declare function spawnNodeAnalysisChannel(): IWorkerChannel;

package/dist/lib/streaming/worker/spawnNodeAnalysisChannel.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnNodeAnalysisChannel = spawnNodeAnalysisChannel;
+const node_worker_threads_1 = require("node:worker_threads");
+const node_path_1 = __importDefault(require("node:path"));
+const NodeWorkerChannel_1 = require("./NodeWorkerChannel");
+/**
+ * node channel factory: spawns the analysis worker (sibling compiled .js) and wraps it in a
+ * NodeWorkerChannel. Loaded lazily by the Analysis facade so the facade itself never statically
+ * imports worker_threads and stays environment-agnostic.
+ */
+function spawnNodeAnalysisChannel() {
+    const worker = new node_worker_threads_1.Worker(node_path_1.default.resolve(__dirname, 'analysisWorker.js'));
+    return new NodeWorkerChannel_1.NodeWorkerChannel(worker);
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@netkitty/analysis",
+  "version": "1.0.0",
+  "description": "Streaming cross-packet network analysis over the netkitty codec: TCP stream reassembly, flow tracking and Wireshark-style follow-stream, off a worker.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "README.zh-CN.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "clean": "shx rm -rf ./dist ./dist-test",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "build:test": "tsc -p tsconfig.test.json",
+    "test": "npm run build:test && node --test \"dist-test/**/*.spec.js\"",
+    "test:only": "node --test \"dist-test/**/*.spec.js\""
+  },
+  "keywords": [
+    "netkitty",
+    "network-analysis",
+    "packet-analysis",
+    "flow",
+    "flow-analysis",
+    "tcp-stream",
+    "stream-reassembly",
+    "follow-tcp-stream",
+    "tcp",
+    "wireshark",
+    "deep-packet-inspection",
+    "dpi",
+    "pcap",
+    "network"
+  ],
+  "author": "alex.ma",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "shx": "^0.3.4",
+    "typescript": "^5.8.2"
+  },
+  "dependencies": {
+    "@netkitty/codec": "^1.0.0",
+    "@netkitty/pcap-core": "^1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/myq1991/netkitty.git",
+    "directory": "packages/analysis"
+  },
+  "homepage": "https://github.com/myq1991/netkitty/tree/main/packages/analysis#readme",
+  "bugs": "https://github.com/myq1991/netkitty/issues",
+  "gitHead": "d71e793d2017c0f207f7b829adfcce11b56fe7ee"
+}