let-them-talk 5.3.0 → 5.4.0

package/office/spectator-camera.js

@@ -56,6 +56,12 @@ export function SpectatorCamera(camera, domElement) {
     lastMouse.x = e.clientX;
     lastMouse.y = e.clientY;
     e.preventDefault();
+
+    // In player mode: request pointer lock on left click for FPS-style mouse
+    // Skip if world builder is open (needs free mouse cursor)
+    if (!self.enabled && e.button === 0 && !document.pointerLockElement && !window._builderActive) {
+      domElement.requestPointerLock();
+    }
   }
 
   function onMouseUp(e) {
@@ -65,12 +71,21 @@ export function SpectatorCamera(camera, domElement) {
   }
 
   function onMouseMove(e) {
-    var dx = e.clientX - lastMouse.x;
-    var dy = e.clientY - lastMouse.y;
-    lastMouse.x = e.clientX;
-    lastMouse.y = e.clientY;
+    var isLocked = document.pointerLockElement === domElement;
+    var dx, dy;
+
+    if (isLocked) {
+      // Pointer lock: use movementX/Y directly (no need for drag)
+      dx = e.movementX;
+      dy = e.movementY;
+    } else {
+      dx = e.clientX - lastMouse.x;
+      dy = e.clientY - lastMouse.y;
+      lastMouse.x = e.clientX;
+      lastMouse.y = e.clientY;
+    }
 
-    if (isRightDrag) {
+    if (isRightDrag || isLocked) {
       // Look around (rotate) — always update euler, but only apply to camera in spectator mode
       euler.y -= dx * self.lookSpeed;
       euler.x -= dy * self.lookSpeed;
@@ -78,11 +93,11 @@ export function SpectatorCamera(camera, domElement) {
       if (self.enabled) {
         camera.quaternion.setFromEuler(euler);
       }
-      // In player mode, euler is read by player.js for orbit camera
+      // In player mode, euler is read by player.js for orbit/FP camera
     }
 
-    if ((isLeftDrag || isMiddleDrag) && self.enabled) {
-      // Pan (strafe) — only in spectator mode
+    if ((isLeftDrag || isMiddleDrag) && self.enabled && !isLocked) {
+      // Pan (strafe) — only in spectator mode, not during pointer lock
       _panRight.setFromMatrixColumn(camera.matrixWorld, 0);
       _panUp.setFromMatrixColumn(camera.matrixWorld, 1);
       camera.position.addScaledVector(_panRight, -dx * self.panSpeed);
@@ -127,6 +142,12 @@ export function SpectatorCamera(camera, domElement) {
     if (e.target === domElement) e.preventDefault();
   }
 
+  // Release pointer lock on Escape (browser does this, but track it)
+  function onPointerLockChange() {
+    // Nothing special needed — isLocked check in onMouseMove handles it
+  }
+  document.addEventListener('pointerlockchange', onPointerLockChange);
+
   // --- Public methods ---
   self.update = function(dt) {
     if (!self.enabled) return;
@@ -144,14 +165,16 @@ export function SpectatorCamera(camera, domElement) {
 
     if (moveDir.lengthSq() > 0) {
       moveDir.normalize();
-      // Transform to world space using camera orientation
+      // Transform to world space using camera yaw for horizontal movement
       var forward = new THREE.Vector3();
       var right = new THREE.Vector3();
       camera.getWorldDirection(forward);
+      forward.y = 0;
+      if (forward.lengthSq() > 0) forward.normalize();
       right.crossVectors(forward, camera.up).normalize();
       var worldUp = new THREE.Vector3(0, 1, 0);
 
-      // Forward/back along camera look direction (projected on XZ for ground feel, or full 3D)
+      // Forward/back stays horizontal; vertical travel uses dedicated up/down controls
       velocity.addScaledVector(forward, -moveDir.z * speed * dt);
       velocity.addScaledVector(right, moveDir.x * speed * dt);
       velocity.addScaledVector(worldUp, moveDir.y * speed * dt);

package/office/state.js

@@ -22,4 +22,6 @@ export const S = {
   monitorCanvases: {},
   fpsCounter: 0,
   fpsTime: 0,
+  galleryScreens: null,
+  cachedMedia: [],
 };

package/office/world-save.js

@@ -15,10 +15,31 @@ function getProjectParam() {
   return window.activeProject ? '?project=' + encodeURIComponent(window.activeProject) : '';
 }
 
+function getScopedWorldUrl(path) {
+  if (typeof window.scopedApiUrl === 'function') {
+    return window.scopedApiUrl(path, null, { includeBranch: false });
+  }
+  return path + getProjectParam();
+}
+
+function clonePlacementEntry(entry) {
+  if (!entry || typeof entry !== 'object' || !entry.type) return null;
+  return {
+    id: entry.id || generatePlacementId(),
+    type: entry.type,
+    x: entry.x,
+    y: entry.y || 0,
+    z: entry.z,
+    rotY: entry.rotY || 0,
+    placed_by: entry.placed_by || 'user',
+    timestamp: entry.timestamp || new Date().toISOString()
+  };
+}
+
 // --- Load world layout from server ---
 export async function loadWorld() {
   try {
-    var res = await fetch('/api/world-layout' + getProjectParam());
+    var res = await fetch(getScopedWorldUrl('/api/world-layout'));
     if (res.ok) {
       var data = await res.json();
       _placements = Array.isArray(data) ? data : [];
@@ -38,7 +59,7 @@ function scheduleSave() {
   if (_saveTimeout) clearTimeout(_saveTimeout);
   _saveTimeout = setTimeout(function() {
     _saveTimeout = null;
-    fetch('/api/world-save' + getProjectParam(), {
+    fetch(getScopedWorldUrl('/api/world-save'), {
       method: 'POST',
       headers: { 'Content-Type': 'application/json', 'X-LTT-Request': '1' },
       body: JSON.stringify(_placements)
@@ -50,7 +71,7 @@ function scheduleSave() {
 
 // --- Add a single placement ---
 export function addPlacement(type, x, y, z, rotY, placedBy) {
-  var entry = {
+  var entry = clonePlacementEntry({
     id: generatePlacementId(),
     type: type,
     x: x,
@@ -59,12 +80,22 @@ export function addPlacement(type, x, y, z, rotY, placedBy) {
     rotY: rotY || 0,
     placed_by: placedBy || 'user',
     timestamp: new Date().toISOString()
-  };
+  });
   _placements.push(entry);
   scheduleSave();
   return entry;
 }
 
+export function restorePlacement(entry) {
+  var restored = clonePlacementEntry(entry);
+  if (!restored) return null;
+  var idx = _placements.findIndex(function(p) { return p.id === restored.id; });
+  if (idx === -1) _placements.push(restored);
+  else _placements[idx] = restored;
+  scheduleSave();
+  return restored;
+}
+
 // --- Remove a placement by ID ---
 export function removePlacement(id) {
   var idx = _placements.findIndex(function(p) { return p.id === id; });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "let-them-talk",
-  "version": "5.3.0",
+  "version": "5.4.0",
   "description": "MCP message broker + web dashboard for inter-agent communication. Let AI CLI agents talk to each other.",
   "main": "server.js",
   "bin": {
@@ -10,17 +10,66 @@
   "scripts": {
     "start": "node server.js",
     "dashboard": "node dashboard.js",
-    "test": "echo \"No tests configured\""
+    "export:markdown-workspace": "node scripts/export-markdown-workspace.js",
+    "sync:packaged-docs": "node scripts/sync-packaged-docs.js",
+    "prepack": "npm run sync:packaged-docs",
+    "test": "npm run verify",
+    "verify": "npm run verify:contracts && npm run verify:replay && npm run verify:invariants",
+    "verify:docs-onboarding": "node scripts/check-docs-onboarding.js",
+    "verify:contracts": "npm run verify:contracts:runtime && npm run verify:contracts:schema && npm run verify:contracts:branches && npm run verify:contracts:markdown-workspace",
+    "verify:contracts:runtime": "node scripts/check-runtime-contract.js",
+    "verify:contracts:schema": "node scripts/check-event-schema.js",
+    "verify:contracts:branches": "node scripts/check-branch-semantics.js",
+    "verify:contracts:markdown-workspace": "node scripts/check-markdown-workspace.js",
+    "verify:replay": "npm run verify:replay:positive && npm run verify:replay:negative",
+    "verify:replay:positive": "npm run verify:replay:healthy && npm run verify:replay:clean",
+    "verify:replay:healthy": "node scripts/check-message-replay.js --scenario healthy",
+    "verify:replay:clean": "node scripts/check-message-replay.js --scenario clean",
+    "verify:replay:negative": "node scripts/run-verification-suite.js replay-negative",
+    "verify:invariants": "npm run verify:invariants:authority && npm run verify:invariants:dashboard-control-plane && npm run verify:invariants:performance-indexing && npm run verify:invariants:capabilities && npm run verify:invariants:api-agent-parity && npm run verify:invariants:dashboard-semantic-gap && npm run verify:invariants:migration-hardening && npm run verify:invariants:branches && npm run verify:invariants:sessions && npm run verify:invariants:evidence && npm run verify:invariants:context && npm run verify:invariants:autonomy-v2 && npm run verify:invariants:autonomy-v2-watchdog && npm run verify:invariants:autonomy-v2-execution && npm run verify:invariants:agent-contracts && npm run verify:invariants:managed-team-integration && npm run verify:invariants:lifecycle-hooks && npm run verify:invariants:markdown-workspace-export && npm run verify:invariants:markdown-workspace-safety",
+    "verify:invariants:authority": "node scripts/check-invariants.js --suite authority",
+    "verify:invariants:dashboard-control-plane": "node scripts/check-dashboard-control-plane.js",
+    "verify:invariants:performance-indexing": "node scripts/check-performance-indexing.js",
+    "verify:invariants:capabilities": "node scripts/check-provider-capabilities.js",
+    "verify:invariants:api-agent-parity": "node scripts/check-api-agent-parity.js",
+    "verify:invariants:dashboard-semantic-gap": "node scripts/run-verification-suite.js dashboard-semantic-gap",
+    "verify:invariants:migration-hardening": "node scripts/check-migration-hardening.js",
+    "verify:invariants:branches": "node scripts/check-branch-isolation.js && node scripts/check-branch-fork-snapshot.js",
+    "verify:invariants:branch-fork": "node scripts/check-branch-fork-snapshot.js",
+    "verify:invariants:sessions": "node scripts/check-session-lifecycle.js",
+    "verify:invariants:evidence": "node scripts/check-evidence-completion.js",
+    "verify:invariants:context": "node scripts/check-session-aware-context.js",
+    "verify:invariants:autonomy-v2": "node scripts/check-autonomy-v2-decision.js",
+    "verify:invariants:autonomy-v2-watchdog": "node scripts/check-autonomy-v2-watchdog.js",
+    "verify:invariants:autonomy-v2-execution": "node scripts/check-autonomy-v2-execution.js",
+    "verify:invariants:agent-contracts": "node scripts/check-agent-contract-advisory.js",
+    "verify:invariants:managed-team-integration": "node scripts/check-managed-team-integration.js",
+    "verify:invariants:lifecycle-hooks": "node scripts/check-lifecycle-hooks.js",
+    "verify:invariants:markdown-workspace-export": "node scripts/check-markdown-workspace-export.js",
+    "verify:invariants:markdown-workspace-safety": "node scripts/check-markdown-workspace-safety.js",
+    "verify:smoke": "node scripts/run-verification-suite.js smoke"
   },
   "engines": {
     "node": ">=18.0.0"
   },
   "files": [
+    "data-dir.js",
     "server.js",
     "dashboard.js",
     "dashboard.html",
+    "api-agents.js",
+    "runtime-descriptor.js",
+    "agent-contracts.js",
+    "managed-team-integration.js",
+    "autonomy/",
+    "events/",
+    "state/",
+    "providers/",
     "office/",
     "mods/",
+    "scripts/",
+    "docs/",
+    "USAGE.md",
     "cli.js",
     "templates/",
     "conversation-templates/",
@@ -53,7 +102,12 @@
   "author": "Dekelelz <contact@talk.unrealai.studio>",
   "license": "SEE LICENSE IN LICENSE",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.27.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "three": "0.175.0"
+  },
+  "overrides": {
+    "hono": "^4.12.14",
+    "path-to-regexp": "^8.4.2",
+    "@hono/node-server": "^1.19.14"
   }
 }

package/providers/comfyui.js

@@ -0,0 +1,383 @@
+// ComfyUI provider — queue workflows via REST API, poll for results
+// Supports text-to-image, image-to-video, and 3D generation
+// Workflow templates have their prompt nodes auto-replaced with user input
+
+const http = require('http');
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+var DEFAULT_PORT = 8188;
+
+class ComfyUIProvider {
+  constructor(options) {
+    options = options || {};
+    this.endpoint = options.endpoint || 'http://127.0.0.1:8188';
+    this.model = options.model || 'default';
+    this.name = 'comfyui';
+    this.color = '#ff6b35'; // orange
+    this.comfyPath = options.comfyPath || 'G:/ComfyUI';
+    this.workflowsDir = path.join(this.comfyPath, 'user/default/workflows');
+    this._workflows = null;
+  }
+
+  // List available workflow files
+  listWorkflows() {
+    try {
+      var files = fs.readdirSync(this.workflowsDir).filter(function(f) { return f.endsWith('.json'); });
+      return files.map(function(f) {
+        return { name: f.replace('.json', ''), file: f };
+      });
+    } catch (e) {
+      return [];
+    }
+  }
+
+  // Load a workflow JSON by name
+  _loadWorkflow(name) {
+    // Try exact match first
+    var filePath = path.join(this.workflowsDir, name + '.json');
+    if (!fs.existsSync(filePath)) {
+      // Try fuzzy match
+      var files = this.listWorkflows();
+      var match = files.find(function(f) {
+        return f.name.toLowerCase().indexOf(name.toLowerCase()) !== -1;
+      });
+      if (match) filePath = path.join(this.workflowsDir, match.file);
+    }
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  }
+
+  // Convert UI-format workflow to API-format (what /prompt expects)
+  _toApiFormat(workflow) {
+    if (!workflow.nodes) return workflow; // already API format
+
+    var api = {};
+    var nodes = workflow.nodes;
+    var links = workflow.links || [];
+
+    // Build link map: linkId → { fromNode, fromSlot, toNode, toSlot }
+    var linkMap = {};
+    for (var li = 0; li < links.length; li++) {
+      var link = links[li];
+      // link format: [linkId, fromNodeId, fromSlotIdx, toNodeId, toSlotIdx, type]
+      linkMap[link[0]] = { from: link[1], fromSlot: link[2], to: link[3], toSlot: link[4] };
+    }
+
+    for (var ni = 0; ni < nodes.length; ni++) {
+      var node = nodes[ni];
+      if (!node.type || node.type === 'Note' || node.type === 'MarkdownNote') continue;
+
+      var inputs = {};
+
+      // Get input connections from node.inputs
+      if (node.inputs) {
+        for (var ii = 0; ii < node.inputs.length; ii++) {
+          var inp = node.inputs[ii];
+          if (inp.link != null && linkMap[inp.link]) {
+            var lk = linkMap[inp.link];
+            inputs[inp.name] = [String(lk.from), lk.fromSlot];
+          }
+        }
+      }
+
+      // Get widget values — these are the non-connected inputs
+      if (node.widgets_values && node.widgets_values.length > 0) {
+        var widgetNames = this._getWidgetNames(node.type);
+        for (var wi = 0; wi < node.widgets_values.length && wi < widgetNames.length; wi++) {
+          var wName = widgetNames[wi];
+          if (!inputs[wName]) {
+            inputs[wName] = node.widgets_values[wi];
+          }
+        }
+      }
+
+      api[String(node.id)] = {
+        class_type: node.type,
+        inputs: inputs,
+      };
+    }
+
+    return api;
+  }
+
+  // Map common node types to their widget parameter names
+  _getWidgetNames(classType) {
+    var maps = {
+      'CLIPTextEncode': ['text'],
+      'KSampler': ['seed', 'control_after_generate', 'steps', 'cfg', 'sampler_name', 'scheduler', 'denoise'],
+      'KSamplerAdvanced': ['add_noise', 'noise_seed', 'control_after_generate', 'steps', 'cfg', 'sampler_name', 'scheduler', 'start_at_step', 'end_at_step', 'return_with_leftover_noise'],
+      'EmptySD3LatentImage': ['width', 'height', 'batch_size'],
+      'EmptyLatentImage': ['width', 'height', 'batch_size'],
+      'UnetLoaderGGUF': ['unet_name'],
+      'UNETLoader': ['unet_name', 'weight_dtype'],
+      'DualCLIPLoader': ['clip_name1', 'clip_name2', 'type'],
+      'CLIPLoader': ['clip_name', 'type'],
+      'VAELoader': ['vae_name'],
+      'VAEDecode': [],
+      'SaveImage': ['filename_prefix'],
+      'SaveVideo': ['output_path', 'filename_prefix'],
+      'LoadImage': ['image', 'upload'],
+      'ModelSamplingSD3': ['shift'],
+      'WanImageToVideo': ['width', 'height', 'length', 'batch_size'],
+      'CreateVideo': ['frame_rate'],
+      'UpscaleModelLoader': ['model_name'],
+      'ImageUpscaleWithModel': [],
+      'LoraLoaderModelOnly': ['lora_name', 'strength_model'],
+    };
+    return maps[classType] || [];
+  }
+
+  // Inject prompt text into the workflow (replace CLIPTextEncode positive prompt)
+  _injectPrompt(apiWorkflow, prompt, negativePrompt) {
+    var positiveFound = false;
+    for (var nodeId in apiWorkflow) {
+      var node = apiWorkflow[nodeId];
+      if (node.class_type === 'CLIPTextEncode' && node.inputs) {
+        if (!positiveFound && node.inputs.text) {
+          // First CLIPTextEncode = positive prompt (unless it looks negative)
+          var existing = (node.inputs.text || '').toLowerCase();
+          if (existing.indexOf('blur') !== -1 || existing.indexOf('bad') !== -1 || existing.indexOf('ugly') !== -1 || existing.indexOf('overexposed') !== -1) {
+            // This is the negative prompt node — set negative if provided
+            if (negativePrompt) node.inputs.text = negativePrompt;
+            continue;
+          }
+          node.inputs.text = prompt;
+          positiveFound = true;
+        } else if (positiveFound && negativePrompt) {
+          // Second CLIPTextEncode after positive = negative
+          node.inputs.text = negativePrompt;
+        }
+      }
+    }
+    return apiWorkflow;
+  }
+
+  async generate(prompt, options) {
+    options = options || {};
+    var workflowName = options.workflow || this.model || 'flux_text_to_image';
+
+    // Load workflow
+    var workflow = this._loadWorkflow(workflowName);
+    if (!workflow) {
+      throw new Error('Workflow not found: ' + workflowName + '. Available: ' + this.listWorkflows().map(function(w) { return w.name; }).join(', '));
+    }
+
+    // Convert to API format and inject prompt
+    var apiWorkflow = this._toApiFormat(workflow);
+    this._injectPrompt(apiWorkflow, prompt, options.negativePrompt || '');
+
+    // Randomize seed
+    for (var nid in apiWorkflow) {
+      var n = apiWorkflow[nid];
+      if (n.inputs && (n.inputs.seed !== undefined || n.inputs.noise_seed !== undefined)) {
+        var seedKey = n.inputs.seed !== undefined ? 'seed' : 'noise_seed';
+        n.inputs[seedKey] = Math.floor(Math.random() * 2147483647);
+      }
+    }
+
+    // Queue the prompt
+    var promptId = await this._queuePrompt(apiWorkflow);
+    if (!promptId) throw new Error('Failed to queue ComfyUI prompt');
+
+    // Poll for completion
+    var result = await this._waitForResult(promptId);
+    if (!result) throw new Error('ComfyUI generation timed out');
+
+    // Download the output
+    if (result.images && result.images.length > 0) {
+      var img = result.images[0];
+      var imageData = await this._downloadOutput(img.filename, img.subfolder, img.type);
+      return {
+        type: 'image',
+        data: imageData.toString('base64'),
+        format: img.filename.endsWith('.png') ? 'png' : 'jpg',
+        model: workflowName,
+        prompt: prompt,
+      };
+    }
+
+    if (result.videos && result.videos.length > 0) {
+      var vid = result.videos[0];
+      var videoData = await this._downloadOutput(vid.filename, vid.subfolder, vid.type);
+      return {
+        type: 'image', // treat as image for now (thumbnail)
+        data: videoData.toString('base64'),
+        format: 'mp4',
+        model: workflowName,
+        prompt: prompt,
+      };
+    }
+
+    if (result.gltf && result.gltf.length > 0) {
+      return {
+        type: 'text',
+        data: '3D model generated: ' + result.gltf[0].filename,
+        model: workflowName,
+        prompt: prompt,
+      };
+    }
+
+    throw new Error('No output from ComfyUI');
+  }
+
+  _queuePrompt(apiWorkflow) {
+    var url = new URL(this.endpoint);
+    var transport = url.protocol === 'https:' ? https : http;
+    var body = JSON.stringify({ prompt: apiWorkflow });
+    var self = this;
+
+    return new Promise(function(resolve, reject) {
+      var req = transport.request({
+        hostname: url.hostname,
+        port: url.port || DEFAULT_PORT,
+        path: '/prompt',
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        timeout: 30000,
+      }, function(res) {
+        var data = '';
+        res.on('data', function(c) { data += c; });
+        res.on('end', function() {
+          try {
+            var r = JSON.parse(data);
+            if (r.error) { reject(new Error('ComfyUI error: ' + (r.error.message || JSON.stringify(r.error)))); return; }
+            resolve(r.prompt_id || null);
+          } catch (e) { reject(new Error('Invalid ComfyUI response')); }
+        });
+      });
+      req.on('error', function(e) { reject(new Error('ComfyUI connection failed: ' + e.message + '. Is ComfyUI running?')); });
+      req.on('timeout', function() { req.destroy(); reject(new Error('ComfyUI queue timeout')); });
+      req.write(body);
+      req.end();
+    });
+  }
+
+  _waitForResult(promptId) {
+    var self = this;
+    var maxWait = 300000; // 5 minutes max
+    var pollInterval = 2000;
+    var elapsed = 0;
+
+    return new Promise(function(resolve, reject) {
+      var timer = setInterval(function() {
+        elapsed += pollInterval;
+        if (elapsed > maxWait) {
+          clearInterval(timer);
+          reject(new Error('ComfyUI generation timed out (5 min)'));
+          return;
+        }
+
+        self._checkHistory(promptId).then(function(result) {
+          if (result) {
+            clearInterval(timer);
+            resolve(result);
+          }
+        }).catch(function() {
+          // ignore polling errors, keep trying
+        });
+      }, pollInterval);
+    });
+  }
+
+  _checkHistory(promptId) {
+    var url = new URL(this.endpoint);
+    var transport = url.protocol === 'https:' ? https : http;
+
+    return new Promise(function(resolve, reject) {
+      var req = transport.request({
+        hostname: url.hostname,
+        port: url.port || DEFAULT_PORT,
+        path: '/history/' + promptId,
+        method: 'GET',
+        timeout: 10000,
+      }, function(res) {
+        var data = '';
+        res.on('data', function(c) { data += c; });
+        res.on('end', function() {
+          try {
+            var history = JSON.parse(data);
+            var entry = history[promptId];
+            if (!entry || !entry.outputs) { resolve(null); return; }
+
+            // Collect outputs
+            var images = [];
+            var videos = [];
+            var gltf = [];
+
+            for (var nodeId in entry.outputs) {
+              var out = entry.outputs[nodeId];
+              if (out.images) images = images.concat(out.images);
+              if (out.videos) videos = videos.concat(out.videos);
+              if (out.gltf) gltf = gltf.concat(out.gltf);
+            }
+
+            if (images.length > 0 || videos.length > 0 || gltf.length > 0) {
+              resolve({ images: images, videos: videos, gltf: gltf });
+            } else {
+              resolve(null); // not done yet
+            }
+          } catch (e) { resolve(null); }
+        });
+      });
+      req.on('error', function() { resolve(null); });
+      req.on('timeout', function() { req.destroy(); resolve(null); });
+      req.end();
+    });
+  }
+
+  _downloadOutput(filename, subfolder, type) {
+    var url = new URL(this.endpoint);
+    var transport = url.protocol === 'https:' ? https : http;
+    var queryPath = '/view?filename=' + encodeURIComponent(filename);
+    if (subfolder) queryPath += '&subfolder=' + encodeURIComponent(subfolder);
+    if (type) queryPath += '&type=' + encodeURIComponent(type);
+
+    return new Promise(function(resolve, reject) {
+      var req = transport.request({
+        hostname: url.hostname,
+        port: url.port || DEFAULT_PORT,
+        path: queryPath,
+        method: 'GET',
+        timeout: 60000,
+      }, function(res) {
+        var chunks = [];
+        res.on('data', function(c) { chunks.push(c); });
+        res.on('end', function() { resolve(Buffer.concat(chunks)); });
+      });
+      req.on('error', function(e) { reject(new Error('Failed to download ComfyUI output: ' + e.message)); });
+      req.on('timeout', function() { req.destroy(); reject(new Error('Download timeout')); });
+      req.end();
+    });
+  }
+
+  async checkHealth() {
+    var url = new URL(this.endpoint);
+    var transport = url.protocol === 'https:' ? https : http;
+    return new Promise(function(resolve) {
+      var req = transport.request({
+        hostname: url.hostname,
+        port: url.port || DEFAULT_PORT,
+        path: '/system_stats',
+        method: 'GET',
+        timeout: 5000,
+      }, function(res) {
+        var data = '';
+        res.on('data', function(c) { data += c; });
+        res.on('end', function() { resolve(res.statusCode === 200); });
+      });
+      req.on('error', function() { resolve(false); });
+      req.on('timeout', function() { req.destroy(); resolve(false); });
+      req.end();
+    });
+  }
+
+  async listModels() {
+    return this.listWorkflows().map(function(w) {
+      return { name: w.name, size: 'local', description: 'ComfyUI workflow' };
+    });
+  }
+}
+
+module.exports = { ComfyUIProvider };