rax-flow 0.1.5 → 0.1.7

package/package/src/ws-relay.ts

@@ -1,156 +0,0 @@
-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

@@ -1,12 +0,0 @@
-{
-  "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" }]
-}