flowscale 1.0.13 → 1.0.15

package/README.md

@@ -1,6 +1,25 @@
 # Flowscale Node.js SDK
 
-A comprehensive Node.js SDK designed to simplify interaction with the FlowScale ComfyUI API. This library abstracts away the complexities of API calls, enabling you to effortlessly invoke workflows, retrieve outputs, manage workflow runs, and monitor system health.
+A comprehensive SDK designed to simplify interaction with the FlowScale ComfyUI API. This library works in both Node.js and browser environments.
+
+---
+
+## ⚠️ Important Security Notice for Browser Usage
+
+When using this SDK in a browser environment, your API key will be exposed to end users. This is a significant security risk. We strongly recommend:
+
+1. Using this SDK in a Node.js backend environment
+2. Creating a proxy API that securely handles the API key server-side
+
+If you understand the risks and still need to use the SDK directly in the browser, you must explicitly acknowledge this by setting the `allowDangerouslyExposeApiKey` parameter:
+
+```javascript
+const flowscale = new FlowscaleAPI(
+  apiKey,
+  apiUrl,
+  true // allowDangerouslyExposeApiKey - Only set to true if you understand the security risks
+);
+```
 
 ---
 
@@ -29,18 +48,31 @@ To get started, import the Flowscale SDK into your project:
 ```javascript
 import { FlowscaleAPI } from 'flowscale';
 
-// Initialize the SDK
+// Node.js Environment (Recommended)
 const apiKey = process.env.FLOWSCALE_API_KEY;
 const apiUrl = process.env.FLOWSCALE_API_URL;
-
-if (!apiKey || !apiUrl) {
-  console.error('FLOWSCALE_API_KEY or FLOWSCALE_API_URL not set in .env');
-  process.exit(1);
-}
-
 const flowscale = new FlowscaleAPI(apiKey, apiUrl);
+
+// Browser Environment (Not Recommended)
+const flowscale = new FlowscaleAPI(
+  'your-api-key', // ⚠️ WARNING: This will be exposed to users
+  'https://your-api-url.pod.flowscale.ai',
+  true // Explicitly acknowledge the security risk
+);
 ```
 
+### Environment-Specific Considerations
+
+#### Node.js (Recommended)
+- Store API keys in environment variables
+- Use `.env` files for configuration
+- Full access to all SDK features
+
+#### Browser
+- API key will be visible in network requests
+- Supports File/Blob uploads directly from browser
+- Consider implementing a backend proxy instead
+
 **Environment Variables:** Add the following to your `.env` file:
 
 ```plaintext
@@ -165,6 +197,51 @@ console.log('Workflow Result:', result);
 
 ---
 
+### 3.1 `executeWorkflowAsync(workflowId, data, groupId?, pollIntervalMs?, timeoutMs?)`
+
+**Description:**
+Execute a workflow and automatically wait for the result by polling the output. This is a convenience method that combines `executeWorkflow` and `getOutput` with automatic polling.
+
+**Parameters:**
+- `workflowId` *(string)*: The unique ID of the workflow.
+- `data` *(object)*: Input parameters for the workflow.
+- `groupId` *(string, optional)*: A custom identifier for grouping runs.
+- `pollIntervalMs` *(number, optional)*: Polling interval in milliseconds (default: 1000).
+- `timeoutMs` *(number, optional)*: Maximum time to wait for results in milliseconds (default: 300000 - 5 minutes).
+
+**Usage:**
+```javascript
+const workflowId = "bncu0a1kipv";
+const inputs = {
+   "text_51536": "Prompt test",
+   "image_1234": { /* File or Blob of image */ }
+};
+
+try {
+  const result = await flowscale.executeWorkflowAsync(workflowId, inputs);
+  console.log('Workflow Result:', result);
+} catch (error) {
+  if (error.message.includes('timed out')) {
+    console.error('Workflow took too long to complete');
+  } else {
+    console.error('Workflow error:', error);
+  }
+}
+```
+
+**Response Example:**
+```json
+{
+  "status": "success",
+  "data": {
+    "download_url": "https://runs.s3.amazonaws.com/generations/...",
+    "generation_status": "success"
+  }
+}
+```
+
+---
+
 ### 4. `getOutput(filename)`
 
 **Description:**

package/dist/index.d.ts

@@ -3,7 +3,8 @@ export declare class FlowscaleAPI {
     private apiKey;
     private baseUrl;
     private client;
-    constructor(apiKey: string, baseUrl: string);
+    private isNode;
+    constructor(apiKey: string, baseUrl: string, allowDangerouslyExposeApiKey?: boolean);
     /**
      * Checks the health status of all ComfyUI instances within the specified cluster.
      */
@@ -21,6 +22,17 @@ export declare class FlowscaleAPI {
     executeWorkflow(workflowId: string, data: {
         [key: string]: any;
     }, groupId?: string): Promise<ExecuteWorkflowResponse>;
+    /**
+     * Executes a workflow and waits for the output by polling.
+     * @param workflowId - The ID of the workflow to execute.
+     * @param data - Form data including text fields and file uploads.
+     * @param groupId - Optional group ID.
+     * @param pollIntervalMs - Optional polling interval in milliseconds (default: 1000)
+     * @param timeoutMs - Optional timeout in milliseconds (default: 300000 - 5 minutes)
+     */
+    executeWorkflowAsync(workflowId: string, data: {
+        [key: string]: any;
+    }, groupId?: string, pollIntervalMs?: number, timeoutMs?: number): Promise<GetOutputResponse>;
     /**
      * Retrieves the output of a specific run by providing the filename.
      * @param filename - The filename of the output to retrieve.

package/dist/index.js

@@ -1,15 +1,4 @@
 "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 __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) {
@@ -52,12 +41,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowscaleAPI = void 0;
 var axios_1 = __importDefault(require("axios"));
-var form_data_1 = __importDefault(require("form-data"));
-var fs_1 = __importDefault(require("fs"));
-var path_1 = __importDefault(require("path"));
 var FlowscaleAPI = /** @class */ (function () {
-    function FlowscaleAPI(apiKey, baseUrl) {
+    function FlowscaleAPI(apiKey, baseUrl, allowDangerouslyExposeApiKey) {
+        if (allowDangerouslyExposeApiKey === void 0) { allowDangerouslyExposeApiKey = false; }
         var _this = this;
+        // Check if we're in a Node.js environment
+        this.isNode = typeof process !== 'undefined' &&
+            process.versions != null &&
+            process.versions.node != null;
+        // Warn about API key exposure in browser environment
+        if (!this.isNode && !allowDangerouslyExposeApiKey) {
+            throw new Error('WARNING: Using FlowscaleAPI in a browser environment will expose your API key to end users. ' +
+                'This is a security risk. If you understand the risks and still want to proceed, ' +
+                'set allowDangerouslyExposeApiKey to true. ' +
+                'We strongly recommend using a backend proxy instead.');
+        }
         this.apiKey = apiKey;
         this.baseUrl = baseUrl;
         this.client = axios_1.default.create({
@@ -132,7 +130,7 @@ var FlowscaleAPI = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 2, , 3]);
-                        formData_1 = new form_data_1.default();
+                        formData_1 = new FormData();
                         _loop_1 = function (key) {
                             if (data.hasOwnProperty(key)) {
                                 var value = data[key];
@@ -152,7 +150,10 @@ var FlowscaleAPI = /** @class */ (function () {
                         for (key in data) {
                             _loop_1(key);
                         }
-                        headers = __assign(__assign({}, formData_1.getHeaders()), { 'X-API-KEY': this.apiKey });
+                        headers = {
+                            'Content-Type': 'multipart/form-data',
+                            'X-API-KEY': this.apiKey,
+                        };
                         url = "/api/v1/runs?workflow_id=".concat(encodeURIComponent(workflowId)).concat(groupId ? "&group_id=".concat(encodeURIComponent(groupId)) : '');
                         return [4 /*yield*/, this.client.post(url, formData_1, { headers: headers })];
                     case 1:
@@ -167,6 +168,55 @@ var FlowscaleAPI = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Executes a workflow and waits for the output by polling.
+     * @param workflowId - The ID of the workflow to execute.
+     * @param data - Form data including text fields and file uploads.
+     * @param groupId - Optional group ID.
+     * @param pollIntervalMs - Optional polling interval in milliseconds (default: 1000)
+     * @param timeoutMs - Optional timeout in milliseconds (default: 300000 - 5 minutes)
+     */
+    FlowscaleAPI.prototype.executeWorkflowAsync = function (workflowId_1, data_1, groupId_1) {
+        return __awaiter(this, arguments, void 0, function (workflowId, data, groupId, pollIntervalMs, timeoutMs) {
+            var startTime, executeResponse, outputName, output;
+            var _a, _b;
+            if (pollIntervalMs === void 0) { pollIntervalMs = 1000; }
+            if (timeoutMs === void 0) { timeoutMs = 300000; }
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        startTime = Date.now();
+                        return [4 /*yield*/, this.executeWorkflow(workflowId, data, groupId)];
+                    case 1:
+                        executeResponse = _c.sent();
+                        // If there are no output names, throw an error
+                        if (!((_b = (_a = executeResponse === null || executeResponse === void 0 ? void 0 : executeResponse.data) === null || _a === void 0 ? void 0 : _a.output_names) === null || _b === void 0 ? void 0 : _b.length)) {
+                            throw new Error('No output names returned from workflow execution');
+                        }
+                        outputName = executeResponse.data.output_names[0];
+                        _c.label = 2;
+                    case 2:
+                        if (!true) return [3 /*break*/, 5];
+                        if (Date.now() - startTime > timeoutMs) {
+                            throw new Error("Workflow execution timed out after ".concat(timeoutMs, "ms"));
+                        }
+                        return [4 /*yield*/, this.getOutput(outputName)];
+                    case 3:
+                        output = _c.sent();
+                        if (output !== null) {
+                            return [2 /*return*/, output];
+                        }
+                        // Wait for the polling interval
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, pollIntervalMs); })];
+                    case 4:
+                        // Wait for the polling interval
+                        _c.sent();
+                        return [3 /*break*/, 2];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Retrieves the output of a specific run by providing the filename.
      * @param filename - The filename of the output to retrieve.
@@ -284,21 +334,16 @@ var FlowscaleAPI = /** @class */ (function () {
      * Helper method to append data to FormData.
      */
     FlowscaleAPI.prototype.appendFormData = function (formData, key, value) {
-        if (value instanceof fs_1.default.ReadStream) {
-            // It's a file stream
+        if (value instanceof Blob || value instanceof File) {
+            // Handle File and Blob objects directly
             formData.append(key, value);
         }
-        else if (Buffer.isBuffer(value)) {
-            // It's a Buffer
-            formData.append(key, value, { filename: "".concat(key, ".dat") });
-        }
-        else if (typeof value === 'string' && fs_1.default.existsSync(value)) {
-            // If the value is a file path
-            var fileName = path_1.default.basename(value);
-            formData.append(key, fs_1.default.createReadStream(value), fileName);
+        else if (typeof value === 'object' && value !== null) {
+            // Handle plain objects by stringifying
+            formData.append(key, JSON.stringify(value));
         }
         else {
-            // Assume it's a string or other value
+            // Handle primitive values
             formData.append(key, value);
         }
     };

package/package.json

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