@reaatech/media-pipeline-mcp-comfyui 0.3.0

package/dist/index.cjs

@@ -0,0 +1,662 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ComfyUIProvider: () => ComfyUIProvider,
+  createComfyUIProvider: () => createComfyUIProvider
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/comfyui-provider.ts
+var import_media_pipeline_mcp_core = require("@reaatech/media-pipeline-mcp-core");
+var import_media_pipeline_mcp_provider_core = require("@reaatech/media-pipeline-mcp-provider-core");
+
+// src/workflows/flux-text2img.json
+var flux_text2img_default = {
+  "3": {
+    class_type: "KSampler",
+    inputs: {
+      seed: -1,
+      steps: 20,
+      cfg: 1,
+      sampler_name: "euler",
+      scheduler: "simple",
+      denoise: 1,
+      model: ["4", 0],
+      positive: ["6", 0],
+      negative: ["7", 0],
+      latent_image: ["5", 0]
+    }
+  },
+  "4": {
+    class_type: "CheckpointLoaderSimple",
+    inputs: {
+      ckpt_name: "flux1-dev.safetensors"
+    }
+  },
+  "5": {
+    class_type: "EmptyLatentImage",
+    inputs: {
+      width: 1024,
+      height: 1024,
+      batch_size: 1
+    }
+  },
+  "6": {
+    class_type: "CLIPTextEncode",
+    inputs: {
+      text: "",
+      clip: ["4", 1]
+    }
+  },
+  "7": {
+    class_type: "CLIPTextEncode",
+    inputs: {
+      text: "",
+      clip: ["4", 1]
+    }
+  },
+  "8": {
+    class_type: "VAEDecode",
+    inputs: {
+      samples: ["3", 0],
+      vae: ["4", 2]
+    }
+  },
+  "9": {
+    class_type: "SaveImage",
+    inputs: {
+      filename_prefix: "ComfyUI",
+      images: ["8", 0]
+    }
+  }
+};
+
+// src/workflows/sdxl-img2img.json
+var sdxl_img2img_default = {
+  "3": {
+    class_type: "KSampler",
+    inputs: {
+      seed: -1,
+      steps: 20,
+      cfg: 7,
+      sampler_name: "euler",
+      scheduler: "normal",
+      denoise: 0.75,
+      model: ["4", 0],
+      positive: ["6", 0],
+      negative: ["7", 0],
+      latent_image: ["11", 0]
+    }
+  },
+  "4": {
+    class_type: "CheckpointLoaderSimple",
+    inputs: {
+      ckpt_name: "sd_xl_base_1.0.safetensors"
+    }
+  },
+  "6": {
+    class_type: "CLIPTextEncode",
+    inputs: {
+      text: "",
+      clip: ["4", 1]
+    }
+  },
+  "7": {
+    class_type: "CLIPTextEncode",
+    inputs: {
+      text: "",
+      clip: ["4", 1]
+    }
+  },
+  "8": {
+    class_type: "VAEDecode",
+    inputs: {
+      samples: ["3", 0],
+      vae: ["4", 2]
+    }
+  },
+  "9": {
+    class_type: "SaveImage",
+    inputs: {
+      filename_prefix: "ComfyUI",
+      images: ["8", 0]
+    }
+  },
+  "10": {
+    class_type: "LoadImage",
+    inputs: {
+      image: "input.png"
+    }
+  },
+  "11": {
+    class_type: "VAEEncode",
+    inputs: {
+      pixels: ["10", 0],
+      vae: ["4", 2]
+    }
+  }
+};
+
+// src/workflows/sdxl-text2img.json
+var sdxl_text2img_default = {
+  "3": {
+    class_type: "KSampler",
+    inputs: {
+      seed: -1,
+      steps: 20,
+      cfg: 7,
+      sampler_name: "euler",
+      scheduler: "normal",
+      denoise: 1,
+      model: ["4", 0],
+      positive: ["6", 0],
+      negative: ["7", 0],
+      latent_image: ["5", 0]
+    }
+  },
+  "4": {
+    class_type: "CheckpointLoaderSimple",
+    inputs: {
+      ckpt_name: "sd_xl_base_1.0.safetensors"
+    }
+  },
+  "5": {
+    class_type: "EmptyLatentImage",
+    inputs: {
+      width: 1024,
+      height: 1024,
+      batch_size: 1
+    }
+  },
+  "6": {
+    class_type: "CLIPTextEncode",
+    inputs: {
+      text: "",
+      clip: ["4", 1]
+    }
+  },
+  "7": {
+    class_type: "CLIPTextEncode",
+    inputs: {
+      text: "",
+      clip: ["4", 1]
+    }
+  },
+  "8": {
+    class_type: "VAEDecode",
+    inputs: {
+      samples: ["3", 0],
+      vae: ["4", 2]
+    }
+  },
+  "9": {
+    class_type: "SaveImage",
+    inputs: {
+      filename_prefix: "ComfyUI",
+      images: ["8", 0]
+    }
+  }
+};
+
+// src/workflows/svd-img2vid.json
+var svd_img2vid_default = {
+  "3": {
+    class_type: "KSampler",
+    inputs: {
+      seed: -1,
+      steps: 20,
+      cfg: 2.5,
+      sampler_name: "euler",
+      scheduler: "karras",
+      denoise: 1,
+      model: ["15", 0],
+      positive: ["12", 0],
+      negative: ["12", 1],
+      latent_image: ["12", 2]
+    }
+  },
+  "8": {
+    class_type: "VAEDecode",
+    inputs: {
+      samples: ["3", 0],
+      vae: ["15", 2]
+    }
+  },
+  "10": {
+    class_type: "LoadImage",
+    inputs: {
+      image: "input.png"
+    }
+  },
+  "12": {
+    class_type: "SVD_img2vid_Conditioning",
+    inputs: {
+      width: 1024,
+      height: 576,
+      video_frames: 14,
+      motion_bucket_id: 127,
+      fps: 6,
+      augmentation_level: 0,
+      clip_vision: ["15", 1],
+      init_image: ["10", 0],
+      vae: ["15", 2]
+    }
+  },
+  "15": {
+    class_type: "ImageOnlyCheckpointLoader",
+    inputs: {
+      ckpt_name: "svd_xt.safetensors"
+    }
+  },
+  "20": {
+    class_type: "SaveAnimatedWEBP",
+    inputs: {
+      filename_prefix: "SVD",
+      fps: 6,
+      lossless: false,
+      quality: 90,
+      method: "default",
+      images: ["8", 0]
+    }
+  }
+};
+
+// src/comfyui-provider.ts
+var BUILT_IN_WORKFLOWS = {
+  "sdxl-text2img": {
+    name: "SDXL Text-to-Image",
+    apiFormat: sdxl_text2img_default,
+    inputs: {
+      prompt: { path: "6.inputs.text", type: "string", required: true },
+      negative_prompt: { path: "7.inputs.text", type: "string", default: "" },
+      seed: { path: "3.inputs.seed", type: "number", default: -1 },
+      steps: { path: "3.inputs.steps", type: "number", default: 20 },
+      cfg: { path: "3.inputs.cfg", type: "number", default: 7 },
+      width: { path: "5.inputs.width", type: "number", default: 1024 },
+      height: { path: "5.inputs.height", type: "number", default: 1024 }
+    },
+    outputs: {
+      "9": "image"
+    }
+  },
+  "sdxl-img2img": {
+    name: "SDXL Image-to-Image",
+    apiFormat: sdxl_img2img_default,
+    inputs: {
+      prompt: { path: "6.inputs.text", type: "string", required: true },
+      negative_prompt: { path: "7.inputs.text", type: "string", default: "" },
+      seed: { path: "3.inputs.seed", type: "number", default: -1 },
+      steps: { path: "3.inputs.steps", type: "number", default: 20 },
+      cfg: { path: "3.inputs.cfg", type: "number", default: 7 },
+      denoise: { path: "3.inputs.denoise", type: "number", default: 0.75 },
+      image: { path: "10.inputs.image", type: "string", required: true }
+    },
+    outputs: {
+      "9": "image"
+    }
+  },
+  "flux-text2img": {
+    name: "Flux.1-dev Text-to-Image",
+    apiFormat: flux_text2img_default,
+    inputs: {
+      prompt: { path: "6.inputs.text", type: "string", required: true },
+      negative_prompt: { path: "7.inputs.text", type: "string", default: "" },
+      seed: { path: "3.inputs.seed", type: "number", default: -1 },
+      steps: { path: "3.inputs.steps", type: "number", default: 20 },
+      cfg: { path: "3.inputs.cfg", type: "number", default: 1 },
+      width: { path: "5.inputs.width", type: "number", default: 1024 },
+      height: { path: "5.inputs.height", type: "number", default: 1024 }
+    },
+    outputs: {
+      "9": "image"
+    }
+  },
+  "svd-img2vid": {
+    name: "Stable Video Diffusion Image-to-Video",
+    apiFormat: svd_img2vid_default,
+    inputs: {
+      image: { path: "10.inputs.image", type: "string", required: true },
+      seed: { path: "3.inputs.seed", type: "number", default: -1 },
+      steps: { path: "3.inputs.steps", type: "number", default: 20 },
+      cfg: { path: "3.inputs.cfg", type: "number", default: 2.5 },
+      width: { path: "12.inputs.width", type: "number", default: 1024 },
+      height: { path: "12.inputs.height", type: "number", default: 576 },
+      video_frames: { path: "12.inputs.video_frames", type: "number", default: 14 },
+      motion_bucket_id: { path: "12.inputs.motion_bucket_id", type: "number", default: 127 },
+      fps: { path: "12.inputs.fps", type: "number", default: 6 }
+    },
+    outputs: {
+      "20": "video"
+    }
+  }
+};
+var ComfyUIProvider = class extends import_media_pipeline_mcp_provider_core.MediaProvider {
+  static id = "comfyui";
+  name = "comfyui";
+  supportedOperations = ["image.generate", "image.edit", "video.generate"];
+  /**
+   * §0.6 capability declarations. ComfyUI exposes per-node progress as it executes a
+   * workflow (we surface it via the F6 progress bridge during pollForCompletion), but
+   * does not push outbound webhooks.
+   */
+  supportsStreaming = /* @__PURE__ */ new Set(["image.generate", "image.edit", "video.generate"]);
+  supportsWebhooks = false;
+  /**
+   * F2 cacheConfig per plan §F10 "Per-implementation features":
+   *   "det per fixed `seed`; cache enabled when seed is provided and non-negative"
+   *
+   * All workflow inputs are deterministic given a fixed seed. The non-det list is
+   * empty because there is no provider-side request id (ComfyUI's `prompt_id` is
+   * generated post-submit and is not user-supplied). Normalize trims string params.
+   */
+  static cacheConfig = {
+    deterministicParams: [
+      "prompt",
+      "negative_prompt",
+      "seed",
+      "steps",
+      "cfg",
+      "denoise",
+      "width",
+      "height",
+      "image",
+      "model",
+      "sampler",
+      "scheduler",
+      "video_frames",
+      "motion_bucket_id",
+      "fps",
+      "dimensions"
+    ],
+    nonDeterministicParams: [],
+    normalize: (inputs) => {
+      const out = {};
+      for (const [k, v] of Object.entries(inputs)) {
+        out[k] = typeof v === "string" ? v.trim().replace(/\s+/g, " ") : v;
+      }
+      return out;
+    }
+  };
+  baseUrl;
+  pollIntervalMs;
+  retentionMs;
+  downloadOutputs;
+  workflows;
+  workflowsDir;
+  workflowsDirLoaded = false;
+  constructor(config = {}) {
+    super();
+    this.baseUrl = config.baseUrl ?? "http://localhost:8188";
+    this.pollIntervalMs = config.pollIntervalMs ?? 1e3;
+    this.retentionMs = config.retentionMs ?? 6e5;
+    this.downloadOutputs = config.downloadOutputs ?? true;
+    this.workflows = { ...BUILT_IN_WORKFLOWS };
+    this.workflowsDir = config.workflowsDir;
+  }
+  /**
+   * Plan §F10 "Mechanism (ComfyUI) #1": load user workflows from `workflowsDir/*.json`
+   * at construction time. We do it lazily (first execute / explicit call) so that the
+   * constructor stays sync and tests can mock fs.
+   *
+   * Each file becomes `custom/<basename>` workflow. The JSON must declare `apiFormat`,
+   * `inputs`, and `outputs` keys (the ComfyUIWorkflow shape). Files that don't match
+   * the shape are skipped with a warning.
+   */
+  async loadWorkflowsFromDir() {
+    if (this.workflowsDirLoaded || !this.workflowsDir) return;
+    this.workflowsDirLoaded = true;
+    try {
+      const fs = await import("fs/promises");
+      const path = await import("path");
+      const entries = await fs.readdir(this.workflowsDir);
+      for (const entry of entries) {
+        if (!entry.endsWith(".json")) continue;
+        const full = path.join(this.workflowsDir, entry);
+        try {
+          const raw = await fs.readFile(full, "utf8");
+          const parsed = JSON.parse(raw);
+          if (typeof parsed.apiFormat !== "object" || typeof parsed.inputs !== "object") {
+            console.warn(`ComfyUI: skipping workflow ${entry} \u2014 missing apiFormat/inputs`);
+            continue;
+          }
+          const slug = `custom/${path.basename(entry, ".json")}`;
+          this.workflows[slug] = parsed;
+        } catch (err) {
+          console.warn(`ComfyUI: failed to load workflow ${entry}: ${err.message}`);
+        }
+      }
+    } catch (err) {
+      console.warn(
+        `ComfyUI: workflowsDir '${this.workflowsDir}' unreadable: ${err.message}`
+      );
+    }
+  }
+  async healthCheck() {
+    const startTime = Date.now();
+    try {
+      const response = await fetch(`${this.baseUrl}/system_stats`, {
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (response.ok) {
+        return {
+          healthy: true,
+          latency: Date.now() - startTime
+        };
+      }
+      return {
+        healthy: false,
+        latency: Date.now() - startTime,
+        error: `HTTP ${response.status}: ${response.statusText}`
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        latency: Date.now() - startTime,
+        error: error.message
+      };
+    }
+  }
+  async estimateCost(_input) {
+    return {
+      costUsd: 0,
+      currency: "USD"
+    };
+  }
+  registerWorkflow(name, workflow) {
+    this.workflows[name] = workflow;
+  }
+  getWorkflow(name) {
+    return this.workflows[name];
+  }
+  listWorkflows() {
+    return Object.keys(this.workflows);
+  }
+  async execute(input) {
+    await this.loadWorkflowsFromDir();
+    const explicit = this.resolveWorkflowName(input);
+    if (explicit) {
+      return this.runWorkflow(explicit, input);
+    }
+    switch (input.operation) {
+      case "image.generate":
+        return this.runWorkflow("sdxl-text2img", input);
+      case "image.edit":
+        return this.runWorkflow("sdxl-img2img", input);
+      case "video.generate":
+        return this.runWorkflow("svd-img2vid", input);
+      default:
+        throw new Error(`Unsupported operation: ${input.operation}`);
+    }
+  }
+  resolveWorkflowName(input) {
+    const model = input.params?.model ?? input.model;
+    if (!model) return null;
+    if (!model.startsWith("workflow:")) return null;
+    return model.slice("workflow:".length);
+  }
+  async runWorkflow(workflowName, input) {
+    const startTime = Date.now();
+    const workflow = this.workflows[workflowName];
+    if (!workflow) {
+      throw new import_media_pipeline_mcp_core.WorkflowNotFoundError(workflowName);
+    }
+    const prompt = structuredClone(workflow.apiFormat);
+    for (const [paramName, spec] of Object.entries(workflow.inputs)) {
+      const value = input.params[paramName] ?? spec.default;
+      if (value === void 0 && spec.required) {
+        throw new import_media_pipeline_mcp_core.InvalidInputError(`Missing required input: ${paramName}`);
+      }
+      if (value !== void 0) {
+        this.setNestedValue(prompt, spec.path, value);
+      }
+    }
+    const dims = input.params.dimensions;
+    if (dims) {
+      const parts = dims.split("x").map(Number);
+      if (parts.length === 2 && !Number.isNaN(parts[0]) && !Number.isNaN(parts[1])) {
+        this.setNestedValue(prompt, "5.inputs.width", parts[0]);
+        this.setNestedValue(prompt, "5.inputs.height", parts[1]);
+      }
+    }
+    const response = await fetch(`${this.baseUrl}/prompt`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ prompt })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`ComfyUI error: ${errorText}`);
+    }
+    const promptResult = await response.json();
+    const promptId = promptResult.prompt_id;
+    const outputs = await this.pollForCompletion(promptId);
+    if (this.downloadOutputs && Object.keys(outputs).length > 0) {
+      const firstOutput = Object.values(outputs)[0];
+      if (firstOutput.images && firstOutput.images.length > 0) {
+        const img = firstOutput.images[0];
+        const imageUrl = `${this.baseUrl}/view?filename=${img.filename}&subfolder=${img.subfolder}&type=${img.type}`;
+        const imageResponse = await fetch(imageUrl);
+        if (!imageResponse.ok) {
+          throw new Error(`Failed to download output image: ${imageResponse.statusText}`);
+        }
+        const arrayBuffer = await imageResponse.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        return {
+          data: buffer,
+          mimeType: this.mimeTypeFromFilename(img.filename),
+          metadata: {
+            type: "image",
+            prompt_id: promptId,
+            workflow: workflowName,
+            filename: img.filename
+          },
+          costUsd: 0,
+          durationMs: Date.now() - startTime
+        };
+      }
+    }
+    throw new Error("No output images produced by workflow");
+  }
+  async pollForCompletion(promptId) {
+    const deadline = Date.now() + this.retentionMs;
+    while (Date.now() < deadline) {
+      await this.sleep(this.pollIntervalMs);
+      try {
+        const response = await fetch(`${this.baseUrl}/history/${promptId}`, {
+          signal: AbortSignal.timeout(1e4)
+        });
+        if (response.status === 404) {
+          continue;
+        }
+        if (!response.ok) {
+          continue;
+        }
+        const history = await response.json();
+        const entry = history[promptId];
+        if (entry?.status.completed) {
+          return entry.outputs;
+        }
+        if (entry && entry.status.status_str === "error") {
+          throw new Error("ComfyUI workflow execution failed");
+        }
+      } catch {
+      }
+    }
+    throw new import_media_pipeline_mcp_core.WorkflowExpiredError();
+  }
+  setNestedValue(obj, path, value) {
+    const keys = path.split(".");
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!(key in current)) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    if (lastKey === "width" || lastKey === "height") {
+      current[lastKey] = typeof value === "string" ? Number(value) : value;
+    } else {
+      current[lastKey] = value;
+    }
+  }
+  mimeTypeFromFilename(filename) {
+    const ext = filename.split(".").pop()?.toLowerCase();
+    switch (ext) {
+      case "png":
+        return "image/png";
+      case "jpg":
+      case "jpeg":
+        return "image/jpeg";
+      case "webp":
+        return "image/webp";
+      case "mp4":
+        return "video/mp4";
+      case "webm":
+        return "video/webm";
+      default:
+        return "application/octet-stream";
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+function createComfyUIProvider(config) {
+  return new ComfyUIProvider(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ComfyUIProvider,
+  createComfyUIProvider
+});