rax-flow 0.1.0

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/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" }]
+}