@co0ontty/wand 2.9.1 → 2.10.0

package/dist/server.js

@@ -25,7 +25,7 @@ import { checkPackageUpdateAsync, installPackageGloballyAsync, normalizeUpdateCh
 import { repairServiceUnitAfterUpdate } from "./service-self-repair.js";
 import { computeRelaunch } from "./relaunch.js";
 import { isServiceInstalled } from "./tui/commands.js";
-import { canUseDetachedUpdateHelper, startDetachedUpdateHelper } from "./update-helper.js";
+import { canUseDetachedUpdateHelper, checkManagedServiceUpdatePreflight, startDetachedUpdateHelper, } from "./update-helper.js";
 import { registerUploadRoutes } from "./upload-routes.js";
 import { optimizePrompt, PromptOptimizeError } from "./prompt-optimizer.js";
 import { resolveDatabasePath, WandStorage } from "./storage.js";
@@ -1884,9 +1884,6 @@ export async function startServer(config, configPath) {
                 version: targetLabel,
                 logPath: helper.logPath,
             });
-            setTimeout(() => {
-                shutdownForDetachedUpdate();
-            }, 500);
         }
         catch (error) {
             res.status(500).json({ error: getErrorMessage(error, "更新失败。") });
@@ -2467,18 +2464,6 @@ export async function startServer(config, configPath) {
         // Force exit after 5s if graceful shutdown stalls
         setTimeout(() => process.exit(0), 5000);
     }
-    function shutdownForDetachedUpdate() {
-        try {
-            wss.clients.forEach((client) => client.close());
-        }
-        catch {
-            /* noop */
-        }
-        server.close(() => {
-            process.exit(0);
-        });
-        setTimeout(() => process.exit(0), 3000);
-    }
     app.post("/api/restart", async (_req, res) => {
         res.json({ ok: true, message: "服务正在重启..." });
         wsManager.emitEvent({
@@ -2607,6 +2592,21 @@ export async function startServer(config, configPath) {
             });
             return;
         }
+        const servicePreflight = checkManagedServiceUpdatePreflight();
+        if (!servicePreflight.ok) {
+            process.stdout.write(`[wand] 自动更新已取消: ${servicePreflight.message}\n`);
+            wsManager.emitEvent({
+                type: "notification",
+                sessionId: "__system__",
+                data: {
+                    kind: "auto-update-failed",
+                    current: info.current,
+                    latest: info.latest,
+                    error: servicePreflight.message,
+                },
+            });
+            return;
+        }
         // Auto-update: install and restart
         process.stdout.write(`[wand] 自动更新：正在从 ${info.current} 更新到 ${info.latest}...\n`);
         wsManager.emitEvent({

package/dist/service-self-repair.d.ts

@@ -10,7 +10,7 @@ import { type ServiceScope } from "./tui/commands.js";
  *
  * 这里在装包成功后调用，best-effort：
  *   - 没装服务 → 跳过；
- *   - 装了服务 → 用 preferGlobalBin 重写 unit（ExecStart→全局 dist/cli.js，
+ *   - 装了服务 → 用 preferGlobalBin 重写 unit（ExecStart→全局稳定 wand shim，
  *     Environment=PATH 取当前已被 path-repair 修复过的 process.env.PATH）+ daemon-reload；
  *   - system scope 非 root 无法写 /etc → installService 返回失败，这里捕获成 warning，
  *     绝不抛错中断更新流程。

package/dist/service-self-repair.js

@@ -22,7 +22,7 @@ export function repairServiceUnitAfterUpdate(configPath) {
             return {
                 repaired: true,
                 scope,
-                message: `已用全局安装重写 ${scope} 服务 unit（刷新 ExecStart / PATH）`,
+                message: `已用全局稳定入口重写 ${scope} 服务 unit（刷新 ExecStart / PATH）`,
             };
         }
         const tail = scope === "system"

package/dist/tui/commands.d.ts

@@ -58,8 +58,8 @@ export interface ServiceContext {
     /** 显式指定作用域。不传走 DEFAULT_SERVICE_SCOPE。 */
     scope?: ServiceScope;
     /**
-     * 更新后自修复场景：优先把 ExecStart 钉到「全局安装的 wand」(npm root -g 下的
-     * dist/cli.js)，而不是 process.argv[1]。源码安装的用户更新到 npm/GitHub 版后，
+     * 更新后自修复场景：优先把 ExecStart 钉到 npm 全局 wand shim，而不是
+     * process.argv[1]。源码安装的用户更新到 npm/GitHub 版后，
      * argv[1] 仍是旧源码路径，沿用它会让重启跑回旧二进制。
      */
     preferGlobalBin?: boolean;

package/dist/tui/commands.js

@@ -10,7 +10,7 @@ import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import { checkPackageUpdateSync, getInstallSpecForChannel, installPackageGloballySync, normalizeUpdateChannel, resolveGlobalWandCli, } from "../npm-update-utils.js";
+import { checkPackageUpdateSync, getInstallSpecForChannel, installPackageGloballySync, normalizeUpdateChannel, resolveGlobalWandBin, resolveGlobalWandCli, } from "../npm-update-utils.js";
 import { whichSync } from "../path-repair.js";
 import { computeRelaunch } from "../relaunch.js";
 import { ensureDatabaseFile, resolveDatabasePath, WandStorage } from "../storage.js";
@@ -95,6 +95,9 @@ export function checkUpdate(currentVersion, channel = "stable") {
  * 返回 npm 输出供调试。
  */
 export function installUpdate(channel = "stable") {
+    const serviceSafety = checkInstalledServiceEntrypointsForUpdate();
+    if (!serviceSafety.ok)
+        return serviceSafety;
     const res = installPackageGloballySync(getInstallSpecForChannel(channel), 180_000);
     const out = (res.stdout || "") + (res.stderr ? "\n" + res.stderr : "");
     const trail = res.attempts.length > 1
@@ -537,12 +540,56 @@ function servicePathFor(scope) {
     }
     return "";
 }
+function readServiceEntrypointForUpdate(scope) {
+    const servicePath = servicePathFor(scope);
+    if (process.platform === "darwin") {
+        const result = spawnSync("plutil", ["-extract", "ProgramArguments.1", "raw", "-o", "-", servicePath], { encoding: "utf8", timeout: 5_000 });
+        return result.status === 0 ? (result.stdout || "").trim() || null : null;
+    }
+    if (process.platform === "linux") {
+        try {
+            const execStart = readFileSync(servicePath, "utf8").split("\n").find((line) => line.startsWith("ExecStart="));
+            if (!execStart)
+                return null;
+            return execStart.slice("ExecStart=".length).trim().split(/\s+/)[1] || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function checkInstalledServiceEntrypointsForUpdate() {
+    const scopes = ["system", "user"].filter((scope) => isServiceInstalled(scope));
+    if (scopes.length === 0)
+        return { ok: true, message: "未安装服务" };
+    const stableBin = resolveGlobalWandBin();
+    if (!stableBin) {
+        return { ok: false, message: "npm 全局 wand shim 不存在，已取消更新以保护当前服务。" };
+    }
+    for (const scope of scopes) {
+        const entrypoint = readServiceEntrypointForUpdate(scope);
+        if (!entrypoint || path.resolve(entrypoint) !== path.resolve(stableBin)) {
+            const command = scope === "system"
+                ? `sudo ${stableBin} service:install`
+                : `${stableBin} service:install --user`;
+            return {
+                ok: false,
+                message: `检测到 ${scope} 服务仍指向不稳定入口，已取消更新。请先运行: ${command}`,
+                detail: `entrypoint: ${entrypoint || "无法读取"}\nstable shim: ${stableBin}`,
+            };
+        }
+    }
+    return { ok: true, message: "服务入口预检通过" };
+}
 function resolveWandBin(ctx) {
-    // 更新后自修复：优先全局安装的 dist/cli.js，避免沿用旧源码路径。
+    // 更新后自修复：优先 npm 全局稳定 shim，避免沿用旧源码路径；不能钉死到包目录
+    // dist/cli.js，因为事务回滚切换 canonical 目录时 shim 才能指向同盘安全备份。
     if (ctx.preferGlobalBin) {
-        const global = resolveGlobalWandCli();
-        if (global)
-            return global;
+        const globalBin = resolveGlobalWandBin();
+        if (globalBin)
+            return globalBin;
+        throw new Error("npm 全局 wand shim 不存在，拒绝把服务 unit 写到不稳定的包目录路径。");
     }
     if (ctx.wandBin && existsSync(ctx.wandBin))
         return ctx.wandBin;

package/dist/update-helper.d.ts

@@ -1,3 +1,4 @@
+import { type ServiceScope } from "./tui/commands.js";
 export interface DetachedUpdateOptions {
     installSpec: string;
     configPath: string;
@@ -14,5 +15,18 @@ export interface DetachedUpdateResult {
     pid?: number;
     message: string;
 }
+/** A manifest alone is not enough: only a process actually launched by its manager may rely on auto-restart. */
+export declare function resolveManagedServiceScope(installedScope: ServiceScope | null, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv, pid?: number): ServiceScope | null;
+export declare function resolveManagedServiceScopeCandidates(installedScopes: ServiceScope[], platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv, pid?: number): ServiceScope | null;
+export declare function isStableServiceEntrypoint(entrypoint: string | null, stableBin: string | null): boolean;
+export declare function checkManagedServiceUpdatePreflight(): {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};
+export declare function shouldUseSystemdRunForDetachedUpdate(serviceScope: ServiceScope | null): boolean;
+/** Exported so the safety-critical update flow can be exercised without starting a detached process. */
+export declare function buildDetachedUpdateHelperScript(opts: DetachedUpdateOptions, logPath: string, serviceScope: ServiceScope | null, updateUtilsPath?: string): string;
 export declare function startDetachedUpdateHelper(opts: DetachedUpdateOptions): DetachedUpdateResult;
 export declare function canUseDetachedUpdateHelper(): boolean;

package/dist/update-helper.js

@@ -1,66 +1,172 @@
 import { spawn, spawnSync } from "node:child_process";
-import { chmodSync, existsSync, mkdtempSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
-import { detectInstalledScope } from "./tui/commands.js";
+import { fileURLToPath } from "node:url";
+import { resolveGlobalWandBin } from "./npm-update-utils.js";
 function shellQuote(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function shellArray(values) {
     return values.map((value) => shellQuote(value)).join(" ");
 }
-function boolShell(value) {
-    return value ? "1" : "0";
-}
 function resolveBashPath() {
     return existsSync("/bin/bash") ? "/bin/bash" : "bash";
 }
-function detectServiceScope() {
+function detectInstalledServiceScopes() {
+    if (process.platform === "darwin") {
+        return [
+            existsSync("/Library/LaunchDaemons/com.wand.web.plist") ? "system" : null,
+            existsSync(path.join(os.homedir(), "Library/LaunchAgents/com.wand.web.plist")) ? "user" : null,
+        ].filter((scope) => scope !== null);
+    }
+    if (process.platform === "linux") {
+        return [
+            existsSync("/etc/systemd/system/wand.service") ? "system" : null,
+            existsSync(path.join(os.homedir(), ".config/systemd/user/wand.service")) ? "user" : null,
+        ].filter((scope) => scope !== null);
+    }
+    return [];
+}
+/** A manifest alone is not enough: only a process actually launched by its manager may rely on auto-restart. */
+export function resolveManagedServiceScope(installedScope, platform = process.platform, env = process.env, pid = process.pid) {
+    if (platform === "darwin") {
+        return env.XPC_SERVICE_NAME === "com.wand.web" ? (installedScope ?? "system") : null;
+    }
+    if (platform === "linux") {
+        const hasSystemdPid = typeof env.SYSTEMD_EXEC_PID === "string" && env.SYSTEMD_EXEC_PID.length > 0;
+        const systemdPid = Number(env.SYSTEMD_EXEC_PID || "0");
+        const managed = hasSystemdPid
+            ? Number.isSafeInteger(systemdPid) && systemdPid === pid
+            : typeof env.INVOCATION_ID === "string" && env.INVOCATION_ID.length > 0;
+        return managed ? (installedScope ?? "system") : null;
+    }
+    return null;
+}
+export function resolveManagedServiceScopeCandidates(installedScopes, platform = process.platform, env = process.env, pid = process.pid) {
+    const installedScope = installedScopes.length === 1 ? installedScopes[0] : null;
+    const managedScope = resolveManagedServiceScope(installedScope, platform, env, pid);
+    if (managedScope && installedScopes.length > 1) {
+        throw new Error("同时检测到 system 与 user 两份 wand 服务，无法安全判断当前托管 scope；请先卸载其中一份。");
+    }
+    return managedScope;
+}
+function detectManagedServiceScope() {
+    return resolveManagedServiceScopeCandidates(detectInstalledServiceScopes());
+}
+export function isStableServiceEntrypoint(entrypoint, stableBin) {
+    if (!entrypoint || !stableBin)
+        return false;
     try {
-        return detectInstalledScope();
+        return path.resolve(entrypoint) === path.resolve(stableBin);
     }
     catch {
-        return null;
+        return false;
     }
 }
-function buildHelperScript(opts, logPath, serviceScope) {
-    const isSystemdManaged = !!process.env.INVOCATION_ID;
-    const isLaunchdManaged = !!process.env.LAUNCHD_SOCKET || !!process.env.XPC_SERVICE_NAME;
-    const shouldStartService = serviceScope !== null;
-    const shouldRestartStandalone = !shouldStartService;
-    const npmCache = opts.env.npm_config_cache || path.join(os.homedir(), ".npm");
-    const timeoutSec = Math.max(30, Math.ceil((opts.timeoutMs ?? 300_000) / 1000));
-    const cliArgArray = opts.cliArgs;
+function readManagedServiceEntrypoint(scope) {
+    if (process.platform === "darwin") {
+        const plist = scope === "system"
+            ? "/Library/LaunchDaemons/com.wand.web.plist"
+            : path.join(os.homedir(), "Library/LaunchAgents/com.wand.web.plist");
+        const result = spawnSync("plutil", ["-extract", "ProgramArguments.1", "raw", "-o", "-", plist], { encoding: "utf8", timeout: 5_000 });
+        return result.status === 0 ? (result.stdout || "").trim() || null : null;
+    }
+    if (process.platform === "linux") {
+        const unit = scope === "system"
+            ? "/etc/systemd/system/wand.service"
+            : path.join(os.homedir(), ".config/systemd/user/wand.service");
+        try {
+            const execStart = readFileSync(unit, "utf8").split("\n").find((line) => line.startsWith("ExecStart="));
+            if (!execStart)
+                return null;
+            const tokens = execStart.slice("ExecStart=".length).trim().split(/\s+/);
+            return tokens[1] || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function managedServiceUpdatePreflight(scope) {
+    const stableBin = resolveGlobalWandBin();
+    const entrypoint = readManagedServiceEntrypoint(scope);
+    if (isStableServiceEntrypoint(entrypoint, stableBin))
+        return { ok: true };
+    const command = scope === "system"
+        ? `sudo ${stableBin || "wand"} service:install -c <config-path>`
+        : `${stableBin || "wand"} service:install --user -c <config-path>`;
+    return {
+        ok: false,
+        message: `检测到 ${scope} 服务仍指向不稳定入口 (${entrypoint || "无法读取"})，已取消 Web 更新以保持服务在线。` +
+            `请先在终端重注册到全局 shim：${command}`,
+    };
+}
+export function checkManagedServiceUpdatePreflight() {
+    try {
+        const scope = detectManagedServiceScope();
+        return scope ? managedServiceUpdatePreflight(scope) : { ok: true };
+    }
+    catch (err) {
+        return { ok: false, message: err instanceof Error ? err.message : String(err) };
+    }
+}
+export function shouldUseSystemdRunForDetachedUpdate(serviceScope) {
+    return serviceScope !== null;
+}
+const DEFAULT_UPDATE_UTILS_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "npm-update-utils.js");
+/** Exported so the safety-critical update flow can be exercised without starting a detached process. */
+export function buildDetachedUpdateHelperScript(opts, logPath, serviceScope, updateUtilsPath = DEFAULT_UPDATE_UTILS_PATH) {
+    if (!Number.isSafeInteger(opts.parentPid) || opts.parentPid <= 1) {
+        throw new Error(`Invalid detached update parent pid: ${opts.parentPid}`);
+    }
+    const home = opts.env.HOME || os.homedir();
+    const npmCache = opts.env.npm_config_cache || path.join(home, ".npm");
+    const requestedTimeout = opts.timeoutMs ?? 300_000;
+    const timeoutMs = Number.isFinite(requestedTimeout)
+        ? Math.max(30_000, Math.trunc(requestedTimeout))
+        : 300_000;
     return `#!/usr/bin/env bash
-set -u
+set -euo pipefail
 LOG=${shellQuote(logPath)}
+INSTALL_SPEC=${shellQuote(opts.installSpec)}
+PARENT_PID=${opts.parentPid}
 exec >>"$LOG" 2>&1
-echo "[wand-update] started at $(date -Is)"
-echo "[wand-update] parent pid: ${opts.parentPid}"
-echo "[wand-update] install spec: ${opts.installSpec}"
+echo "[wand-update] started at $(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+echo "[wand-update] parent pid: $PARENT_PID"
+echo "[wand-update] install spec: $INSTALL_SPEC"
 
 export PATH=${shellQuote(opts.env.PATH || process.env.PATH || "")}
-export HOME=${shellQuote(opts.env.HOME || os.homedir())}
+export HOME=${shellQuote(home)}
 export npm_config_cache=${shellQuote(npmCache)}
 CONFIG_PATH=${shellQuote(opts.configPath)}
-INSTALL_SPEC=${shellQuote(opts.installSpec)}
-PARENT_PID=${opts.parentPid}
 SERVICE_SCOPE=${shellQuote(serviceScope ?? "")}
-SHOULD_START_SERVICE=${boolShell(shouldStartService)}
-SHOULD_RESTART_STANDALONE=${boolShell(shouldRestartStandalone)}
-TIMEOUT_SEC=${timeoutSec}
-CLI_ARGS=(${shellArray(cliArgArray)})
+TIMEOUT_MS=${timeoutMs}
+NODE_BIN=${shellQuote(process.execPath)}
+UPDATE_UTILS=${shellQuote(updateUtilsPath)}
+WORKING_DIRECTORY=${shellQuote(opts.cwd)}
+CLI_ARGS=(${shellArray(opts.cliArgs)})
+GLOBAL_CLI=""
+PARENT_EXITED=0
 
 run() {
   echo "+ $*"
   "$@"
 }
 
-run_best_effort() {
-  echo "+ $*"
-  "$@" || true
+on_exit() {
+  local status="$?"
+  if [ "$status" -ne 0 ]; then
+    if [ "$PARENT_EXITED" = "0" ]; then
+      echo "[wand-update] failed with exit code $status; parent service was left running"
+    else
+      echo "[wand-update] failed with exit code $status after parent service exited"
+    fi
+  fi
 }
+trap on_exit EXIT
 
 wait_for_parent_exit() {
   local pid="$1"
@@ -68,84 +174,68 @@ wait_for_parent_exit() {
   while kill -0 "$pid" 2>/dev/null; do
     i=$((i + 1))
     if [ "$i" -ge 120 ]; then
-      echo "[wand-update] parent still alive after 60s; continuing"
-      return 0
+      echo "[wand-update] parent still alive after SIGTERM timeout"
+      return 1
     fi
     sleep 0.5
   done
 }
 
-clean_leftovers() {
+resolve_global_cli() {
   local npm_root
-  npm_root="$(npm root -g 2>/dev/null || true)"
-  if [ -n "$npm_root" ] && [ -d "$npm_root/@co0ontty" ]; then
-    find "$npm_root/@co0ontty" -maxdepth 1 -name ".wand-*" -type d -print -exec rm -rf {} + 2>/dev/null || true
+  npm_root="$(npm root -g)"
+  GLOBAL_CLI="$npm_root/@co0ontty/wand/dist/cli.js"
+  if [ ! -f "$GLOBAL_CLI" ]; then
+    echo "[wand-update] global CLI not found after install: $GLOBAL_CLI"
+    return 1
   fi
 }
 
-npm_install_wand() {
-  if command -v timeout >/dev/null 2>&1; then
-    run timeout "$TIMEOUT_SEC" npm install -g "$INSTALL_SPEC"
-  else
-    run npm install -g "$INSTALL_SPEC"
-  fi
-}
+main() {
+  echo "[wand-update] installing while parent service stays online"
+  if run "$NODE_BIN" --input-type=module - "$UPDATE_UTILS" "$INSTALL_SPEC" "$TIMEOUT_MS" <<'WAND_INSTALL_NODE'
+import { pathToFileURL } from "node:url";
 
-npm_install_wand_force() {
-  if command -v timeout >/dev/null 2>&1; then
-    run timeout "$TIMEOUT_SEC" npm install -g --force "$INSTALL_SPEC"
+const [modulePath, installSpec, timeoutValue] = process.argv.slice(2);
+const timeoutMs = Number(timeoutValue);
+const updateUtils = await import(pathToFileURL(modulePath).href);
+if (typeof updateUtils.installPackageGloballyAsync !== "function") {
+  throw new Error("installPackageGloballyAsync is unavailable in " + modulePath);
+}
+await updateUtils.installPackageGloballyAsync(installSpec, timeoutMs, (line) => {
+  process.stdout.write(String(line) + "\\n");
+});
+WAND_INSTALL_NODE
+  then
+    echo "[wand-update] install completed"
   else
-    run npm install -g --force "$INSTALL_SPEC"
+    local install_status="$?"
+    echo "[wand-update] install failed; keeping parent service online"
+    return "$install_status"
   fi
-}
 
-restart_or_start_service() {
-  if [ "$SHOULD_START_SERVICE" = "1" ]; then
-    if [ "$SERVICE_SCOPE" = "user" ]; then
-      run_best_effort wand service:install --user -c "$CONFIG_PATH"
-      run_best_effort systemctl --user restart wand.service
-    else
-      run_best_effort wand service:install -c "$CONFIG_PATH"
-      run_best_effort systemctl restart wand.service
-    fi
-    return
-  fi
+  resolve_global_cli
+  echo "[wand-update] initializing updated installation"
+  run "$NODE_BIN" "$GLOBAL_CLI" init -c "$CONFIG_PATH"
 
-  if [ "$SHOULD_RESTART_STANDALONE" = "1" ]; then
-    echo "[wand-update] starting standalone process"
-    cd ${shellQuote(opts.cwd)}
-    local global_cli
-    global_cli="$(npm root -g 2>/dev/null)/@co0ontty/wand/dist/cli.js"
-    if [ -f "$global_cli" ]; then
-      nohup ${shellQuote(process.execPath)} "$global_cli" "$\{CLI_ARGS[@]}" >>"$LOG" 2>&1 &
-    else
-      nohup wand "$\{CLI_ARGS[@]}" >>"$LOG" 2>&1 &
-    fi
-  fi
-}
-
-main() {
-  if [ "$SERVICE_SCOPE" = "user" ]; then
-    run_best_effort systemctl --user stop wand.service
-  elif [ "$SERVICE_SCOPE" = "system" ]; then
-    run_best_effort systemctl stop wand.service
+  if kill -0 "$PARENT_PID" 2>/dev/null; then
+    echo "[wand-update] sending SIGTERM to parent pid $PARENT_PID"
+    run kill -TERM "$PARENT_PID"
+    wait_for_parent_exit "$PARENT_PID"
+  else
+    echo "[wand-update] parent pid $PARENT_PID already exited"
   fi
+  PARENT_EXITED=1
 
-  wait_for_parent_exit "$PARENT_PID"
-  clean_leftovers
-
-  echo "[wand-update] installing"
-  if ! npm_install_wand; then
-    echo "[wand-update] first install failed; retrying with uninstall + force install"
-    clean_leftovers
-    run_best_effort npm uninstall -g @co0ontty/wand
-    clean_leftovers
-    npm_install_wand_force
+  if [ -n "$SERVICE_SCOPE" ]; then
+    echo "[wand-update] $SERVICE_SCOPE service detected; waiting for Restart/KeepAlive relaunch"
+  else
+    echo "[wand-update] starting updated standalone process"
+    cd "$WORKING_DIRECTORY"
+    nohup "$NODE_BIN" "$GLOBAL_CLI" "$\{CLI_ARGS[@]}" >>"$LOG" 2>&1 </dev/null &
+    echo "[wand-update] standalone pid: $!"
   fi
-
-  run wand init -c "$CONFIG_PATH"
-  restart_or_start_service
-  echo "[wand-update] completed at $(date -Is)"
+  echo "[wand-update] completed at $(date -u +"%Y-%m-%dT%H:%M:%SZ")"
 }
 
 main
@@ -179,15 +269,15 @@ function spawnDetached(scriptPath, _logPath, env, serviceScope) {
             });
             return res.status === 0 ? { method } : null;
         };
-        const userService = runTransient(["--user", `--unit=${unitName}`, "--quiet", "--collect", bashPath, scriptPath], "systemd-run --user") ??
-            runTransient(["--user", `--unit=${unitName}`, "--quiet", bashPath, scriptPath], "systemd-run --user");
-        if (userService)
-            return userService;
-        const systemService = runTransient([`--unit=${unitName}`, "--quiet", "--collect", bashPath, scriptPath], "systemd-run") ??
-            runTransient([`--unit=${unitName}`, "--quiet", bashPath, scriptPath], "systemd-run");
-        if (systemService)
-            return systemService;
-        if (serviceScope) {
+        if (shouldUseSystemdRunForDetachedUpdate(serviceScope)) {
+            const userService = runTransient(["--user", `--unit=${unitName}`, "--quiet", "--collect", bashPath, scriptPath], "systemd-run --user") ??
+                runTransient(["--user", `--unit=${unitName}`, "--quiet", bashPath, scriptPath], "systemd-run --user");
+            if (userService)
+                return userService;
+            const systemService = runTransient([`--unit=${unitName}`, "--quiet", "--collect", bashPath, scriptPath], "systemd-run") ??
+                runTransient([`--unit=${unitName}`, "--quiet", bashPath, scriptPath], "systemd-run");
+            if (systemService)
+                return systemService;
             return null;
         }
         const setsid = spawnSync("setsid", ["--version"], { encoding: "utf8", timeout: 2000 });
@@ -208,8 +298,33 @@ export function startDetachedUpdateHelper(opts) {
     const dir = mkdtempSync(path.join(os.tmpdir(), "wand-update-"));
     const scriptPath = path.join(dir, "update.sh");
     const logPath = path.join(dir, "update.log");
-    const serviceScope = detectServiceScope();
-    writeFileSync(scriptPath, buildHelperScript(opts, logPath, serviceScope), { encoding: "utf8", mode: 0o700 });
+    let serviceScope;
+    try {
+        serviceScope = detectManagedServiceScope();
+    }
+    catch (err) {
+        return {
+            started: false,
+            scriptPath,
+            logPath,
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+    if (serviceScope) {
+        const preflight = managedServiceUpdatePreflight(serviceScope);
+        if (!preflight.ok) {
+            return {
+                started: false,
+                scriptPath,
+                logPath,
+                message: preflight.message.replace("<config-path>", opts.configPath),
+            };
+        }
+    }
+    writeFileSync(scriptPath, buildDetachedUpdateHelperScript(opts, logPath, serviceScope), {
+        encoding: "utf8",
+        mode: 0o700,
+    });
     chmodSync(scriptPath, 0o700);
     const spawned = spawnDetached(scriptPath, logPath, opts.env, serviceScope);
     if (!spawned) {