flowscale 2.0.0 → 2.1.0-beta.1

package/dist/index.d.ts

@@ -122,3 +122,7 @@ export declare class FlowscaleAPI {
     };
 }
 export * from './types';
+export { FlowscalePlatformAPI } from './platform';
+export { LocalPodsAPI } from './local-pods';
+export * from './local-types';
+export * from './platform-types';

package/dist/index.js

@@ -73,7 +73,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowscaleAPI = void 0;
+exports.LocalPodsAPI = exports.FlowscalePlatformAPI = exports.FlowscaleAPI = void 0;
 var axios_1 = __importDefault(require("axios"));
 var FlowscaleAPI = /** @class */ (function () {
     function FlowscaleAPI(config) {
@@ -1294,3 +1294,11 @@ if (typeof window !== 'undefined') {
 }
 // Export all types for TypeScript consumers
 __exportStar(require("./types"), exports);
+// Platform API — JWT-based control of the full Flowscale platform
+var platform_1 = require("./platform");
+Object.defineProperty(exports, "FlowscalePlatformAPI", { enumerable: true, get: function () { return platform_1.FlowscalePlatformAPI; } });
+// Local Pods API — for managing local ComfyUI instances in Electron
+var local_pods_1 = require("./local-pods");
+Object.defineProperty(exports, "LocalPodsAPI", { enumerable: true, get: function () { return local_pods_1.LocalPodsAPI; } });
+__exportStar(require("./local-types"), exports);
+__exportStar(require("./platform-types"), exports);

package/dist/local-pods.d.ts

@@ -0,0 +1,67 @@
+import type { LocalPodsTransport, LocalPod, LocalPodInstance, LocalPodInstanceStatus, SystemInfo, ComfyUISystemStats, ComfyUIWorkflow, ComfyUIWorkflowResult, PodWorkflowHandle, ExecuteWorkflowOptions, CreateLocalPodRequest, UpdateLocalPodRequest, StartInstanceRequest } from './local-types';
+/**
+ * LocalPodsAPI — manages local ComfyUI pods via a pluggable transport.
+ *
+ * In the Electron app, pass an ElectronPodsTransport that delegates to IPC.
+ * This class contains no logic; it is a typed facade over the transport.
+ */
+export declare class LocalPodsAPI {
+    private transport;
+    constructor(transport: LocalPodsTransport);
+    create(data: CreateLocalPodRequest): Promise<LocalPod>;
+    list(): Promise<LocalPod[]>;
+    get(id: string): Promise<LocalPod | null>;
+    update(id: string, data: UpdateLocalPodRequest): Promise<LocalPod>;
+    delete(id: string): Promise<void>;
+    /** Scan common OS directories for a ComfyUI installation path. */
+    scanPaths(): Promise<string | null>;
+    /** Probe ports 8188–9188 and associate any found ComfyUI instances with podId. */
+    scanPorts(podId: string): Promise<LocalPodInstance[]>;
+    /** Re-probe a single instance port and return the updated instance. */
+    refreshInstance(instanceId: string): Promise<LocalPodInstance>;
+    startInstance(req: StartInstanceRequest): Promise<LocalPodInstance>;
+    stopInstance(instanceId: string): Promise<void>;
+    restartInstance(instanceId: string): Promise<void>;
+    deleteInstance(instanceId: string): Promise<void>;
+    getSystemInfo(): Promise<SystemInfo>;
+    getLogs(instanceId: string): Promise<string[]>;
+    onInstanceStatusChanged(cb: (instanceId: string, status: LocalPodInstanceStatus, info?: ComfyUISystemStats) => void): () => void;
+    onLog(cb: (instanceId: string, line: string) => void): () => void;
+    installRocmPyTorch(podId: string): void;
+    onRocmSetupDone(cb: (data: {
+        podId: string;
+        success: boolean;
+    }) => void): () => void;
+    /**
+     * Execute a workflow on a pod. The SDK automatically picks the
+     * least-loaded running ComfyUI instance inside the pod.
+     *
+     * Returns a handle with a `wait()` method to get the outputs.
+     * Use `executeWorkflowAndWait` if you want a single awaitable call.
+     *
+     * @param podId     ID of the pod to run the workflow on
+     * @param workflow  ComfyUI workflow graph (API format)
+     * @param options   Optional clientId and extraData
+     */
+    executeWorkflow(podId: string, workflow: ComfyUIWorkflow | Record<string, unknown>, options?: ExecuteWorkflowOptions): Promise<PodWorkflowHandle>;
+    /**
+     * Execute a workflow on a pod and wait for it to complete.
+     * The SDK automatically picks the least-loaded running instance.
+     *
+     * @param podId     ID of the pod to run the workflow on
+     * @param workflow  ComfyUI workflow graph (API format)
+     * @param options   Optional clientId and extraData
+     * @param timeoutMs Maximum wait time in ms (default 5 minutes)
+     */
+    executeWorkflowAndWait(podId: string, workflow: ComfyUIWorkflow | Record<string, unknown>, options?: ExecuteWorkflowOptions, timeoutMs?: number): Promise<ComfyUIWorkflowResult>;
+    /**
+     * Find the port of the least-loaded running instance in a pod.
+     * Checks ComfyUI's /queue endpoint on all running instances in parallel
+     * and picks the one with the fewest queued jobs.
+     */
+    private _findFreeInstancePort;
+    /** Returns total number of jobs (running + pending) on a ComfyUI instance. */
+    private _getQueueDepth;
+    /** Poll /history until the prompt completes, then return the result. */
+    private _pollHistory;
+}

package/dist/local-pods.js

@@ -0,0 +1,319 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalPodsAPI = void 0;
+/**
+ * LocalPodsAPI — manages local ComfyUI pods via a pluggable transport.
+ *
+ * In the Electron app, pass an ElectronPodsTransport that delegates to IPC.
+ * This class contains no logic; it is a typed facade over the transport.
+ */
+var LocalPodsAPI = /** @class */ (function () {
+    function LocalPodsAPI(transport) {
+        this.transport = transport;
+    }
+    // ── Pod CRUD ──────────────────────────────────────────────
+    LocalPodsAPI.prototype.create = function (data) {
+        return this.transport.create(data);
+    };
+    LocalPodsAPI.prototype.list = function () {
+        return this.transport.list();
+    };
+    LocalPodsAPI.prototype.get = function (id) {
+        return this.transport.get(id);
+    };
+    LocalPodsAPI.prototype.update = function (id, data) {
+        return this.transport.update(id, data);
+    };
+    LocalPodsAPI.prototype.delete = function (id) {
+        return this.transport.delete(id);
+    };
+    // ── Detection & scanning ──────────────────────────────────
+    /** Scan common OS directories for a ComfyUI installation path. */
+    LocalPodsAPI.prototype.scanPaths = function () {
+        return this.transport.scanPaths();
+    };
+    /** Probe ports 8188–9188 and associate any found ComfyUI instances with podId. */
+    LocalPodsAPI.prototype.scanPorts = function (podId) {
+        return this.transport.scanPorts(podId);
+    };
+    /** Re-probe a single instance port and return the updated instance. */
+    LocalPodsAPI.prototype.refreshInstance = function (instanceId) {
+        return this.transport.refreshInstance(instanceId);
+    };
+    // ── Instance lifecycle ────────────────────────────────────
+    LocalPodsAPI.prototype.startInstance = function (req) {
+        return this.transport.startInstance(req);
+    };
+    LocalPodsAPI.prototype.stopInstance = function (instanceId) {
+        return this.transport.stopInstance(instanceId);
+    };
+    LocalPodsAPI.prototype.restartInstance = function (instanceId) {
+        return this.transport.restartInstance(instanceId);
+    };
+    LocalPodsAPI.prototype.deleteInstance = function (instanceId) {
+        return this.transport.deleteInstance(instanceId);
+    };
+    // ── System info ───────────────────────────────────────────
+    LocalPodsAPI.prototype.getSystemInfo = function () {
+        return this.transport.getSystemInfo();
+    };
+    // ── Logs ──────────────────────────────────────────────────
+    LocalPodsAPI.prototype.getLogs = function (instanceId) {
+        return this.transport.getLogs(instanceId);
+    };
+    // ── Events ────────────────────────────────────────────────
+    LocalPodsAPI.prototype.onInstanceStatusChanged = function (cb) {
+        return this.transport.onInstanceStatusChanged(cb);
+    };
+    LocalPodsAPI.prototype.onLog = function (cb) {
+        return this.transport.onLog(cb);
+    };
+    // ── AMD GPU setup ─────────────────────────────────────────
+    LocalPodsAPI.prototype.installRocmPyTorch = function (podId) {
+        return this.transport.installRocmPyTorch(podId);
+    };
+    LocalPodsAPI.prototype.onRocmSetupDone = function (cb) {
+        return this.transport.onRocmSetupDone(cb);
+    };
+    // ── Workflow execution ────────────────────────────────────
+    // External apps only need to know about pods — the SDK handles
+    // routing to a free ComfyUI instance internally.
+    /**
+     * Execute a workflow on a pod. The SDK automatically picks the
+     * least-loaded running ComfyUI instance inside the pod.
+     *
+     * Returns a handle with a `wait()` method to get the outputs.
+     * Use `executeWorkflowAndWait` if you want a single awaitable call.
+     *
+     * @param podId     ID of the pod to run the workflow on
+     * @param workflow  ComfyUI workflow graph (API format)
+     * @param options   Optional clientId and extraData
+     */
+    LocalPodsAPI.prototype.executeWorkflow = function (podId_1, workflow_1) {
+        return __awaiter(this, arguments, void 0, function (podId, workflow, options) {
+            var pod, port, clientId, body, res, text, prompt_id;
+            var _this = this;
+            var _a;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.transport.get(podId)];
+                    case 1:
+                        pod = _b.sent();
+                        if (!pod)
+                            throw new Error("Pod \"".concat(podId, "\" not found"));
+                        return [4 /*yield*/, this._findFreeInstancePort(pod)];
+                    case 2:
+                        port = _b.sent();
+                        clientId = (_a = options.clientId) !== null && _a !== void 0 ? _a : crypto.randomUUID();
+                        body = { prompt: workflow, client_id: clientId };
+                        if (options.extraData)
+                            body.extra_data = options.extraData;
+                        return [4 /*yield*/, fetch("http://localhost:".concat(port, "/prompt"), {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify(body)
+                            })];
+                    case 3:
+                        res = _b.sent();
+                        if (!!res.ok) return [3 /*break*/, 5];
+                        return [4 /*yield*/, res.text().catch(function () { return res.statusText; })];
+                    case 4:
+                        text = _b.sent();
+                        throw new Error("ComfyUI /prompt failed (".concat(res.status, "): ").concat(text));
+                    case 5: return [4 /*yield*/, res.json()];
+                    case 6:
+                        prompt_id = (_b.sent()).prompt_id;
+                        return [2 /*return*/, {
+                                promptId: prompt_id,
+                                podId: podId,
+                                wait: function (timeoutMs) { return _this._pollHistory(port, prompt_id, podId, timeoutMs); }
+                            }];
+                }
+            });
+        });
+    };
+    /**
+     * Execute a workflow on a pod and wait for it to complete.
+     * The SDK automatically picks the least-loaded running instance.
+     *
+     * @param podId     ID of the pod to run the workflow on
+     * @param workflow  ComfyUI workflow graph (API format)
+     * @param options   Optional clientId and extraData
+     * @param timeoutMs Maximum wait time in ms (default 5 minutes)
+     */
+    LocalPodsAPI.prototype.executeWorkflowAndWait = function (podId_1, workflow_1) {
+        return __awaiter(this, arguments, void 0, function (podId, workflow, options, timeoutMs) {
+            var handle;
+            if (options === void 0) { options = {}; }
+            if (timeoutMs === void 0) { timeoutMs = 300000; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.executeWorkflow(podId, workflow, options)];
+                    case 1:
+                        handle = _a.sent();
+                        return [2 /*return*/, handle.wait(timeoutMs)];
+                }
+            });
+        });
+    };
+    // ── Private helpers ───────────────────────────────────────
+    /**
+     * Find the port of the least-loaded running instance in a pod.
+     * Checks ComfyUI's /queue endpoint on all running instances in parallel
+     * and picks the one with the fewest queued jobs.
+     */
+    LocalPodsAPI.prototype._findFreeInstancePort = function (pod) {
+        return __awaiter(this, void 0, void 0, function () {
+            var running, withLoad;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        running = pod.instances.filter(function (i) { return i.status === 'running'; });
+                        if (running.length === 0) {
+                            throw new Error("No running ComfyUI instances in pod \"".concat(pod.name, "\". Start an instance first."));
+                        }
+                        return [4 /*yield*/, Promise.all(running.map(function (inst) { return __awaiter(_this, void 0, void 0, function () {
+                                var load;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this._getQueueDepth(inst.port)];
+                                        case 1:
+                                            load = _a.sent();
+                                            return [2 /*return*/, { port: inst.port, load: load }];
+                                    }
+                                });
+                            }); }))
+                            // Sort by total load (running + pending jobs) and pick the least busy
+                        ];
+                    case 1:
+                        withLoad = _a.sent();
+                        // Sort by total load (running + pending jobs) and pick the least busy
+                        withLoad.sort(function (a, b) { return a.load - b.load; });
+                        return [2 /*return*/, withLoad[0].port];
+                }
+            });
+        });
+    };
+    /** Returns total number of jobs (running + pending) on a ComfyUI instance. */
+    LocalPodsAPI.prototype._getQueueDepth = function (port) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res, data, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, fetch("http://localhost:".concat(port, "/queue"), {
+                                signal: AbortSignal.timeout(2000)
+                            })];
+                    case 1:
+                        res = _b.sent();
+                        if (!res.ok)
+                            return [2 /*return*/, Infinity];
+                        return [4 /*yield*/, res.json()];
+                    case 2:
+                        data = _b.sent();
+                        return [2 /*return*/, data.queue_running.length + data.queue_pending.length];
+                    case 3:
+                        _a = _b.sent();
+                        return [2 /*return*/, Infinity]; // treat unreachable instances as fully loaded
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /** Poll /history until the prompt completes, then return the result. */
+    LocalPodsAPI.prototype._pollHistory = function (port_1, promptId_1, podId_1) {
+        return __awaiter(this, arguments, void 0, function (port, promptId, podId, timeoutMs, pollMs) {
+            var start, res, history_1, entry, err_1;
+            if (timeoutMs === void 0) { timeoutMs = 300000; }
+            if (pollMs === void 0) { pollMs = 1000; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        start = Date.now();
+                        _a.label = 1;
+                    case 1:
+                        if (!(Date.now() - start < timeoutMs)) return [3 /*break*/, 8];
+                        return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, pollMs); })];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _a.trys.push([3, 6, , 7]);
+                        return [4 /*yield*/, fetch("http://localhost:".concat(port, "/history/").concat(promptId), {
+                                signal: AbortSignal.timeout(5000)
+                            })];
+                    case 4:
+                        res = _a.sent();
+                        if (!res.ok)
+                            return [3 /*break*/, 1];
+                        return [4 /*yield*/, res.json()];
+                    case 5:
+                        history_1 = _a.sent();
+                        entry = history_1[promptId];
+                        if (!entry)
+                            return [3 /*break*/, 1];
+                        if (entry.status.status_str === 'error') {
+                            throw new Error("Workflow \"".concat(promptId, "\" failed on pod \"").concat(podId, "\""));
+                        }
+                        if (entry.status.completed) {
+                            return [2 /*return*/, {
+                                    promptId: promptId,
+                                    podId: podId,
+                                    outputs: entry.outputs,
+                                    elapsedMs: Date.now() - start
+                                }];
+                        }
+                        return [3 /*break*/, 7];
+                    case 6:
+                        err_1 = _a.sent();
+                        if (err_1 instanceof Error && err_1.message.startsWith('Workflow'))
+                            throw err_1;
+                        return [3 /*break*/, 7];
+                    case 7: return [3 /*break*/, 1];
+                    case 8: throw new Error("Workflow \"".concat(promptId, "\" timed out after ").concat(timeoutMs, "ms"));
+                }
+            });
+        });
+    };
+    return LocalPodsAPI;
+}());
+exports.LocalPodsAPI = LocalPodsAPI;

package/dist/local-types.d.ts

@@ -0,0 +1,143 @@
+export type LocalPodDevice = {
+    type: 'cpu';
+} | {
+    type: 'gpu';
+    index: number;
+    name: string;
+    vram?: number;
+    vendor?: string;
+};
+export type LocalPodInstanceStatus = 'running' | 'idle';
+export interface ComfyUIDevice {
+    name: string;
+    type: string;
+    index: number;
+    vram_total: number;
+    vram_free: number;
+}
+export interface ComfyUISystemStats {
+    system: {
+        os: string;
+        python_version: string;
+    };
+    devices: ComfyUIDevice[];
+}
+export interface LocalPodInstance {
+    id: string;
+    podId: string;
+    port: number;
+    device: LocalPodDevice;
+    status: LocalPodInstanceStatus;
+    /** null = externally running (not spawned by app) */
+    pid: number | null;
+    lastDetectedAt: number | null;
+    comfyuiInfo?: ComfyUISystemStats;
+    createdAt: number;
+}
+export interface LocalPod {
+    id: string;
+    name: string;
+    description?: string;
+    /** null if not found/provided */
+    comfyuiPath: string | null;
+    instances: LocalPodInstance[];
+    createdAt: number;
+    updatedAt: number;
+}
+export interface GpuInfo {
+    index: number;
+    name: string;
+    vram?: number;
+    vendor?: string;
+}
+export interface CpuInfo {
+    model: string;
+    cores: number;
+    threads: number;
+}
+export interface SystemInfo {
+    gpus: GpuInfo[];
+    cpu: CpuInfo;
+}
+export interface CreateLocalPodRequest {
+    name: string;
+    description?: string;
+    comfyuiPath?: string;
+}
+export interface UpdateLocalPodRequest {
+    name?: string;
+    description?: string;
+    comfyuiPath?: string | null;
+}
+export interface StartInstanceRequest {
+    podId: string;
+    /** The device (CPU or specific GPU) to start ComfyUI on */
+    device: LocalPodDevice;
+}
+/** A ComfyUI workflow graph — map of node ID to node definition */
+export type ComfyUIWorkflow = Record<string, {
+    class_type: string;
+    inputs: Record<string, unknown>;
+    _meta?: Record<string, unknown>;
+}>;
+export interface ExecuteWorkflowOptions {
+    /** ComfyUI client ID for WebSocket tracking. Auto-generated if omitted. */
+    clientId?: string;
+    /** Extra data passed to ComfyUI alongside the prompt */
+    extraData?: Record<string, unknown>;
+}
+export interface ComfyUIOutputFile {
+    filename: string;
+    subfolder: string;
+    type: 'output' | 'temp' | 'input';
+}
+export interface ComfyUINodeOutput {
+    images?: ComfyUIOutputFile[];
+    gifs?: ComfyUIOutputFile[];
+    [key: string]: unknown;
+}
+export interface ComfyUIWorkflowResult {
+    promptId: string;
+    podId: string;
+    /** Map of node ID → its outputs (images, etc.) */
+    outputs: Record<string, ComfyUINodeOutput>;
+    /** Total elapsed time in ms */
+    elapsedMs: number;
+}
+/**
+ * Handle returned by `executeWorkflow`. Lets you track or await the result
+ * without caring which instance inside the pod is running it.
+ */
+export interface PodWorkflowHandle {
+    /** ComfyUI prompt ID */
+    promptId: string;
+    podId: string;
+    /** Wait for the workflow to complete and return its outputs */
+    wait(timeoutMs?: number): Promise<ComfyUIWorkflowResult>;
+}
+export interface LocalPodsTransport {
+    create(data: CreateLocalPodRequest): Promise<LocalPod>;
+    list(): Promise<LocalPod[]>;
+    get(id: string): Promise<LocalPod | null>;
+    update(id: string, data: UpdateLocalPodRequest): Promise<LocalPod>;
+    delete(id: string): Promise<void>;
+    /** Scan common OS directories for a ComfyUI installation. Returns path or null. */
+    scanPaths(): Promise<string | null>;
+    /** Scan ports 8188–9188 in parallel; associate discovered instances with podId. */
+    scanPorts(podId: string): Promise<LocalPodInstance[]>;
+    /** Re-probe a single instance's port and update its status. */
+    refreshInstance(instanceId: string): Promise<LocalPodInstance>;
+    startInstance(req: StartInstanceRequest): Promise<LocalPodInstance>;
+    stopInstance(instanceId: string): Promise<void>;
+    restartInstance(instanceId: string): Promise<void>;
+    deleteInstance(instanceId: string): Promise<void>;
+    getSystemInfo(): Promise<SystemInfo>;
+    getLogs(instanceId: string): Promise<string[]>;
+    onInstanceStatusChanged(cb: (instanceId: string, status: LocalPodInstanceStatus, info?: ComfyUISystemStats) => void): () => void;
+    onLog(cb: (instanceId: string, line: string) => void): () => void;
+    installRocmPyTorch(podId: string): void;
+    onRocmSetupDone(cb: (data: {
+        podId: string;
+        success: boolean;
+    }) => void): () => void;
+}

package/dist/local-types.js

@@ -0,0 +1,5 @@
+"use strict";
+// ============================================================
+// Local Pod Types — for Electron/local ComfyUI management
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/platform-types.d.ts

@@ -0,0 +1,156 @@
+export interface FlowscalePlatformConfig {
+    /** Flowscale JWT access token (from OAuth or login) */
+    token: string;
+    /** Team UUID — required for all team-scoped endpoints */
+    teamId: string;
+    /** Platform API base URL. Defaults to https://api.flowscale.ai */
+    baseUrl?: string;
+    /** Request timeout in ms. Default: 30000 */
+    timeout?: number;
+}
+export interface PlatformResponse<T = unknown> {
+    status: string;
+    data: T;
+    errors?: string;
+}
+export interface ProjectWorkflow {
+    id: string;
+    name: string;
+    description: string;
+    inputs: string;
+    outputs: string;
+}
+export interface Project {
+    _id: string;
+    name: string;
+    description?: string;
+    team_id: string;
+    cluster_url?: string;
+    api_key?: string;
+    status?: string;
+    created_at: string;
+    updated_at?: string;
+}
+export interface CreateProjectRequest {
+    name: string;
+    description?: string;
+    comfyui_version?: string;
+    [key: string]: unknown;
+}
+export interface UpdateProjectRequest {
+    name?: string;
+    description?: string;
+    [key: string]: unknown;
+}
+export interface ProjectApiKeyRequest {
+    name: string;
+    scopes?: string[];
+}
+export interface ProjectContentItem {
+    id: string;
+    name: string;
+    type: 'file' | 'folder';
+    path?: string;
+    size?: number;
+    created_at?: string;
+}
+export interface Pod {
+    _id: string;
+    name: string;
+    team_id: string;
+    project_id?: string;
+    status?: string;
+    gpu_type?: string;
+    budget?: number;
+    created_at: string;
+}
+export interface CreatePodRequest {
+    name: string;
+    project_id?: string;
+    gpu_type?: string;
+    budget?: number;
+    [key: string]: unknown;
+}
+export interface UpdatePodRequest {
+    name?: string;
+    budget?: number;
+    [key: string]: unknown;
+}
+export interface Cluster {
+    _id: string;
+    pod_id: string;
+    project_id?: string;
+    status: string;
+    created_at: string;
+    started_at?: string;
+    stopped_at?: string;
+}
+export interface StartClusterRequest {
+    pod_id: string;
+    project_id?: string;
+    [key: string]: unknown;
+}
+export interface ClusterLogEntry {
+    timestamp: string;
+    message: string;
+    level?: string;
+}
+export interface ClusterAnalytics {
+    [key: string]: unknown;
+}
+export interface PlatformRun {
+    _id: string;
+    team_id: string;
+    project_id?: string;
+    workflow_id?: string;
+    status: string;
+    created_at: string;
+    completed_at?: string;
+}
+export interface CreatePlatformRunRequest {
+    workflow_id: string;
+    inputs?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface TeamApiKey {
+    _id: string;
+    name: string;
+    key_preview: string;
+    scopes?: string[];
+    created_at: string;
+}
+export interface CreateTeamApiKeyRequest {
+    name: string;
+    scopes?: string[];
+}
+export interface InviteLink {
+    _id: string;
+    token: string;
+    url: string;
+    role?: string;
+    expires_at?: string;
+    created_at: string;
+}
+export interface CreateInviteLinkRequest {
+    role?: string;
+    expires_in_hours?: number;
+}
+export interface AnalyticsOverview {
+    total_runs: number;
+    total_api_calls: number;
+    credits_used: number;
+    [key: string]: unknown;
+}
+export interface RunsAnalytics {
+    [key: string]: unknown;
+}
+export interface ApiCallsAnalytics {
+    [key: string]: unknown;
+}
+export interface UserProfile {
+    username: string;
+    email: string;
+    avatar?: string;
+    is_active: boolean;
+    created_at: string;
+}

package/dist/platform-types.js

@@ -0,0 +1,5 @@
+"use strict";
+// ============================================================
+// Platform API — configuration
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/platform.d.ts

@@ -0,0 +1,29 @@
+import { FlowscaleAPI } from './index';
+import type { FlowscalePlatformConfig } from './platform-types';
+export declare class FlowscalePlatformAPI {
+    private client;
+    private teamId;
+    readonly projects: ReturnType<FlowscalePlatformAPI['buildProjects']>;
+    readonly pods: ReturnType<FlowscalePlatformAPI['buildPods']>;
+    readonly clusters: ReturnType<FlowscalePlatformAPI['buildClusters']>;
+    readonly runs: ReturnType<FlowscalePlatformAPI['buildRuns']>;
+    readonly team: ReturnType<FlowscalePlatformAPI['buildTeam']>;
+    readonly analytics: ReturnType<FlowscalePlatformAPI['buildAnalytics']>;
+    readonly auth: ReturnType<FlowscalePlatformAPI['buildAuth']>;
+    constructor(config: FlowscalePlatformConfig);
+    /**
+     * Create a deployment-level FlowscaleAPI client for a specific project cluster.
+     * @param clusterUrl  The cluster base URL from the project (e.g. https://cluster-xyz.flowscale.ai)
+     * @param apiKey      A project-scoped API key from project.addApiKey()
+     */
+    getDeploymentClient(clusterUrl: string, apiKey: string): FlowscaleAPI;
+    private request;
+    private buildProjects;
+    private buildPods;
+    private buildClusters;
+    private buildRuns;
+    private buildTeam;
+    private buildAnalytics;
+    private buildAuth;
+}
+export * from './platform-types';

package/dist/platform.js

@@ -0,0 +1,380 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowscalePlatformAPI = void 0;
+var axios_1 = __importDefault(require("axios"));
+var index_1 = require("./index");
+var DEFAULT_BASE_URL = 'https://api.flowscale.ai';
+var FlowscalePlatformAPI = /** @class */ (function () {
+    function FlowscalePlatformAPI(config) {
+        var _this = this;
+        var _a, _b;
+        if (!config.token)
+            throw new Error('FlowscalePlatformAPI: token is required');
+        if (!config.teamId)
+            throw new Error('FlowscalePlatformAPI: teamId is required');
+        this.teamId = config.teamId;
+        this.client = axios_1.default.create({
+            baseURL: ((_a = config.baseUrl) !== null && _a !== void 0 ? _a : DEFAULT_BASE_URL).trimEnd().replace(/\/$/, ''),
+            timeout: (_b = config.timeout) !== null && _b !== void 0 ? _b : 30000,
+        });
+        this.client.interceptors.request.use(function (req) {
+            if (!req.headers)
+                req.headers = {};
+            req.headers['Authorization'] = "Bearer ".concat(config.token);
+            req.headers['X-Team'] = _this.teamId;
+            return req;
+        });
+        this.projects = this.buildProjects();
+        this.pods = this.buildPods();
+        this.clusters = this.buildClusters();
+        this.runs = this.buildRuns();
+        this.team = this.buildTeam();
+        this.analytics = this.buildAnalytics();
+        this.auth = this.buildAuth();
+    }
+    // ── Bridge to deployment client ─────────────────────────
+    /**
+     * Create a deployment-level FlowscaleAPI client for a specific project cluster.
+     * @param clusterUrl  The cluster base URL from the project (e.g. https://cluster-xyz.flowscale.ai)
+     * @param apiKey      A project-scoped API key from project.addApiKey()
+     */
+    FlowscalePlatformAPI.prototype.getDeploymentClient = function (clusterUrl, apiKey) {
+        return new index_1.FlowscaleAPI({ baseUrl: clusterUrl, apiKey: apiKey });
+    };
+    // ── Helper ───────────────────────────────────────────────
+    FlowscalePlatformAPI.prototype.request = function (method, path, data, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.request({ method: method, url: path, data: data, params: params })];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    // ── Projects ─────────────────────────────────────────────
+    FlowscalePlatformAPI.prototype.buildProjects = function () {
+        var req = this.request.bind(this);
+        return {
+            /** List all projects for the team. */
+            list: function () {
+                return req('get', '/api/v2/project');
+            },
+            /** Get a single project by ID. */
+            get: function (projectId) {
+                return req('get', "/api/v2/project/".concat(enc(projectId)));
+            },
+            /** Get a public project (no auth required — skips team header). */
+            getPublic: function (projectId) {
+                return req('get', "/api/v2/project/public/".concat(enc(projectId)));
+            },
+            /** Create a new project. */
+            create: function (data) {
+                return req('post', '/api/v2/project', data);
+            },
+            /** Update a project. */
+            update: function (projectId, data) {
+                return req('put', "/api/v2/project/".concat(enc(projectId)), data);
+            },
+            /** Delete a project. */
+            delete: function (projectId) {
+                return req('delete', "/api/v2/project/".concat(enc(projectId)));
+            },
+            /** Fork a project into the current team. */
+            fork: function (projectId) {
+                return req('post', "/api/v2/project/".concat(enc(projectId), "/fork"));
+            },
+            /** List workflows for a project. */
+            listWorkflows: function (projectId) {
+                return req('get', "/api/v2/project/".concat(enc(projectId), "/workflows"));
+            },
+            /** Get a single workflow. */
+            getWorkflow: function (projectId, workflowId) {
+                return req('get', "/api/v2/project/".concat(enc(projectId), "/workflows/").concat(enc(workflowId)));
+            },
+            /** Add a project-scoped API key (use with getDeploymentClient). */
+            addApiKey: function (projectId, data) {
+                return req('post', "/api/v2/project/".concat(enc(projectId), "/api_key"), data);
+            },
+            /** Delete a project-scoped API key. */
+            deleteApiKey: function (projectId, data) {
+                return req('delete', "/api/v2/project/".concat(enc(projectId), "/api_key"), data);
+            },
+            /** List files and folders in a project. */
+            getContents: function (projectId) {
+                return req('get', "/api/v2/project/".concat(enc(projectId), "/contents"));
+            },
+            /** Create a folder inside a project. */
+            createFolder: function (projectId, data) {
+                return req('post', "/api/v2/project/".concat(enc(projectId), "/contents/folder"), data);
+            },
+            /** Download a file (returns download URL or content). */
+            downloadFile: function (projectId, fileId) {
+                return req('get', "/api/v2/project/".concat(enc(projectId), "/contents/file/").concat(enc(fileId), "/download"));
+            },
+            /** Delete a file from a project. */
+            deleteFile: function (projectId, fileId) {
+                return req('delete', "/api/v2/project/".concat(enc(projectId), "/contents/file/").concat(enc(fileId)));
+            },
+            /** Delete a folder from a project. */
+            deleteFolder: function (projectId, folderId) {
+                return req('delete', "/api/v2/project/".concat(enc(projectId), "/contents/folder/").concat(enc(folderId)));
+            },
+            /** Get ComfyUI compute balance for a project. */
+            getComfyBalance: function (projectId) {
+                return req('get', "/api/v2/project/".concat(enc(projectId), "/comfy/balance"));
+            },
+            /** Get storage usage analytics for a project. */
+            getStorageAnalytics: function (projectId) {
+                return req('get', "/api/v2/project/".concat(enc(projectId), "/storage-analytics"));
+            },
+            /** Get clusters deployed for a specific project. */
+            getDeployedClusters: function (projectId) {
+                return req('get', "/api/v2/project/".concat(enc(projectId), "/clusters/deployed"));
+            },
+        };
+    };
+    // ── Pods ─────────────────────────────────────────────────
+    FlowscalePlatformAPI.prototype.buildPods = function () {
+        var req = this.request.bind(this);
+        return {
+            /** List available GPU types. */
+            listGpus: function () {
+                return req('get', '/api/v2/pod/gpus');
+            },
+            /** List all pods for the team. */
+            list: function () {
+                return req('get', '/api/v2/pod');
+            },
+            /** Get a pod by ID. */
+            get: function (podId) {
+                return req('get', "/api/v2/pod/".concat(enc(podId)));
+            },
+            /** Create a new pod. */
+            create: function (data) {
+                return req('post', '/api/v2/pod', data);
+            },
+            /** Update pod settings. */
+            update: function (podId, data) {
+                return req('put', "/api/v2/pod/".concat(enc(podId)), data);
+            },
+            /** Update pod budget. */
+            updateBudget: function (podId, budget) {
+                return req('patch', "/api/v2/pod/".concat(enc(podId), "/budget"), { budget: budget });
+            },
+            /** Stop all running clusters for a pod. */
+            stop: function (podId) {
+                return req('post', "/api/v2/pod/".concat(enc(podId), "/stop"));
+            },
+            /** Delete a pod. */
+            delete: function (podId) {
+                return req('delete', "/api/v2/pod/".concat(enc(podId)));
+            },
+            /** List workflows attached to a pod. */
+            listWorkflows: function (podId) {
+                return req('get', "/api/v2/pod/".concat(enc(podId), "/workflows"));
+            },
+            /** List all clusters for a pod. */
+            listClusters: function (podId) {
+                return req('get', "/api/v2/pod/".concat(enc(podId), "/clusters"));
+            },
+            /** Get the currently active cluster for a pod. */
+            getActiveCluster: function (podId) {
+                return req('get', "/api/v2/pod/".concat(enc(podId), "/cluster/active"));
+            },
+        };
+    };
+    // ── Clusters ─────────────────────────────────────────────
+    FlowscalePlatformAPI.prototype.buildClusters = function () {
+        var req = this.request.bind(this);
+        return {
+            /** List all clusters for the team. */
+            list: function () {
+                return req('get', '/api/v2/cluster');
+            },
+            /** Get a cluster by ID. */
+            get: function (clusterId) {
+                return req('get', "/api/v2/cluster/".concat(enc(clusterId)));
+            },
+            /** Start (deploy) a new cluster. */
+            start: function (data) {
+                return req('post', '/api/v2/cluster', data);
+            },
+            /** Stop a running cluster. */
+            stop: function (clusterId) {
+                return req('post', "/api/v2/cluster/".concat(enc(clusterId), "/stop"));
+            },
+            /** Get logs for a cluster. */
+            getLogs: function (clusterId) {
+                return req('get', "/api/v2/cluster/".concat(enc(clusterId), "/logs"));
+            },
+            /** Get usage analytics for a cluster. */
+            getAnalytics: function (clusterId) {
+                return req('get', "/api/v2/cluster/".concat(enc(clusterId), "/analytics"));
+            },
+            /** Analyze init logs with AI. */
+            analyzeInitLogs: function (clusterId) {
+                return req('post', "/api/v2/cluster/".concat(enc(clusterId), "/analyze-init-logs"));
+            },
+            /** Get temp nodes for a cluster. */
+            getTempNodes: function (clusterId) {
+                return req('get', "/api/v2/cluster/".concat(enc(clusterId), "/tempnodes"));
+            },
+        };
+    };
+    // ── Runs (platform-level) ─────────────────────────────────
+    FlowscalePlatformAPI.prototype.buildRuns = function () {
+        var req = this.request.bind(this);
+        return {
+            /** List all runs for the team. */
+            list: function (params) {
+                return req('get', '/api/v2/run', undefined, params);
+            },
+            /** Create a new run. */
+            create: function (data) {
+                return req('post', '/api/v2/run', data);
+            },
+            /** Delete a single run. */
+            delete: function (runId) {
+                return req('delete', "/api/v2/run/".concat(enc(runId)));
+            },
+            /** List output filenames for recent runs. */
+            listOutputs: function () {
+                return req('get', '/api/v2/run/outputs/list');
+            },
+        };
+    };
+    // ── Team ─────────────────────────────────────────────────
+    FlowscalePlatformAPI.prototype.buildTeam = function () {
+        var req = this.request.bind(this);
+        return {
+            /** List team-level API keys. */
+            listApiKeys: function () {
+                return req('get', '/api/v2/team/api-keys');
+            },
+            /** Create a new team-level API key. */
+            createApiKey: function (data) {
+                return req('post', '/api/v2/team/api-keys', data);
+            },
+            /** Revoke a team-level API key. */
+            revokeApiKey: function (keyId) {
+                return req('delete', "/api/v2/team/api-keys/".concat(enc(keyId)));
+            },
+            /** List active invite links. */
+            listInviteLinks: function () {
+                return req('get', '/api/v2/team/invite-links');
+            },
+            /** Create a new invite link. */
+            createInviteLink: function (data) {
+                return req('post', '/api/v2/team/invite-link', data);
+            },
+            /** Delete an invite link. */
+            deleteInviteLink: function (linkId) {
+                return req('delete', "/api/v2/team/invite-link/".concat(enc(linkId)));
+            },
+        };
+    };
+    // ── Analytics ────────────────────────────────────────────
+    FlowscalePlatformAPI.prototype.buildAnalytics = function () {
+        var req = this.request.bind(this);
+        return {
+            /** Get all analytics for the team. */
+            get: function (params) {
+                return req('get', '/api/v2/analytics', undefined, params);
+            },
+            /** Get high-level overview metrics. */
+            getOverview: function () {
+                return req('get', '/api/v2/analytics/overview');
+            },
+            /** Get run-specific analytics. */
+            getRuns: function (params) {
+                return req('get', '/api/v2/analytics/runs', undefined, params);
+            },
+            /** Get API call analytics. */
+            getApiCalls: function (params) {
+                return req('get', '/api/v2/analytics/api-calls', undefined, params);
+            },
+        };
+    };
+    // ── Auth ─────────────────────────────────────────────────
+    FlowscalePlatformAPI.prototype.buildAuth = function () {
+        var req = this.request.bind(this);
+        return {
+            /** Get the current user's profile. */
+            getProfile: function () {
+                return req('get', '/api/v2/auth/profile');
+            },
+            /** Refresh the access token using the refresh token. */
+            refreshToken: function (refreshToken) {
+                return req('post', '/api/v2/auth/refresh', { refresh_token: refreshToken });
+            },
+            /** Logout (invalidate current token). */
+            logout: function () {
+                return req('post', '/api/v2/auth/logout');
+            },
+        };
+    };
+    return FlowscalePlatformAPI;
+}());
+exports.FlowscalePlatformAPI = FlowscalePlatformAPI;
+// ── Utility ───────────────────────────────────────────────
+function enc(value) {
+    return encodeURIComponent(value);
+}
+__exportStar(require("./platform-types"), exports);

package/package.json

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