meshy-node 0.3.4 → 0.3.6

package/main.cjs

@@ -33847,6 +33847,7 @@ var TaskEngine = class {
   }
   /** Tracks which node a task was previously assigned to, for retry preference. */
   previousAssignments = /* @__PURE__ */ new Map();
+  deletedTaskIds = /* @__PURE__ */ new Set();
   // ── Task CRUD ────────────────────────────────────────────────────────
   createTask(input) {
     if (!input.title) {
@@ -33901,6 +33902,9 @@ var TaskEngine = class {
     let created = 0;
     let updated = 0;
     for (const task of tasks) {
+      if (this.deletedTaskIds.has(task.id)) {
+        continue;
+      }
       const existing = this.store.getTask(task.id);
       if (!existing) {
         this.store.createTask(task);
@@ -33962,6 +33966,7 @@ var TaskEngine = class {
     const deleted = this.store.deleteTask(id);
     if (!deleted) return false;
     this.previousAssignments.delete(id);
+    this.deletedTaskIds.add(id);
     if (this.logDir) {
       const logFile = path4.join(this.logDir, `${id}.jsonl`);
       try {
@@ -36197,14 +36202,51 @@ var import_node_child_process3 = require("child_process");
 // ../../packages/core/src/agents/cli-invocations.ts
 var fs8 = __toESM(require("fs"), 1);
 var path8 = __toESM(require("path"), 1);
+var WINDOWS_CLAUDE_NATIVE_PACKAGES = {
+  x64: "@anthropic-ai/claude-code-win32-x64",
+  arm64: "@anthropic-ai/claude-code-win32-arm64"
+};
+function getPathEntries() {
+  return (process.env.PATH ?? process.env.Path ?? process.env.path ?? "").split(path8.delimiter).filter(Boolean);
+}
+function isWindowsExecutable(filePath) {
+  let fd = null;
+  try {
+    fd = fs8.openSync(filePath, "r");
+    const signature = Buffer.alloc(2);
+    return fs8.readSync(fd, signature, 0, signature.length, 0) === signature.length && signature.toString("ascii") === "MZ";
+  } catch {
+    return false;
+  } finally {
+    if (fd !== null) fs8.closeSync(fd);
+  }
+}
+function getWindowsClaudePackageBinaryPath(npmBinDir) {
+  const binaryPath = path8.join(npmBinDir, "node_modules", "@anthropic-ai", "claude-code", "bin", "claude.exe");
+  return isWindowsExecutable(binaryPath) ? binaryPath : null;
+}
+function getWindowsClaudeNativePath(npmBinDir) {
+  const packageName = WINDOWS_CLAUDE_NATIVE_PACKAGES[process.arch];
+  if (!packageName) return null;
+  const nativePath = path8.join(npmBinDir, "node_modules", ...packageName.split("/"), "claude.exe");
+  return isWindowsExecutable(nativePath) ? nativePath : null;
+}
 function resolveClaudeInvocation() {
   if (process.platform !== "win32") {
     return { command: "claude", argsPrefix: [] };
   }
-  const pathEntries = (process.env.PATH ?? "").split(path8.delimiter).filter(Boolean);
+  const pathEntries = getPathEntries();
   for (const entry of pathEntries) {
     const shimPath = path8.join(entry, "claude.cmd");
     if (!fs8.existsSync(shimPath)) continue;
+    const packageBinaryPath = getWindowsClaudePackageBinaryPath(entry);
+    if (packageBinaryPath) {
+      return { command: packageBinaryPath, argsPrefix: [] };
+    }
+    const nativePath = getWindowsClaudeNativePath(entry);
+    if (nativePath) {
+      return { command: nativePath, argsPrefix: [] };
+    }
     const cliPath = path8.join(entry, "node_modules", "@anthropic-ai", "claude-code", "cli.js");
     if (fs8.existsSync(cliPath)) {
       return {
@@ -36212,6 +36254,13 @@ function resolveClaudeInvocation() {
         argsPrefix: [cliPath]
       };
     }
+    const wrapperPath = path8.join(entry, "node_modules", "@anthropic-ai", "claude-code", "cli-wrapper.cjs");
+    if (fs8.existsSync(wrapperPath)) {
+      return {
+        command: process.execPath,
+        argsPrefix: [wrapperPath]
+      };
+    }
   }
   return { command: "claude", argsPrefix: [] };
 }
@@ -36219,7 +36268,7 @@ function resolveCodexInvocation() {
   if (process.platform !== "win32") {
     return { command: "codex", argsPrefix: [] };
   }
-  const pathEntries = (process.env.PATH ?? "").split(path8.delimiter).filter(Boolean);
+  const pathEntries = getPathEntries();
   for (const entry of pathEntries) {
     const shimPath = path8.join(entry, "codex.cmd");
     if (!fs8.existsSync(shimPath)) continue;
@@ -37472,6 +37521,12 @@ async function handleLocalNodeMessage(deps, message) {
         error: error instanceof Error ? error.message : String(error)
       });
     }
+    return;
+  }
+  if (message.kind === "task.delete") {
+    const payload = message.payload;
+    if (!payload.taskId) return;
+    deps.taskEngine.deleteTask(payload.taskId);
   }
 }
 
@@ -44405,1962 +44460,2010 @@ function computeParentPath(rootPath, currentPath, useAbsolute) {
   return segments.length === 0 ? "." : segments.join("/");
 }
 
-// ../../packages/api/src/routes/node-workdir.ts
-function sendLocalNodeWorkDirTree(req, res, nodeId, options = {}) {
-  const query = NodeWorkDirTreeQuery.parse(req.query);
-  const { nodeRegistry, workDir, logger: logger27 } = req.app.locals.deps;
-  const self2 = nodeRegistry.getSelf();
-  if (options.requireSelfNode && nodeId !== self2.id) {
-    throw new MeshyError("NODE_NOT_FOUND", `Node ${nodeId} not found`, 404);
+// ../../packages/api/src/node/node-operation-service.ts
+var fs15 = __toESM(require("fs"), 1);
+var path17 = __toESM(require("path"), 1);
+var import_node_crypto7 = require("crypto");
+
+// ../../packages/api/src/node/agent-upgrade-service.ts
+var import_node_child_process9 = require("child_process");
+
+// ../../packages/api/src/app/system-info.ts
+var os6 = __toESM(require("os"), 1);
+var import_node_child_process8 = require("child_process");
+var RUNTIME_TOOLS = [
+  { id: "claude", label: "Claude Code", command: "claude", packageName: "@anthropic-ai/claude-code" },
+  { id: "codex", label: "Codex", command: "codex", packageName: "@openai/codex" }
+];
+var runtimeToolUpdateCache = /* @__PURE__ */ new Map();
+function clearRuntimeToolUpdateCache(packageName) {
+  if (packageName) {
+    runtimeToolUpdateCache.delete(packageName);
+    return;
   }
-  const startedAt = Date.now();
-  const log2 = logger27?.child("nodes/workdir-local");
-  let logged = false;
-  let result;
-  let serviceDurationMs;
-  const logCompletion = (closed) => {
-    if (logged) return;
-    logged = true;
-    log2?.info?.("completed local node workdir tree request", {
-      nodeId: self2.id,
-      requestedNodeId: nodeId,
-      path: query.path,
-      directoriesOnly: query.directoriesOnly,
-      allowAbsolute: query.allowAbsolute,
-      limit: query.limit,
-      offset: query.offset,
-      entries: result?.entries.length,
-      total: result?.total,
-      serviceDurationMs,
-      durationMs: Date.now() - startedAt,
-      statusCode: res.statusCode,
-      closed
-    });
-  };
-  res.once("finish", () => logCompletion(false));
-  res.once("close", () => {
-    if (!res.writableEnded) {
-      logCompletion(true);
-    }
-  });
-  const serviceStartedAt = Date.now();
-  result = getLocalNodeWorkDirTree(
-    self2.id,
-    self2.workDir ?? workDir,
-    query.path,
-    {
-      limit: query.limit,
-      offset: query.offset,
-      directoriesOnly: query.directoriesOnly,
-      allowAbsolute: query.allowAbsolute
-    }
-  );
-  serviceDurationMs = Date.now() - serviceStartedAt;
-  res.json(result);
+  runtimeToolUpdateCache.clear();
 }
-function sendLocalNodeWorkDirBranchInfo(req, res, nodeId, options = {}) {
-  const query = NodeWorkDirBranchQuery.parse(req.query);
-  const { nodeRegistry, workDir } = req.app.locals.deps;
-  const self2 = nodeRegistry.getSelf();
-  if (options.requireSelfNode && nodeId !== self2.id) {
-    throw new MeshyError("NODE_NOT_FOUND", `Node ${nodeId} not found`, 404);
-  }
-  res.json(getLocalNodeWorkDirBranchInfo(
-    self2.id,
-    self2.workDir ?? workDir,
-    query.path,
-    {
-      limit: query.limit,
-      offset: query.offset,
-      allowAbsolute: query.allowAbsolute
-    }
-  ));
+function runRuntimeToolCommand(command, args, platform2) {
+  const result = (0, import_node_child_process8.spawnSync)(command, args, {
+    encoding: "utf-8",
+    shell: platform2 === "win32" && command !== "where",
+    windowsHide: true,
+    timeout: 2500
+  });
+  return {
+    status: result.status,
+    stdout: typeof result.stdout === "string" ? result.stdout : "",
+    stderr: typeof result.stderr === "string" ? result.stderr : "",
+    error: result.error?.message ?? null
+  };
 }
-function sendLocalNodeWorkDirBranchCreate(req, res, nodeId, options = {}) {
-  const body = CreateNodeWorkDirBranchBody.parse(req.body);
-  const { nodeRegistry, workDir } = req.app.locals.deps;
-  const self2 = nodeRegistry.getSelf();
-  if (options.requireSelfNode && nodeId !== self2.id) {
-    throw new MeshyError("NODE_NOT_FOUND", `Node ${nodeId} not found`, 404);
+function normalizeOutput(output) {
+  if (!output) {
+    return null;
   }
-  res.json(createLocalNodeWorkDirBranch(
-    self2.id,
-    self2.workDir ?? workDir,
-    body.path,
-    {
-      branchName: body.branchName,
-      startPoint: body.startPoint,
-      limit: body.limit,
-      offset: body.offset,
-      allowAbsolute: body.allowAbsolute
-    }
-  ));
-}
-
-// ../../packages/api/src/tasks/task-route-utils.ts
-var fs15 = __toESM(require("fs"), 1);
-var import_node_stream2 = require("stream");
-var import_promises5 = require("stream/promises");
-
-// ../../packages/api/src/node/node-message-compat.ts
-var LEGACY_KIND_BY_NODE_MESSAGE = {
-  "node.workdir.tree": "node-workdir-tree",
-  "node.workdir.branch-info": "node-workdir-branch-info",
-  "node.workdir.branch-create": "node-workdir-branch-create",
-  "node.sessions.list": "node-sessions-list",
-  "node.transport.set": "devtunnel",
-  "node.agent.upgrade": "node-agent-upgrade",
-  "task.cancel": "task-cancel",
-  "task.logs": "task-logs",
-  "task.output.summary": "task-output-summary",
-  "task.output.tree": "task-output-tree",
-  "task.output.content": "task-output-content",
-  "task.output.download": "task-output-download",
-  "task.output.diff": "task-output-diff",
-  "task.preview.create": "task-preview-session"
-};
-function canRequestNodeMessage(heartbeat) {
-  return !!(heartbeat?.requestNodeMessage || heartbeat?.requestWorkerControl);
+  const firstLine = output.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+  return firstLine ?? null;
 }
-function requestFallbackNodeMessage(heartbeat, nodeId, message) {
-  if (heartbeat.requestNodeMessage) return heartbeat.requestNodeMessage(nodeId, message);
-  if (heartbeat.requestWorkerControl) return heartbeat.requestWorkerControl(nodeId, toLegacyWorkerControl2(message));
-  throw new Error("Node message fallback is not available");
+function formatLocalDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
 }
-function toLegacyWorkerControl2(message) {
+function resolveCommandPath(command, commandRunner, platform2) {
+  const lookupCommand = platform2 === "win32" ? "where" : "which";
+  const result = commandRunner(lookupCommand, [command]);
+  if (result.status === 0) {
+    return { path: normalizeOutput(result.stdout) };
+  }
   return {
-    ...typeof message.payload === "object" && message.payload !== null ? message.payload : {},
-    kind: LEGACY_KIND_BY_NODE_MESSAGE[message.kind] ?? message.kind
+    path: null,
+    detail: normalizeOutput(result.stderr) ?? result.error ?? null
   };
 }
-
-// ../../packages/api/src/tasks/task-route-utils.ts
-function isRecord4(value) {
-  return typeof value === "object" && value !== null;
-}
-function restoreTaskState(taskEngine, task) {
-  taskEngine.updateTask(task.id, {
-    status: task.status,
-    result: task.result,
-    error: task.error,
-    assignedTo: task.assignedTo
-  });
+function extractSemver(value) {
+  return value?.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/)?.[0] ?? null;
 }
-function readLocalTaskLogs(engineRegistry, taskId, after, agent) {
-  const engine = engineRegistry.get(agent);
-  if (!engine) {
-    throw new MeshyError("VALIDATION_ERROR", `Engine not registered for agent: ${agent}`, 400);
-  }
-  const logPath = engine.getLogPath(taskId);
-  if (!fs15.existsSync(logPath)) {
-    return { logs: [], total: 0 };
-  }
-  const content = fs15.readFileSync(logPath, "utf-8");
-  const allLines = content.trim().split("\n").filter(Boolean);
-  const logs = [];
-  for (let i = after; i < allLines.length; i++) {
-    try {
-      logs.push(JSON.parse(allLines[i]));
-    } catch {
+function normalizePackageVersion(output) {
+  if (!output) return null;
+  const trimmed = output.trim();
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed === "string") {
+      return parsed.trim() || null;
     }
+  } catch {
   }
-  return { logs, total: allLines.length };
+  return normalizeOutput(trimmed);
 }
-function recordLocalTaskLogs(engineRegistry, task, logs) {
-  if (logs.length === 0) {
-    return;
-  }
-  const engine = engineRegistry.get(task.agent);
-  if (!engine) {
-    throw new MeshyError("VALIDATION_ERROR", `Engine not registered for agent: ${task.agent}`, 400);
-  }
-  for (const event of logs) {
-    engine.recordOutput(task.id, event);
+function normalizeInstalledPackageVersion(output, packageName) {
+  if (!output) return null;
+  const trimmed = output.trim();
+  try {
+    const parsed = JSON.parse(trimmed);
+    const version2 = parsed.dependencies?.[packageName]?.version;
+    if (typeof version2 === "string") {
+      return version2.trim() || null;
+    }
+  } catch {
   }
+  return extractSemver(normalizeOutput(trimmed));
 }
-function parseEventTimestamp(event) {
-  if (typeof event.timestamp !== "string") {
-    return null;
-  }
-  const parsed = Date.parse(event.timestamp);
-  return Number.isNaN(parsed) ? null : parsed;
+function resolveInstalledPackageVersion(definition, commandRunner) {
+  const result = commandRunner("npm", ["list", "-g", definition.packageName, "--depth=0", "--json"]);
+  return normalizeInstalledPackageVersion(result.stdout ?? null, definition.packageName);
 }
-function getTaskUserMessageSignature(value) {
-  const content = normalizeTaskUserMessageContent(value);
-  if (content.length === 0) {
-    return null;
+function compareSemver(left, right) {
+  const leftParts = left.split(/[.-]/).map((part) => Number.parseInt(part, 10));
+  const rightParts = right.split(/[.-]/).map((part) => Number.parseInt(part, 10));
+  for (let index = 0; index < 3; index += 1) {
+    const delta = (leftParts[index] || 0) - (rightParts[index] || 0);
+    if (delta !== 0) return delta;
   }
-  return content.map((part) => {
-    if (part.type === "text") return `t:${part.text}`;
-    if (part.type === "tool_result") return `r:${part.toolUseId}:${part.isError === true ? "1" : "0"}:${part.content}`;
-    const dataStart = part.data.slice(0, 32);
-    const dataEnd = part.data.slice(-32);
-    return `i:${part.mediaType}:${part.data.length}:${dataStart}:${dataEnd}`;
-  }).join("|");
+  return 0;
 }
-function normalizeStructuredValue(value) {
-  if (Array.isArray(value)) {
-    return value.map((entry) => normalizeStructuredValue(entry));
-  }
-  if (!isRecord4(value)) {
-    return value;
+function checkToolUpdate(definition, installedVersion, checkedAt, commandRunner, checkedOn, updateCache) {
+  const currentVersion = extractSemver(installedVersion);
+  const cached = updateCache.get(definition.packageName);
+  let latestVersion = cached?.latestVersion ?? null;
+  let detail = cached?.detail ?? null;
+  let updateCheckedAt = cached?.checkedAt ?? checkedAt;
+  if (cached?.checkedOn !== checkedOn) {
+    const latestResult = commandRunner("npm", ["view", definition.packageName, "version", "--json"]);
+    latestVersion = latestResult.status === 0 ? normalizePackageVersion(latestResult.stdout ?? null) : null;
+    detail = latestResult.status === 0 ? null : normalizeOutput(latestResult.stderr) ?? latestResult.error ?? "Update check failed";
+    updateCheckedAt = checkedAt;
+    updateCache.set(definition.packageName, {
+      checkedOn,
+      checkedAt,
+      latestVersion,
+      detail
+    });
   }
-  return Object.fromEntries(
-    Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([key, entryValue]) => [key, normalizeStructuredValue(entryValue)])
-  );
+  return {
+    packageName: definition.packageName,
+    currentVersion,
+    latestVersion,
+    updateAvailable: Boolean(currentVersion && latestVersion && compareSemver(latestVersion, currentVersion) > 0),
+    checkedAt: updateCheckedAt,
+    detail
+  };
 }
-function getTranscriptEventSignature(event) {
-  if (event.type === "user") {
-    const signature = getTaskUserMessageSignature(isRecord4(event.message) ? event.message.content : event.message) ?? getTaskUserMessageSignature(event.content);
-    return signature ? `user:${signature}` : null;
-  }
-  if (event.type === "assistant") {
-    if (typeof event.message === "string") {
-      return `assistant:${JSON.stringify(event.message)}`;
-    }
-    if (isRecord4(event.message) && "content" in event.message) {
-      return `assistant:${JSON.stringify(normalizeStructuredValue(event.message.content))}`;
-    }
-    if (Array.isArray(event.content)) {
-      return `assistant:${JSON.stringify(normalizeStructuredValue(event.content))}`;
-    }
-    if (isRecord4(event.message)) {
-      return `assistant:${JSON.stringify(normalizeStructuredValue(event.message))}`;
-    }
+function inspectTool(definition, commandRunner, checkedAt, checkedOn, updateCache, platform2) {
+  const resolved = resolveCommandPath(definition.command, commandRunner, platform2);
+  if (!resolved.path) {
+    return {
+      id: definition.id,
+      label: definition.label,
+      command: definition.command,
+      available: false,
+      path: null,
+      version: null,
+      checkedAt,
+      detail: resolved.detail ?? "Command not found on PATH",
+      update: checkToolUpdate(definition, null, checkedAt, commandRunner, checkedOn, updateCache)
+    };
   }
-  return null;
+  const versionResult = commandRunner(definition.command, ["--version"]);
+  const commandVersion = normalizeOutput(versionResult.stdout) ?? normalizeOutput(versionResult.stderr);
+  const version2 = extractSemver(commandVersion) ? commandVersion : resolveInstalledPackageVersion(definition, commandRunner);
+  const detail = versionResult.status === 0 ? null : normalizeOutput(versionResult.stderr) ?? versionResult.error ?? "Version check failed";
+  return {
+    id: definition.id,
+    label: definition.label,
+    command: definition.command,
+    available: true,
+    path: resolved.path,
+    version: version2,
+    checkedAt,
+    detail,
+    update: checkToolUpdate(definition, version2, checkedAt, commandRunner, checkedOn, updateCache)
+  };
 }
-function sortLogsChronologically(events) {
-  return events.map((event, index) => ({ event, index })).sort((left, right) => {
-    const leftTimestamp = parseEventTimestamp(left.event);
-    const rightTimestamp = parseEventTimestamp(right.event);
-    if (leftTimestamp !== null && rightTimestamp !== null && leftTimestamp !== rightTimestamp) {
-      return leftTimestamp - rightTimestamp;
-    }
-    return left.index - right.index;
-  }).map((entry) => entry.event);
+function inspectRuntimeTools(options = {}) {
+  const platform2 = options.platform ?? process.platform;
+  const commandRunner = options.commandRunner ?? ((command, args) => runRuntimeToolCommand(command, args, platform2));
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const checkedAt = now.toISOString();
+  const checkedOn = formatLocalDate(now);
+  const updateCache = options.updateCache ?? runtimeToolUpdateCache;
+  return RUNTIME_TOOLS.map((definition) => inspectTool(definition, commandRunner, checkedAt, checkedOn, updateCache, platform2));
 }
-function timestampsMatch(left, right) {
-  const leftTimestamp = parseEventTimestamp(left);
-  const rightTimestamp = parseEventTimestamp(right);
-  if (leftTimestamp === null || rightTimestamp === null) {
-    return true;
-  }
-  return Math.abs(leftTimestamp - rightTimestamp) <= 6e4;
+function getOsSnapshot() {
+  const cpus2 = os6.cpus();
+  return {
+    platform: os6.platform(),
+    release: os6.release(),
+    arch: os6.arch(),
+    hostname: os6.hostname(),
+    cpuModel: cpus2[0]?.model ?? null,
+    cpuCount: cpus2.length,
+    totalMemoryBytes: os6.totalmem(),
+    freeMemoryBytes: os6.freemem()
+  };
 }
-function transcriptEvents(events) {
-  return events.flatMap((event, index) => {
-    const signature = getTranscriptEventSignature(event);
-    return signature ? [{ index, event, signature }] : [];
+function buildNodeSettingsSnapshot(options) {
+  const uptime = process.uptime();
+  const runtimeMetadata = options.runtimeMetadata;
+  const agents = (options.inspectRuntimeTools?.() ?? inspectRuntimeTools()).map((agent) => ({
+    ...agent,
+    metadataStatus: runtimeMetadata?.components?.[agent.id]?.status ?? null
+  }));
+  return {
+    collectedAt: Date.now(),
+    version: runtimeMetadata?.packageVersion ?? "0.1.0",
+    packageName: runtimeMetadata?.packageName ?? "meshy",
+    uptime,
+    auth: options.auth,
+    os: getOsSnapshot(),
+    runtime: {
+      nodeVersion: process.version,
+      pid: process.pid,
+      startedAt: Date.now() - Math.floor(uptime * 1e3),
+      cwd: process.cwd(),
+      workDir: options.workDir ?? null,
+      storagePath: options.storagePath ?? null,
+      localDashboardOrigin: options.localDashboardOrigin ?? null
+    },
+    agents,
+    startupRequirements: {
+      lastCheckedAt: runtimeMetadata?.startupRequirementsLastCheckedAt,
+      lastCheckedOn: runtimeMetadata?.startupRequirementsLastCheckedOn,
+      components: runtimeMetadata?.components ?? {}
+    },
+    components: runtimeMetadata?.components ?? {},
+    repository: runtimeMetadata?.repository ?? {},
+    packages: runtimeMetadata?.packages ?? {}
+  };
+}
+
+// ../../packages/api/src/node/agent-upgrade-service.ts
+var AGENT_PACKAGES = {
+  claude: "@anthropic-ai/claude-code",
+  codex: "@openai/codex"
+};
+var OUTPUT_LIMIT = 4e3;
+function summarizeOutput(value) {
+  const text = value ?? "";
+  return text.length > OUTPUT_LIMIT ? `${text.slice(0, OUTPUT_LIMIT)}\u2026` : text;
+}
+function defaultCommandRunner(command, args) {
+  const result = (0, import_node_child_process9.spawnSync)(command, args, {
+    encoding: "utf-8",
+    shell: process.platform === "win32",
+    windowsHide: true,
+    timeout: 18e4
   });
+  return {
+    status: result.status,
+    stdout: typeof result.stdout === "string" ? result.stdout : "",
+    stderr: typeof result.stderr === "string" ? result.stderr : "",
+    error: result.error?.message ?? null
+  };
 }
-function findLocalTranscriptDuplicates(nativeLogs, localLogs) {
-  const nativeTranscript = transcriptEvents(nativeLogs);
-  const localTranscript = transcriptEvents(localLogs);
-  if (nativeTranscript.length === 0 || localTranscript.length === 0) {
-    return /* @__PURE__ */ new Set();
-  }
-  const duplicates = /* @__PURE__ */ new Set();
-  for (const localEvent of localTranscript) {
-    if (nativeTranscript.some((nativeEvent) => nativeEvent.signature === localEvent.signature && timestampsMatch(nativeEvent.event, localEvent.event))) {
-      duplicates.add(localEvent.index);
-    }
+function isRuntimeAgentId(value) {
+  return value === "claude" || value === "codex";
+}
+function buildUpgradeArgs(agent, packageName) {
+  const args = ["install", "-g", `${packageName}@latest`];
+  if (agent === "claude") {
+    args.push("--include=optional", "--ignore-scripts=false");
   }
-  return duplicates;
+  return args;
 }
-function mergeNativeSessionLogs(nativeLogs, localLogs) {
-  if (localLogs.length === 0) {
-    return nativeLogs;
+function upgradeRuntimeAgent(agent, options = {}) {
+  const packageName = AGENT_PACKAGES[agent];
+  if (!packageName) {
+    throw new MeshyError("VALIDATION_ERROR", `Unsupported upgrade agent: ${agent}`, 400);
   }
-  const duplicateLocalIndexes = findLocalTranscriptDuplicates(nativeLogs, localLogs);
-  const retainedLocalLogs = localLogs.filter((_, index) => !duplicateLocalIndexes.has(index));
-  if (retainedLocalLogs.length === 0) {
-    return nativeLogs;
+  const command = "npm";
+  const args = buildUpgradeArgs(agent, packageName);
+  const result = (options.commandRunner ?? defaultCommandRunner)(command, args);
+  const ok = result.status === 0 && !result.error;
+  if (ok) {
+    clearRuntimeToolUpdateCache(packageName);
   }
-  return sortLogsChronologically([...nativeLogs, ...retainedLocalLogs]);
+  const detail = result.error ?? (summarizeOutput(result.stderr) || "Agent upgrade failed");
+  return {
+    ok,
+    agent,
+    packageName,
+    command,
+    args,
+    status: result.status,
+    stdout: summarizeOutput(result.stdout),
+    stderr: summarizeOutput(result.stderr),
+    detail: ok ? null : detail
+  };
 }
-function readLocalTaskLogsWithNativeHistory(engineRegistry, task, taskId, after, agent) {
-  const local = readLocalTaskLogs(engineRegistry, taskId, after, agent);
-  const sessionId = typeof task?.payload?.sessionId === "string" ? task.payload.sessionId : "";
-  if (after > 0 || task?.conversationKind !== "nativeSession" || !sessionId || task.agent !== "codex" && task.agent !== "claudecode") {
-    return local;
+function upgradeRuntimeAgentForDeps(deps, agent) {
+  const result = deps.upgradeRuntimeAgent?.(agent) ?? upgradeRuntimeAgent(agent);
+  if (result.ok) {
+    const settingsSnapshot = deps.refreshSettingsSnapshot?.();
+    if (settingsSnapshot) {
+      deps.nodeRegistry.updateSettingsSnapshot(deps.nodeRegistry.getSelf().id, settingsSnapshot);
+      return { ...result, settingsSnapshot };
+    }
   }
-  const history = loadNativeSessionHistory({ agent: task.agent, sessionId });
-  if (history.logs.length === 0) {
-    return local;
-  }
-  if (local.total > 0) {
-    const logs = mergeNativeSessionLogs(history.logs, local.logs);
-    return { logs, total: logs.length };
-  }
-  recordLocalTaskLogs(engineRegistry, task, history.logs);
-  return readLocalTaskLogs(engineRegistry, taskId, after, agent);
-}
-async function seedTaskSnapshotOnWorker(task, logs, node, log2, timeoutMs = 1e4) {
-  const proxyPath = "/api/worker/import-task";
-  const { endpoint, response } = await fetchNodeWithFallback(
-    node,
-    proxyPath,
-    {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ task, logs })
-    },
-    timeoutMs,
-    void 0,
-    { preferPublicEndpoint: true }
-  );
-  if (!response.ok) {
-    const failure = await response.text().catch(() => "");
-    throw new MeshyError("NODE_OFFLINE", failure || `Failed to seed task on ${node.name} (${response.status})`, 502);
-  }
-  const body = await response.json().catch(() => null);
-  const seededLogs = Array.isArray(body?.logs) ? body.logs : logs;
-  log2.info("seeded task snapshot on worker", {
-    taskId: task.id,
-    assignedTo: node.id,
-    endpoint,
-    importedLogCount: seededLogs.length
-  });
-  return seededLogs;
-}
-async function requestTaskLogsOverKeepalive(heartbeat, nodeId, task, after) {
-  if (!canRequestNodeMessage(heartbeat)) return null;
-  const message = createNodeMessage("task.logs", { taskId: task.id, after, task }, { expectsResponse: true });
-  return requestFallbackNodeMessage(heartbeat, nodeId, message);
-}
-async function sendProxyResponse(res, proxyRes) {
-  const contentType = proxyRes.headers.get("content-type");
-  const contentDisposition = proxyRes.headers.get("content-disposition");
-  const cacheControl = proxyRes.headers.get("cache-control");
-  if (contentType) res.setHeader("Content-Type", contentType);
-  if (contentDisposition) res.setHeader("Content-Disposition", contentDisposition);
-  if (cacheControl) res.setHeader("Cache-Control", cacheControl);
-  if (contentType?.split(";")[0]?.trim().toLowerCase() === "text/event-stream") {
-    if (!cacheControl) res.setHeader("Cache-Control", "no-cache");
-    res.status(proxyRes.status);
-    res.flushHeaders();
-    if (!proxyRes.body) {
-      res.end();
-      return;
-    }
-    try {
-      await (0, import_promises5.pipeline)(import_node_stream2.Readable.fromWeb(proxyRes.body), res);
-    } catch (error) {
-      if (!res.destroyed && !res.writableEnded) {
-        throw error;
-      }
-    }
-    return;
-  }
-  const body = Buffer.from(await proxyRes.arrayBuffer());
-  res.status(proxyRes.status).send(body);
-}
-async function maybeProxyReadToLeader(req, res, options = {}) {
-  const { dataRouter, nodeRegistry, logger: rootLogger } = req.app.locals.deps;
-  const methods = new Set((options.methods ?? ["GET"]).map((method) => method.toUpperCase()));
-  if (!methods.has(req.method.toUpperCase()) || nodeRegistry?.isLeader?.() !== false || !dataRouter?.proxyToLeader) {
-    return false;
-  }
-  const leaderEndpoint = dataRouter.getLeaderEndpoint?.();
-  if (!leaderEndpoint) {
-    return false;
-  }
-  try {
-    const result = await dataRouter.proxyToLeader(req);
-    for (const [key, value] of Object.entries(result.headers)) {
-      if (key.toLowerCase() === "content-length" || key.toLowerCase() === "transfer-encoding") continue;
-      res.setHeader(key, value);
-    }
-    res.status(result.status).json(result.body);
-    return true;
-  } catch (error) {
-    const log2 = rootLogger?.child?.("tasks/leader-read-proxy") ?? rootLogger;
-    log2?.warn?.("leader read proxy failed", {
-      path: req.originalUrl ?? req.url,
-      leaderEndpoint,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    throw error instanceof MeshyError ? error : new MeshyError("NODE_OFFLINE", "Leader unreachable", 502);
-  }
-}
-
-// ../../packages/api/src/node/node-native-session-service.ts
-function getLocalNodeNativeSessions(nodeId, agent, limit) {
-  return {
-    nodeId,
-    agent,
-    sessions: listNativeSessions({ agent, limit })
-  };
-}
-
-// ../../packages/api/src/tasks/task-cancellation.ts
-var TERMINAL_STATUSES2 = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "archived"]);
-function cancelTaskOnCurrentNode(deps, taskId, options = {}) {
-  const task = deps.taskEngine.getTask(taskId);
-  if (!task) {
-    if (options.missingOk) {
-      return {
-        task: null,
-        cancelled: false,
-        engineCancelRequested: false,
-        missing: true,
-        terminal: false
-      };
-    }
-    throw new MeshyError("TASK_NOT_FOUND", `Task ${taskId} not found`, 404);
-  }
-  if (TERMINAL_STATUSES2.has(task.status)) {
-    if (options.terminalOk) {
-      return {
-        task,
-        cancelled: false,
-        engineCancelRequested: false,
-        missing: false,
-        terminal: true
-      };
-    }
-    throw new MeshyError("VALIDATION_ERROR", `Task ${taskId} cannot be cancelled (status: ${task.status})`, 400);
-  }
-  let engineCancelRequested = false;
-  if (task.status === "running") {
-    const engine = deps.engineRegistry.get(task.agent);
-    if (!engine || typeof engine.cancelTask !== "function") {
-      deps.logger.warn("engine not registered while cancelling running task", {
-        taskId,
-        agent: task.agent
-      });
-    } else {
-      engineCancelRequested = engine.cancelTask(taskId);
-      if (!engineCancelRequested) {
-        deps.logger.warn("running task had no active engine process to cancel", {
-          taskId,
-          agent: task.agent
-        });
-      }
-    }
-  }
-  const cancelled = deps.taskEngine.cancelTask(taskId);
-  if (!cancelled) {
-    throw new MeshyError("VALIDATION_ERROR", `Task ${taskId} cannot be cancelled`, 400);
-  }
-  return {
-    task,
-    cancelled: true,
-    engineCancelRequested,
-    missing: false,
-    terminal: false
-  };
+  return result;
 }
 
-// ../../packages/api/src/tasks/task-output-service.ts
-var fs17 = __toESM(require("fs"), 1);
-var path18 = __toESM(require("path"), 1);
-
-// ../../packages/api/src/preview/preview-server.ts
-var crypto3 = __toESM(require("crypto"), 1);
-var fs16 = __toESM(require("fs"), 1);
-var path17 = __toESM(require("path"), 1);
-var http2 = __toESM(require("http"), 1);
-var import_node_stream3 = require("stream");
-var import_promises6 = require("stream/promises");
-
-// ../../packages/api/src/preview/preview-request.ts
-var PREVIEW_AUTHORIZATION_HEADER = "x-meshy-preview-authorization";
-var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
-  "connection",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade"
-]);
-function isReadOnlyPreviewMethod(method) {
-  const normalizedMethod = method?.toUpperCase() ?? "GET";
-  return normalizedMethod === "GET" || normalizedMethod === "HEAD";
-}
-function methodAllowsRequestBody(method) {
-  return !isReadOnlyPreviewMethod(method);
-}
-function toArrayBuffer(value) {
-  const copy = new Uint8Array(value.byteLength);
-  copy.set(value);
-  return copy.buffer;
-}
-function getParsedRequestBody(req) {
-  const body = req.body;
-  if (body === void 0) {
-    return void 0;
+// ../../packages/api/src/node/node-operation-service.ts
+var NodeOperationFailure = class extends Error {
+  constructor(message, result) {
+    super(message);
+    this.result = result;
   }
-  if (typeof body === "string" || body instanceof URLSearchParams || body instanceof Blob || body instanceof FormData) {
-    return body;
+};
+var InMemoryNodeOperationStore = class {
+  operations = /* @__PURE__ */ new Map();
+  get(id) {
+    const operation = this.operations.get(id);
+    return operation ? clone2(operation) : null;
   }
-  if (Buffer.isBuffer(body)) {
-    return toArrayBuffer(body);
+  list(filter = {}) {
+    return Array.from(this.operations.values()).filter((operation) => matchesFilter(operation, filter)).sort((a, b) => b.createdAt - a.createdAt).map((operation) => clone2(operation));
   }
-  if (body instanceof Uint8Array) {
-    return toArrayBuffer(body);
+  upsert(operation) {
+    const copy = clone2(operation);
+    this.operations.set(copy.id, copy);
+    return clone2(copy);
   }
-  return JSON.stringify(body);
-}
-async function readPreviewRequestBody(req) {
-  if (!req || !methodAllowsRequestBody(req.method)) {
-    return void 0;
+  update(id, updates) {
+    const current = this.operations.get(id);
+    if (!current) return null;
+    const next = { ...current, ...clone2(updates), id, createdAt: current.createdAt };
+    this.operations.set(id, next);
+    return clone2(next);
   }
-  const parsedBody = getParsedRequestBody(req);
-  if (parsedBody !== void 0) {
-    return parsedBody;
+};
+var FileNodeOperationStore = class {
+  constructor(storagePath) {
+    this.storagePath = storagePath;
   }
-  const chunks = [];
-  for await (const chunk of req) {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  operations = /* @__PURE__ */ new Map();
+  loaded = false;
+  get(id) {
+    this.load();
+    const operation = this.operations.get(id);
+    return operation ? clone2(operation) : null;
   }
-  return chunks.length > 0 ? toArrayBuffer(Buffer.concat(chunks)) : void 0;
-}
-function buildServiceProxyHeaders(req) {
-  const headers = {};
-  if (!req) {
-    return headers;
+  list(filter = {}) {
+    this.load();
+    return Array.from(this.operations.values()).filter((operation) => matchesFilter(operation, filter)).sort((a, b) => b.createdAt - a.createdAt).map((operation) => clone2(operation));
   }
-  let previewAuthorization;
-  for (const [key, value] of Object.entries(req.headers)) {
-    const normalizedKey = key.toLowerCase();
-    if (HOP_BY_HOP_HEADERS.has(normalizedKey) || normalizedKey === "host" || normalizedKey === "content-length" || normalizedKey === "forwarded" || normalizedKey === "x-real-ip" || normalizedKey.startsWith("x-forwarded-") || normalizedKey === MESHY_AUTHORIZATION_HEADER) {
-      continue;
-    }
-    if (normalizedKey === PREVIEW_AUTHORIZATION_HEADER) {
-      previewAuthorization = Array.isArray(value) ? value[0] : value;
-      continue;
-    }
-    if (Array.isArray(value)) {
-      headers[key] = value.join(", ");
-    } else if (typeof value === "string") {
-      headers[key] = value;
-    }
+  upsert(operation) {
+    this.load();
+    const copy = clone2(operation);
+    this.operations.set(copy.id, copy);
+    this.persist();
+    return clone2(copy);
   }
-  if (previewAuthorization && !headers.authorization) {
-    headers.authorization = previewAuthorization;
+  update(id, updates) {
+    this.load();
+    const current = this.operations.get(id);
+    if (!current) return null;
+    const next = { ...current, ...clone2(updates), id, createdAt: current.createdAt };
+    this.operations.set(id, next);
+    this.persist();
+    return clone2(next);
   }
-  return headers;
-}
-function buildPreviewWorkerProxyHeaders(req) {
-  const headers = {};
-  let previewAuthorization;
-  for (const [key, value] of Object.entries(req.headers)) {
-    const normalizedKey = key.toLowerCase();
-    if (HOP_BY_HOP_HEADERS.has(normalizedKey) || normalizedKey === "host" || normalizedKey === "content-length" || normalizedKey === MESHY_AUTHORIZATION_HEADER || normalizedKey === PREVIEW_AUTHORIZATION_HEADER) {
-      continue;
-    }
-    if (normalizedKey === "authorization") {
-      previewAuthorization = Array.isArray(value) ? value[0] : value;
-      continue;
-    }
-    if (Array.isArray(value)) {
-      headers[key] = value.join(", ");
-    } else if (typeof value === "string") {
-      headers[key] = value;
+  load() {
+    if (this.loaded) return;
+    this.loaded = true;
+    if (!fs15.existsSync(this.filePath)) return;
+    const raw = JSON.parse(fs15.readFileSync(this.filePath, "utf-8"));
+    const entries = Array.isArray(raw) ? raw : Object.values(raw);
+    for (const entry of entries) {
+      if (isNodeOperation(entry)) {
+        this.operations.set(entry.id, clone2(entry));
+      }
     }
   }
-  if (previewAuthorization) {
-    headers[PREVIEW_AUTHORIZATION_HEADER] = previewAuthorization;
-  }
-  return headers;
-}
-
-// ../../packages/api/src/preview/preview-server.ts
-function resolvePreviewPath(rootPath, relativePath) {
-  const sanitizedPath = relativePath.replace(/\\/g, "/");
-  const resolvedPath = path17.resolve(rootPath, sanitizedPath);
-  const normalizedRoot = path17.resolve(rootPath);
-  if (!resolvedPath.startsWith(normalizedRoot + path17.sep) && resolvedPath !== normalizedRoot) {
-    throw new Error("Invalid preview path");
-  }
-  return {
-    absolutePath: resolvedPath,
-    normalizedPath: path17.relative(normalizedRoot, resolvedPath).split(path17.sep).join("/")
-  };
-}
-function resolvePreviewEntryPath(rootPath, entryPath) {
-  const { absolutePath, normalizedPath } = resolvePreviewPath(rootPath, entryPath ?? "index.html");
-  if (!fs16.existsSync(absolutePath) || !fs16.statSync(absolutePath).isFile()) {
-    throw new Error("Preview entry not found");
-  }
-  return normalizedPath;
-}
-function normalizeServiceEntryPath(entryPath) {
-  if (!entryPath || entryPath === "/") {
-    return "";
+  persist() {
+    fs15.mkdirSync(this.storagePath, { recursive: true });
+    const body = JSON.stringify(Object.fromEntries(this.operations), null, 2);
+    const tmpPath = `${this.filePath}.tmp`;
+    fs15.writeFileSync(tmpPath, body, "utf-8");
+    fs15.renameSync(tmpPath, this.filePath);
   }
-  return entryPath.replace(/\\/g, "/").replace(/^\/+/, "");
-}
-function assertPreviewServicePort(port) {
-  if (!Number.isInteger(port) || port < 1 || port > 65535) {
-    throw new Error("Invalid preview service port");
+  get filePath() {
+    return path17.join(this.storagePath, "node-operations.json");
   }
-  return port;
-}
-function buildPreviewUrl(origin, session) {
-  return buildPreviewRouteUrl(origin, "preview", session);
-}
-function buildPreviewOpenUrl(origin, session) {
-  return buildPreviewRouteUrl(origin, "preview-open", session);
-}
-function buildPreviewRouteUrl(origin, route, session) {
-  const encodedEntryPath = session.entryPath.split("/").filter(Boolean).map((segment) => encodeURIComponent(segment)).join("/");
-  const suffix = encodedEntryPath.length > 0 ? `/${encodedEntryPath}` : session.kind === "service" ? "/" : "";
-  return `${origin.replace(/\/+$/, "")}/${route}/${session.token}${suffix}`;
-}
-var DEFAULT_TTL_MS = 15 * 60 * 1e3;
-var PreviewSessionManager = class {
-  sessions = /* @__PURE__ */ new Map();
-  create(options) {
-    const token = crypto3.randomBytes(32).toString("hex");
-    const expiresAt = Date.now() + (options.ttlMs ?? DEFAULT_TTL_MS);
-    if (options.port !== void 0) {
-      const session2 = {
-        token,
-        taskId: options.taskId,
-        kind: "service",
-        port: assertPreviewServicePort(options.port),
-        entryPath: normalizeServiceEntryPath(options.entryPath),
-        expiresAt
-      };
-      this.sessions.set(token, session2);
-      return session2;
-    }
-    if (!options.rootPath) {
-      throw new Error("Preview root path is required");
-    }
-    const entryPath = resolvePreviewEntryPath(options.rootPath, options.entryPath);
-    const session = {
-      token,
-      taskId: options.taskId,
-      kind: "file",
-      rootPath: options.rootPath,
-      entryPath,
-      expiresAt
-    };
-    this.sessions.set(token, session);
-    return session;
+};
+var NodeOperationService = class {
+  constructor(deps, store) {
+    this.deps = deps;
+    this.store = store;
+    this.registerHandler("agent.upgrade", runAgentUpgradeOperation);
+    this.registerHandler("workdir.branch-create", runWorkDirBranchCreateOperation);
   }
-  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;
+  handlers = /* @__PURE__ */ new Map();
+  registerHandler(kind, handler) {
+    this.handlers.set(kind, handler);
   }
-  cleanup() {
+  create(kind, nodeId, payload) {
     const now = Date.now();
-    for (const [token, session] of this.sessions) {
-      if (now > session.expiresAt) {
-        this.sessions.delete(token);
-      }
-    }
-  }
-};
-var MIME_MAP2 = {
-  ".html": "text/html",
-  ".htm": "text/html",
-  ".css": "text/css",
-  ".js": "text/javascript",
-  ".mjs": "text/javascript",
-  ".json": "application/json",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".svg": "image/svg+xml",
-  ".webp": "image/webp",
-  ".ico": "image/x-icon",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".eot": "application/vnd.ms-fontobject",
-  ".pdf": "application/pdf",
-  ".md": "text/markdown",
-  ".mdx": "text/markdown"
-};
-function getMime(filePath) {
-  return MIME_MAP2[path17.extname(filePath).toLowerCase()] ?? "application/octet-stream";
-}
-function escapeHtml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-function renderInlineMarkdown(value) {
-  let rendered = escapeHtml(value);
-  rendered = rendered.replace(/!\[([^\]]*)]\(([^\s)]+)\)/g, '<img alt="$1" src="$2">');
-  rendered = rendered.replace(/`([^`]+)`/g, "<code>$1</code>").replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>").replace(/\[([^\]]+)]\((https?:\/\/[^\s)]+)\)/g, '<a href="$2" rel="noreferrer noopener" target="_blank">$1</a>');
-  return rendered;
-}
-function renderMarkdownBody(markdown) {
-  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
-  const blocks = [];
-  let paragraph = [];
-  let listItems = [];
-  let codeLines = null;
-  const flushParagraph = () => {
-    if (paragraph.length === 0) return;
-    blocks.push(`<p>${renderInlineMarkdown(paragraph.join(" "))}</p>`);
-    paragraph = [];
-  };
-  const flushList = () => {
-    if (listItems.length === 0) return;
-    blocks.push(`<ul>${listItems.map((item) => `<li>${renderInlineMarkdown(item)}</li>`).join("")}</ul>`);
-    listItems = [];
-  };
-  for (const line of lines) {
-    if (line.trim().startsWith("```")) {
-      if (codeLines) {
-        blocks.push(`<pre><code>${escapeHtml(codeLines.join("\n"))}</code></pre>`);
-        codeLines = null;
-      } else {
-        flushParagraph();
-        flushList();
-        codeLines = [];
-      }
-      continue;
-    }
-    if (codeLines) {
-      codeLines.push(line);
-      continue;
-    }
-    const trimmed = line.trim();
-    if (!trimmed) {
-      flushParagraph();
-      flushList();
-      continue;
+    const operation = {
+      id: (0, import_node_crypto7.randomUUID)(),
+      kind,
+      nodeId,
+      requestedByNodeId: this.deps.nodeRegistry.getSelf().id,
+      status: "queued",
+      payload,
+      createdAt: now,
+      updatedAt: now
+    };
+    const saved = this.store.upsert(operation);
+    this.deps.eventBus.emit("node.operation.created", { operation: saved });
+    return saved;
+  }
+  get(id) {
+    return this.store.get(id);
+  }
+  list(filter) {
+    return this.store.list(filter);
+  }
+  accept(operation) {
+    const current = this.store.get(operation.id);
+    if (current) {
+      if (current.status === "queued") this.scheduleRun(current.id);
+      return current;
     }
-    const heading = trimmed.match(/^(#{1,6})\s+(.+)$/);
-    if (heading) {
-      flushParagraph();
-      flushList();
-      const level = heading[1].length;
-      blocks.push(`<h${level}>${renderInlineMarkdown(heading[2])}</h${level}>`);
-      continue;
+    const saved = this.store.upsert({ ...operation, status: "queued", updatedAt: Date.now() });
+    this.deps.eventBus.emit("node.operation.created", { operation: saved });
+    this.scheduleRun(saved.id);
+    return saved;
+  }
+  runLocal(id) {
+    this.scheduleRun(id);
+  }
+  applyRemoteUpdate(operation) {
+    const current = this.store.get(operation.id);
+    const saved = this.store.upsert(current ? { ...current, ...operation } : operation);
+    this.applyOperationSideEffects(saved);
+    this.deps.eventBus.emit("node.operation.updated", { operation: saved });
+    return saved;
+  }
+  markFailed(id, error) {
+    return this.update(id, {
+      status: "failed",
+      error,
+      completedAt: Date.now()
+    });
+  }
+  scheduleRun(id) {
+    setTimeout(() => {
+      void this.run(id);
+    }, 0);
+  }
+  async run(id) {
+    const operation = this.store.get(id);
+    if (!operation || operation.status !== "queued") return;
+    const running = this.update(id, { status: "running", startedAt: Date.now() });
+    if (!running) return;
+    try {
+      const handler = this.handlers.get(running.kind);
+      if (!handler) throw new Error(`No node operation handler registered for kind: ${running.kind}`);
+      const result = await handler(running, this.deps);
+      this.update(id, { status: "succeeded", result, completedAt: Date.now() });
+    } catch (err) {
+      this.update(id, {
+        status: "failed",
+        result: err instanceof NodeOperationFailure ? err.result : void 0,
+        error: err instanceof Error ? err.message : String(err),
+        completedAt: Date.now()
+      });
     }
-    const listItem = trimmed.match(/^[-*]\s+(.+)$/);
-    if (listItem) {
-      flushParagraph();
-      listItems.push(listItem[1]);
-      continue;
+  }
+  update(id, updates) {
+    const saved = this.store.update(id, { ...updates, updatedAt: Date.now() });
+    if (!saved) return null;
+    this.applyOperationSideEffects(saved);
+    this.deps.eventBus.emit("node.operation.updated", { operation: saved });
+    void this.reportToLeader(saved);
+    return saved;
+  }
+  applyOperationSideEffects(operation) {
+    if (operation.kind !== "agent.upgrade" || operation.status !== "succeeded") return;
+    const settingsSnapshot = readSettingsSnapshot(operation.result);
+    if (settingsSnapshot) {
+      this.deps.nodeRegistry.updateSettingsSnapshot(operation.nodeId, settingsSnapshot);
     }
-    flushList();
-    paragraph.push(trimmed);
   }
-  if (codeLines) {
-    blocks.push(`<pre><code>${escapeHtml(codeLines.join("\n"))}</code></pre>`);
+  async reportToLeader(operation) {
+    if (this.deps.nodeRegistry.isLeader()) return;
+    const leaderEndpoint = this.deps.nodeRegistry.getLeaderEndpoint?.();
+    if (!leaderEndpoint) return;
+    try {
+      await fetch(`${leaderEndpoint}/api/worker/node-operations/${operation.id}`, applyRequestAuthHeaders({
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(operation)
+      }));
+    } catch (err) {
+      this.deps.logger.child("node-operation").warn("failed to report node operation update to leader", {
+        operationId: operation.id,
+        kind: operation.kind,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
   }
-  flushParagraph();
-  flushList();
-  return blocks.join("\n");
-}
-function renderMarkdownDocument(markdown, title) {
-  const body = renderMarkdownBody(markdown);
-  return Buffer.from(`<!doctype html>
-<html>
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>${escapeHtml(title)}</title>
-  <style>
-    body { box-sizing: border-box; max-width: 860px; margin: 0 auto; padding: 32px; color: #111827; font: 16px/1.65 -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
-    h1, h2, h3, h4, h5, h6 { line-height: 1.25; margin: 1.5em 0 0.5em; }
-    h1 { border-bottom: 1px solid #e5e7eb; padding-bottom: 0.3em; }
-    pre { overflow: auto; border-radius: 8px; background: #111827; color: #f9fafb; padding: 16px; }
-    code { border-radius: 4px; background: #f3f4f6; padding: 0.1em 0.25em; }
-    pre code { background: transparent; padding: 0; }
-    img { max-width: 100%; }
-    a { color: #2563eb; }
-  </style>
-</head>
-<body>
-${body}
-</body>
-</html>`, "utf8");
+};
+function getNodeOperationService(deps) {
+  if (deps.nodeOperationService) return deps.nodeOperationService;
+  const store = deps.nodeOperationStore ?? (deps.storagePath ? new FileNodeOperationStore(deps.storagePath) : new InMemoryNodeOperationStore());
+  const service = new NodeOperationService(deps, store);
+  deps.nodeOperationStore = store;
+  deps.nodeOperationService = service;
+  return service;
 }
-function splitPreviewPathAndSearch(value) {
-  const marker = value.indexOf("?");
-  if (marker === -1) {
-    return { pathname: value, search: "" };
+async function dispatchNodeOperation(deps, operation, node) {
+  const message = createNodeMessage("node.operation.execute", { operation });
+  const heartbeat = deps.heartbeat;
+  if (heartbeat.canPushToNode?.(node.id) === false) {
+    if (!heartbeat.enqueueNodeMessage) throw new Error(`Cannot queue node operation for ${node.id}`);
+    heartbeat.enqueueNodeMessage(node.id, message);
+    return;
   }
-  return { pathname: value.slice(0, marker), search: value.slice(marker) };
+  const client = new NodeMessageClient({
+    heartbeat: heartbeat.enqueueNodeMessage ? { enqueueNodeMessage: heartbeat.enqueueNodeMessage.bind(heartbeat) } : void 0,
+    logger: deps.logger
+  });
+  await client.send(node, message);
 }
-function normalizeServiceRequestPath(pathname) {
-  const normalized = pathname.replace(/\\/g, "/");
-  if (!normalized || normalized === "/") {
-    return "/";
+function runAgentUpgradeOperation(operation, deps) {
+  const agent = readPayloadString(operation, "agent");
+  if (!isRuntimeAgentId(agent)) throw new Error(`Unsupported upgrade agent: ${agent}`);
+  const result = upgradeRuntimeAgentForDeps(deps, agent);
+  if (!result.ok) {
+    throw new NodeOperationFailure(result.detail ?? `${agent} upgrade failed`, result);
   }
-  return `/${normalized.replace(/^\/+/, "")}`;
+  return result;
 }
-function rewriteServiceRootRelativeUrls(value, token) {
-  const previewRoot = `/preview/${token}/`;
-  return value.replace(/\b(src|href|action)=(['"])\/(?!\/|preview\/)/gi, `$1=$2${previewRoot}`).replace(/url\((['"]?)\/(?!\/|preview\/)/gi, `url($1${previewRoot}`).replace(/\bimport\((['"])\/(?!\/|preview\/)/gi, `import($1${previewRoot}`).replace(/\bfrom\s+(['"])\/(?!\/|preview\/)/gi, `from $1${previewRoot}`).replace(/(['"])\/(assets\/[^'"]+)\1/g, `$1${previewRoot}$2$1`);
+function runWorkDirBranchCreateOperation(operation, deps) {
+  const self2 = deps.nodeRegistry.getSelf();
+  return createLocalNodeWorkDirBranch(
+    self2.id,
+    self2.workDir ?? deps.workDir,
+    readPayloadString(operation, "path") || ".",
+    {
+      branchName: readPayloadString(operation, "branchName"),
+      startPoint: readPayloadString(operation, "startPoint"),
+      limit: readPayloadNumber(operation, "limit", 20),
+      offset: readPayloadNumber(operation, "offset", 0),
+      allowAbsolute: readPayloadBoolean(operation, "allowAbsolute", true)
+    }
+  );
 }
-function escapeHtmlAttribute(value) {
-  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+function readPayloadString(operation, key) {
+  const payload = operation.payload;
+  if (!payload || typeof payload !== "object") return "";
+  const value = payload[key];
+  return typeof value === "string" ? value : "";
 }
-function buildServicePreviewBridge(token) {
-  const previewRoot = `/preview/${token}/`;
-  const previewBase = previewRoot.replace(/\/$/, "");
-  const script = [
-    "(()=>{",
-    "if(window.top===window)return;",
-    `const previewBase=${JSON.stringify(previewBase)};`,
-    `const previewRoot=${JSON.stringify(previewRoot)};`,
-    "const rewritePreviewRequestUrl=(value)=>{",
-    "if(value==null)return value;",
-    "let raw;",
-    'try{raw=value instanceof URL?value.href:typeof value==="string"?value:value&&typeof value.url==="string"?value.url:undefined;}catch{return value;}',
-    "if(!raw)return value;",
-    "let url;",
-    "try{url=new URL(raw,window.location.href);}catch{return value;}",
-    "if(url.origin!==window.location.origin)return value;",
-    'if(url.pathname===previewBase||url.pathname.startsWith(previewRoot)||url.pathname.startsWith("/preview-open/"))return value;',
-    'return previewRoot+url.pathname.replace(/^\\/+/,"")+url.search+url.hash;',
-    "};",
-    "const rewritePreviewRequestInput=(input)=>{",
-    "const next=rewritePreviewRequestUrl(input);",
-    "if(next===input)return input;",
-    'if(typeof Request==="function"&&input instanceof Request)return new Request(next,input);',
-    "return next;",
-    "};",
-    "const originalFetch=window.fetch;",
-    'if(typeof originalFetch==="function")window.fetch=(input,init)=>originalFetch.call(window,rewritePreviewRequestInput(input),init);',
-    "const XHR=window.XMLHttpRequest;",
-    "if(XHR&&XHR.prototype){const open=XHR.prototype.open;XMLHttpRequest.prototype.open=function(method,url,...rest){return open.call(this,method,rewritePreviewRequestUrl(url),...rest);};}",
-    "const OriginalEventSource=window.EventSource;",
-    'if(typeof OriginalEventSource==="function"){window.EventSource=function(url,config){return new OriginalEventSource(rewritePreviewRequestUrl(url),config);};window.EventSource.prototype=OriginalEventSource.prototype;}',
-    "const currentPath=window.location.pathname;",
-    "if(currentPath===previewBase||currentPath.startsWith(previewRoot)){",
-    "const suffix=currentPath===previewBase?'':currentPath.slice(previewRoot.length);",
-    "const servicePath=suffix?'/' + suffix:'/';",
-    "window.history.replaceState(window.history.state,'',servicePath+window.location.search+window.location.hash);",
-    "}",
-    "})();"
-  ].join("");
-  return `<base data-meshy-preview-base href="${escapeHtmlAttribute(previewRoot)}"><script data-meshy-preview-bridge>${script}</script>`;
+function readPayloadNumber(operation, key, fallback) {
+  const payload = operation.payload;
+  if (!payload || typeof payload !== "object") return fallback;
+  const value = payload[key];
+  return typeof value === "number" ? value : fallback;
 }
-function injectServicePreviewBridge(value, token) {
-  const bridge = buildServicePreviewBridge(token);
-  const headPattern = /<head(?:\s[^>]*)?>/i;
-  if (headPattern.test(value)) {
-    return value.replace(headPattern, (match) => `${match}${bridge}`);
-  }
-  const htmlPattern = /<html(?:\s[^>]*)?>/i;
-  if (htmlPattern.test(value)) {
-    return value.replace(htmlPattern, (match) => `${match}<head>${bridge}</head>`);
-  }
-  return `${bridge}${value}`;
+function readPayloadBoolean(operation, key, fallback) {
+  const payload = operation.payload;
+  if (!payload || typeof payload !== "object") return fallback;
+  const value = payload[key];
+  return typeof value === "boolean" ? value : fallback;
 }
-function normalizeContentType(contentType) {
-  return contentType?.split(";")[0]?.trim().toLowerCase();
+function readSettingsSnapshot(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const snapshot = value.settingsSnapshot;
+  return snapshot && typeof snapshot === "object" ? snapshot : void 0;
 }
-function isServiceHtmlContentType(contentType) {
-  return normalizeContentType(contentType) === "text/html";
+function matchesFilter(operation, filter) {
+  return (!filter.nodeId || operation.nodeId === filter.nodeId) && (!filter.status || operation.status === filter.status) && (!filter.kind || operation.kind === filter.kind);
 }
-function isServiceEventStreamContentType(contentType) {
-  return normalizeContentType(contentType) === "text/event-stream";
+function isNodeOperation(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  return typeof record.id === "string" && typeof record.kind === "string" && typeof record.nodeId === "string" && typeof record.status === "string" && typeof record.createdAt === "number" && typeof record.updatedAt === "number";
 }
-function isServiceJavaScriptContentType(normalizedType) {
-  return normalizedType === "text/javascript" || normalizedType === "application/javascript" || normalizedType === "application/x-javascript";
+function clone2(value) {
+  return JSON.parse(JSON.stringify(value));
 }
-function rewriteServiceJavaScriptRuntimeUrls(value, token) {
-  if (!value.includes("__vite__mapDeps")) {
-    return value;
+
+// ../../packages/api/src/routes/node-workdir.ts
+function sendLocalNodeWorkDirTree(req, res, nodeId, options = {}) {
+  const query = NodeWorkDirTreeQuery.parse(req.query);
+  const { nodeRegistry, workDir, logger: logger27 } = req.app.locals.deps;
+  const self2 = nodeRegistry.getSelf();
+  if (options.requireSelfNode && nodeId !== self2.id) {
+    throw new MeshyError("NODE_NOT_FOUND", `Node ${nodeId} not found`, 404);
   }
-  const previewRoot = `/preview/${token}/`;
-  return value.replace(
-    /return\s*(['"])\/\1\s*\+\s*([A-Za-z_$][\w$]*)/g,
-    (_match, quote, argumentName) => `return${quote}${previewRoot}${quote}+${argumentName}`
+  const startedAt = Date.now();
+  const log2 = logger27?.child("nodes/workdir-local");
+  let logged = false;
+  let result;
+  let serviceDurationMs;
+  const logCompletion = (closed) => {
+    if (logged) return;
+    logged = true;
+    log2?.info?.("completed local node workdir tree request", {
+      nodeId: self2.id,
+      requestedNodeId: nodeId,
+      path: query.path,
+      directoriesOnly: query.directoriesOnly,
+      allowAbsolute: query.allowAbsolute,
+      limit: query.limit,
+      offset: query.offset,
+      entries: result?.entries.length,
+      total: result?.total,
+      serviceDurationMs,
+      durationMs: Date.now() - startedAt,
+      statusCode: res.statusCode,
+      closed
+    });
+  };
+  res.once("finish", () => logCompletion(false));
+  res.once("close", () => {
+    if (!res.writableEnded) {
+      logCompletion(true);
+    }
+  });
+  const serviceStartedAt = Date.now();
+  result = getLocalNodeWorkDirTree(
+    self2.id,
+    self2.workDir ?? workDir,
+    query.path,
+    {
+      limit: query.limit,
+      offset: query.offset,
+      directoriesOnly: query.directoriesOnly,
+      allowAbsolute: query.allowAbsolute
+    }
   );
+  serviceDurationMs = Date.now() - serviceStartedAt;
+  res.json(result);
 }
-function rewriteServiceResponseContent(content, contentType, token) {
-  const normalizedType = normalizeContentType(contentType);
-  if (normalizedType !== "text/html" && normalizedType !== "text/css" && !isServiceJavaScriptContentType(normalizedType)) {
-    return content;
+function sendLocalNodeWorkDirBranchInfo(req, res, nodeId, options = {}) {
+  const query = NodeWorkDirBranchQuery.parse(req.query);
+  const { nodeRegistry, workDir } = req.app.locals.deps;
+  const self2 = nodeRegistry.getSelf();
+  if (options.requireSelfNode && nodeId !== self2.id) {
+    throw new MeshyError("NODE_NOT_FOUND", `Node ${nodeId} not found`, 404);
   }
-  const source = content.toString("utf8");
-  const bridged = normalizedType === "text/html" ? injectServicePreviewBridge(source, token) : source;
-  const rewritten = rewriteServiceRootRelativeUrls(bridged, token);
-  return Buffer.from(
-    isServiceJavaScriptContentType(normalizedType) ? rewriteServiceJavaScriptRuntimeUrls(rewritten, token) : rewritten,
-    "utf8"
-  );
+  res.json(getLocalNodeWorkDirBranchInfo(
+    self2.id,
+    self2.workDir ?? workDir,
+    query.path,
+    {
+      limit: query.limit,
+      offset: query.offset,
+      allowAbsolute: query.allowAbsolute
+    }
+  ));
 }
-function rewriteServiceRedirectLocation(value, session) {
-  const previewRoot = `/preview/${session.token}`;
-  if (value.startsWith("/preview/")) {
-    return value;
+async function sendNodeWorkDirBranchCreateOperation(req, res, nodeId) {
+  const body = CreateNodeWorkDirBranchBody.parse(req.body);
+  const deps = req.app.locals.deps;
+  const self2 = deps.nodeRegistry.getSelf();
+  const isSelf = nodeId === self2.id;
+  if (!isSelf && !deps.election.isLeader()) {
+    throw new MeshyError("NOT_LEADER", "Only the leader can create branches on other nodes", 403);
   }
-  if (value.startsWith("/")) {
-    return `${previewRoot}${value}`;
+  const node = isSelf ? self2 : deps.nodeRegistry.getNode(nodeId);
+  if (!node) {
+    throw new MeshyError("NODE_NOT_FOUND", `Node ${nodeId} not found`, 404);
   }
-  try {
-    const url = new URL(value);
-    const isLocalService = (url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "[::1]") && url.port === String(session.port);
-    if (isLocalService) {
-      return `${previewRoot}${url.pathname}${url.search}${url.hash}`;
+  const payload = {
+    path: body.path,
+    branchName: body.branchName,
+    startPoint: body.startPoint,
+    limit: body.limit,
+    offset: body.offset,
+    allowAbsolute: body.allowAbsolute
+  };
+  const operations = getNodeOperationService(deps);
+  const operation = operations.create("workdir.branch-create", nodeId, payload);
+  if (isSelf) {
+    operations.runLocal(operation.id);
+  } else {
+    try {
+      await dispatchNodeOperation(deps, operation, node);
+    } catch (err) {
+      operations.markFailed(operation.id, err instanceof Error ? err.message : String(err));
+      throw new MeshyError("NODE_OFFLINE", `Cannot reach node ${nodeId} to create a git branch`, 502);
     }
-  } catch {
   }
-  return value;
+  res.status(202).json(operation);
 }
-function buildServiceResponseHeaders(upstream, session, isHtml) {
-  const headers = {};
-  upstream.headers.forEach((value, key) => {
-    const normalizedKey = key.toLowerCase();
-    if (HOP_BY_HOP_HEADERS.has(normalizedKey) || normalizedKey === "content-length" || normalizedKey === "content-encoding" || isHtml && normalizedKey === "content-security-policy" || isHtml && normalizedKey === "content-security-policy-report-only" || isHtml && normalizedKey === "x-frame-options") {
-      return;
-    }
-    if (normalizedKey === "location") {
-      headers[key] = rewriteServiceRedirectLocation(value, session);
-      return;
-    }
-    headers[key] = value;
-  });
-  if (typeof headers["cache-control"] !== "string") {
-    headers["cache-control"] = "no-cache";
-  }
-  return headers;
+
+// ../../packages/api/src/tasks/task-route-utils.ts
+var fs16 = __toESM(require("fs"), 1);
+var import_node_stream2 = require("stream");
+var import_promises5 = require("stream/promises");
+
+// ../../packages/api/src/node/node-message-compat.ts
+var LEGACY_KIND_BY_NODE_MESSAGE = {
+  "node.workdir.tree": "node-workdir-tree",
+  "node.workdir.branch-info": "node-workdir-branch-info",
+  "node.workdir.branch-create": "node-workdir-branch-create",
+  "node.sessions.list": "node-sessions-list",
+  "node.transport.set": "devtunnel",
+  "node.agent.upgrade": "node-agent-upgrade",
+  "task.cancel": "task-cancel",
+  "task.logs": "task-logs",
+  "task.output.summary": "task-output-summary",
+  "task.output.tree": "task-output-tree",
+  "task.output.content": "task-output-content",
+  "task.output.download": "task-output-download",
+  "task.output.diff": "task-output-diff",
+  "task.preview.create": "task-preview-session"
+};
+function canRequestNodeMessage(heartbeat) {
+  return !!(heartbeat?.requestNodeMessage || heartbeat?.requestWorkerControl);
 }
-async function pipeServiceResponseBody(upstream, res) {
-  if (!upstream.body) {
-    res.end();
-    return;
-  }
-  try {
-    await (0, import_promises6.pipeline)(import_node_stream3.Readable.fromWeb(upstream.body), res);
-  } catch (error) {
-    if (!res.destroyed && !res.writableEnded) {
-      throw error;
-    }
-  }
+function requestFallbackNodeMessage(heartbeat, nodeId, message) {
+  if (heartbeat.requestNodeMessage) return heartbeat.requestNodeMessage(nodeId, message);
+  if (heartbeat.requestWorkerControl) return heartbeat.requestWorkerControl(nodeId, toLegacyWorkerControl2(message));
+  throw new Error("Node message fallback is not available");
 }
-async function sendServicePreviewResponse(session, requestedPath, req, res) {
-  const decodedPath = decodeURIComponent(requestedPath ?? session.entryPath);
-  const { pathname, search } = splitPreviewPathAndSearch(decodedPath);
-  const targetPath = normalizeServiceRequestPath(pathname || session.entryPath);
-  const targetUrl = `http://127.0.0.1:${session.port}${targetPath}${search}`;
-  let upstream;
-  try {
-    const body = await readPreviewRequestBody(req);
-    upstream = await fetch(targetUrl, {
-      method: req?.method ?? "GET",
-      headers: buildServiceProxyHeaders(req),
-      ...body !== void 0 ? { body } : {},
-      redirect: "manual"
-    });
-  } catch {
-    res.writeHead(502, { "Content-Type": "text/plain" });
-    res.end("Preview service unavailable");
-    return;
-  }
-  const upstreamContentType = upstream.headers.get("content-type");
-  const isHtml = isServiceHtmlContentType(upstreamContentType);
-  const headers = buildServiceResponseHeaders(upstream, session, isHtml);
-  if (isServiceEventStreamContentType(upstreamContentType)) {
-    res.writeHead(upstream.status, headers);
-    await pipeServiceResponseBody(upstream, res);
-    return;
-  }
-  const content = rewriteServiceResponseContent(Buffer.from(await upstream.arrayBuffer()), upstreamContentType, session.token);
-  headers["content-length"] = content.length;
-  res.writeHead(upstream.status, headers);
-  res.end(content);
+function toLegacyWorkerControl2(message) {
+  return {
+    ...typeof message.payload === "object" && message.payload !== null ? message.payload : {},
+    kind: LEGACY_KIND_BY_NODE_MESSAGE[message.kind] ?? message.kind
+  };
 }
-function buildPreviewUrlForRequest(token, requestedPath, session) {
-  const { pathname, search } = splitPreviewPathAndSearch(requestedPath ?? session.entryPath);
-  return `${buildPreviewUrl("", { token, entryPath: pathname, kind: session.kind })}${search}`;
+
+// ../../packages/api/src/tasks/task-route-utils.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
 }
-function renderPreviewOpenDocument(previewUrl) {
-  const safePreviewUrl = escapeHtmlAttribute(previewUrl);
-  return Buffer.from(`<!doctype html>
-<html>
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Preview</title>
-  <style>
-    html, body { width: 100%; height: 100%; margin: 0; background: #fff; }
-    iframe { display: block; width: 100%; height: 100%; border: 0; }
-  </style>
-</head>
-<body>
-  <iframe src="${safePreviewUrl}" title="Preview"></iframe>
-</body>
-</html>`, "utf8");
+function restoreTaskState(taskEngine, task) {
+  taskEngine.updateTask(task.id, {
+    status: task.status,
+    result: task.result,
+    error: task.error,
+    assignedTo: task.assignedTo
+  });
 }
-function sendPreviewOpenResponse(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;
+function readLocalTaskLogs(engineRegistry, taskId, after, agent) {
+  const engine = engineRegistry.get(agent);
+  if (!engine) {
+    throw new MeshyError("VALIDATION_ERROR", `Engine not registered for agent: ${agent}`, 400);
+  }
+  const logPath = engine.getLogPath(taskId);
+  if (!fs16.existsSync(logPath)) {
+    return { logs: [], total: 0 };
   }
-  const content = renderPreviewOpenDocument(buildPreviewUrlForRequest(token, requestedPath, session));
-  res.writeHead(200, {
-    "Content-Type": "text/html",
-    "Content-Length": content.length,
-    "Cache-Control": "no-cache"
-  });
-  res.end(content);
+  const content = fs16.readFileSync(logPath, "utf-8");
+  const allLines = content.trim().split("\n").filter(Boolean);
+  const logs = [];
+  for (let i = after; i < allLines.length; i++) {
+    try {
+      logs.push(JSON.parse(allLines[i]));
+    } catch {
+    }
+  }
+  return { logs, total: allLines.length };
 }
-async function sendPreviewAssetResponse(sessionManager, token, requestedPath, res, req) {
-  const session = sessionManager.get(token);
-  if (!session) {
-    res.writeHead(403, { "Content-Type": "text/plain" });
-    res.end("Invalid or expired preview token");
+function recordLocalTaskLogs(engineRegistry, task, logs) {
+  if (logs.length === 0) {
     return;
   }
-  if (session.kind === "service") {
-    await sendServicePreviewResponse(session, requestedPath, req, res);
-    return;
+  const engine = engineRegistry.get(task.agent);
+  if (!engine) {
+    throw new MeshyError("VALIDATION_ERROR", `Engine not registered for agent: ${task.agent}`, 400);
   }
-  if (!isReadOnlyPreviewMethod(req?.method)) {
-    res.writeHead(405, { "Content-Type": "text/plain" });
-    res.end("Method not allowed");
-    return;
+  for (const event of logs) {
+    engine.recordOutput(task.id, event);
   }
-  const { pathname } = splitPreviewPathAndSearch(decodeURIComponent(requestedPath ?? session.entryPath));
-  const resolvedRequestedPath = pathname || session.entryPath;
-  let resolved;
-  try {
-    resolved = resolvePreviewPath(session.rootPath, resolvedRequestedPath).absolutePath;
-  } catch {
-    res.writeHead(400, { "Content-Type": "text/plain" });
-    res.end("Invalid path");
-    return;
+}
+function parseEventTimestamp(event) {
+  if (typeof event.timestamp !== "string") {
+    return null;
   }
-  if (!fs16.existsSync(resolved) || !fs16.statSync(resolved).isFile()) {
-    res.writeHead(404, { "Content-Type": "text/plain" });
-    res.end("File not found");
-    return;
+  const parsed = Date.parse(event.timestamp);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function getTaskUserMessageSignature(value) {
+  const content = normalizeTaskUserMessageContent(value);
+  if (content.length === 0) {
+    return null;
   }
-  const ext = path17.extname(resolved).toLowerCase();
-  const mime = ext === ".md" || ext === ".mdx" ? "text/html" : getMime(resolved);
-  const content = ext === ".md" || ext === ".mdx" ? renderMarkdownDocument(fs16.readFileSync(resolved, "utf8"), path17.basename(resolved)) : fs16.readFileSync(resolved);
-  res.writeHead(200, {
-    "Content-Type": mime,
-    "Content-Length": content.length,
-    "Cache-Control": "no-cache"
-  });
-  res.end(content);
+  return content.map((part) => {
+    if (part.type === "text") return `t:${part.text}`;
+    if (part.type === "tool_result") return `r:${part.toolUseId}:${part.isError === true ? "1" : "0"}:${part.content}`;
+    const dataStart = part.data.slice(0, 32);
+    const dataEnd = part.data.slice(-32);
+    return `i:${part.mediaType}:${part.data.length}:${dataStart}:${dataEnd}`;
+  }).join("|");
 }
-async function handlePreviewRequest(sessionManager, req, res) {
-  const url = new URL(req.url ?? "/", "http://localhost");
-  if (!url.pathname.startsWith("/preview/") && !url.pathname.startsWith("/preview-open/")) {
-    return false;
+function normalizeStructuredValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeStructuredValue(entry));
   }
-  const openMatch = url.pathname.match(/^\/preview-open\/([a-f0-9]+)(?:\/(.*))?$/i);
-  if (openMatch?.[1]) {
-    if (!isReadOnlyPreviewMethod(req.method)) {
-      res.writeHead(405, { "Content-Type": "text/plain" });
-      res.end("Method not allowed");
-      return true;
+  if (!isRecord4(value)) {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([key, entryValue]) => [key, normalizeStructuredValue(entryValue)])
+  );
+}
+function getTranscriptEventSignature(event) {
+  if (event.type === "user") {
+    const signature = getTaskUserMessageSignature(isRecord4(event.message) ? event.message.content : event.message) ?? getTaskUserMessageSignature(event.content);
+    return signature ? `user:${signature}` : null;
+  }
+  if (event.type === "assistant") {
+    if (typeof event.message === "string") {
+      return `assistant:${JSON.stringify(event.message)}`;
+    }
+    if (isRecord4(event.message) && "content" in event.message) {
+      return `assistant:${JSON.stringify(normalizeStructuredValue(event.message.content))}`;
+    }
+    if (Array.isArray(event.content)) {
+      return `assistant:${JSON.stringify(normalizeStructuredValue(event.content))}`;
+    }
+    if (isRecord4(event.message)) {
+      return `assistant:${JSON.stringify(normalizeStructuredValue(event.message))}`;
     }
-    const requestedPath2 = openMatch[2];
-    sendPreviewOpenResponse(sessionManager, openMatch[1], requestedPath2 ? `${requestedPath2}${url.search}` : url.search || void 0, res);
-    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 null;
+}
+function sortLogsChronologically(events) {
+  return events.map((event, index) => ({ event, index })).sort((left, right) => {
+    const leftTimestamp = parseEventTimestamp(left.event);
+    const rightTimestamp = parseEventTimestamp(right.event);
+    if (leftTimestamp !== null && rightTimestamp !== null && leftTimestamp !== rightTimestamp) {
+      return leftTimestamp - rightTimestamp;
+    }
+    return left.index - right.index;
+  }).map((entry) => entry.event);
+}
+function timestampsMatch(left, right) {
+  const leftTimestamp = parseEventTimestamp(left);
+  const rightTimestamp = parseEventTimestamp(right);
+  if (leftTimestamp === null || rightTimestamp === null) {
     return true;
   }
-  const requestedPath = match?.[2];
-  await sendPreviewAssetResponse(sessionManager, token, requestedPath ? `${requestedPath}${url.search}` : url.search || void 0, res, req);
-  return true;
+  return Math.abs(leftTimestamp - rightTimestamp) <= 6e4;
 }
-
-// ../../packages/api/src/preview/preview-proxy.ts
-var PREVIEW_ASSET_PROXY_TIMEOUT_MS = 1e4;
-function describeProxyError(error) {
-  if (error instanceof Error) {
-    const errorCategory = error.name === "AbortError" || /aborted/i.test(error.message) ? "abort" : /timeout/i.test(error.message) ? "timeout" : "network";
-    return {
-      errorName: error.name,
-      errorMessage: error.message,
-      errorCategory
-    };
-  }
-  return {
-    errorName: "UnknownError",
-    errorMessage: String(error),
-    errorCategory: "unknown"
-  };
+function transcriptEvents(events) {
+  return events.flatMap((event, index) => {
+    const signature = getTranscriptEventSignature(event);
+    return signature ? [{ index, event, signature }] : [];
+  });
 }
-function createPreviewAssetProxyTrace(log2, token, nodeId, requestPath, proxyPath) {
-  return {
-    onAttempt: ({ attempt, endpoint, timeoutMs, totalEndpoints }) => {
-      log2.debug("preview asset proxy attempt", {
-        token,
-        nodeId,
-        requestPath,
-        proxyPath,
-        endpoint,
-        attempt,
-        totalEndpoints,
-        timeoutMs
-      });
-    },
-    onResponse: ({ attempt, endpoint, response, timeoutMs, totalEndpoints }) => {
-      log2.debug("preview asset proxy response", {
-        token,
-        nodeId,
-        requestPath,
-        proxyPath,
-        endpoint,
-        attempt,
-        totalEndpoints,
-        timeoutMs,
-        ok: response.ok,
-        statusCode: response.status
-      });
-    },
-    onError: ({ attempt, endpoint, error, timeoutMs, totalEndpoints }) => {
-      log2.warn("preview asset proxy attempt failed", {
-        token,
-        nodeId,
-        requestPath,
-        proxyPath,
-        endpoint,
-        attempt,
-        totalEndpoints,
-        timeoutMs,
-        ...describeProxyError(error)
-      });
+function findLocalTranscriptDuplicates(nativeLogs, localLogs) {
+  const nativeTranscript = transcriptEvents(nativeLogs);
+  const localTranscript = transcriptEvents(localLogs);
+  if (nativeTranscript.length === 0 || localTranscript.length === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const localEvent of localTranscript) {
+    if (nativeTranscript.some((nativeEvent) => nativeEvent.signature === localEvent.signature && timestampsMatch(nativeEvent.event, localEvent.event))) {
+      duplicates.add(localEvent.index);
     }
-  };
+  }
+  return duplicates;
 }
-function parsePreviewRequest(previewUrl) {
-  const url = new URL(previewUrl, "http://localhost");
-  const match = url.pathname.match(/^\/preview\/([a-f0-9]+)(?:\/(.*))?$/i);
-  const token = match?.[1];
-  if (!token) {
-    return null;
+function mergeNativeSessionLogs(nativeLogs, localLogs) {
+  if (localLogs.length === 0) {
+    return nativeLogs;
   }
-  const requestedPath = match?.[2];
-  return {
-    token,
-    requestedPath: requestedPath ? `${requestedPath}${url.search}` : url.search || void 0
-  };
+  const duplicateLocalIndexes = findLocalTranscriptDuplicates(nativeLogs, localLogs);
+  const retainedLocalLogs = localLogs.filter((_, index) => !duplicateLocalIndexes.has(index));
+  if (retainedLocalLogs.length === 0) {
+    return nativeLogs;
+  }
+  return sortLogsChronologically([...nativeLogs, ...retainedLocalLogs]);
 }
-function parsePreviewOpenRequest(previewUrl) {
-  const url = new URL(previewUrl, "http://localhost");
-  const match = url.pathname.match(/^\/preview-open\/([a-f0-9]+)(?:\/(.*))?$/i);
-  const token = match?.[1];
-  if (!token) {
-    return null;
+function readLocalTaskLogsWithNativeHistory(engineRegistry, task, taskId, after, agent) {
+  const local = readLocalTaskLogs(engineRegistry, taskId, after, agent);
+  const sessionId = typeof task?.payload?.sessionId === "string" ? task.payload.sessionId : "";
+  if (after > 0 || task?.conversationKind !== "nativeSession" || !sessionId || task.agent !== "codex" && task.agent !== "claudecode") {
+    return local;
+  }
+  const history = loadNativeSessionHistory({ agent: task.agent, sessionId });
+  if (history.logs.length === 0) {
+    return local;
+  }
+  if (local.total > 0) {
+    const logs = mergeNativeSessionLogs(history.logs, local.logs);
+    return { logs, total: logs.length };
+  }
+  recordLocalTaskLogs(engineRegistry, task, history.logs);
+  return readLocalTaskLogs(engineRegistry, taskId, after, agent);
+}
+async function seedTaskSnapshotOnWorker(task, logs, node, log2, timeoutMs = 1e4) {
+  const proxyPath = "/api/worker/import-task";
+  const { endpoint, response } = await fetchNodeWithFallback(
+    node,
+    proxyPath,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ task, logs })
+    },
+    timeoutMs,
+    void 0,
+    { preferPublicEndpoint: true }
+  );
+  if (!response.ok) {
+    const failure = await response.text().catch(() => "");
+    throw new MeshyError("NODE_OFFLINE", failure || `Failed to seed task on ${node.name} (${response.status})`, 502);
   }
-  const requestedPath = match?.[2];
-  const suffix = requestedPath !== void 0 ? `/${requestedPath}` : "";
-  return {
-    token,
-    previewUrl: `/preview/${token}${suffix}${url.search}`
-  };
+  const body = await response.json().catch(() => null);
+  const seededLogs = Array.isArray(body?.logs) ? body.logs : logs;
+  log2.info("seeded task snapshot on worker", {
+    taskId: task.id,
+    assignedTo: node.id,
+    endpoint,
+    importedLogCount: seededLogs.length
+  });
+  return seededLogs;
 }
-function extractPreviewToken(previewUrl) {
-  return parsePreviewRequest(previewUrl)?.token ?? null;
+async function requestTaskLogsOverKeepalive(heartbeat, nodeId, task, after) {
+  if (!canRequestNodeMessage(heartbeat)) return null;
+  const message = createNodeMessage("task.logs", { taskId: task.id, after, task }, { expectsResponse: true });
+  return requestFallbackNodeMessage(heartbeat, nodeId, message);
 }
-function buildPreviewAssetProxyPath(token, requestedPath) {
-  const search = new URLSearchParams({ token });
-  if (requestedPath) {
-    search.set("path", decodeURIComponent(requestedPath));
+async function sendProxyResponse(res, proxyRes) {
+  const contentType = proxyRes.headers.get("content-type");
+  const contentDisposition = proxyRes.headers.get("content-disposition");
+  const cacheControl = proxyRes.headers.get("cache-control");
+  if (contentType) res.setHeader("Content-Type", contentType);
+  if (contentDisposition) res.setHeader("Content-Disposition", contentDisposition);
+  if (cacheControl) res.setHeader("Cache-Control", cacheControl);
+  if (contentType?.split(";")[0]?.trim().toLowerCase() === "text/event-stream") {
+    if (!cacheControl) res.setHeader("Cache-Control", "no-cache");
+    res.status(proxyRes.status);
+    res.flushHeaders();
+    if (!proxyRes.body) {
+      res.end();
+      return;
+    }
+    try {
+      await (0, import_promises5.pipeline)(import_node_stream2.Readable.fromWeb(proxyRes.body), res);
+    } catch (error) {
+      if (!res.destroyed && !res.writableEnded) {
+        throw error;
+      }
+    }
+    return;
   }
-  return `/api/worker/preview-asset?${search.toString()}`;
+  const body = Buffer.from(await proxyRes.arrayBuffer());
+  res.status(proxyRes.status).send(body);
 }
-var PreviewProxyManager = class {
-  sessions = /* @__PURE__ */ new Map();
-  register(token, nodeId, expiresAt) {
-    this.sessions.set(token, { token, nodeId, expiresAt });
+async function maybeProxyReadToLeader(req, res, options = {}) {
+  const { dataRouter, nodeRegistry, logger: rootLogger } = req.app.locals.deps;
+  const methods = new Set((options.methods ?? ["GET"]).map((method) => method.toUpperCase()));
+  if (!methods.has(req.method.toUpperCase()) || nodeRegistry?.isLeader?.() !== false || !dataRouter?.proxyToLeader) {
+    return false;
   }
-  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;
+  const leaderEndpoint = dataRouter.getLeaderEndpoint?.();
+  if (!leaderEndpoint) {
+    return false;
   }
-  cleanup() {
-    const now = Date.now();
-    for (const [token, session] of this.sessions) {
-      if (session.expiresAt <= now) {
-        this.sessions.delete(token);
-      }
+  try {
+    const result = await dataRouter.proxyToLeader(req);
+    for (const [key, value] of Object.entries(result.headers)) {
+      if (key.toLowerCase() === "content-length" || key.toLowerCase() === "transfer-encoding") continue;
+      res.setHeader(key, value);
     }
+    res.status(result.status).json(result.body);
+    return true;
+  } catch (error) {
+    const log2 = rootLogger?.child?.("tasks/leader-read-proxy") ?? rootLogger;
+    log2?.warn?.("leader read proxy failed", {
+      path: req.originalUrl ?? req.url,
+      leaderEndpoint,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    throw error instanceof MeshyError ? error : new MeshyError("NODE_OFFLINE", "Leader unreachable", 502);
   }
-};
-function rewritePreviewSessionPayloadForProxy(manager, payload, nodeId) {
-  const token = extractPreviewToken(payload.previewUrl);
-  if (!token) {
-    return payload;
-  }
-  manager.register(token, nodeId, payload.expiresAt);
+}
+
+// ../../packages/api/src/node/node-native-session-service.ts
+function getLocalNodeNativeSessions(nodeId, agent, limit) {
   return {
-    ...payload,
-    previewUrl: buildPreviewUrl("", {
-      token,
-      entryPath: payload.entryPath,
-      kind: payload.kind
-    }),
-    ...payload.kind === "service" || payload.openUrl ? {
-      openUrl: buildPreviewOpenUrl("", {
-        token,
-        entryPath: payload.entryPath,
-        kind: payload.kind
-      })
-    } : {}
+    nodeId,
+    agent,
+    sessions: listNativeSessions({ agent, limit })
   };
 }
-async function handlePreviewProxyRequest(manager, nodeRegistry, logger27, req, res) {
-  const requestPath = req.originalUrl ?? req.url;
-  const previewOpenRequest = parsePreviewOpenRequest(requestPath);
-  if (previewOpenRequest) {
-    const session2 = manager.get(previewOpenRequest.token);
-    if (!session2) {
-      return false;
+
+// ../../packages/api/src/tasks/task-cancellation.ts
+var TERMINAL_STATUSES2 = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "archived"]);
+function cancelTaskOnCurrentNode(deps, taskId, options = {}) {
+  const task = deps.taskEngine.getTask(taskId);
+  if (!task) {
+    if (options.missingOk) {
+      return {
+        task: null,
+        cancelled: false,
+        engineCancelRequested: false,
+        missing: true,
+        terminal: false
+      };
     }
-    const content = renderPreviewOpenDocument(previewOpenRequest.previewUrl);
-    res.status(200).set({
-      "Content-Type": "text/html",
-      "Content-Length": String(content.length),
-      "Cache-Control": "no-cache"
-    }).send(content);
-    return true;
-  }
-  const previewRequest = parsePreviewRequest(requestPath);
-  if (!previewRequest) {
-    return false;
+    throw new MeshyError("TASK_NOT_FOUND", `Task ${taskId} not found`, 404);
   }
-  const session = manager.get(previewRequest.token);
-  if (!session) {
-    return false;
+  if (TERMINAL_STATUSES2.has(task.status)) {
+    if (options.terminalOk) {
+      return {
+        task,
+        cancelled: false,
+        engineCancelRequested: false,
+        missing: false,
+        terminal: true
+      };
+    }
+    throw new MeshyError("VALIDATION_ERROR", `Task ${taskId} cannot be cancelled (status: ${task.status})`, 400);
   }
-  const node = nodeRegistry.getNode(session.nodeId);
-  if (!node) {
-    throw new MeshyError("NODE_NOT_FOUND", `Preview worker ${session.nodeId} not found`, 404);
+  let engineCancelRequested = false;
+  if (task.status === "running") {
+    const engine = deps.engineRegistry.get(task.agent);
+    if (!engine || typeof engine.cancelTask !== "function") {
+      deps.logger.warn("engine not registered while cancelling running task", {
+        taskId,
+        agent: task.agent
+      });
+    } else {
+      engineCancelRequested = engine.cancelTask(taskId);
+      if (!engineCancelRequested) {
+        deps.logger.warn("running task had no active engine process to cancel", {
+          taskId,
+          agent: task.agent
+        });
+      }
+    }
   }
-  const previewLog = logger27.child("preview-proxy");
-  const proxyPath = buildPreviewAssetProxyPath(previewRequest.token, previewRequest.requestedPath);
-  try {
-    const body = await readPreviewRequestBody(req);
-    const { endpoint, response } = await fetchNodeWithFallback(
-      node,
-      proxyPath,
-      {
-        method: req.method,
-        headers: buildPreviewWorkerProxyHeaders(req),
-        ...body !== void 0 ? { body } : {}
-      },
-      PREVIEW_ASSET_PROXY_TIMEOUT_MS,
-      createPreviewAssetProxyTrace(previewLog, previewRequest.token, session.nodeId, requestPath, proxyPath),
-      { preferPublicEndpoint: true }
-    );
-    previewLog.debug("proxying preview asset from assigned worker", {
-      token: previewRequest.token,
-      nodeId: session.nodeId,
-      requestPath,
-      proxyPath,
-      endpoint
-    });
-    await sendProxyResponse(res, response);
-    return true;
-  } catch (err) {
-    previewLog.warn("preview asset proxy error", {
-      token: previewRequest.token,
-      nodeId: session.nodeId,
-      requestPath,
-      proxyPath,
-      timeoutMs: PREVIEW_ASSET_PROXY_TIMEOUT_MS,
-      ...describeProxyError(err)
-    });
-    throw new MeshyError("NODE_OFFLINE", "Cannot reach worker for preview asset", 502);
+  const cancelled = deps.taskEngine.cancelTask(taskId);
+  if (!cancelled) {
+    throw new MeshyError("VALIDATION_ERROR", `Task ${taskId} cannot be cancelled`, 400);
   }
+  return {
+    task,
+    cancelled: true,
+    engineCancelRequested,
+    missing: false,
+    terminal: false
+  };
 }
 
-// ../../packages/api/src/tasks/task-output-service.ts
-var TASK_OUTPUT_ROUTE_PREFIX = "/api/tasks";
-function getTask(taskEngine, taskId) {
-  const task = taskEngine.getTask(taskId);
-  if (!task) {
-    throw new MeshyError("TASK_NOT_FOUND", `Task ${taskId} not found`, 404);
-  }
-  return task;
+// ../../packages/api/src/tasks/task-output-service.ts
+var fs18 = __toESM(require("fs"), 1);
+var path19 = __toESM(require("path"), 1);
+
+// ../../packages/api/src/preview/preview-server.ts
+var crypto3 = __toESM(require("crypto"), 1);
+var fs17 = __toESM(require("fs"), 1);
+var path18 = __toESM(require("path"), 1);
+var http2 = __toESM(require("http"), 1);
+var import_node_stream3 = require("stream");
+var import_promises6 = require("stream/promises");
+
+// ../../packages/api/src/preview/preview-request.ts
+var PREVIEW_AUTHORIZATION_HEADER = "x-meshy-preview-authorization";
+var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+function isReadOnlyPreviewMethod(method) {
+  const normalizedMethod = method?.toUpperCase() ?? "GET";
+  return normalizedMethod === "GET" || normalizedMethod === "HEAD";
 }
-function getTaskOutputRoot(taskEngine, taskId) {
-  const task = getTask(taskEngine, taskId);
-  if (!task.effectiveProjectPath) {
-    throw new MeshyError("VALIDATION_ERROR", "Task output not available", 400);
-  }
-  return task.effectiveProjectPath;
+function methodAllowsRequestBody(method) {
+  return !isReadOnlyPreviewMethod(method);
 }
-function buildTaskOutputDownloadUrl(taskId, filePath) {
-  return `${TASK_OUTPUT_ROUTE_PREFIX}/${taskId}/output/download?path=${encodeURIComponent(filePath)}`;
+function toArrayBuffer(value) {
+  const copy = new Uint8Array(value.byteLength);
+  copy.set(value);
+  return copy.buffer;
 }
-function getLocalTaskOutputSummary(taskEngine, taskId) {
-  const task = getTask(taskEngine, taskId);
-  if (!task.effectiveProjectPath) {
-    return {
-      taskId: task.id,
-      requestedProject: task.project,
-      effectiveProjectPath: null,
-      assignedTo: task.assignedTo,
-      available: false,
-      summary: null
-    };
+function getParsedRequestBody(req) {
+  const body = req.body;
+  if (body === void 0) {
+    return void 0;
   }
-  return {
-    taskId: task.id,
-    requestedProject: task.project,
-    effectiveProjectPath: task.effectiveProjectPath,
-    assignedTo: task.assignedTo,
-    available: true,
-    summary: getOutputSummary(task.effectiveProjectPath)
-  };
+  if (typeof body === "string" || body instanceof URLSearchParams || body instanceof Blob || body instanceof FormData) {
+    return body;
+  }
+  if (Buffer.isBuffer(body)) {
+    return toArrayBuffer(body);
+  }
+  if (body instanceof Uint8Array) {
+    return toArrayBuffer(body);
+  }
+  return JSON.stringify(body);
 }
-function getLocalTaskOutputTree(taskEngine, taskId, currentPath) {
-  const rootPath = getTaskOutputRoot(taskEngine, taskId);
-  try {
-    return {
-      rootPath,
-      currentPath,
-      entries: listDirectory(rootPath, currentPath)
-    };
-  } catch (err) {
-    if (err instanceof Error && err.message === "Path traversal detected") {
-      throw new MeshyError("VALIDATION_ERROR", "Invalid directory path", 400);
-    }
-    throw err;
+async function readPreviewRequestBody(req) {
+  if (!req || !methodAllowsRequestBody(req.method)) {
+    return void 0;
+  }
+  const parsedBody = getParsedRequestBody(req);
+  if (parsedBody !== void 0) {
+    return parsedBody;
+  }
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
   }
+  return chunks.length > 0 ? toArrayBuffer(Buffer.concat(chunks)) : void 0;
 }
-function getLocalTaskOutputContent(taskEngine, taskId, filePath) {
-  const rootPath = getTaskOutputRoot(taskEngine, taskId);
-  try {
-    return {
-      ...readFileContent(rootPath, filePath),
-      downloadUrl: buildTaskOutputDownloadUrl(taskId, filePath)
-    };
-  } catch (err) {
-    if (err instanceof Error && err.message === "Path traversal detected") {
-      throw new MeshyError("VALIDATION_ERROR", "Invalid file path", 400);
+function buildServiceProxyHeaders(req) {
+  const headers = {};
+  if (!req) {
+    return headers;
+  }
+  let previewAuthorization;
+  for (const [key, value] of Object.entries(req.headers)) {
+    const normalizedKey = key.toLowerCase();
+    if (HOP_BY_HOP_HEADERS.has(normalizedKey) || normalizedKey === "host" || normalizedKey === "content-length" || normalizedKey === "forwarded" || normalizedKey === "x-real-ip" || normalizedKey.startsWith("x-forwarded-") || normalizedKey === MESHY_AUTHORIZATION_HEADER) {
+      continue;
     }
-    if (err instanceof Error && err.message === "File not found") {
-      throw new MeshyError("TASK_NOT_FOUND", `File not found: ${filePath}`, 404);
+    if (normalizedKey === PREVIEW_AUTHORIZATION_HEADER) {
+      previewAuthorization = Array.isArray(value) ? value[0] : value;
+      continue;
     }
-    throw err;
+    if (Array.isArray(value)) {
+      headers[key] = value.join(", ");
+    } else if (typeof value === "string") {
+      headers[key] = value;
+    }
+  }
+  if (previewAuthorization && !headers.authorization) {
+    headers.authorization = previewAuthorization;
   }
+  return headers;
 }
-function getLocalTaskOutputDownload(taskEngine, taskId, filePath) {
-  const rootPath = getTaskOutputRoot(taskEngine, taskId);
-  try {
-    const absolutePath = resolveOutputPath(rootPath, filePath);
-    if (!fs17.existsSync(absolutePath) || !fs17.statSync(absolutePath).isFile()) {
-      throw new MeshyError("TASK_NOT_FOUND", `File not found: ${filePath}`, 404);
+function buildPreviewWorkerProxyHeaders(req) {
+  const headers = {};
+  let previewAuthorization;
+  for (const [key, value] of Object.entries(req.headers)) {
+    const normalizedKey = key.toLowerCase();
+    if (HOP_BY_HOP_HEADERS.has(normalizedKey) || normalizedKey === "host" || normalizedKey === "content-length" || normalizedKey === MESHY_AUTHORIZATION_HEADER || normalizedKey === PREVIEW_AUTHORIZATION_HEADER) {
+      continue;
     }
-    const { mimeType } = classifyFile(absolutePath);
-    const fileName = path18.basename(absolutePath).replace(/"/g, "");
-    return {
-      content: fs17.readFileSync(absolutePath),
-      headers: {
-        "Content-Type": mimeType,
-        "Content-Disposition": `inline; filename="${fileName}"`,
-        "Cache-Control": "no-cache"
-      }
-    };
-  } catch (err) {
-    if (err instanceof MeshyError) {
-      throw err;
+    if (normalizedKey === "authorization") {
+      previewAuthorization = Array.isArray(value) ? value[0] : value;
+      continue;
     }
-    if (err instanceof Error && err.message === "Path traversal detected") {
-      throw new MeshyError("VALIDATION_ERROR", "Invalid file path", 400);
+    if (Array.isArray(value)) {
+      headers[key] = value.join(", ");
+    } else if (typeof value === "string") {
+      headers[key] = value;
     }
-    throw err;
-  }
-}
-function getLocalTaskOutputDiff(taskEngine, taskId) {
-  const rootPath = getTaskOutputRoot(taskEngine, taskId);
-  return getGitDiff(rootPath);
-}
-async function createPreviewSessionPayload(deps, taskId, optionsOrPath, requestOrigin) {
-  const previewManager = deps.previewSessionManager;
-  if (!previewManager) {
-    throw new MeshyError("VALIDATION_ERROR", "Preview not available on this node", 400);
   }
-  const options = typeof optionsOrPath === "string" ? { path: optionsOrPath } : optionsOrPath ?? {};
-  getTask(deps.taskEngine, taskId);
-  const session = options.port !== void 0 ? previewManager.create({
-    taskId,
-    port: options.port,
-    entryPath: options.path
-  }) : previewManager.create({
-    taskId,
-    rootPath: getTaskOutputRoot(deps.taskEngine, taskId),
-    entryPath: options.path
-  });
-  const origin = requestOrigin ?? deps.dashboardOrigin ?? deps.localDashboardOrigin;
-  if (!origin) {
-    throw new MeshyError("VALIDATION_ERROR", "Preview origin not available", 502);
+  if (previewAuthorization) {
+    headers[PREVIEW_AUTHORIZATION_HEADER] = previewAuthorization;
   }
-  return {
-    previewUrl: buildPreviewUrl(origin, session),
-    ...session.kind === "service" ? { openUrl: buildPreviewOpenUrl(origin, session) } : {},
-    expiresAt: session.expiresAt,
-    entryPath: session.entryPath,
-    kind: session.kind,
-    ...session.kind === "service" ? { port: session.port } : {}
-  };
+  return headers;
 }
 
-// ../../packages/api/src/node/agent-upgrade-service.ts
-var import_node_child_process9 = require("child_process");
-
-// ../../packages/api/src/app/system-info.ts
-var os6 = __toESM(require("os"), 1);
-var import_node_child_process8 = require("child_process");
-var RUNTIME_TOOLS = [
-  { id: "claude", label: "Claude Code", command: "claude", packageName: "@anthropic-ai/claude-code" },
-  { id: "codex", label: "Codex", command: "codex", packageName: "@openai/codex" }
-];
-var runtimeToolUpdateCache = /* @__PURE__ */ new Map();
-function clearRuntimeToolUpdateCache(packageName) {
-  if (packageName) {
-    runtimeToolUpdateCache.delete(packageName);
-    return;
-  }
-  runtimeToolUpdateCache.clear();
-}
-function runRuntimeToolCommand(command, args, platform2) {
-  const result = (0, import_node_child_process8.spawnSync)(command, args, {
-    encoding: "utf-8",
-    shell: platform2 === "win32" && command !== "where",
-    windowsHide: true,
-    timeout: 2500
-  });
-  return {
-    status: result.status,
-    stdout: typeof result.stdout === "string" ? result.stdout : "",
-    stderr: typeof result.stderr === "string" ? result.stderr : "",
-    error: result.error?.message ?? null
-  };
-}
-function normalizeOutput(output) {
-  if (!output) {
-    return null;
-  }
-  const firstLine = output.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
-  return firstLine ?? null;
-}
-function formatLocalDate(date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  return `${year}-${month}-${day}`;
-}
-function resolveCommandPath(command, commandRunner, platform2) {
-  const lookupCommand = platform2 === "win32" ? "where" : "which";
-  const result = commandRunner(lookupCommand, [command]);
-  if (result.status === 0) {
-    return { path: normalizeOutput(result.stdout) };
+// ../../packages/api/src/preview/preview-server.ts
+function resolvePreviewPath(rootPath, relativePath) {
+  const sanitizedPath = relativePath.replace(/\\/g, "/");
+  const resolvedPath = path18.resolve(rootPath, sanitizedPath);
+  const normalizedRoot = path18.resolve(rootPath);
+  if (!resolvedPath.startsWith(normalizedRoot + path18.sep) && resolvedPath !== normalizedRoot) {
+    throw new Error("Invalid preview path");
   }
   return {
-    path: null,
-    detail: normalizeOutput(result.stderr) ?? result.error ?? null
+    absolutePath: resolvedPath,
+    normalizedPath: path18.relative(normalizedRoot, resolvedPath).split(path18.sep).join("/")
   };
 }
-function extractSemver(value) {
-  return value?.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/)?.[0] ?? null;
+function resolvePreviewEntryPath(rootPath, entryPath) {
+  const { absolutePath, normalizedPath } = resolvePreviewPath(rootPath, entryPath ?? "index.html");
+  if (!fs17.existsSync(absolutePath) || !fs17.statSync(absolutePath).isFile()) {
+    throw new Error("Preview entry not found");
+  }
+  return normalizedPath;
 }
-function normalizePackageVersion(output) {
-  if (!output) return null;
-  const trimmed = output.trim();
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (typeof parsed === "string") {
-      return parsed.trim() || null;
-    }
-  } catch {
+function normalizeServiceEntryPath(entryPath) {
+  if (!entryPath || entryPath === "/") {
+    return "";
   }
-  return normalizeOutput(trimmed);
+  return entryPath.replace(/\\/g, "/").replace(/^\/+/, "");
 }
-function normalizeInstalledPackageVersion(output, packageName) {
-  if (!output) return null;
-  const trimmed = output.trim();
-  try {
-    const parsed = JSON.parse(trimmed);
-    const version2 = parsed.dependencies?.[packageName]?.version;
-    if (typeof version2 === "string") {
-      return version2.trim() || null;
+function assertPreviewServicePort(port) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error("Invalid preview service port");
+  }
+  return port;
+}
+function buildPreviewUrl(origin, session) {
+  return buildPreviewRouteUrl(origin, "preview", session);
+}
+function buildPreviewOpenUrl(origin, session) {
+  return buildPreviewRouteUrl(origin, "preview-open", session);
+}
+function buildPreviewRouteUrl(origin, route, session) {
+  const encodedEntryPath = session.entryPath.split("/").filter(Boolean).map((segment) => encodeURIComponent(segment)).join("/");
+  const suffix = encodedEntryPath.length > 0 ? `/${encodedEntryPath}` : session.kind === "service" ? "/" : "";
+  return `${origin.replace(/\/+$/, "")}/${route}/${session.token}${suffix}`;
+}
+var DEFAULT_TTL_MS = 15 * 60 * 1e3;
+var PreviewSessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  create(options) {
+    const token = crypto3.randomBytes(32).toString("hex");
+    const expiresAt = Date.now() + (options.ttlMs ?? DEFAULT_TTL_MS);
+    if (options.port !== void 0) {
+      const session2 = {
+        token,
+        taskId: options.taskId,
+        kind: "service",
+        port: assertPreviewServicePort(options.port),
+        entryPath: normalizeServiceEntryPath(options.entryPath),
+        expiresAt
+      };
+      this.sessions.set(token, session2);
+      return session2;
     }
-  } catch {
+    if (!options.rootPath) {
+      throw new Error("Preview root path is required");
+    }
+    const entryPath = resolvePreviewEntryPath(options.rootPath, options.entryPath);
+    const session = {
+      token,
+      taskId: options.taskId,
+      kind: "file",
+      rootPath: options.rootPath,
+      entryPath,
+      expiresAt
+    };
+    this.sessions.set(token, session);
+    return session;
   }
-  return extractSemver(normalizeOutput(trimmed));
+  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 (now > session.expiresAt) {
+        this.sessions.delete(token);
+      }
+    }
+  }
+};
+var MIME_MAP2 = {
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".pdf": "application/pdf",
+  ".md": "text/markdown",
+  ".mdx": "text/markdown"
+};
+function getMime(filePath) {
+  return MIME_MAP2[path18.extname(filePath).toLowerCase()] ?? "application/octet-stream";
 }
-function resolveInstalledPackageVersion(definition, commandRunner) {
-  const result = commandRunner("npm", ["list", "-g", definition.packageName, "--depth=0", "--json"]);
-  return normalizeInstalledPackageVersion(result.stdout ?? null, definition.packageName);
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
-function compareSemver(left, right) {
-  const leftParts = left.split(/[.-]/).map((part) => Number.parseInt(part, 10));
-  const rightParts = right.split(/[.-]/).map((part) => Number.parseInt(part, 10));
-  for (let index = 0; index < 3; index += 1) {
-    const delta = (leftParts[index] || 0) - (rightParts[index] || 0);
-    if (delta !== 0) return delta;
+function renderInlineMarkdown(value) {
+  let rendered = escapeHtml(value);
+  rendered = rendered.replace(/!\[([^\]]*)]\(([^\s)]+)\)/g, '<img alt="$1" src="$2">');
+  rendered = rendered.replace(/`([^`]+)`/g, "<code>$1</code>").replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>").replace(/\[([^\]]+)]\((https?:\/\/[^\s)]+)\)/g, '<a href="$2" rel="noreferrer noopener" target="_blank">$1</a>');
+  return rendered;
+}
+function renderMarkdownBody(markdown) {
+  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+  const blocks = [];
+  let paragraph = [];
+  let listItems = [];
+  let codeLines = null;
+  const flushParagraph = () => {
+    if (paragraph.length === 0) return;
+    blocks.push(`<p>${renderInlineMarkdown(paragraph.join(" "))}</p>`);
+    paragraph = [];
+  };
+  const flushList = () => {
+    if (listItems.length === 0) return;
+    blocks.push(`<ul>${listItems.map((item) => `<li>${renderInlineMarkdown(item)}</li>`).join("")}</ul>`);
+    listItems = [];
+  };
+  for (const line of lines) {
+    if (line.trim().startsWith("```")) {
+      if (codeLines) {
+        blocks.push(`<pre><code>${escapeHtml(codeLines.join("\n"))}</code></pre>`);
+        codeLines = null;
+      } else {
+        flushParagraph();
+        flushList();
+        codeLines = [];
+      }
+      continue;
+    }
+    if (codeLines) {
+      codeLines.push(line);
+      continue;
+    }
+    const trimmed = line.trim();
+    if (!trimmed) {
+      flushParagraph();
+      flushList();
+      continue;
+    }
+    const heading = trimmed.match(/^(#{1,6})\s+(.+)$/);
+    if (heading) {
+      flushParagraph();
+      flushList();
+      const level = heading[1].length;
+      blocks.push(`<h${level}>${renderInlineMarkdown(heading[2])}</h${level}>`);
+      continue;
+    }
+    const listItem = trimmed.match(/^[-*]\s+(.+)$/);
+    if (listItem) {
+      flushParagraph();
+      listItems.push(listItem[1]);
+      continue;
+    }
+    flushList();
+    paragraph.push(trimmed);
   }
-  return 0;
+  if (codeLines) {
+    blocks.push(`<pre><code>${escapeHtml(codeLines.join("\n"))}</code></pre>`);
+  }
+  flushParagraph();
+  flushList();
+  return blocks.join("\n");
 }
-function checkToolUpdate(definition, installedVersion, checkedAt, commandRunner, checkedOn, updateCache) {
-  const currentVersion = extractSemver(installedVersion);
-  const cached = updateCache.get(definition.packageName);
-  let latestVersion = cached?.latestVersion ?? null;
-  let detail = cached?.detail ?? null;
-  let updateCheckedAt = cached?.checkedAt ?? checkedAt;
-  if (cached?.checkedOn !== checkedOn) {
-    const latestResult = commandRunner("npm", ["view", definition.packageName, "version", "--json"]);
-    latestVersion = latestResult.status === 0 ? normalizePackageVersion(latestResult.stdout ?? null) : null;
-    detail = latestResult.status === 0 ? null : normalizeOutput(latestResult.stderr) ?? latestResult.error ?? "Update check failed";
-    updateCheckedAt = checkedAt;
-    updateCache.set(definition.packageName, {
-      checkedOn,
-      checkedAt,
-      latestVersion,
-      detail
-    });
+function renderMarkdownDocument(markdown, title) {
+  const body = renderMarkdownBody(markdown);
+  return Buffer.from(`<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${escapeHtml(title)}</title>
+  <style>
+    body { box-sizing: border-box; max-width: 860px; margin: 0 auto; padding: 32px; color: #111827; font: 16px/1.65 -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+    h1, h2, h3, h4, h5, h6 { line-height: 1.25; margin: 1.5em 0 0.5em; }
+    h1 { border-bottom: 1px solid #e5e7eb; padding-bottom: 0.3em; }
+    pre { overflow: auto; border-radius: 8px; background: #111827; color: #f9fafb; padding: 16px; }
+    code { border-radius: 4px; background: #f3f4f6; padding: 0.1em 0.25em; }
+    pre code { background: transparent; padding: 0; }
+    img { max-width: 100%; }
+    a { color: #2563eb; }
+  </style>
+</head>
+<body>
+${body}
+</body>
+</html>`, "utf8");
+}
+function splitPreviewPathAndSearch(value) {
+  const marker = value.indexOf("?");
+  if (marker === -1) {
+    return { pathname: value, search: "" };
   }
-  return {
-    packageName: definition.packageName,
-    currentVersion,
-    latestVersion,
-    updateAvailable: Boolean(currentVersion && latestVersion && compareSemver(latestVersion, currentVersion) > 0),
-    checkedAt: updateCheckedAt,
-    detail
-  };
+  return { pathname: value.slice(0, marker), search: value.slice(marker) };
+}
+function decodePreviewPathname(pathname) {
+  return pathname ? decodeURIComponent(pathname) : "";
 }
-function inspectTool(definition, commandRunner, checkedAt, checkedOn, updateCache, platform2) {
-  const resolved = resolveCommandPath(definition.command, commandRunner, platform2);
-  if (!resolved.path) {
-    return {
-      id: definition.id,
-      label: definition.label,
-      command: definition.command,
-      available: false,
-      path: null,
-      version: null,
-      checkedAt,
-      detail: resolved.detail ?? "Command not found on PATH",
-      update: checkToolUpdate(definition, null, checkedAt, commandRunner, checkedOn, updateCache)
-    };
+function normalizeServiceRequestPath(pathname) {
+  const normalized = pathname.replace(/\\/g, "/");
+  if (!normalized || normalized === "/") {
+    return "/";
   }
-  const versionResult = commandRunner(definition.command, ["--version"]);
-  const commandVersion = normalizeOutput(versionResult.stdout) ?? normalizeOutput(versionResult.stderr);
-  const version2 = extractSemver(commandVersion) ? commandVersion : resolveInstalledPackageVersion(definition, commandRunner);
-  const detail = versionResult.status === 0 ? null : normalizeOutput(versionResult.stderr) ?? versionResult.error ?? "Version check failed";
-  return {
-    id: definition.id,
-    label: definition.label,
-    command: definition.command,
-    available: true,
-    path: resolved.path,
-    version: version2,
-    checkedAt,
-    detail,
-    update: checkToolUpdate(definition, version2, checkedAt, commandRunner, checkedOn, updateCache)
-  };
+  return `/${normalized.replace(/^\/+/, "")}`;
 }
-function inspectRuntimeTools(options = {}) {
-  const platform2 = options.platform ?? process.platform;
-  const commandRunner = options.commandRunner ?? ((command, args) => runRuntimeToolCommand(command, args, platform2));
-  const now = options.now ?? /* @__PURE__ */ new Date();
-  const checkedAt = now.toISOString();
-  const checkedOn = formatLocalDate(now);
-  const updateCache = options.updateCache ?? runtimeToolUpdateCache;
-  return RUNTIME_TOOLS.map((definition) => inspectTool(definition, commandRunner, checkedAt, checkedOn, updateCache, platform2));
+function rewriteServiceRootRelativeUrls(value, token) {
+  const previewRoot = `/preview/${token}/`;
+  return value.replace(/\b(src|href|action)=(['"])\/(?!\/|preview\/)/gi, `$1=$2${previewRoot}`).replace(/url\((['"]?)\/(?!\/|preview\/)/gi, `url($1${previewRoot}`).replace(/\bimport\((['"])\/(?!\/|preview\/)/gi, `import($1${previewRoot}`).replace(/\bfrom\s+(['"])\/(?!\/|preview\/)/gi, `from $1${previewRoot}`).replace(/(['"])\/(assets\/[^'"]+)\1/g, `$1${previewRoot}$2$1`);
 }
-function getOsSnapshot() {
-  const cpus2 = os6.cpus();
-  return {
-    platform: os6.platform(),
-    release: os6.release(),
-    arch: os6.arch(),
-    hostname: os6.hostname(),
-    cpuModel: cpus2[0]?.model ?? null,
-    cpuCount: cpus2.length,
-    totalMemoryBytes: os6.totalmem(),
-    freeMemoryBytes: os6.freemem()
-  };
+function escapeHtmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
 }
-function buildNodeSettingsSnapshot(options) {
-  const uptime = process.uptime();
-  const runtimeMetadata = options.runtimeMetadata;
-  const agents = (options.inspectRuntimeTools?.() ?? inspectRuntimeTools()).map((agent) => ({
-    ...agent,
-    metadataStatus: runtimeMetadata?.components?.[agent.id]?.status ?? null
-  }));
-  return {
-    collectedAt: Date.now(),
-    version: runtimeMetadata?.packageVersion ?? "0.1.0",
-    packageName: runtimeMetadata?.packageName ?? "meshy",
-    uptime,
-    auth: options.auth,
-    os: getOsSnapshot(),
-    runtime: {
-      nodeVersion: process.version,
-      pid: process.pid,
-      startedAt: Date.now() - Math.floor(uptime * 1e3),
-      cwd: process.cwd(),
-      workDir: options.workDir ?? null,
-      storagePath: options.storagePath ?? null,
-      localDashboardOrigin: options.localDashboardOrigin ?? null
-    },
-    agents,
-    startupRequirements: {
-      lastCheckedAt: runtimeMetadata?.startupRequirementsLastCheckedAt,
-      lastCheckedOn: runtimeMetadata?.startupRequirementsLastCheckedOn,
-      components: runtimeMetadata?.components ?? {}
-    },
-    components: runtimeMetadata?.components ?? {},
-    repository: runtimeMetadata?.repository ?? {},
-    packages: runtimeMetadata?.packages ?? {}
-  };
+function buildServicePreviewBridge(token) {
+  const previewRoot = `/preview/${token}/`;
+  const previewBase = previewRoot.replace(/\/$/, "");
+  const script = [
+    "(()=>{",
+    "if(window.top===window)return;",
+    `const previewBase=${JSON.stringify(previewBase)};`,
+    `const previewRoot=${JSON.stringify(previewRoot)};`,
+    "const rewritePreviewRequestUrl=(value)=>{",
+    "if(value==null)return value;",
+    "let raw;",
+    'try{raw=value instanceof URL?value.href:typeof value==="string"?value:value&&typeof value.url==="string"?value.url:undefined;}catch{return value;}',
+    "if(!raw)return value;",
+    "let url;",
+    "try{url=new URL(raw,window.location.href);}catch{return value;}",
+    "if(url.origin!==window.location.origin)return value;",
+    'if(url.pathname===previewBase||url.pathname.startsWith(previewRoot)||url.pathname.startsWith("/preview-open/"))return value;',
+    'return previewRoot+url.pathname.replace(/^\\/+/,"")+url.search+url.hash;',
+    "};",
+    "const rewritePreviewRequestInput=(input)=>{",
+    "const next=rewritePreviewRequestUrl(input);",
+    "if(next===input)return input;",
+    'if(typeof Request==="function"&&input instanceof Request)return new Request(next,input);',
+    "return next;",
+    "};",
+    "const originalFetch=window.fetch;",
+    'if(typeof originalFetch==="function")window.fetch=(input,init)=>originalFetch.call(window,rewritePreviewRequestInput(input),init);',
+    "const XHR=window.XMLHttpRequest;",
+    "if(XHR&&XHR.prototype){const open=XHR.prototype.open;XMLHttpRequest.prototype.open=function(method,url,...rest){return open.call(this,method,rewritePreviewRequestUrl(url),...rest);};}",
+    "const OriginalEventSource=window.EventSource;",
+    'if(typeof OriginalEventSource==="function"){window.EventSource=function(url,config){return new OriginalEventSource(rewritePreviewRequestUrl(url),config);};window.EventSource.prototype=OriginalEventSource.prototype;}',
+    "const currentPath=window.location.pathname;",
+    "if(currentPath===previewBase||currentPath.startsWith(previewRoot)){",
+    "const suffix=currentPath===previewBase?'':currentPath.slice(previewRoot.length);",
+    "const servicePath=suffix?'/' + suffix:'/';",
+    "window.history.replaceState(window.history.state,'',servicePath+window.location.search+window.location.hash);",
+    "}",
+    "})();"
+  ].join("");
+  return `<base data-meshy-preview-base href="${escapeHtmlAttribute(previewRoot)}"><script data-meshy-preview-bridge>${script}</script>`;
 }
-
-// ../../packages/api/src/node/agent-upgrade-service.ts
-var AGENT_PACKAGES = {
-  claude: "@anthropic-ai/claude-code",
-  codex: "@openai/codex"
-};
-var OUTPUT_LIMIT = 4e3;
-function summarizeOutput(value) {
-  const text = value ?? "";
-  return text.length > OUTPUT_LIMIT ? `${text.slice(0, OUTPUT_LIMIT)}\u2026` : text;
+function injectServicePreviewBridge(value, token) {
+  const bridge = buildServicePreviewBridge(token);
+  const headPattern = /<head(?:\s[^>]*)?>/i;
+  if (headPattern.test(value)) {
+    return value.replace(headPattern, (match) => `${match}${bridge}`);
+  }
+  const htmlPattern = /<html(?:\s[^>]*)?>/i;
+  if (htmlPattern.test(value)) {
+    return value.replace(htmlPattern, (match) => `${match}<head>${bridge}</head>`);
+  }
+  return `${bridge}${value}`;
 }
-function defaultCommandRunner(command, args) {
-  const result = (0, import_node_child_process9.spawnSync)(command, args, {
-    encoding: "utf-8",
-    shell: process.platform === "win32",
-    windowsHide: true,
-    timeout: 18e4
-  });
-  return {
-    status: result.status,
-    stdout: typeof result.stdout === "string" ? result.stdout : "",
-    stderr: typeof result.stderr === "string" ? result.stderr : "",
-    error: result.error?.message ?? null
-  };
+function normalizeContentType(contentType) {
+  return contentType?.split(";")[0]?.trim().toLowerCase();
 }
-function isRuntimeAgentId(value) {
-  return value === "claude" || value === "codex";
+function isServiceHtmlContentType(contentType) {
+  return normalizeContentType(contentType) === "text/html";
 }
-function buildUpgradeArgs(agent, packageName) {
-  const args = ["install", "-g", `${packageName}@latest`];
-  if (agent === "claude") {
-    args.push("--include=optional", "--ignore-scripts=false");
+function isServiceEventStreamContentType(contentType) {
+  return normalizeContentType(contentType) === "text/event-stream";
+}
+function isServiceJavaScriptContentType(normalizedType) {
+  return normalizedType === "text/javascript" || normalizedType === "application/javascript" || normalizedType === "application/x-javascript";
+}
+function rewriteServiceJavaScriptRuntimeUrls(value, token) {
+  if (!value.includes("__vite__mapDeps")) {
+    return value;
   }
-  return args;
+  const previewRoot = `/preview/${token}/`;
+  return value.replace(
+    /return\s*(['"])\/\1\s*\+\s*([A-Za-z_$][\w$]*)/g,
+    (_match, quote, argumentName) => `return${quote}${previewRoot}${quote}+${argumentName}`
+  );
 }
-function upgradeRuntimeAgent(agent, options = {}) {
-  const packageName = AGENT_PACKAGES[agent];
-  if (!packageName) {
-    throw new MeshyError("VALIDATION_ERROR", `Unsupported upgrade agent: ${agent}`, 400);
+function rewriteServiceResponseContent(content, contentType, token) {
+  const normalizedType = normalizeContentType(contentType);
+  if (normalizedType !== "text/html" && normalizedType !== "text/css" && !isServiceJavaScriptContentType(normalizedType)) {
+    return content;
   }
-  const command = "npm";
-  const args = buildUpgradeArgs(agent, packageName);
-  const result = (options.commandRunner ?? defaultCommandRunner)(command, args);
-  const ok = result.status === 0 && !result.error;
-  if (ok) {
-    clearRuntimeToolUpdateCache(packageName);
+  const source = content.toString("utf8");
+  const bridged = normalizedType === "text/html" ? injectServicePreviewBridge(source, token) : source;
+  const rewritten = rewriteServiceRootRelativeUrls(bridged, token);
+  return Buffer.from(
+    isServiceJavaScriptContentType(normalizedType) ? rewriteServiceJavaScriptRuntimeUrls(rewritten, token) : rewritten,
+    "utf8"
+  );
+}
+function rewriteServiceRedirectLocation(value, session) {
+  const previewRoot = `/preview/${session.token}`;
+  if (value.startsWith("/preview/")) {
+    return value;
   }
-  const detail = result.error ?? (summarizeOutput(result.stderr) || "Agent upgrade failed");
-  return {
-    ok,
-    agent,
-    packageName,
-    command,
-    args,
-    status: result.status,
-    stdout: summarizeOutput(result.stdout),
-    stderr: summarizeOutput(result.stderr),
-    detail: ok ? null : detail
-  };
+  if (value.startsWith("/")) {
+    return `${previewRoot}${value}`;
+  }
+  try {
+    const url = new URL(value);
+    const isLocalService = (url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "[::1]") && url.port === String(session.port);
+    if (isLocalService) {
+      return `${previewRoot}${url.pathname}${url.search}${url.hash}`;
+    }
+  } catch {
+  }
+  return value;
+}
+function buildServiceResponseHeaders(upstream, session, isHtml) {
+  const headers = {};
+  upstream.headers.forEach((value, key) => {
+    const normalizedKey = key.toLowerCase();
+    if (HOP_BY_HOP_HEADERS.has(normalizedKey) || normalizedKey === "content-length" || normalizedKey === "content-encoding" || isHtml && normalizedKey === "content-security-policy" || isHtml && normalizedKey === "content-security-policy-report-only" || isHtml && normalizedKey === "x-frame-options") {
+      return;
+    }
+    if (normalizedKey === "location") {
+      headers[key] = rewriteServiceRedirectLocation(value, session);
+      return;
+    }
+    headers[key] = value;
+  });
+  if (typeof headers["cache-control"] !== "string") {
+    headers["cache-control"] = "no-cache";
+  }
+  return headers;
 }
-function upgradeRuntimeAgentForDeps(deps, agent) {
-  const result = deps.upgradeRuntimeAgent?.(agent) ?? upgradeRuntimeAgent(agent);
-  if (result.ok) {
-    const settingsSnapshot = deps.refreshSettingsSnapshot?.();
-    if (settingsSnapshot) {
-      deps.nodeRegistry.updateSettingsSnapshot(deps.nodeRegistry.getSelf().id, settingsSnapshot);
-      return { ...result, settingsSnapshot };
+async function pipeServiceResponseBody(upstream, res) {
+  if (!upstream.body) {
+    res.end();
+    return;
+  }
+  try {
+    await (0, import_promises6.pipeline)(import_node_stream3.Readable.fromWeb(upstream.body), res);
+  } catch (error) {
+    if (!res.destroyed && !res.writableEnded) {
+      throw error;
     }
   }
-  return result;
 }
-
-// ../../packages/api/src/node/node-operation-service.ts
-var fs18 = __toESM(require("fs"), 1);
-var path19 = __toESM(require("path"), 1);
-var import_node_crypto7 = require("crypto");
-var NodeOperationFailure = class extends Error {
-  constructor(message, result) {
-    super(message);
-    this.result = result;
+async function sendServicePreviewResponse(session, requestedPath, req, res) {
+  const { pathname, search } = splitPreviewPathAndSearch(requestedPath ?? session.entryPath);
+  const decodedPathname = decodePreviewPathname(pathname);
+  const targetPath = normalizeServiceRequestPath(decodedPathname || session.entryPath);
+  const targetUrl = `http://127.0.0.1:${session.port}${targetPath}${search}`;
+  let upstream;
+  try {
+    const body = await readPreviewRequestBody(req);
+    upstream = await fetch(targetUrl, {
+      method: req?.method ?? "GET",
+      headers: buildServiceProxyHeaders(req),
+      ...body !== void 0 ? { body } : {},
+      redirect: "manual"
+    });
+  } catch {
+    res.writeHead(502, { "Content-Type": "text/plain" });
+    res.end("Preview service unavailable");
+    return;
   }
-};
-var InMemoryNodeOperationStore = class {
-  operations = /* @__PURE__ */ new Map();
-  get(id) {
-    const operation = this.operations.get(id);
-    return operation ? clone2(operation) : null;
+  const upstreamContentType = upstream.headers.get("content-type");
+  const isHtml = isServiceHtmlContentType(upstreamContentType);
+  const headers = buildServiceResponseHeaders(upstream, session, isHtml);
+  if (isServiceEventStreamContentType(upstreamContentType)) {
+    res.writeHead(upstream.status, headers);
+    await pipeServiceResponseBody(upstream, res);
+    return;
   }
-  list(filter = {}) {
-    return Array.from(this.operations.values()).filter((operation) => matchesFilter(operation, filter)).sort((a, b) => b.createdAt - a.createdAt).map((operation) => clone2(operation));
+  const content = rewriteServiceResponseContent(Buffer.from(await upstream.arrayBuffer()), upstreamContentType, session.token);
+  headers["content-length"] = content.length;
+  res.writeHead(upstream.status, headers);
+  res.end(content);
+}
+function buildPreviewUrlForRequest(token, requestedPath, session) {
+  const { pathname, search } = splitPreviewPathAndSearch(requestedPath ?? session.entryPath);
+  const entryPath = pathname ? decodePreviewPathname(pathname) : session.entryPath;
+  return `${buildPreviewUrl("", { token, entryPath, kind: session.kind })}${search}`;
+}
+function renderPreviewOpenDocument(previewUrl) {
+  const safePreviewUrl = escapeHtmlAttribute(previewUrl);
+  return Buffer.from(`<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Preview</title>
+  <style>
+    html, body { width: 100%; height: 100%; margin: 0; background: #fff; }
+    iframe { display: block; width: 100%; height: 100%; border: 0; }
+  </style>
+</head>
+<body>
+  <iframe src="${safePreviewUrl}" title="Preview"></iframe>
+</body>
+</html>`, "utf8");
+}
+function sendPreviewOpenResponse(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;
   }
-  upsert(operation) {
-    const copy = clone2(operation);
-    this.operations.set(copy.id, copy);
-    return clone2(copy);
+  const content = renderPreviewOpenDocument(buildPreviewUrlForRequest(token, requestedPath, session));
+  res.writeHead(200, {
+    "Content-Type": "text/html",
+    "Content-Length": content.length,
+    "Cache-Control": "no-cache"
+  });
+  res.end(content);
+}
+async function sendPreviewAssetResponse(sessionManager, token, requestedPath, res, req) {
+  const session = sessionManager.get(token);
+  if (!session) {
+    res.writeHead(403, { "Content-Type": "text/plain" });
+    res.end("Invalid or expired preview token");
+    return;
   }
-  update(id, updates) {
-    const current = this.operations.get(id);
-    if (!current) return null;
-    const next = { ...current, ...clone2(updates), id, createdAt: current.createdAt };
-    this.operations.set(id, next);
-    return clone2(next);
+  if (session.kind === "service") {
+    await sendServicePreviewResponse(session, requestedPath, req, res);
+    return;
   }
-};
-var FileNodeOperationStore = class {
-  constructor(storagePath) {
-    this.storagePath = storagePath;
+  if (!isReadOnlyPreviewMethod(req?.method)) {
+    res.writeHead(405, { "Content-Type": "text/plain" });
+    res.end("Method not allowed");
+    return;
   }
-  operations = /* @__PURE__ */ new Map();
-  loaded = false;
-  get(id) {
-    this.load();
-    const operation = this.operations.get(id);
-    return operation ? clone2(operation) : null;
+  const { pathname } = splitPreviewPathAndSearch(requestedPath ?? session.entryPath);
+  const resolvedRequestedPath = pathname ? decodePreviewPathname(pathname) : session.entryPath;
+  let resolved;
+  try {
+    resolved = resolvePreviewPath(session.rootPath, resolvedRequestedPath).absolutePath;
+  } catch {
+    res.writeHead(400, { "Content-Type": "text/plain" });
+    res.end("Invalid path");
+    return;
   }
-  list(filter = {}) {
-    this.load();
-    return Array.from(this.operations.values()).filter((operation) => matchesFilter(operation, filter)).sort((a, b) => b.createdAt - a.createdAt).map((operation) => clone2(operation));
+  if (!fs17.existsSync(resolved) || !fs17.statSync(resolved).isFile()) {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("File not found");
+    return;
   }
-  upsert(operation) {
-    this.load();
-    const copy = clone2(operation);
-    this.operations.set(copy.id, copy);
-    this.persist();
-    return clone2(copy);
+  const ext = path18.extname(resolved).toLowerCase();
+  const mime = ext === ".md" || ext === ".mdx" ? "text/html" : getMime(resolved);
+  const content = ext === ".md" || ext === ".mdx" ? renderMarkdownDocument(fs17.readFileSync(resolved, "utf8"), path18.basename(resolved)) : fs17.readFileSync(resolved);
+  res.writeHead(200, {
+    "Content-Type": mime,
+    "Content-Length": content.length,
+    "Cache-Control": "no-cache"
+  });
+  res.end(content);
+}
+async function handlePreviewRequest(sessionManager, req, res) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  if (!url.pathname.startsWith("/preview/") && !url.pathname.startsWith("/preview-open/")) {
+    return false;
   }
-  update(id, updates) {
-    this.load();
-    const current = this.operations.get(id);
-    if (!current) return null;
-    const next = { ...current, ...clone2(updates), id, createdAt: current.createdAt };
-    this.operations.set(id, next);
-    this.persist();
-    return clone2(next);
+  const openMatch = url.pathname.match(/^\/preview-open\/([a-f0-9]+)(?:\/(.*))?$/i);
+  if (openMatch?.[1]) {
+    if (!isReadOnlyPreviewMethod(req.method)) {
+      res.writeHead(405, { "Content-Type": "text/plain" });
+      res.end("Method not allowed");
+      return true;
+    }
+    const requestedPath2 = openMatch[2];
+    sendPreviewOpenResponse(sessionManager, openMatch[1], requestedPath2 ? `${requestedPath2}${url.search}` : url.search || void 0, res);
+    return true;
   }
-  load() {
-    if (this.loaded) return;
-    this.loaded = true;
-    if (!fs18.existsSync(this.filePath)) return;
-    const raw = JSON.parse(fs18.readFileSync(this.filePath, "utf-8"));
-    const entries = Array.isArray(raw) ? raw : Object.values(raw);
-    for (const entry of entries) {
-      if (isNodeOperation(entry)) {
-        this.operations.set(entry.id, clone2(entry));
-      }
+  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;
+  }
+  const requestedPath = match?.[2];
+  await sendPreviewAssetResponse(sessionManager, token, requestedPath ? `${requestedPath}${url.search}` : url.search || void 0, res, req);
+  return true;
+}
+
+// ../../packages/api/src/preview/preview-proxy.ts
+var PREVIEW_ASSET_PROXY_TIMEOUT_MS = 1e4;
+function describeProxyError(error) {
+  if (error instanceof Error) {
+    const errorCategory = error.name === "AbortError" || /aborted/i.test(error.message) ? "abort" : /timeout/i.test(error.message) ? "timeout" : "network";
+    return {
+      errorName: error.name,
+      errorMessage: error.message,
+      errorCategory
+    };
+  }
+  return {
+    errorName: "UnknownError",
+    errorMessage: String(error),
+    errorCategory: "unknown"
+  };
+}
+function createPreviewAssetProxyTrace(log2, token, nodeId, requestPath, proxyPath) {
+  return {
+    onAttempt: ({ attempt, endpoint, timeoutMs, totalEndpoints }) => {
+      log2.debug("preview asset proxy attempt", {
+        token,
+        nodeId,
+        requestPath,
+        proxyPath,
+        endpoint,
+        attempt,
+        totalEndpoints,
+        timeoutMs
+      });
+    },
+    onResponse: ({ attempt, endpoint, response, timeoutMs, totalEndpoints }) => {
+      log2.debug("preview asset proxy response", {
+        token,
+        nodeId,
+        requestPath,
+        proxyPath,
+        endpoint,
+        attempt,
+        totalEndpoints,
+        timeoutMs,
+        ok: response.ok,
+        statusCode: response.status
+      });
+    },
+    onError: ({ attempt, endpoint, error, timeoutMs, totalEndpoints }) => {
+      log2.warn("preview asset proxy attempt failed", {
+        token,
+        nodeId,
+        requestPath,
+        proxyPath,
+        endpoint,
+        attempt,
+        totalEndpoints,
+        timeoutMs,
+        ...describeProxyError(error)
+      });
     }
+  };
+}
+function parsePreviewRequest(previewUrl) {
+  const url = new URL(previewUrl, "http://localhost");
+  const match = url.pathname.match(/^\/preview\/([a-f0-9]+)(?:\/(.*))?$/i);
+  const token = match?.[1];
+  if (!token) {
+    return null;
   }
-  persist() {
-    fs18.mkdirSync(this.storagePath, { recursive: true });
-    const body = JSON.stringify(Object.fromEntries(this.operations), null, 2);
-    const tmpPath = `${this.filePath}.tmp`;
-    fs18.writeFileSync(tmpPath, body, "utf-8");
-    fs18.renameSync(tmpPath, this.filePath);
+  const requestedPath = match?.[2];
+  return {
+    token,
+    requestedPath: requestedPath ? `${requestedPath}${url.search}` : url.search || void 0
+  };
+}
+function parsePreviewOpenRequest(previewUrl) {
+  const url = new URL(previewUrl, "http://localhost");
+  const match = url.pathname.match(/^\/preview-open\/([a-f0-9]+)(?:\/(.*))?$/i);
+  const token = match?.[1];
+  if (!token) {
+    return null;
   }
-  get filePath() {
-    return path19.join(this.storagePath, "node-operations.json");
+  const requestedPath = match?.[2];
+  const suffix = requestedPath !== void 0 ? `/${requestedPath}` : "";
+  return {
+    token,
+    previewUrl: `/preview/${token}${suffix}${url.search}`
+  };
+}
+function extractPreviewToken(previewUrl) {
+  return parsePreviewRequest(previewUrl)?.token ?? null;
+}
+function buildPreviewAssetProxyPath(token, requestedPath) {
+  const search = new URLSearchParams({ token });
+  if (requestedPath) {
+    search.set("path", requestedPath);
   }
-};
-var NodeOperationService = class {
-  constructor(deps, store) {
-    this.deps = deps;
-    this.store = store;
-    this.registerHandler("agent.upgrade", runAgentUpgradeOperation);
+  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 });
   }
-  handlers = /* @__PURE__ */ new Map();
-  registerHandler(kind, handler) {
-    this.handlers.set(kind, handler);
+  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;
   }
-  create(kind, nodeId, payload) {
+  cleanup() {
     const now = Date.now();
-    const operation = {
-      id: (0, import_node_crypto7.randomUUID)(),
-      kind,
-      nodeId,
-      requestedByNodeId: this.deps.nodeRegistry.getSelf().id,
-      status: "queued",
-      payload,
-      createdAt: now,
-      updatedAt: now
-    };
-    const saved = this.store.upsert(operation);
-    this.deps.eventBus.emit("node.operation.created", { operation: saved });
-    return saved;
-  }
-  get(id) {
-    return this.store.get(id);
+    for (const [token, session] of this.sessions) {
+      if (session.expiresAt <= now) {
+        this.sessions.delete(token);
+      }
+    }
   }
-  list(filter) {
-    return this.store.list(filter);
+};
+function rewritePreviewSessionPayloadForProxy(manager, payload, nodeId) {
+  const token = extractPreviewToken(payload.previewUrl);
+  if (!token) {
+    return payload;
   }
-  accept(operation) {
-    const current = this.store.get(operation.id);
-    if (current) {
-      if (current.status === "queued") this.scheduleRun(current.id);
-      return current;
+  manager.register(token, nodeId, payload.expiresAt);
+  return {
+    ...payload,
+    previewUrl: buildPreviewUrl("", {
+      token,
+      entryPath: payload.entryPath,
+      kind: payload.kind
+    }),
+    ...payload.kind === "service" || payload.openUrl ? {
+      openUrl: buildPreviewOpenUrl("", {
+        token,
+        entryPath: payload.entryPath,
+        kind: payload.kind
+      })
+    } : {}
+  };
+}
+async function handlePreviewProxyRequest(manager, nodeRegistry, logger27, req, res) {
+  const requestPath = req.originalUrl ?? req.url;
+  const previewOpenRequest = parsePreviewOpenRequest(requestPath);
+  if (previewOpenRequest) {
+    const session2 = manager.get(previewOpenRequest.token);
+    if (!session2) {
+      return false;
     }
-    const saved = this.store.upsert({ ...operation, status: "queued", updatedAt: Date.now() });
-    this.deps.eventBus.emit("node.operation.created", { operation: saved });
-    this.scheduleRun(saved.id);
-    return saved;
+    const content = renderPreviewOpenDocument(previewOpenRequest.previewUrl);
+    res.status(200).set({
+      "Content-Type": "text/html",
+      "Content-Length": String(content.length),
+      "Cache-Control": "no-cache"
+    }).send(content);
+    return true;
   }
-  runLocal(id) {
-    this.scheduleRun(id);
+  const previewRequest = parsePreviewRequest(requestPath);
+  if (!previewRequest) {
+    return false;
   }
-  applyRemoteUpdate(operation) {
-    const current = this.store.get(operation.id);
-    const saved = this.store.upsert(current ? { ...current, ...operation } : operation);
-    this.applyOperationSideEffects(saved);
-    this.deps.eventBus.emit("node.operation.updated", { operation: saved });
-    return saved;
+  const session = manager.get(previewRequest.token);
+  if (!session) {
+    return false;
   }
-  markFailed(id, error) {
-    return this.update(id, {
-      status: "failed",
-      error,
-      completedAt: Date.now()
+  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);
+  try {
+    const body = await readPreviewRequestBody(req);
+    const { endpoint, response } = await fetchNodeWithFallback(
+      node,
+      proxyPath,
+      {
+        method: req.method,
+        headers: buildPreviewWorkerProxyHeaders(req),
+        ...body !== void 0 ? { body } : {}
+      },
+      PREVIEW_ASSET_PROXY_TIMEOUT_MS,
+      createPreviewAssetProxyTrace(previewLog, previewRequest.token, session.nodeId, requestPath, proxyPath),
+      { preferPublicEndpoint: true }
+    );
+    previewLog.debug("proxying preview asset from assigned worker", {
+      token: previewRequest.token,
+      nodeId: session.nodeId,
+      requestPath,
+      proxyPath,
+      endpoint
+    });
+    await sendProxyResponse(res, response);
+    return true;
+  } catch (err) {
+    previewLog.warn("preview asset proxy error", {
+      token: previewRequest.token,
+      nodeId: session.nodeId,
+      requestPath,
+      proxyPath,
+      timeoutMs: PREVIEW_ASSET_PROXY_TIMEOUT_MS,
+      ...describeProxyError(err)
     });
+    throw new MeshyError("NODE_OFFLINE", "Cannot reach worker for preview asset", 502);
   }
-  scheduleRun(id) {
-    setTimeout(() => {
-      void this.run(id);
-    }, 0);
+}
+
+// ../../packages/api/src/tasks/task-output-service.ts
+var TASK_OUTPUT_ROUTE_PREFIX = "/api/tasks";
+function getTask(taskEngine, taskId) {
+  const task = taskEngine.getTask(taskId);
+  if (!task) {
+    throw new MeshyError("TASK_NOT_FOUND", `Task ${taskId} not found`, 404);
   }
-  async run(id) {
-    const operation = this.store.get(id);
-    if (!operation || operation.status !== "queued") return;
-    const running = this.update(id, { status: "running", startedAt: Date.now() });
-    if (!running) return;
-    try {
-      const handler = this.handlers.get(running.kind);
-      if (!handler) throw new Error(`No node operation handler registered for kind: ${running.kind}`);
-      const result = await handler(running, this.deps);
-      this.update(id, { status: "succeeded", result, completedAt: Date.now() });
-    } catch (err) {
-      this.update(id, {
-        status: "failed",
-        result: err instanceof NodeOperationFailure ? err.result : void 0,
-        error: err instanceof Error ? err.message : String(err),
-        completedAt: Date.now()
-      });
+  return task;
+}
+function getTaskOutputRoot(taskEngine, taskId) {
+  const task = getTask(taskEngine, taskId);
+  if (!task.effectiveProjectPath) {
+    throw new MeshyError("VALIDATION_ERROR", "Task output not available", 400);
+  }
+  return task.effectiveProjectPath;
+}
+function buildTaskOutputDownloadUrl(taskId, filePath) {
+  return `${TASK_OUTPUT_ROUTE_PREFIX}/${taskId}/output/download?path=${encodeURIComponent(filePath)}`;
+}
+function getLocalTaskOutputSummary(taskEngine, taskId) {
+  const task = getTask(taskEngine, taskId);
+  if (!task.effectiveProjectPath) {
+    return {
+      taskId: task.id,
+      requestedProject: task.project,
+      effectiveProjectPath: null,
+      assignedTo: task.assignedTo,
+      available: false,
+      summary: null
+    };
+  }
+  return {
+    taskId: task.id,
+    requestedProject: task.project,
+    effectiveProjectPath: task.effectiveProjectPath,
+    assignedTo: task.assignedTo,
+    available: true,
+    summary: getOutputSummary(task.effectiveProjectPath)
+  };
+}
+function getLocalTaskOutputTree(taskEngine, taskId, currentPath) {
+  const rootPath = getTaskOutputRoot(taskEngine, taskId);
+  try {
+    return {
+      rootPath,
+      currentPath,
+      entries: listDirectory(rootPath, currentPath)
+    };
+  } catch (err) {
+    if (err instanceof Error && err.message === "Path traversal detected") {
+      throw new MeshyError("VALIDATION_ERROR", "Invalid directory path", 400);
     }
+    throw err;
   }
-  update(id, updates) {
-    const saved = this.store.update(id, { ...updates, updatedAt: Date.now() });
-    if (!saved) return null;
-    this.applyOperationSideEffects(saved);
-    this.deps.eventBus.emit("node.operation.updated", { operation: saved });
-    void this.reportToLeader(saved);
-    return saved;
-  }
-  applyOperationSideEffects(operation) {
-    if (operation.kind !== "agent.upgrade" || operation.status !== "succeeded") return;
-    const settingsSnapshot = readSettingsSnapshot(operation.result);
-    if (settingsSnapshot) {
-      this.deps.nodeRegistry.updateSettingsSnapshot(operation.nodeId, settingsSnapshot);
+}
+function getLocalTaskOutputContent(taskEngine, taskId, filePath) {
+  const rootPath = getTaskOutputRoot(taskEngine, taskId);
+  try {
+    return {
+      ...readFileContent(rootPath, filePath),
+      downloadUrl: buildTaskOutputDownloadUrl(taskId, filePath)
+    };
+  } catch (err) {
+    if (err instanceof Error && err.message === "Path traversal detected") {
+      throw new MeshyError("VALIDATION_ERROR", "Invalid file path", 400);
+    }
+    if (err instanceof Error && err.message === "File not found") {
+      throw new MeshyError("TASK_NOT_FOUND", `File not found: ${filePath}`, 404);
     }
+    throw err;
   }
-  async reportToLeader(operation) {
-    if (this.deps.nodeRegistry.isLeader()) return;
-    const leaderEndpoint = this.deps.nodeRegistry.getLeaderEndpoint?.();
-    if (!leaderEndpoint) return;
-    try {
-      await fetch(`${leaderEndpoint}/api/worker/node-operations/${operation.id}`, applyRequestAuthHeaders({
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(operation)
-      }));
-    } catch (err) {
-      this.deps.logger.child("node-operation").warn("failed to report node operation update to leader", {
-        operationId: operation.id,
-        kind: operation.kind,
-        error: err instanceof Error ? err.message : String(err)
-      });
+}
+function getLocalTaskOutputDownload(taskEngine, taskId, filePath) {
+  const rootPath = getTaskOutputRoot(taskEngine, taskId);
+  try {
+    const absolutePath = resolveOutputPath(rootPath, filePath);
+    if (!fs18.existsSync(absolutePath) || !fs18.statSync(absolutePath).isFile()) {
+      throw new MeshyError("TASK_NOT_FOUND", `File not found: ${filePath}`, 404);
+    }
+    const { mimeType } = classifyFile(absolutePath);
+    const fileName = path19.basename(absolutePath).replace(/"/g, "");
+    return {
+      content: fs18.readFileSync(absolutePath),
+      headers: {
+        "Content-Type": mimeType,
+        "Content-Disposition": `inline; filename="${fileName}"`,
+        "Cache-Control": "no-cache"
+      }
+    };
+  } catch (err) {
+    if (err instanceof MeshyError) {
+      throw err;
+    }
+    if (err instanceof Error && err.message === "Path traversal detected") {
+      throw new MeshyError("VALIDATION_ERROR", "Invalid file path", 400);
     }
+    throw err;
   }
-};
-function getNodeOperationService(deps) {
-  if (deps.nodeOperationService) return deps.nodeOperationService;
-  const store = deps.nodeOperationStore ?? (deps.storagePath ? new FileNodeOperationStore(deps.storagePath) : new InMemoryNodeOperationStore());
-  const service = new NodeOperationService(deps, store);
-  deps.nodeOperationStore = store;
-  deps.nodeOperationService = service;
-  return service;
 }
-async function dispatchNodeOperation(deps, operation, node) {
-  const message = createNodeMessage("node.operation.execute", { operation });
-  const heartbeat = deps.heartbeat;
-  if (heartbeat.canPushToNode?.(node.id) === false) {
-    if (!heartbeat.enqueueNodeMessage) throw new Error(`Cannot queue node operation for ${node.id}`);
-    heartbeat.enqueueNodeMessage(node.id, message);
-    return;
+function getLocalTaskOutputDiff(taskEngine, taskId) {
+  const rootPath = getTaskOutputRoot(taskEngine, taskId);
+  return getGitDiff(rootPath);
+}
+async function createPreviewSessionPayload(deps, taskId, optionsOrPath, requestOrigin) {
+  const previewManager = deps.previewSessionManager;
+  if (!previewManager) {
+    throw new MeshyError("VALIDATION_ERROR", "Preview not available on this node", 400);
   }
-  const client = new NodeMessageClient({
-    heartbeat: heartbeat.enqueueNodeMessage ? { enqueueNodeMessage: heartbeat.enqueueNodeMessage.bind(heartbeat) } : void 0,
-    logger: deps.logger
+  const options = typeof optionsOrPath === "string" ? { path: optionsOrPath } : optionsOrPath ?? {};
+  getTask(deps.taskEngine, taskId);
+  const session = options.port !== void 0 ? previewManager.create({
+    taskId,
+    port: options.port,
+    entryPath: options.path
+  }) : previewManager.create({
+    taskId,
+    rootPath: getTaskOutputRoot(deps.taskEngine, taskId),
+    entryPath: options.path
   });
-  await client.send(node, message);
-}
-function runAgentUpgradeOperation(operation, deps) {
-  const agent = readPayloadString(operation, "agent");
-  if (!isRuntimeAgentId(agent)) throw new Error(`Unsupported upgrade agent: ${agent}`);
-  const result = upgradeRuntimeAgentForDeps(deps, agent);
-  if (!result.ok) {
-    throw new NodeOperationFailure(result.detail ?? `${agent} upgrade failed`, result);
+  const origin = requestOrigin ?? deps.dashboardOrigin ?? deps.localDashboardOrigin;
+  if (!origin) {
+    throw new MeshyError("VALIDATION_ERROR", "Preview origin not available", 502);
   }
-  return result;
-}
-function readPayloadString(operation, key) {
-  const payload = operation.payload;
-  if (!payload || typeof payload !== "object") return "";
-  const value = payload[key];
-  return typeof value === "string" ? value : "";
-}
-function readSettingsSnapshot(value) {
-  if (!value || typeof value !== "object") return void 0;
-  const snapshot = value.settingsSnapshot;
-  return snapshot && typeof snapshot === "object" ? snapshot : void 0;
-}
-function matchesFilter(operation, filter) {
-  return (!filter.nodeId || operation.nodeId === filter.nodeId) && (!filter.status || operation.status === filter.status) && (!filter.kind || operation.kind === filter.kind);
-}
-function isNodeOperation(value) {
-  if (!value || typeof value !== "object") return false;
-  const record = value;
-  return typeof record.id === "string" && typeof record.kind === "string" && typeof record.nodeId === "string" && typeof record.status === "string" && typeof record.createdAt === "number" && typeof record.updatedAt === "number";
-}
-function clone2(value) {
-  return JSON.parse(JSON.stringify(value));
+  return {
+    previewUrl: buildPreviewUrl(origin, session),
+    ...session.kind === "service" ? { openUrl: buildPreviewOpenUrl(origin, session) } : {},
+    expiresAt: session.expiresAt,
+    entryPath: session.entryPath,
+    kind: session.kind,
+    ...session.kind === "service" ? { port: session.port } : {}
+  };
 }
 
 // ../../packages/api/src/node/worker-control.ts
@@ -46559,6 +46662,17 @@ async function executeWorkerControlRequest(deps, request) {
         });
         break;
       }
+      case "task.delete": {
+        const taskId = payloadValue(request, "taskId", "");
+        const deleted = deps.taskEngine.deleteTask(taskId);
+        response = jsonResponse(request.id, 200, {
+          ok: true,
+          taskId,
+          deleted,
+          missing: !deleted
+        });
+        break;
+      }
       case "task.logs": {
         const taskId = payloadValue(request, "taskId", "");
         const task = deps.taskEngine.getTask(taskId);
@@ -46913,79 +47027,6 @@ async function maybeHandleRemoteNodeWorkDirBranchInfoRequest(req, res, nodeId) {
     throw new MeshyError("NODE_OFFLINE", `Cannot reach node ${nodeId} to inspect its git branch`, 502);
   }
 }
-async function maybeHandleRemoteNodeWorkDirBranchCreateRequest(req, res, nodeId) {
-  const body = CreateNodeWorkDirBranchBody.parse(req.body);
-  const { nodeRegistry, heartbeat, logger: rootLogger } = req.app.locals.deps;
-  const selfId = nodeRegistry.getSelf().id;
-  if (nodeId === selfId) {
-    return false;
-  }
-  const node = nodeRegistry.getNode(nodeId);
-  if (!node) {
-    throw new MeshyError("NODE_NOT_FOUND", `Node ${nodeId} not found`, 404);
-  }
-  const log2 = rootLogger.child("nodes/workdir-branch-create");
-  const proxyPath = req.originalUrl ?? `/api/nodes/${nodeId}/workdir/branch`;
-  const fallbackRequest = createNodeMessage("node.workdir.branch-create", {
-    path: body.path,
-    branchName: body.branchName,
-    startPoint: body.startPoint,
-    limit: body.limit,
-    offset: body.offset,
-    allowAbsolute: body.allowAbsolute
-  }, { expectsResponse: true });
-  const canPushToNode = heartbeat?.canPushToNode?.(nodeId) ?? true;
-  if (!canPushToNode && canRequestNodeMessage(heartbeat)) {
-    log2.warn("node workdir branch create request falling back to keepalive control", {
-      nodeId,
-      proxyPath
-    });
-    const controlResponse = await requestFallbackNodeMessage(heartbeat, nodeId, fallbackRequest);
-    sendWorkerControlResponse(res, controlResponse);
-    return true;
-  }
-  try {
-    const { endpoint, response } = await fetchNodeWithFallback(
-      node,
-      proxyPath,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body)
-      },
-      NODE_WORKDIR_BRANCH_PROXY_TIMEOUT_MS,
-      createNodeWorkdirProxyTrace(log2, nodeId, proxyPath),
-      { preferPublicEndpoint: true }
-    );
-    log2.debug("proxying node workdir branch create request", {
-      nodeId,
-      endpoint,
-      proxyPath
-    });
-    await sendProxyResponse(res, response);
-    return true;
-  } catch (err) {
-    const errorDetails = describeProxyError2(err);
-    log2.warn("node workdir branch create proxy error", {
-      nodeId,
-      proxyPath,
-      timeoutMs: NODE_WORKDIR_BRANCH_PROXY_TIMEOUT_MS,
-      ...errorDetails
-    });
-    if (canRequestNodeMessage(heartbeat)) {
-      log2.warn("node workdir branch create proxy failed, falling back to keepalive control", {
-        nodeId,
-        proxyPath,
-        timeoutMs: NODE_WORKDIR_BRANCH_PROXY_TIMEOUT_MS,
-        ...errorDetails
-      });
-      const controlResponse = await requestFallbackNodeMessage(heartbeat, nodeId, fallbackRequest);
-      sendWorkerControlResponse(res, controlResponse);
-      return true;
-    }
-    throw new MeshyError("NODE_OFFLINE", `Cannot reach node ${nodeId} to create a git branch`, 502);
-  }
-}
 async function maybeHandleRemoteNodeNativeSessionsRequest(req, res, nodeId) {
   const query = NodeNativeSessionsQuery.parse(req.query);
   const { nodeRegistry, heartbeat, logger: rootLogger } = req.app.locals.deps;
@@ -47119,11 +47160,7 @@ function createNodeRoutes() {
   }));
   router.post("/:id/workdir/branch", asyncHandler3(async (req, res) => {
     const nodeId = req.params.id;
-    const handled = await maybeHandleRemoteNodeWorkDirBranchCreateRequest(req, res, nodeId);
-    if (handled) {
-      return;
-    }
-    sendLocalNodeWorkDirBranchCreate(req, res, nodeId);
+    await sendNodeWorkDirBranchCreateOperation(req, res, nodeId);
   }));
   router.post("/:id/agents/:agent/upgrade", asyncHandler3(async (req, res) => {
     await sendNodeAgentUpgrade(req, res, req.params.id, req.params.agent);
@@ -48085,6 +48122,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"]);
+var TASK_DELETE_NOTIFY_TIMEOUT_MS = 1500;
 function shouldGenerateTitle(task) {
   return task.payload.titleSource === "derived";
 }
@@ -48198,6 +48236,39 @@ function toTaskResponse(task, nodeRegistry, taskEngine, shareOrigin) {
 function buildShareUrl(origin, shareId) {
   return `${origin.replace(/\/+$/, "")}/shared/tasks/${encodeURIComponent(shareId)}`;
 }
+async function notifyAssignedWorkerTaskDeleted(deps, task) {
+  if (!task.assignedTo || task.assignedTo === deps.nodeRegistry.getSelf()?.id) {
+    return;
+  }
+  const node = deps.nodeRegistry.getNode(task.assignedTo);
+  const log2 = deps.logger.child("tasks/delete");
+  if (!node) {
+    log2.warn("skipping worker task delete notification because assigned node is missing", {
+      taskId: task.id,
+      assignedTo: task.assignedTo
+    });
+    return;
+  }
+  try {
+    const client = new NodeMessageClient({
+      heartbeat: deps.heartbeat,
+      logger: deps.logger,
+      timeoutMs: TASK_DELETE_NOTIFY_TIMEOUT_MS
+    });
+    const delivery = await client.send(node, createNodeMessage("task.delete", { taskId: task.id }));
+    log2.info("notified assigned worker of task delete", {
+      taskId: task.id,
+      assignedTo: task.assignedTo,
+      queued: delivery.queued
+    });
+  } catch (err) {
+    log2.warn("failed to notify assigned worker of task delete", {
+      taskId: task.id,
+      assignedTo: task.assignedTo,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
 function createTaskRoutes() {
   const router = (0, import_express8.Router)();
   router.post("/", asyncHandler6(async (req, res) => {
@@ -48249,16 +48320,21 @@ function createTaskRoutes() {
     });
   }));
   router.post("/batch/delete", asyncHandler6(async (req, res) => {
-    const { taskEngine } = req.app.locals.deps;
+    const deps = req.app.locals.deps;
+    const { taskEngine } = deps;
     const { ids } = BatchTaskIdsBody.parse(req.body);
+    const deletedTasks = [];
     const results = ids.map((id) => {
       try {
+        const task = taskEngine.getTask(id);
         const ok = taskEngine.deleteTask(id);
+        if (ok && task) deletedTasks.push(task);
         return ok ? { id, ok: true } : { id, ok: false, error: "Task not found" };
       } catch (err) {
         return { id, ok: false, error: err instanceof Error ? err.message : "Unknown error" };
       }
     });
+    await Promise.all(deletedTasks.map((task) => notifyAssignedWorkerTaskDeleted(deps, task)));
     res.json({ results });
   }));
   router.post("/batch/archive", asyncHandler6(async (req, res) => {
@@ -48380,12 +48456,17 @@ function createTaskRoutes() {
     res.json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
   router.delete("/:id", asyncHandler6(async (req, res) => {
-    const { taskEngine } = req.app.locals.deps;
+    const deps = req.app.locals.deps;
+    const { taskEngine } = deps;
     const taskId = req.params.id;
+    const task = taskEngine.getTask(taskId);
     const result = taskEngine.deleteTask(taskId);
     if (!result) {
       throw new MeshyError("TASK_NOT_FOUND", `Task ${taskId} not found`, 404);
     }
+    if (task) {
+      await notifyAssignedWorkerTaskDeleted(deps, task);
+    }
     res.json({ ok: true });
   }));
   router.post("/:id/cancel", asyncHandler6(async (req, res) => {
@@ -49092,6 +49173,7 @@ function parseStatus(value) {
 function createNodeOperationRoutes() {
   const router = (0, import_express13.Router)();
   router.get("/", asyncHandler10(async (req, res) => {
+    if (await maybeProxyReadToLeader(req, res)) return;
     const deps = req.app.locals.deps;
     const operations = getNodeOperationService(deps).list({
       nodeId: typeof req.query.nodeId === "string" ? req.query.nodeId : void 0,
@@ -49101,6 +49183,7 @@ function createNodeOperationRoutes() {
     res.json({ operations });
   }));
   router.get("/:id", asyncHandler10(async (req, res) => {
+    if (await maybeProxyReadToLeader(req, res)) return;
     const deps = req.app.locals.deps;
     const operation = getNodeOperationService(deps).get(req.params.id);
     if (!operation) {