faultmesh 1.0.0

package/dist/toxics/LatencyToxic.js

@@ -0,0 +1,40 @@
+import { BaseToxic } from './BaseToxic.js';
+export class LatencyToxic extends BaseToxic {
+    type = 'latency';
+    latencyMs;
+    jitterMs;
+    pendingTimer = null;
+    constructor(config) {
+        super();
+        this.latencyMs = Math.max(0, config.latencyMs);
+        this.jitterMs = Math.max(0, config.jitterMs ?? 0);
+    }
+    calculateDelay() {
+        if (this.jitterMs === 0)
+            return this.latencyMs;
+        const jitter = (Math.random() * 2 - 1) * this.jitterMs;
+        return Math.max(0, Math.round(this.latencyMs + jitter));
+    }
+    _transform(chunk, encoding, callback) {
+        const delay = this.calculateDelay();
+        this.bytesProcessed += chunk.length;
+        if (delay === 0) {
+            this.push(chunk);
+            callback();
+            return;
+        }
+        this.pendingTimer = setTimeout(() => {
+            this.pendingTimer = null;
+            if (!this.destroyedCleanly) {
+                this.push(chunk);
+                callback();
+            }
+        }, delay);
+    }
+    cleanup() {
+        if (this.pendingTimer) {
+            clearTimeout(this.pendingTimer);
+            this.pendingTimer = null;
+        }
+    }
+}

package/dist/toxics/StatusToxic.d.ts

@@ -0,0 +1,9 @@
+import { StatusToxicConfig, ToxicType } from '../types.js';
+export declare class StatusToxic {
+    readonly type: ToxicType;
+    readonly statusCode: number;
+    readonly statusMessage: string;
+    readonly responseBody?: string;
+    constructor(config: StatusToxicConfig);
+    private getDefaultMessage;
+}

package/dist/toxics/StatusToxic.js

@@ -0,0 +1,22 @@
+export class StatusToxic {
+    type = 'status';
+    statusCode;
+    statusMessage;
+    responseBody;
+    constructor(config) {
+        this.statusCode = config.statusCode;
+        this.statusMessage = config.statusMessage || this.getDefaultMessage(config.statusCode);
+        this.responseBody = config.responseBody;
+    }
+    getDefaultMessage(code) {
+        switch (code) {
+            case 400: return 'Bad Request (FaultMesh Injected)';
+            case 429: return 'Too Many Requests (FaultMesh Rate-Limit)';
+            case 500: return 'Internal Server Error (FaultMesh Injected)';
+            case 502: return 'Bad Gateway (FaultMesh Upstream Dropped)';
+            case 503: return 'Service Unavailable (FaultMesh Maintenance)';
+            case 504: return 'Gateway Timeout (FaultMesh Deadlock)';
+            default: return 'FaultMesh Overridden Status';
+        }
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,123 @@
+/**
+ * FaultMesh Core Domain Types & Contracts
+ */
+export type ToxicType = 'latency' | 'bandwidth' | 'cut' | 'corrupt' | 'status';
+export type ToxicStreamDirection = 'upstream' | 'downstream';
+export interface LatencyToxicConfig {
+    latencyMs: number;
+    jitterMs?: number;
+}
+export interface BandwidthToxicConfig {
+    rateKbps: number;
+}
+export interface CutToxicConfig {
+    cutAfterBytes?: number;
+    cutAfterPercent?: number;
+}
+export interface CorruptToxicConfig {
+    corruptProbability?: number;
+    corruptType?: 'bitflip' | 'truncate' | 'garbage';
+}
+export interface StatusToxicConfig {
+    statusCode: number;
+    statusMessage?: string;
+    responseBody?: string;
+}
+export type ToxicConfigMap = {
+    latency: LatencyToxicConfig;
+    bandwidth: BandwidthToxicConfig;
+    cut: CutToxicConfig;
+    corrupt: CorruptToxicConfig;
+    status: StatusToxicConfig;
+};
+export interface ToxicRule<T extends ToxicType = ToxicType> {
+    id: string;
+    name: string;
+    type: T;
+    direction: ToxicStreamDirection;
+    enabled: boolean;
+    config: ToxicConfigMap[T];
+}
+export interface ProxyConfig {
+    port: number;
+    targetUrl: string;
+    host?: string;
+}
+export interface TelemetryEvent {
+    id: string;
+    timestamp: number;
+    method: string;
+    path: string;
+    statusCode: number;
+    durationMs: number;
+    bytesReceived: number;
+    bytesSent: number;
+    appliedToxics: string[];
+    error?: string;
+}
+export interface ProxyMetrics {
+    totalRequests: number;
+    activeConnections: number;
+    bytesProxied: number;
+    faultsInjected: number;
+    avgLatencyMs: number;
+}
+export interface ResilienceAttackResult {
+    name: string;
+    description: string;
+    toxicUsed: ToxicType;
+    passed: boolean;
+    latencyMs: number;
+    errorCaught?: string;
+    details: string;
+}
+export interface ResilienceScorecard {
+    score: number;
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+    timestamp: number;
+    totalAttacks: number;
+    passedAttacks: number;
+    results: ResilienceAttackResult[];
+    recommendations: string[];
+}
+export type SecuritySeverity = 'critical' | 'high' | 'medium' | 'low';
+export interface SecurityCheckResult {
+    id: string;
+    name: string;
+    category: 'headers' | 'cors' | 'leakage' | 'injection' | 'errors' | 'pii-leakage' | 'traversal';
+    description: string;
+    passed: boolean;
+    severity: SecuritySeverity;
+    latencyMs: number;
+    details: string;
+    remediation: string;
+}
+export interface SecurityScorecard {
+    score: number;
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+    timestamp: number;
+    totalChecks: number;
+    passedChecks: number;
+    checks: SecurityCheckResult[];
+    recommendations: string[];
+}
+export interface TrafficStormResult {
+    id: string;
+    name: string;
+    category: 'ratelimit' | 'payload' | 'slowloris' | 'idempotency';
+    description: string;
+    passed: boolean;
+    severity: SecuritySeverity;
+    latencyMs: number;
+    details: string;
+    remediation: string;
+}
+export interface TrafficStormScorecard {
+    score: number;
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
+    timestamp: number;
+    totalChecks: number;
+    passedChecks: number;
+    checks: TrafficStormResult[];
+    recommendations: string[];
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * FaultMesh Core Domain Types & Contracts
+ */
+export {};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "faultmesh",
+  "version": "1.0.0",
+  "description": "High-Precision Network & API Fault Injection Engine and Live Resilience Dashboard",
+  "type": "module",
+  "main": "dist/server.js",
+  "bin": {
+    "faultmesh": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "start": "tsx src/server.ts",
+    "build": "tsc && node scripts/copy-assets.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "keywords": ["chaos-engineering", "fault-injection", "proxy", "resilience", "testing"],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.10.1",
+    "@vitest/coverage-v8": "^2.1.8",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}