flowscale 2.1.0-beta.5 → 2.1.0-beta.7

package/dist/operator-server.d.ts

@@ -1,15 +1,23 @@
 import type { NodePodsTransport } from './node-transport';
 /**
- * PodsOperatorServer — exposes a pod management and workflow execution HTTP API
- * so that remote FlowScale apps (e.g. AI OS) can discover pods and run workflows
- * without any direct knowledge of ComfyUI.
+ * PodsOperatorServer — exposes a complete ComfyUI proxy API so that remote
+ * FlowScale apps (e.g. AI OS, Studio) can operate entirely through the operator
+ * without any direct knowledge of ComfyUI ports or URLs.
  *
- * Endpoints:
- *   GET  /api/pods                    — list all pods
- *   GET  /api/pods/:id                — get a single pod
- *   POST /api/pods/:id/upload         — upload a file to the pod's ComfyUI instance
- *   POST /api/pods/:id/execute        — execute a workflow and wait for outputs
- *   GET  /api/pods/:id/view?filename= — proxy a ComfyUI output image
+ * HTTP Endpoints:
+ *   GET  /api/pods                          — list all pods
+ *   GET  /api/pods/:id                      — get a single pod
+ *   POST /api/pods/:id/upload               — upload a file to ComfyUI
+ *   POST /api/pods/:id/execute              — execute workflow and wait (blocking)
+ *   GET  /api/pods/:id/view?filename=       — proxy a ComfyUI output image
+ *   GET  /api/pods/:id/workflow?filename=   — load a workflow JSON from ComfyUI userdata
+ *   POST /api/pods/:id/queue                — queue a prompt (non-blocking, returns prompt_id)
+ *   GET  /api/pods/:id/history/:promptId    — fetch execution history for a prompt
+ *   GET  /api/pods/:id/object_info          — proxy ComfyUI node type definitions
+ *   POST /api/pods/:id/interrupt            — cancel current execution
+ *
+ * WebSocket:
+ *   WS   /api/pods/:id/ws?clientId=        — transparent tunnel to ComfyUI WS
  *
  * Serves on 0.0.0.0 so any machine on the LAN can reach it.
  * Includes CORS headers for browser-based clients.
@@ -23,6 +31,8 @@ export declare class PodsOperatorServer {
     start(): void;
     stop(): void;
     private _json;
+    /** Pipe a GET response from ComfyUI directly to the client (handles large payloads). */
+    private _proxyGet;
     private _readBody;
     /** Returns the port of the first running instance in the given pod. */
     private _runningPort;

package/dist/operator-server.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -71,18 +82,27 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PodsOperatorServer = void 0;
 var http = __importStar(require("http"));
+var net = __importStar(require("net"));
 var local_pods_1 = require("./local-pods");
 /**
- * PodsOperatorServer — exposes a pod management and workflow execution HTTP API
- * so that remote FlowScale apps (e.g. AI OS) can discover pods and run workflows
- * without any direct knowledge of ComfyUI.
+ * PodsOperatorServer — exposes a complete ComfyUI proxy API so that remote
+ * FlowScale apps (e.g. AI OS, Studio) can operate entirely through the operator
+ * without any direct knowledge of ComfyUI ports or URLs.
+ *
+ * HTTP Endpoints:
+ *   GET  /api/pods                          — list all pods
+ *   GET  /api/pods/:id                      — get a single pod
+ *   POST /api/pods/:id/upload               — upload a file to ComfyUI
+ *   POST /api/pods/:id/execute              — execute workflow and wait (blocking)
+ *   GET  /api/pods/:id/view?filename=       — proxy a ComfyUI output image
+ *   GET  /api/pods/:id/workflow?filename=   — load a workflow JSON from ComfyUI userdata
+ *   POST /api/pods/:id/queue                — queue a prompt (non-blocking, returns prompt_id)
+ *   GET  /api/pods/:id/history/:promptId    — fetch execution history for a prompt
+ *   GET  /api/pods/:id/object_info          — proxy ComfyUI node type definitions
+ *   POST /api/pods/:id/interrupt            — cancel current execution
  *
- * Endpoints:
- *   GET  /api/pods                    — list all pods
- *   GET  /api/pods/:id                — get a single pod
- *   POST /api/pods/:id/upload         — upload a file to the pod's ComfyUI instance
- *   POST /api/pods/:id/execute        — execute a workflow and wait for outputs
- *   GET  /api/pods/:id/view?filename= — proxy a ComfyUI output image
+ * WebSocket:
+ *   WS   /api/pods/:id/ws?clientId=        — transparent tunnel to ComfyUI WS
  *
  * Serves on 0.0.0.0 so any machine on the LAN can reach it.
  * Includes CORS headers for browser-based clients.
@@ -100,11 +120,11 @@ var PodsOperatorServer = /** @class */ (function () {
         if (this.server)
             return;
         this.server = http.createServer(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
-            var url, query, pods, podMatch, pod, uploadMatch, podId, port_1, executeMatch, podId, body, _a, _b, result, viewMatch, podId, port, params, upstream, imageBuffer, err_1;
+            var url, query, pods, podMatch, pod, uploadMatch, podId, port_1, executeMatch, podId, body, _a, _b, result, viewMatch, podId, port, workflowMatch, podId, port, filename, encoded, queueMatch, podId, port_2, body_1, historyMatch, podId, promptId, port, objectInfoMatch, podId, port, interruptMatch, podId, port_3, catchAllMatch, podId, subpath, port_4, qs, fullPath_1, err_1;
             var _this = this;
-            var _c, _d, _e, _f, _g, _h;
-            return __generator(this, function (_j) {
-                switch (_j.label) {
+            var _c, _d, _e, _f, _g, _h, _j;
+            return __generator(this, function (_k) {
+                switch (_k.label) {
                     case 0:
                         res.setHeader('Access-Control-Allow-Origin', '*');
                         res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
@@ -116,20 +136,20 @@ var PodsOperatorServer = /** @class */ (function () {
                         }
                         url = ((_c = req.url) !== null && _c !== void 0 ? _c : '/').split('?')[0];
                         query = new URLSearchParams((_e = ((_d = req.url) !== null && _d !== void 0 ? _d : '').split('?')[1]) !== null && _e !== void 0 ? _e : '');
-                        _j.label = 1;
+                        _k.label = 1;
                     case 1:
-                        _j.trys.push([1, 16, , 17]);
+                        _k.trys.push([1, 36, , 37]);
                         if (!(req.method === 'GET' && (url === '/api/pods' || url === '/api/pods/'))) return [3 /*break*/, 3];
                         return [4 /*yield*/, this.transport.list()];
                     case 2:
-                        pods = _j.sent();
+                        pods = _k.sent();
                         return [2 /*return*/, this._json(res, 200, pods)];
                     case 3:
                         podMatch = url.match(/^\/api\/pods\/([^/]+)$/);
                         if (!(req.method === 'GET' && podMatch)) return [3 /*break*/, 5];
                         return [4 /*yield*/, this.transport.get(decodeURIComponent(podMatch[1]))];
                     case 4:
-                        pod = _j.sent();
+                        pod = _k.sent();
                         if (!pod)
                             return [2 /*return*/, this._json(res, 404, { error: 'Pod not found' })];
                         return [2 /*return*/, this._json(res, 200, pod)];
@@ -137,12 +157,9 @@ var PodsOperatorServer = /** @class */ (function () {
                         uploadMatch = url.match(/^\/api\/pods\/([^/]+)\/upload$/);
                         if (!(req.method === 'POST' && uploadMatch)) return [3 /*break*/, 8];
                         podId = decodeURIComponent(uploadMatch[1]);
-                        return [4 /*yield*/, this._runningPort(podId)
-                            // Pipe the multipart body directly to ComfyUI to preserve boundary and encoding
-                        ];
+                        return [4 /*yield*/, this._runningPort(podId)];
                     case 6:
-                        port_1 = _j.sent();
-                        // Pipe the multipart body directly to ComfyUI to preserve boundary and encoding
+                        port_1 = _k.sent();
                         return [4 /*yield*/, new Promise(function (resolve, reject) {
                                 var _a;
                                 var headers = {
@@ -172,8 +189,7 @@ var PodsOperatorServer = /** @class */ (function () {
                                 req.pipe(upstreamReq);
                             })];
                     case 7:
-                        // Pipe the multipart body directly to ComfyUI to preserve boundary and encoding
-                        _j.sent();
+                        _k.sent();
                         return [2 /*return*/];
                     case 8:
                         executeMatch = url.match(/^\/api\/pods\/([^/]+)\/execute$/);
@@ -182,46 +198,220 @@ var PodsOperatorServer = /** @class */ (function () {
                         _b = (_a = JSON).parse;
                         return [4 /*yield*/, this._readBody(req)];
                     case 9:
-                        body = _b.apply(_a, [(_j.sent()).toString()]);
+                        body = _b.apply(_a, [(_k.sent()).toString()]);
                         return [4 /*yield*/, this.api.executeWorkflowAndWait(podId, body.workflow, (_f = body.options) !== null && _f !== void 0 ? _f : {})];
                     case 10:
-                        result = _j.sent();
+                        result = _k.sent();
                         return [2 /*return*/, this._json(res, 200, result)];
                     case 11:
                         viewMatch = url.match(/^\/api\/pods\/([^/]+)\/view$/);
-                        if (!(req.method === 'GET' && viewMatch)) return [3 /*break*/, 15];
+                        if (!(req.method === 'GET' && viewMatch)) return [3 /*break*/, 14];
                         podId = decodeURIComponent(viewMatch[1]);
                         return [4 /*yield*/, this._runningPort(podId)];
                     case 12:
-                        port = _j.sent();
-                        params = new URLSearchParams(query.toString());
-                        return [4 /*yield*/, fetch("http://localhost:".concat(port, "/view?").concat(params))];
+                        port = _k.sent();
+                        return [4 /*yield*/, this._proxyGet(res, port, "/view?".concat(query))];
                     case 13:
-                        upstream = _j.sent();
-                        if (!upstream.ok) {
-                            res.writeHead(upstream.status);
-                            res.end();
-                            return [2 /*return*/];
-                        }
-                        return [4 /*yield*/, upstream.arrayBuffer()];
-                    case 14:
-                        imageBuffer = _j.sent();
-                        res.writeHead(200, {
-                            'Content-Type': (_g = upstream.headers.get('content-type')) !== null && _g !== void 0 ? _g : 'image/png',
-                            'Cache-Control': 'public, max-age=3600',
-                        });
-                        res.end(Buffer.from(imageBuffer));
+                        _k.sent();
                         return [2 /*return*/];
+                    case 14:
+                        workflowMatch = url.match(/^\/api\/pods\/([^/]+)\/workflow$/);
+                        if (!(req.method === 'GET' && workflowMatch)) return [3 /*break*/, 17];
+                        podId = decodeURIComponent(workflowMatch[1]);
+                        return [4 /*yield*/, this._runningPort(podId)];
                     case 15:
+                        port = _k.sent();
+                        filename = (_g = query.get('filename')) !== null && _g !== void 0 ? _g : '';
+                        encoded = encodeURIComponent("workflows/".concat(filename));
+                        return [4 /*yield*/, this._proxyGet(res, port, "/api/userdata/".concat(encoded))];
+                    case 16:
+                        _k.sent();
+                        return [2 /*return*/];
+                    case 17:
+                        queueMatch = url.match(/^\/api\/pods\/([^/]+)\/queue$/);
+                        if (!(req.method === 'POST' && queueMatch)) return [3 /*break*/, 21];
+                        podId = decodeURIComponent(queueMatch[1]);
+                        return [4 /*yield*/, this._runningPort(podId)];
+                    case 18:
+                        port_2 = _k.sent();
+                        return [4 /*yield*/, this._readBody(req)];
+                    case 19:
+                        body_1 = _k.sent();
+                        return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                var upstreamReq = http.request({
+                                    hostname: 'localhost',
+                                    port: port_2,
+                                    path: '/prompt', method: 'POST',
+                                    headers: { 'content-type': 'application/json', 'content-length': body_1.length },
+                                }, function (upstreamRes) {
+                                    var chunks = [];
+                                    upstreamRes.on('data', function (c) { return chunks.push(c); });
+                                    upstreamRes.on('end', function () {
+                                        var _a;
+                                        try {
+                                            var data = JSON.parse(Buffer.concat(chunks).toString());
+                                            _this._json(res, (_a = upstreamRes.statusCode) !== null && _a !== void 0 ? _a : 500, data);
+                                            resolve();
+                                        }
+                                        catch (e) {
+                                            reject(e);
+                                        }
+                                    });
+                                    upstreamRes.on('error', reject);
+                                });
+                                upstreamReq.on('error', reject);
+                                upstreamReq.write(body_1);
+                                upstreamReq.end();
+                            })];
+                    case 20:
+                        _k.sent();
+                        return [2 /*return*/];
+                    case 21:
+                        historyMatch = url.match(/^\/api\/pods\/([^/]+)\/history\/([^/]+)$/);
+                        if (!(req.method === 'GET' && historyMatch)) return [3 /*break*/, 24];
+                        podId = decodeURIComponent(historyMatch[1]);
+                        promptId = decodeURIComponent(historyMatch[2]);
+                        return [4 /*yield*/, this._runningPort(podId)];
+                    case 22:
+                        port = _k.sent();
+                        return [4 /*yield*/, this._proxyGet(res, port, "/history/".concat(promptId))];
+                    case 23:
+                        _k.sent();
+                        return [2 /*return*/];
+                    case 24:
+                        objectInfoMatch = url.match(/^\/api\/pods\/([^/]+)\/object_info$/);
+                        if (!(req.method === 'GET' && objectInfoMatch)) return [3 /*break*/, 27];
+                        podId = decodeURIComponent(objectInfoMatch[1]);
+                        return [4 /*yield*/, this._runningPort(podId)];
+                    case 25:
+                        port = _k.sent();
+                        return [4 /*yield*/, this._proxyGet(res, port, '/object_info')];
+                    case 26:
+                        _k.sent();
+                        return [2 /*return*/];
+                    case 27:
+                        interruptMatch = url.match(/^\/api\/pods\/([^/]+)\/interrupt$/);
+                        if (!(req.method === 'POST' && interruptMatch)) return [3 /*break*/, 30];
+                        podId = decodeURIComponent(interruptMatch[1]);
+                        return [4 /*yield*/, this._runningPort(podId)];
+                    case 28:
+                        port_3 = _k.sent();
+                        return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                var upstreamReq = http.request({ hostname: 'localhost', port: port_3, path: '/interrupt', method: 'POST' }, function (upstreamRes) { upstreamRes.resume(); upstreamRes.on('end', resolve); });
+                                upstreamReq.on('error', reject);
+                                upstreamReq.end();
+                            })];
+                    case 29:
+                        _k.sent();
+                        return [2 /*return*/, this._json(res, 200, { ok: true })];
+                    case 30:
+                        catchAllMatch = url.match(/^\/api\/pods\/([^/]+)(\/.+)$/);
+                        if (!catchAllMatch) return [3 /*break*/, 35];
+                        podId = decodeURIComponent(catchAllMatch[1]);
+                        subpath = catchAllMatch[2];
+                        return [4 /*yield*/, this._runningPort(podId)];
+                    case 31:
+                        port_4 = _k.sent();
+                        qs = ((_h = req.url) !== null && _h !== void 0 ? _h : '').split('?')[1];
+                        fullPath_1 = qs ? "".concat(subpath, "?").concat(qs) : subpath;
+                        if (!(req.method === 'GET' || req.method === 'HEAD')) return [3 /*break*/, 33];
+                        return [4 /*yield*/, this._proxyGet(res, port_4, fullPath_1)];
+                    case 32:
+                        _k.sent();
+                        return [2 /*return*/];
+                    case 33: 
+                    // POST / PUT / PATCH / DELETE — pipe body through
+                    return [4 /*yield*/, new Promise(function (resolve, reject) {
+                            var upstream = http.request({
+                                hostname: 'localhost',
+                                port: port_4,
+                                path: fullPath_1, method: req.method,
+                                headers: __assign(__assign({}, (req.headers['content-type'] ? { 'content-type': req.headers['content-type'] } : {})), (req.headers['content-length'] ? { 'content-length': req.headers['content-length'] } : {})),
+                            }, function (upstreamRes) {
+                                var _a, _b;
+                                res.writeHead((_a = upstreamRes.statusCode) !== null && _a !== void 0 ? _a : 200, {
+                                    'Content-Type': (_b = upstreamRes.headers['content-type']) !== null && _b !== void 0 ? _b : 'application/json',
+                                    'Access-Control-Allow-Origin': '*',
+                                });
+                                upstreamRes.pipe(res);
+                                upstreamRes.on('end', resolve);
+                                upstreamRes.on('error', reject);
+                            });
+                            upstream.on('error', reject);
+                            req.pipe(upstream);
+                        })];
+                    case 34:
+                        // POST / PUT / PATCH / DELETE — pipe body through
+                        _k.sent();
+                        return [2 /*return*/];
+                    case 35:
                         res.writeHead(404);
                         res.end('Not found');
-                        return [3 /*break*/, 17];
-                    case 16:
-                        err_1 = _j.sent();
+                        return [3 /*break*/, 37];
+                    case 36:
+                        err_1 = _k.sent();
                         console.error('[PodsOperatorServer] Error handling request:', err_1);
-                        this._json(res, 500, { error: (_h = err_1 === null || err_1 === void 0 ? void 0 : err_1.message) !== null && _h !== void 0 ? _h : 'Internal server error' });
-                        return [3 /*break*/, 17];
-                    case 17: return [2 /*return*/];
+                        this._json(res, 500, { error: (_j = err_1 === null || err_1 === void 0 ? void 0 : err_1.message) !== null && _j !== void 0 ? _j : 'Internal server error' });
+                        return [3 /*break*/, 37];
+                    case 37: return [2 /*return*/];
+                }
+            });
+        }); });
+        // ── WebSocket tunnel: WS /api/pods/:id/ws?clientId= ─────────────────────
+        this.server.on('upgrade', function (req, socket, head) { return __awaiter(_this, void 0, void 0, function () {
+            var rawUrl, urlPath, qs, wsMatch, podId, port_5, clientId_1, upstream_1, err_2;
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        rawUrl = (_a = req.url) !== null && _a !== void 0 ? _a : '/';
+                        urlPath = rawUrl.split('?')[0];
+                        qs = new URLSearchParams((_b = rawUrl.split('?')[1]) !== null && _b !== void 0 ? _b : '');
+                        wsMatch = urlPath.match(/^\/api\/pods\/([^/]+)\/ws$/);
+                        if (!wsMatch) {
+                            socket.destroy();
+                            return [2 /*return*/];
+                        }
+                        podId = decodeURIComponent(wsMatch[1]);
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this._runningPort(podId)];
+                    case 2:
+                        port_5 = _d.sent();
+                        clientId_1 = (_c = qs.get('clientId')) !== null && _c !== void 0 ? _c : '';
+                        upstream_1 = net.createConnection({ host: 'localhost', port: port_5 });
+                        upstream_1.on('connect', function () {
+                            var _a, _b;
+                            var upgradeReq = [
+                                "GET /ws?clientId=".concat(encodeURIComponent(clientId_1), " HTTP/1.1"),
+                                "Host: localhost:".concat(port_5),
+                                'Upgrade: websocket',
+                                'Connection: Upgrade',
+                                "Sec-WebSocket-Key: ".concat((_a = req.headers['sec-websocket-key']) !== null && _a !== void 0 ? _a : ''),
+                                "Sec-WebSocket-Version: ".concat((_b = req.headers['sec-websocket-version']) !== null && _b !== void 0 ? _b : '13'),
+                                '',
+                                '',
+                            ].join('\r\n');
+                            upstream_1.write(upgradeReq);
+                            if (head && head.length > 0)
+                                upstream_1.write(head);
+                            // Bidirectional pipe — all WS frames pass through transparently
+                            socket.pipe(upstream_1);
+                            upstream_1.pipe(socket);
+                        });
+                        upstream_1.on('error', function () { return socket.destroy(); });
+                        socket.on('error', function () { return upstream_1.destroy(); });
+                        socket.on('close', function () { return upstream_1.destroy(); });
+                        upstream_1.on('close', function () { return socket.destroy(); });
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_2 = _d.sent();
+                        console.error('[PodsOperatorServer] WS tunnel error:', err_2);
+                        socket.write('HTTP/1.1 503 Service Unavailable\r\n\r\n');
+                        socket.destroy();
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
                 }
             });
         }); });
@@ -240,9 +430,26 @@ var PodsOperatorServer = /** @class */ (function () {
     };
     // ── Private helpers ──────────────────────────────────────────────────────
     PodsOperatorServer.prototype._json = function (res, status, data) {
-        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.writeHead(status, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
         res.end(JSON.stringify(data));
     };
+    /** Pipe a GET response from ComfyUI directly to the client (handles large payloads). */
+    PodsOperatorServer.prototype._proxyGet = function (res, port, path) {
+        return new Promise(function (resolve, reject) {
+            var upstreamReq = http.request({ hostname: 'localhost', port: port, path: path, method: 'GET' }, function (upstreamRes) {
+                var _a, _b;
+                res.writeHead((_a = upstreamRes.statusCode) !== null && _a !== void 0 ? _a : 200, {
+                    'Content-Type': (_b = upstreamRes.headers['content-type']) !== null && _b !== void 0 ? _b : 'application/json',
+                    'Access-Control-Allow-Origin': '*',
+                });
+                upstreamRes.pipe(res);
+                upstreamRes.on('end', resolve);
+                upstreamRes.on('error', reject);
+            });
+            upstreamReq.on('error', reject);
+            upstreamReq.end();
+        });
+    };
     PodsOperatorServer.prototype._readBody = function (req) {
         return new Promise(function (resolve, reject) {
             var chunks = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowscale",
-  "version": "2.1.0-beta.5",
+  "version": "2.1.0-beta.7",
   "description": "An NPM library for communicating with the Flowscale APIs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",