@mindstudio-ai/local-model-tunnel 0.2.0 → 0.3.0

package/dist/chunk-PTK4SJQK.js

@@ -0,0 +1,1768 @@
+// src/config.ts
+import Conf from "conf";
+import os from "os";
+import path from "path";
+var config = new Conf({
+  projectName: "mindstudio-local",
+  cwd: path.join(os.homedir(), ".mindstudio-local-tunnel"),
+  configName: "config",
+  defaults: {
+    environment: "prod",
+    providerBaseUrls: {},
+    providerInstallPaths: {},
+    environments: {
+      prod: {
+        apiBaseUrl: "https://api.mindstudio.ai"
+      },
+      local: {
+        apiBaseUrl: "http://localhost:3129"
+      }
+    }
+  }
+});
+function getEnvironment() {
+  return config.get("environment");
+}
+function getEnvConfig() {
+  const env = getEnvironment();
+  return config.get(`environments.${env}`);
+}
+function setEnvConfig(key, value) {
+  const env = getEnvironment();
+  config.set(`environments.${env}.${key}`, value);
+}
+function getApiKey() {
+  return getEnvConfig().apiKey;
+}
+function setApiKey(key) {
+  setEnvConfig("apiKey", key);
+}
+function getApiBaseUrl() {
+  return getEnvConfig().apiBaseUrl;
+}
+function getConfigPath() {
+  return config.path;
+}
+function getProviderBaseUrl(name, defaultUrl) {
+  const urls = config.get("providerBaseUrls");
+  return urls[name] ?? defaultUrl;
+}
+function getProviderInstallPath(name) {
+  const paths = config.get("providerInstallPaths");
+  return paths[name];
+}
+
+// src/api.ts
+function getHeaders() {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error("Not authenticated. Run: mindstudio-local auth");
+  }
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+}
+async function pollForRequest(models) {
+  const baseUrl = getApiBaseUrl();
+  const modelsParam = models.join(",");
+  const response = await fetch(
+    `${baseUrl}/v1/local-models/poll?models=${encodeURIComponent(modelsParam)}`,
+    {
+      method: "GET",
+      headers: getHeaders()
+    }
+  );
+  if (response.status === 204) {
+    return null;
+  }
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Poll failed: ${response.status} ${error}`);
+  }
+  const data = await response.json();
+  return data.request;
+}
+async function submitProgress(requestId, content) {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(
+    `${baseUrl}/v1/local-models/requests/${requestId}/progress`,
+    {
+      method: "POST",
+      headers: getHeaders(),
+      body: JSON.stringify({ content })
+    }
+  );
+  if (!response.ok) {
+    console.warn(`Progress update failed: ${response.status}`);
+  }
+}
+async function submitGenerationProgress(requestId, step, totalSteps, preview) {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(
+    `${baseUrl}/v1/local-models/requests/${requestId}/progress`,
+    {
+      method: "POST",
+      headers: getHeaders(),
+      body: JSON.stringify({
+        type: "generation",
+        step,
+        totalSteps,
+        preview
+      })
+    }
+  );
+  if (!response.ok) {
+    console.warn(`Generation progress update failed: ${response.status}`);
+  }
+}
+async function submitResult(requestId, success, result, error) {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(
+    `${baseUrl}/v1/local-models/requests/${requestId}/result`,
+    {
+      method: "POST",
+      headers: getHeaders(),
+      body: JSON.stringify({ success, result, error })
+    }
+  );
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Result submission failed: ${response.status} ${errorText}`
+    );
+  }
+}
+async function verifyApiKey() {
+  const baseUrl = getApiBaseUrl();
+  try {
+    const response = await fetch(`${baseUrl}/v1/local-models/verify-api-key`, {
+      method: "GET",
+      headers: getHeaders()
+    });
+    return response.status === 204 || response.ok;
+  } catch {
+    return false;
+  }
+}
+async function registerLocalModel(modelNameOrOptions, provider = "ollama", modelType = "llm_chat") {
+  const baseUrl = getApiBaseUrl();
+  let payload;
+  if (typeof modelNameOrOptions === "string") {
+    payload = {
+      modelName: modelNameOrOptions,
+      provider,
+      modelType
+    };
+  } else {
+    payload = {
+      modelName: modelNameOrOptions.modelName,
+      provider: modelNameOrOptions.provider,
+      modelType: modelNameOrOptions.modelType || "llm_chat",
+      parameters: modelNameOrOptions.parameters
+    };
+  }
+  const response = await fetch(`${baseUrl}/v1/local-models/models/create`, {
+    method: "POST",
+    headers: getHeaders(),
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Register failed: ${response.status} ${errorText}`);
+  }
+}
+async function getRegisteredModels() {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(`${baseUrl}/v1/local-models/models`, {
+    method: "GET",
+    headers: getHeaders()
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to fetch registered models: ${response.status} ${errorText}`
+    );
+  }
+  const data = await response.json();
+  return data.models;
+}
+async function requestDeviceAuth() {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(`${baseUrl}/developer/v2/request-auth-url`, {
+    method: "GET",
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Device auth request failed: ${response.status} ${error}`);
+  }
+  const data = await response.json();
+  return data;
+}
+async function pollDeviceAuth(token) {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(`${baseUrl}/developer/v2/poll-auth-url`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ token })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Device auth poll failed: ${response.status} ${error}`);
+  }
+  const data = await response.json();
+  return data;
+}
+async function disconnectHeartbeat() {
+  const baseUrl = getApiBaseUrl();
+  const response = await fetch(`${baseUrl}/v1/local-models/disconnect`, {
+    method: "POST",
+    headers: getHeaders()
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Heartbeat disconnect failed: ${response.status} ${error}`);
+  }
+}
+
+// src/providers/ollama/index.ts
+import { Ollama } from "ollama";
+
+// src/providers/utils.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function commandExists(command) {
+  try {
+    const checkCmd = process.platform === "win32" ? "where" : "which";
+    await execAsync(`${checkCmd} ${command}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/providers/ollama/readme.md
+var readme_default = '# Ollama\n\nOllama lets you run text generation models (Llama, Mistral, Gemma, etc.) locally. Once it\'s running with at least one model downloaded, MindStudio will detect it automatically.\n\n**Default port:** 11434\n**Website:** https://ollama.com\n**GitHub:** https://github.com/ollama/ollama\n\n## Step 1: Install Ollama\n\n### macOS / Linux\n\nOpen a terminal and paste this command:\n\n```\ncurl -fsSL https://ollama.com/install.sh | sh\n```\n\n### macOS (alternative)\n\nDownload the app from https://ollama.com/download, open the file, and drag it into your Applications folder.\n\n### Windows\n\nDownload the installer from https://ollama.com/download and run it. Follow the on-screen instructions.\n\n## Step 2: Start the Server\n\nOpen a terminal and run:\n\n```\nollama serve\n```\n\nLeave this terminal window open -- the server needs to keep running for MindStudio to connect to it.\n\n**macOS tip:** If you installed Ollama as a desktop app, the server starts automatically when you open it. Look for the Ollama icon in your menu bar -- if it\'s there, you can skip this step.\n\n## Step 3: Download a Model\n\nOpen a **new** terminal window (keep the server running in the other one) and download a model:\n\n```\nollama pull llama3.2\n```\n\nSome good models to start with:\n\n- **llama3.2** -- fast, great all-around model (2 GB download)\n- **mistral** -- efficient for most tasks (4 GB)\n- **gemma2** -- Google\'s open model (5 GB)\n\nBrowse more models at https://ollama.com/library\n\nOnce the download finishes, go back to the MindStudio tunnel and select **Refresh Providers**. Your models should appear.\n\n## Troubleshooting\n\n- **MindStudio says Ollama is "not running"** -- Make sure `ollama serve` is running in a terminal window. You should see "Listening on 127.0.0.1:11434" in the output.\n\n- **Ollama is running but no models show up** -- You need to download at least one model first. Run `ollama pull llama3.2` in a separate terminal window.\n\n- **"address already in use"** -- Ollama is probably already running. On macOS, check for the Ollama icon in your menu bar. On Linux, run `pkill ollama` and try `ollama serve` again.\n\n- **"out of memory" errors** -- Your machine doesn\'t have enough RAM for that model. Try a smaller one like `llama3.2` (2 GB).\n';
+
+// src/providers/ollama/index.ts
+var OllamaProvider = class {
+  name = "ollama";
+  displayName = "Ollama";
+  description = "Run open-source LLMs locally via CLI. Supports Llama, Mistral, Gemma, and more.";
+  capabilities = ["text"];
+  readme = readme_default;
+  defaultBaseUrl = "http://localhost:11434";
+  get baseUrl() {
+    return getProviderBaseUrl(this.name, this.defaultBaseUrl);
+  }
+  createClient() {
+    return new Ollama({ host: this.baseUrl });
+  }
+  async isRunning() {
+    try {
+      const client = this.createClient();
+      await client.list();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async discoverModels() {
+    try {
+      const client = this.createClient();
+      const response = await client.list();
+      return response.models.map((m) => ({
+        name: m.name,
+        provider: this.name,
+        capability: "text",
+        size: m.size,
+        parameterSize: m.details?.parameter_size,
+        quantization: m.details?.quantization_level
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async detect() {
+    const installed = await commandExists("ollama");
+    let running = false;
+    if (installed) {
+      running = await this.isRunning();
+    }
+    return { installed, running };
+  }
+  async *chat(model, messages, options) {
+    const client = this.createClient();
+    const stream = await client.chat({
+      model,
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      stream: true,
+      options: {
+        temperature: options?.temperature,
+        num_predict: options?.maxTokens
+      }
+    });
+    for await (const chunk of stream) {
+      yield {
+        content: chunk.message.content,
+        done: chunk.done
+      };
+    }
+  }
+};
+var ollama_default = new OllamaProvider();
+
+// src/providers/lmstudio/index.ts
+import * as fs from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+
+// src/providers/lmstudio/readme.md
+var readme_default2 = '# LM Studio\n\nLM Studio is a desktop app for running text generation models locally. No terminal needed -- everything is done through the app. Once its server is running, MindStudio will detect it automatically.\n\n**Default port:** 1234\n**Website:** https://lmstudio.ai\n**GitHub:** https://github.com/lmstudio-ai\n\n## Step 1: Install LM Studio\n\n1. Go to https://lmstudio.ai\n2. Click the download button for your operating system\n3. Open the downloaded file and install it like any other app\n\n## Step 2: Download a Model\n\n1. Open LM Studio\n2. Click the **Discover** tab on the left sidebar\n3. Search for a model (see suggestions below)\n4. Click the download button next to the model you want\n5. Wait for the download to finish\n\nGood starter models:\n\n- **Llama 3.2** -- great all-around model, fast\n- **Mistral** -- efficient and capable\n- **Phi-3** -- compact, runs well on most machines\n\n## Step 3: Start the Server\n\nThis is the key step -- LM Studio needs to be running its local server for MindStudio to connect.\n\n1. In LM Studio, click the **Developer** tab on the left sidebar\n2. Select a model from the dropdown at the top if one isn\'t already loaded\n3. Click **Start Server**\n\nYou should see a green indicator showing the server is running on `http://localhost:1234`.\n\n**Important:** Just opening LM Studio is not enough. You must start the server from the Developer tab.\n\nLeave LM Studio open with the server running while you use MindStudio. Go back to the tunnel and select **Refresh Providers** -- your models should appear.\n\n## Troubleshooting\n\n- **MindStudio says LM Studio is "not running"** -- Make sure you started the server in the Developer tab. The green indicator should be visible.\n\n- **Server is running but no models show up** -- You need to load a model in the Developer tab. Select one from the dropdown at the top of the Developer tab before starting the server.\n\n- **Port conflict** -- If something else is using port 1234, you can change the port in the Developer tab settings.\n';
+
+// src/providers/lmstudio/index.ts
+var LMStudioProvider = class {
+  name = "lmstudio";
+  displayName = "LM Studio";
+  description = "Desktop app for running LLMs locally with a visual interface. No terminal required.";
+  capabilities = ["text"];
+  readme = readme_default2;
+  defaultBaseUrl = "http://localhost:1234/v1";
+  get baseUrl() {
+    return getProviderBaseUrl(this.name, this.defaultBaseUrl);
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  async isRunning() {
+    try {
+      const response = await fetch(`${this.getBaseUrl()}/models`, {
+        method: "GET",
+        signal: AbortSignal.timeout(3e3)
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async discoverModels() {
+    try {
+      const response = await fetch(`${this.getBaseUrl()}/models`);
+      if (!response.ok) {
+        return [];
+      }
+      const data = await response.json();
+      return data.data.map((m) => ({
+        name: m.id,
+        provider: this.name,
+        capability: "text"
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async detect() {
+    let installed = false;
+    const possiblePaths = {
+      darwin: ["/Applications/LM Studio.app"],
+      linux: [
+        path2.join(os2.homedir(), ".local/share/LM Studio"),
+        "/opt/lm-studio"
+      ],
+      win32: [
+        path2.join(process.env.LOCALAPPDATA || "", "LM Studio"),
+        path2.join(process.env.PROGRAMFILES || "", "LM Studio")
+      ]
+    };
+    const paths = possiblePaths[process.platform] || [];
+    for (const p of paths) {
+      if (fs.existsSync(p)) {
+        installed = true;
+        break;
+      }
+    }
+    let running = false;
+    try {
+      const response = await fetch("http://localhost:1234/v1/models", {
+        signal: AbortSignal.timeout(1e3)
+      });
+      running = response.ok;
+      if (running) installed = true;
+    } catch {
+      running = false;
+    }
+    return { installed, running };
+  }
+  async *chat(model, messages, options) {
+    const response = await fetch(`${this.getBaseUrl()}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model,
+        messages: messages.map((m) => ({
+          role: m.role,
+          content: m.content
+        })),
+        stream: true,
+        temperature: options?.temperature,
+        max_tokens: options?.maxTokens
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`LM Studio request failed: ${response.status} ${error}`);
+    }
+    if (!response.body) {
+      throw new Error("No response body from LM Studio");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          yield { content: "", done: true };
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith("data: ")) {
+            continue;
+          }
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") {
+            yield { content: "", done: true };
+            return;
+          }
+          try {
+            const parsed = JSON.parse(data);
+            const choice = parsed.choices[0];
+            const content = choice?.delta?.content || "";
+            const isDone = choice?.finish_reason !== null;
+            if (content) {
+              yield { content, done: isDone };
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+var lmstudio_default = new LMStudioProvider();
+
+// src/providers/stable-diffusion/index.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+import * as os3 from "os";
+
+// src/providers/stable-diffusion/readme.md
+var readme_default3 = '# Stable Diffusion WebUI\n\nAUTOMATIC1111\'s Stable Diffusion WebUI runs image generation models locally. Once the server is running with at least one model, MindStudio will detect it automatically.\n\n**Default port:** 7860\n**GitHub:** https://github.com/AUTOMATIC1111/stable-diffusion-webui\n\n## What You\'ll Need\n\n- **Python 3.10 or newer** -- Check by opening a terminal and typing `python3 --version`. If you don\'t have it, download from https://www.python.org/downloads/\n\n- **Git** -- Check by typing `git --version`. If you don\'t have it, download from https://git-scm.com/downloads\n\n## Step 1: Install the WebUI\n\nOpen a terminal and paste this command:\n\n```\ngit clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git ~/stable-diffusion-webui\n```\n\n**Windows users**, use this instead:\n\n```\ngit clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git %USERPROFILE%\\stable-diffusion-webui\n```\n\n## Step 2: Download a Model\n\nYou need at least one model file for MindStudio to use. Model files have the `.safetensors` extension (typically 2-7 GB).\n\n1. Browse models at https://civitai.com or https://huggingface.co\n2. Download a `.safetensors` checkpoint file\n3. Move the file into this folder:\n\n```\n~/stable-diffusion-webui/models/Stable-diffusion/\n```\n\nGood starter models:\n\n- **Stable Diffusion XL (SDXL)** -- high quality, 1024x1024\n- **Stable Diffusion 1.5** -- fast, widely supported\n\n## Step 3: Start the Server\n\nOpen a terminal and run:\n\n```\ncd ~/stable-diffusion-webui && ./webui.sh --api\n```\n\n**Windows users:**\n\n```\ncd %USERPROFILE%\\stable-diffusion-webui && webui-user.bat --api\n```\n\nThe first time you run this it will take several minutes to install dependencies. This is normal -- let it finish.\n\n**Important:** The `--api` flag is required. Without it, MindStudio cannot send requests to the server.\n\nLeave this terminal window open while using MindStudio. Once the server is ready, go back to the tunnel and select **Refresh Providers** -- your models should appear.\n\n## Troubleshooting\n\n- **MindStudio says WebUI is "not running"** -- Make sure you included `--api` when launching. The terminal should show the server at `http://127.0.0.1:7860`.\n\n- **Server is running but no models show up** -- Make sure your `.safetensors` file is directly in the `models/Stable-diffusion/` folder, not inside a subfolder. Restart the server after adding new model files.\n\n- **"Python not found"** -- Python 3.10+ is required. Download from https://www.python.org/downloads/. On Windows, check "Add Python to PATH" during installation.\n\n- **Errors during first launch** -- Delete the `venv` folder inside `stable-diffusion-webui` and run the launch command again to reinstall dependencies from scratch.\n\n- **"CUDA out of memory"** -- Your GPU doesn\'t have enough memory. Add `--medvram` or `--lowvram` to the launch command: `./webui.sh --api --medvram`\n';
+
+// src/providers/stable-diffusion/index.ts
+var StableDiffusionProvider = class {
+  name = "stable-diffusion";
+  displayName = "Stable Diffusion WebUI";
+  description = "Generate images locally using Stable Diffusion checkpoints. Runs as a local web UI.";
+  capabilities = ["image"];
+  readme = readme_default3;
+  defaultBaseUrl = "http://127.0.0.1:7860";
+  get baseUrl() {
+    return getProviderBaseUrl(this.name, this.defaultBaseUrl);
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  async isRunning() {
+    try {
+      const response = await fetch(`${this.getBaseUrl()}/sdapi/v1/sd-models`, {
+        method: "GET",
+        signal: AbortSignal.timeout(5e3)
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async discoverModels() {
+    try {
+      const response = await fetch(`${this.getBaseUrl()}/sdapi/v1/sd-models`);
+      if (!response.ok) {
+        return [];
+      }
+      const models = await response.json();
+      return models.map((m) => ({
+        name: m.model_name,
+        provider: this.name,
+        capability: "image"
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async detect() {
+    const savedPath = getProviderInstallPath(this.name);
+    const possiblePaths = [
+      ...savedPath ? [savedPath] : [],
+      path3.join(os3.homedir(), "stable-diffusion-webui"),
+      path3.join(os3.homedir(), "Projects", "stable-diffusion-webui"),
+      path3.join(os3.homedir(), "Code", "stable-diffusion-webui")
+    ];
+    let installed = false;
+    for (const p of possiblePaths) {
+      if (fs2.existsSync(path3.join(p, "launch.py")) || fs2.existsSync(path3.join(p, "webui.sh")) || fs2.existsSync(path3.join(p, "webui.bat"))) {
+        installed = true;
+        break;
+      }
+    }
+    let running = false;
+    try {
+      const response = await fetch("http://127.0.0.1:7860/sdapi/v1/sd-models", {
+        signal: AbortSignal.timeout(1e3)
+      });
+      running = response.ok;
+      if (running) installed = true;
+    } catch {
+      running = false;
+    }
+    return { installed, running };
+  }
+  /**
+   * Get the currently loaded model
+   */
+  async getCurrentModel() {
+    try {
+      const response = await fetch(`${this.getBaseUrl()}/sdapi/v1/options`);
+      if (!response.ok) return null;
+      const options = await response.json();
+      return options.sd_model_checkpoint || null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Switch to a different model
+   */
+  async setModel(modelName) {
+    const response = await fetch(`${this.getBaseUrl()}/sdapi/v1/options`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sd_model_checkpoint: modelName })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to switch model: ${error}`);
+    }
+  }
+  async generateImage(model, prompt, options) {
+    const currentModel = await this.getCurrentModel();
+    if (currentModel && !currentModel.includes(model)) {
+      await this.setModel(model);
+    }
+    const payload = {
+      prompt,
+      negative_prompt: options?.negativePrompt || "",
+      steps: options?.steps || 20,
+      width: options?.width || 512,
+      height: options?.height || 512,
+      cfg_scale: options?.cfgScale || 7,
+      seed: options?.seed ?? -1,
+      sampler_name: options?.sampler || "Euler a"
+    };
+    const response = await fetch(`${this.getBaseUrl()}/sdapi/v1/txt2img`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Image generation failed: ${response.status} ${error}`);
+    }
+    const result = await response.json();
+    if (!result.images || result.images.length === 0) {
+      throw new Error("No images returned from Stable Diffusion");
+    }
+    let info = {};
+    let seed;
+    try {
+      info = JSON.parse(result.info);
+      seed = typeof info.seed === "number" ? info.seed : void 0;
+    } catch {
+    }
+    return {
+      imageBase64: result.images[0],
+      mimeType: "image/png",
+      seed,
+      info
+    };
+  }
+  async generateImageWithProgress(model, prompt, options, onProgress) {
+    const generatePromise = this.generateImage(model, prompt, options);
+    if (onProgress) {
+      const pollProgress = async () => {
+        while (true) {
+          try {
+            const response = await fetch(
+              `${this.getBaseUrl()}/sdapi/v1/progress`
+            );
+            if (!response.ok) break;
+            const progress = await response.json();
+            onProgress({
+              step: progress.state.sampling_step,
+              totalSteps: progress.state.sampling_steps,
+              preview: progress.current_image
+            });
+            if (progress.progress >= 1) break;
+            await new Promise((resolve) => setTimeout(resolve, 500));
+          } catch {
+            break;
+          }
+        }
+      };
+      pollProgress().catch(() => {
+      });
+    }
+    return generatePromise;
+  }
+  /**
+   * Fetch available samplers from the backend
+   */
+  async getSamplers() {
+    try {
+      const response = await fetch(`${this.getBaseUrl()}/sdapi/v1/samplers`);
+      if (!response.ok) return this.getDefaultSamplers();
+      const samplers = await response.json();
+      return samplers.map((s) => s.name);
+    } catch {
+      return this.getDefaultSamplers();
+    }
+  }
+  getDefaultSamplers() {
+    return [
+      "Euler a",
+      "Euler",
+      "LMS",
+      "Heun",
+      "DPM2",
+      "DPM2 a",
+      "DPM++ 2S a",
+      "DPM++ 2M",
+      "DPM++ SDE",
+      "DPM fast",
+      "DPM adaptive",
+      "LMS Karras",
+      "DPM2 Karras",
+      "DPM2 a Karras",
+      "DPM++ 2S a Karras",
+      "DPM++ 2M Karras",
+      "DPM++ SDE Karras",
+      "DDIM",
+      "PLMS",
+      "UniPC"
+    ];
+  }
+  generateDimensionOptions() {
+    const options = [];
+    for (let size = 256; size <= 2048; size += 64) {
+      options.push({
+        label: `${size}px`,
+        value: String(size)
+      });
+    }
+    return options;
+  }
+  async getParameterSchemas() {
+    const samplers = await this.getSamplers();
+    const dimensionOptions = this.generateDimensionOptions();
+    return [
+      {
+        type: "select",
+        label: "Sampler",
+        variable: "sampler",
+        helpText: "The sampling method used for image generation",
+        defaultValue: "Euler a",
+        selectOptions: samplers.map((name) => ({
+          label: name,
+          value: name
+        }))
+      },
+      {
+        type: "select",
+        label: "Width",
+        variable: "width",
+        defaultValue: "512",
+        selectOptions: dimensionOptions
+      },
+      {
+        type: "select",
+        label: "Height",
+        variable: "height",
+        defaultValue: "512",
+        selectOptions: dimensionOptions
+      },
+      {
+        type: "number",
+        label: "Steps",
+        variable: "steps",
+        helpText: "Number of denoising steps. More steps = higher quality but slower.",
+        defaultValue: 20,
+        numberOptions: {
+          min: 1,
+          max: 150,
+          step: 1
+        }
+      },
+      {
+        type: "number",
+        label: "CFG Scale",
+        variable: "cfgScale",
+        helpText: "How strongly the image should follow the prompt. Higher = more literal.",
+        defaultValue: 7,
+        numberOptions: {
+          min: 1,
+          max: 30,
+          step: 0.5
+        }
+      },
+      {
+        type: "number",
+        label: "Seed",
+        variable: "seed",
+        helpText: "A specific value used to guide the 'randomness' of generation. Use -1 for random.",
+        defaultValue: -1,
+        numberOptions: {
+          min: -1,
+          max: 2147483647
+        }
+      },
+      {
+        type: "text",
+        label: "Negative Prompt",
+        variable: "negativePrompt",
+        helpText: "Things you don't want in the image",
+        placeholder: "blurry, low quality, distorted"
+      }
+    ];
+  }
+};
+var stable_diffusion_default = new StableDiffusionProvider();
+
+// src/providers/comfyui/index.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+import * as os4 from "os";
+
+// src/providers/comfyui/workflows/ltx-video.ts
+var LTX_VIDEO_DEFAULTS = {
+  model: "ltx-video-2b-v0.9.5.safetensors",
+  textEncoder: "t5xxl_fp16.safetensors",
+  prompt: "",
+  negativePrompt: "worst quality, blurry, distorted, disfigured, motion smear, motion artifacts",
+  width: 512,
+  height: 320,
+  numFrames: 41,
+  fps: 8,
+  steps: 20,
+  cfgScale: 3,
+  seed: -1
+};
+function buildLtxVideoWorkflow(params) {
+  const p = { ...LTX_VIDEO_DEFAULTS, ...params };
+  const seed = p.seed === -1 ? Math.floor(Math.random() * 2 ** 32) : p.seed;
+  return {
+    // Node 1: Load checkpoint (MODEL + VAE, CLIP output unused)
+    "1": {
+      class_type: "CheckpointLoaderSimple",
+      inputs: {
+        ckpt_name: p.model
+      }
+    },
+    // Node 2: Load text encoder (T5-XXL) separately
+    "2": {
+      class_type: "CLIPLoader",
+      inputs: {
+        clip_name: p.textEncoder,
+        type: "ltxv"
+      }
+    },
+    // Node 3: Positive prompt encoding (CLIP from CLIPLoader, NOT from checkpoint)
+    "3": {
+      class_type: "CLIPTextEncode",
+      inputs: {
+        text: p.prompt,
+        clip: ["2", 0]
+      }
+    },
+    // Node 4: Negative prompt encoding
+    "4": {
+      class_type: "CLIPTextEncode",
+      inputs: {
+        text: p.negativePrompt,
+        clip: ["2", 0]
+      }
+    },
+    // Node 5: Empty latent video
+    "5": {
+      class_type: "EmptyLTXVLatentVideo",
+      inputs: {
+        width: p.width,
+        height: p.height,
+        length: p.numFrames,
+        batch_size: 1
+      }
+    },
+    // Node 6: KSampler
+    "6": {
+      class_type: "KSampler",
+      inputs: {
+        model: ["1", 0],
+        positive: ["3", 0],
+        negative: ["4", 0],
+        latent_image: ["5", 0],
+        seed,
+        steps: p.steps,
+        cfg: p.cfgScale,
+        sampler_name: "euler",
+        scheduler: "normal",
+        denoise: 1
+      }
+    },
+    // Node 7: VAE Decode (VAE from checkpoint, slot 2)
+    "7": {
+      class_type: "VAEDecode",
+      inputs: {
+        samples: ["6", 0],
+        vae: ["1", 2]
+      }
+    },
+    // Node 8: Save as MP4 via VideoHelperSuite
+    "8": {
+      class_type: "VHS_VideoCombine",
+      inputs: {
+        images: ["7", 0],
+        frame_rate: p.fps,
+        loop_count: 0,
+        filename_prefix: "ltxv_output",
+        format: "video/h264-mp4",
+        pingpong: false,
+        save_output: true
+      }
+    }
+  };
+}
+var LTX_VIDEO_OUTPUT_NODE = "8";
+
+// src/providers/comfyui/workflows/wan2.1.ts
+var WAN21_DEFAULTS = {
+  model: "wan2.1_t2v_1.3B_fp16.safetensors",
+  textEncoder: "umt5_xxl_fp8_e4m3fn_scaled.safetensors",
+  vae: "wan_2.1_vae.safetensors",
+  prompt: "",
+  negativePrompt: "worst quality, blurry, distorted",
+  width: 480,
+  height: 320,
+  numFrames: 25,
+  fps: 8,
+  steps: 20,
+  cfgScale: 5,
+  seed: -1
+};
+function buildWan21Workflow(params) {
+  const p = { ...WAN21_DEFAULTS, ...params };
+  const seed = p.seed === -1 ? Math.floor(Math.random() * 2 ** 32) : p.seed;
+  return {
+    // Node 1: Load diffusion model (UNET)
+    "1": {
+      class_type: "UNETLoader",
+      inputs: {
+        unet_name: p.model,
+        weight_dtype: "default"
+      }
+    },
+    // Node 2: Load text encoder (UMT5-XXL)
+    "2": {
+      class_type: "CLIPLoader",
+      inputs: {
+        clip_name: p.textEncoder,
+        type: "wan"
+      }
+    },
+    // Node 3: Load VAE
+    "3": {
+      class_type: "VAELoader",
+      inputs: {
+        vae_name: p.vae
+      }
+    },
+    // Node 4: Positive prompt encoding
+    "4": {
+      class_type: "CLIPTextEncode",
+      inputs: {
+        text: p.prompt,
+        clip: ["2", 0]
+      }
+    },
+    // Node 5: Negative prompt encoding
+    "5": {
+      class_type: "CLIPTextEncode",
+      inputs: {
+        text: p.negativePrompt,
+        clip: ["2", 0]
+      }
+    },
+    // Node 6: Empty latent image (for video frames)
+    "6": {
+      class_type: "EmptySD3LatentImage",
+      inputs: {
+        width: p.width,
+        height: p.height,
+        batch_size: p.numFrames
+      }
+    },
+    // Node 7: KSampler
+    "7": {
+      class_type: "KSampler",
+      inputs: {
+        model: ["1", 0],
+        positive: ["4", 0],
+        negative: ["5", 0],
+        latent_image: ["6", 0],
+        seed,
+        steps: p.steps,
+        cfg: p.cfgScale,
+        sampler_name: "euler",
+        scheduler: "normal",
+        denoise: 1
+      }
+    },
+    // Node 8: VAE Decode
+    "8": {
+      class_type: "VAEDecode",
+      inputs: {
+        samples: ["7", 0],
+        vae: ["3", 0]
+      }
+    },
+    // Node 9: Save as MP4 via VideoHelperSuite
+    "9": {
+      class_type: "VHS_VideoCombine",
+      inputs: {
+        images: ["8", 0],
+        frame_rate: p.fps,
+        loop_count: 0,
+        filename_prefix: "wan21_output",
+        format: "video/h264-mp4",
+        pingpong: false,
+        save_output: true
+      }
+    }
+  };
+}
+var WAN21_OUTPUT_NODE = "9";
+
+// src/providers/comfyui/workflows/index.ts
+var MODEL_REGISTRY = [
+  // LTX-Video models
+  {
+    pattern: /ltx[_-]?video/i,
+    config: {
+      family: "ltx-video",
+      displayName: "LTX-Video",
+      buildWorkflow: (params) => buildLtxVideoWorkflow({
+        model: params.model,
+        prompt: params.prompt,
+        negativePrompt: params.negativePrompt,
+        width: params.width,
+        height: params.height,
+        numFrames: params.numFrames,
+        fps: params.fps,
+        steps: params.steps,
+        cfgScale: params.cfgScale,
+        seed: params.seed
+      }),
+      outputNodeId: LTX_VIDEO_OUTPUT_NODE,
+      defaults: {
+        width: LTX_VIDEO_DEFAULTS.width,
+        height: LTX_VIDEO_DEFAULTS.height,
+        numFrames: LTX_VIDEO_DEFAULTS.numFrames,
+        fps: LTX_VIDEO_DEFAULTS.fps,
+        steps: LTX_VIDEO_DEFAULTS.steps,
+        cfgScale: LTX_VIDEO_DEFAULTS.cfgScale
+      }
+    }
+  },
+  // Wan 2.1 models
+  {
+    pattern: /wan2[\._]?1/i,
+    config: {
+      family: "wan2.1",
+      displayName: "Wan 2.1",
+      buildWorkflow: (params) => buildWan21Workflow({
+        model: params.model,
+        prompt: params.prompt,
+        negativePrompt: params.negativePrompt,
+        width: params.width,
+        height: params.height,
+        numFrames: params.numFrames,
+        fps: params.fps,
+        steps: params.steps,
+        cfgScale: params.cfgScale,
+        seed: params.seed
+      }),
+      outputNodeId: WAN21_OUTPUT_NODE,
+      defaults: {
+        width: WAN21_DEFAULTS.width,
+        height: WAN21_DEFAULTS.height,
+        numFrames: WAN21_DEFAULTS.numFrames,
+        fps: WAN21_DEFAULTS.fps,
+        steps: WAN21_DEFAULTS.steps,
+        cfgScale: WAN21_DEFAULTS.cfgScale
+      }
+    }
+  }
+];
+function getWorkflowForModel(modelFilename) {
+  for (const entry of MODEL_REGISTRY) {
+    if (entry.pattern.test(modelFilename)) {
+      return entry.config;
+    }
+  }
+  return null;
+}
+function isKnownVideoModel(modelFilename) {
+  return getWorkflowForModel(modelFilename) !== null;
+}
+
+// src/providers/comfyui/readme.md
+var readme_default4 = '# ComfyUI\n\nComfyUI runs video generation models (LTX-Video, Wan2.1) locally. MindStudio handles all the workflow complexity for you -- you just need to install ComfyUI and download a model.\n\n**Default port:** 8188\n**Website:** https://www.comfy.org\n**GitHub:** https://github.com/comfyanonymous/ComfyUI\n\n## What You\'ll Need\n\n- **Python 3.10 or newer** -- Check by opening a terminal and typing `python3 --version`. If you don\'t have it, download from https://www.python.org/downloads/\n\n- **Git** -- Check by typing `git --version`. If you don\'t have it, download from https://git-scm.com/downloads\n\n- **A GPU with 8+ GB of VRAM** -- Video generation is demanding. Without enough GPU memory, generation will fail or be extremely slow.\n\n## Step 1: Install ComfyUI\n\nOpen a terminal and run these commands one at a time, waiting for each to finish before running the next.\n\nDownload ComfyUI:\n\n```\ngit clone https://github.com/comfyanonymous/ComfyUI.git ~/ComfyUI\n```\n\nGo into the folder:\n\n```\ncd ~/ComfyUI\n```\n\nCreate an isolated Python environment:\n\n```\npython3 -m venv venv\n```\n\nActivate the environment:\n\n```\nsource venv/bin/activate\n```\n\n**Windows users:** use `venv\\Scripts\\activate` instead.\n\nInstall dependencies (may take a few minutes):\n\n```\npip install -r requirements.txt\n```\n\n## Step 2: Download a Video Model\n\nYou need at least one video model for MindStudio to use.\n\n### LTX-Video (recommended to start)\n\nFastest option, good for getting up and running quickly.\n\n1. Go to https://huggingface.co/Lightricks/LTX-Video\n2. Download `ltx-video-2b-v0.9.5.safetensors`\n3. Move the file into:\n\n```\n~/ComfyUI/models/checkpoints/\n```\n\n### Wan2.1\n\nHigher quality but slower and needs more VRAM. Requires multiple files -- make sure you download all of them or it won\'t work.\n\n1. Go to https://huggingface.co/Comfy-Org/Wan2.1_ComfyUI_repackaged\n2. Place UNET files in `~/ComfyUI/models/diffusion_models/`\n3. Place text encoder files in `~/ComfyUI/models/text_encoders/`\n4. Place VAE files in `~/ComfyUI/models/vae/`\n\n## Step 3: Start the Server\n\nEvery time you want to use ComfyUI with MindStudio, open a terminal and run:\n\n```\ncd ~/ComfyUI && source venv/bin/activate && python main.py --listen\n```\n\n**Windows users:**\n\n```\ncd %USERPROFILE%\\ComfyUI && venv\\Scripts\\activate && python main.py --listen\n```\n\n**Important:** The `--listen` flag is required. Without it, MindStudio cannot connect to the server.\n\nLeave this terminal window open. When you see "To see the GUI go to: http://0.0.0.0:8188", the server is ready. Go back to the tunnel and select **Refresh Providers** -- your models should appear.\n\n## Troubleshooting\n\n- **MindStudio says ComfyUI is "not running"** -- Make sure you started with the `--listen` flag. Without it, the server won\'t accept connections from MindStudio.\n\n- **Server is running but no models show up** -- Check that your model files are in the right folders under `~/ComfyUI/models/`. Checkpoint files go in `checkpoints/`, UNET files go in `diffusion_models/`.\n\n- **Generation fails with workflow errors** -- For Wan2.1, you need all three files (UNET, text encoder, VAE). If any are missing, generation will fail.\n\n- **"CUDA out of memory"** -- Video generation needs a lot of GPU memory. Try reducing the resolution or number of frames in your generation settings, or use LTX-Video which is lighter.\n\n- **Server crashes mid-generation** -- Press Ctrl+C in the terminal and run the start command again.\n';
+
+// src/providers/comfyui/index.ts
+var ComfyUIProvider = class {
+  name = "comfyui";
+  displayName = "ComfyUI";
+  description = "Generate videos locally using node-based workflows. Supports LTX-Video and Wan2.1.";
+  capabilities = ["video"];
+  readme = readme_default4;
+  defaultBaseUrl = "http://127.0.0.1:8188";
+  get baseUrl() {
+    return getProviderBaseUrl(this.name, this.defaultBaseUrl);
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  async isRunning() {
+    try {
+      const response = await fetch(`${this.getBaseUrl()}/system_stats`, {
+        method: "GET",
+        signal: AbortSignal.timeout(5e3)
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async detect() {
+    const savedPath = getProviderInstallPath(this.name);
+    const possiblePaths = [
+      ...savedPath ? [savedPath] : [],
+      path4.join(os4.homedir(), "ComfyUI"),
+      path4.join(os4.homedir(), "comfyui"),
+      path4.join(os4.homedir(), "Projects", "ComfyUI"),
+      path4.join(os4.homedir(), "Code", "ComfyUI")
+    ];
+    let installed = false;
+    for (const p of possiblePaths) {
+      if (fs3.existsSync(path4.join(p, "main.py")) && fs3.existsSync(path4.join(p, "requirements.txt"))) {
+        installed = true;
+        break;
+      }
+    }
+    let running = false;
+    try {
+      const response = await fetch("http://127.0.0.1:8188/system_stats", {
+        signal: AbortSignal.timeout(1e3)
+      });
+      running = response.ok;
+      if (running) installed = true;
+    } catch {
+      running = false;
+    }
+    return { installed, running };
+  }
+  /**
+   * Discover video models by scanning ComfyUI's model directories.
+   */
+  async discoverModels() {
+    const models = [];
+    try {
+      const response = await fetch(
+        `${this.getBaseUrl()}/object_info/CheckpointLoaderSimple`,
+        { signal: AbortSignal.timeout(5e3) }
+      );
+      if (response.ok) {
+        const data = await response.json();
+        const nodeInfo = data.CheckpointLoaderSimple;
+        const checkpoints = nodeInfo?.input?.required?.ckpt_name?.[0] || [];
+        for (const name of checkpoints) {
+          if (isKnownVideoModel(name)) {
+            const workflow = getWorkflowForModel(name);
+            models.push({
+              name,
+              provider: this.name,
+              capability: "video",
+              parameterSize: workflow?.displayName
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    try {
+      const response = await fetch(
+        `${this.getBaseUrl()}/object_info/UNETLoader`,
+        { signal: AbortSignal.timeout(5e3) }
+      );
+      if (response.ok) {
+        const data = await response.json();
+        const nodeInfo = data.UNETLoader;
+        const unetModels = nodeInfo?.input?.required?.unet_name?.[0] || [];
+        for (const name of unetModels) {
+          if (isKnownVideoModel(name) && !models.some((m) => m.name === name)) {
+            const workflow = getWorkflowForModel(name);
+            models.push({
+              name,
+              provider: this.name,
+              capability: "video",
+              parameterSize: workflow?.displayName
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    if (models.length === 0) {
+      const installPath = getProviderInstallPath(this.name);
+      if (installPath) {
+        const dirs = [
+          path4.join(installPath, "models", "checkpoints"),
+          path4.join(installPath, "models", "diffusion_models")
+        ];
+        for (const dir of dirs) {
+          if (fs3.existsSync(dir)) {
+            try {
+              const files = fs3.readdirSync(dir);
+              for (const file of files) {
+                if (isKnownVideoModel(file) && !models.some((m) => m.name === file)) {
+                  const workflow = getWorkflowForModel(file);
+                  models.push({
+                    name: file,
+                    provider: this.name,
+                    capability: "video",
+                    parameterSize: workflow?.displayName
+                  });
+                }
+              }
+            } catch {
+            }
+          }
+        }
+      }
+    }
+    return models;
+  }
+  /**
+   * Generate a video using ComfyUI.
+   */
+  async generateVideo(model, prompt, options, onProgress) {
+    const baseUrl = this.getBaseUrl();
+    const workflowConfig = getWorkflowForModel(model);
+    if (!workflowConfig) {
+      throw new Error(
+        `No workflow template found for model: ${model}. Supported families: LTX-Video, Wan2.1`
+      );
+    }
+    const defaults = workflowConfig.defaults;
+    const seed = options?.seed !== void 0 && options.seed !== -1 ? options.seed : Math.floor(Math.random() * 2 ** 32);
+    const workflow = workflowConfig.buildWorkflow({
+      model,
+      prompt,
+      negativePrompt: options?.negativePrompt || "worst quality, blurry, distorted",
+      width: options?.width || defaults.width,
+      height: options?.height || defaults.height,
+      numFrames: options?.numFrames || defaults.numFrames,
+      fps: options?.fps || defaults.fps,
+      steps: options?.steps || defaults.steps,
+      cfgScale: options?.cfgScale || defaults.cfgScale,
+      seed
+    });
+    const clientId = `mindstudio_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    const wsUrl = baseUrl.replace(/^http/, "ws") + `/ws?clientId=${clientId}`;
+    const submitResponse = await fetch(`${baseUrl}/prompt`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        prompt: workflow,
+        client_id: clientId
+      })
+    });
+    if (!submitResponse.ok) {
+      const errorText = await submitResponse.text();
+      throw new Error(
+        `ComfyUI prompt submission failed: ${submitResponse.status} ${errorText}`
+      );
+    }
+    const submitResult2 = await submitResponse.json();
+    if (submitResult2.node_errors && Object.keys(submitResult2.node_errors).length > 0) {
+      throw new Error(
+        `ComfyUI workflow validation failed: ${JSON.stringify(submitResult2.node_errors)}`
+      );
+    }
+    const promptId = submitResult2.prompt_id;
+    await this.waitForCompletion(wsUrl, promptId, onProgress);
+    const historyResponse = await fetch(`${baseUrl}/history/${promptId}`, {
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!historyResponse.ok) {
+      throw new Error(
+        `Failed to fetch result history: ${historyResponse.status}`
+      );
+    }
+    const history = await historyResponse.json();
+    const promptHistory = history[promptId];
+    if (!promptHistory) {
+      throw new Error("No result found in ComfyUI history");
+    }
+    const outputNodeId = workflowConfig.outputNodeId;
+    const outputData = promptHistory.outputs[outputNodeId];
+    const outputFiles = outputData?.gifs || outputData?.images;
+    if (!outputFiles || outputFiles.length === 0) {
+      throw new Error("No output files found in ComfyUI result");
+    }
+    const outputFile = outputFiles[0];
+    const fileUrl = new URL(`${baseUrl}/view`);
+    fileUrl.searchParams.set("filename", outputFile.filename);
+    fileUrl.searchParams.set("subfolder", outputFile.subfolder || "");
+    fileUrl.searchParams.set("type", outputFile.type || "output");
+    const fileResponse = await fetch(fileUrl.toString(), {
+      signal: AbortSignal.timeout(6e4)
+    });
+    if (!fileResponse.ok) {
+      throw new Error(`Failed to download output file: ${fileResponse.status}`);
+    }
+    const fileBuffer = await fileResponse.arrayBuffer();
+    const videoBase64 = Buffer.from(fileBuffer).toString("base64");
+    const ext = path4.extname(outputFile.filename).toLowerCase();
+    const mimeType = ext === ".mp4" ? "video/mp4" : ext === ".webm" ? "video/webm" : ext === ".webp" ? "image/webp" : ext === ".gif" ? "image/gif" : "video/mp4";
+    const fps = options?.fps || defaults.fps;
+    const numFrames = options?.numFrames || defaults.numFrames;
+    return {
+      videoBase64,
+      mimeType,
+      duration: numFrames / fps,
+      fps,
+      seed
+    };
+  }
+  /**
+   * Wait for a ComfyUI prompt to finish execution via WebSocket.
+   */
+  waitForCompletion(wsUrl, promptId, onProgress) {
+    return new Promise((resolve, reject) => {
+      const timeoutMs = 30 * 60 * 1e3;
+      let ws;
+      const timeout = setTimeout(() => {
+        try {
+          ws?.close();
+        } catch {
+        }
+        reject(new Error("Video generation timed out after 30 minutes"));
+      }, timeoutMs);
+      try {
+        ws = new WebSocket(wsUrl);
+      } catch (err) {
+        clearTimeout(timeout);
+        reject(
+          new Error(
+            `Failed to connect to ComfyUI WebSocket: ${err instanceof Error ? err.message : err}`
+          )
+        );
+        return;
+      }
+      ws.onmessage = (event) => {
+        try {
+          const message = JSON.parse(
+            typeof event.data === "string" ? event.data : ""
+          );
+          if (message.type === "progress") {
+            const data = message.data;
+            if (!data.prompt_id || data.prompt_id === promptId) {
+              onProgress?.({
+                step: data.value,
+                totalSteps: data.max,
+                currentNode: data.node
+              });
+            }
+          }
+          if (message.type === "execution_success") {
+            const data = message.data;
+            if (data.prompt_id === promptId) {
+              clearTimeout(timeout);
+              ws.close();
+              resolve();
+            }
+          }
+          if (message.type === "execution_error") {
+            const data = message.data;
+            if (data.prompt_id === promptId) {
+              clearTimeout(timeout);
+              ws.close();
+              reject(
+                new Error(
+                  `ComfyUI execution error${data.node_type ? ` in ${data.node_type}` : ""}: ${data.exception_message || "Unknown error"}`
+                )
+              );
+            }
+          }
+        } catch {
+        }
+      };
+      ws.onerror = () => {
+        clearTimeout(timeout);
+        reject(new Error("ComfyUI WebSocket error: connection failed"));
+      };
+      ws.onclose = (event) => {
+        if (!event.wasClean) {
+          clearTimeout(timeout);
+          reject(new Error("ComfyUI WebSocket connection closed unexpectedly"));
+        }
+      };
+    });
+  }
+  /**
+   * Get parameter schemas for video generation UI configuration.
+   */
+  async getParameterSchemas() {
+    return [
+      {
+        type: "number",
+        label: "Width",
+        variable: "width",
+        helpText: "Video width in pixels. Larger = better quality but bigger file.",
+        defaultValue: 512,
+        numberOptions: { min: 256, max: 1280, step: 64 }
+      },
+      {
+        type: "number",
+        label: "Height",
+        variable: "height",
+        helpText: "Video height in pixels. Larger = better quality but bigger file.",
+        defaultValue: 320,
+        numberOptions: { min: 256, max: 1280, step: 64 }
+      },
+      {
+        type: "number",
+        label: "Frames",
+        variable: "numFrames",
+        helpText: "Number of frames to generate. More frames = longer video but bigger file. Keep low to avoid upload limits.",
+        defaultValue: 41,
+        numberOptions: { min: 9, max: 97, step: 8 }
+      },
+      {
+        type: "number",
+        label: "FPS",
+        variable: "fps",
+        helpText: "Frames per second for the output video.",
+        defaultValue: 8,
+        numberOptions: { min: 4, max: 30, step: 1 }
+      },
+      {
+        type: "number",
+        label: "Steps",
+        variable: "steps",
+        helpText: "Number of denoising steps. More steps = higher quality but slower.",
+        defaultValue: 20,
+        numberOptions: { min: 10, max: 100, step: 1 }
+      },
+      {
+        type: "number",
+        label: "CFG Scale",
+        variable: "cfgScale",
+        helpText: "How strongly the video should follow the prompt. Higher = more literal.",
+        defaultValue: 7,
+        numberOptions: { min: 1, max: 20, step: 0.5 }
+      },
+      {
+        type: "number",
+        label: "Seed",
+        variable: "seed",
+        helpText: "A specific value used to guide randomness. Use -1 for random.",
+        defaultValue: -1,
+        numberOptions: { min: -1, max: 2147483647 }
+      },
+      {
+        type: "text",
+        label: "Negative Prompt",
+        variable: "negativePrompt",
+        helpText: "Things you don't want in the video",
+        placeholder: "worst quality, blurry, distorted"
+      }
+    ];
+  }
+};
+var comfyui_default = new ComfyUIProvider();
+
+// src/providers/index.ts
+var allProviders = [
+  ollama_default,
+  lmstudio_default,
+  stable_diffusion_default,
+  comfyui_default
+];
+function getProvider(name) {
+  return allProviders.find((p) => p.name === name);
+}
+async function discoverRunningProviders() {
+  const results = await Promise.all(
+    allProviders.map(async (provider) => ({
+      provider,
+      running: await provider.isRunning()
+    }))
+  );
+  return results.filter((r) => r.running).map((r) => r.provider);
+}
+async function discoverAllModels() {
+  const runningProviders = await discoverRunningProviders();
+  const modelArrays = await Promise.all(
+    runningProviders.map((p) => p.discoverModels())
+  );
+  return modelArrays.flat();
+}
+async function getProviderStatuses() {
+  return Promise.all(
+    allProviders.map(async (provider) => ({
+      provider,
+      running: await provider.isRunning()
+    }))
+  );
+}
+async function detectAllProviderStatuses() {
+  return Promise.all(
+    allProviders.map(async (provider) => ({
+      provider,
+      status: await provider.detect()
+    }))
+  );
+}
+async function discoverAllModelsWithParameters() {
+  const runningProviders = await discoverRunningProviders();
+  const modelsWithParams = await Promise.all(
+    runningProviders.map(async (provider) => {
+      const models = await provider.discoverModels();
+      if (typeof provider.getParameterSchemas === "function") {
+        const parameters = await provider.getParameterSchemas();
+        return models.map((model) => ({
+          ...model,
+          parameters
+        }));
+      }
+      return models;
+    })
+  );
+  return modelsWithParams.flat();
+}
+
+// src/events.ts
+import { EventEmitter } from "events";
+var RequestEventEmitter = class extends EventEmitter {
+  emitStart(event) {
+    this.emit("request:start", event);
+  }
+  emitProgress(event) {
+    this.emit("request:progress", event);
+  }
+  emitComplete(event) {
+    this.emit("request:complete", event);
+  }
+  onStart(handler) {
+    this.on("request:start", handler);
+    return () => this.off("request:start", handler);
+  }
+  onProgress(handler) {
+    this.on("request:progress", handler);
+    return () => this.off("request:progress", handler);
+  }
+  onComplete(handler) {
+    this.on("request:complete", handler);
+    return () => this.off("request:complete", handler);
+  }
+};
+var requestEvents = new RequestEventEmitter();
+
+// src/runner.ts
+var TunnelRunner = class {
+  isRunning = false;
+  modelProviderMap = /* @__PURE__ */ new Map();
+  models = [];
+  /**
+   * Start with a pre-discovered list of model names.
+   * Used by the TUI, which discovers models itself.
+   */
+  async start(models) {
+    if (this.isRunning) return;
+    this.models = models;
+    this.isRunning = true;
+    const allModels = await discoverAllModels();
+    this.buildModelProviderMap(allModels);
+    this.pollLoop();
+  }
+  stop() {
+    this.isRunning = false;
+    disconnectHeartbeat().catch(() => {
+    });
+  }
+  buildModelProviderMap(models) {
+    this.modelProviderMap.clear();
+    for (const model of models) {
+      const provider = getProvider(model.provider);
+      if (provider) {
+        this.modelProviderMap.set(model.name, provider);
+      }
+    }
+  }
+  async pollLoop() {
+    while (this.isRunning) {
+      try {
+        const request = await pollForRequest(this.models);
+        if (request) {
+          this.processRequest(request);
+        }
+      } catch (error) {
+        await this.sleep(5e3);
+      }
+    }
+  }
+  async processRequest(request) {
+    const startTime = Date.now();
+    requestEvents.emitStart({
+      id: request.id,
+      modelId: request.modelId,
+      requestType: request.requestType,
+      timestamp: startTime
+    });
+    const provider = this.modelProviderMap.get(request.modelId);
+    if (!provider) {
+      const error = `Model ${request.modelId} not found`;
+      await submitResult(request.id, false, void 0, error);
+      requestEvents.emitComplete({
+        id: request.id,
+        success: false,
+        duration: Date.now() - startTime,
+        error
+      });
+      return;
+    }
+    try {
+      switch (request.requestType) {
+        case "llm_chat":
+          await this.handleTextRequest(request, provider, startTime);
+          break;
+        case "image_generation":
+          await this.handleImageRequest(request, provider, startTime);
+          break;
+        case "video_generation":
+          await this.handleVideoRequest(request, provider, startTime);
+          break;
+        default:
+          throw new Error(`Unsupported request type: ${request.requestType}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      await submitResult(request.id, false, void 0, message);
+      requestEvents.emitComplete({
+        id: request.id,
+        success: false,
+        duration: Date.now() - startTime,
+        error: message
+      });
+    }
+  }
+  async handleTextRequest(request, provider, startTime) {
+    if (!provider.chat) {
+      throw new Error(`Provider does not support text generation`);
+    }
+    const messages = (request.payload.messages || []).map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    const stream = provider.chat(request.modelId, messages, {
+      temperature: request.payload.temperature,
+      maxTokens: request.payload.maxTokens
+    });
+    let fullContent = "";
+    let lastProgressUpdate = 0;
+    const progressInterval = 100;
+    for await (const chunk of stream) {
+      fullContent += chunk.content;
+      const now = Date.now();
+      if (now - lastProgressUpdate > progressInterval) {
+        await submitProgress(request.id, fullContent);
+        requestEvents.emitProgress({
+          id: request.id,
+          content: fullContent
+        });
+        lastProgressUpdate = now;
+      }
+    }
+    await submitProgress(request.id, fullContent);
+    await submitResult(request.id, true, {
+      content: fullContent,
+      usage: { promptTokens: 0, completionTokens: 0 }
+    });
+    requestEvents.emitComplete({
+      id: request.id,
+      success: true,
+      duration: Date.now() - startTime,
+      result: { chars: fullContent.length }
+    });
+  }
+  async handleImageRequest(request, provider, startTime) {
+    if (!provider.generateImage) {
+      throw new Error(`Provider does not support image generation`);
+    }
+    const prompt = request.payload.prompt || "";
+    const config2 = request.payload.config || {};
+    let result;
+    if (provider.generateImageWithProgress) {
+      result = await provider.generateImageWithProgress(
+        request.modelId,
+        prompt,
+        {
+          negativePrompt: config2.negativePrompt,
+          width: config2.width,
+          height: config2.height,
+          steps: config2.steps,
+          cfgScale: config2.cfgScale,
+          seed: config2.seed,
+          sampler: config2.sampler
+        },
+        async (progress) => {
+          await submitGenerationProgress(
+            request.id,
+            progress.step,
+            progress.totalSteps,
+            progress.preview
+          );
+          requestEvents.emitProgress({
+            id: request.id,
+            step: progress.step,
+            totalSteps: progress.totalSteps
+          });
+        }
+      );
+    } else {
+      result = await provider.generateImage(request.modelId, prompt, {
+        negativePrompt: config2.negativePrompt,
+        width: config2.width,
+        height: config2.height,
+        steps: config2.steps,
+        cfgScale: config2.cfgScale,
+        seed: config2.seed,
+        sampler: config2.sampler
+      });
+    }
+    await submitResult(request.id, true, {
+      imageBase64: result.imageBase64,
+      mimeType: result.mimeType,
+      seed: result.seed
+    });
+    const imageSize = Math.round(result.imageBase64.length * 3 / 4);
+    requestEvents.emitComplete({
+      id: request.id,
+      success: true,
+      duration: Date.now() - startTime,
+      result: { imageSize }
+    });
+  }
+  async handleVideoRequest(request, provider, startTime) {
+    if (!provider.generateVideo) {
+      throw new Error(`Provider does not support video generation`);
+    }
+    const prompt = request.payload.prompt || "";
+    const config2 = request.payload.config || {};
+    const result = await provider.generateVideo(
+      request.modelId,
+      prompt,
+      {
+        negativePrompt: config2.negativePrompt,
+        width: config2.width,
+        height: config2.height,
+        numFrames: config2.numFrames,
+        fps: config2.fps,
+        steps: config2.steps,
+        cfgScale: config2.cfgScale,
+        seed: config2.seed
+      },
+      async (progress) => {
+        await submitGenerationProgress(
+          request.id,
+          progress.step,
+          progress.totalSteps
+        );
+        requestEvents.emitProgress({
+          id: request.id,
+          step: progress.step,
+          totalSteps: progress.totalSteps
+        });
+      }
+    );
+    await submitResult(request.id, true, {
+      videoBase64: result.videoBase64,
+      mimeType: result.mimeType,
+      duration: result.duration,
+      fps: result.fps,
+      seed: result.seed
+    });
+    const videoSize = Math.round(result.videoBase64.length * 3 / 4);
+    requestEvents.emitComplete({
+      id: request.id,
+      success: true,
+      duration: Date.now() - startTime,
+      result: { videoSize }
+    });
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+export {
+  getEnvironment,
+  getApiKey,
+  setApiKey,
+  getConfigPath,
+  verifyApiKey,
+  registerLocalModel,
+  getRegisteredModels,
+  requestDeviceAuth,
+  pollDeviceAuth,
+  discoverAllModels,
+  getProviderStatuses,
+  detectAllProviderStatuses,
+  discoverAllModelsWithParameters,
+  requestEvents,
+  TunnelRunner
+};
+//# sourceMappingURL=chunk-PTK4SJQK.js.map