flowscale 2.1.0-beta.0 → 2.1.0-beta.1

package/dist/index.d.ts

@@ -123,4 +123,6 @@ 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.FlowscalePlatformAPI = 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) {
@@ -1297,4 +1297,8 @@ __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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowscale",
-  "version": "2.1.0-beta.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",