meshy-node 0.1.3 → 0.1.4

package/main.cjs

@@ -4619,7 +4619,7 @@ var require_helpers = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.req = exports2.json = exports2.toBuffer = void 0;
-    var http4 = __importStar(require("http"));
+    var http3 = __importStar(require("http"));
     var https2 = __importStar(require("https"));
     async function toBuffer(stream) {
       let length = 0;
@@ -4645,7 +4645,7 @@ var require_helpers = __commonJS({
     exports2.json = json;
     function req(url, opts = {}) {
       const href = typeof url === "string" ? url : url.href;
-      const req2 = (href.startsWith("https:") ? https2 : http4).request(url, opts);
+      const req2 = (href.startsWith("https:") ? https2 : http3).request(url, opts);
       const promise = new Promise((resolve11, reject) => {
         req2.once("response", resolve11).once("error", reject).end();
       });
@@ -4693,11 +4693,11 @@ var require_dist = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.Agent = void 0;
     var net = __importStar(require("net"));
-    var http4 = __importStar(require("http"));
+    var http3 = __importStar(require("http"));
     var https_1 = require("https");
     __exportStar(require_helpers(), exports2);
     var INTERNAL = /* @__PURE__ */ Symbol("AgentBaseInternalState");
-    var Agent = class extends http4.Agent {
+    var Agent = class extends http3.Agent {
       constructor(opts) {
         super(opts);
         this[INTERNAL] = {};
@@ -4769,7 +4769,7 @@ var require_dist = __commonJS({
         const fakeSocket = this.incrementSockets(name2);
         Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
           this.decrementSockets(name2, fakeSocket);
-          if (socket instanceof http4.Agent) {
+          if (socket instanceof http3.Agent) {
             try {
               return socket.addRequest(req, connectOpts);
             } catch (err) {
@@ -23145,10 +23145,10 @@ var require_layer = __commonJS({
 var require_methods = __commonJS({
   "../../node_modules/.pnpm/methods@1.1.2/node_modules/methods/index.js"(exports2, module2) {
     "use strict";
-    var http4 = require("http");
+    var http3 = require("http");
     module2.exports = getCurrentNodeMethods() || getBasicNodeMethods();
     function getCurrentNodeMethods() {
-      return http4.METHODS && http4.METHODS.map(function lowerCaseMethod(method) {
+      return http3.METHODS && http3.METHODS.map(function lowerCaseMethod(method) {
         return method.toLowerCase();
       });
     }
@@ -25766,7 +25766,7 @@ var require_application = __commonJS({
     var query = require_query();
     var debug = require_src2()("express:application");
     var View = require_view();
-    var http4 = require("http");
+    var http3 = require("http");
     var compileETag = require_utils2().compileETag;
     var compileQueryParser = require_utils2().compileQueryParser;
     var compileTrust = require_utils2().compileTrust;
@@ -26015,7 +26015,7 @@ var require_application = __commonJS({
       tryRender(view, renderOptions, done);
     };
     app.listen = function listen() {
-      var server = http4.createServer(this);
+      var server = http3.createServer(this);
       return server.listen.apply(server, arguments);
     };
     function logerror(err) {
@@ -26617,12 +26617,12 @@ var require_request = __commonJS({
     var deprecate = require_depd()("express");
     var isIP = require("net").isIP;
     var typeis = require_type_is();
-    var http4 = require("http");
+    var http3 = require("http");
     var fresh = require_fresh();
     var parseRange = require_range_parser();
     var parse = require_parseurl();
     var proxyaddr = require_proxy_addr();
-    var req = Object.create(http4.IncomingMessage.prototype);
+    var req = Object.create(http3.IncomingMessage.prototype);
     module2.exports = req;
     req.get = req.header = function header(name2) {
       if (!name2) {
@@ -27044,7 +27044,7 @@ var require_response = __commonJS({
     var deprecate = require_depd()("express");
     var encodeUrl = require_encodeurl();
     var escapeHtml = require_escape_html();
-    var http4 = require("http");
+    var http3 = require("http");
     var isAbsolute4 = require_utils2().isAbsolute;
     var onFinished = require_on_finished();
     var path17 = require("path");
@@ -27060,7 +27060,7 @@ var require_response = __commonJS({
     var mime = send.mime;
     var resolve11 = path17.resolve;
     var vary = require_vary();
-    var res = Object.create(http4.ServerResponse.prototype);
+    var res = Object.create(http3.ServerResponse.prototype);
     module2.exports = res;
     var charsetRegExp = /;\s*charset\s*=/;
     res.status = function status(code) {
@@ -27784,7 +27784,6 @@ __export(main_exports, {
   shouldSkipStartupRequirementsCheck: () => shouldSkipStartupRequirementsCheck
 });
 module.exports = __toCommonJS(main_exports);
-var http3 = __toESM(require("http"), 1);
 var nodePath = __toESM(require("path"), 1);
 
 // ../../packages/core/src/logger.ts
@@ -32704,8 +32703,7 @@ function parseNodeInfo(value) {
     lastHeartbeat: value.lastHeartbeat,
     transportType: typeof value.transportType === "string" ? value.transportType : void 0,
     devtunnelEndpoint: typeof value.devtunnelEndpoint === "string" ? value.devtunnelEndpoint : void 0,
-    dashboardOrigin: typeof value.dashboardOrigin === "string" ? value.dashboardOrigin : void 0,
-    previewOrigin: typeof value.previewOrigin === "string" ? value.previewOrigin : void 0
+    dashboardOrigin: typeof value.dashboardOrigin === "string" ? value.dashboardOrigin : void 0
   };
 }
 function parseTask(value) {
@@ -32990,24 +32988,6 @@ var NodeRegistry = class {
       }
     }
   }
-  updatePreviewOrigin(id, previewOrigin) {
-    const node = this.nodes.get(id);
-    if (node) {
-      if (previewOrigin) {
-        node.previewOrigin = previewOrigin;
-      } else {
-        delete node.previewOrigin;
-      }
-      this.store.upsertNode(node);
-    }
-    if (this.selfNode && this.selfNode.id === id) {
-      if (previewOrigin) {
-        this.selfNode.previewOrigin = previewOrigin;
-      } else {
-        delete this.selfNode.previewOrigin;
-      }
-    }
-  }
   // -- Self --------------------------------------------------------------
   setSelf(info) {
     this.selfNode = { ...info };
@@ -34139,7 +34119,6 @@ var HeartbeatMonitor = class {
           this.nodeRegistry.updateLoad(node.id, result.load);
           this.applyReportedDevTunnelState(node.id, result.devtunnelEnabled, result.devtunnelEndpoint);
           this.nodeRegistry.updateDashboardOrigin(node.id, result.dashboardOrigin);
-          this.nodeRegistry.updatePreviewOrigin(node.id, result.previewOrigin);
           if (result.workDirFolders) {
             this.nodeRegistry.updateFolders(node.id, result.workDirFolders);
           }
@@ -34205,7 +34184,6 @@ var HeartbeatMonitor = class {
       devtunnelEnabled: self2.devtunnelEndpoint !== void 0,
       devtunnelEndpoint: self2.devtunnelEndpoint,
       dashboardOrigin: self2.dashboardOrigin,
-      previewOrigin: self2.previewOrigin,
       workDirFolders: self2.workDir ? listWorkDirFolders(self2.workDir) : void 0
     };
     return response;
@@ -34224,7 +34202,6 @@ var HeartbeatMonitor = class {
       devtunnelEnabled,
       devtunnelEndpoint,
       dashboardOrigin,
-      previewOrigin,
       workDirFolders
     } = req;
     const existingNode = this.nodeRegistry.getNode(nodeId);
@@ -34249,7 +34226,6 @@ var HeartbeatMonitor = class {
         ...workDir ? { workDir } : {},
         ...devtunnelEnabled && devtunnelEndpoint ? { devtunnelEndpoint } : {},
         ...dashboardOrigin ? { dashboardOrigin } : {},
-        ...previewOrigin ? { previewOrigin } : {},
         ...workDirFolders ? { workDirFolders } : {}
       });
       this.log.info("keepalive restored missing follower", { nodeId, endpoint: normalizedEndpoint });
@@ -34283,7 +34259,6 @@ var HeartbeatMonitor = class {
     this.nodeRegistry.updateLoad(nodeId, load);
     this.applyReportedDevTunnelState(nodeId, devtunnelEnabled, devtunnelEndpoint);
     this.nodeRegistry.updateDashboardOrigin(nodeId, dashboardOrigin);
-    this.nodeRegistry.updatePreviewOrigin(nodeId, previewOrigin);
     if (workDirFolders) {
       this.nodeRegistry.updateFolders(nodeId, workDirFolders);
     }
@@ -34341,7 +34316,6 @@ var HeartbeatMonitor = class {
       devtunnelEnabled: self2.devtunnelEndpoint !== void 0,
       devtunnelEndpoint: self2.devtunnelEndpoint,
       dashboardOrigin: self2.dashboardOrigin,
-      previewOrigin: self2.previewOrigin,
       workDirFolders: self2.workDir ? listWorkDirFolders(self2.workDir) : void 0
     };
     this.log.debug("sending keepalive request", {
@@ -34667,7 +34641,8 @@ var EXCLUDED_PATH_PREFIXES = [
   "/api/cluster/"
 ];
 var EXCLUDED_PATH_SUFFIXES = [
-  "/devtunnel"
+  "/devtunnel",
+  "/output/preview-sessions"
 ];
 var WRITE_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
 var DataRouter = class {
@@ -35854,6 +35829,18 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
   }
   async joinCluster(seedUrl) {
     const log2 = this.logger.child("node/join-cluster");
+    const currentSelf = this.nodeRegistry.getSelf();
+    if (this.config.transport.type !== "devtunnel" && !currentSelf.devtunnelEndpoint && !this.devtunnelTransport) {
+      log2.info("enabling anonymous node tunnel before cluster join", {
+        seedUrl,
+        transportType: this.config.transport.type
+      });
+      const devtunnelEndpoint = await this.enableDevTunnel();
+      log2.info("enabled anonymous node tunnel before cluster join", {
+        seedUrl,
+        devtunnelEndpoint
+      });
+    }
     const tasks = this.taskEngine.listTasks().tasks;
     const self2 = this.nodeRegistry.getSelf();
     const joinBody = {
@@ -35872,17 +35859,13 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
     if (self2.dashboardOrigin) {
       joinBody.dashboardOrigin = self2.dashboardOrigin;
     }
-    if (self2.previewOrigin) {
-      joinBody.previewOrigin = self2.previewOrigin;
-    }
     log2.info("sending cluster join request", {
       seedUrl,
       nodeId: self2.id,
       endpoint: self2.endpoint,
       taskCount: tasks.length,
       hasDevTunnel: !!self2.devtunnelEndpoint,
-      hasDashboardOrigin: !!self2.dashboardOrigin,
-      hasPreviewOrigin: !!self2.previewOrigin
+      hasDashboardOrigin: !!self2.dashboardOrigin
     });
     let response;
     try {
@@ -36069,6 +36052,27 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
   getTransportType() {
     return this.config.transport.type;
   }
+  hasPublishedNodeTunnel() {
+    return this.config.transport.type === "devtunnel" || this.devtunnelTransport !== null;
+  }
+  async isPublishedNodeTunnelHealthy() {
+    if (this.config.transport.type === "devtunnel") {
+      return this.transport.isHealthy();
+    }
+    if (this.devtunnelTransport) {
+      return this.devtunnelTransport.isHealthy();
+    }
+    return true;
+  }
+  async restartPublishedNodeTunnel() {
+    if (this.config.transport.type === "devtunnel") {
+      return this.restartPrimaryTransport();
+    }
+    if (this.devtunnelTransport) {
+      return this.restartDevTunnelSidecar();
+    }
+    return void 0;
+  }
   async switchTransport(transportType) {
     if (this.config.transport.type === transportType && this.transport) {
       return this.transport.getEndpoint();
@@ -36172,8 +36176,7 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
       workDir: currentSelf.workDir,
       workDirFolders: listWorkDirFolders(this.getWorkDir()),
       ...currentSelf.devtunnelEndpoint ? { devtunnelEndpoint: currentSelf.devtunnelEndpoint } : {},
-      ...currentSelf.dashboardOrigin ? { dashboardOrigin: currentSelf.dashboardOrigin } : {},
-      ...currentSelf.previewOrigin ? { previewOrigin: currentSelf.previewOrigin } : {}
+      ...currentSelf.dashboardOrigin ? { dashboardOrigin: currentSelf.dashboardOrigin } : {}
     };
     this.selfInfo = nextSelf;
     this.nodeRegistry.setSelf(nextSelf);
@@ -36209,6 +36212,64 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
       }
     };
   }
+  async restartPrimaryTransport() {
+    const nextTransportConfig = this.resolveTransportConfig(this.config.transport.type, this.selfInfo.id);
+    const previousTransport = this.transport;
+    let nextTransport = null;
+    await previousTransport.stop().catch(() => void 0);
+    try {
+      nextTransport = this.transportFactory(nextTransportConfig);
+      await nextTransport.start(this.config.node.port);
+      const nextEndpoint = await nextTransport.getEndpoint();
+      this.transport = nextTransport;
+      this.selfInfo.endpoint = nextEndpoint;
+      this.selfInfo.transportType = this.config.transport.type;
+      this.nodeRegistry.updateEndpoint(this.selfInfo.id, nextEndpoint);
+      this.eventBus.emit("transport.changed", {
+        nodeId: this.selfInfo.id,
+        transportType: this.config.transport.type,
+        endpoint: nextEndpoint
+      });
+      return nextEndpoint;
+    } catch (err) {
+      if (nextTransport) {
+        await nextTransport.stop().catch(() => void 0);
+      }
+      this.transport = previousTransport;
+      throw err;
+    }
+  }
+  async restartDevTunnelSidecar() {
+    if (!this.devtunnelTransport) {
+      throw new Error("DevTunnel sidecar is not enabled");
+    }
+    const previousTransport = this.devtunnelTransport;
+    const tunnelConfig = this.resolveStableDevTunnelConfig("sidecar", this.selfInfo.id);
+    let nextTransport = null;
+    await previousTransport.stop().catch(() => void 0);
+    try {
+      nextTransport = this.transportFactory(tunnelConfig);
+      await nextTransport.start(this.config.node.port);
+      const devtunnelEndpoint = await nextTransport.getEndpoint();
+      this.devtunnelTransport = nextTransport;
+      this.syncSelfInfoFromRegistry();
+      this.selfInfo.devtunnelEndpoint = devtunnelEndpoint;
+      this.nodeRegistry.setSelf(this.selfInfo);
+      this.nodeRegistry.updateDevTunnelEndpoint(this.selfInfo.id, devtunnelEndpoint);
+      this.eventBus.emit("transport.changed", {
+        nodeId: this.selfInfo.id,
+        transportType: "devtunnel",
+        endpoint: devtunnelEndpoint
+      });
+      return devtunnelEndpoint;
+    } catch (err) {
+      if (nextTransport) {
+        await nextTransport.stop().catch(() => void 0);
+      }
+      this.devtunnelTransport = previousTransport;
+      throw err;
+    }
+  }
   /**
    * Handle a task received via pull-based dispatch (keepalive channel).
    * Mirrors the logic of POST /api/worker/execute but without the HTTP layer.
@@ -40408,8 +40469,7 @@ var NodeInfoSchema = external_exports.object({
   lastHeartbeat: external_exports.number(),
   transportType: external_exports.string().optional(),
   devtunnelEndpoint: external_exports.string().optional(),
-  dashboardOrigin: external_exports.string().optional(),
-  previewOrigin: external_exports.string().optional()
+  dashboardOrigin: external_exports.string().optional()
 });
 var JoinTaskSchema = external_exports.object({
   id: external_exports.string(),
@@ -40441,7 +40501,6 @@ var JoinClusterBody = external_exports.object({
   workDirFolders: external_exports.array(external_exports.string()).optional(),
   devtunnelEndpoint: external_exports.string().url().optional(),
   dashboardOrigin: external_exports.string().url().optional(),
-  previewOrigin: external_exports.string().url().optional(),
   tasks: external_exports.array(JoinTaskSchema).default([])
 });
 var JoinClusterResponse = external_exports.object({
@@ -40484,7 +40543,6 @@ var NodeInfoSchema2 = external_exports.object({
   transportType: external_exports.string().optional(),
   devtunnelEndpoint: external_exports.string().optional(),
   dashboardOrigin: external_exports.string().optional(),
-  previewOrigin: external_exports.string().optional(),
   workDir: external_exports.string().optional(),
   workDirFolders: external_exports.array(external_exports.string()).optional()
 });
@@ -40935,8 +40993,7 @@ function createClusterRoutes() {
       endpoint: body.endpoint,
       taskCount: body.tasks?.length ?? 0,
       hasDevTunnel: !!body.devtunnelEndpoint,
-      hasDashboardOrigin: !!body.dashboardOrigin,
-      hasPreviewOrigin: !!body.previewOrigin
+      hasDashboardOrigin: !!body.dashboardOrigin
     });
     const existingNodes = nodeRegistry.getAllNodes();
     let removedCount = 0;
@@ -40959,8 +41016,7 @@ function createClusterRoutes() {
       ...body.workDir && { workDir: body.workDir },
       ...body.workDirFolders && { workDirFolders: body.workDirFolders },
       ...body.devtunnelEndpoint && { devtunnelEndpoint: body.devtunnelEndpoint },
-      ...body.dashboardOrigin && { dashboardOrigin: body.dashboardOrigin },
-      ...body.previewOrigin && { previewOrigin: body.previewOrigin }
+      ...body.dashboardOrigin && { dashboardOrigin: body.dashboardOrigin }
     };
     nodeRegistry.addNode(node);
     taskEngine.importTasks(body.tasks ?? []);
@@ -41467,9 +41523,6 @@ function computeParentPath(rootPath, currentPath, useAbsolute) {
 }
 
 // ../../packages/api/src/routes/node-workdir.ts
-function asyncHandler2(fn) {
-  return (req, res, next) => fn(req, res, next).catch(next);
-}
 function sendLocalNodeWorkDirTree(req, res, nodeId, options = {}) {
   const query = NodeWorkDirTreeQuery.parse(req.query);
   const { nodeRegistry, workDir } = req.app.locals.deps;
@@ -41489,13 +41542,6 @@ function sendLocalNodeWorkDirTree(req, res, nodeId, options = {}) {
     }
   ));
 }
-function createLocalNodeWorkDirRoutes(options = {}) {
-  const router = (0, import_express2.Router)();
-  router.get("/:id/workdir/tree", asyncHandler2(async (req, res) => {
-    sendLocalNodeWorkDirTree(req, res, req.params.id, options);
-  }));
-  return router;
-}
 
 // ../../packages/api/src/task-route-utils.ts
 var fs11 = __toESM(require("fs"), 1);
@@ -41686,42 +41732,26 @@ var MIME_MAP2 = {
 function getMime(filePath) {
   return MIME_MAP2[path13.extname(filePath).toLowerCase()] ?? "application/octet-stream";
 }
-function handlePreviewRequest(sessionManager, req, res) {
-  const url = new URL(req.url ?? "/", "http://localhost");
-  if (!url.pathname.startsWith("/preview/")) {
-    return false;
-  }
-  if (req.method !== "GET") {
-    res.writeHead(405, { "Content-Type": "text/plain" });
-    res.end("Method not allowed");
-    return true;
-  }
-  const match = url.pathname.match(/^\/preview\/([a-f0-9]+)(?:\/(.*))?$/i);
-  const token = match?.[1];
-  if (!token) {
-    res.writeHead(404, { "Content-Type": "text/plain" });
-    res.end("Preview not found");
-    return true;
-  }
+function sendPreviewAssetResponse(sessionManager, token, requestedPath, res) {
   const session = sessionManager.get(token);
   if (!session) {
     res.writeHead(403, { "Content-Type": "text/plain" });
     res.end("Invalid or expired preview token");
-    return true;
+    return;
   }
-  const requestedPath = decodeURIComponent(match?.[2] ?? session.entryPath);
+  const resolvedRequestedPath = decodeURIComponent(requestedPath ?? session.entryPath);
   let resolved;
   try {
-    resolved = resolvePreviewPath(session.rootPath, requestedPath).absolutePath;
+    resolved = resolvePreviewPath(session.rootPath, resolvedRequestedPath).absolutePath;
   } catch {
     res.writeHead(400, { "Content-Type": "text/plain" });
     res.end("Invalid path");
-    return true;
+    return;
   }
   if (!fs12.existsSync(resolved) || !fs12.statSync(resolved).isFile()) {
     res.writeHead(404, { "Content-Type": "text/plain" });
     res.end("File not found");
-    return true;
+    return;
   }
   const mime = getMime(resolved);
   const content = fs12.readFileSync(resolved);
@@ -41731,6 +41761,115 @@ function handlePreviewRequest(sessionManager, req, res) {
     "Cache-Control": "no-cache"
   });
   res.end(content);
+}
+function handlePreviewRequest(sessionManager, req, res) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  if (!url.pathname.startsWith("/preview/")) {
+    return false;
+  }
+  if (req.method !== "GET") {
+    res.writeHead(405, { "Content-Type": "text/plain" });
+    res.end("Method not allowed");
+    return true;
+  }
+  const match = url.pathname.match(/^\/preview\/([a-f0-9]+)(?:\/(.*))?$/i);
+  const token = match?.[1];
+  if (!token) {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Preview not found");
+    return true;
+  }
+  sendPreviewAssetResponse(sessionManager, token, match?.[2], res);
+  return true;
+}
+
+// ../../packages/api/src/preview/preview-proxy.ts
+function parsePreviewRequest(previewUrl) {
+  const pathname = new URL(previewUrl, "http://localhost").pathname;
+  const match = pathname.match(/^\/preview\/([a-f0-9]+)(?:\/(.*))?$/i);
+  const token = match?.[1];
+  if (!token) {
+    return null;
+  }
+  return {
+    token,
+    requestedPath: match?.[2]
+  };
+}
+function extractPreviewToken(previewUrl) {
+  return parsePreviewRequest(previewUrl)?.token ?? null;
+}
+function buildPreviewAssetProxyPath(token, requestedPath) {
+  const search = new URLSearchParams({ token });
+  if (requestedPath) {
+    search.set("path", decodeURIComponent(requestedPath));
+  }
+  return `/api/worker/preview-asset?${search.toString()}`;
+}
+var PreviewProxyManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  register(token, nodeId, expiresAt) {
+    this.sessions.set(token, { token, nodeId, expiresAt });
+  }
+  get(token) {
+    const session = this.sessions.get(token);
+    if (!session) {
+      return null;
+    }
+    if (Date.now() > session.expiresAt) {
+      this.sessions.delete(token);
+      return null;
+    }
+    return session;
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [token, session] of this.sessions) {
+      if (session.expiresAt <= now) {
+        this.sessions.delete(token);
+      }
+    }
+  }
+};
+function rewritePreviewSessionPayloadForProxy(manager, payload, nodeId) {
+  const token = extractPreviewToken(payload.previewUrl);
+  if (!token) {
+    return payload;
+  }
+  manager.register(token, nodeId, payload.expiresAt);
+  return {
+    ...payload,
+    previewUrl: buildPreviewUrl("", {
+      token,
+      entryPath: payload.entryPath
+    })
+  };
+}
+async function handlePreviewProxyRequest(manager, nodeRegistry, logger27, req, res) {
+  const requestPath = req.originalUrl ?? req.url;
+  const previewRequest = parsePreviewRequest(requestPath);
+  if (!previewRequest) {
+    return false;
+  }
+  const session = manager.get(previewRequest.token);
+  if (!session) {
+    return false;
+  }
+  const node = nodeRegistry.getNode(session.nodeId);
+  if (!node) {
+    throw new MeshyError("NODE_NOT_FOUND", `Preview worker ${session.nodeId} not found`, 404);
+  }
+  const previewLog = logger27.child("preview-proxy");
+  const proxyPath = buildPreviewAssetProxyPath(previewRequest.token, previewRequest.requestedPath);
+  const { endpoint, response } = await fetchNodeWithFallback(node, proxyPath);
+  previewLog.debug("proxying preview asset from assigned worker", {
+    token: previewRequest.token,
+    nodeId: session.nodeId,
+    requestPath,
+    proxyPath,
+    endpoint
+  });
+  await sendProxyResponse(res, response);
   return true;
 }
 
@@ -41837,21 +41976,18 @@ function getLocalTaskOutputDiff(taskEngine, taskId) {
   const rootPath = getTaskOutputRoot(taskEngine, taskId);
   return getGitDiff(rootPath);
 }
-async function createPreviewSessionPayload(deps, taskId, entryPath) {
+async function createPreviewSessionPayload(deps, taskId, entryPath, requestOrigin) {
   const previewManager = deps.previewSessionManager;
   if (!previewManager) {
     throw new MeshyError("VALIDATION_ERROR", "Preview not available on this node", 400);
   }
-  if (!deps.previewPort) {
-    throw new MeshyError("VALIDATION_ERROR", "Preview server not running", 400);
-  }
   const rootPath = getTaskOutputRoot(deps.taskEngine, taskId);
   const session = previewManager.create({
     taskId,
     rootPath,
     entryPath
   });
-  const origin = deps.ensurePreviewOrigin ? await deps.ensurePreviewOrigin() ?? deps.previewOrigin : deps.previewOrigin;
+  const origin = requestOrigin ?? deps.dashboardOrigin ?? deps.localDashboardOrigin;
   if (!origin) {
     throw new MeshyError("VALIDATION_ERROR", "Preview origin not available", 502);
   }
@@ -42123,7 +42259,7 @@ function createNodeWorkdirProxyTrace(log2, nodeId, proxyPath) {
     }
   };
 }
-function asyncHandler3(fn) {
+function asyncHandler2(fn) {
   return (req, res, next) => fn(req, res, next).catch(next);
 }
 async function maybeHandleRemoteNodeWorkDirRequest(req, res, nodeId) {
@@ -42158,9 +42294,8 @@ async function maybeHandleRemoteNodeWorkDirRequest(req, res, nodeId) {
     return true;
   }
   try {
-    const proxyTarget = node.previewOrigin ? { endpoint: node.previewOrigin } : node;
     const { endpoint, response } = await fetchNodeWithFallback(
-      proxyTarget,
+      node,
       proxyPath,
       void 0,
       NODE_WORKDIR_PROXY_TIMEOUT_MS,
@@ -42197,7 +42332,7 @@ async function maybeHandleRemoteNodeWorkDirRequest(req, res, nodeId) {
 }
 function createNodeRoutes() {
   const router = (0, import_express3.Router)();
-  router.get("/", asyncHandler3(async (req, res) => {
+  router.get("/", asyncHandler2(async (req, res) => {
     const { nodeRegistry } = req.app.locals.deps;
     const query = NodeListQuery.parse(req.query);
     let nodes = nodeRegistry.getAllNodes();
@@ -42211,7 +42346,7 @@ function createNodeRoutes() {
     }
     res.json({ nodes });
   }));
-  router.get("/:id", asyncHandler3(async (req, res) => {
+  router.get("/:id", asyncHandler2(async (req, res) => {
     const { nodeRegistry } = req.app.locals.deps;
     const node = nodeRegistry.getNode(req.params.id);
     if (!node) {
@@ -42219,7 +42354,7 @@ function createNodeRoutes() {
     }
     res.json(node);
   }));
-  router.get("/:id/status", asyncHandler3(async (req, res) => {
+  router.get("/:id/status", asyncHandler2(async (req, res) => {
     const { nodeRegistry, taskEngine } = req.app.locals.deps;
     const node = nodeRegistry.getNode(req.params.id);
     if (!node) {
@@ -42234,7 +42369,7 @@ function createNodeRoutes() {
     }));
     res.json({ node, tasks: taskSummary });
   }));
-  router.get("/:id/workdir/tree", asyncHandler3(async (req, res) => {
+  router.get("/:id/workdir/tree", asyncHandler2(async (req, res) => {
     const nodeId = req.params.id;
     const handled = await maybeHandleRemoteNodeWorkDirRequest(req, res, nodeId);
     if (handled) {
@@ -42242,7 +42377,7 @@ function createNodeRoutes() {
     }
     sendLocalNodeWorkDirTree(req, res, nodeId);
   }));
-  router.patch("/:id", asyncHandler3(async (req, res) => {
+  router.patch("/:id", asyncHandler2(async (req, res) => {
     const { nodeRegistry, persistNodeNamePreference } = req.app.locals.deps;
     const updates = UpdateNodeBody.parse(req.body);
     const nodeId = req.params.id;
@@ -42265,7 +42400,7 @@ function createNodeRoutes() {
     }
     res.json(node);
   }));
-  router.delete("/:id", asyncHandler3(async (req, res) => {
+  router.delete("/:id", asyncHandler2(async (req, res) => {
     const { nodeRegistry, election } = req.app.locals.deps;
     if (!election.isLeader()) {
       throw new MeshyError("NOT_LEADER", "Only the leader node can delete nodes", 403);
@@ -42277,7 +42412,7 @@ function createNodeRoutes() {
     nodeRegistry.removeNode(req.params.id);
     res.json({ ok: true });
   }));
-  router.post("/:id/devtunnel", asyncHandler3(async (req, res) => {
+  router.post("/:id/devtunnel", asyncHandler2(async (req, res) => {
     const { nodeRegistry, election, heartbeat, enableDevTunnel, disableDevTunnel, taskEngine } = req.app.locals.deps;
     const self2 = nodeRegistry.getSelf();
     const targetId = req.params.id;
@@ -42444,9 +42579,71 @@ function startLocalTaskFollowUp(deps, task, content, assignedTo, metadata) {
 
 // ../../packages/api/src/routes/task-output.ts
 var import_express4 = __toESM(require_express2(), 1);
-function asyncHandler4(fn) {
+
+// ../../packages/api/src/request-origin.ts
+function getFirstHeaderValue(value) {
+  if (Array.isArray(value)) {
+    return getFirstHeaderValue(value[0]);
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const first = value.split(",")[0]?.trim();
+  return first ? first : void 0;
+}
+function getForwardedHeaderOrigin(req) {
+  const forwarded = getFirstHeaderValue(req.headers.forwarded);
+  if (!forwarded) {
+    return void 0;
+  }
+  let host;
+  let proto;
+  for (const segment of forwarded.split(";")) {
+    const [rawKey, rawValue] = segment.split("=", 2);
+    const key = rawKey?.trim().toLowerCase();
+    const value = rawValue?.trim().replace(/^"|"$/g, "");
+    if (!key || !value) {
+      continue;
+    }
+    if (key === "host" && !host) {
+      host = value;
+    }
+    if (key === "proto" && !proto) {
+      proto = value;
+    }
+  }
+  if (!host) {
+    return void 0;
+  }
+  return `${proto ?? req.protocol ?? "http"}://${host}`;
+}
+function resolveRequestOrigin(req) {
+  const forwardedOrigin = getForwardedHeaderOrigin(req);
+  if (forwardedOrigin) {
+    return forwardedOrigin;
+  }
+  const host = getFirstHeaderValue(req.headers["x-forwarded-host"]) ?? getFirstHeaderValue(req.headers.host) ?? req.get("host");
+  if (!host) {
+    return void 0;
+  }
+  const proto = getFirstHeaderValue(req.headers["x-forwarded-proto"]) ?? req.protocol ?? "http";
+  return `${proto}://${host}`;
+}
+
+// ../../packages/api/src/routes/task-output.ts
+function asyncHandler3(fn) {
   return (req, res, next) => fn(req, res, next).catch(next);
 }
+function isPreviewSessionPayload(value) {
+  return typeof value === "object" && value !== null && typeof value.previewUrl === "string" && typeof value.entryPath === "string" && typeof value.expiresAt === "number";
+}
+function rewritePreviewPayloadIfNeeded(req, nodeId, payload) {
+  const { previewProxyManager } = req.app.locals.deps;
+  if (!previewProxyManager) {
+    return payload;
+  }
+  return rewritePreviewSessionPayloadForProxy(previewProxyManager, payload, nodeId);
+}
 async function maybeHandleRemoteTaskOutputRequest(req, res, taskId, subPath, init, fallbackRequest) {
   const { taskEngine, nodeRegistry, heartbeat, logger: rootLogger } = req.app.locals.deps;
   const log2 = rootLogger.child("tasks/output");
@@ -42467,14 +42664,20 @@ async function maybeHandleRemoteTaskOutputRequest(req, res, taskId, subPath, ini
   if (!node) {
     throw new MeshyError("NODE_NOT_FOUND", `Assigned node ${assignedNodeId} not found`, 404);
   }
-  if (!node.previewOrigin) {
+  if (!node.endpoint && !node.devtunnelEndpoint) {
     if (fallbackRequest && heartbeat?.requestWorkerControl) {
-      log2.warn("task output server origin missing, falling back to keepalive control", {
+      log2.warn("worker output endpoint missing, falling back to keepalive control", {
         taskId,
         assignedTo: assignedNodeId,
         kind: fallbackRequest.kind
       });
       const controlResponse = await heartbeat.requestWorkerControl(assignedNodeId, fallbackRequest);
+      if (fallbackRequest.kind === "task-preview-session" && controlResponse.bodyEncoding === "json" && isPreviewSessionPayload(controlResponse.body)) {
+        res.status(controlResponse.statusCode).json(
+          rewritePreviewPayloadIfNeeded(req, assignedNodeId, controlResponse.body)
+        );
+        return true;
+      }
       sendWorkerControlResponse(res, controlResponse);
       return true;
     }
@@ -42484,31 +42687,44 @@ async function maybeHandleRemoteTaskOutputRequest(req, res, taskId, subPath, ini
   const proxyPath = `/api/tasks/${taskId}/output${subPath}${qs}`;
   try {
     const { endpoint, response: proxyRes } = await fetchNodeWithFallback(
-      { endpoint: node.previewOrigin },
+      node,
       proxyPath,
       init
     );
-    log2.debug("proxying task output request to worker output server", {
+    log2.debug("proxying task output request to worker node API", {
       taskId,
       assignedTo: assignedNodeId,
       proxyPath,
-      outputOrigin: endpoint
+      outputEndpoint: endpoint
     });
+    if (fallbackRequest?.kind === "task-preview-session" && proxyRes.ok) {
+      const body = await proxyRes.json().catch(() => null);
+      if (isPreviewSessionPayload(body)) {
+        res.status(proxyRes.status).json(rewritePreviewPayloadIfNeeded(req, assignedNodeId, body));
+        return true;
+      }
+    }
     await sendProxyResponse(res, proxyRes);
     return true;
   } catch (err) {
     if (fallbackRequest && heartbeat?.requestWorkerControl) {
-      log2.warn("output server proxy failed, falling back to keepalive control", {
+      log2.warn("worker output proxy failed, falling back to keepalive control", {
         taskId,
         assignedTo: assignedNodeId,
         kind: fallbackRequest.kind,
         error: err instanceof Error ? err.message : String(err)
       });
       const controlResponse = await heartbeat.requestWorkerControl(assignedNodeId, fallbackRequest);
+      if (fallbackRequest.kind === "task-preview-session" && controlResponse.bodyEncoding === "json" && isPreviewSessionPayload(controlResponse.body)) {
+        res.status(controlResponse.statusCode).json(
+          rewritePreviewPayloadIfNeeded(req, assignedNodeId, controlResponse.body)
+        );
+        return true;
+      }
       sendWorkerControlResponse(res, controlResponse);
       return true;
     }
-    log2.warn("output server proxy error", {
+    log2.warn("worker output proxy error", {
       taskId,
       assignedTo: assignedNodeId,
       error: err instanceof Error ? err.message : String(err)
@@ -42519,7 +42735,7 @@ async function maybeHandleRemoteTaskOutputRequest(req, res, taskId, subPath, ini
 function createTaskOutputRoutes(options = {}) {
   const router = (0, import_express4.Router)();
   const allowRemoteProxy = options.allowRemoteProxy ?? true;
-  router.get("/:id/output", asyncHandler4(async (req, res) => {
+  router.get("/:id/output", asyncHandler3(async (req, res) => {
     const taskId = req.params.id;
     if (allowRemoteProxy) {
       const handled = await maybeHandleRemoteTaskOutputRequest(req, res, taskId, "", void 0, {
@@ -42533,7 +42749,7 @@ function createTaskOutputRoutes(options = {}) {
     const { taskEngine } = req.app.locals.deps;
     res.json(getLocalTaskOutputSummary(taskEngine, taskId));
   }));
-  router.get("/:id/output/tree", asyncHandler4(async (req, res) => {
+  router.get("/:id/output/tree", asyncHandler3(async (req, res) => {
     const taskId = req.params.id;
     const query = TaskOutputTreeQuery.parse(req.query);
     if (allowRemoteProxy) {
@@ -42549,7 +42765,7 @@ function createTaskOutputRoutes(options = {}) {
     const { taskEngine } = req.app.locals.deps;
     res.json(getLocalTaskOutputTree(taskEngine, taskId, query.path));
   }));
-  router.get("/:id/output/content", asyncHandler4(async (req, res) => {
+  router.get("/:id/output/content", asyncHandler3(async (req, res) => {
     const taskId = req.params.id;
     const query = TaskOutputContentQuery.parse(req.query);
     if (allowRemoteProxy) {
@@ -42565,7 +42781,7 @@ function createTaskOutputRoutes(options = {}) {
     const { taskEngine } = req.app.locals.deps;
     res.json(getLocalTaskOutputContent(taskEngine, taskId, query.path));
   }));
-  router.get("/:id/output/download", asyncHandler4(async (req, res) => {
+  router.get("/:id/output/download", asyncHandler3(async (req, res) => {
     const taskId = req.params.id;
     const query = TaskOutputDownloadQuery.parse(req.query);
     if (allowRemoteProxy) {
@@ -42585,7 +42801,7 @@ function createTaskOutputRoutes(options = {}) {
     }
     res.send(download.content);
   }));
-  router.get("/:id/output/diff", asyncHandler4(async (req, res) => {
+  router.get("/:id/output/diff", asyncHandler3(async (req, res) => {
     const taskId = req.params.id;
     if (allowRemoteProxy) {
       const handled = await maybeHandleRemoteTaskOutputRequest(req, res, taskId, "/diff", void 0, {
@@ -42599,7 +42815,7 @@ function createTaskOutputRoutes(options = {}) {
     const { taskEngine } = req.app.locals.deps;
     res.json(getLocalTaskOutputDiff(taskEngine, taskId));
   }));
-  router.post("/:id/output/preview-sessions", asyncHandler4(async (req, res) => {
+  router.post("/:id/output/preview-sessions", asyncHandler3(async (req, res) => {
     const taskId = req.params.id;
     const body = TaskPreviewSessionBody.parse(req.body ?? {});
     if (allowRemoteProxy) {
@@ -42616,7 +42832,7 @@ function createTaskOutputRoutes(options = {}) {
         return;
       }
     }
-    res.json(await createPreviewSessionPayload(req.app.locals.deps, taskId, body.path));
+    res.json(await createPreviewSessionPayload(req.app.locals.deps, taskId, body.path, resolveRequestOrigin(req)));
   }));
   return router;
 }
@@ -42625,7 +42841,7 @@ function createTaskOutputRoutes(options = {}) {
 var TERMINAL_STATUSES3 = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "archived"]);
 var ARCHIVABLE_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "archived"]);
 var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["pending", "assigned", "running"]);
-function asyncHandler5(fn) {
+function asyncHandler4(fn) {
   return (req, res, next) => fn(req, res, next).catch(next);
 }
 function withAssignedNodeMetadata(task, nodeRegistry) {
@@ -42641,7 +42857,7 @@ function withAssignedNodeMetadata(task, nodeRegistry) {
 }
 function createTaskRoutes() {
   const router = (0, import_express5.Router)();
-  router.post("/", asyncHandler5(async (req, res) => {
+  router.post("/", asyncHandler4(async (req, res) => {
     const { taskEngine, nodeRegistry } = req.app.locals.deps;
     const body = CreateTaskBody.parse(req.body);
     const task = taskEngine.createTask({
@@ -42660,7 +42876,7 @@ function createTaskRoutes() {
     }
     res.status(201).json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
-  router.get("/", asyncHandler5(async (req, res) => {
+  router.get("/", asyncHandler4(async (req, res) => {
     const { taskEngine, nodeRegistry } = req.app.locals.deps;
     const query = TaskListQuery.parse(req.query);
     const filter = {};
@@ -42675,7 +42891,7 @@ function createTaskRoutes() {
       total: result.total
     });
   }));
-  router.post("/batch/delete", asyncHandler5(async (req, res) => {
+  router.post("/batch/delete", asyncHandler4(async (req, res) => {
     const { taskEngine } = req.app.locals.deps;
     const { ids } = BatchTaskIdsBody.parse(req.body);
     const results = ids.map((id) => {
@@ -42688,7 +42904,7 @@ function createTaskRoutes() {
     });
     res.json({ results });
   }));
-  router.post("/batch/archive", asyncHandler5(async (req, res) => {
+  router.post("/batch/archive", asyncHandler4(async (req, res) => {
     const { taskEngine } = req.app.locals.deps;
     const { ids } = BatchTaskIdsBody.parse(req.body);
     const results = ids.map((id) => {
@@ -42706,7 +42922,7 @@ function createTaskRoutes() {
     });
     res.json({ results });
   }));
-  router.get("/:id", asyncHandler5(async (req, res) => {
+  router.get("/:id", asyncHandler4(async (req, res) => {
     const { taskEngine, nodeRegistry } = req.app.locals.deps;
     const task = taskEngine.getTask(req.params.id);
     if (!task) {
@@ -42714,7 +42930,7 @@ function createTaskRoutes() {
     }
     res.json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
-  router.patch("/:id", asyncHandler5(async (req, res) => {
+  router.patch("/:id", asyncHandler4(async (req, res) => {
     const { taskEngine, nodeRegistry, logger: rootLogger } = req.app.locals.deps;
     const log2 = rootLogger.child("tasks/patch");
     const updates = UpdateTaskBody.parse(req.body);
@@ -42753,7 +42969,7 @@ function createTaskRoutes() {
     }
     res.json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
-  router.delete("/:id", asyncHandler5(async (req, res) => {
+  router.delete("/:id", asyncHandler4(async (req, res) => {
     const { taskEngine } = req.app.locals.deps;
     const result = taskEngine.deleteTask(req.params.id);
     if (!result) {
@@ -42761,7 +42977,7 @@ function createTaskRoutes() {
     }
     res.json({ ok: true });
   }));
-  router.post("/:id/cancel", asyncHandler5(async (req, res) => {
+  router.post("/:id/cancel", asyncHandler4(async (req, res) => {
     const { taskEngine, nodeRegistry, engineRegistry, heartbeat, logger: rootLogger } = req.app.locals.deps;
     const log2 = rootLogger.child("tasks/cancel");
     const task = taskEngine.getTask(req.params.id);
@@ -42798,18 +43014,18 @@ function createTaskRoutes() {
     }, task.id);
     res.json({ ok: true });
   }));
-  router.post("/:id/assign", asyncHandler5(async (req, res) => {
+  router.post("/:id/assign", asyncHandler4(async (req, res) => {
     const { taskEngine, nodeRegistry } = req.app.locals.deps;
     const body = AssignTaskBody.parse(req.body);
     const task = taskEngine.assignTask(req.params.id, body.nodeId);
     res.json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
-  router.post("/:id/retry", asyncHandler5(async (req, res) => {
+  router.post("/:id/retry", asyncHandler4(async (req, res) => {
     const { taskEngine, nodeRegistry } = req.app.locals.deps;
     const task = taskEngine.retryTask(req.params.id);
     res.json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
-  router.get("/:id/logs", asyncHandler5(async (req, res) => {
+  router.get("/:id/logs", asyncHandler4(async (req, res) => {
     const { engineRegistry, taskEngine, nodeRegistry, logger: rootLogger } = req.app.locals.deps;
     const log2 = rootLogger.child("tasks/logs");
     const query = TaskLogsQuery.parse(req.query);
@@ -42876,7 +43092,7 @@ function createTaskRoutes() {
     });
     res.json(local);
   }));
-  router.post("/:id/message", asyncHandler5(async (req, res) => {
+  router.post("/:id/message", asyncHandler4(async (req, res) => {
     const { taskEngine, engineRegistry, nodeRegistry, heartbeat, logger: rootLogger } = req.app.locals.deps;
     const log2 = rootLogger.child("tasks/message");
     const body = SendMessageBody.parse(req.body);
@@ -42972,12 +43188,12 @@ var WorkerMessageBody = external_exports.object({
 var WorkerTaskBody = external_exports.object({
   taskId: external_exports.string().min(1)
 });
-function asyncHandler6(fn) {
+function asyncHandler5(fn) {
   return (req, res, next) => fn(req, res, next).catch(next);
 }
 function createWorkerRoutes() {
   const router = (0, import_express6.Router)();
-  router.post("/execute", asyncHandler6(async (req, res) => {
+  router.post("/execute", asyncHandler5(async (req, res) => {
     const { taskEngine, engineRegistry, nodeRegistry, eventBus, logger: rootLogger, workDir } = req.app.locals.deps;
     const log2 = rootLogger.child("worker/execute");
     const task = req.body;
@@ -43050,7 +43266,7 @@ function createWorkerRoutes() {
       }
     }
   }));
-  router.post("/message", asyncHandler6(async (req, res) => {
+  router.post("/message", asyncHandler5(async (req, res) => {
     const { engineRegistry, taskEngine, nodeRegistry, eventBus, logger: rootLogger } = req.app.locals.deps;
     const log2 = rootLogger.child("worker/message");
     const body = WorkerMessageBody.parse(req.body);
@@ -43093,7 +43309,7 @@ function createWorkerRoutes() {
     }
     res.json({ ok: true });
   }));
-  router.post("/cancel", asyncHandler6(async (req, res) => {
+  router.post("/cancel", asyncHandler5(async (req, res) => {
     const { taskEngine, engineRegistry, logger: rootLogger } = req.app.locals.deps;
     const log2 = rootLogger.child("worker/cancel");
     const body = WorkerTaskBody.parse(req.body);
@@ -43113,7 +43329,7 @@ function createWorkerRoutes() {
       terminal: result.terminal
     });
   }));
-  router.post("/output", asyncHandler6(async (req, res) => {
+  router.post("/output", asyncHandler5(async (req, res) => {
     const { eventBus, engineRegistry, taskEngine, logger: rootLogger } = req.app.locals.deps;
     const log2 = rootLogger.child("worker/output");
     const { taskId, event } = req.body;
@@ -43128,7 +43344,7 @@ function createWorkerRoutes() {
     }
     res.json({ ok: true });
   }));
-  router.post("/heartbeat", asyncHandler6(async (req, res) => {
+  router.post("/heartbeat", asyncHandler5(async (req, res) => {
     const { heartbeat, logger: rootLogger } = req.app.locals.deps;
     const log2 = rootLogger.child("worker/heartbeat");
     const body = req.body;
@@ -43145,7 +43361,7 @@ function createWorkerRoutes() {
     });
     res.json(response);
   }));
-  router.post("/keepalive", asyncHandler6(async (req, res) => {
+  router.post("/keepalive", asyncHandler5(async (req, res) => {
     const { heartbeat, logger: rootLogger } = req.app.locals.deps;
     const log2 = rootLogger.child("worker/keepalive");
     const body = req.body;
@@ -43165,27 +43381,41 @@ function createWorkerRoutes() {
     });
     res.json(response);
   }));
-  router.post("/vote", asyncHandler6(async (req, res) => {
+  router.post("/vote", asyncHandler5(async (req, res) => {
     const { election } = req.app.locals.deps;
     const response = election.handleVoteRequest(req.body);
     res.json(response);
   }));
-  router.post("/announce", asyncHandler6(async (req, res) => {
+  router.post("/announce", asyncHandler5(async (req, res) => {
     const { election } = req.app.locals.deps;
     election.handleLeaderAnnounce(req.body);
     res.json({ ok: true });
   }));
-  router.post("/preview-session", asyncHandler6(async (req, res) => {
+  router.post("/preview-session", asyncHandler5(async (req, res) => {
     const { logger: rootLogger } = req.app.locals.deps;
     const log2 = rootLogger.child("worker/preview-session");
     const body = TaskPreviewSessionBody.extend({
       taskId: external_exports.string().min(1)
     }).parse(req.body ?? {});
-    const payload = await createPreviewSessionPayload(req.app.locals.deps, body.taskId, body.path);
+    const payload = await createPreviewSessionPayload(
+      req.app.locals.deps,
+      body.taskId,
+      body.path,
+      resolveRequestOrigin(req)
+    );
     log2.info("created preview session", { taskId: body.taskId, entryPath: payload.entryPath });
     res.json(payload);
   }));
-  router.post("/control-response", asyncHandler6(async (req, res) => {
+  router.get("/preview-asset", asyncHandler5(async (req, res) => {
+    const { previewSessionManager } = req.app.locals.deps;
+    if (!previewSessionManager) {
+      throw new MeshyError("VALIDATION_ERROR", "Preview not available on this node", 400);
+    }
+    const token = external_exports.string().min(1).parse(req.query.token);
+    const requestedPath = typeof req.query.path === "string" && req.query.path.length > 0 ? req.query.path : void 0;
+    sendPreviewAssetResponse(previewSessionManager, token, requestedPath, res);
+  }));
+  router.post("/control-response", asyncHandler5(async (req, res) => {
     const { heartbeat, logger: rootLogger } = req.app.locals.deps;
     const log2 = rootLogger.child("worker/control-response");
     const body = req.body;
@@ -43206,12 +43436,12 @@ function createWorkerRoutes() {
 
 // ../../packages/api/src/routes/system.ts
 var import_express7 = __toESM(require_express2(), 1);
-function asyncHandler7(fn) {
+function asyncHandler6(fn) {
   return (req, res, next) => fn(req, res, next).catch(next);
 }
 function createSystemRoutes() {
   const router = (0, import_express7.Router)();
-  router.get("/health", asyncHandler7(async (req, res) => {
+  router.get("/health", asyncHandler6(async (req, res) => {
     const { logger: rootLogger } = req.app.locals.deps;
     rootLogger.child("system/health").info("received system health API call", {
       method: req.method,
@@ -43220,7 +43450,7 @@ function createSystemRoutes() {
     });
     res.json({ status: "ok", timestamp: Date.now() });
   }));
-  router.get("/info", asyncHandler7(async (req, res) => {
+  router.get("/info", asyncHandler6(async (req, res) => {
     const { nodeRegistry, getTransportType, config, dashboardOrigin } = req.app.locals.deps;
     const self2 = nodeRegistry.getSelf();
     res.json({
@@ -43236,7 +43466,7 @@ function createSystemRoutes() {
       }
     });
   }));
-  router.post("/transport", asyncHandler7(async (req, res) => {
+  router.post("/transport", asyncHandler6(async (req, res) => {
     const { switchTransport } = req.app.locals.deps;
     if (!switchTransport) {
       res.status(501).json({ error: "Transport switching not available" });
@@ -43250,7 +43480,7 @@ function createSystemRoutes() {
     const newEndpoint = await switchTransport(type);
     res.json({ ok: true, transportType: type, endpoint: newEndpoint });
   }));
-  router.post("/devtunnel", asyncHandler7(async (req, res) => {
+  router.post("/devtunnel", asyncHandler6(async (req, res) => {
     const { enableDevTunnel, disableDevTunnel, nodeRegistry, taskEngine } = req.app.locals.deps;
     if (!enableDevTunnel || !disableDevTunnel) {
       res.status(501).json({ error: "DevTunnel control not available" });
@@ -43279,7 +43509,7 @@ function createSystemRoutes() {
       });
     }
   }));
-  router.get("/metrics", asyncHandler7(async (req, res) => {
+  router.get("/metrics", asyncHandler6(async (req, res) => {
     const { taskEngine } = req.app.locals.deps;
     const metrics = taskEngine.getMetrics();
     res.json(metrics);
@@ -43440,6 +43670,25 @@ function createServer2(deps) {
   }
   app.use(import_express9.default.json({ limit: JSON_BODY_LIMIT }));
   app.use(createAuthMiddleware(authConfig));
+  app.use((req, res, next) => {
+    void (async () => {
+      if (!req.path.startsWith("/preview/")) {
+        next();
+        return;
+      }
+      if (!canServeDashboard(req)) {
+        res.status(404).type("text/plain").send("Not Found");
+        return;
+      }
+      if (deps.previewProxyManager && await handlePreviewProxyRequest(deps.previewProxyManager, deps.nodeRegistry, deps.logger, req, res)) {
+        return;
+      }
+      if (deps.previewSessionManager && handlePreviewRequest(deps.previewSessionManager, req, res)) {
+        return;
+      }
+      next();
+    })().catch(next);
+  });
   app.use(createRoutingMiddleware(deps.dataRouter));
   const largeBodyParser = import_express9.default.json({ limit: JSON_BODY_LIMIT_LARGE });
   app.use("/api/cluster", createClusterRoutes());
@@ -43468,37 +43717,6 @@ function createServer2(deps) {
   return app;
 }
 
-// ../../packages/api/src/output-server.ts
-var import_express10 = __toESM(require_express2(), 1);
-var JSON_BODY_LIMIT_LARGE2 = "25mb";
-function createOutputServer(deps) {
-  if (!deps.previewSessionManager) {
-    throw new Error("Preview session manager is required for the output server");
-  }
-  const app = (0, import_express10.default)();
-  app.locals.deps = deps;
-  app.use((req, res, next) => {
-    if (handlePreviewRequest(deps.previewSessionManager, req, res)) {
-      return;
-    }
-    next();
-  });
-  const authConfig = {
-    apiKey: deps.config.apiKey,
-    validateBearerToken: deps.config.validateBearerToken,
-    allowTrustedHostBypass: false
-  };
-  const largeBodyParser = import_express10.default.json({ limit: JSON_BODY_LIMIT_LARGE2 });
-  app.use("/api/tasks", largeBodyParser, createAuthMiddleware(authConfig), createTaskOutputRoutes({
-    allowRemoteProxy: false
-  }));
-  app.use("/api/nodes", createAuthMiddleware(authConfig), createLocalNodeWorkDirRoutes({
-    requireSelfNode: true
-  }));
-  app.use(createErrorMiddleware());
-  return app;
-}
-
 // ../../packages/transport/src/direct.ts
 var import_node_os4 = require("os");
 var import_node_http2 = require("http");
@@ -44382,21 +44600,10 @@ async function main() {
   });
   await meshyNode.start();
   const previewSessionManager = new PreviewSessionManager();
-  const previewPort = config.node.port + 1;
-  let actualPreviewPort = previewPort;
+  const previewProxyManager = new PreviewProxyManager();
   let dashboardTransport = null;
   let dashboardOrigin;
-  let previewTransport = null;
-  let previewOrigin;
-  let outputServer = null;
   let deps;
-  async function listen(app2, port) {
-    return new Promise((resolve11, reject) => {
-      const server2 = http3.createServer(app2);
-      server2.listen(port, () => resolve11(server2));
-      server2.on("error", reject);
-    });
-  }
   async function closeServer(server2) {
     if (!server2) {
       return;
@@ -44424,33 +44631,15 @@ async function main() {
       }
     };
   }
-  function createPreviewTransportConfig() {
-    return {
-      type: "devtunnel",
-      devtunnel: {
-        id: resolveOrCreateDevTunnelId(
-          config.storage.path,
-          meshyNode.getNodeRegistry().getSelf().id,
-          "preview"
-        ),
-        allowAnonymous: true
-      }
-    };
-  }
   function setAdvertisedDashboardOrigin(origin) {
     dashboardOrigin = origin;
     deps.dashboardOrigin = origin;
     meshyNode.getNodeRegistry().updateDashboardOrigin(meshyNode.getNodeRegistry().getSelf().id, origin);
   }
-  function setAdvertisedPreviewOrigin(origin) {
-    previewOrigin = origin;
-    deps.previewOrigin = origin;
-    meshyNode.getNodeRegistry().updatePreviewOrigin(meshyNode.getNodeRegistry().getSelf().id, origin);
-  }
   function shouldPublishDashboardTunnel() {
     return authMetadata.enabled && (meshyNode.getTransportType() === "devtunnel" || meshyNode.isDevTunnelEnabled());
   }
-  async function stopDashboardTransport() {
+  async function stopDashboardTransport(reason) {
     if (!dashboardTransport) {
       if (dashboardOrigin) {
         setAdvertisedDashboardOrigin(void 0);
@@ -44461,15 +44650,20 @@ async function main() {
     dashboardTransport = null;
     setAdvertisedDashboardOrigin(void 0);
     meshyNode.getLogger().info("stopped dashboard tunnel", {
-      reason: "dashboard transport no longer required",
+      reason,
       mainTransportType: meshyNode.getTransportType(),
       sidecarEnabled: meshyNode.isDevTunnelEnabled()
     });
   }
-  async function restartDashboardTransport(transportConfig) {
+  async function restartDashboardTransport(reason) {
+    const transportConfig = createDashboardTransportConfig();
     const previousTransport = dashboardTransport;
-    const previousOrigin = dashboardOrigin;
     let nextTransport = null;
+    if (previousTransport) {
+      await previousTransport.stop().catch(() => void 0);
+      dashboardTransport = null;
+      setAdvertisedDashboardOrigin(void 0);
+    }
     try {
       nextTransport = createTransport(transportConfig);
       await nextTransport.start(config.node.port);
@@ -44477,20 +44671,20 @@ async function main() {
       dashboardTransport = nextTransport;
       setAdvertisedDashboardOrigin(nextOrigin);
       meshyNode.getLogger().info("started dashboard tunnel", {
+        reason,
         dashboardOrigin: nextOrigin,
+        stableUrl: true,
         mainTransportType: meshyNode.getTransportType(),
         sidecarEnabled: meshyNode.isDevTunnelEnabled()
       });
-      if (previousTransport) {
-        await previousTransport.stop().catch(() => void 0);
-      }
     } catch (err) {
       if (nextTransport) {
         await nextTransport.stop().catch(() => void 0);
       }
-      dashboardTransport = previousTransport;
-      setAdvertisedDashboardOrigin(previousOrigin);
+      dashboardTransport = null;
+      setAdvertisedDashboardOrigin(void 0);
       meshyNode.getLogger().warn("failed to start dashboard transport", {
+        reason,
         error: err instanceof Error ? err.message : String(err),
         port: config.node.port,
         transportType: transportConfig.type
@@ -44499,7 +44693,7 @@ async function main() {
   }
   async function syncDashboardTransport(reason) {
     if (!authMetadata.enabled) {
-      await stopDashboardTransport();
+      await stopDashboardTransport("auth disabled");
       return;
     }
     if (!shouldPublishDashboardTunnel()) {
@@ -44509,7 +44703,7 @@ async function main() {
         sidecarEnabled: meshyNode.isDevTunnelEnabled(),
         authEnabled: authMetadata.enabled
       });
-      await stopDashboardTransport();
+      await stopDashboardTransport(reason);
       return;
     }
     if (dashboardTransport && await dashboardTransport.isHealthy().catch(() => false)) {
@@ -44521,37 +44715,7 @@ async function main() {
       });
       return;
     }
-    await restartDashboardTransport(createDashboardTransportConfig());
-  }
-  async function restartPreviewTransport(transportConfig) {
-    const previousTransport = previewTransport;
-    const previousOrigin = previewOrigin;
-    let nextTransport = null;
-    try {
-      nextTransport = createTransport(transportConfig);
-      await nextTransport.start(actualPreviewPort);
-      const nextOrigin = await nextTransport.getEndpoint();
-      previewTransport = nextTransport;
-      setAdvertisedPreviewOrigin(nextOrigin);
-      meshyNode.getLogger().info("started output preview tunnel", {
-        previewOrigin: nextOrigin,
-        previewPort: actualPreviewPort
-      });
-      if (previousTransport) {
-        await previousTransport.stop().catch(() => void 0);
-      }
-    } catch (err) {
-      if (nextTransport) {
-        await nextTransport.stop().catch(() => void 0);
-      }
-      previewTransport = previousTransport;
-      setAdvertisedPreviewOrigin(previousOrigin);
-      meshyNode.getLogger().warn("failed to start preview transport", {
-        error: err instanceof Error ? err.message : String(err),
-        previewPort: actualPreviewPort,
-        transportType: transportConfig.type
-      });
-    }
+    await restartDashboardTransport(reason);
   }
   deps = {
     dataRouter: meshyNode.getDataRouter(),
@@ -44571,6 +44735,7 @@ async function main() {
     persistNodeNamePreference: (name2) => persistDefaultNodeName(config.storage.path, name2),
     joinCurrentNodeToCluster: async (leaderEndpoint) => {
       await meshyNode.joinCluster(leaderEndpoint);
+      await syncDashboardTransport("joinCluster");
     },
     leaveCurrentCluster: async () => {
       await meshyNode.leaveCluster();
@@ -44597,29 +44762,12 @@ async function main() {
       await syncDashboardTransport("disableDevTunnel");
     },
     isDevTunnelEnabled: () => meshyNode.isDevTunnelEnabled(),
-    dashboardOrigin,
-    ensurePreviewOrigin: async () => {
-      if (previewTransport && !await previewTransport.isHealthy()) {
-        await previewTransport.stop().catch(() => void 0);
-        previewTransport = null;
-        setAdvertisedPreviewOrigin(void 0);
-      }
-      if (previewOrigin?.includes("devtunnels.ms") && previewTransport) {
-        return previewOrigin;
-      }
-      await restartPreviewTransport(createPreviewTransportConfig());
-      return previewOrigin;
-    }
+    localDashboardOrigin: `http://localhost:${config.node.port}`,
+    dashboardOrigin
   };
   deps.previewSessionManager = previewSessionManager;
-  deps.previewPort = actualPreviewPort;
+  deps.previewProxyManager = previewProxyManager;
   deps.dashboardOrigin = dashboardOrigin;
-  deps.previewOrigin = previewOrigin;
-  const outputApp = createOutputServer(deps);
-  outputServer = await listen(outputApp, previewPort);
-  const outputAddress = outputServer.address();
-  actualPreviewPort = typeof outputAddress === "object" && outputAddress ? outputAddress.port : previewPort;
-  deps.previewPort = actualPreviewPort;
   meshyNode.getLogger().info("configured node auth mode", {
     authEnabled: authMetadata.enabled,
     allowSameTenant: authMetadata.allowSameTenant,
@@ -44627,20 +44775,31 @@ async function main() {
     mainTransportType: meshyNode.getTransportType(),
     sidecarEnabled: meshyNode.isDevTunnelEnabled()
   });
-  await restartPreviewTransport(createPreviewTransportConfig());
   await syncDashboardTransport("startup");
-  const previewHealthTimer = setInterval(() => {
+  const nodeTunnelHealthTimer = setInterval(() => {
     void (async () => {
-      if (!previewTransport) return;
-      const healthy = await previewTransport.isHealthy().catch(() => false);
+      if (!meshyNode.hasPublishedNodeTunnel()) return;
+      const healthy = await meshyNode.isPublishedNodeTunnelHealthy().catch(() => false);
       if (healthy) return;
-      await previewTransport.stop().catch(() => void 0);
-      previewTransport = null;
-      setAdvertisedPreviewOrigin(void 0);
-      meshyNode.getLogger().warn("preview transport became unhealthy and was cleared", {
-        previewPort: actualPreviewPort
+      meshyNode.getLogger().warn("published node tunnel became unhealthy; restarting with stable id", {
+        mainTransportType: meshyNode.getTransportType(),
+        sidecarEnabled: meshyNode.isDevTunnelEnabled()
       });
-      await restartPreviewTransport(createPreviewTransportConfig());
+      try {
+        const endpoint = await meshyNode.restartPublishedNodeTunnel();
+        meshyNode.getLogger().info("restarted published node tunnel", {
+          endpoint,
+          stableUrl: true,
+          mainTransportType: meshyNode.getTransportType(),
+          sidecarEnabled: meshyNode.isDevTunnelEnabled()
+        });
+      } catch (err) {
+        meshyNode.getLogger().warn("failed to restart published node tunnel", {
+          error: err instanceof Error ? err.message : String(err),
+          mainTransportType: meshyNode.getTransportType(),
+          sidecarEnabled: meshyNode.isDevTunnelEnabled()
+        });
+      }
     })();
   }, config.cluster.heartbeatInterval);
   const dashboardHealthTimer = setInterval(() => {
@@ -44648,12 +44807,10 @@ async function main() {
       if (!dashboardTransport) return;
       const healthy = await dashboardTransport.isHealthy().catch(() => false);
       if (healthy) return;
-      await dashboardTransport.stop().catch(() => void 0);
-      dashboardTransport = null;
-      setAdvertisedDashboardOrigin(void 0);
-      meshyNode.getLogger().warn("dashboard transport became unhealthy and was cleared", {
+      meshyNode.getLogger().warn("dashboard tunnel became unhealthy; restarting with stable id", {
         port: config.node.port
       });
+      await restartDashboardTransport("healthcheck");
     })();
   }, config.cluster.heartbeatInterval);
   const app = createServer2(deps);
@@ -44680,14 +44837,10 @@ async function main() {
     console.log("\nShutting down...");
     try {
       clearInterval(dashboardHealthTimer);
-      clearInterval(previewHealthTimer);
+      clearInterval(nodeTunnelHealthTimer);
       if (dashboardTransport) {
         await dashboardTransport.stop();
       }
-      if (previewTransport) {
-        await previewTransport.stop();
-      }
-      await closeServer(outputServer);
       await meshyNode.stop();
       await closeServer(server);
       console.log("Goodbye!");