comfyui-node 1.6.6 → 1.6.7

package/dist/pool/WorkflowPool.d.ts

@@ -1,203 +1,203 @@
-import { TypedEventTarget } from "../typed-event-target.js";
-import type { ComfyApi } from "../client.js";
-import type { QueueAdapter, QueueStats } from "./queue/QueueAdapter.js";
-import type { FailoverStrategy } from "./failover/Strategy.js";
-import type { JobRecord, WorkflowInput, WorkflowJobOptions, JobId } from "./types/job.js";
-import type { WorkflowPoolEventMap } from "./types/events.js";
-import type { WorkflowAffinity } from "./types/affinity.js";
-/**
- * Configuration options for WorkflowPool.
- */
-export interface WorkflowPoolOpts {
-    /**
-     * An array of workflow affinity rules to establish a default mapping
-     * between workflows and specific clients.
-     *
-     * @example
-     * ```ts
-     * const pool = new WorkflowPool(clients, {
-     *   workflowAffinities: [
-     *     { workflowHash: "hash1", preferredClientIds: ["client-a"] },
-     *     { workflowHash: "hash2", excludeClientIds: ["client-b"] },
-     *   ]
-     * });
-     * ```
-     */
-    workflowAffinities?: WorkflowAffinity[];
-    /**
-     * Queue adapter for managing job queue operations.
-     *
-     * @default MemoryQueueAdapter (in-memory queue)
-     * @example
-     * ```ts
-     * import { WorkflowPool, MemoryQueueAdapter } from 'comfyui-node';
-     * const pool = new WorkflowPool(clients, {
-     *   queueAdapter: new MemoryQueueAdapter()
-     * });
-     * ```
-     */
-    queueAdapter?: QueueAdapter;
-    /**
-     * Failover strategy for handling client failures and workflow routing.
-     *
-     * @default SmartFailoverStrategy (exponential backoff with workflow-specific cooldowns)
-     * @example
-     * ```ts
-     * import { WorkflowPool, SmartFailoverStrategy } from 'comfyui-node';
-     * const pool = new WorkflowPool(clients, {
-     *   failoverStrategy: new SmartFailoverStrategy()
-     * });
-     * ```
-     */
-    failoverStrategy?: FailoverStrategy;
-    /**
-     * Base retry backoff delay in milliseconds for failed jobs.
-     * Actual delay may be adjusted by the failover strategy.
-     *
-     * @default 1000 (1 second)
-     */
-    retryBackoffMs?: number;
-    /**
-     * Timeout in milliseconds for execution to start after job is queued.
-     *
-     * If a server gets stuck before emitting the `execution_start` event, the job
-     * will be failed and retried on another server after this timeout.
-     *
-     * This prevents jobs from being lost when a server accepts a prompt but fails
-     * to begin execution (e.g., GPU hang, process crash, deadlock).
-     *
-     * Set to `0` to disable timeout (not recommended for production).
-     *
-     * @default 5000 (5 seconds)
-     * @example
-     * ```ts
-     * const pool = new WorkflowPool(clients, {
-     *   executionStartTimeoutMs: 10000 // 10 seconds
-     * });
-     * ```
-     * @since 1.5.0
-     */
-    executionStartTimeoutMs?: number;
-    /**
-     * Timeout in milliseconds for individual node execution.
-     *
-     * If a node takes longer than this timeout to execute (time between `executing` events),
-     * the job will be failed and retried on another server.
-     *
-     * This is critical for:
-     * - Model loading on slow disks (can take 60+ seconds on first load)
-     * - Heavy diffusion steps on slower GPUs
-     * - VAE decode operations on large images
-     * - Custom nodes with long processing times
-     *
-     * The timeout is per-node, not total execution time. Each node gets the full timeout duration.
-     *
-     * Set to `0` to disable timeout (not recommended for production).
-     *
-     * @default 300000 (5 minutes)
-     * @example
-     * ```ts
-     * const pool = new WorkflowPool(clients, {
-     *   nodeExecutionTimeoutMs: 600000 // 10 minutes for slow model loading
-     * });
-     * ```
-     * @remarks
-     * - Timeout resets when a new node starts executing
-     * - Progress events (e.g., KSampler steps) reset the timeout
-     * - First generation with model loading often needs longer timeout
-     * - Cached nodes complete instantly and don't trigger timeout
-     * @since 1.5.0
-     */
-    nodeExecutionTimeoutMs?: number;
-    /**
-     * Interval in milliseconds for health check pings to keep WebSocket connections alive.
-     *
-     * Health checks prevent idle connection timeouts by periodically pinging inactive clients
-     * with lightweight `getQueue()` calls. This maintains stable connections when the pool
-     * has no active jobs, avoiding false disconnection alerts.
-     *
-     * Set to `0` to disable health checks (not recommended for production).
-     *
-     * @default 30000 (30 seconds)
-     * @example
-     * ```ts
-     * const pool = new WorkflowPool(clients, {
-     *   healthCheckIntervalMs: 30000 // ping every 30 seconds
-     * });
-     * ```
-     * @remarks
-     * - Only pings idle (non-busy) clients to avoid interference with active jobs
-     * - Recommended for long-running services or when using persistent connections
-     * - Lower values increase network traffic but detect issues faster
-     * - Higher values reduce overhead but may miss connection issues sooner
-     * @since 1.4.1
-     */
-    healthCheckIntervalMs?: number;
-    /**
-     * Enable automatic profiling of workflow execution.
-     *
-     * When enabled, captures detailed per-node execution metrics including:
-     * - Node execution timing (start, end, duration)
-     * - Progress events for long-running nodes
-     * - Cached vs executed nodes
-     * - Execution order and dependencies
-     *
-     * Profile stats are attached to `JobRecord.profileStats` and included
-     * in `job:completed` event details.
-     *
-     * @default false
-     * @example
-     * ```ts
-     * const pool = new WorkflowPool(clients, {
-     *   enableProfiling: true
-     * });
-     *
-     * pool.on('job:completed', (event) => {
-     *   const stats = event.detail.job.profileStats;
-     *   console.log(`Total: ${stats.totalDuration}ms`);
-     *   console.log(`Slowest nodes:`, stats.summary.slowestNodes);
-     * });
-     * ```
-     * @since 1.5.0
-     */
-    enableProfiling?: boolean;
-}
-export declare class WorkflowPool extends TypedEventTarget<WorkflowPoolEventMap> {
-    private queue;
-    private strategy;
-    private clientManager;
-    private opts;
-    private jobStore;
-    private jobFailureAnalysis;
-    private affinities;
-    private initPromise;
-    private processing;
-    private processQueued;
-    private activeJobs;
-    private readonly queueDebug;
-    private debugLog;
-    constructor(clients: ComfyApi[], opts?: WorkflowPoolOpts);
-    ready(): Promise<void>;
-    setAffinity(affinity: WorkflowAffinity): void;
-    removeAffinity(workflowHash: string): boolean;
-    getAffinities(): WorkflowAffinity[];
-    enqueue(workflowInput: WorkflowInput, options?: WorkflowJobOptions): Promise<JobId>;
-    getJob(jobId: string): JobRecord | undefined;
-    cancel(jobId: string): Promise<boolean>;
-    shutdown(): Promise<void>;
-    getQueueStats(): Promise<QueueStats>;
-    private normalizeWorkflow;
-    private generateJobId;
-    private static fallbackId;
-    private scheduleProcess;
-    private applyAutoSeed;
-    private rememberJobFailure;
-    private clearJobFailures;
-    private collectFailureReasons;
-    private addPermanentExclusion;
-    private hasRetryPath;
-    private createWorkflowNotSupportedError;
-    private processQueue;
-    private runJob;
-}
+import { TypedEventTarget } from "../typed-event-target.js";
+import type { ComfyApi } from "../client.js";
+import type { QueueAdapter, QueueStats } from "./queue/QueueAdapter.js";
+import type { FailoverStrategy } from "./failover/Strategy.js";
+import type { JobRecord, WorkflowInput, WorkflowJobOptions, JobId } from "./types/job.js";
+import type { WorkflowPoolEventMap } from "./types/events.js";
+import type { WorkflowAffinity } from "./types/affinity.js";
+/**
+ * Configuration options for WorkflowPool.
+ */
+export interface WorkflowPoolOpts {
+    /**
+     * An array of workflow affinity rules to establish a default mapping
+     * between workflows and specific clients.
+     *
+     * @example
+     * ```ts
+     * const pool = new WorkflowPool(clients, {
+     *   workflowAffinities: [
+     *     { workflowHash: "hash1", preferredClientIds: ["client-a"] },
+     *     { workflowHash: "hash2", excludeClientIds: ["client-b"] },
+     *   ]
+     * });
+     * ```
+     */
+    workflowAffinities?: WorkflowAffinity[];
+    /**
+     * Queue adapter for managing job queue operations.
+     *
+     * @default MemoryQueueAdapter (in-memory queue)
+     * @example
+     * ```ts
+     * import { WorkflowPool, MemoryQueueAdapter } from 'comfyui-node';
+     * const pool = new WorkflowPool(clients, {
+     *   queueAdapter: new MemoryQueueAdapter()
+     * });
+     * ```
+     */
+    queueAdapter?: QueueAdapter;
+    /**
+     * Failover strategy for handling client failures and workflow routing.
+     *
+     * @default SmartFailoverStrategy (exponential backoff with workflow-specific cooldowns)
+     * @example
+     * ```ts
+     * import { WorkflowPool, SmartFailoverStrategy } from 'comfyui-node';
+     * const pool = new WorkflowPool(clients, {
+     *   failoverStrategy: new SmartFailoverStrategy()
+     * });
+     * ```
+     */
+    failoverStrategy?: FailoverStrategy;
+    /**
+     * Base retry backoff delay in milliseconds for failed jobs.
+     * Actual delay may be adjusted by the failover strategy.
+     *
+     * @default 1000 (1 second)
+     */
+    retryBackoffMs?: number;
+    /**
+     * Timeout in milliseconds for execution to start after job is queued.
+     *
+     * If a server gets stuck before emitting the `execution_start` event, the job
+     * will be failed and retried on another server after this timeout.
+     *
+     * This prevents jobs from being lost when a server accepts a prompt but fails
+     * to begin execution (e.g., GPU hang, process crash, deadlock).
+     *
+     * Set to `0` to disable timeout (not recommended for production).
+     *
+     * @default 5000 (5 seconds)
+     * @example
+     * ```ts
+     * const pool = new WorkflowPool(clients, {
+     *   executionStartTimeoutMs: 10000 // 10 seconds
+     * });
+     * ```
+     * @since 1.5.0
+     */
+    executionStartTimeoutMs?: number;
+    /**
+     * Timeout in milliseconds for individual node execution.
+     *
+     * If a node takes longer than this timeout to execute (time between `executing` events),
+     * the job will be failed and retried on another server.
+     *
+     * This is critical for:
+     * - Model loading on slow disks (can take 60+ seconds on first load)
+     * - Heavy diffusion steps on slower GPUs
+     * - VAE decode operations on large images
+     * - Custom nodes with long processing times
+     *
+     * The timeout is per-node, not total execution time. Each node gets the full timeout duration.
+     *
+     * Set to `0` to disable timeout (not recommended for production).
+     *
+     * @default 300000 (5 minutes)
+     * @example
+     * ```ts
+     * const pool = new WorkflowPool(clients, {
+     *   nodeExecutionTimeoutMs: 600000 // 10 minutes for slow model loading
+     * });
+     * ```
+     * @remarks
+     * - Timeout resets when a new node starts executing
+     * - Progress events (e.g., KSampler steps) reset the timeout
+     * - First generation with model loading often needs longer timeout
+     * - Cached nodes complete instantly and don't trigger timeout
+     * @since 1.5.0
+     */
+    nodeExecutionTimeoutMs?: number;
+    /**
+     * Interval in milliseconds for health check pings to keep WebSocket connections alive.
+     *
+     * Health checks prevent idle connection timeouts by periodically pinging inactive clients
+     * with lightweight `getQueue()` calls. This maintains stable connections when the pool
+     * has no active jobs, avoiding false disconnection alerts.
+     *
+     * Set to `0` to disable health checks (not recommended for production).
+     *
+     * @default 30000 (30 seconds)
+     * @example
+     * ```ts
+     * const pool = new WorkflowPool(clients, {
+     *   healthCheckIntervalMs: 30000 // ping every 30 seconds
+     * });
+     * ```
+     * @remarks
+     * - Only pings idle (non-busy) clients to avoid interference with active jobs
+     * - Recommended for long-running services or when using persistent connections
+     * - Lower values increase network traffic but detect issues faster
+     * - Higher values reduce overhead but may miss connection issues sooner
+     * @since 1.4.1
+     */
+    healthCheckIntervalMs?: number;
+    /**
+     * Enable automatic profiling of workflow execution.
+     *
+     * When enabled, captures detailed per-node execution metrics including:
+     * - Node execution timing (start, end, duration)
+     * - Progress events for long-running nodes
+     * - Cached vs executed nodes
+     * - Execution order and dependencies
+     *
+     * Profile stats are attached to `JobRecord.profileStats` and included
+     * in `job:completed` event details.
+     *
+     * @default false
+     * @example
+     * ```ts
+     * const pool = new WorkflowPool(clients, {
+     *   enableProfiling: true
+     * });
+     *
+     * pool.on('job:completed', (event) => {
+     *   const stats = event.detail.job.profileStats;
+     *   console.log(`Total: ${stats.totalDuration}ms`);
+     *   console.log(`Slowest nodes:`, stats.summary.slowestNodes);
+     * });
+     * ```
+     * @since 1.5.0
+     */
+    enableProfiling?: boolean;
+}
+export declare class WorkflowPool extends TypedEventTarget<WorkflowPoolEventMap> {
+    private queue;
+    private strategy;
+    private clientManager;
+    private opts;
+    private jobStore;
+    private jobFailureAnalysis;
+    private affinities;
+    private initPromise;
+    private processing;
+    private processQueued;
+    private activeJobs;
+    private readonly queueDebug;
+    private debugLog;
+    constructor(clients: ComfyApi[], opts?: WorkflowPoolOpts);
+    ready(): Promise<void>;
+    setAffinity(affinity: WorkflowAffinity): void;
+    removeAffinity(workflowHash: string): boolean;
+    getAffinities(): WorkflowAffinity[];
+    enqueue(workflowInput: WorkflowInput, options?: WorkflowJobOptions): Promise<JobId>;
+    getJob(jobId: string): JobRecord | undefined;
+    cancel(jobId: string): Promise<boolean>;
+    shutdown(): Promise<void>;
+    getQueueStats(): Promise<QueueStats>;
+    private normalizeWorkflow;
+    private generateJobId;
+    private static fallbackId;
+    private scheduleProcess;
+    private applyAutoSeed;
+    private rememberJobFailure;
+    private clearJobFailures;
+    private collectFailureReasons;
+    private addPermanentExclusion;
+    private hasRetryPath;
+    private createWorkflowNotSupportedError;
+    private processQueue;
+    private runJob;
+}
 //# sourceMappingURL=WorkflowPool.d.ts.map

package/dist/pool/client/ClientManager.d.ts

@@ -1,87 +1,87 @@
-import type { ComfyApi } from "../../client.js";
-import { TypedEventTarget } from "../../typed-event-target.js";
-import type { JobRecord } from "../types/job.js";
-import type { FailoverStrategy } from "../failover/Strategy.js";
-import type { WorkflowPoolEventMap } from "../types/events.js";
-export interface ManagedClient {
-    client: ComfyApi;
-    id: string;
-    online: boolean;
-    busy: boolean;
-    lastError?: unknown;
-    lastSeenAt: number;
-    supportedWorkflows: Set<string>;
-    lastDisconnectedAt?: number;
-    reconnectionStableAt?: number;
-}
-interface ClientLease {
-    client: ComfyApi;
-    clientId: string;
-    release: (opts?: {
-        success?: boolean;
-    }) => void;
-}
-export declare class ClientManager extends TypedEventTarget<WorkflowPoolEventMap> {
-    private clients;
-    private strategy;
-    private healthCheckInterval;
-    private readonly healthCheckIntervalMs;
-    private readonly debugLogs;
-    /**
-     * Grace period after reconnection before client is considered stable (default: 10 seconds).
-     * ComfyUI sometimes quickly disconnects/reconnects after job execution.
-     * During this grace period, the client won't be used for new jobs.
-     */
-    private readonly reconnectionGracePeriodMs;
-    /**
-     * Create a new ClientManager for managing ComfyUI client connections.
-     *
-     * @param strategy - Failover strategy for handling client failures
-     * @param opts - Configuration options
-     * @param opts.healthCheckIntervalMs - Interval (ms) for health check pings to keep connections alive.
-     *   Set to 0 to disable. Default: 30000 (30 seconds).
-     */
-    constructor(strategy: FailoverStrategy, opts?: {
-        /**
-         * Interval in milliseconds for health check pings.
-         * Health checks keep idle connections alive by periodically polling client status.
-         * @default 30000 (30 seconds)
-         */
-        healthCheckIntervalMs?: number;
-    });
-    private emitBlocked;
-    private emitUnblocked;
-    initialize(clients: ComfyApi[]): Promise<void>;
-    addClient(client: ComfyApi): Promise<void>;
-    list(): ManagedClient[];
-    getClient(clientId: string): ManagedClient | undefined;
-    /**
-     * Checks if a client is truly available for work.
-     * A client must be online, not busy, AND past the reconnection grace period.
-     */
-    isClientStable(client: ManagedClient): boolean;
-    canClientRunJob(client: ManagedClient, job: JobRecord): boolean;
-    claim(job: JobRecord, specificClientId?: string): ClientLease | null;
-    recordFailure(clientId: string, job: JobRecord, error: unknown): void;
-    /**
-     * Start periodic health check to keep connections alive and detect issues early.
-     * Pings idle clients by polling their queue status.
-     */
-    private startHealthCheck;
-    /**
-     * Perform health check on all clients.
-     * Polls queue status to keep WebSocket alive and detect connection issues.
-     * IMPORTANT: Pings ALL online clients (including busy ones) to prevent WebSocket timeout during heavy load.
-     */
-    private performHealthCheck;
-    /**
-     * Stop health check interval (called during shutdown).
-     */
-    stopHealthCheck(): void;
-    /**
-     * Cleanup resources when destroying the manager.
-     */
-    destroy(): void;
-}
-export {};
+import type { ComfyApi } from "../../client.js";
+import { TypedEventTarget } from "../../typed-event-target.js";
+import type { JobRecord } from "../types/job.js";
+import type { FailoverStrategy } from "../failover/Strategy.js";
+import type { WorkflowPoolEventMap } from "../types/events.js";
+export interface ManagedClient {
+    client: ComfyApi;
+    id: string;
+    online: boolean;
+    busy: boolean;
+    lastError?: unknown;
+    lastSeenAt: number;
+    supportedWorkflows: Set<string>;
+    lastDisconnectedAt?: number;
+    reconnectionStableAt?: number;
+}
+interface ClientLease {
+    client: ComfyApi;
+    clientId: string;
+    release: (opts?: {
+        success?: boolean;
+    }) => void;
+}
+export declare class ClientManager extends TypedEventTarget<WorkflowPoolEventMap> {
+    private clients;
+    private strategy;
+    private healthCheckInterval;
+    private readonly healthCheckIntervalMs;
+    private readonly debugLogs;
+    /**
+     * Grace period after reconnection before client is considered stable (default: 10 seconds).
+     * ComfyUI sometimes quickly disconnects/reconnects after job execution.
+     * During this grace period, the client won't be used for new jobs.
+     */
+    private readonly reconnectionGracePeriodMs;
+    /**
+     * Create a new ClientManager for managing ComfyUI client connections.
+     *
+     * @param strategy - Failover strategy for handling client failures
+     * @param opts - Configuration options
+     * @param opts.healthCheckIntervalMs - Interval (ms) for health check pings to keep connections alive.
+     *   Set to 0 to disable. Default: 30000 (30 seconds).
+     */
+    constructor(strategy: FailoverStrategy, opts?: {
+        /**
+         * Interval in milliseconds for health check pings.
+         * Health checks keep idle connections alive by periodically polling client status.
+         * @default 30000 (30 seconds)
+         */
+        healthCheckIntervalMs?: number;
+    });
+    private emitBlocked;
+    private emitUnblocked;
+    initialize(clients: ComfyApi[]): Promise<void>;
+    addClient(client: ComfyApi): Promise<void>;
+    list(): ManagedClient[];
+    getClient(clientId: string): ManagedClient | undefined;
+    /**
+     * Checks if a client is truly available for work.
+     * A client must be online, not busy, AND past the reconnection grace period.
+     */
+    isClientStable(client: ManagedClient): boolean;
+    canClientRunJob(client: ManagedClient, job: JobRecord): boolean;
+    claim(job: JobRecord, specificClientId?: string): ClientLease | null;
+    recordFailure(clientId: string, job: JobRecord, error: unknown): void;
+    /**
+     * Start periodic health check to keep connections alive and detect issues early.
+     * Pings idle clients by polling their queue status.
+     */
+    private startHealthCheck;
+    /**
+     * Perform health check on all clients.
+     * Polls queue status to keep WebSocket alive and detect connection issues.
+     * IMPORTANT: Pings ALL online clients (including busy ones) to prevent WebSocket timeout during heavy load.
+     */
+    private performHealthCheck;
+    /**
+     * Stop health check interval (called during shutdown).
+     */
+    stopHealthCheck(): void;
+    /**
+     * Cleanup resources when destroying the manager.
+     */
+    destroy(): void;
+}
+export {};
 //# sourceMappingURL=ClientManager.d.ts.map

package/dist/pool/index.d.ts

@@ -1,10 +1,10 @@
-export { WorkflowPool } from "./WorkflowPool.js";
-export type { WorkflowPoolOpts } from "./WorkflowPool.js";
-export type { WorkflowPoolEventMap } from "./types/events.js";
-export type { JobRecord, JobStatus, WorkflowJobOptions } from "./types/job.js";
-export type { QueueAdapter, QueueReservation, QueueStats } from "./queue/QueueAdapter.js";
-export { MemoryQueueAdapter } from "./queue/adapters/memory.js";
-export type { FailoverStrategy } from "./failover/Strategy.js";
-export { SmartFailoverStrategy } from "./failover/SmartFailoverStrategy.js";
-export type { JobProfileStats, NodeExecutionProfile } from "./profiling/JobProfiler.js";
+export { WorkflowPool } from "./WorkflowPool.js";
+export type { WorkflowPoolOpts } from "./WorkflowPool.js";
+export type { WorkflowPoolEventMap } from "./types/events.js";
+export type { JobRecord, JobStatus, WorkflowJobOptions } from "./types/job.js";
+export type { QueueAdapter, QueueReservation, QueueStats } from "./queue/QueueAdapter.js";
+export { MemoryQueueAdapter } from "./queue/adapters/memory.js";
+export type { FailoverStrategy } from "./failover/Strategy.js";
+export { SmartFailoverStrategy } from "./failover/SmartFailoverStrategy.js";
+export type { JobProfileStats, NodeExecutionProfile } from "./profiling/JobProfiler.js";
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comfyui-node",
-  "version": "1.6.6",
+  "version": "1.6.7",
   "description": "ComfyUI Node.js Client",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -74,4 +74,4 @@
     "typescript": "5.9.3",
     "type-coverage": "^2.29.7"
   }
-}
+}