rax-flow 0.1.0 → 0.1.2

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.0",
+  "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.0",
-    "rax-flow-core": "0.1.0",
-    "rax-flow-providers": "0.1.0",
+    "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"
   }
-}
+}

package/src/benchmark.ts

@@ -1,9 +1,9 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { performance } from "node:perf_hooks";
-import { CoreOrchestrator } from "@rax-flow/core";
-import { buildOfficialAgentsRuntime } from "@rax-flow/agents";
-import { ClaudeAdapter, GenericRestAdapter, HostBridgeAdapter, OpenAIAdapter } from "@rax-flow/providers";
+import { CoreOrchestrator } from "rax-flow-core";
+import { buildOfficialAgentsRuntime } from "rax-flow-agents";
+import { ClaudeAdapter, GenericRestAdapter, HostBridgeAdapter, OpenAIAdapter } from "rax-flow-providers";
 import { c } from "./styles.js";
 import { readFile } from "node:fs/promises";
 

package/src/doctor.ts

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { HostBridgeAdapter } from "@rax-flow/providers";
+import { HostBridgeAdapter } from "rax-flow-providers";
 import { c } from "./styles.js";
 
 interface DoctorOptions {

package/src/run.ts

@@ -4,9 +4,9 @@ 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 { 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";
 
@@ -155,7 +155,7 @@ export async function runWorkflow(options: RunOptions): Promise<number> {
   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 { LocalVectorStore, GraphMemory, MemoryManager } = await import("rax-flow-core");
 
   const vectorStore = new LocalVectorStore(path.join(memoryDir, "vector-index.json"));
   await vectorStore.load();
@@ -168,7 +168,7 @@ export async function runWorkflow(options: RunOptions): Promise<number> {
   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, PIIPolicy } = await import("rax-flow-core");
   const governancePlugin = new GovernancePlugin(
     [new PIIPolicy()],
     path.join(options.cwd, ".rax-flow", "audit"),
@@ -179,7 +179,7 @@ export async function runWorkflow(options: RunOptions): Promise<number> {
 
   // Register Memory Plugin if an embedding provider is available (OpenAI in this case)
   if (providers.openai) {
-    const { LongTermMemoryPlugin } = await import("@rax-flow/core");
+    const { LongTermMemoryPlugin } = await import("rax-flow-core");
     orchestrator.registerPlugin(new LongTermMemoryPlugin(memoryManager, providers.openai as any));
   }
 

package/src/ws-relay.ts

@@ -1,5 +1,5 @@
 import { WebSocketServer, WebSocket } from "ws";
-import { RuntimeEventBus } from "@rax-flow/core";
+import { RuntimeEventBus } from "rax-flow-core";
 import { readdir, readFile, mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";