run-workflow-http.ts

import * as fs from "fs";
import * as https from "https";
import FormData from "form-data";

// Types
interface WanAnimateInputs {
  positive_prompt: string;
  negative_prompt?: string;
  video_width?: number;
  video_height?: number;
  video_length_frames?: number;
  seed?: number;
  steps?: number;
  cfg_scale?: number;
}

// API Client
class ComfyUIApiClient {
  private hostname: string;
  private port: number;

  constructor(baseUrl: string) {
    const url = new URL(baseUrl);
    this.hostname = url.hostname;
    this.port = parseInt(url.port) || 443;
  }

  async uploadFile(fileBuffer: Buffer, filename: string): Promise<string> {
    return new Promise((resolve, reject) => {
      const form = new FormData();
      form.append("image", fileBuffer, {
        filename,
        contentType: "image/png",
      });

      console.log(`📤 Uploading ${filename}...`);

      const options = {
        hostname: this.hostname,
        port: this.port,
        path: "/upload/image",
        method: "POST",
        headers: form.getHeaders(),
      };

      const req = https.request(options, (res) => {
        let data = "";

        res.on("data", (chunk) => {
          data += chunk;
        });

        res.on("end", () => {
          if (res.statusCode === 200) {
            try {
              const result = JSON.parse(data);
              console.log(`✅ Uploaded: ${result.name || filename}`);
              resolve(result.name || filename);
            } catch (e) {
              console.log(`✅ Uploaded: ${filename}`);
              resolve(filename);
            }
          } else {
            reject(new Error(`Upload failed: ${res.statusCode} - ${data}`));
          }
        });
      });

      req.on("error", (error) => {
        reject(error);
      });

      form.pipe(req);
    });
  }

  async queueWorkflow(workflow: any): Promise<{ prompt_id: string }> {
    return new Promise((resolve, reject) => {
      console.log("📤 Sending workflow to queue...");

      const data = JSON.stringify({
        prompt: workflow,
        client_id: "test-client",
      });

      const options = {
        hostname: this.hostname,
        port: this.port,
        path: "/prompt",
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "Content-Length": Buffer.byteLength(data),
        },
      };

      const req = https.request(options, (res) => {
        let responseData = "";

        res.on("data", (chunk) => {
          responseData += chunk;
        });

        res.on("end", () => {
          if (res.statusCode === 200) {
            const result = JSON.parse(responseData);
            console.log(`📋 Queued: ${result.prompt_id}`);
            resolve(result);
          } else {
            reject(new Error(`Queue failed: ${res.statusCode} - ${responseData}`));
          }
        });
      });

      req.on("error", (error) => {
        reject(error);
      });

      req.write(data);
      req.end();
    });
  }

  async waitForCompletion(promptId: string): Promise<any> {
    let lastStatus = "";
    console.log("⏳ Waiting 5 seconds for job to initialize...");
    await new Promise((r) => setTimeout(r, 5000));

    while (true) {
      try {
        const response = await fetch(`https://${this.hostname}:${this.port}/history/${promptId}`);
        const history = await response.json();
        const job = history[promptId];

        if (!job) {
          console.log("⏳ Job not in history yet, waiting...");
          await new Promise((r) => setTimeout(r, 5000));
          continue;
        }

        const status = job.status.status_str;
        if (status !== lastStatus) {
          console.log(`⏳ Status: ${status}`);
          lastStatus = status;
        }

        if (job.status.completed) {
          console.log("✅ Job completed!");
          return job;
        }
        if (status === "error") {
          console.log("❌ Job error details:", JSON.stringify(job, null, 2));
          throw new Error("❌ Job failed");
        }

        await new Promise((r) => setTimeout(r, 3000));
      } catch (error) {
        console.log("⏳ Error checking status, retrying...", error);
        await new Promise((r) => setTimeout(r, 5000));
      }
    }
  }

  getOutputUrl(filename: string): string {
    return `https://${this.hostname}:${this.port}/view?filename=${encodeURIComponent(filename)}&type=output`;
  }
}

// Workflow Builder
class WanAnimateWorkflowBuilder {
  build(inputs: WanAnimateInputs, imageName: string, videoName: string): any {
    return {
      "311": {
        inputs: {
          image: imageName,
          upload: "image"
        },
        class_type: "LoadImage",
      },
      "417": {
        inputs: {
          video: videoName,
          force_rate: 16,
          frame_load_cap: inputs.video_length_frames || 176,
          format: "Wan",
        },
        class_type: "VHS_LoadVideo",
      },
      "224": {
        inputs: {
          clip_name: "umt5_xxl_fp8_e4m3fn_scaled.safetensors",
          type: "wan",
          device: "default",
        },
        class_type: "CLIPLoader",
      },
      "226": {
        inputs: {
          unet_name: "wan2.2_animate_14B_bf16.safetensors",
          weight_dtype: "default",
        },
        class_type: "UNETLoader",
      },
      "225": {
        inputs: { vae_name: "wan_2.1_vae.safetensors" },
        class_type: "VAELoader",
      },
      "317": {
        inputs: { clip_name: "clip_vision_h.safetensors" },
        class_type: "CLIPVisionLoader",
      },
      "227": {
        inputs: {
          text: inputs.positive_prompt,
          clip: ["224", 0],
        },
        class_type: "CLIPTextEncode",
      },
      "228": {
        inputs: {
          text: inputs.negative_prompt || "blurry, low quality, distorted",
          clip: ["224", 0],
        },
        class_type: "CLIPTextEncode",
      },
      "326": {
        inputs: {
          clip_vision: ["317", 0],
          image: ["311", 0],
          crop: "center",
        },
        class_type: "CLIPVisionEncode",
      },
      "370": {
        inputs: {
          positive: ["227", 0],
          negative: ["228", 0],
          vae: ["225", 0],
          clip_vision_output: ["326", 0],
          reference_image: ["311", 0],
          width: inputs.video_width || 1080,
          height: inputs.video_height || 1920,
          length: inputs.video_length_frames || 176,
          batch_size: 1,
          flicker_scale: 4097,
          video_frame_offset: 0,
          continue_motion_max_frames: inputs.video_length_frames || 176,
        },
        class_type: "WanAnimateToVideo",
      },
      "324": {
        inputs: {
          model: ["226", 0],
          positive: ["370", 0],
          negative: ["370", 1],
          latent_image: ["370", 2],
          seed: inputs.seed || Math.floor(Math.random() * 1e12),
          steps: inputs.steps || 20,
          cfg: inputs.cfg_scale || 4,
          sampler_name: "euler",
          scheduler: "simple",
          denoise: 1.0,
        },
        class_type: "KSampler",
      },
      "269": {
        inputs: {
          samples: ["324", 0],
          vae: ["225", 0],
        },
        class_type: "VAEDecode",
      },
      "462": {
        inputs: {
          images: ["269", 0],
          frame_rate: 16,
          filename_prefix: "WanComfy",
          format: "video/h264-mp4",
          crf: 19,
          loop_count: 0,
          pingpong: false,
          save_output: true,
        },
        class_type: "VHS_VideoCombine",
      },
    };
  }
}

// Main Test
async function run() {
  console.log("🚀 Starting Wan Animate Video Generation...");

  const client = new ComfyUIApiClient("https://zqyh42lvmsz2qy-8188.proxy.runpod.net");
  const builder = new WanAnimateWorkflowBuilder();

  console.log("📂 Uploading files to server...");

  try {
    // Upload files to server first
    const imageName = await client.uploadFile(fs.readFileSync("./myimage.png"), "myimage.png");
    const videoName = await client.uploadFile(fs.readFileSync("./myvideo.mp4"), "myvideo.mp4");

    console.log(`📁 Image ready: ${imageName}`);
    console.log(`📹 Video ready: ${videoName}`);

    const inputs: WanAnimateInputs = {
      positive_prompt: "photorealistic video of blond women wearing navy blue bikini",
      video_width: 1080,
      video_height: 1920,
      video_length_frames: 176, // 16 fps * 11 detik = 176 frames
      seed: 123456789,
      steps: 20,
    };

    console.log("📋 Building workflow...");
    const workflow = builder.build(inputs, imageName, videoName);

    console.log("📤 Queueing workflow...");
    const { prompt_id } = await client.queueWorkflow(workflow);
    console.log(`⏳ Processing job ${prompt_id}...`);

    const result = await client.waitForCompletion(prompt_id);

    const outputNode = result.outputs["462"];
    if (outputNode?.video?.[0]?.filename) {
      const videoUrl = client.getOutputUrl(outputNode.video[0].filename);
      console.log("\n✅ SUCCESS! Download your video:");
      console.log(videoUrl);
    } else if (outputNode?.gifs?.[0]?.filename) {
      const videoUrl = client.getOutputUrl(outputNode.gifs[0].filename);
      console.log("\n✅ SUCCESS! Download your video:");
      console.log(videoUrl);
    } else {
      console.log("❌ No video output found in result");
      console.log("Full result:", JSON.stringify(result, null, 2));
    }
  } catch (error) {
    console.error("❌ Error:", error);
  }
}

run();