rax-flow 0.1.1 → 0.1.2

package/package/src/run.ts

@@ -0,0 +1,317 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import * as readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+import { CoreOrchestrator, WorkflowGraph } from "rax-flow-core";
+import { buildOfficialAgentsRuntime } from "rax-flow-agents";
+import { ClaudeAdapter, GenericRestAdapter, HostBridgeAdapter, OpenAIAdapter } from "rax-flow-providers";
+import { WebSocketRelay } from "./ws-relay.js";
+import { c } from "./styles.js";
+
+interface RunOptions {
+  cwd: string;
+  prompt: string;
+  workflowPath?: string;
+  asJson?: boolean;
+  stream?: boolean;
+  maxParallel?: number;
+  noCachePersist?: boolean;
+  providerOverride?: string;
+  bridgeCommandOverride?: string;
+  ui?: boolean;
+  yolo?: boolean;
+}
+
+
+interface RaxConfig {
+  defaultProvider?: string;
+  strongProvider?: string;
+  providers?: {
+    host?: { model?: string; mode?: "auto" | "bridge-only" | "mock"; bridgeCommandEnv?: string; timeoutMs?: number };
+    openai?: { model?: string; apiKeyEnv?: string; baseUrl?: string };
+    claude?: { model?: string; apiKeyEnv?: string; baseUrl?: string };
+    rest?: { endpoint?: string; tokenEnv?: string; model?: string };
+  };
+}
+
+async function loadConfig(cwd: string): Promise<RaxConfig> {
+  const file = path.join(cwd, ".raxrc");
+  const raw = await readFile(file, "utf8");
+  return JSON.parse(raw) as RaxConfig;
+}
+
+async function loadWorkflow(cwd: string, workflowPath?: string): Promise<WorkflowGraph | undefined> {
+  const file = workflowPath
+    ? path.resolve(cwd, workflowPath)
+    : path.join(cwd, ".rax-flow", "workflows", "fullstack-feature.json");
+
+  try {
+    const raw = await readFile(file, "utf8");
+    return JSON.parse(raw) as WorkflowGraph;
+  } catch {
+    return undefined;
+  }
+}
+
+function createProviders(config: RaxConfig, bridgeCommandOverride?: string) {
+  const providers: Record<string, OpenAIAdapter | ClaudeAdapter | GenericRestAdapter | HostBridgeAdapter> = {};
+
+  const hostCfg = config.providers?.host;
+  const bridgeCommand = bridgeCommandOverride ?? process.env[hostCfg?.bridgeCommandEnv ?? "RAX_HOST_BRIDGE_COMMAND"];
+  providers.host = new HostBridgeAdapter({
+    model: hostCfg?.model ?? "host-managed",
+    mode: hostCfg?.mode ?? "auto",
+    command: bridgeCommand,
+    timeoutMs: hostCfg?.timeoutMs ?? 20000
+  });
+
+  const openaiKey = process.env[config.providers?.openai?.apiKeyEnv ?? "OPENAI_API_KEY"];
+  if (openaiKey) {
+    providers.openai = new OpenAIAdapter(openaiKey, config.providers?.openai?.baseUrl);
+  }
+
+  const claudeKey = process.env[config.providers?.claude?.apiKeyEnv ?? "ANTHROPIC_API_KEY"];
+  if (claudeKey) {
+    providers.claude = new ClaudeAdapter(claudeKey, config.providers?.claude?.baseUrl);
+  }
+
+  const restEndpoint = config.providers?.rest?.endpoint;
+  if (restEndpoint) {
+    const restToken = process.env[config.providers?.rest?.tokenEnv ?? "RAX_REST_TOKEN"];
+    providers.rest = new GenericRestAdapter(restEndpoint, restToken);
+  }
+
+  return providers;
+}
+
+function cachePath(cwd: string): string {
+  return path.join(cwd, ".rax-flow", "cache", "semantic-cache.json");
+}
+
+async function saveHistory(cwd: string, taskId: string, data: any) {
+  const dir = path.join(cwd, ".rax-flow", "history");
+  await mkdir(dir, { recursive: true });
+  const file = path.join(dir, `${taskId}.json`);
+  await writeFile(file, JSON.stringify(data, null, 2));
+}
+
+async function askApproval(nodeId: string, agent: string, data: any): Promise<{ approved: boolean; feedback?: string }> {
+  const rl = readline.createInterface({ input, output });
+  console.log(c.magenta("\n--- [HUMAN INTERVENTION REQUIRED] ---"));
+  console.log(c.cyan(`Step: ${nodeId} | Agent: ${agent}`));
+  console.log(c.white("Candidate Output Data:"));
+  console.log(JSON.stringify(data, null, 2));
+
+  const answer = await rl.question(c.yellow("\nApprove? [Y to accept, or type your feedback to reject/fix]: "));
+  rl.close();
+
+  if (answer.toLowerCase() === "y" || answer === "") {
+    return { approved: true };
+  } else {
+    return { approved: false, feedback: answer };
+  }
+}
+
+
+export async function runWorkflow(options: RunOptions): Promise<number> {
+  let config: RaxConfig;
+  try {
+    config = await loadConfig(options.cwd);
+  } catch {
+    console.error(c.red("Missing .raxrc. Run `rax-flow install` first."));
+    return 1;
+  }
+  const providers = createProviders(config, options.bridgeCommandOverride);
+  const selectedDefault = options.providerOverride ?? config.defaultProvider ?? "host";
+
+  // Pre-flight check: Ensure Zero-Error compliance for Bridge integration
+  if (selectedDefault === "host") {
+    const health = await providers.host.healthCheck();
+    if (!health) {
+      console.error(c.red(`[Error] Host Bridge connectivity failed.`));
+      console.error(c.yellow(`Check your .raxrc or set RAX_HOST_BRIDGE_COMMAND env var.`));
+      console.log("Tip: run `rax-flow doctor` for detailed diagnostics.");
+      return 1;
+    }
+  }
+
+  const selectedStrong = config.strongProvider ?? "host";
+
+
+  const agents = buildOfficialAgentsRuntime({
+    providers,
+    defaultProvider: selectedDefault,
+    strongProvider: selectedStrong,
+    providerModels: {
+      host: config.providers?.host?.model ?? "host-managed",
+      openai: config.providers?.openai?.model ?? "gpt-4.1-mini",
+      claude: config.providers?.claude?.model ?? "claude-3-5-sonnet-latest",
+      rest: config.providers?.rest?.model ?? "generic-llm"
+    }
+  });
+
+  const workflow = await loadWorkflow(options.cwd, options.workflowPath);
+  // Memory System: Quantum Semantic Graph Memory (QSGM)
+  const memoryDir = path.join(options.cwd, ".rax-flow", "memory");
+  const { LocalVectorStore, GraphMemory, MemoryManager } = await import("rax-flow-core");
+
+  const vectorStore = new LocalVectorStore(path.join(memoryDir, "vector-index.json"));
+  await vectorStore.load();
+
+  const graphMemory = new GraphMemory(path.join(memoryDir, "graph-memory.json"));
+  await graphMemory.load();
+
+  const memoryManager = new MemoryManager(vectorStore, graphMemory);
+
+  const orchestrator = new CoreOrchestrator(providers, agents, { memory: memoryManager }, { maxParallel: options.maxParallel ?? 4, cacheTtlMs: 1000 * 60 * 60 * 24 });
+
+  // Governance System: Enterprise security & compliance
+  const { GovernancePlugin, PIIPolicy } = await import("rax-flow-core");
+  const governancePlugin = new GovernancePlugin(
+    [new PIIPolicy()],
+    path.join(options.cwd, ".rax-flow", "audit"),
+    orchestrator.events
+  );
+  orchestrator.registerPlugin(governancePlugin);
+
+
+  // Register Memory Plugin if an embedding provider is available (OpenAI in this case)
+  if (providers.openai) {
+    const { LongTermMemoryPlugin } = await import("rax-flow-core");
+    orchestrator.registerPlugin(new LongTermMemoryPlugin(memoryManager, providers.openai as any));
+  }
+
+
+
+  let relay: WebSocketRelay | undefined;
+
+  if (options.ui) {
+    relay = new WebSocketRelay(3002);
+    relay.start(orchestrator.events);
+  }
+
+  const persistentCacheFile = cachePath(options.cwd);
+  if (!options.noCachePersist) {
+    await orchestrator.loadCache(persistentCacheFile);
+  }
+
+  const sessionEvents: any[] = [];
+  orchestrator.onEvent(e => sessionEvents.push(e));
+
+  // Connect WebSocket relay resolutions to orchestrator
+  orchestrator.onEvent((event: any) => {
+    if (event.type === "INTERNAL_RESOLVE_APPROVAL") {
+      orchestrator.resolveApproval(event.taskId, event.nodeId, event.approved, event.feedback);
+    }
+  });
+
+  if (options.stream) {
+    orchestrator.onEvent((event) => {
+      if (event.type === "graph_ready") {
+        console.log(c.magenta(c.bold(`\n--- [DAG FLOW] ---`)));
+        const edgeCount = event.workflow.nodes.reduce((acc: number, n: any) => acc + (n.dependsOn?.length || 0), 0);
+        console.log(c.gray(`Tasks: ${event.workflow.nodes.length} | Edges: ${edgeCount}`));
+      }
+
+      if (event.type === "node_start") {
+        const retryPrefix = event.retry > 0 ? c.yellow(` (Retry ${event.retry})`) : "";
+        console.log(`${c.blue("◆")} ${c.bold(event.nodeId)}${retryPrefix} ${c.gray(`[${event.agent}]`)}`);
+      }
+
+      if (event.type === "node_awaiting_approval") {
+        if (options.yolo) {
+          orchestrator.resolveApproval(event.taskId, event.nodeId, true);
+        } else {
+          (async () => {
+            const { approved, feedback } = await askApproval(event.nodeId, event.agent, event.data);
+            orchestrator.resolveApproval(event.taskId, event.nodeId, approved, feedback);
+          })();
+        }
+      }
+
+      if (event.type === "node_end") {
+        const confColor = event.confidence >= 0.8 ? c.green : (event.confidence >= 0.6 ? c.yellow : c.red);
+        const icon = event.success ? c.green("✔") : c.red("✘");
+        console.log(`  ${icon} ${confColor(`conf: ${(event.confidence * 100).toFixed(0)}%`)} ${c.gray(`cost: $${(event.costUsd || 0).toFixed(5)}`)}`);
+      }
+
+      if (event.type === "node_error") {
+        console.log(`  ${c.red("!")} ${c.red(event.message)}`);
+      }
+
+      if (event.type === "audit_record" && event.mutation) {
+        console.log(c.magenta(`\n🧬 [Genetic Mutation Generated]`));
+        console.log(c.magenta(`   Reason: ${event.mutation.reason ?? "Optimization"}`));
+      }
+    });
+  }
+
+  const taskId = `task_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
+  const result = await orchestrator.run(
+    {
+      taskId,
+      userPrompt: options.prompt,
+      context: {
+        cli: true,
+        host: os.hostname()
+      }
+    },
+    workflow
+  );
+
+  if (relay) {
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    relay.stop();
+  }
+
+  if (!options.noCachePersist) {
+    await orchestrator.saveCache(persistentCacheFile);
+  }
+
+  // Save to history
+  await saveHistory(options.cwd, taskId, {
+    taskId,
+    timestamp: Date.now(),
+    prompt: options.prompt,
+    result: result.result,
+    metrics: result.metrics,
+    workflow: result.workflow,
+    events: sessionEvents
+  });
+
+  if (options.asJson) {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+
+  // Final Summary Table
+  console.log(c.bold(c.cyan(`\n\n--- [RUN SUMMARY] ---`)));
+  const tableData = [
+    ["Task ID", taskId],
+    ["Main Agent", result.result.agent],
+    ["Status", result.result.success ? c.green("SUCCESS") : c.red("FAILED")],
+    ["Confidence", `${(result.result.confidence * 100).toFixed(1)}%`],
+    ["Retries", result.metrics.retries.toString()],
+    ["Escalations", result.metrics.escalations.toString()],
+    ["Latency", `${(result.metrics.totalLatencyMs / 1000).toFixed(2)}s`],
+    ["Total Cost", c.yellow(`$${(result.metrics.totalCostUsd || 0).toFixed(5)}`)]
+  ];
+
+  for (const [key, value] of tableData) {
+    console.log(`${c.bold(key.padEnd(15))} : ${value}`);
+  }
+
+  if (result.result.logs.length > 0) {
+    console.log(c.bold(`\nTrace Logs:`));
+    for (const line of result.result.logs.slice(-5)) {
+      console.log(c.gray(`  • ${line}`));
+    }
+    if (result.result.logs.length > 5) {
+      console.log(c.gray(`  ... and ${result.result.logs.length - 5} more lines.`));
+    }
+  }
+
+  return 0;
+}

package/package/src/styles.ts

@@ -0,0 +1,12 @@
+export const c = {
+  blue: (s: string) => `\u001b[34m${s}\u001b[0m`,
+  green: (s: string) => `\u001b[32m${s}\u001b[0m`,
+  yellow: (s: string) => `\u001b[33m${s}\u001b[0m`,
+  red: (s: string) => `\u001b[31m${s}\u001b[0m`,
+  magenta: (s: string) => `\u001b[35m${s}\u001b[0m`,
+  cyan: (s: string) => `\u001b[36m${s}\u001b[0m`,
+  white: (s: string) => `\u001b[37m${s}\u001b[0m`,
+  gray: (s: string) => `\u001b[90m${s}\u001b[0m`,
+  bold: (s: string) => `\u001b[1m${s}\u001b[22m`
+};
+

package/package/src/vendor-manifests.ts

@@ -0,0 +1,113 @@
+import path from "node:path";
+import { HostTarget } from "./host-init-templates.js";
+
+export interface HostManifestModel {
+  version: number;
+  target: HostTarget;
+  title: string;
+  autoInjectMode: "native" | "scripted" | "manual";
+  bridgeCommand: string;
+  quickCommands: string[];
+  sessionEntryExamples: string[];
+  task: string | null;
+  files: {
+    bootstrapPrompt: string;
+    instructions: string;
+    bridgeAdapter: string;
+    bridgeRuntimeConfig: string;
+    bridgeSmokeTest: string;
+    vendorManifest: string;
+  };
+}
+
+function toRelative(baseDir: string, file: string): string {
+  const rel = path.relative(baseDir, file);
+  return rel.length > 0 ? rel : path.basename(file);
+}
+
+function buildClaudeManifest(baseDir: string, manifest: HostManifestModel) {
+  return {
+    schema: "rax.vendor.claude-code.v1",
+    session: {
+      initMessageFile: toRelative(baseDir, manifest.files.bootstrapPrompt),
+      mode: manifest.autoInjectMode,
+      bridgeCommand: manifest.bridgeCommand
+    },
+    orchestrator: {
+      tool: "rax-flow",
+      quickCommands: manifest.quickCommands
+    }
+  };
+}
+
+function buildCodexManifest(baseDir: string, manifest: HostManifestModel) {
+  return {
+    schema: "rax.vendor.codex.v1",
+    chat: {
+      bootstrapFile: toRelative(baseDir, manifest.files.bootstrapPrompt),
+      strategy: manifest.autoInjectMode
+    },
+    runtime: {
+      bridgeCommand: manifest.bridgeCommand,
+      taskContext: manifest.task
+    }
+  };
+}
+
+function buildOpenCodeManifest(baseDir: string, manifest: HostManifestModel) {
+  return {
+    schema: "rax.vendor.opencode.v1",
+    integration: {
+      startupPromptFile: toRelative(baseDir, manifest.files.bootstrapPrompt),
+      launchMode: manifest.autoInjectMode
+    },
+    orchestration: {
+      quickCommands: manifest.quickCommands,
+      bridgeCommand: manifest.bridgeCommand
+    }
+  };
+}
+
+function buildKiloManifest(baseDir: string, manifest: HostManifestModel) {
+  return {
+    schema: "rax.vendor.kilo.v1",
+    initializer: {
+      promptFile: toRelative(baseDir, manifest.files.bootstrapPrompt),
+      injectMode: manifest.autoInjectMode
+    },
+    runtime: {
+      bridgeCommand: manifest.bridgeCommand,
+      commandHints: manifest.sessionEntryExamples
+    }
+  };
+}
+
+function buildGenericManifest(baseDir: string, manifest: HostManifestModel) {
+  return {
+    schema: "rax.vendor.generic.v1",
+    bootstrap: {
+      file: toRelative(baseDir, manifest.files.bootstrapPrompt)
+    },
+    bridge: {
+      command: manifest.bridgeCommand,
+      mode: manifest.autoInjectMode
+    },
+    commands: manifest.quickCommands
+  };
+}
+
+export function generateVendorManifest(target: HostTarget, baseDir: string, manifest: HostManifestModel): Record<string, unknown> {
+  if (target === "claude-code") return buildClaudeManifest(baseDir, manifest);
+  if (target === "codex") return buildCodexManifest(baseDir, manifest);
+  if (target === "opencode") return buildOpenCodeManifest(baseDir, manifest);
+  if (target === "kilo") return buildKiloManifest(baseDir, manifest);
+  return buildGenericManifest(baseDir, manifest);
+}
+
+export function vendorManifestFilename(target: HostTarget): string {
+  if (target === "claude-code") return "vendor-claude-code.json";
+  if (target === "codex") return "vendor-codex.json";
+  if (target === "opencode") return "vendor-opencode.json";
+  if (target === "kilo") return "vendor-kilo.json";
+  return "vendor-generic.json";
+}

package/package/src/ws-relay.ts

@@ -0,0 +1,156 @@
+import { WebSocketServer, WebSocket } from "ws";
+import { RuntimeEventBus } from "rax-flow-core";
+import { readdir, readFile, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+export class WebSocketRelay {
+    private wss: WebSocketServer | null = null;
+    private clients = new Set<WebSocket>();
+    private bus: RuntimeEventBus | null = null;
+
+    constructor(private port: number = 3002) { }
+
+    public start(eventBus: RuntimeEventBus): void {
+        this.bus = eventBus;
+        try {
+            this.wss = new WebSocketServer({ port: this.port });
+            console.log(`\n[UI] 📡 WebSocket relay started on ws://localhost:${this.port}`);
+
+            this.wss.on("connection", (ws) => {
+                this.clients.add(ws);
+                ws.send(JSON.stringify({ type: "HELLO", timestamp: Date.now() }));
+
+                ws.on("close", () => {
+                    this.clients.delete(ws);
+                });
+
+                ws.on("message", async (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        const historyDir = path.join(process.cwd(), ".rax-flow", "history");
+
+                        if (message.type === "GET_HISTORY") {
+                            try {
+                                const files = await readdir(historyDir);
+                                const runs = await Promise.all(
+                                    files.filter(f => f.endsWith(".json")).map(async f => {
+                                        const content = await readFile(path.join(historyDir, f), "utf8");
+                                        const parsed = JSON.parse(content);
+                                        return {
+                                            taskId: parsed.taskId,
+                                            timestamp: parsed.timestamp,
+                                            prompt: parsed.prompt,
+                                            success: parsed.result.success,
+                                            costUsd: parsed.metrics.totalCostUsd
+                                        };
+                                    })
+                                );
+                                ws.send(JSON.stringify({ type: "HISTORY_LIST", runs: runs.sort((a, b) => b.timestamp - a.timestamp) }));
+                            } catch {
+                                ws.send(JSON.stringify({ type: "HISTORY_LIST", runs: [] }));
+                            }
+                        }
+
+                        else if (message.type === "LOAD_RUN") {
+                            try {
+                                const file = path.join(historyDir, `${message.taskId}.json`);
+                                const content = await readFile(file, "utf8");
+                                ws.send(JSON.stringify({ type: "RUN_DATA", data: JSON.parse(content) }));
+                            } catch (err) {
+                                ws.send(JSON.stringify({ type: "ERROR", message: "Run not found" }));
+                            }
+                        }
+
+                        else if (message.type === "LIST_WORKFLOWS") {
+                            const workflowsDir = path.join(process.cwd(), ".rax-flow", "workflows");
+                            try {
+                                const files = await readdir(workflowsDir);
+                                const list = files.filter(f => f.endsWith(".json")).map(f => ({
+                                    id: f.replace(".json", ""),
+                                    filename: f
+                                }));
+                                ws.send(JSON.stringify({ type: "WORKFLOW_LIST", workflows: list }));
+                            } catch {
+                                ws.send(JSON.stringify({ type: "WORKFLOW_LIST", workflows: [] }));
+                            }
+                        }
+
+                        else if (message.type === "RESOLVE_APPROVAL") {
+                            this.bus?.emit({
+                                type: "INTERNAL_RESOLVE_APPROVAL",
+                                taskId: message.taskId,
+                                nodeId: message.nodeId,
+                                approved: message.approved,
+                                feedback: message.feedback
+                            } as any);
+                        }
+
+                        else if (message.type === "SAVE_WORKFLOW") {
+                            try {
+                                const workflowsDir = path.join(process.cwd(), ".rax-flow", "workflows");
+                                await mkdir(workflowsDir, { recursive: true });
+                                const file = path.join(workflowsDir, `${message.id}.json`);
+                                const data = {
+                                    id: message.id,
+                                    nodes: message.nodes,
+                                    edges: message.edges
+                                };
+                                await writeFile(file, JSON.stringify(data, null, 2));
+                                ws.send(JSON.stringify({ type: "INFO", message: `Workflow ${message.id} saved.` }));
+                                this.broadcast({ type: "REFRESH_WORKFLOWS" });
+                            } catch (err) {
+                                ws.send(JSON.stringify({ type: "ERROR", message: "Failed to save workflow" }));
+                            }
+                        }
+
+                        else if (message.type === "DELETE_WORKFLOW") {
+                            try {
+                                const url = path.join(process.cwd(), ".rax-flow", "workflows", `${message.id}.json`);
+                                const { unlink } = await import("node:fs/promises");
+                                await unlink(url);
+                                this.broadcast({ type: "REFRESH_WORKFLOWS" });
+                            } catch (err) {
+                                ws.send(JSON.stringify({ type: "ERROR", message: "Failed to delete workflow" }));
+                            }
+                        }
+                    } catch (e) {
+                        console.error("[WS] Message parse error:", e);
+                    }
+                });
+
+                ws.on("error", () => {
+                    this.clients.delete(ws);
+                });
+            });
+
+            this.wss.on("error", (err) => {
+                console.error(`[UI] WebSocket server error: ${err.message}`);
+            });
+
+            eventBus.onEvent((event) => {
+                this.broadcast(event);
+            });
+        } catch (err) {
+            console.error(`[UI] Failed to start WebSocket server: ${err}`);
+        }
+    }
+
+    private broadcast(event: unknown): void {
+        if (!this.wss) return;
+        const payload = JSON.stringify(event);
+        for (const client of this.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(payload);
+            }
+        }
+    }
+
+    public stop(): void {
+        if (this.wss) {
+            this.wss.close();
+            this.wss = null;
+            this.clients.clear();
+            console.log("[UI] 📡 WebSocket relay stopped.");
+        }
+    }
+}

package/package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": ["src/**/*.ts"],
+  "references": [{ "path": "../core" }, { "path": "../agents" }, { "path": "../providers" }]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rax-flow",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,9 +14,9 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "rax-flow-agents": "0.1.1",
-    "rax-flow-core": "0.1.1",
-    "rax-flow-providers": "0.1.1",
+    "rax-flow-agents": "0.1.2",
+    "rax-flow-core": "0.1.2",
+    "rax-flow-providers": "0.1.2",
     "ws": "^8.19.0"
   },
   "publishConfig": {
@@ -25,4 +25,4 @@
   "devDependencies": {
     "@types/ws": "^8.18.1"
   }
-}
+}