meshy-node 0.0.5 → 0.0.7

package/main.cjs

@@ -22771,9 +22771,11 @@ __export(main_exports, {
   DEFAULT_CONFIG: () => DEFAULT_CONFIG3,
   DEFAULT_NODE_NAME: () => DEFAULT_NODE_NAME,
   DEFAULT_NODE_PORT: () => DEFAULT_NODE_PORT,
+  applyStartMetadata: () => applyStartMetadata,
   createDefaultConfig: () => createDefaultConfig,
   createRuntimeDefaultConfig: () => createRuntimeDefaultConfig,
   formatBanner: () => formatBanner,
+  formatLoadedStartMetadata: () => formatLoadedStartMetadata,
   getDefaultNodeName: () => getDefaultNodeName,
   isDirectRunPath: () => isDirectRunPath,
   loadConfigFile: () => loadConfigFile,
@@ -22781,12 +22783,12 @@ __export(main_exports, {
   mergeConfig: () => mergeConfig,
   parseArgs: () => parseArgs,
   promptStartOptions: () => promptStartOptions,
+  resolveRuntimeAuthMetadata: () => resolveRuntimeAuthMetadata,
+  shouldCollectStartOptions: () => shouldCollectStartOptions,
   shouldPromptForStartOptions: () => shouldPromptForStartOptions
 });
 module.exports = __toCommonJS(main_exports);
-var fs16 = __toESM(require("fs"), 1);
 var nodePath = __toESM(require("path"), 1);
-var readline = __toESM(require("readline/promises"), 1);
 
 // ../../packages/core/src/logger.ts
 var fs = __toESM(require("fs"), 1);
@@ -22810,18 +22812,19 @@ function hourlyFolder(date) {
 var FileWriter = class {
   constructor(logDir, component, clock) {
     this.logDir = logDir;
-    this.component = component;
     this.clock = clock;
+    this.fileName = component.replace(/[/\\]/g, "-");
   }
   currentFolder = "";
   currentStream = null;
+  fileName;
   write(chunk) {
     const folder = hourlyFolder(this.clock());
     if (folder !== this.currentFolder) {
       this.currentStream?.end();
       const dir = path.join(this.logDir, folder);
       fs.mkdirSync(dir, { recursive: true });
-      const filePath = path.join(dir, `${this.component}.log`);
+      const filePath = path.join(dir, `${this.fileName}.log`);
       this.currentStream = fs.createWriteStream(filePath, { flags: "a" });
       this.currentFolder = folder;
     }
@@ -22856,6 +22859,12 @@ var MeshyLogger = class _MeshyLogger {
     this.log("error", msg, data);
   }
   child(component) {
+    if (this.state.logDir) {
+      const fileWriter = new FileWriter(this.state.logDir, component, this.state.clock);
+      const writer = this.state.consoleEnabled ? new MultiWriter([process.stdout, fileWriter]) : fileWriter;
+      const childState = { ...this.state, writer };
+      return new _MeshyLogger(childState, component);
+    }
     return new _MeshyLogger(this.state, component);
   }
   log(level, msg, data) {
@@ -22912,7 +22921,9 @@ function createLogger(options = {}) {
     level: options.level ?? "info",
     nodeId: options.nodeId,
     clock,
-    writer
+    writer,
+    logDir: options.logDir,
+    consoleEnabled: options.console
   };
   return new MeshyRootLogger(state, options.component);
 }
@@ -22996,10 +23007,14 @@ function getTaskInitialMessageContent(task) {
   return normalizeTaskUserMessageContent(task.description || task.title);
 }
 
+// ../../packages/core/src/azure-cli-auth.ts
+var import_node_child_process = require("child_process");
+
 // ../../packages/core/src/node-metadata.ts
 var fs2 = __toESM(require("fs"), 1);
 var os = __toESM(require("os"), 1);
 var path2 = __toESM(require("path"), 1);
+var STARTUP_TRANSPORTS = /* @__PURE__ */ new Set(["direct", "devtunnel", "tailscale"]);
 function getDeviceNodeName() {
   return os.hostname();
 }
@@ -23026,8 +23041,59 @@ function writeNodeMetadata(storagePath, metadata) {
   fs2.mkdirSync(storagePath, { recursive: true });
   fs2.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2) + "\n", "utf-8");
 }
+function normalizeAllowedUsers(allowedUsers) {
+  if (!Array.isArray(allowedUsers)) {
+    return [];
+  }
+  const unique = /* @__PURE__ */ new Set();
+  for (const user of allowedUsers) {
+    if (typeof user !== "string") continue;
+    const normalized = user.trim().toLowerCase();
+    if (normalized.length > 0) {
+      unique.add(normalized);
+    }
+  }
+  return [...unique];
+}
+function normalizeAuthMetadata(auth) {
+  return {
+    enabled: auth?.enabled === true,
+    allowSameTenant: auth?.allowSameTenant === true,
+    allowedUsers: normalizeAllowedUsers(auth?.allowedUsers)
+  };
+}
+function normalizePositiveInteger(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    return void 0;
+  }
+  return value;
+}
+function normalizeString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeStartupTransport(value) {
+  return typeof value === "string" && STARTUP_TRANSPORTS.has(value) ? value : void 0;
+}
+function normalizeStartupMetadata(startup) {
+  return {
+    port: normalizePositiveInteger(startup?.port),
+    transport: normalizeStartupTransport(startup?.transport),
+    join: normalizeString(startup?.join),
+    workDir: normalizeString(startup?.workDir)
+  };
+}
+function hasStartupValues(startup) {
+  return startup.port !== void 0 || startup.transport !== void 0 || startup.join !== void 0 || startup.workDir !== void 0;
+}
+function resolvePersistedDefaultNodeName(storagePath) {
+  return normalizeString(readNodeMetadata(storagePath).defaultNodeName);
+}
 function resolveDefaultNodeName(storagePath, deviceName = getDeviceNodeName()) {
-  const preferredName = readNodeMetadata(storagePath).defaultNodeName?.trim();
+  const preferredName = resolvePersistedDefaultNodeName(storagePath);
   return preferredName && preferredName.length > 0 ? preferredName : deviceName;
 }
 function persistDefaultNodeName(storagePath, name, deviceName = getDeviceNodeName()) {
@@ -23040,6 +23106,46 @@ function persistDefaultNodeName(storagePath, name, deviceName = getDeviceNodeNam
   }
   writeNodeMetadata(storagePath, metadata);
 }
+function resolveNodeAuthMetadata(storagePath) {
+  return normalizeAuthMetadata(readNodeMetadata(storagePath).auth);
+}
+function resolveNodeStartupMetadata(storagePath) {
+  return normalizeStartupMetadata(readNodeMetadata(storagePath).startup);
+}
+function hasPersistedNodeStartupMetadata(storagePath) {
+  return hasStartupValues(resolveNodeStartupMetadata(storagePath));
+}
+function persistNodeAuthMetadata(storagePath, auth) {
+  const metadata = readNodeMetadata(storagePath);
+  const normalized = normalizeAuthMetadata(auth);
+  if (!normalized.enabled && !normalized.allowSameTenant && normalized.allowedUsers.length === 0) {
+    delete metadata.auth;
+  } else {
+    metadata.auth = {
+      enabled: normalized.enabled,
+      allowSameTenant: normalized.allowSameTenant,
+      allowedUsers: normalized.allowedUsers
+    };
+  }
+  writeNodeMetadata(storagePath, metadata);
+}
+function persistNodeStartupMetadata(storagePath, startup) {
+  const metadata = readNodeMetadata(storagePath);
+  const normalized = normalizeStartupMetadata(startup);
+  if (!hasStartupValues(normalized)) {
+    delete metadata.startup;
+  } else {
+    metadata.startup = normalized;
+  }
+  writeNodeMetadata(storagePath, metadata);
+}
+function persistNodeStartupTransport(storagePath, transport) {
+  const startup = resolveNodeStartupMetadata(storagePath);
+  persistNodeStartupMetadata(storagePath, {
+    ...startup,
+    transport
+  });
+}
 function resolvePersistedDevTunnelId(storagePath, kind) {
   return readNodeMetadata(storagePath).devTunnelIds?.[kind]?.trim() || void 0;
 }
@@ -23072,6 +23178,246 @@ function resolveOrCreateDevTunnelId(storagePath, nodeId, kind) {
   return generatedId;
 }
 
+// ../../packages/core/src/azure-cli-auth.ts
+var DEFAULT_AZ_RESOURCE = process.env.MESHY_AZ_TOKEN_RESOURCE?.trim() || "https://management.azure.com/";
+var TOKEN_REFRESH_SKEW_MS = 6e4;
+function summarizeClaims(claims) {
+  return {
+    tid: claims.tid,
+    oid: claims.oid,
+    preferred_username: claims.preferred_username,
+    upn: claims.upn,
+    email: claims.email,
+    aud: claims.aud
+  };
+}
+function decodeAzureCliJwtClaims(token) {
+  const parts = token.split(".");
+  if (parts.length < 2) {
+    throw new Error("Token is not a JWT");
+  }
+  const payload = parts[1];
+  if (!payload) {
+    throw new Error("JWT payload is empty");
+  }
+  const normalized = payload.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(payload.length / 4) * 4, "=");
+  const parsed = JSON.parse(Buffer.from(normalized, "base64").toString("utf-8"));
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("JWT payload is not an object");
+  }
+  return parsed;
+}
+function normalizeIdentityValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim().toLowerCase() : void 0;
+}
+function getIdentityValues(claims) {
+  const values = /* @__PURE__ */ new Set();
+  for (const candidate of [
+    claims.oid,
+    claims.preferred_username,
+    claims.upn,
+    claims.email,
+    claims.unique_name,
+    claims.sub
+  ]) {
+    const normalized = normalizeIdentityValue(candidate);
+    if (normalized) {
+      values.add(normalized);
+    }
+  }
+  return values;
+}
+function parseExpiry(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value > 1e10 ? value : value * 1e3;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+      throw new Error("expiresOn is empty");
+    }
+    if (/^\d+$/.test(trimmed)) {
+      const numeric = Number(trimmed);
+      return numeric > 1e10 ? numeric : numeric * 1e3;
+    }
+    const parsed = Date.parse(trimmed);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  throw new Error("Unable to parse Azure CLI token expiry");
+}
+function getAzureCliCommandInvocation(command, args, platform = process.platform) {
+  if (platform !== "win32") {
+    return { command, args };
+  }
+  return {
+    command,
+    args,
+    shell: true
+  };
+}
+function defaultCommandRunner(command, args) {
+  const invocation = getAzureCliCommandInvocation(command, args);
+  const result = (0, import_node_child_process.spawnSync)(invocation.command, invocation.args, {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: invocation.shell
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    const message = result.stderr?.trim() || `Azure CLI command exited with code ${result.status}`;
+    throw new Error(message);
+  }
+  return result.stdout;
+}
+var AzureCliNodeAuth = class {
+  constructor(storagePath, options = {}) {
+    this.storagePath = storagePath;
+    this.runCommand = options.commandRunner ?? defaultCommandRunner;
+    this.log = options.logger ?? { debug() {
+    }, info() {
+    }, warn() {
+    }, error() {
+    }, child() {
+      return this;
+    } };
+    this.resource = options.resource?.trim() || DEFAULT_AZ_RESOURCE;
+    this.settingsProvider = options.settingsProvider;
+  }
+  runCommand;
+  log;
+  resource;
+  settingsProvider;
+  cachedToken = null;
+  getSettings() {
+    return this.settingsProvider?.() ?? resolveNodeAuthMetadata(this.storagePath);
+  }
+  isEnabled() {
+    return this.getSettings().enabled;
+  }
+  getAuthorizationHeaders() {
+    if (!this.isEnabled()) {
+      return {};
+    }
+    const token = this.getAccessToken();
+    return {
+      authorization: `Bearer ${token.accessToken}`
+    };
+  }
+  validateAuthorizationHeader(header) {
+    if (!this.isEnabled()) {
+      return { ok: true, reason: "disabled" };
+    }
+    if (typeof header !== "string") {
+      return { ok: false, reason: "missing" };
+    }
+    const token = header.startsWith("Bearer ") ? header.slice("Bearer ".length).trim() : "";
+    if (!token) {
+      return { ok: false, reason: "missing" };
+    }
+    let peerClaims;
+    try {
+      peerClaims = decodeAzureCliJwtClaims(token);
+    } catch {
+      return { ok: false, reason: "invalid" };
+    }
+    const local = this.getAccessToken();
+    const settings = this.getSettings();
+    if (isPeerIdentityAllowed(peerClaims, local.claims, settings)) {
+      return {
+        ok: true,
+        reason: "match",
+        localClaims: local.claims,
+        peerClaims
+      };
+    }
+    return {
+      ok: false,
+      reason: "mismatch",
+      localClaims: local.claims,
+      peerClaims
+    };
+  }
+  getAccessToken() {
+    if (this.cachedToken && this.cachedToken.expiresAtMs - TOKEN_REFRESH_SKEW_MS > Date.now()) {
+      this.log.debug("using cached azure cli access token", {
+        resource: this.resource,
+        expiresAt: new Date(this.cachedToken.expiresAtMs).toISOString(),
+        expiresInMs: this.cachedToken.expiresAtMs - Date.now(),
+        claims: summarizeClaims(this.cachedToken.claims)
+      });
+      return this.cachedToken;
+    }
+    this.log.info("requesting azure cli access token", {
+      resource: this.resource,
+      cachedTokenPresent: this.cachedToken !== null
+    });
+    let raw;
+    try {
+      raw = this.runCommand("az", [
+        "account",
+        "get-access-token",
+        "--resource",
+        this.resource,
+        "--output",
+        "json"
+      ]);
+    } catch (error) {
+      this.log.error("failed to execute az account get-access-token", {
+        resource: this.resource,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.accessToken !== "string" || parsed.accessToken.trim().length === 0) {
+      this.log.error("azure cli token response did not include accessToken", {
+        resource: this.resource
+      });
+      throw new Error("Azure CLI did not return accessToken");
+    }
+    const expiresAtMs = parseExpiry(parsed.expiresOn ?? parsed.expires_on);
+    const claims = decodeAzureCliJwtClaims(parsed.accessToken);
+    this.cachedToken = {
+      accessToken: parsed.accessToken,
+      expiresAtMs,
+      claims
+    };
+    this.log.info("received azure cli access token", {
+      resource: this.resource,
+      expiresAt: new Date(expiresAtMs).toISOString(),
+      expiresInMs: expiresAtMs - Date.now(),
+      claims: summarizeClaims(claims)
+    });
+    return this.cachedToken;
+  }
+};
+function isPeerIdentityAllowed(peerClaims, localClaims, settings) {
+  const peerIdentities = getIdentityValues(peerClaims);
+  const localIdentities = getIdentityValues(localClaims);
+  for (const identity of peerIdentities) {
+    if (localIdentities.has(identity)) {
+      return true;
+    }
+  }
+  for (const allowedUser of settings.allowedUsers) {
+    if (peerIdentities.has(allowedUser)) {
+      return true;
+    }
+  }
+  if (settings.allowSameTenant) {
+    const peerTenant = normalizeIdentityValue(peerClaims.tid);
+    const localTenant = normalizeIdentityValue(localClaims.tid);
+    if (peerTenant && localTenant && peerTenant === localTenant) {
+      return true;
+    }
+  }
+  return false;
+}
+
 // ../../packages/core/src/file-store.ts
 var fs3 = __toESM(require("fs"), 1);
 var path3 = __toESM(require("path"), 1);
@@ -23516,6 +23862,7 @@ function parseNodeInfo(value) {
     lastHeartbeat: value.lastHeartbeat,
     transportType: typeof value.transportType === "string" ? value.transportType : void 0,
     devtunnelEndpoint: typeof value.devtunnelEndpoint === "string" ? value.devtunnelEndpoint : void 0,
+    dashboardOrigin: typeof value.dashboardOrigin === "string" ? value.dashboardOrigin : void 0,
     previewOrigin: typeof value.previewOrigin === "string" ? value.previewOrigin : void 0
   };
 }
@@ -23595,6 +23942,38 @@ var EventBus = class {
   }
 };
 
+// ../../packages/core/src/request-auth.ts
+var requestAuthHeadersProvider = null;
+function normalizeHeaders(headers) {
+  if (!headers) {
+    return {};
+  }
+  if (headers instanceof Headers) {
+    return Object.fromEntries(headers.entries());
+  }
+  if (Array.isArray(headers)) {
+    return Object.fromEntries(headers);
+  }
+  return Object.fromEntries(
+    Object.entries(headers).flatMap(
+      ([key, value]) => value === void 0 ? [] : [[key, String(value)]]
+    )
+  );
+}
+function setRequestAuthHeadersProvider(provider) {
+  requestAuthHeadersProvider = provider;
+}
+function applyRequestAuthHeaders(init = {}) {
+  const headers = normalizeHeaders(init.headers);
+  if (!Object.keys(headers).some((key) => key.toLowerCase() === "authorization") && requestAuthHeadersProvider) {
+    Object.assign(headers, requestAuthHeadersProvider());
+  }
+  return {
+    ...init,
+    headers
+  };
+}
+
 // ../../packages/core/src/node-endpoints.ts
 var DEFAULT_NODE_REQUEST_TIMEOUT_MS = 1500;
 function getNodePublicEndpoint(node) {
@@ -23623,10 +24002,10 @@ function createRequestSignal(signal, timeoutMs) {
 async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_NODE_REQUEST_TIMEOUT_MS) {
   const { cleanup, signal } = createRequestSignal(init?.signal, timeoutMs);
   try {
-    return await fetch(url, {
+    return await fetch(url, applyRequestAuthHeaders({
       ...init,
       signal
-    });
+    }));
   } finally {
     cleanup();
   }
@@ -23672,6 +24051,10 @@ var NodeRegistry = class {
       endpoint: info.endpoint
     });
   }
+  upsertNode(info) {
+    this.nodes.set(info.id, { ...info });
+    this.store.upsertNode(info);
+  }
   removeNode(id) {
     this.nodes.delete(id);
     this.store.removeNode(id);
@@ -23742,6 +24125,24 @@ var NodeRegistry = class {
       }
     }
   }
+  updateDashboardOrigin(id, dashboardOrigin) {
+    const node = this.nodes.get(id);
+    if (node) {
+      if (dashboardOrigin) {
+        node.dashboardOrigin = dashboardOrigin;
+      } else {
+        delete node.dashboardOrigin;
+      }
+      this.store.upsertNode(node);
+    }
+    if (this.selfNode && this.selfNode.id === id) {
+      if (dashboardOrigin) {
+        this.selfNode.dashboardOrigin = dashboardOrigin;
+      } else {
+        delete this.selfNode.dashboardOrigin;
+      }
+    }
+  }
   updatePreviewOrigin(id, previewOrigin) {
     const node = this.nodes.get(id);
     if (node) {
@@ -23996,11 +24397,11 @@ var LeaderElection = class {
     const announcePromises = onlineNodes.map(async (node) => {
       try {
         const endpoint = getNodePublicEndpoint(node);
-        await fetch(`${endpoint}/api/worker/announce`, {
+        await fetch(`${endpoint}/api/worker/announce`, applyRequestAuthHeaders({
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({ leaderId, term })
-        });
+        }));
       } catch {
       }
     });
@@ -24092,6 +24493,44 @@ var TaskEngine = class {
     const tasks = this.store.getAllTasks(filter);
     return { tasks, total: tasks.length };
   }
+  importTasks(tasks) {
+    let created = 0;
+    let updated = 0;
+    for (const task of tasks) {
+      const existing = this.store.getTask(task.id);
+      if (!existing) {
+        this.store.createTask(task);
+        created++;
+        this.eventBus.emit("task.created", {
+          taskId: task.id,
+          title: task.title,
+          priority: task.priority
+        });
+        this.eventBus.emit("task.status", {
+          taskId: task.id,
+          status: task.status,
+          ...task.result ? { result: task.result } : {},
+          ...task.error ? { error: task.error } : {}
+        });
+        continue;
+      }
+      if (existing.updatedAt > task.updatedAt) {
+        continue;
+      }
+      const previousStatus = existing.status;
+      this.store.updateTask(task.id, task);
+      updated++;
+      if (task.status !== previousStatus) {
+        this.eventBus.emit("task.status", {
+          taskId: task.id,
+          status: task.status,
+          ...task.result ? { result: task.result } : {},
+          ...task.error ? { error: task.error } : {}
+        });
+      }
+    }
+    return { created, updated };
+  }
   updateTask(id, updates) {
     const existing = this.store.getTask(id);
     if (!existing) return null;
@@ -24740,6 +25179,7 @@ var HeartbeatMonitor = class {
           this.nodeRegistry.updateHeartbeat(node.id, Date.now());
           this.nodeRegistry.updateLoad(node.id, result.load);
           this.applyReportedDevTunnelState(node.id, result.devtunnelEnabled, result.devtunnelEndpoint);
+          this.nodeRegistry.updateDashboardOrigin(node.id, result.dashboardOrigin);
           this.nodeRegistry.updatePreviewOrigin(node.id, result.previewOrigin);
           if (result.workDirFolders) {
             this.nodeRegistry.updateFolders(node.id, result.workDirFolders);
@@ -24783,17 +25223,76 @@ var HeartbeatMonitor = class {
       load: 0,
       devtunnelEnabled: self.devtunnelEndpoint !== void 0,
       devtunnelEndpoint: self.devtunnelEndpoint,
+      dashboardOrigin: self.dashboardOrigin,
       previewOrigin: self.previewOrigin,
       workDirFolders: self.workDir ? listWorkDirFolders(self.workDir) : void 0
     };
   }
   // ── Leader: handle keepalive from follower ──────────────────────────
   handleKeepalive(req) {
-    const { nodeId, status, load, devtunnelEnabled, devtunnelEndpoint, previewOrigin, workDirFolders } = req;
+    const {
+      nodeId,
+      name,
+      endpoint,
+      status,
+      load,
+      capabilities,
+      transportType,
+      workDir,
+      devtunnelEnabled,
+      devtunnelEndpoint,
+      dashboardOrigin,
+      previewOrigin,
+      workDirFolders
+    } = req;
+    const existingNode = this.nodeRegistry.getNode(nodeId);
+    const normalizedName = name ?? existingNode?.name ?? nodeId;
+    const normalizedEndpoint = endpoint ?? existingNode?.endpoint ?? devtunnelEndpoint ?? "";
+    const normalizedCapabilities = capabilities ?? existingNode?.capabilities ?? [];
+    const currentCapabilities = existingNode?.capabilities ?? [];
     this.log.debug("keepalive received", { nodeId, status });
     this.followerMissedMap.set(nodeId, 0);
-    this.nodeRegistry.updateHeartbeat(nodeId, Date.now());
-    const node = this.nodeRegistry.getNode(nodeId);
+    let node = existingNode;
+    const now = Date.now();
+    if (!node) {
+      this.nodeRegistry.addNode({
+        id: nodeId,
+        name: normalizedName,
+        endpoint: normalizedEndpoint,
+        role: "follower",
+        status,
+        capabilities: normalizedCapabilities,
+        joinedAt: now,
+        lastHeartbeat: now,
+        ...transportType ? { transportType } : {},
+        ...workDir ? { workDir } : {},
+        ...devtunnelEnabled && devtunnelEndpoint ? { devtunnelEndpoint } : {},
+        ...dashboardOrigin ? { dashboardOrigin } : {},
+        ...previewOrigin ? { previewOrigin } : {},
+        ...workDirFolders ? { workDirFolders } : {}
+      });
+      this.log.info("keepalive restored missing follower", { nodeId, endpoint: normalizedEndpoint });
+      node = this.nodeRegistry.getNode(nodeId);
+    }
+    this.nodeRegistry.updateHeartbeat(nodeId, now);
+    node = this.nodeRegistry.getNode(nodeId);
+    if (node && normalizedEndpoint && node.endpoint !== normalizedEndpoint) {
+      this.nodeRegistry.updateEndpoint(nodeId, normalizedEndpoint);
+      node = this.nodeRegistry.getNode(nodeId);
+    }
+    if (node && (node.name !== normalizedName || node.transportType !== transportType || node.workDir !== workDir || currentCapabilities.length !== normalizedCapabilities.length || currentCapabilities.some((capability, index) => capability !== normalizedCapabilities[index]))) {
+      this.nodeRegistry.upsertNode({
+        ...node,
+        name: normalizedName,
+        endpoint: normalizedEndpoint || node.endpoint,
+        status,
+        lastHeartbeat: now,
+        capabilities: normalizedCapabilities,
+        ...transportType ? { transportType } : {},
+        ...workDir ? { workDir } : {}
+      });
+      node = this.nodeRegistry.getNode(nodeId);
+    }
     if (node && node.status === "offline") {
       this.nodeRegistry.updateStatus(nodeId, status);
       this.log.info("keepalive restored node", { nodeId, status });
@@ -24802,6 +25301,7 @@ var HeartbeatMonitor = class {
     }
     this.nodeRegistry.updateLoad(nodeId, load);
     this.applyReportedDevTunnelState(nodeId, devtunnelEnabled, devtunnelEndpoint);
+    this.nodeRegistry.updateDashboardOrigin(nodeId, dashboardOrigin);
     this.nodeRegistry.updatePreviewOrigin(nodeId, previewOrigin);
     if (workDirFolders) {
       this.nodeRegistry.updateFolders(nodeId, workDirFolders);
@@ -24840,19 +25340,25 @@ var HeartbeatMonitor = class {
     const self = this.nodeRegistry.getSelf();
     const request = {
       nodeId: self.id,
+      name: self.name,
+      endpoint: self.endpoint,
       status: self.status,
       load: 0,
+      capabilities: self.capabilities,
+      transportType: self.transportType,
+      workDir: self.workDir,
       devtunnelEnabled: self.devtunnelEndpoint !== void 0,
       devtunnelEndpoint: self.devtunnelEndpoint,
+      dashboardOrigin: self.dashboardOrigin,
       previewOrigin: self.previewOrigin,
       workDirFolders: self.workDir ? listWorkDirFolders(self.workDir) : void 0
     };
     try {
-      const response = await fetch(`${leaderEndpoint}/api/worker/keepalive`, {
+      const response = await fetch(`${leaderEndpoint}/api/worker/keepalive`, applyRequestAuthHeaders({
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(request)
-      });
+      }));
       if (response.ok) {
         const result = await response.json();
         this.log.debug("keepalive ok", { nodes: result.clusterState.nodes.length });
@@ -25022,11 +25528,11 @@ var HeartbeatMonitor = class {
       }
     }
     try {
-      const res = await fetch(`${leaderEndpoint}/api/worker/control-response`, {
+      const res = await fetch(`${leaderEndpoint}/api/worker/control-response`, applyRequestAuthHeaders({
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(response)
-      });
+      }));
       if (!res.ok) {
         this.log.warn("leader rejected control response", {
           requestId: request.requestId,
@@ -25116,12 +25622,12 @@ var DataRouter = class {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.config.proxyTimeout);
     try {
-      const response = await fetch(targetUrl, {
+      const response = await fetch(targetUrl, applyRequestAuthHeaders({
         method,
         headers: forwardHeaders,
         body,
         signal: controller.signal
-      });
+      }));
       const responseHeaders = {};
       response.headers.forEach((value, key) => {
         responseHeaders[key] = value;
@@ -25315,11 +25821,11 @@ function forwardLeaderTaskPatch(log, nodeRegistry, taskId, data, options) {
     log.warn(options.missingLeaderMessage, metadata);
     return;
   }
-  fetch(`${leaderEndpoint}/api/tasks/${taskId}`, {
+  fetch(`${leaderEndpoint}/api/tasks/${taskId}`, applyRequestAuthHeaders({
     method: "PATCH",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(buildLeaderTaskPatch(data))
-  }).then((response) => {
+  })).then((response) => {
     if (!response.ok) {
       log.warn(options.rejectedMessage, {
         ...metadata,
@@ -25366,11 +25872,11 @@ function forwardTaskOutputToLeader(log, nodeRegistry, taskId, event) {
     });
     return;
   }
-  fetch(`${leaderEndpoint}/api/worker/output`, {
+  fetch(`${leaderEndpoint}/api/worker/output`, applyRequestAuthHeaders({
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ taskId, event })
-  }).then((response) => {
+  })).then((response) => {
     if (!response.ok) {
       log.warn("leader rejected forwarded output", {
         taskId,
@@ -25438,7 +25944,7 @@ function registerLeaderForwarding(eventBus, nodeRegistry, log, taskId, agent) {
 // ../../packages/core/src/engines/claude-code-engine.ts
 var fs7 = __toESM(require("fs"), 1);
 var path7 = __toESM(require("path"), 1);
-var import_node_child_process = require("child_process");
+var import_node_child_process2 = require("child_process");
 function resolveClaudeInvocation() {
   if (process.platform !== "win32") {
     return { command: "claude", argsPrefix: [] };
@@ -25500,7 +26006,7 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
     this.ensureLogDir();
     this.logger.info("Spawning claude CLI", { taskId: task.id, title: task.title, cwd });
     const invocation = resolveClaudeInvocation();
-    const proc = (0, import_node_child_process.spawn)(invocation.command, [...invocation.argsPrefix, ...args], {
+    const proc = (0, import_node_child_process2.spawn)(invocation.command, [...invocation.argsPrefix, ...args], {
       cwd,
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -25610,7 +26116,7 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
       "stream-json"
     ];
     const invocation = resolveClaudeInvocation();
-    const proc = (0, import_node_child_process.spawn)(invocation.command, [...invocation.argsPrefix, ...args], {
+    const proc = (0, import_node_child_process2.spawn)(invocation.command, [...invocation.argsPrefix, ...args], {
       cwd: session.cwd,
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -25745,7 +26251,7 @@ var ClaudeCodeEngine = class extends ExecutionEngine {
 // ../../packages/core/src/engines/codex-engine.ts
 var fs8 = __toESM(require("fs"), 1);
 var path8 = __toESM(require("path"), 1);
-var import_node_child_process2 = require("child_process");
+var import_node_child_process3 = require("child_process");
 function buildAssistantEvent(text, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
   return {
     type: "assistant",
@@ -25804,7 +26310,7 @@ var CodexEngine = class extends ExecutionEngine {
     const args = this.buildArgs(prompt, imagePaths, { model: config.model });
     this.ensureLogDir();
     this.logger.info("Spawning codex CLI", { taskId: task.id, title: task.title, cwd });
-    const proc = (0, import_node_child_process2.spawn)("codex", args, {
+    const proc = (0, import_node_child_process3.spawn)("codex", args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -25831,7 +26337,7 @@ var CodexEngine = class extends ExecutionEngine {
     const { prompt, imagePaths } = this.prepareAssets(taskId, content);
     const args = this.buildArgs(prompt, imagePaths, { model, sessionId: session.sessionId });
     this.logger.info("Sending Codex follow-up message", { taskId, sessionId: session.sessionId });
-    const proc = (0, import_node_child_process2.spawn)("codex", args, {
+    const proc = (0, import_node_child_process3.spawn)("codex", args, {
       cwd: session.cwd,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -26191,16 +26697,17 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
       id: this.selfInfo.id,
       endpoint: this.selfInfo.endpoint,
       name: this.config.node.name,
-      capabilities: []
+      capabilities: [],
+      tasks: this.taskEngine.listTasks().tasks
     };
     if (this.selfInfo.devtunnelEndpoint) {
       joinBody.devtunnelEndpoint = this.selfInfo.devtunnelEndpoint;
     }
-    const response = await fetch(`${seedUrl}/api/cluster/join`, {
+    const response = await fetch(`${seedUrl}/api/cluster/join`, applyRequestAuthHeaders({
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(joinBody)
-    });
+    }));
     if (!response.ok) {
       const body = await response.json?.().catch(() => null);
       if (body?.error?.code === "NOT_LEADER") {
@@ -26212,13 +26719,36 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
       throw new Error(`Failed to join cluster via ${seedUrl}: ${response.status}`);
     }
     const data = await response.json();
-    for (const node of data.nodes) {
-      const existing = this.nodeRegistry.getNode(node.id);
-      if (!existing && node.id !== this.selfInfo.id) {
-        this.nodeRegistry.addNode(node);
-      }
+    this.applyClusterState(data.nodes, data.leaderId, data.term);
+  }
+  async leaveCluster() {
+    const leader = this.nodeRegistry.getLeader();
+    const leaderEndpoint = this.nodeRegistry.getLeaderEndpoint();
+    const self = this.nodeRegistry.getSelf();
+    if (!leader || !leaderEndpoint || leader.id === self.id) {
+      return;
     }
-    this.nodeRegistry.setLeader(data.leaderId, data.term);
+    try {
+      await fetch(`${leaderEndpoint}/api/cluster/leave`, applyRequestAuthHeaders({
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ nodeId: self.id })
+      }));
+    } catch {
+    }
+    const refreshedSelf = {
+      ...self,
+      role: "follower",
+      status: "online",
+      lastHeartbeat: Date.now(),
+      workDirFolders: listWorkDirFolders(this.getWorkDir())
+    };
+    this.selfInfo = refreshedSelf;
+    this.nodeRegistry.setSelf(refreshedSelf);
+    this.nodeRegistry.syncFromHeartbeat([refreshedSelf]);
+    this.nodeRegistry.clearLeader();
+    this.election.stepDown();
+    await this.election.startElection();
   }
   async stop() {
     if (!this.started) return;
@@ -26228,11 +26758,11 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
     try {
       const leaderEndpoint = this.nodeRegistry.getLeaderEndpoint();
       if (leaderEndpoint) {
-        await fetch(`${leaderEndpoint}/api/cluster/leave`, {
+        await fetch(`${leaderEndpoint}/api/cluster/leave`, applyRequestAuthHeaders({
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({ nodeId: this.selfInfo.id })
-        });
+        }));
       }
     } catch {
     }
@@ -26313,11 +26843,11 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
       const leaderEndpoint = this.nodeRegistry.getLeaderEndpoint();
       if (leaderEndpoint && !this.nodeRegistry.isLeader()) {
         try {
-          await fetch(`${leaderEndpoint}/api/nodes/${this.selfInfo.id}`, {
+          await fetch(`${leaderEndpoint}/api/nodes/${this.selfInfo.id}`, applyRequestAuthHeaders({
             method: "PATCH",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({ endpoint: newEndpoint })
-          });
+          }));
         } catch {
         }
       }
@@ -26381,6 +26911,22 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
     this.selfInfo.role = current.role;
     this.selfInfo.status = current.status;
   }
+  applyClusterState(nodes, leaderId, term) {
+    const remoteSelf = nodes.find((node) => node.id === this.selfInfo.id);
+    const nextSelf = {
+      ...this.selfInfo,
+      ...remoteSelf ?? {},
+      transportType: this.config.transport.type,
+      workDir: this.selfInfo.workDir,
+      workDirFolders: listWorkDirFolders(this.getWorkDir()),
+      ...this.selfInfo.devtunnelEndpoint ? { devtunnelEndpoint: this.selfInfo.devtunnelEndpoint } : {},
+      ...this.selfInfo.previewOrigin ? { previewOrigin: this.selfInfo.previewOrigin } : {}
+    };
+    this.selfInfo = nextSelf;
+    this.nodeRegistry.setSelf(nextSelf);
+    this.nodeRegistry.syncFromHeartbeat(nodes);
+    this.election.handleLeaderAnnounce({ leaderId, term });
+  }
   cloneTransportConfig(config) {
     return {
       type: config.type,
@@ -30609,14 +31155,36 @@ var NodeInfoSchema = external_exports.object({
   lastHeartbeat: external_exports.number(),
   transportType: external_exports.string().optional(),
   devtunnelEndpoint: external_exports.string().optional(),
+  dashboardOrigin: external_exports.string().optional(),
   previewOrigin: external_exports.string().optional()
 });
+var JoinTaskSchema = external_exports.object({
+  id: external_exports.string(),
+  title: external_exports.string(),
+  description: external_exports.string(),
+  agent: external_exports.string(),
+  project: external_exports.string().nullable(),
+  effectiveProjectPath: external_exports.string().nullable(),
+  payload: external_exports.record(external_exports.unknown()),
+  status: external_exports.enum(["pending", "assigned", "running", "completed", "failed", "cancelled", "archived"]),
+  priority: external_exports.enum(["low", "normal", "high", "critical"]),
+  assignedTo: external_exports.string().nullable(),
+  assignedNodeName: external_exports.string().nullable().optional(),
+  createdBy: external_exports.string(),
+  result: external_exports.record(external_exports.unknown()).nullable(),
+  error: external_exports.string().nullable(),
+  retryCount: external_exports.number(),
+  maxRetries: external_exports.number(),
+  createdAt: external_exports.number(),
+  updatedAt: external_exports.number()
+});
 var JoinClusterBody = external_exports.object({
   id: external_exports.string().min(1),
   endpoint: external_exports.string().url(),
   name: external_exports.string().min(1),
   capabilities: external_exports.array(external_exports.string()).default([]),
-  devtunnelEndpoint: external_exports.string().url().optional()
+  devtunnelEndpoint: external_exports.string().url().optional(),
+  tasks: external_exports.array(JoinTaskSchema).default([])
 });
 var JoinClusterResponse = external_exports.object({
   clusterId: external_exports.string(),
@@ -30640,6 +31208,10 @@ var ElectionBody = external_exports.object({
   candidateId: external_exports.string(),
   term: external_exports.number().int().min(1)
 });
+var ConnectClusterBody = external_exports.object({
+  leaderEndpoint: external_exports.string().url(),
+  transport: external_exports.literal("devtunnel")
+});
 
 // ../../packages/api/src/schemas/nodes.ts
 var NodeInfoSchema2 = external_exports.object({
@@ -30653,6 +31225,7 @@ var NodeInfoSchema2 = external_exports.object({
   lastHeartbeat: external_exports.number(),
   transportType: external_exports.string().optional(),
   devtunnelEndpoint: external_exports.string().optional(),
+  dashboardOrigin: external_exports.string().optional(),
   previewOrigin: external_exports.string().optional()
 });
 var NodeListQuery = external_exports.object({
@@ -30707,6 +31280,7 @@ var TaskListResponse = external_exports.object({
     priority: external_exports.enum(["low", "normal", "high", "critical"]),
     assignedTo: external_exports.string().nullable(),
     assignedNodeName: external_exports.string().nullable().optional(),
+    assignedNodeAvailable: external_exports.boolean().optional(),
     createdBy: external_exports.string(),
     result: external_exports.record(external_exports.unknown()).nullable(),
     error: external_exports.string().nullable(),
@@ -30778,13 +31352,113 @@ var import_express7 = __toESM(require_express2(), 1);
 
 // ../../packages/api/src/middleware/auth.ts
 var SKIP_AUTH_PATHS = ["/api/system/health"];
+var TRUSTED_LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+function normalizeHost(value) {
+  if (!value) return void 0;
+  const trimmed = value.trim().toLowerCase();
+  if (!trimmed) return void 0;
+  return trimmed.replace(/:\d+$/, "");
+}
+function collectHosts(candidates) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    for (const item of candidate.split(",")) {
+      const normalized = normalizeHost(item);
+      if (normalized) {
+        unique.add(normalized);
+      }
+    }
+  }
+  return [...unique];
+}
+function getForwardedHosts(req) {
+  const forwardedHosts = collectHosts([
+    typeof req.headers["x-forwarded-host"] === "string" ? req.headers["x-forwarded-host"] : void 0
+  ]);
+  if (forwardedHosts.length > 0) {
+    return forwardedHosts;
+  }
+  const forwardedHeader = typeof req.headers.forwarded === "string" ? req.headers.forwarded : void 0;
+  if (!forwardedHeader) {
+    return [];
+  }
+  const forwardedMatches = [...forwardedHeader.matchAll(/host=([^;,\s]+)/gi)];
+  return collectHosts(forwardedMatches.map((match) => match[1]?.replace(/^"|"$/g, "")));
+}
+function getDirectHosts(req) {
+  return collectHosts([
+    req.hostname,
+    typeof req.headers.host === "string" ? req.headers.host : void 0
+  ]);
+}
+function getRequestHosts(req) {
+  const forwardedHosts = getForwardedHosts(req);
+  if (forwardedHosts.length > 0) {
+    return forwardedHosts;
+  }
+  return getDirectHosts(req);
+}
+function isTrustedDashboardRequest(req, config) {
+  const trustedHosts = new Set((config.getTrustedHosts?.() ?? []).map((host) => normalizeHost(host)).filter(Boolean));
+  for (const host of getRequestHosts(req)) {
+    if (TRUSTED_LOCAL_HOSTS.has(host) || trustedHosts.has(host)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getAuthLogger(req) {
+  const logger = req.app?.locals?.deps?.logger;
+  if (logger && typeof logger.child === "function") {
+    return logger.child("api/auth");
+  }
+  return {
+    debug() {
+    },
+    warn() {
+    }
+  };
+}
 function createAuthMiddleware(config) {
   return (req, _res, next) => {
-    if (!config.apiKey) {
+    const log = getAuthLogger(req);
+    if (SKIP_AUTH_PATHS.includes(req.path)) {
       next();
       return;
     }
-    if (SKIP_AUTH_PATHS.includes(req.path)) {
+    if (config.validateBearerToken) {
+      if (isTrustedDashboardRequest(req, config)) {
+        log.debug("skipping bearer auth for trusted dashboard request", {
+          path: req.path,
+          method: req.method,
+          hosts: getRequestHosts(req)
+        });
+        next();
+        return;
+      }
+      const result = config.validateBearerToken(req.headers.authorization);
+      if (!result.ok) {
+        log.warn("rejected bearer-authenticated request", {
+          path: req.path,
+          method: req.method,
+          hosts: getRequestHosts(req),
+          reason: result.reason
+        });
+        throw new MeshyError("VALIDATION_ERROR", "Invalid or missing bearer token", 401, {
+          reason: result.reason
+        });
+      }
+      log.debug("accepted bearer-authenticated request", {
+        path: req.path,
+        method: req.method,
+        hosts: getRequestHosts(req),
+        reason: result.reason
+      });
+      next();
+      return;
+    }
+    if (!config.apiKey) {
       next();
       return;
     }
@@ -30885,13 +31559,32 @@ function createErrorMiddleware() {
 
 // ../../packages/api/src/routes/cluster.ts
 var import_express = __toESM(require_express2(), 1);
+var CONNECTIVITY_TIMEOUT_MS = 8e3;
+async function verifyHealth(endpoint) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), CONNECTIVITY_TIMEOUT_MS);
+  try {
+    const response = await fetch(`${endpoint}/api/system/health`, {
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`health check returned ${response.status}`);
+    }
+  } catch (err) {
+    throw new Error(
+      `Failed to verify connectivity for ${endpoint}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+}
 function asyncHandler(fn) {
   return (req, res, next) => fn(req, res, next).catch(next);
 }
 function createClusterRoutes() {
   const router = (0, import_express.Router)();
   router.post("/join", asyncHandler(async (req, res) => {
-    const { nodeRegistry, election } = req.app.locals.deps;
+    const { nodeRegistry, election, taskEngine } = req.app.locals.deps;
     if (!election.isLeader()) {
       const leaderEndpoint = nodeRegistry.getLeaderEndpoint();
       res.status(421).json({
@@ -30922,6 +31615,7 @@ function createClusterRoutes() {
       ...body.devtunnelEndpoint && { devtunnelEndpoint: body.devtunnelEndpoint }
     };
     nodeRegistry.addNode(node);
+    taskEngine.importTasks(body.tasks ?? []);
     const clusterState = nodeRegistry.getClusterState();
     res.status(201).json({
       clusterId: clusterState.clusterId ?? nanoid(),
@@ -30930,13 +31624,50 @@ function createClusterRoutes() {
       nodes: clusterState.nodes
     });
   }));
+  router.post("/connect", asyncHandler(async (req, res) => {
+    const {
+      nodeRegistry,
+      joinCurrentNodeToCluster
+    } = req.app.locals.deps;
+    const body = ConnectClusterBody.parse(req.body);
+    if (!joinCurrentNodeToCluster) {
+      throw new MeshyError("VALIDATION_ERROR", "Join flow is not available on this node", 501);
+    }
+    await verifyHealth(body.leaderEndpoint);
+    await joinCurrentNodeToCluster(body.leaderEndpoint);
+    const self = nodeRegistry.getSelf();
+    const clusterState = nodeRegistry.getClusterState();
+    res.json({
+      ok: true,
+      transport: body.transport,
+      self,
+      leaderId: clusterState.leaderId,
+      term: clusterState.term,
+      nodes: clusterState.nodes
+    });
+  }));
   router.post("/leave", asyncHandler(async (req, res) => {
-    const { nodeRegistry, eventBus } = req.app.locals.deps;
+    const { nodeRegistry } = req.app.locals.deps;
     const { nodeId } = req.body;
     nodeRegistry.removeNode(nodeId);
-    eventBus.emit("node.left", { nodeId, reason: "left" });
     res.json({ ok: true });
   }));
+  router.post("/disconnect", asyncHandler(async (req, res) => {
+    const { leaveCurrentCluster, nodeRegistry } = req.app.locals.deps;
+    if (!leaveCurrentCluster) {
+      throw new MeshyError("VALIDATION_ERROR", "Leave flow is not available on this node", 501);
+    }
+    await leaveCurrentCluster();
+    const self = nodeRegistry.getSelf();
+    const clusterState = nodeRegistry.getClusterState();
+    res.json({
+      ok: true,
+      self,
+      leaderId: clusterState.leaderId,
+      term: clusterState.term,
+      nodes: clusterState.nodes
+    });
+  }));
   router.get("/state", asyncHandler(async (req, res) => {
     const { nodeRegistry, taskEngine } = req.app.locals.deps;
     const clusterState = nodeRegistry.getClusterState();
@@ -31419,10 +32150,10 @@ function readFileContent(root, relativePath) {
 }
 
 // ../../packages/api/src/output/git-diff.ts
-var import_node_child_process3 = require("child_process");
+var import_node_child_process4 = require("child_process");
 function git(args, cwd) {
   try {
-    return (0, import_node_child_process3.execFileSync)("git", ["-C", cwd, ...args], {
+    return (0, import_node_child_process4.execFileSync)("git", ["-C", cwd, ...args], {
       encoding: "utf-8",
       timeout: 1e4,
       stdio: ["pipe", "pipe", "pipe"]
@@ -31615,7 +32346,8 @@ async function executeWorkerControlRequest(deps, request) {
           return jsonResponse(request.requestId, 200, {
             ok: true,
             enabled: true,
-            devtunnelEndpoint
+            devtunnelEndpoint,
+            dashboardOrigin: deps.nodeRegistry.getSelf().dashboardOrigin
           });
         }
         if (!deps.disableDevTunnel) {
@@ -31624,7 +32356,8 @@ async function executeWorkerControlRequest(deps, request) {
         await deps.disableDevTunnel();
         return jsonResponse(request.requestId, 200, {
           ok: true,
-          enabled: false
+          enabled: false,
+          dashboardOrigin: deps.nodeRegistry.getSelf().dashboardOrigin
         });
       }
       case "task-cancel": {
@@ -31826,7 +32559,7 @@ function createNodeRoutes() {
     res.json(node);
   }));
   router.delete("/:id", asyncHandler2(async (req, res) => {
-    const { nodeRegistry, eventBus, election } = req.app.locals.deps;
+    const { nodeRegistry, election } = req.app.locals.deps;
     if (!election.isLeader()) {
       throw new MeshyError("NOT_LEADER", "Only the leader node can delete nodes", 403);
     }
@@ -31835,7 +32568,6 @@ function createNodeRoutes() {
       throw new MeshyError("NODE_NOT_FOUND", `Node ${req.params.id} not found`, 404);
     }
     nodeRegistry.removeNode(req.params.id);
-    eventBus.emit("node.left", { nodeId: req.params.id, reason: "deleted" });
     res.json({ ok: true });
   }));
   router.post("/:id/devtunnel", asyncHandler2(async (req, res) => {
@@ -31859,10 +32591,19 @@ function createNodeRoutes() {
       }
       if (enabled) {
         const devtunnelEndpoint = await enableDevTunnel();
-        res.json({ ok: true, enabled: true, devtunnelEndpoint });
+        res.json({
+          ok: true,
+          enabled: true,
+          devtunnelEndpoint,
+          dashboardOrigin: nodeRegistry.getSelf().dashboardOrigin
+        });
       } else {
         await disableDevTunnel();
-        res.json({ ok: true, enabled: false });
+        res.json({
+          ok: true,
+          enabled: false,
+          dashboardOrigin: nodeRegistry.getSelf().dashboardOrigin
+        });
       }
     } else {
       const node = nodeRegistry.getNode(targetId);
@@ -31901,6 +32642,7 @@ function createNodeRoutes() {
           if (result?.ok) {
             if (nodeRegistry.getNode(targetId)) {
               nodeRegistry.updateDevTunnelEndpoint(targetId, result.devtunnelEndpoint);
+              nodeRegistry.updateDashboardOrigin(targetId, result.dashboardOrigin);
             }
           }
           sendWorkerControlResponse(res, controlResponse);
@@ -31916,6 +32658,7 @@ function createNodeRoutes() {
       const updatedNode = nodeRegistry.getNode(targetId);
       if (updatedNode) {
         nodeRegistry.updateDevTunnelEndpoint(targetId, result.devtunnelEndpoint);
+        nodeRegistry.updateDashboardOrigin(targetId, result.dashboardOrigin);
       }
       res.json(result);
     }
@@ -32042,17 +32785,15 @@ var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["pending", "assigned", "running"]
 function asyncHandler3(fn) {
   return (req, res, next) => fn(req, res, next).catch(next);
 }
-function withAssignedNodeName(task, nodeRegistry) {
-  if (task.assignedNodeName || !task.assignedTo) {
+function withAssignedNodeMetadata(task, nodeRegistry) {
+  if (!task.assignedTo) {
     return task;
   }
   const node = nodeRegistry.getNode(task.assignedTo);
-  if (!node?.name) {
-    return task;
-  }
   return {
     ...task,
-    assignedNodeName: node.name
+    assignedNodeName: task.assignedNodeName ?? node?.name ?? null,
+    assignedNodeAvailable: node?.status !== "offline" && Boolean(node)
   };
 }
 function createTaskRoutes() {
@@ -32071,10 +32812,10 @@ function createTaskRoutes() {
     });
     if (body.assignTo) {
       const assigned = taskEngine.assignTask(task.id, body.assignTo);
-      res.status(201).json(withAssignedNodeName(assigned, nodeRegistry));
+      res.status(201).json(withAssignedNodeMetadata(assigned, nodeRegistry));
       return;
     }
-    res.status(201).json(withAssignedNodeName(task, nodeRegistry));
+    res.status(201).json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
   router.get("/", asyncHandler3(async (req, res) => {
     const { taskEngine, nodeRegistry } = req.app.locals.deps;
@@ -32087,7 +32828,7 @@ function createTaskRoutes() {
     if (query.offset) filter.offset = query.offset;
     const result = taskEngine.listTasks(filter);
     res.json({
-      tasks: result.tasks.map((task) => withAssignedNodeName(task, nodeRegistry)),
+      tasks: result.tasks.map((task) => withAssignedNodeMetadata(task, nodeRegistry)),
       total: result.total
     });
   }));
@@ -32128,7 +32869,7 @@ function createTaskRoutes() {
     if (!task) {
       throw new MeshyError("TASK_NOT_FOUND", `Task ${req.params.id} not found`, 404);
     }
-    res.json(withAssignedNodeName(task, nodeRegistry));
+    res.json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
   router.patch("/:id", asyncHandler3(async (req, res) => {
     const { taskEngine, nodeRegistry, logger: rootLogger } = req.app.locals.deps;
@@ -32144,7 +32885,7 @@ function createTaskRoutes() {
         currentStatus: existing.status,
         incomingStatus: updates.status
       });
-      res.json(withAssignedNodeName(existing, nodeRegistry));
+      res.json(withAssignedNodeMetadata(existing, nodeRegistry));
       return;
     }
     if (updates.status === "archived" && !ARCHIVABLE_STATUSES.has(existing.status)) {
@@ -32160,14 +32901,14 @@ function createTaskRoutes() {
         currentStatus: existing.status,
         incomingStatus: updates.status
       });
-      res.json(withAssignedNodeName(existing, nodeRegistry));
+      res.json(withAssignedNodeMetadata(existing, nodeRegistry));
       return;
     }
     const task = taskEngine.updateTask(req.params.id, updates);
     if (!task) {
       throw new MeshyError("TASK_NOT_FOUND", `Task ${req.params.id} not found`, 404);
     }
-    res.json(withAssignedNodeName(task, nodeRegistry));
+    res.json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
   router.delete("/:id", asyncHandler3(async (req, res) => {
     const { taskEngine } = req.app.locals.deps;
@@ -32218,12 +32959,12 @@ function createTaskRoutes() {
     const { taskEngine, nodeRegistry } = req.app.locals.deps;
     const body = AssignTaskBody.parse(req.body);
     const task = taskEngine.assignTask(req.params.id, body.nodeId);
-    res.json(withAssignedNodeName(task, nodeRegistry));
+    res.json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
   router.post("/:id/retry", asyncHandler3(async (req, res) => {
     const { taskEngine, nodeRegistry } = req.app.locals.deps;
     const task = taskEngine.retryTask(req.params.id);
-    res.json(withAssignedNodeName(task, nodeRegistry));
+    res.json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
   router.get("/:id/logs", asyncHandler3(async (req, res) => {
     const { engineRegistry, taskEngine, nodeRegistry, logger: rootLogger } = req.app.locals.deps;
@@ -32308,26 +33049,18 @@ function createTaskRoutes() {
     }
     if (task.assignedTo && task.assignedTo !== nodeRegistry.getSelf()?.id) {
       const node = nodeRegistry.getNode(task.assignedTo);
-      const selfId = nodeRegistry.getSelf()?.id ?? null;
       if (!node || node.status === "offline") {
-        log.warn("assigned worker unavailable, resuming follow-up locally", {
+        log.warn("assigned worker unavailable for follow-up", {
           taskId: task.id,
-          assignedTo: task.assignedTo,
-          nodeFound: Boolean(node),
-          nodeStatus: node?.status,
-          reassignedTo: selfId
-        });
-        startLocalTaskFollowUp({
-          taskEngine,
-          engineRegistry,
-          logger: log
-        }, task, body.content, selfId, {
           assignedTo: task.assignedTo,
           nodeFound: Boolean(node),
           nodeStatus: node?.status
         });
-        res.json({ ok: true, reassigned: true });
-        return;
+        throw new MeshyError(
+          "NODE_OFFLINE",
+          `Task ${task.id} is unavailable because ${task.assignedNodeName ?? task.assignedTo} is no longer reachable`,
+          409
+        );
       }
       taskEngine.updateTask(task.id, { status: "running" });
       let workerEndpoint = node.endpoint;
@@ -32858,13 +33591,19 @@ function createSystemRoutes() {
     res.json({ status: "ok", timestamp: Date.now() });
   }));
   router.get("/info", asyncHandler5(async (req, res) => {
-    const { nodeRegistry, getTransportType } = req.app.locals.deps;
+    const { nodeRegistry, getTransportType, config, dashboardOrigin } = req.app.locals.deps;
     const self = nodeRegistry.getSelf();
     res.json({
       ...self,
       version: "0.1.0",
       uptime: process.uptime(),
-      transportType: getTransportType?.() ?? "direct"
+      transportType: getTransportType?.() ?? "direct",
+      dashboardOrigin: dashboardOrigin ?? self.dashboardOrigin,
+      auth: config.authMetadata ?? {
+        enabled: false,
+        allowSameTenant: false,
+        allowedUsers: []
+      }
     });
   }));
   router.post("/transport", asyncHandler5(async (req, res) => {
@@ -32895,10 +33634,19 @@ function createSystemRoutes() {
     assertCanChangeNodeDevTunnel(taskEngine, nodeRegistry.getSelf().id);
     if (enabled) {
       const devtunnelEndpoint = await enableDevTunnel();
-      res.json({ ok: true, enabled: true, devtunnelEndpoint });
+      res.json({
+        ok: true,
+        enabled: true,
+        devtunnelEndpoint,
+        dashboardOrigin: nodeRegistry.getSelf().dashboardOrigin
+      });
     } else {
       await disableDevTunnel();
-      res.json({ ok: true, enabled: false });
+      res.json({
+        ok: true,
+        enabled: false,
+        dashboardOrigin: nodeRegistry.getSelf().dashboardOrigin
+      });
     }
   }));
   router.get("/metrics", asyncHandler5(async (req, res) => {
@@ -33028,13 +33776,39 @@ function createServer2(deps) {
   if (typeof deps.heartbeat.setControlRequestHandler === "function") {
     deps.heartbeat.setControlRequestHandler((request) => executeWorkerControlRequest(deps, request));
   }
+  const authConfig = {
+    apiKey: deps.config.apiKey,
+    validateBearerToken: deps.config.validateBearerToken,
+    getTrustedHosts: () => {
+      const trustedHosts = [];
+      if (deps.dashboardOrigin) {
+        try {
+          trustedHosts.push(new URL(deps.dashboardOrigin).host);
+        } catch {
+        }
+      }
+      return trustedHosts;
+    }
+  };
+  const isApiRequest = (req) => req.path === "/api" || req.path.startsWith("/api/");
+  const canServeDashboard = (req) => !deps.config.validateBearerToken || isTrustedDashboardRequest(req, authConfig);
   const runtimeBaseDir = resolveRuntimeBaseDir();
   const staticDir = resolveStaticDir(runtimeBaseDir);
   if (staticDir) {
-    app.use(import_express7.default.static(staticDir));
+    const staticMiddleware = import_express7.default.static(staticDir);
+    app.use((req, res, next) => {
+      if (isApiRequest(req)) {
+        next();
+        return;
+      }
+      if (!canServeDashboard(req)) {
+        res.status(404).type("text/plain").send("Not Found");
+        return;
+      }
+      staticMiddleware(req, res, next);
+    });
   }
   app.use(import_express7.default.json({ limit: JSON_BODY_LIMIT }));
-  const authConfig = { apiKey: deps.config.apiKey };
   app.use(createAuthMiddleware(authConfig));
   app.use(createRoutingMiddleware(deps.dataRouter));
   const largeBodyParser = import_express7.default.json({ limit: JSON_BODY_LIMIT_LARGE });
@@ -33047,7 +33821,15 @@ function createServer2(deps) {
   if (staticDir) {
     const indexPath = path15.join(staticDir, "index.html");
     if (fs15.existsSync(indexPath)) {
-      app.get("*", (_req, res) => {
+      app.get("*", (req, res, next) => {
+        if (isApiRequest(req)) {
+          next();
+          return;
+        }
+        if (!canServeDashboard(req)) {
+          res.status(404).type("text/plain").send("Not Found");
+          return;
+        }
         res.sendFile(indexPath);
       });
     }
@@ -33122,10 +33904,10 @@ var DirectTransport = class {
 };
 
 // ../../packages/transport/src/devtunnel.ts
-var import_node_child_process4 = require("child_process");
+var import_node_child_process5 = require("child_process");
 function isInstalled(cmd) {
   try {
-    (0, import_node_child_process4.execSync)(process.platform === "win32" ? `where ${cmd}` : `command -v ${cmd}`, { stdio: "pipe" });
+    (0, import_node_child_process5.execSync)(process.platform === "win32" ? `where ${cmd}` : `command -v ${cmd}`, { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -33148,14 +33930,14 @@ var DevTunnelTransport = class {
       );
     }
     try {
-      (0, import_node_child_process4.execSync)("devtunnel user show", { stdio: "pipe" });
+      (0, import_node_child_process5.execSync)("devtunnel user show", { stdio: "pipe" });
     } catch {
       throw new Error(
         "Not logged in to devtunnel. Run: devtunnel user login"
       );
     }
     const hostArgs = this.buildHostArgs(localPort);
-    const child = (0, import_node_child_process4.spawn)("devtunnel", hostArgs, {
+    const child = (0, import_node_child_process5.spawn)("devtunnel", hostArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.process = child;
@@ -33260,7 +34042,7 @@ ${lines.join("")}`
       return void 0;
     }
     try {
-      (0, import_node_child_process4.execFileSync)("devtunnel", ["show", tunnelId], { stdio: "pipe" });
+      (0, import_node_child_process5.execFileSync)("devtunnel", ["show", tunnelId], { stdio: "pipe" });
       return tunnelId;
     } catch {
       const createArgs = ["create", tunnelId];
@@ -33268,7 +34050,7 @@ ${lines.join("")}`
         createArgs.push("-a");
       }
       try {
-        (0, import_node_child_process4.execFileSync)("devtunnel", createArgs, { stdio: "pipe" });
+        (0, import_node_child_process5.execFileSync)("devtunnel", createArgs, { stdio: "pipe" });
         return tunnelId;
       } catch (err) {
         throw new Error(
@@ -33283,7 +34065,7 @@ ${lines.join("")}`
       return;
     }
     try {
-      (0, import_node_child_process4.execFileSync)(
+      (0, import_node_child_process5.execFileSync)(
         "devtunnel",
         ["port", "create", tunnelId, "-p", String(localPort), "--protocol", "http"],
         { stdio: "pipe" }
@@ -33299,7 +34081,7 @@ ${lines.join("")}`
   }
   listTunnelPorts(tunnelId) {
     try {
-      const output = (0, import_node_child_process4.execFileSync)("devtunnel", ["port", "list", tunnelId, "-j"], { stdio: "pipe" });
+      const output = (0, import_node_child_process5.execFileSync)("devtunnel", ["port", "list", tunnelId, "-j"], { stdio: "pipe" });
       const parsed = JSON.parse(output.toString());
       const items = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.ports) ? parsed.ports : parsed && typeof parsed === "object" && Array.isArray(parsed.value) ? parsed.value : [];
       return items.map((item) => getPortNumber(item)).filter((value) => value !== void 0);
@@ -33311,7 +34093,7 @@ ${lines.join("")}`
   }
   hasTunnelPort(tunnelId, localPort) {
     try {
-      (0, import_node_child_process4.execFileSync)(
+      (0, import_node_child_process5.execFileSync)(
         "devtunnel",
         ["port", "show", tunnelId, "-p", String(localPort), "-j"],
         { stdio: "pipe" }
@@ -33365,7 +34147,9 @@ function createTransport(config) {
   }
 }
 
-// src/main.ts
+// src/startup.ts
+var fs16 = __toESM(require("fs"), 1);
+var readline = __toESM(require("readline/promises"), 1);
 function getDefaultNodeName() {
   return getDeviceNodeName();
 }
@@ -33381,9 +34165,10 @@ function createDefaultConfig(storagePath = resolveDefaultStoragePath(), nodeName
   };
 }
 var DEFAULT_CONFIG3 = createDefaultConfig();
-function createRuntimeDefaultConfig(fileConfig) {
+function createRuntimeDefaultConfig(fileConfig, options = {}) {
   const storagePath = fileConfig.storage?.path ?? resolveDefaultStoragePath();
-  return createDefaultConfig(storagePath, resolveDefaultNodeName(storagePath));
+  const nodeName = options.ignorePersistedName ? getDeviceNodeName() : resolveDefaultNodeName(storagePath);
+  return createDefaultConfig(storagePath, nodeName);
 }
 function parseArgs(argv) {
   const result = {};
@@ -33421,6 +34206,12 @@ function parseArgs(argv) {
           result.config = argv[++i];
         }
         break;
+      case "--reset":
+        result.reset = true;
+        break;
+      case "--disable-auth":
+        result.disableAuth = true;
+        break;
     }
   }
   return result;
@@ -33531,6 +34322,67 @@ async function promptStartOptions(args, fileConfig, defaults, prompt) {
     await closePrompt?.();
   }
 }
+function applyStartMetadata(storagePath, args) {
+  const startup = resolveNodeStartupMetadata(storagePath);
+  const result = { ...args };
+  const loaded = {};
+  const persistedName = resolvePersistedDefaultNodeName(storagePath);
+  if (persistedName && result.name === void 0) {
+    loaded.name = persistedName;
+  }
+  if (startup.port !== void 0 && result.port === void 0) {
+    result.port = startup.port;
+    loaded.port = startup.port;
+  }
+  if (startup.transport && result.transport === void 0) {
+    result.transport = startup.transport;
+    loaded.transport = startup.transport;
+  }
+  if (startup.join && result.join === void 0) {
+    result.join = startup.join;
+    loaded.join = startup.join;
+  }
+  return {
+    args: result,
+    loaded: Object.keys(loaded).length > 0 ? loaded : void 0
+  };
+}
+function shouldCollectStartOptions(args, storagePath) {
+  return args.reset === true || !hasPersistedNodeStartupMetadata(storagePath);
+}
+function resolveRuntimeAuthMetadata(storagePath, disableAuth = false) {
+  const persisted = resolveNodeAuthMetadata(storagePath);
+  if (disableAuth) {
+    return { ...persisted, enabled: false };
+  }
+  if (!persisted.enabled && !persisted.allowSameTenant && persisted.allowedUsers.length === 0) {
+    return {
+      enabled: true,
+      allowSameTenant: false,
+      allowedUsers: []
+    };
+  }
+  return persisted;
+}
+function formatLoadedStartMetadata(info, authEnabled) {
+  const lines = ["Loaded startup options from metadata:"];
+  if (info.name) {
+    lines.push(`  Node: ${info.name}`);
+  }
+  if (info.port !== void 0) {
+    lines.push(`  Port: ${info.port}`);
+  }
+  if (info.transport) {
+    lines.push(`  Transport: ${info.transport}`);
+  }
+  if (info.join) {
+    lines.push(`  Join: ${info.join}`);
+  }
+  lines.push(`  Auth: ${authEnabled ? "enabled" : "disabled"}`);
+  return lines.join("\n");
+}
+
+// src/main.ts
 function formatBanner(info) {
   const lines = [
     `Node:      ${info.name}`,
@@ -33538,6 +34390,9 @@ function formatBanner(info) {
     `Endpoint:  ${info.endpoint}`,
     `Dashboard: http://localhost:${info.port}`
   ];
+  if (info.dashboardOrigin) {
+    lines.push(`Dashboard Tunnel: ${info.dashboardOrigin}`);
+  }
   const maxLen = Math.max(...lines.map((l) => l.length));
   const innerWidth = maxLen + 4;
   const top = `  \u256D${"\u2500".repeat(innerWidth)}\u256E`;
@@ -33559,16 +34414,48 @@ async function main() {
   const args = parseArgs(process.argv.slice(2));
   const configPath = args.config ?? "./config.json";
   const fileConfig = loadConfigFile(configPath);
-  const defaults = createRuntimeDefaultConfig(fileConfig);
-  const resolvedArgs = await promptStartOptions(args, fileConfig, defaults);
+  const storagePath = fileConfig.storage?.path ?? resolveDefaultStoragePath();
+  const hydratedArgs = args.reset ? { args: { ...args }, loaded: void 0 } : applyStartMetadata(storagePath, args);
+  const defaults = createRuntimeDefaultConfig(fileConfig, {
+    ignorePersistedName: args.reset === true
+  });
+  const resolvedArgs = shouldCollectStartOptions(args, storagePath) ? await promptStartOptions(
+    args.reset ? args : hydratedArgs.args,
+    fileConfig,
+    defaults
+  ) : hydratedArgs.args;
   const config = mergeConfig(defaults, fileConfig, resolvedArgs);
   persistDefaultNodeName(config.storage.path, config.node.name);
+  persistNodeStartupMetadata(config.storage.path, {
+    port: config.node.port,
+    transport: config.transport.type,
+    join: resolvedArgs.join
+  });
+  const authMetadata = resolveRuntimeAuthMetadata(config.storage.path, resolvedArgs.disableAuth === true);
+  if (!resolvedArgs.disableAuth) {
+    persistNodeAuthMetadata(config.storage.path, authMetadata);
+  }
   const logDir = nodePath.join(config.storage.path, "logs");
   const logger = createLogger({
     component: "node",
     logDir,
     console: true
   });
+  const nodeAuth = new AzureCliNodeAuth(config.storage.path, {
+    logger: logger.child("azure-auth"),
+    settingsProvider: () => authMetadata
+  });
+  if (hydratedArgs.loaded) {
+    console.log("");
+    console.log(formatLoadedStartMetadata(hydratedArgs.loaded, authMetadata.enabled));
+    console.log("");
+  }
+  if (authMetadata.enabled) {
+    nodeAuth.getAccessToken();
+    setRequestAuthHeadersProvider(() => nodeAuth.getAuthorizationHeaders());
+  } else {
+    setRequestAuthHeadersProvider(null);
+  }
   const meshyNode = new MeshyNode(config, {
     logger,
     transportFactory: createTransport
@@ -33578,9 +34465,24 @@ async function main() {
   const previewServer = new PreviewServer(previewSessionManager);
   const previewPort = config.node.port + 1;
   const actualPreviewPort = await previewServer.start(previewPort);
+  let dashboardTransport = null;
+  let dashboardOrigin;
   let previewTransport = null;
   let previewOrigin;
   let deps;
+  function createDashboardTransportConfig() {
+    return {
+      type: "devtunnel",
+      devtunnel: {
+        id: resolveOrCreateDevTunnelId(
+          config.storage.path,
+          meshyNode.getNodeRegistry().getSelf().id,
+          "dashboard"
+        ),
+        allowAnonymous: false
+      }
+    };
+  }
   function createPreviewTransportConfig() {
     return {
       type: "devtunnel",
@@ -33594,11 +34496,92 @@ async function main() {
       }
     };
   }
+  function setAdvertisedDashboardOrigin(origin) {
+    dashboardOrigin = origin;
+    deps.dashboardOrigin = origin;
+    meshyNode.getNodeRegistry().updateDashboardOrigin(meshyNode.getNodeRegistry().getSelf().id, origin);
+  }
   function setAdvertisedPreviewOrigin(origin) {
     previewOrigin = origin;
     deps.previewOrigin = origin;
     meshyNode.getNodeRegistry().updatePreviewOrigin(meshyNode.getNodeRegistry().getSelf().id, origin);
   }
+  function shouldPublishDashboardTunnel() {
+    return authMetadata.enabled && (meshyNode.getTransportType() === "devtunnel" || meshyNode.isDevTunnelEnabled());
+  }
+  async function stopDashboardTransport() {
+    if (!dashboardTransport) {
+      if (dashboardOrigin) {
+        setAdvertisedDashboardOrigin(void 0);
+      }
+      return;
+    }
+    await dashboardTransport.stop().catch(() => void 0);
+    dashboardTransport = null;
+    setAdvertisedDashboardOrigin(void 0);
+    meshyNode.getLogger().info("stopped dashboard tunnel", {
+      reason: "dashboard transport no longer required",
+      mainTransportType: meshyNode.getTransportType(),
+      sidecarEnabled: meshyNode.isDevTunnelEnabled()
+    });
+  }
+  async function restartDashboardTransport(transportConfig) {
+    const previousTransport = dashboardTransport;
+    const previousOrigin = dashboardOrigin;
+    let nextTransport = null;
+    try {
+      nextTransport = createTransport(transportConfig);
+      await nextTransport.start(config.node.port);
+      const nextOrigin = await nextTransport.getEndpoint();
+      dashboardTransport = nextTransport;
+      setAdvertisedDashboardOrigin(nextOrigin);
+      meshyNode.getLogger().info("started dashboard tunnel", {
+        dashboardOrigin: nextOrigin,
+        mainTransportType: meshyNode.getTransportType(),
+        sidecarEnabled: meshyNode.isDevTunnelEnabled()
+      });
+      if (previousTransport) {
+        await previousTransport.stop().catch(() => void 0);
+      }
+    } catch (err) {
+      if (nextTransport) {
+        await nextTransport.stop().catch(() => void 0);
+      }
+      dashboardTransport = previousTransport;
+      setAdvertisedDashboardOrigin(previousOrigin);
+      meshyNode.getLogger().warn("failed to start dashboard transport", {
+        error: err instanceof Error ? err.message : String(err),
+        port: config.node.port,
+        transportType: transportConfig.type
+      });
+    }
+  }
+  async function syncDashboardTransport(reason) {
+    if (!authMetadata.enabled) {
+      await stopDashboardTransport();
+      return;
+    }
+    if (!shouldPublishDashboardTunnel()) {
+      meshyNode.getLogger().info("skipping dashboard tunnel", {
+        reason,
+        mainTransportType: meshyNode.getTransportType(),
+        sidecarEnabled: meshyNode.isDevTunnelEnabled(),
+        authEnabled: authMetadata.enabled
+      });
+      await stopDashboardTransport();
+      return;
+    }
+    if (dashboardTransport && await dashboardTransport.isHealthy().catch(() => false)) {
+      meshyNode.getLogger().debug("dashboard tunnel already active", {
+        reason,
+        dashboardOrigin,
+        mainTransportType: meshyNode.getTransportType(),
+        sidecarEnabled: meshyNode.isDevTunnelEnabled()
+      });
+      return;
+    }
+    await restartDashboardTransport(createDashboardTransportConfig());
+  }
   async function restartPreviewTransport(transportConfig) {
     const previousTransport = previewTransport;
     const previousOrigin = previewOrigin;
@@ -33634,16 +34617,42 @@ async function main() {
     eventBus: meshyNode.getEventBus(),
     engineRegistry: meshyNode.getEngineRegistry(),
     logger: meshyNode.getLogger(),
-    config: { apiKey: config.cluster.apiKey },
+    config: {
+      apiKey: config.cluster.apiKey,
+      authMetadata,
+      validateBearerToken: authMetadata.enabled ? (header) => nodeAuth.validateAuthorizationHeader(header) : void 0
+    },
     workDir: meshyNode.getWorkDir(),
     persistNodeNamePreference: (name) => persistDefaultNodeName(config.storage.path, name),
+    joinCurrentNodeToCluster: async (leaderEndpoint) => {
+      await meshyNode.joinCluster(leaderEndpoint);
+    },
+    leaveCurrentCluster: async () => {
+      await meshyNode.leaveCluster();
+    },
     switchTransport: async (type) => {
-      return meshyNode.switchTransport(type);
+      const endpoint = await meshyNode.switchTransport(type);
+      persistNodeStartupTransport(config.storage.path, type);
+      await syncDashboardTransport(`switchTransport:${type}`);
+      return endpoint;
     },
     getTransportType: () => meshyNode.getTransportType(),
-    enableDevTunnel: async () => meshyNode.enableDevTunnel(),
-    disableDevTunnel: async () => meshyNode.disableDevTunnel(),
+    enableDevTunnel: async () => {
+      const endpoint = await meshyNode.enableDevTunnel();
+      persistNodeStartupTransport(config.storage.path, "devtunnel");
+      await syncDashboardTransport("enableDevTunnel");
+      return endpoint;
+    },
+    disableDevTunnel: async () => {
+      await meshyNode.disableDevTunnel();
+      persistNodeStartupTransport(
+        config.storage.path,
+        meshyNode.getTransportType()
+      );
+      await syncDashboardTransport("disableDevTunnel");
+    },
     isDevTunnelEnabled: () => meshyNode.isDevTunnelEnabled(),
+    dashboardOrigin,
     ensurePreviewOrigin: async () => {
       if (previewTransport && !await previewTransport.isHealthy()) {
         await previewTransport.stop().catch(() => void 0);
@@ -33659,7 +34668,16 @@ async function main() {
   };
   deps.previewSessionManager = previewSessionManager;
   deps.previewPort = actualPreviewPort;
+  deps.dashboardOrigin = dashboardOrigin;
   deps.previewOrigin = previewOrigin;
+  meshyNode.getLogger().info("configured node auth mode", {
+    authEnabled: authMetadata.enabled,
+    allowSameTenant: authMetadata.allowSameTenant,
+    allowedUsersCount: authMetadata.allowedUsers.length,
+    mainTransportType: meshyNode.getTransportType(),
+    sidecarEnabled: meshyNode.isDevTunnelEnabled()
+  });
+  await syncDashboardTransport("startup");
   const previewHealthTimer = setInterval(() => {
     void (async () => {
       if (!previewTransport) return;
@@ -33673,6 +34691,19 @@ async function main() {
       });
     })();
   }, config.cluster.heartbeatInterval);
+  const dashboardHealthTimer = setInterval(() => {
+    void (async () => {
+      if (!dashboardTransport) return;
+      const healthy = await dashboardTransport.isHealthy().catch(() => false);
+      if (healthy) return;
+      await dashboardTransport.stop().catch(() => void 0);
+      dashboardTransport = null;
+      setAdvertisedDashboardOrigin(void 0);
+      meshyNode.getLogger().warn("dashboard transport became unhealthy and was cleared", {
+        port: config.node.port
+      });
+    })();
+  }, config.cluster.heartbeatInterval);
   const app = createServer2(deps);
   const server = app.listen(config.node.port, () => {
     const self = meshyNode.getNodeRegistry().getSelf();
@@ -33683,7 +34714,8 @@ async function main() {
       role,
       term,
       endpoint: self.endpoint,
-      port: config.node.port
+      port: config.node.port,
+      dashboardOrigin
     });
     console.log("");
     console.log(banner);
@@ -33695,7 +34727,11 @@ async function main() {
     shuttingDown = true;
     console.log("\nShutting down...");
     try {
+      clearInterval(dashboardHealthTimer);
       clearInterval(previewHealthTimer);
+      if (dashboardTransport) {
+        await dashboardTransport.stop();
+      }
       if (previewTransport) {
         await previewTransport.stop();
       }
@@ -33724,9 +34760,11 @@ if (isDirectRun) {
   DEFAULT_CONFIG,
   DEFAULT_NODE_NAME,
   DEFAULT_NODE_PORT,
+  applyStartMetadata,
   createDefaultConfig,
   createRuntimeDefaultConfig,
   formatBanner,
+  formatLoadedStartMetadata,
   getDefaultNodeName,
   isDirectRunPath,
   loadConfigFile,
@@ -33734,6 +34772,8 @@ if (isDirectRun) {
   mergeConfig,
   parseArgs,
   promptStartOptions,
+  resolveRuntimeAuthMetadata,
+  shouldCollectStartOptions,
   shouldPromptForStartOptions
 });
 /*! Bundled license information: