meshy-node 0.4.4 → 0.4.5

package/main.cjs

@@ -6629,8 +6629,8 @@ var require_node2 = __commonJS({
           }
           break;
         case "FILE":
-          var fs22 = require("fs");
-          stream2 = new fs22.SyncWriteStream(fd2, { autoClose: false });
+          var fs23 = require("fs");
+          stream2 = new fs23.SyncWriteStream(fd2, { autoClose: false });
           stream2._type = "fs";
           break;
         case "PIPE":
@@ -23749,8 +23749,8 @@ var require_view = __commonJS({
     "use strict";
     var debug = require_src2()("express:view");
     var path23 = require("path");
-    var fs22 = require("fs");
-    var dirname7 = path23.dirname;
+    var fs23 = require("fs");
+    var dirname8 = path23.dirname;
     var basename5 = path23.basename;
     var extname3 = path23.extname;
     var join17 = path23.join;
@@ -23789,7 +23789,7 @@ var require_view = __commonJS({
       for (var i = 0; i < roots.length && !path24; i++) {
         var root = roots[i];
         var loc = resolve15(root, name2);
-        var dir = dirname7(loc);
+        var dir = dirname8(loc);
         var file = basename5(loc);
         path24 = this.resolve(dir, file);
       }
@@ -23815,7 +23815,7 @@ var require_view = __commonJS({
     function tryStat(path24) {
       debug('stat "%s"', path24);
       try {
-        return fs22.statSync(path24);
+        return fs23.statSync(path24);
       } catch (e) {
         return void 0;
       }
@@ -24113,7 +24113,7 @@ var require_mime = __commonJS({
   "../../node_modules/.pnpm/mime@1.6.0/node_modules/mime/mime.js"(exports2, module2) {
     "use strict";
     var path23 = require("path");
-    var fs22 = require("fs");
+    var fs23 = require("fs");
     function Mime() {
       this.types = /* @__PURE__ */ Object.create(null);
       this.extensions = /* @__PURE__ */ Object.create(null);
@@ -24134,7 +24134,7 @@ var require_mime = __commonJS({
     };
     Mime.prototype.load = function(file) {
       this._loading = file;
-      var map = {}, content = fs22.readFileSync(file, "ascii"), lines = content.split(/[\r\n]+/);
+      var map = {}, content = fs23.readFileSync(file, "ascii"), lines = content.split(/[\r\n]+/);
       lines.forEach(function(line) {
         var fields = line.replace(/\s*#.*|^\s*|\s*$/g, "").split(/\s+/);
         map[fields.shift()] = fields;
@@ -24256,7 +24256,7 @@ var require_send = __commonJS({
     var escapeHtml2 = require_escape_html();
     var etag = require_etag();
     var fresh = require_fresh();
-    var fs22 = require("fs");
+    var fs23 = require("fs");
     var mime = require_mime();
     var ms = require_ms();
     var onFinished = require_on_finished();
@@ -24589,7 +24589,7 @@ var require_send = __commonJS({
       var i = 0;
       var self2 = this;
       debug('stat "%s"', path24);
-      fs22.stat(path24, function onstat(err, stat) {
+      fs23.stat(path24, function onstat(err, stat) {
         if (err && err.code === "ENOENT" && !extname3(path24) && path24[path24.length - 1] !== sep4) {
           return next(err);
         }
@@ -24604,7 +24604,7 @@ var require_send = __commonJS({
         }
         var p = path24 + "." + self2._extensions[i++];
         debug('stat "%s"', p);
-        fs22.stat(p, function(err2, stat) {
+        fs23.stat(p, function(err2, stat) {
           if (err2) return next(err2);
           if (stat.isDirectory()) return next();
           self2.emit("file", p, stat);
@@ -24622,7 +24622,7 @@ var require_send = __commonJS({
         }
         var p = join17(path24, self2._index[i]);
         debug('stat "%s"', p);
-        fs22.stat(p, function(err2, stat) {
+        fs23.stat(p, function(err2, stat) {
           if (err2) return next(err2);
           if (stat.isDirectory()) return next();
           self2.emit("file", p, stat);
@@ -24634,7 +24634,7 @@ var require_send = __commonJS({
     SendStream.prototype.stream = function stream(path24, options) {
       var self2 = this;
       var res = this.res;
-      var stream2 = fs22.createReadStream(path24, options);
+      var stream2 = fs23.createReadStream(path24, options);
       this.emit("stream", stream2);
       stream2.pipe(res);
       function cleanup() {
@@ -31894,11 +31894,11 @@ var processUtils = {
 // ../../node_modules/.pnpm/@azure+identity@4.13.1/node_modules/@azure/identity/dist/esm/credentials/azurePowerShellCredential.js
 var logger18 = credentialLogger("AzurePowerShellCredential");
 var isWindows = process.platform === "win32";
-function formatCommand(commandName) {
+function formatCommand(commandName2) {
   if (isWindows) {
-    return `${commandName}.exe`;
+    return `${commandName2}.exe`;
   } else {
-    return commandName;
+    return commandName2;
   }
 }
 async function runCommands(commands, timeout) {
@@ -37934,7 +37934,7 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
     this.election.stop();
     try {
       const leaderEndpoint = this.nodeRegistry.getLeaderEndpoint();
-      if (leaderEndpoint) {
+      if (leaderEndpoint && !this.nodeRegistry.isLeader()) {
         this.logger.info("sending shutdown cluster leave request", {
           leaderEndpoint,
           nodeId: this.selfInfo.id
@@ -38835,7 +38835,7 @@ function isDirectRunPath(entryPath) {
 }
 
 // src/bootstrap/start-node.ts
-var nodePath2 = __toESM(require("path"), 1);
+var nodePath3 = __toESM(require("path"), 1);
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -42951,6 +42951,15 @@ var SystemAgentInfoSchema = external_exports.object({
     detail: external_exports.string().nullable().optional()
   }).optional()
 });
+var SystemRuntimeUpdateInfoSchema = external_exports.object({
+  packageName: external_exports.string(),
+  currentVersion: external_exports.string().nullable(),
+  latestVersion: external_exports.string().nullable(),
+  updateAvailable: external_exports.boolean(),
+  checkedAt: external_exports.string(),
+  restartMode: external_exports.enum(["package", "development"]),
+  detail: external_exports.string().nullable().optional()
+});
 var NodeSettingsSnapshotSchema = external_exports.object({
   collectedAt: external_exports.number(),
   version: external_exports.string(),
@@ -42959,6 +42968,7 @@ var NodeSettingsSnapshotSchema = external_exports.object({
   auth: SystemAuthInfoSchema.optional(),
   os: SystemOsInfoSchema.optional(),
   runtime: SystemRuntimeInfoSchema.optional(),
+  runtimeUpdate: SystemRuntimeUpdateInfoSchema.optional(),
   agents: external_exports.array(SystemAgentInfoSchema).optional(),
   startupRequirements: external_exports.object({
     lastCheckedAt: external_exports.string().optional(),
@@ -44755,6 +44765,7 @@ function buildNodeSettingsSnapshot(options) {
       storagePath: options.storagePath ?? null,
       localDashboardOrigin: options.localDashboardOrigin ?? null
     },
+    runtimeUpdate: options.runtimeUpdate,
     agents,
     startupRequirements: {
       lastCheckedAt: runtimeMetadata?.startupRequirementsLastCheckedAt,
@@ -44840,6 +44851,7 @@ function upgradeRuntimeAgentForDeps(deps, agent) {
 
 // ../../packages/api/src/node/node-operation-service.ts
 var LEADER_REPORT_RETRY_MS = 5e3;
+var OPERATION_COMMIT_EFFECT = /* @__PURE__ */ Symbol("operationCommitEffect");
 var NodeOperationFailure = class extends Error {
   constructor(message, result) {
     super(message);
@@ -44873,6 +44885,7 @@ var NodeOperationService = class {
     this.deps = deps;
     this.store = store;
     this.registerHandler("agent.upgrade", runAgentUpgradeOperation);
+    this.registerHandler("runtime.restart", runRuntimeRestartOperation);
     this.registerHandler("workdir.branch-create", runWorkDirBranchCreateOperation);
   }
   handlers = /* @__PURE__ */ new Map();
@@ -44943,8 +44956,14 @@ var NodeOperationService = class {
     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() });
+      const handled = readOperationCommitEffect(await handler(running, this.deps));
+      const saved = this.update(id, { status: "succeeded", result: handled.result, completedAt: Date.now() }, {
+        reportToLeader: handled.afterCommit ? false : true
+      });
+      if (handled.afterCommit) {
+        if (saved) await this.reportToLeader(saved);
+        await handled.afterCommit();
+      }
     } catch (err) {
       this.update(id, {
         status: "failed",
@@ -44954,12 +44973,12 @@ var NodeOperationService = class {
       });
     }
   }
-  update(id, updates) {
+  update(id, updates, options = {}) {
     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);
+    if (options.reportToLeader !== false) void this.reportToLeader(saved);
     return saved;
   }
   applyOperationSideEffects(operation) {
@@ -45040,6 +45059,23 @@ function runAgentUpgradeOperation(operation, deps) {
   }
   return result;
 }
+function runRuntimeRestartOperation(operation, deps) {
+  if (!deps.restartRuntime) throw new Error("Runtime restart is not available for this node");
+  const reason = readPayloadString(operation, "reason") === "update" ? "update" : "restart";
+  return deps.restartRuntime({ reason, deferShutdown: true }).then(
+    ({ completeShutdown, ...result }) => operationCommitEffect(result, completeShutdown)
+  );
+}
+function operationCommitEffect(result, afterCommit) {
+  return { [OPERATION_COMMIT_EFFECT]: true, result, afterCommit };
+}
+function readOperationCommitEffect(value) {
+  if (value && typeof value === "object" && value[OPERATION_COMMIT_EFFECT]) {
+    const effect = value;
+    return { result: effect.result, afterCommit: effect.afterCommit };
+  }
+  return { result: value };
+}
 function runWorkDirBranchCreateOperation(operation, deps) {
   const self2 = deps.nodeRegistry.getSelf();
   return createLocalNodeWorkDirBranch(
@@ -47125,6 +47161,37 @@ async function sendNodeAgentUpgrade(req, res, nodeId, agentParam) {
   res.status(202).json(operation);
 }
 
+// ../../packages/api/src/routes/node-runtime.ts
+function parseRestartReason(value) {
+  return value === "update" ? "update" : "restart";
+}
+async function sendNodeRuntimeRestart(req, res, nodeId) {
+  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 restart other nodes", 403);
+  }
+  const node = isSelf ? self2 : deps.nodeRegistry.getNode(nodeId);
+  if (!node) {
+    throw new MeshyError("NODE_NOT_FOUND", `Node ${nodeId} not found`, 404);
+  }
+  const reason = parseRestartReason(req.body?.reason);
+  const operations = getNodeOperationService(deps);
+  const operation = operations.create("runtime.restart", nodeId, { reason });
+  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 restart runtime`, 502);
+    }
+  }
+  res.status(202).json(operation);
+}
+
 // ../../packages/api/src/routes/node-terminal.ts
 var TERMINAL_SESSION_PROXY_TIMEOUT_MS = 1e4;
 function getTerminalSessionService2(deps) {
@@ -47548,6 +47615,9 @@ function createNodeRoutes() {
   router.post("/:id/agents/:agent/upgrade", asyncHandler3(async (req, res) => {
     await sendNodeAgentUpgrade(req, res, req.params.id, req.params.agent);
   }));
+  router.post("/:id/runtime/restart", asyncHandler3(async (req, res) => {
+    await sendNodeRuntimeRestart(req, res, req.params.id);
+  }));
   router.patch("/:id", asyncHandler3(async (req, res) => {
     const { nodeRegistry, persistNodeNamePreference } = req.app.locals.deps;
     const updates = UpdateNodeBody.parse(req.body);
@@ -49378,7 +49448,8 @@ function createSystemRoutes() {
       localDashboardOrigin,
       storagePath,
       inspectRuntimeTools: inspectTools,
-      runtimeMetadata
+      runtimeMetadata,
+      runtimeUpdate
     } = req.app.locals.deps;
     const self2 = nodeRegistry.getSelf();
     const auth = config.authMetadata ?? {
@@ -49391,6 +49462,7 @@ function createSystemRoutes() {
       inspectRuntimeTools: inspectTools,
       localDashboardOrigin,
       runtimeMetadata,
+      runtimeUpdate,
       storagePath,
       workDir: self2.workDir
     });
@@ -49406,6 +49478,7 @@ function createSystemRoutes() {
       auth: settingsSnapshot.auth,
       os: settingsSnapshot.os,
       runtime: settingsSnapshot.runtime,
+      runtimeUpdate: settingsSnapshot.runtimeUpdate,
       agents: settingsSnapshot.agents,
       startupRequirements: settingsSnapshot.startupRequirements,
       components: settingsSnapshot.components,
@@ -49413,6 +49486,24 @@ function createSystemRoutes() {
       packages: settingsSnapshot.packages
     });
   }));
+  router.post("/runtime/restart", asyncHandler9(async (req, res) => {
+    const { restartRuntime } = req.app.locals.deps;
+    if (!restartRuntime) {
+      throw new MeshyError("VALIDATION_ERROR", "Runtime restart is not available for this node", 501);
+    }
+    const body = req.body;
+    const reason = body.reason === "update" ? "update" : "restart";
+    const result = await restartRuntime({ reason });
+    res.status(202).json(result);
+  }));
+  router.post("/runtime/stop", asyncHandler9(async (req, res) => {
+    const { stopRuntime } = req.app.locals.deps;
+    if (!stopRuntime) {
+      throw new MeshyError("VALIDATION_ERROR", "Runtime stop is not available for this node", 501);
+    }
+    const result = await stopRuntime();
+    res.status(202).json(result);
+  }));
   router.post("/transport", asyncHandler9(async (req, res) => {
     const { switchTransport } = req.app.locals.deps;
     if (!switchTransport) {
@@ -50780,6 +50871,343 @@ function buildRuntimeMetadata(storagePath) {
   };
 }
 
+// src/bootstrap/runtime-restart.ts
+var fs22 = __toESM(require("fs"), 1);
+var nodePath2 = __toESM(require("path"), 1);
+var import_node_child_process14 = require("child_process");
+var runtimeUpdateCache = /* @__PURE__ */ new Map();
+var RESTARTER_SOURCE = String.raw`
+const { spawn } = require('node:child_process');
+const http = require('node:http');
+
+const plan = JSON.parse(process.env.MESHY_RESTART_PLAN || '{}');
+const parentPid = Number(process.env.MESHY_RESTART_PARENT_PID || '0');
+
+function log(message) {
+  process.stdout.write('[' + new Date().toISOString() + '] ' + message + '\n');
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function isProcessAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function requestHealth(url) {
+  return new Promise(resolve => {
+    const req = http.get(url, res => {
+      res.resume();
+      res.on('end', () => resolve(res.statusCode >= 200 && res.statusCode < 500));
+    });
+    req.setTimeout(1000, () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.on('error', () => resolve(false));
+  });
+}
+
+async function waitForParentExit() {
+  const deadline = Date.now() + 30000;
+  while (isProcessAlive(parentPid) && Date.now() < deadline) {
+    await sleep(250);
+  }
+}
+
+async function waitForEndpointDown() {
+  if (!plan.healthUrl) return;
+  const deadline = Date.now() + 30000;
+  while (Date.now() < deadline) {
+    if (!await requestHealth(plan.healthUrl)) return;
+    await sleep(250);
+  }
+}
+
+(async () => {
+  log('waiting to restart ' + (plan.displayCommand || plan.command));
+  await waitForParentExit();
+  await waitForEndpointDown();
+  log('starting ' + (plan.displayCommand || plan.command));
+  const child = spawn(plan.command, plan.args || [], {
+    cwd: plan.cwd,
+    env: { ...process.env, ...(plan.env || {}), MESHY_RESTART_CHILD: '1' },
+    detached: true,
+    stdio: ['ignore', 'inherit', 'inherit'],
+    windowsHide: true,
+  });
+  child.on('error', error => {
+    log('failed to launch restart command: ' + (error && error.message ? error.message : String(error)));
+    process.exitCode = 1;
+  });
+  child.unref();
+  await sleep(500);
+})().catch(error => {
+  log('restart helper failed: ' + (error && error.message ? error.message : String(error)));
+  process.exit(1);
+});
+`;
+function formatLocalDate3(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 normalizeOutput2(output) {
+  if (!output) return null;
+  const firstLine = output.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+  return firstLine ?? null;
+}
+function normalizePackageVersion2(output) {
+  const normalized = normalizeOutput2(output);
+  if (!normalized) return null;
+  try {
+    const parsed = JSON.parse(normalized);
+    return typeof parsed === "string" ? parsed.trim() || null : normalized;
+  } catch {
+    return normalized;
+  }
+}
+function compareSemver2(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 0;
+}
+function runRuntimePackageCommand(command, args) {
+  const result = (0, import_node_child_process14.spawnSync)(command, args, {
+    encoding: "utf-8",
+    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 commandName(base, platform2) {
+  return platform2 === "win32" ? `${base}.cmd` : base;
+}
+function pathForPlatform(platform2) {
+  return platform2 === "win32" ? nodePath2.win32 : nodePath2;
+}
+function resolveDevelopmentRepoRoot(cwd, env, platform2) {
+  if (env.MESHY_STORAGE_BASE_DIR) return env.MESHY_STORAGE_BASE_DIR;
+  const pathApi = pathForPlatform(platform2);
+  const packageDir = pathApi.basename(cwd);
+  const packageParent = pathApi.basename(pathApi.dirname(cwd));
+  return packageDir === "node" && packageParent === "apps" ? pathApi.dirname(pathApi.dirname(cwd)) : cwd;
+}
+function windowsShellQuote(value) {
+  return /[\s&()^|<>"]/.test(value) ? `"${value.replace(/"/g, '\\"')}"` : value;
+}
+function createSpawnableCommand(command, args, platform2) {
+  const displayCommand = [command, ...args].map(shellQuote).join(" ");
+  if (platform2 !== "win32") return { command, args, displayCommand };
+  return {
+    command: "cmd.exe",
+    args: ["/d", "/s", "/c", [command, ...args].map(windowsShellQuote).join(" ")],
+    displayCommand
+  };
+}
+function readProcessCommand(pid, platform2) {
+  if (platform2 === "win32") return null;
+  const result = (0, import_node_child_process14.spawnSync)("ps", ["-p", String(pid), "-o", "args="], {
+    encoding: "utf-8",
+    windowsHide: true,
+    timeout: 1e3
+  });
+  return result.status === 0 && typeof result.stdout === "string" ? result.stdout.trim() || null : null;
+}
+function isNodeWatchCommand(command) {
+  return /(?:^|[/\\])node(?:\.exe)?(?:\s|$)/.test(command) && /(?:^|\s)--watch(?:=|\s|$)/.test(command);
+}
+function terminateRuntimeWatchParent(options) {
+  if (options.mode !== "development") return { terminated: false, reason: "not-development" };
+  const parentPid = options.parentPid ?? process.ppid;
+  if (!Number.isInteger(parentPid) || parentPid <= 1 || parentPid === process.pid) {
+    return { terminated: false, reason: "invalid-parent" };
+  }
+  const commandReader = options.commandReader ?? ((pid) => readProcessCommand(pid, options.platform ?? process.platform));
+  const parentCommand = commandReader(parentPid);
+  const parentIsWatch = parentCommand !== null ? isNodeWatchCommand(parentCommand) : options.env?.WATCH_REPORT_DEPENDENCIES === "1";
+  if (!parentIsWatch) return { terminated: false, reason: "parent-not-watch" };
+  try {
+    const kill = options.kill ?? process.kill;
+    kill(parentPid, "SIGINT");
+    return { terminated: true, pid: parentPid };
+  } catch {
+    return { terminated: false, reason: "kill-failed" };
+  }
+}
+function compactEnv(env) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === "string") result[key] = value;
+  }
+  return result;
+}
+function shellQuote(value) {
+  return /\s/.test(value) ? JSON.stringify(value) : value;
+}
+function formatStartArgs(args) {
+  const result = ["start"];
+  if (args.port !== void 0) result.push("--port", String(args.port));
+  if (args.name) result.push("--name", args.name);
+  if (args.join) result.push("--join", args.join);
+  if (args.transport) result.push("--transport", args.transport);
+  if (args.workDir) result.push("--work-dir", args.workDir);
+  if (args.config) result.push("--config", args.config);
+  if (args.disableAuth) result.push("--disable-auth");
+  return result;
+}
+function detectRuntimeRestartMode(env = process.env, entryPath = process.argv[1]) {
+  if (env.MESHY_RESTART_MODE === "package" || env.MESHY_RESTART_MODE === "development") {
+    return env.MESHY_RESTART_MODE;
+  }
+  if (env.MESHY_STORAGE_MODE === "cwd" && env.MESHY_STORAGE_BASE_DIR) {
+    return "development";
+  }
+  return typeof entryPath === "string" && /src[/\\]main\.ts$/.test(entryPath) ? "development" : "package";
+}
+function createRuntimeRestartLaunchPlan(options) {
+  const platform2 = options.platform ?? process.platform;
+  const startArgs = formatStartArgs(options.startArgs);
+  const env = compactEnv(options.env);
+  const logPath = pathForPlatform(platform2).join(options.storagePath, "logs", "restart.log");
+  const healthUrl = new URL("/api/system/health", options.localDashboardOrigin).toString();
+  if (options.mode === "development") {
+    const repoRoot2 = resolveDevelopmentRepoRoot(options.cwd, options.env, platform2);
+    const launch2 = createSpawnableCommand(commandName("pnpm", platform2), ["dev:node", "--", ...startArgs], platform2);
+    return {
+      mode: "development",
+      command: launch2.command,
+      args: launch2.args,
+      cwd: repoRoot2,
+      env,
+      displayCommand: launch2.displayCommand,
+      logPath,
+      healthUrl
+    };
+  }
+  const launch = createSpawnableCommand(commandName("npx", platform2), ["-y", "meshy-node@latest", ...startArgs], platform2);
+  return {
+    mode: "package",
+    command: launch.command,
+    args: launch.args,
+    cwd: options.cwd,
+    env,
+    displayCommand: launch.displayCommand,
+    logPath,
+    healthUrl
+  };
+}
+function scheduleRuntimeRestart(plan, options = {}) {
+  fs22.mkdirSync(nodePath2.dirname(plan.logPath), { recursive: true });
+  const logFd = fs22.openSync(plan.logPath, "a");
+  const spawnImpl = options.spawnImpl ?? import_node_child_process14.spawn;
+  const env = {
+    ...process.env,
+    MESHY_RESTART_PARENT_PID: String(options.parentPid ?? process.pid),
+    MESHY_RESTART_PLAN: JSON.stringify(plan)
+  };
+  const child = spawnImpl(process.execPath, ["-e", RESTARTER_SOURCE], {
+    detached: true,
+    env,
+    stdio: ["ignore", logFd, logFd],
+    windowsHide: true
+  });
+  child.unref();
+}
+function createRuntimeUpdateSnapshot(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const checkedAt = now.toISOString();
+  const currentVersion = options.runtimeMetadata?.packageVersion ?? null;
+  const packageName = "meshy-node";
+  if (options.mode === "development") {
+    return {
+      packageName,
+      currentVersion,
+      latestVersion: null,
+      updateAvailable: false,
+      checkedAt,
+      restartMode: "development",
+      detail: "Development runtime restarts from the local workspace."
+    };
+  }
+  const cache = options.updateCache ?? runtimeUpdateCache;
+  const checkedOn = formatLocalDate3(now);
+  const cached = cache.get(packageName);
+  let latestVersion = cached?.latestVersion ?? null;
+  let detail = cached?.detail ?? null;
+  let updateCheckedAt = cached?.checkedAt ?? checkedAt;
+  if (cached?.checkedOn !== checkedOn) {
+    const runner = options.commandRunner ?? runRuntimePackageCommand;
+    const result = runner("npm", ["view", `${packageName}@latest`, "version", "--json"]);
+    latestVersion = result.status === 0 ? normalizePackageVersion2(result.stdout) : null;
+    detail = result.status === 0 ? null : normalizeOutput2(result.stderr) ?? result.error ?? "Runtime update check failed";
+    updateCheckedAt = checkedAt;
+    cache.set(packageName, { checkedOn, checkedAt, latestVersion, detail });
+  }
+  return {
+    packageName,
+    currentVersion,
+    latestVersion,
+    updateAvailable: Boolean(currentVersion && latestVersion && compareSemver2(latestVersion, currentVersion) > 0),
+    checkedAt: updateCheckedAt,
+    restartMode: "package",
+    detail
+  };
+}
+
+// src/bootstrap/settings-snapshot.ts
+function createSettingsSnapshotProvider(options) {
+  let cachedSnapshot = null;
+  let cachedSnapshotAt = 0;
+  function buildSnapshot() {
+    cachedSnapshot = buildNodeSettingsSnapshot({
+      auth: options.authMetadata,
+      localDashboardOrigin: options.localDashboardOrigin,
+      runtimeMetadata: options.runtimeMetadata,
+      runtimeUpdate: createRuntimeUpdateSnapshot({
+        mode: options.runtimeRestartMode,
+        runtimeMetadata: options.runtimeMetadata
+      }),
+      storagePath: options.storagePath,
+      workDir: options.workDir
+    });
+    cachedSnapshotAt = Date.now();
+    return structuredClone(cachedSnapshot);
+  }
+  function getSettingsSnapshot() {
+    const now = Date.now();
+    if (cachedSnapshot && now - cachedSnapshotAt < 3e4) {
+      return structuredClone(cachedSnapshot);
+    }
+    return buildSnapshot();
+  }
+  return {
+    getSettingsSnapshot,
+    refreshSettingsSnapshot: () => {
+      cachedSnapshot = null;
+      cachedSnapshotAt = 0;
+      return buildSnapshot();
+    }
+  };
+}
+
 // src/bootstrap/tunnel-health.ts
 var DEFAULT_TUNNEL_REACHABILITY_INTERVAL_MS = 6e4;
 var DEFAULT_TUNNEL_REACHABILITY_TIMEOUT_MS = 5e3;
@@ -50857,36 +51285,6 @@ async function fetchWithTimeout2(fetchImpl, url, timeoutMs) {
 }
 
 // src/bootstrap/start-node.ts
-function createSettingsSnapshotProvider(options) {
-  let cachedSnapshot = null;
-  let cachedSnapshotAt = 0;
-  function buildSnapshot() {
-    cachedSnapshot = buildNodeSettingsSnapshot({
-      auth: options.authMetadata,
-      localDashboardOrigin: options.localDashboardOrigin,
-      runtimeMetadata: options.runtimeMetadata,
-      storagePath: options.storagePath,
-      workDir: options.workDir
-    });
-    cachedSnapshotAt = Date.now();
-    return structuredClone(cachedSnapshot);
-  }
-  function getSettingsSnapshot() {
-    const now = Date.now();
-    if (cachedSnapshot && now - cachedSnapshotAt < 3e4) {
-      return structuredClone(cachedSnapshot);
-    }
-    return buildSnapshot();
-  }
-  return {
-    getSettingsSnapshot,
-    refreshSettingsSnapshot: () => {
-      cachedSnapshot = null;
-      cachedSnapshotAt = 0;
-      return buildSnapshot();
-    }
-  };
-}
 async function resolveStartConfig(args) {
   const configPath = args.config ?? "./config.json";
   const fileConfig = loadConfigFile(configPath);
@@ -50916,7 +51314,7 @@ async function resolveStartConfig(args) {
     ignorePersistedName: args.reset === true
   });
   const config = mergeConfig(defaults, scopedFileConfig, resolvedArgs);
-  setStartupFatalLogPath(nodePath2.join(config.storage.path, "logs", "startup-fatal.log"));
+  setStartupFatalLogPath(nodePath3.join(config.storage.path, "logs", "startup-fatal.log"));
   persistDefaultNodeName(storageRoot, config.node.name);
   persistDefaultNodeName(config.storage.path, config.node.name);
   persistNodeStartupMetadata(config.storage.path, {
@@ -51271,15 +51669,20 @@ function createTunnelManager(options) {
 }
 function registerShutdownHandlers(options) {
   let shuttingDown = false;
-  async function shutdown() {
+  function stopDevelopmentWatchParent(runtimeMode) {
+    if (runtimeMode) terminateRuntimeWatchParent({ mode: runtimeMode, env: process.env });
+  }
+  async function shutdown(reason = "shutdown", runtimeMode) {
     if (shuttingDown) {
       terminalWriter.line("Force exit.");
+      stopDevelopmentWatchParent(runtimeMode);
       process.exit(130);
     }
     shuttingDown = true;
-    terminalWriter.line("\nShutting down...");
+    terminalWriter.line(reason === "restart" ? "\nRestarting..." : "\nShutting down...");
     const forceExitTimer = setTimeout(() => {
       terminalWriter.line("Force exit.");
+      stopDevelopmentWatchParent(runtimeMode);
       process.exit(0);
     }, 1e4);
     forceExitTimer.unref?.();
@@ -51289,15 +51692,21 @@ function registerShutdownHandlers(options) {
       await options.tunnelManager.stop();
       await options.meshyNode.stop();
       clearTimeout(forceExitTimer);
-      terminalWriter.line("Goodbye!");
+      terminalWriter.line(reason === "restart" ? "Restart handoff complete." : "Goodbye!");
+      stopDevelopmentWatchParent(runtimeMode);
       process.exit(0);
     } catch (err) {
       terminalWriter.error("Error during shutdown:", err);
       process.exit(1);
     }
   }
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", () => void shutdown("shutdown"));
+  process.on("SIGTERM", () => void shutdown("shutdown"));
+  return {
+    requestShutdown: (reason = "shutdown", runtimeMode) => {
+      void shutdown(reason, runtimeMode);
+    }
+  };
 }
 async function startNode(args) {
   const { authMetadata, config, hydratedArgs, runtimeMetadata, storageRoot } = await resolveStartConfig(args);
@@ -51309,7 +51718,7 @@ async function startNode(args) {
   const localDashboardOrigin = `http://localhost:${config.node.port}`;
   const logger27 = createLogger({
     component: "node",
-    logDir: nodePath2.join(config.storage.path, "logs"),
+    logDir: nodePath3.join(config.storage.path, "logs"),
     console: true
   });
   const nodeAuth = new AzureCliNodeAuth(config.storage.path, {
@@ -51331,8 +51740,9 @@ async function startNode(args) {
     authMetadata,
     localDashboardOrigin,
     runtimeMetadata,
+    runtimeRestartMode: detectRuntimeRestartMode(),
     storagePath: config.storage.path,
-    workDir: nodePath2.resolve(config.node.workDir ?? process.cwd())
+    workDir: nodePath3.resolve(config.node.workDir ?? process.cwd())
   });
   const { getSettingsSnapshot, refreshSettingsSnapshot } = settingsSnapshotProvider;
   const meshyNode = new MeshyNode(config, {
@@ -51348,6 +51758,7 @@ async function startNode(args) {
   const previewSessionManager = new PreviewSessionManager();
   const previewProxyManager = new PreviewProxyManager();
   let deps;
+  let requestShutdownForRestart;
   const tunnelManager = createTunnelManager({
     authMetadata,
     config,
@@ -51424,7 +51835,39 @@ async function startNode(args) {
     isDevTunnelEnabled: () => meshyNode.isDevTunnelEnabled(),
     localDashboardOrigin,
     upgradeRuntimeAgent,
+    restartRuntime: async (request) => {
+      const mode = detectRuntimeRestartMode();
+      const plan = createRuntimeRestartLaunchPlan({
+        mode,
+        cwd: process.cwd(),
+        env: process.env,
+        localDashboardOrigin,
+        startArgs: hydratedArgs.args,
+        storagePath: config.storage.path
+      });
+      scheduleRuntimeRestart(plan, { parentPid: process.pid });
+      const completeShutdown = () => setTimeout(() => requestShutdownForRestart?.("restart", mode), 250).unref?.();
+      if (!request.deferShutdown) completeShutdown();
+      return {
+        ok: true,
+        mode: plan.mode,
+        command: plan.displayCommand,
+        logPath: plan.logPath,
+        pid: process.pid,
+        completeShutdown
+      };
+    },
+    stopRuntime: async () => {
+      const pid = process.pid;
+      const mode = detectRuntimeRestartMode();
+      setTimeout(() => requestShutdownForRestart?.("shutdown", mode), 250).unref?.();
+      return { ok: true, pid };
+    },
     refreshSettingsSnapshot,
+    runtimeUpdate: createRuntimeUpdateSnapshot({
+      mode: detectRuntimeRestartMode(),
+      runtimeMetadata
+    }),
     dashboardOrigin: tunnelManager.getDashboardOrigin(),
     shareOrigin: tunnelManager.getShareOrigin(),
     ensureShareTunnel: () => tunnelManager.ensureShareTunnel(),
@@ -51456,11 +51899,12 @@ async function startNode(args) {
     terminalWriter.line(banner);
     terminalWriter.line("");
   });
-  registerShutdownHandlers({
+  const shutdownHandle = registerShutdownHandlers({
     server,
     meshyNode,
     tunnelManager
   });
+  requestShutdownForRestart = shutdownHandle.requestShutdown;
 }
 
 // src/main.ts