@co0ontty/wand 1.40.1 → 1.41.1

package/dist/build-info.json

@@ -0,0 +1,6 @@
+{
+  "commit": "7881848a909b65c2a17ee9d443514110e2e23f1f",
+  "builtAt": "2026-05-30T15:40:31.007Z",
+  "version": "1.41.1",
+  "channel": "stable"
+}

package/dist/npm-update-utils.d.ts

@@ -48,4 +48,14 @@ export declare function installPackageGloballySync(pkg: string, timeoutMs: numbe
     stderr: string;
     attempts: string[];
 };
+/**
+ * 解析「刚装好的全局 wand CLI 入口」(dist/cli.js) 的绝对路径。
+ *
+ * 用途：应用内更新装完新包后，要把 systemd/launchd unit 的 ExecStart 钉到这个
+ * 全局安装，而不是 process.argv[1]（源码安装场景下 argv[1] 是旧源码路径）。
+ *
+ * 优先 `npm root -g`/@co0ontty/wand/dist/cli.js（最准确）；失败回退 `which wand`
+ * （npm 全局 bin 里的符号链接，node 跟随软链一样能跑）。都找不到返回 null。
+ */
+export declare function resolveGlobalWandCli(): string | null;
 export declare const NPM_UPDATE_PACKAGE_NAME = "@co0ontty/wand";

package/dist/npm-update-utils.js

@@ -14,6 +14,7 @@
 import { exec, spawnSync } from "node:child_process";
 import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
 import path from "node:path";
+import process from "node:process";
 import { promisify } from "node:util";
 const execAsync = promisify(exec);
 const PACKAGE_NAME = "@co0ontty/wand";
@@ -120,9 +121,10 @@ export async function installPackageGloballyAsync(pkg, timeoutMs, log) {
         note(`[wand] 重试仍失败，尝试先卸载再强制安装...`);
     }
     // 终极兜底：uninstall + force install
-    const baseName = pkg.replace(/@[^@/]*$/, ""); // strip @latest / @1.2.3
+    // 卸载用固定包名 PACKAGE_NAME，而不是从 install spec 反推：spec 可能是 git
+    // 形式（`github:co0ontty/wand#beta`），用正则 strip @tag 反推会得到错误的卸载目标。
     try {
-        await execAsync(`npm uninstall -g ${baseName}`, { timeout: timeoutMs });
+        await execAsync(`npm uninstall -g ${PACKAGE_NAME}`, { timeout: timeoutMs });
     }
     catch {
         /* 卸载失败也继续，下一步 --force 可能仍然能装上 */
@@ -160,12 +162,46 @@ export function installPackageGloballySync(pkg, timeoutMs) {
         return { ...res, attempts };
     if (!hitENOTEMPTY(res))
         return { ...res, attempts };
-    // 终极兜底
-    const baseName = pkg.replace(/@[^@/]*$/, "");
-    attempts.push(`npm uninstall -g ${baseName}`);
-    spawnSync("npm", ["uninstall", "-g", baseName], { encoding: "utf8", timeout: timeoutMs });
+    // 终极兜底（卸载用固定包名，兼容 git spec，见 async 版同样注释）
+    attempts.push(`npm uninstall -g ${PACKAGE_NAME}`);
+    spawnSync("npm", ["uninstall", "-g", PACKAGE_NAME], { encoding: "utf8", timeout: timeoutMs });
     cleanupNpmLeftovers();
     res = tryInstall(["--force"]);
     return { ...res, attempts };
 }
+/**
+ * 解析「刚装好的全局 wand CLI 入口」(dist/cli.js) 的绝对路径。
+ *
+ * 用途：应用内更新装完新包后，要把 systemd/launchd unit 的 ExecStart 钉到这个
+ * 全局安装，而不是 process.argv[1]（源码安装场景下 argv[1] 是旧源码路径）。
+ *
+ * 优先 `npm root -g`/@co0ontty/wand/dist/cli.js（最准确）；失败回退 `which wand`
+ * （npm 全局 bin 里的符号链接，node 跟随软链一样能跑）。都找不到返回 null。
+ */
+export function resolveGlobalWandCli() {
+    const root = getNpmGlobalRoot();
+    if (root) {
+        const cli = path.join(root, PACKAGE_SCOPE, PACKAGE_BASENAME, "dist", "cli.js");
+        try {
+            if (existsSync(cli))
+                return cli;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    try {
+        const tool = process.platform === "win32" ? "where" : "which";
+        const r = spawnSync(tool, ["wand"], { encoding: "utf8", timeout: 10_000 });
+        if (r.status === 0) {
+            const first = (r.stdout || "").split(/\r?\n/).find((line) => line.trim().length > 0);
+            if (first)
+                return first.trim();
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+}
 export const NPM_UPDATE_PACKAGE_NAME = PACKAGE_NAME;

package/dist/relaunch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 重启策略（纯计算，无项目内依赖，便于被 server / TUI / commands 共用而不引入循环）。
+ *
+ * 背景：历史上三处重启（/api/restart、performAutoUpdate、TUI restartSelf）都无脑
+ * `spawn(node, process.argv.slice(1), {detached}) → exit(0)`。这在两种场景下有坑：
+ *   1. 应用内更新后 argv[1] 可能仍指向旧源码路径 → 重启跑回旧二进制；
+ *   2. systemd 托管时，exit 本身就会触发 Restart=always 重启；再 spawn 一个 detached
+ *      子进程会和 systemd 抢单实例 pidfile，旧 argv 的子进程可能先赢。
+ */
+export interface RelaunchPlan {
+    /** "exit-only" = 仅退出，交由进程管理器（systemd Restart=always）拉起。 */
+    mode: "exit-only" | "spawn";
+    /** spawn 模式下要执行的 CLI 入口（全局 dist/cli.js 或 argv[1]）。 */
+    bin?: string;
+    /** spawn 模式下传给 CLI 的参数（不含 node 与 bin），即 process.argv.slice(2)。 */
+    args?: string[];
+}
+/**
+ * 计算重启方式。
+ *
+ * - systemd 托管（存在 INVOCATION_ID）且已装服务 → "exit-only"：仅退出，由 unit 里
+ *   （更新自修复后可能刚被重写的）ExecStart 重新拉起，避免 spawn 抢 pidfile 的竞态。
+ * - 否则 → "spawn"：bin 优先用刚装好的全局 CLI（更新后能跑到新版），回退 argv[1]。
+ */
+export declare function computeRelaunch(opts: {
+    serviceInstalled: boolean;
+    globalCli: string | null;
+}): RelaunchPlan;

package/dist/relaunch.js

@@ -0,0 +1,17 @@
+import process from "node:process";
+/**
+ * 计算重启方式。
+ *
+ * - systemd 托管（存在 INVOCATION_ID）且已装服务 → "exit-only"：仅退出，由 unit 里
+ *   （更新自修复后可能刚被重写的）ExecStart 重新拉起，避免 spawn 抢 pidfile 的竞态。
+ * - 否则 → "spawn"：bin 优先用刚装好的全局 CLI（更新后能跑到新版），回退 argv[1]。
+ */
+export function computeRelaunch(opts) {
+    const managedBySystemd = !!process.env.INVOCATION_ID;
+    if (managedBySystemd && opts.serviceInstalled) {
+        return { mode: "exit-only" };
+    }
+    const bin = opts.globalCli ?? process.argv[1] ?? "";
+    const args = process.argv.slice(2);
+    return { mode: "spawn", bin, args };
+}

package/dist/server.js

@@ -21,7 +21,10 @@ import { SessionLogger } from "./session-logger.js";
 import { StructuredSessionManager } from "./structured-session-manager.js";
 import { generatePwaManifest, generateServiceWorker } from "./pwa.js";
 import { getErrorMessage, registerClaudeHistoryRoutes, registerSessionRoutes } from "./server-session-routes.js";
-import { installPackageGloballyAsync } from "./npm-update-utils.js";
+import { installPackageGloballyAsync, resolveGlobalWandCli } from "./npm-update-utils.js";
+import { repairServiceUnitAfterUpdate } from "./service-self-repair.js";
+import { computeRelaunch } from "./relaunch.js";
+import { isServiceInstalled } from "./tui/commands.js";
 import { registerUploadRoutes } from "./upload-routes.js";
 import { optimizePrompt, PromptOptimizeError } from "./prompt-optimizer.js";
 import { resolveDatabasePath, WandStorage } from "./storage.js";
@@ -115,6 +118,72 @@ function compareSemver(a, b) {
     }
     return 0;
 }
+/** 读取 dist/build-info.json（由 scripts/stamp-build-info.js 在 build 时生成）。 */
+function readBuildInfo() {
+    try {
+        const raw = readFileSync(path.join(SERVER_MODULE_DIR, "build-info.json"), "utf8");
+        const j = JSON.parse(raw);
+        return {
+            commit: typeof j.commit === "string" && j.commit ? j.commit : null,
+            builtAt: typeof j.builtAt === "string" && j.builtAt ? j.builtAt : null,
+            version: typeof j.version === "string" && j.version ? j.version : null,
+            channel: typeof j.channel === "string" && j.channel ? j.channel : null,
+        };
+    }
+    catch {
+        // dev（tsx 跑 src/）或老版本（无此文件）时降级为全 null。
+        return { commit: null, builtAt: null, version: null, channel: null };
+    }
+}
+const BUILD_INFO = readBuildInfo();
+// owner/repo（从 PKG_REPO_URL 派生），用于拼 beta 分支 raw 地址与 git 安装 spec。
+const PKG_REPO_SLUG = PKG_REPO_URL.replace(/^https?:\/\/github\.com\//, "").replace(/\.git$/, "");
+const BETA_BRANCH = "beta";
+const BETA_BUILD_INFO_URL = `https://raw.githubusercontent.com/${PKG_REPO_SLUG}/${BETA_BRANCH}/dist/build-info.json`;
+const BETA_INSTALL_SPEC = `github:${PKG_REPO_SLUG}#${BETA_BRANCH}`;
+let cachedBetaInfo = null;
+let betaCacheTs = 0;
+/**
+ * 通过 beta 分支的 dist/build-info.json 判定 beta 更新。
+ * 比对本地构建 commit 与远端 commit（两者记录的都是「构建源自的 master commit」）。
+ * 取不到远端 → updateAvailable=false（不冒进）。
+ */
+async function checkBetaUpdate(forceRefresh = false) {
+    const now = Date.now();
+    if (!forceRefresh && cachedBetaInfo && now - betaCacheTs < CACHE_TTL_MS) {
+        return cachedBetaInfo;
+    }
+    const localCommit = BUILD_INFO.commit;
+    let remoteCommit = null;
+    let remoteBuiltAt = null;
+    try {
+        const resp = await fetch(BETA_BUILD_INFO_URL, {
+            headers: { "User-Agent": "wand-server", Accept: "application/json" },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (resp.ok) {
+            const j = (await resp.json());
+            remoteCommit = typeof j.commit === "string" && j.commit ? j.commit : null;
+            remoteBuiltAt = typeof j.builtAt === "string" && j.builtAt ? j.builtAt : null;
+        }
+    }
+    catch {
+        /* 网络失败：保持 null，下面判定为无更新 */
+    }
+    const short = (c) => (c ? c.slice(0, 7) : "unknown");
+    const info = {
+        channel: "beta",
+        current: short(localCommit),
+        latest: short(remoteCommit),
+        updateAvailable: !!remoteCommit && remoteCommit !== localCommit,
+        localCommit,
+        remoteCommit,
+        remoteBuiltAt,
+    };
+    cachedBetaInfo = info;
+    betaCacheTs = now;
+    return info;
+}
 let cachedGitHubApk = null;
 let gitHubApkCacheTs = 0;
 const GITHUB_APK_CACHE_TTL = 10 * 60 * 1000; // 10 minutes
@@ -412,6 +481,56 @@ function verifyAppToken(token, password, secret) {
 function encodeConnectCode(url, token) {
     return Buffer.from(`${url}#${token}`).toString("base64");
 }
+function firstHeaderValue(value) {
+    if (Array.isArray(value))
+        return value[0];
+    return value;
+}
+function firstHeaderListValue(value) {
+    return firstHeaderValue(value)?.split(",")[0]?.trim();
+}
+function unquoteHeaderValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 && trimmed.startsWith("\"") && trimmed.endsWith("\"")) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function getForwardedParam(req, key) {
+    const forwarded = firstHeaderListValue(req.headers.forwarded);
+    if (!forwarded)
+        return undefined;
+    const targetKey = key.toLowerCase();
+    for (const part of forwarded.split(";")) {
+        const eqIdx = part.indexOf("=");
+        if (eqIdx < 1)
+            continue;
+        const partKey = part.slice(0, eqIdx).trim().toLowerCase();
+        if (partKey !== targetKey)
+            continue;
+        return unquoteHeaderValue(part.slice(eqIdx + 1));
+    }
+    return undefined;
+}
+function normalizePublicProtocol(value) {
+    const proto = value?.trim().toLowerCase();
+    if (proto === "http" || proto === "https")
+        return proto;
+    return undefined;
+}
+function getPublicRequestProtocol(req, fallback) {
+    return (normalizePublicProtocol(firstHeaderListValue(req.headers["x-forwarded-proto"]))
+        ?? normalizePublicProtocol(getForwardedParam(req, "proto"))
+        ?? (firstHeaderListValue(req.headers["x-forwarded-ssl"])?.toLowerCase() === "on" ? "https" : undefined)
+        ?? (firstHeaderListValue(req.headers["x-forwarded-scheme"])?.toLowerCase() === "https" ? "https" : undefined)
+        ?? fallback);
+}
+function getPublicRequestHost(req, config) {
+    return (firstHeaderListValue(req.headers["x-forwarded-host"])
+        ?? getForwardedParam(req, "host")
+        ?? req.headers.host
+        ?? `${config.host}:${config.port}`);
+}
 function decodeConnectCode(code) {
     try {
         const decoded = Buffer.from(code, "base64").toString("utf8");
@@ -1138,6 +1257,13 @@ export async function startServer(config, configPath) {
             hasCert: existsSync(certPaths.keyPath) && existsSync(certPaths.certPath),
             updateAvailable: cachedUpdateInfo?.updateAvailable ?? false,
             latestVersion: cachedUpdateInfo?.latest ?? null,
+            updateChannel: getUpdateChannel(),
+            build: {
+                commit: BUILD_INFO.commit,
+                shortCommit: BUILD_INFO.commit ? BUILD_INFO.commit.slice(0, 7) : null,
+                builtAt: BUILD_INFO.builtAt,
+                channel: BUILD_INFO.channel,
+            },
             autoUpdate: {
                 web: storage.getConfigValue("autoUpdateWeb") === "true",
                 apk: storage.getConfigValue("autoUpdateApk") === "true",
@@ -1259,8 +1385,8 @@ export async function startServer(config, configPath) {
     app.get("/api/app-connect-code", requireAuth, (req, res) => {
         const dbPassword = storage.getPassword();
         const effectivePassword = dbPassword ?? config.password;
-        const protocol = useHttps ? "https" : "http";
-        const host = req.headers.host || `${config.host}:${config.port}`;
+        const protocol = getPublicRequestProtocol(req, useHttps ? "https" : "http");
+        const host = getPublicRequestHost(req, config);
         const serverUrl = `${protocol}://${host}`;
         const appSecret = config.appSecret ?? "";
         const token = generateAppToken(effectivePassword, appSecret);
@@ -1383,10 +1509,31 @@ export async function startServer(config, configPath) {
             process.stdout.write(`${line}\n`);
         });
     }
+    /** 当前更新通道：stable（npm @latest，semver）或 beta（GitHub beta 分支，按 commit）。 */
+    const getUpdateChannel = () => storage.getConfigValue("updateChannel") === "beta" ? "beta" : "stable";
     app.get("/api/check-update", async (_req, res) => {
         try {
+            const channel = getUpdateChannel();
+            if (channel === "beta") {
+                const b = await checkBetaUpdate(true);
+                res.json({
+                    channel: "beta",
+                    current: b.current,
+                    latest: b.latest,
+                    updateAvailable: b.updateAvailable,
+                    builtAt: b.remoteBuiltAt,
+                });
+                return;
+            }
             const result = await checkNpmLatestVersion(true);
-            res.json(result);
+            // 离开 beta 边界：当前跑的是 beta 构建、但通道切回 stable 时，强制提示可更新，
+            // 让用户能从 beta 装回干净的正式版（否则 semver 相等会卡在 beta 构建上）。
+            const onBetaBuild = BUILD_INFO.channel === "beta";
+            res.json({
+                channel: "stable",
+                ...result,
+                updateAvailable: result.updateAvailable || onBetaBuild,
+            });
         }
         catch (error) {
             res.status(500).json({ error: getErrorMessage(error, "检查更新失败。") });
@@ -1400,18 +1547,52 @@ export async function startServer(config, configPath) {
         }
         updateInFlight = true;
         try {
-            const { updateAvailable, latest } = await checkNpmLatestVersion(true);
-            if (!updateAvailable) {
-                res.json({ ok: true, message: "已经是最新版本。" });
+            const channel = getUpdateChannel();
+            let installSpec;
+            let targetLabel;
+            if (channel === "beta") {
+                const b = await checkBetaUpdate(true);
+                if (!b.updateAvailable) {
+                    res.json({ ok: true, message: "已是最新 Beta 构建。" });
+                    return;
+                }
+                installSpec = BETA_INSTALL_SPEC;
+                targetLabel = `Beta ${b.latest}`;
+            }
+            else {
+                const { updateAvailable, latest } = await checkNpmLatestVersion(true);
+                const onBetaBuild = BUILD_INFO.channel === "beta";
+                if (!updateAvailable && !onBetaBuild) {
+                    res.json({ ok: true, message: "已经是最新版本。" });
+                    return;
+                }
+                installSpec = `${PKG_NAME}@latest`;
+                targetLabel = onBetaBuild ? "最新正式版" : latest;
+            }
+            // beta 走 git 安装（clone + 装依赖），比 registry tarball 慢，给足超时。
+            const logLines = [];
+            try {
+                await installPackageGloballyAsync(installSpec, 300000, (line) => {
+                    logLines.push(line);
+                    process.stdout.write(`${line}\n`);
+                });
+            }
+            catch (e) {
+                res.status(500).json({
+                    error: getErrorMessage(e, "更新失败。"),
+                    detail: logLines.join("\n").slice(-2000),
+                });
                 return;
             }
-            await npmInstallGlobal(`${PKG_NAME}@latest`, 120000);
+            // 镜像 install.sh：装完用全局安装刷新服务 unit（ExecStart/PATH），重启才会跑到新版。
+            const repair = repairServiceUnitAfterUpdate(configPath);
             // 装包成功后告知前端可以发起重启；前端会随即调用 /api/restart 完成自动重启。
             res.json({
                 ok: true,
-                message: `已更新到 ${latest}`,
+                message: `已更新到 ${targetLabel}`,
                 restartRequired: true,
-                version: latest,
+                version: targetLabel,
+                serviceRepair: repair.scope ? { repaired: repair.repaired, message: repair.message } : null,
             });
         }
         catch (error) {
@@ -1967,6 +2148,45 @@ export async function startServer(config, configPath) {
         wsManager.emitEvent(event);
     });
     // ── Restart endpoint (needs server + wss in scope) ──
+    function safeServiceInstalled() {
+        try {
+            return isServiceInstalled();
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 统一的关服 + 重启。重启方式由 computeRelaunch 决定：
+     *   - systemd 托管且已装服务 → 仅退出，交给 Restart=always 用（更新自修复后可能刚被
+     *     重写的）ExecStart 拉起，避免再 spawn detached 子进程与 systemd 抢单实例 pidfile；
+     *   - 否则 → spawn 一个 detached 子进程（bin 优先全局安装，确保更新后跑到新版）再退出。
+     */
+    function relaunchAfterShutdown() {
+        const plan = computeRelaunch({
+            serviceInstalled: safeServiceInstalled(),
+            globalCli: resolveGlobalWandCli(),
+        });
+        try {
+            wss.clients.forEach((client) => client.close());
+        }
+        catch {
+            /* noop */
+        }
+        server.close(() => {
+            if (plan.mode === "spawn") {
+                spawn(process.execPath, [plan.bin ?? "", ...(plan.args ?? [])], {
+                    detached: true,
+                    stdio: "inherit",
+                    cwd: process.cwd(),
+                    env: process.env,
+                }).unref();
+            }
+            process.exit(0);
+        });
+        // Force exit after 5s if graceful shutdown stalls
+        setTimeout(() => process.exit(0), 5000);
+    }
     app.post("/api/restart", async (_req, res) => {
         res.json({ ok: true, message: "服务正在重启..." });
         wsManager.emitEvent({
@@ -1975,19 +2195,7 @@ export async function startServer(config, configPath) {
             data: { kind: "restart" },
         });
         setTimeout(() => {
-            // Close all WebSocket connections first
-            wss.clients.forEach((client) => client.close());
-            server.close(() => {
-                spawn(process.execPath, process.argv.slice(1), {
-                    detached: true,
-                    stdio: "inherit",
-                    cwd: process.cwd(),
-                    env: process.env,
-                }).unref();
-                process.exit(0);
-            });
-            // Force exit after 5s if graceful shutdown stalls
-            setTimeout(() => process.exit(0), 5000);
+            relaunchAfterShutdown();
         }, 600);
     });
     let bindAddr = config.host === "0.0.0.0" ? "0.0.0.0" : config.host;
@@ -2045,16 +2253,45 @@ export async function startServer(config, configPath) {
             dmg: storage.getConfigValue("autoUpdateDmg") === "true",
         });
     });
+    // ── Update channel (stable / beta) ──
+    app.get("/api/update-channel", (_req, res) => {
+        res.json({
+            channel: getUpdateChannel(),
+            build: {
+                commit: BUILD_INFO.commit,
+                shortCommit: BUILD_INFO.commit ? BUILD_INFO.commit.slice(0, 7) : null,
+                builtAt: BUILD_INFO.builtAt,
+                channel: BUILD_INFO.channel,
+            },
+        });
+    });
+    app.post("/api/update-channel", express.json(), (req, res) => {
+        const body = (req.body ?? {});
+        const channel = body.channel === "beta" ? "beta" : "stable";
+        storage.setConfigValue("updateChannel", channel);
+        res.json({ channel });
+    });
     // ── Auto-update logic ──
     async function performAutoUpdate() {
-        const info = await checkNpmLatestVersion(true);
+        const channel = getUpdateChannel();
+        let info;
+        let updateSpec;
+        if (channel === "beta") {
+            const b = await checkBetaUpdate(true);
+            info = { current: b.current, latest: b.latest, updateAvailable: b.updateAvailable };
+            updateSpec = BETA_INSTALL_SPEC;
+        }
+        else {
+            info = await checkNpmLatestVersion(true);
+            updateSpec = `${PKG_NAME}@latest`;
+        }
         cachedUpdateInfo = info;
         if (!info.updateAvailable)
             return;
         const autoEnabled = storage.getConfigValue("autoUpdateWeb") === "true";
         if (!autoEnabled) {
             // Not auto-updating, just notify
-            process.stdout.write(`[wand] 发现新版本 ${info.latest}（当前 ${info.current}）。运行 npm install -g ${PKG_NAME}@latest 进行更新。\n`);
+            process.stdout.write(`[wand] 发现新版本 ${info.latest}（当前 ${info.current}）。可在设置中更新${channel === "beta" ? "（Beta 通道）" : ""}。\n`);
             wsManager.emitEvent({
                 type: "notification",
                 sessionId: "__system__",
@@ -2070,7 +2307,11 @@ export async function startServer(config, configPath) {
             data: { kind: "auto-update-start", current: info.current, latest: info.latest },
         });
         try {
-            await npmInstallGlobal(`${PKG_NAME}@latest`, 120000);
+            await npmInstallGlobal(updateSpec, 120000);
+            // 镜像 install.sh：装完用全局安装刷新服务 unit（ExecStart/PATH），重启才会跑到新版。
+            const repair = repairServiceUnitAfterUpdate(configPath);
+            if (repair.scope)
+                process.stdout.write(`[wand] ${repair.message}\n`);
             process.stdout.write(`[wand] 自动更新完成，正在重启...\n`);
             wsManager.emitEvent({
                 type: "notification",
@@ -2079,21 +2320,18 @@ export async function startServer(config, configPath) {
             });
             // Restart after a brief delay
             setTimeout(() => {
-                wss.clients.forEach((client) => client.close());
-                server.close(() => {
-                    spawn(process.execPath, process.argv.slice(1), {
-                        detached: true,
-                        stdio: "inherit",
-                        cwd: process.cwd(),
-                        env: process.env,
-                    }).unref();
-                    process.exit(0);
-                });
-                setTimeout(() => process.exit(0), 5000);
+                relaunchAfterShutdown();
             }, 1000);
         }
         catch (error) {
-            process.stdout.write(`[wand] 自动更新失败: ${getErrorMessage(error, "未知错误")}\n`);
+            const msg = getErrorMessage(error, "未知错误");
+            process.stdout.write(`[wand] 自动更新失败: ${msg}\n`);
+            // 失败不重启、保留旧版；通知前端，避免静默。
+            wsManager.emitEvent({
+                type: "notification",
+                sessionId: "__system__",
+                data: { kind: "auto-update-failed", current: info.current, latest: info.latest, error: msg },
+            });
         }
     }
     // Background update check on startup

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

@@ -0,0 +1,25 @@
+import { type ServiceScope } from "./tui/commands.js";
+/**
+ * 应用内更新后的「服务单元自修复」，对齐 install.sh 的行为。
+ *
+ * install.sh 升级时会在 `npm install -g` 之后重跑 `wand service:install`，用当前 PATH
+ * 重新烧 unit、并把 ExecStart 钉到新装的全局 wand。应用内的三条更新路径
+ * （/api/update、performAutoUpdate、TUI installUpdate）过去缺这一步，于是源码安装的
+ * 用户更新到 npm/GitHub 版后，systemd unit 的 ExecStart 仍指旧源码、baked PATH 失效，
+ * 重启时「服务找不到 / claude 找不到」。
+ *
+ * 这里在装包成功后调用，best-effort：
+ *   - 没装服务 → 跳过；
+ *   - 装了服务 → 用 preferGlobalBin 重写 unit（ExecStart→全局 dist/cli.js，
+ *     Environment=PATH 取当前已被 path-repair 修复过的 process.env.PATH）+ daemon-reload；
+ *   - system scope 非 root 无法写 /etc → installService 返回失败，这里捕获成 warning，
+ *     绝不抛错中断更新流程。
+ */
+export interface ServiceRepairResult {
+    /** 是否成功重写了 unit。无服务、或重写失败都为 false。 */
+    repaired: boolean;
+    scope?: ServiceScope;
+    /** 给日志 / 前端展示的一行说明。 */
+    message: string;
+}
+export declare function repairServiceUnitAfterUpdate(configPath: string): ServiceRepairResult;

package/dist/service-self-repair.js

@@ -0,0 +1,43 @@
+import process from "node:process";
+import { detectInstalledScope, installService } from "./tui/commands.js";
+export function repairServiceUnitAfterUpdate(configPath) {
+    // 仅 Linux(systemd) / macOS(launchd) 有服务模型。
+    if (process.platform !== "linux" && process.platform !== "darwin") {
+        return { repaired: false, message: "当前平台无服务模型，跳过 unit 自修复" };
+    }
+    let scope = null;
+    try {
+        scope = detectInstalledScope();
+    }
+    catch {
+        scope = null;
+    }
+    if (!scope) {
+        return { repaired: false, message: "未安装系统服务，跳过 unit 自修复" };
+    }
+    try {
+        const result = installService({ configPath, scope, preferGlobalBin: true });
+        if (result.ok) {
+            return {
+                repaired: true,
+                scope,
+                message: `已用全局安装重写 ${scope} 服务 unit（刷新 ExecStart / PATH）`,
+            };
+        }
+        const tail = scope === "system"
+            ? "；系统级 unit 需要 root 才能重写，重启后可手动跑 `sudo wand service:install` 修复"
+            : "";
+        return {
+            repaired: false,
+            scope,
+            message: `服务 unit 重写失败（${result.message}）${tail}`,
+        };
+    }
+    catch (err) {
+        return {
+            repaired: false,
+            scope,
+            message: `服务 unit 重写异常: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}

package/dist/tui/attach.js

@@ -7,6 +7,7 @@
  */
 import { checkUpdate, copyToClipboard, installService, installUpdate, isServiceInstalled, openInBrowser, uninstallService, } from "./commands.js";
 import { spawnSync } from "node:child_process";
+import { repairServiceUnitAfterUpdate } from "../service-self-repair.js";
 import { IpcClient } from "./ipc-client.js";
 import { buildLayout } from "./layout.js";
 import { openServicePanel } from "./service-panel.js";
@@ -224,6 +225,12 @@ export function startAttachTui(deps) {
         layout.showToast(r.message, r.ok ? "success" : "error", 5000);
         if (r.detail)
             layout.showDetail(r.ok ? "更新输出" : "更新失败", r.detail);
+        if (r.ok) {
+            // 镜像 install.sh：装完用全局安装刷新服务 unit（ExecStart/PATH），再按 R 重启服务生效。
+            const repair = await runOffMicrotask(() => repairServiceUnitAfterUpdate(deps.configPath));
+            if (repair.scope)
+                layout.showToast(repair.message, repair.repaired ? "success" : "warn", 4500);
+        }
     }
     async function handleInstallService() {
         if (isServiceInstalled()) {

package/dist/tui/commands.d.ts

@@ -53,11 +53,19 @@ export interface ServiceContext {
     wandBin?: string;
     /** 显式指定作用域。不传走 DEFAULT_SERVICE_SCOPE。 */
     scope?: ServiceScope;
+    /**
+     * 更新后自修复场景：优先把 ExecStart 钉到「全局安装的 wand」(npm root -g 下的
+     * dist/cli.js)，而不是 process.argv[1]。源码安装的用户更新到 npm/GitHub 版后，
+     * argv[1] 仍是旧源码路径，沿用它会让重启跑回旧二进制。
+     */
+    preferGlobalBin?: boolean;
 }
 export interface ServiceOpts {
     /** 不传 = 自动检测已装的那个；都没装就用 default。 */
     scope?: ServiceScope;
 }
+/** 自动检测哪个 scope 已经装了 unit；优先 system，找不到就 user。两个都没装返回 null。 */
+export declare function detectInstalledScope(): ServiceScope | null;
 export declare function isServiceInstalled(scope?: ServiceScope): boolean;
 export interface ServiceStatus {
     /** 是否已安装服务文件。 */

package/dist/tui/commands.js

@@ -9,7 +9,8 @@ import { existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
-import { installPackageGloballySync } from "../npm-update-utils.js";
+import { installPackageGloballySync, resolveGlobalWandCli } from "../npm-update-utils.js";
+import { computeRelaunch } from "../relaunch.js";
 const PACKAGE_NAME = "@co0ontty/wand";
 // ─── 重启 ────────────────────────────────────────────────────────────────
 /**
@@ -19,7 +20,17 @@ const PACKAGE_NAME = "@co0ontty/wand";
  */
 export function restartSelf() {
     try {
-        const child = spawn(process.execPath, process.argv.slice(1), {
+        const plan = computeRelaunch({
+            serviceInstalled: isServiceInstalled(),
+            globalCli: resolveGlobalWandCli(),
+        });
+        if (plan.mode === "exit-only") {
+            // systemd 托管：仅退出，交给 Restart=always 用 unit 里的 ExecStart 拉起，
+            // 避免再 spawn 一个 detached 子进程与 systemd 抢单实例 pidfile。
+            setTimeout(() => process.exit(0), 200);
+            return { ok: true, message: "重启中…交由 systemd 拉起" };
+        }
+        const child = spawn(process.execPath, [plan.bin ?? "", ...(plan.args ?? [])], {
             detached: true,
             stdio: "inherit",
             env: process.env,
@@ -136,7 +147,7 @@ function isRoot() {
     }
 }
 /** 自动检测哪个 scope 已经装了 unit；优先 system，找不到就 user。两个都没装返回 null。 */
-function detectInstalledScope() {
+export function detectInstalledScope() {
     if (existsSync(servicePathFor("system")))
         return "system";
     if (existsSync(servicePathFor("user")))
@@ -418,6 +429,12 @@ function servicePathFor(scope) {
     return "";
 }
 function resolveWandBin(ctx) {
+    // 更新后自修复：优先全局安装的 dist/cli.js，避免沿用旧源码路径。
+    if (ctx.preferGlobalBin) {
+        const global = resolveGlobalWandCli();
+        if (global)
+            return global;
+    }
     if (ctx.wandBin && existsSync(ctx.wandBin))
         return ctx.wandBin;
     const argv1 = process.argv[1];

package/dist/tui/index.js

@@ -1,4 +1,5 @@
 import { checkUpdate, copyToClipboard, installService, installUpdate, isServiceInstalled, openInBrowser, restartSelf, uninstallService, } from "./commands.js";
+import { repairServiceUnitAfterUpdate } from "../service-self-repair.js";
 import { buildLayout } from "./layout.js";
 import { installLogBus, restoreLogBus } from "./log-bus.js";
 import { formatSession, sortRows } from "./session-formatter.js";
@@ -182,6 +183,12 @@ export function startTui(deps) {
         layout.showToast(r.message, r.ok ? "success" : "error", 5000);
         if (r.detail)
             layout.showDetail(r.ok ? "更新输出" : "更新失败", r.detail);
+        if (r.ok) {
+            // 镜像 install.sh：装完用全局安装刷新服务 unit（ExecStart/PATH），再按 R 重启生效。
+            const repair = await runOffMicrotask(() => repairServiceUnitAfterUpdate(deps.configPath));
+            if (repair.scope)
+                layout.showToast(repair.message, repair.repaired ? "success" : "warn", 4500);
+        }
     }
     function handleOpenBrowser() {
         const url = deps.urls[0]?.url;

package/dist/web-ui/content/scripts.js

@@ -86,11 +86,9 @@
       // 当前长度时整段跳过；新用户首次加载会一口气把所有 migration 都跑完再写
       // schema 号 —— 因此每个 migration 函数对「key 不存在」的输入也必须是无害的。
       var LS_MIGRATIONS = [
-        // v1（2026-05）取消独立的「图钉」按钮，呼出侧栏即常驻。旧版残留的
-        // wand-sidebar-pinned=false 会让老用户继续走 drawer 模式看不到新行为，
-        // 这里直接清掉，让 state 初始化回退到默认 true。
+        // v1 保留为 no-op：曾经这里会删除 wand-sidebar-pinned，导致升级或刷新时
+        // 覆盖用户明确选择的侧栏状态。迁移函数必须只修正格式，不能抹掉偏好。
         function migrateSidebarPinDefault() {
-          try { localStorage.removeItem("wand-sidebar-pinned"); } catch (e) {}
         }
       ];
       (function runLocalStorageMigrations() {
@@ -107,6 +105,23 @@
         } catch (e) { /* localStorage 不可用就跳过，按默认行为运行 */ }
       })();
 
+      function readStoredBoolean(key, defaultValue) {
+        try {
+          var value = localStorage.getItem(key);
+          if (value === "true") return true;
+          if (value === "false") return false;
+          return defaultValue;
+        } catch (e) {
+          return defaultValue;
+        }
+      }
+
+      function writeStoredBoolean(key, value) {
+        try {
+          localStorage.setItem(key, String(!!value));
+        } catch (e) {}
+      }
+
       var state = {
         selectedId: (function() {
           try { return localStorage.getItem("wand-selected-session") || null; } catch (e) { return null; }
@@ -182,18 +197,10 @@
         loginPending: false,
         loginChecked: false,
         bootstrapping: true,
-        sessionsDrawerOpen: false,
-        sidebarPinned: (function() {
-          // 新交互：桌面默认呼出即常驻；只有用户主动 X 关闭过才记 "false"。
-          // 老用户的旧值（"true"/"false"）继续生效，没存过 key 时回退到 true。
-          try {
-            var v = localStorage.getItem("wand-sidebar-pinned");
-            return v === null ? true : v !== "false";
-          } catch (e) { return true; }
-        })(),
-        sidebarCollapsed: (function() {
-          try { return localStorage.getItem("wand-sidebar-collapsed") === "true"; } catch (e) { return false; }
-        })(),
+        sessionsDrawerOpen: readStoredBoolean("wand-sidebar-open", false),
+        // 新交互：桌面默认呼出即常驻；只有用户主动关闭过才记 "false"。
+        sidebarPinned: readStoredBoolean("wand-sidebar-pinned", true),
+        sidebarCollapsed: readStoredBoolean("wand-sidebar-collapsed", false),
         modalOpen: false,
         presetValue: "",
         cwdValue: "",
@@ -1563,9 +1570,9 @@
       }
 
       // ===== 桌面：点 sidebar 外的空白处自动收起 =====
-      // 旧版 drawer 模式下点 backdrop 关闭的便利性，在「呼出即常驻」之后用
-      // document 级捕获 handler 续上。
-      // - 仅 desktop + 全尺寸（非窄条）+ 已打开 时生效
+      // 只对「临时打开但未锁定」的全尺寸侧栏生效；已锁定的 pinned 侧栏
+      // 必须保持常驻，除非用户明确点 X / hamburger 关闭。
+      // - 仅 desktop + 未锁定 + 全尺寸（非窄条）+ 已打开 时生效
       // - 窄条态不触发（窄条本来就是稳定常驻形态）
       // - 手机端由 .drawer-backdrop 元素自己接住点击，不在这里重复处理
       // - 各类弹层（modal / topbar-more / overflow 菜单 / 文件夹下拉等）不算
@@ -1573,7 +1580,7 @@
       // 用 capture 阶段是为了绕过下游按钮自己的 stopPropagation。
       document.addEventListener("click", function(e) {
         if (isMobileLayout()) return;
-        if (!state.sidebarPinned) return;
+        if (state.sidebarPinned) return;
         if (state.sidebarCollapsed) return;
         if (!state.sessionsDrawerOpen) return;
         var target = e.target;
@@ -1615,6 +1622,7 @@
         // false 打架，并在手机端误触发背景遮罩。窄条态下不强制 open。
         if (state.sidebarPinned && !state.sidebarCollapsed && !isMobileLayout()) {
           state.sessionsDrawerOpen = true;
+          writeStoredBoolean("wand-sidebar-open", true);
         }
         app.innerHTML = isLoggedIn ? renderAppShell() : renderLogin();
         // Reset chat render tracking since DOM was fully replaced
@@ -3102,6 +3110,16 @@
                     '<button id="do-restart-button" class="btn btn-success btn-sm hidden">\u91cd\u542f\u751f\u6548</button>' +
                   '</div>' +
                   '<p id="update-message" class="hint hidden"></p>' +
+                  '<div class="settings-toggle-row">' +
+                    '<div class="settings-toggle-text">' +
+                      '<span class="settings-toggle-title">Beta 通道</span>' +
+                      '<span class="settings-toggle-desc">更新到最新提交构建（commit 版本），尝鲜新功能，可能不稳定。</span>' +
+                    '</div>' +
+                    '<label class="settings-switch">' +
+                      '<input type="checkbox" id="beta-channel-toggle" class="switch-toggle">' +
+                      '<span class="switch-slider"></span>' +
+                    '</label>' +
+                  '</div>' +
                   '<div class="settings-toggle-row">' +
                     '<div class="settings-toggle-text">' +
                       '<span class="settings-toggle-title">自动更新</span>' +
@@ -4157,6 +4175,7 @@
         } catch (e) {}
         if (state.filePanelOpen && isMobileLayout()) {
           state.sessionsDrawerOpen = false;
+          writeStoredBoolean("wand-sidebar-open", false);
         }
         updateLayoutState();
         if (state.filePanelOpen) {
@@ -6371,6 +6390,10 @@
         if (autoUpdateDmgToggle) autoUpdateDmgToggle.addEventListener("change", function() {
           toggleAutoUpdate("dmg", autoUpdateDmgToggle.checked);
         });
+        var betaChannelToggle = document.getElementById("beta-channel-toggle");
+        if (betaChannelToggle) betaChannelToggle.addEventListener("change", function() {
+          setUpdateChannel(betaChannelToggle.checked ? "beta" : "stable");
+        });
         var copyConnectCodeBtn = document.getElementById("copy-connect-code-button");
         if (copyConnectCodeBtn) copyConnectCodeBtn.addEventListener("click", function() {
           var text = document.getElementById("android-connect-code");
@@ -8644,6 +8667,7 @@
         state.claudeHistoryExpanded = false;
         state.claudeHistoryExpandedDirs = {};
         state.sessionsDrawerOpen = false;
+        writeStoredBoolean("wand-sidebar-open", false);
         render();
       }
 
@@ -9842,15 +9866,17 @@
           if (willOpen) {
             // 桌面重新呼出默认回到全尺寸；窄条形态需用户主动点 collapse 按钮切换。
             state.sidebarCollapsed = false;
-            try { localStorage.setItem("wand-sidebar-collapsed", "false"); } catch (e) {}
+            writeStoredBoolean("wand-sidebar-collapsed", false);
           }
-          try { localStorage.setItem("wand-sidebar-pinned", String(willOpen)); } catch (e) {}
+          writeStoredBoolean("wand-sidebar-pinned", willOpen);
+          writeStoredBoolean("wand-sidebar-open", state.sessionsDrawerOpen);
           updateLayoutState();
           scheduleTerminalRefitAfterPaddingTransition();
           return;
         }
         // 手机端：保持原 drawer 行为。
         state.sessionsDrawerOpen = !state.sessionsDrawerOpen;
+        writeStoredBoolean("wand-sidebar-open", state.sessionsDrawerOpen);
         if (state.sessionsDrawerOpen) {
           state.filePanelOpen = false;
           try {
@@ -9869,7 +9895,8 @@
           closeSwipedItem();
           state.sidebarPinned = false;
           state.sessionsDrawerOpen = false;
-          try { localStorage.setItem("wand-sidebar-pinned", "false"); } catch (e) {}
+          writeStoredBoolean("wand-sidebar-pinned", false);
+          writeStoredBoolean("wand-sidebar-open", false);
           updateLayoutState();
           scheduleTerminalRefitAfterPaddingTransition();
           return;
@@ -9878,6 +9905,7 @@
         if (!state.sessionsDrawerOpen) return;
         closeSwipedItem();
         state.sessionsDrawerOpen = false;
+        writeStoredBoolean("wand-sidebar-open", false);
         updateLayoutState();
       }
 
@@ -9978,14 +10006,10 @@
         // 任何形态下点窄条按钮都意味着「我要常驻」，确保 pinned 写上。
         if (!state.sidebarPinned) {
           state.sidebarPinned = true;
-          try {
-            localStorage.setItem("wand-sidebar-pinned", "true");
-          } catch (e) {}
+          writeStoredBoolean("wand-sidebar-pinned", true);
         }
         state.sidebarCollapsed = !state.sidebarCollapsed;
-        try {
-          localStorage.setItem("wand-sidebar-collapsed", String(state.sidebarCollapsed));
-        } catch (e) {}
+        writeStoredBoolean("wand-sidebar-collapsed", state.sidebarCollapsed);
         if (state.sidebarCollapsed) {
           // 进入窄条形态：sessionsDrawerOpen 设 false，避免手机上 .drawer-backdrop
           // 仍带 .open 类导致背景遮罩误显示（窄条已经常驻显示，不需要遮罩）。
@@ -9995,13 +10019,12 @@
           // 改为回到 drawer 模式并自动打开抽屉，让用户看到完整会话列表。
           state.sidebarPinned = false;
           state.sessionsDrawerOpen = true;
-          try {
-            localStorage.setItem("wand-sidebar-pinned", "false");
-          } catch (e) {}
+          writeStoredBoolean("wand-sidebar-pinned", false);
         } else {
           // 桌面端展开窄条 → 300px 全栏常驻。
           state.sessionsDrawerOpen = true;
         }
+        writeStoredBoolean("wand-sidebar-open", state.sessionsDrawerOpen);
         // 轻量更新而非全量 render()：render() 会 teardown 并重建整个终端 DOM，
         // 导致收窄/展开时终端闪烁、丢失滚动与渲染状态。这里只切布局 class
         // （宽度 56↔300 走 CSS width transition）、重渲侧栏列表内容、刷新
@@ -10028,7 +10051,8 @@
         state.sidebarPinned = !state.sidebarPinned;
         // 关键：保持侧栏可见停靠，无论锁定与否，点图钉都不让它消失。
         state.sessionsDrawerOpen = true;
-        try { localStorage.setItem("wand-sidebar-pinned", String(state.sidebarPinned)); } catch (e) {}
+        writeStoredBoolean("wand-sidebar-pinned", state.sidebarPinned);
+        writeStoredBoolean("wand-sidebar-open", true);
         updateLayoutState();
         scheduleTerminalRefitAfterPaddingTransition();
       }
@@ -10081,6 +10105,7 @@
         closeSettingsModal();
         state.modalOpen = true;
         state.sessionsDrawerOpen = false;
+        writeStoredBoolean("wand-sidebar-open", false);
         updateDrawerState();
         var modal = document.getElementById("session-modal");
         if (modal) {
@@ -10691,6 +10716,10 @@
               }
             }
 
+            // Beta channel toggle
+            var betaChannelToggle = document.getElementById("beta-channel-toggle");
+            if (betaChannelToggle) betaChannelToggle.checked = data.updateChannel === "beta";
+
             // Auto-update toggles
             var autoUpdate = data.autoUpdate || {};
             var autoUpdateWebToggle = document.getElementById("auto-update-web-toggle");
@@ -11233,12 +11262,22 @@
               if (latestEl) latestEl.textContent = "检查失败";
               return;
             }
-            if (latestEl) latestEl.textContent = data.latest;
+            var isBeta = data.channel === "beta";
+            if (latestEl) {
+              if (isBeta) {
+                var label = "beta · " + (data.latest || "unknown");
+                if (data.builtAt) { try { label += " · " + timeAgo(data.builtAt); } catch (_e) {} }
+                latestEl.textContent = label;
+              } else {
+                latestEl.textContent = data.latest;
+              }
+            }
             if (data.updateAvailable && updateBtn) {
+              updateBtn.textContent = isBeta ? "更新到最新 Beta" : "更新到最新版";
               updateBtn.classList.remove("hidden");
             }
             if (!data.updateAvailable && msgEl) {
-              msgEl.textContent = "已是最新版本。";
+              msgEl.textContent = isBeta ? "已是最新 Beta 构建。" : "已是最新版本。";
               msgEl.style.color = "var(--success)";
               msgEl.classList.remove("hidden");
             }
@@ -11369,6 +11408,26 @@
         });
       }
 
+      function setUpdateChannel(channel) {
+        fetch("/api/update-channel", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          credentials: "same-origin",
+          body: JSON.stringify({ channel: channel }),
+        })
+        .then(function(res) { return res.json(); })
+        .then(function(data) {
+          var toggle = document.getElementById("beta-channel-toggle");
+          if (toggle) toggle.checked = data.channel === "beta";
+          // 切换通道后重新检查更新，刷新"最新版本"显示与更新按钮。
+          checkForUpdate();
+        })
+        .catch(function() {
+          var toggle = document.getElementById("beta-channel-toggle");
+          if (toggle) toggle.checked = channel !== "beta";
+        });
+      }
+
       // ── Notification Settings Helpers ──
 
       function _updateAppIconSelection(activeIcon) {
@@ -16771,9 +16830,11 @@
             lastKnownDesktop = isDesktop;
             if (!isDesktop && state.sidebarPinned && state.sessionsDrawerOpen) {
               state.sessionsDrawerOpen = false;
+              writeStoredBoolean("wand-sidebar-open", false);
               updateDrawerState();
             } else if (isDesktop && state.sidebarPinned && !state.sessionsDrawerOpen) {
               state.sessionsDrawerOpen = true;
+              writeStoredBoolean("wand-sidebar-open", true);
               updateDrawerState();
             }
           }
@@ -21849,6 +21910,7 @@
           state.selectedId = null;
           persistSelectedId();
           state.sessionsDrawerOpen = true;
+          writeStoredBoolean("wand-sidebar-open", true);
           render();
           return true;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@co0ontty/wand",
-  "version": "1.40.1",
+  "version": "1.41.1",
   "description": "A web terminal for local CLI tools like Claude.",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
   ],
   "preferGlobal": true,
   "scripts": {
-    "build": "node scripts/bundle-wterm.js && node scripts/bundle-qrcode.js && tsc -p tsconfig.json && npm run build:copy-content",
+    "build": "node scripts/bundle-wterm.js && node scripts/bundle-qrcode.js && tsc -p tsconfig.json && npm run build:copy-content && node scripts/stamp-build-info.js",
     "build:copy-content": "cp -r src/web-ui/content dist/web-ui/",
     "dev": "tsx src/cli.ts web",
     "check": "tsc --noEmit -p tsconfig.json",