pi-webapp 0.1.5 → 0.1.7

package/README.md

@@ -16,6 +16,8 @@ npx pi-webapp
 
 This starts Pi in the background and opens the default browser on a local graphical desktop, leaving the terminal free. If Pi is missing, the launcher installs the official `@earendil-works/pi-coding-agent` package with npm. An existing Pi installation must be version 0.87.1 or later. The launcher does not replace an older installation automatically. Running the launcher again reopens the existing server. Remote or headless sessions print the address instead; set `PI_WEBAPP_AUTO_OPEN=0` to disable automatic opening.
 
+In Settings → General → App updates, the web page checks npm for a newer `pi-webapp` release. When started by the background launcher from an npm package, **Update and restart** installs the verified release under Pi's `pi-web/releases/` data directory, restarts the server, and reloads the same browser address. Wait for any active reply to finish first. If the new version cannot start, the launcher restores the previous service. This works for both `npx` and global-command launches; later launches select the managed release automatically. It does not change the npm global installation. Source checkouts and `/web` pages opened from an existing Pi terminal show version information but cannot restart from the web page. If the service does not return, run `pi-webapp status` and check `~/.pi/agent/pi-web/launcher.log`.
+
 Use `npx pi-webapp status` to show the address and `npx pi-webapp stop` to stop the background service. After a global install, use `pi-webapp status` and `pi-webapp stop`.
 
 You can also install the launcher globally:
@@ -37,12 +39,12 @@ In Pi, enter `/web` to open the interface in your default browser. Pi also print
 ## Features
 
 - View the current conversation with Markdown, streaming output, expandable reasoning and tool calls, token usage, and a turn-by-turn trace.
-- Send messages, stop a run, start a new Pi session, and change the current model or thinking level.
+- Send messages, pause and continue a run, start a new Pi session, and change the current model or thinking level. The bottom-right control pauses an active run; an empty composer offers Continue after pausing, including after refreshing or reopening the session. Continue uses an internal control action without adding a user message; the model makes a new request based on existing progress, and plan mode still requires fresh approval.
 - Browse workspaces and saved sessions. Add a workspace with the native directory picker when available, or use the built-in directory browser over SSH.
 - Attach up to 20 files of 20 MB each by selecting, dropping, or pasting them. Images show previews and are also sent as Pi image content.
 - Manage appearance, Pi packages, extensions, skills, and models from the settings panel. The Models page can add models, edit display names, context windows, output limits, and input types, and restore built-in defaults; changes are saved to Pi's `models.json`. Browser sign-in opens the provider's authorization page automatically; manual code entry remains available when a callback cannot reach Pi. Stored provider credentials can also be removed there. Credentials stay in Pi's local `auth.json` and are never returned to the browser.
 
-If you enter `/web` manually in a Pi terminal, that terminal session stays synchronized with the browser. With the launcher, Pi runs in the background. Sessions opened in other workspaces use the Pi SDK and load that workspace's skills and project context. They do not load extensions again in the same process.
+If you enter `/web` manually in a Pi terminal, that terminal session stays synchronized with the browser. With the launcher, Pi runs in the background. Sessions opened in other workspaces use the Pi SDK and load that workspace's skills and project context. They load enabled Web plugin Pi entries explicitly while keeping other Pi extensions isolated from the parent bridge.
 
 On startup, the app discovers workspaces from Pi's saved sessions, so conversations from other directories appear in the sidebar. Workspace records and attachments stay under Pi's existing `pi-web/` data directory. Removing a workspace from the sidebar does not delete its files or sessions; you can add it again manually.
 
@@ -60,13 +62,24 @@ npm run stop
 
 `npm run start` builds the project, starts Pi in the background, and opens the web interface. After editing the extension, run `npm run stop` followed by `npm run start`. If you develop with `pi -e .`, enter `/reload` and `/web` in Pi after rebuilding. Refreshing an old browser page alone does not replace the running bridge.
 
+For local Web plugin development with the sibling `pi-extensions` workspace, follow its `README.md`. Set `PI_WEBAPP_PLUGIN_DEV_ROOTS=../pi-extensions/packages/plan-mode` when starting this app; browser asset changes refresh automatically and Pi entry changes trigger a safe reload when the agent is idle.
+
 The source lives in `extension/`, `shared/`, and `web/src/`. The npm package contains only the bundled, minified JavaScript extension, built web assets, cover image, and the English and Chinese READMEs. No TypeScript source or source maps are published. Minification makes the shipped code harder to read; it does not encrypt JavaScript.
 
 ## Publish
 
+CI resolves the published `@chengzhiyi/pi-web-protocol` version before `npm ci`.
+Until the first protocol publication, verification builds a pinned `pi-extensions`
+commit in an ignored `.ci/` checkout and uses that local package. Checks, tests,
+and builds still run; the Actions summary explains why host publication is waiting.
+Release builds always require the published npm dependency. Once it exists, the
+next workflow uses its exact version and the release commit records the lockfile.
+Use Actions' manual run after initializing npm; protocol releases do not trigger
+this repository automatically.
+
 `npm publish` runs the checks, tests, and production build. The `pi-package` keyword makes the published npm package eligible for the [Pi package catalog](https://pi.dev/packages); catalog updates may lag behind npm.
 
-GitHub Actions runs `check`, `test`, and `build` on pull requests to `main`. A push to `main` repeats those checks and then publishes the next patch version to npm. The release version is selected from the greater of the source version and the npm `latest` version; it is set in the package during CI and is not committed back to Git. To start a new minor or major series, raise the version in `package.json` and `package-lock.json` in the pull request. Each release also updates the package's `pi.image` URL to its own version.
+GitHub Actions runs `check`, `test`, and `build` on pull requests to `main`. A push to `main` repeats those checks, chooses the next patch version from the source version and npm `latest`, then commits the updated `package.json` and `package-lock.json` to `main` before publishing. The release commit uses the workflow's `GITHUB_TOKEN` and does not start another workflow run. To start a new minor or major series, raise the version in both package files in the pull request. Each release also updates the package's `pi.image` URL to its own version. The repository must allow the workflow to push to `main` for publishing to proceed.
 
 Before the first automated release, configure npm Trusted Publishing for the `pi-webapp` package: GitHub owner `chengzhiyi`, repository `pi-webapp`, workflow filename `ci.yml`, no environment, and allow direct `npm publish`. This workflow uses GitHub's OIDC identity and does not need an npm token. Keep the package's repository URL in `package.json` aligned with the GitHub repository.
 

package/README.zh-CN.md

@@ -16,6 +16,8 @@ npx pi-webapp
 
 该命令会在后台启动 Pi，并在本地图形桌面用默认浏览器打开网页，终端可继续使用。若未找到 Pi，会自动通过 npm 安装官方 `@earendil-works/pi-coding-agent`。已有 Pi 需要 0.87.1 或更新版本；启动器不会自动覆盖旧版本。再次运行启动命令会重新打开已有服务。远程或无图形界面时只显示地址；设置 `PI_WEBAPP_AUTO_OPEN=0` 可关闭自动打开。
 
+网页的「设置 → 通用设置 → 应用更新」会检查 npm 上的 `pi-webapp` 新版本。通过 npm 包的后台启动器运行时，点击「升级并重启」会先将新版安装并校验到 Pi 数据目录的 `pi-web/releases/`，然后重启服务，网页会在原地址重新加载。请先等待当前回复结束。若新版无法启动，启动器会恢复旧版服务。`npx` 和全局命令启动均可使用；后续启动会自动选用已安装的新版。此操作不会改动 npm 全局安装。源码目录运行和已有 Pi 终端中的 `/web` 页面可以查看版本，但不能从网页重启。若服务未恢复，可运行 `pi-webapp status` 并查看 `~/.pi/agent/pi-web/launcher.log`。
+
 可用 `npx pi-webapp status` 查看地址，用 `npx pi-webapp stop` 停止后台服务。全局安装后可直接运行 `pi-webapp status` 和 `pi-webapp stop`。
 
 也可以将启动器安装为全局命令：
@@ -37,12 +39,12 @@ pi
 ## 功能
 
 - 查看当前对话，包括 Markdown 内容、流式输出、可展开的推理过程与工具调用、Token 用量，以及逐轮执行轨迹。
-- 发送消息、停止运行、启动新的 Pi 会话，以及切换当前模型或思考级别。
+- 发送消息、暂停与继续运行、启动新的 Pi 会话，以及切换当前模型或思考级别。运行时右下角显示暂停；暂停后清空输入框即可继续，刷新或重新打开会话后仍可恢复。继续通过内部控制动作恢复原任务，不新增用户消息；模型会基于已有进度发起新请求，计划模式仍需重新审批。
 - 浏览工作区和已保存的会话。环境支持时可通过系统目录选择器添加工作区；通过 SSH 使用时，也可使用内置目录浏览器。
 - 通过选择、拖放或粘贴附加文件，最多 20 个，每个不超过 20 MB。图片会显示预览，并作为 Pi 图片内容发送。
 - 在设置面板中管理外观、Pi 软件包、扩展、技能和模型。模型页可添加模型、编辑显示名称、上下文窗口、最大输出 token 数和输入类型，或恢复内置模型的默认参数；配置写入 Pi 的 `models.json`。网页登录会自动打开提供方授权页；当回调无法到达 Pi 时，仍可手动粘贴授权码。已保存的提供方认证可在这里移除。凭据保留在 Pi 本地的 `auth.json`，不会返回给浏览器。
 
-如果通过 Pi 终端手动输入 `/web`，该终端会话会与浏览器保持同步。使用启动器时，Pi 在后台运行。在其他工作区打开的会话使用 Pi SDK，并加载该工作区的技能和项目上下文；同一进程中不会再次加载扩展。
+如果通过 Pi 终端手动输入 `/web`，该终端会话会与浏览器保持同步。使用启动器时，Pi 在后台运行。在其他工作区打开的会话使用 Pi SDK，并加载该工作区的技能和项目上下文；已启用的 Web 插件 Pi 入口会显式加载，其他普通 Pi 扩展仍与主会话隔离。
 
 启动时会从 Pi 已保存的会话中发现工作区，因此先前在其他目录使用 Pi 的会话也会出现在侧边栏。工作区记录和附件继续存放在 Pi 现有的 `pi-web/` 数据目录下。从侧边栏移除工作区不会删除其文件或会话；移除后如需再次显示，可以手动添加。
 
@@ -60,13 +62,22 @@ npm run stop
 
 `npm run start` 会构建项目、在后台启动 Pi 并打开 Web 界面。修改扩展后，运行 `npm run stop`，再运行 `npm run start`；如果使用 `pi -e .` 开发，则在 Pi 中依次输入 `/reload` 和 `/web`。仅刷新旧的浏览器页面不会替换正在运行的连接桥接代码。
 
+与同级 `pi-extensions` 联调时，先在该目录运行 `pnpm install && pnpm build`，再运行 `pnpm dev`；在本项目设置 `PI_WEBAPP_PLUGIN_DEV_ROOTS=../pi-extensions/packages/plan-mode` 后执行 `npm run start`。浏览器资源变化后页面会刷新，Pi 入口变化后会等待代理空闲并重载扩展。完整步骤见 `pi-extensions/README.md`。
+
 源代码位于 `extension/`、`shared/` 和 `web/src/`。npm 软件包仅包含打包并压缩后的 JavaScript 扩展、构建后的 Web 资源、封面图片，以及英文和中文 README；不会发布 TypeScript 源码或 source map。代码压缩会增加阅读发布版本代码的难度，但不会对 JavaScript 加密。
 
 ## 发布
 
+CI 会先从 npm 解析 `@chengzhiyi/pi-web-protocol` 的已发布版本，再运行 `npm ci`。
+首次发布协议前，校验任务会将固定提交的 `pi-extensions` 检出到被忽略的 `.ci/`
+目录，构建协议并使用本地包，完整执行检查、测试与构建；Actions 摘要会说明
+宿主发布仍在等待协议初始化。正式发布始终要求准确的 npm 依赖，并将清单和
+锁文件变化同步回仓库。协议发布后可以在 Actions 手动运行工作流；协议发布
+不会主动触发这个仓库。
+
 `npm publish` 会运行检查、测试和生产构建。`pi-package` 关键词使发布到 npm 的软件包有资格进入 [Pi 软件包目录](https://pi.dev/packages)；目录更新可能晚于 npm。
 
-GitHub Actions 会在针对 `main` 的拉取请求中运行 `check`、`test` 和 `build`。代码推送到 `main` 后会再次运行这些检查，全部通过才自动发布下一个补丁版本。发布版本根据源码版本和 npm `latest` 版本确定，仅在 CI 中写入包文件，不会提交回 Git。如需开始新的次版本或主版本，请在拉取请求中同步提高 `package.json` 和 `package-lock.json` 的版本。每次发布也会将包内 `pi.image` 的地址更新为该版本。
+GitHub Actions 会在针对 `main` 的拉取请求中运行 `check`、`test` 和 `build`。代码推送到 `main` 后会再次运行这些检查，根据源码版本和 npm `latest` 版本确定下一个补丁版本，先将更新后的 `package.json` 和 `package-lock.json` 提交回 `main`，再发布到 npm。版本同步提交使用工作流的 `GITHUB_TOKEN`，不会再次触发工作流。如需开始新的次版本或主版本，请在拉取请求中同步提高两个包文件的版本。每次发布也会将包内 `pi.image` 的地址更新为该版本。仓库必须允许工作流推送到 `main`，发布才能继续。
 
 首次自动发布前，请在 npm 的 `pi-webapp` 包设置中配置 Trusted Publishing：GitHub 所有者为 `chengzhiyi`，仓库为 `pi-webapp`，工作流文件名为 `ci.yml`，不设置环境，并允许直接执行 `npm publish`。工作流通过 GitHub OIDC 认证，无需 npm token。`package.json` 中的仓库地址应与 GitHub 仓库保持一致。
 

package/THIRD_PARTY_LICENSE.txt

@@ -0,0 +1,24 @@
+DSH presentation components are derived from DeepSeek Harness, commit
+477b4f420553e8a52c2fbccc464d7561b239c443.
+
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/pi-webapp.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { spawn as spawnNode } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { closeSync, existsSync, openSync } from "node:fs";
+import { closeSync, existsSync, openSync, watch } from "node:fs";
 import { mkdir, open, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { delimiter, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import spawn from "cross-spawn";
 import { openWebPage } from "./open-web-page.mjs";
@@ -15,6 +15,8 @@ const extension = fileURLToPath(new URL("../dist/extension.js", import.meta.url)
 const agentDir = resolve((process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent")).replace(/^~(?=$|[\\/])/, homedir()));
 const statePath = join(agentDir, "pi-web", "launcher.json");
 const stopPath = join(agentDir, "pi-web", "launcher.stop");
+const restartPath = join(agentDir, "pi-web", "launcher.restart");
+const updatePath = join(agentDir, "pi-web", "update.json");
 const logPath = join(agentDir, "pi-web", "launcher.log");
 
 function versionParts(value) {
@@ -111,8 +113,9 @@ async function serve(pi, args) {
     return;
   } finally { await lock?.close().catch(() => {}); }
 
-  const child = spawn(pi, ["--mode", "rpc", "-e", extension, ...args], {
-    cwd: process.cwd(), env: { ...process.env, PI_WEBAPP_AUTO_OPEN: "0" }, stdio: ["pipe", "pipe", "pipe"],
+  const pluginRoots = (process.env.PI_WEBAPP_PLUGIN_DEV_ROOTS ?? "").split(delimiter).filter(Boolean).map((root) => resolve(root));
+  const child = spawn(pi, ["--mode", "rpc", "-e", extension, ...pluginRoots.flatMap((root) => ["-e", root]), ...args], {
+    cwd: process.cwd(), env: { ...process.env, PI_WEBAPP_AUTO_OPEN: "0", PI_WEBAPP_LAUNCHER_NONCE: nonce }, stdio: ["pipe", "pipe", "pipe"],
   });
   child.stderr?.pipe(process.stderr, { end: false });
   let ready = false;
@@ -121,8 +124,14 @@ async function serve(pi, args) {
   let closed = false;
   let stateWrite = Promise.resolve();
   let stopping = false;
+  let restartRequest = null;
+  let runningUrl = null;
   let buffer = "";
   let killTimer;
+  const devWatchers = [];
+  let devReloadTimer;
+  let devReloadCount = 0;
+  let devReloadCommand;
   const shutdown = () => {
     if (stopping) return;
     stopping = true;
@@ -140,11 +149,20 @@ async function serve(pi, args) {
   const stopTimer = setInterval(async () => {
     try { if ((await readFile(stopPath, "utf8")).trim() === nonce) shutdown(); }
     catch { /* No stop request. */ }
+    if (stopping) return;
+    try {
+      const request = JSON.parse(await readFile(restartPath, "utf8"));
+      const prepared = JSON.parse(await readFile(updatePath, "utf8"));
+      if (request.nonce === nonce && request.launcher === prepared.launcher && existsSync(request.launcher)) {
+        restartRequest = request;
+        shutdown();
+      }
+    } catch { /* No valid restart request. */ }
   }, 400);
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
   child.stdout?.on("data", (chunk) => {
-    if (ready || opening || failed) return;
+    if (failed) return;
     buffer += chunk.toString("utf8");
     if (buffer.length > 8 * 1024 * 1024) { fail("Pi RPC 输出超出预期大小"); return; }
     for (let index; (index = buffer.indexOf("\n")) !== -1;) {
@@ -152,6 +170,11 @@ async function serve(pi, args) {
       buffer = buffer.slice(index + 1);
       let record;
       try { record = JSON.parse(line); } catch { continue; }
+      if (record?.type === "response" && /^dev-reload-\d+$/.test(record.id ?? "")) {
+        console.error(`pi-webapp: ${record.id} /${devReloadCommand ?? "web-dev-reload"}: ${record.success === true ? "reloaded" : `failed: ${record.error ?? "Unknown RPC error"}`}`);
+        continue;
+      }
+      if (ready || opening) continue;
       if (record?.type === "response" && record.id === "list-commands") {
         if (record.success !== true || !Array.isArray(record.data?.commands)) {
           fail("无法读取 Pi 扩展命令列表");
@@ -163,6 +186,8 @@ async function serve(pi, args) {
           fail("Pi 没有加载当前项目的 Web 扩展");
           return;
         }
+        devReloadCommand = record.data.commands.find((item) => item?.source === "extension"
+          && item.sourceInfo?.path === extension && /^web-dev-reload(?::\d+)?$/.test(item.name))?.name;
         child.stdin?.write(JSON.stringify({ id: "open-web", type: "prompt", message: `/${command.name}` }) + "\n");
         continue;
       }
@@ -175,6 +200,7 @@ async function serve(pi, args) {
       try { url = new URL(record.message.slice("pi-webapp: ".length)); }
       catch { continue; }
       if (url.hostname !== "127.0.0.1" || !url.hash) continue;
+      runningUrl = url.href;
       opening = true;
       stateWrite = saveState({ pid: process.pid, piPid: child.pid, nonce, cwd: process.cwd(), url: url.href })
         .then(() => {
@@ -182,6 +208,19 @@ async function serve(pi, args) {
           ready = true;
           clearTimeout(startupTimer);
           notifyParent({ type: "ready", pid: process.pid, url: url.href });
+          for (const root of pluginRoots) {
+            try {
+              devWatchers.push(watch(join(root, "dist"), (_event, file) => {
+                if (String(file ?? "") !== "extension.js") return;
+                clearTimeout(devReloadTimer);
+                devReloadTimer = setTimeout(() => {
+                  if (closed || stopping) return;
+                  if (!devReloadCommand) { console.error("pi-webapp: development reload unavailable: local extension command not found"); return; }
+                  child.stdin?.write(JSON.stringify({ id: `dev-reload-${++devReloadCount}`, type: "prompt", message: `/${devReloadCommand}` }) + "\n");
+                }, 250);
+              }));
+            } catch (error) { console.error(`pi-webapp: cannot watch plugin ${root}: ${error}`); }
+          }
         })
         .catch((error) => fail(`无法保存启动状态：${error.message}`));
       return;
@@ -199,6 +238,8 @@ async function serve(pi, args) {
   });
   await stateWrite;
   clearTimeout(startupTimer);
+  clearTimeout(devReloadTimer);
+  for (const watcher of devWatchers) watcher.close();
   clearInterval(stopTimer);
   clearTimeout(killTimer);
   try { if ((await readFile(stopPath, "utf8")).trim() === nonce) await unlink(stopPath); } catch { /* Already removed. */ }
@@ -206,6 +247,42 @@ async function serve(pi, args) {
     try { if (JSON.parse(await readFile(statePath, "utf8")).nonce === nonce) await unlink(statePath); }
     catch { /* Already removed. */ }
   }
+  if (restartRequest && runningUrl) {
+    await unlink(restartPath).catch(() => {});
+    const oldUrl = new URL(runningUrl);
+    const fd = openSync(logPath, "a", 0o600);
+    const restartEnv = { ...process.env, PI_WEBAPP_AUTO_OPEN: "0", PI_WEBAPP_RESTART_PORT: oldUrl.port, PI_WEBAPP_RESTART_TOKEN: oldUrl.hash.slice(1) };
+    try {
+      const runLauncher = (path) => new Promise((resolveExit) => {
+        const next = spawnNode(process.execPath, [path, "start", ...args], { cwd: process.cwd(), env: restartEnv, stdio: ["ignore", fd, fd] });
+        next.once("error", () => resolveExit(1));
+        next.once("exit", (code) => resolveExit(code ?? 1));
+      });
+      if (await runLauncher(restartRequest.launcher) !== 0) {
+        await clearManagedLauncher(restartRequest.launcher);
+        console.error("pi-webapp: 新版启动失败，正在恢复旧版服务");
+        if (await runLauncher(launcher) !== 0) console.error(`pi-webapp: 旧版恢复失败。日志：${logPath}`);
+      }
+    } finally { closeSync(fd); }
+  }
+}
+
+async function clearManagedLauncher(path) {
+  try {
+    if (JSON.parse(await readFile(updatePath, "utf8")).launcher === path) await unlink(updatePath);
+  } catch { /* No matching managed release. */ }
+}
+
+async function managedLauncher() {
+  try {
+    if (existsSync(fileURLToPath(new URL("../.git", import.meta.url)))) return null;
+    const update = JSON.parse(await readFile(updatePath, "utf8"));
+    const current = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+    if (!/^\d+\.\d+\.\d+$/.test(update.version) || !/^\d+\.\d+\.\d+$/.test(current.version)) return null;
+    if (!compatible(versionParts(update.version), versionParts(current.version))) return null;
+    if (update.version === current.version || !existsSync(update.launcher)) return null;
+    return update.launcher;
+  } catch { return null; }
 }
 
 async function start(args) {
@@ -215,6 +292,17 @@ async function start(args) {
     if (existing.url) await openPageIfLocal(existing.url);
     return;
   }
+  const managed = await managedLauncher();
+  if (managed) {
+    const next = spawnNode(process.execPath, [managed, "start", ...args], { cwd: process.cwd(), env: process.env, stdio: "inherit" });
+    const code = await new Promise((resolveExit, rejectExit) => { next.once("error", rejectExit); next.once("exit", (status) => resolveExit(status)); });
+    if (code !== 0) {
+      await clearManagedLauncher(managed);
+      console.error(`pi-webapp: 新版启动失败（代码 ${code ?? "未知"}），正在恢复当前安装`);
+      await start(args);
+    }
+    return;
+  }
   const nodeVersion = versionParts(process.versions.node);
   if (!nodeVersion || !compatible(nodeVersion, [22, 19, 0])) throw new Error("需要 Node.js 22.19 或更新版本。");
   if (!existsSync(extension)) throw new Error("找不到构建后的扩展。请先运行 npm run build。");