npm - cicy-desktop - Versions diffs - 2.1.64 → 2.1.66 - Mend

cicy-desktop 2.1.64 → 2.1.66

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/package.json +1 -1
package/src/backends/homepage-preload.js +7 -0
package/src/backends/homepage-react/assets/{index-BV0z4aaf.css → index-ByYzSssW.css} +1 -1
package/src/backends/homepage-react/assets/index-DHvg4jSd.js +49 -0
package/src/backends/homepage-react/index.html +2 -2
package/src/backends/local-teams.js +16 -1
package/src/backends/sidecar-ipc.js +8 -4
package/src/sidecar/cicy-code.js +41 -8
package/src/sidecar/docker.js +19 -2
package/src/sidecar/native.js +207 -0
package/workers/render/src/App.css +18 -0
package/workers/render/src/App.jsx +31 -4
package/src/backends/homepage-react/assets/index-C0vFqx44.js +0 -49

package/src/backends/homepage-react/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>CiCy Desktop</title>
-  <script type="module" crossorigin src="./assets/index-C0vFqx44.js"></script>
-  <link rel="stylesheet" crossorigin href="./assets/index-BV0z4aaf.css">
+  <script type="module" crossorigin src="./assets/index-DHvg4jSd.js"></script>
+  <link rel="stylesheet" crossorigin href="./assets/index-ByYzSssW.css">
 </head>
 <body>
   <div id="root"></div>

package/src/backends/local-teams.js CHANGED Viewed

@@ -180,7 +180,7 @@ async function list({ refresh = false } = {}) {
 // dom-ready electronRPC injection — bare `new BrowserWindow` strips
 // the SPA of every desktop tool, which was the regression in the
 // previous implementation.
-function openTeam(id) {
+async function openTeam(id) {
   const node = readNodes()[id];
   if (!node) return { ok: false, error: "team not found" };
   const baseUrl = (node.base_url || "").replace(/\/$/, "");
@@ -201,6 +201,21 @@ function openTeam(id) {
     try { if (existing.isMinimized()) existing.restore(); } catch {}
     try { existing.show(); } catch {}
     try { existing.focus(); } catch {}
+    // A reused window can be STUCK at the login screen (its original load
+    // had a stale/absent token, e.g. after a token rotation) — focusing it
+    // would loop the user at login forever. If the page holds no token,
+    // re-navigate with the current ?token= so the SPA can consume it. An
+    // authenticated workspace (token present) is left untouched.
+    if (token) {
+      try {
+        const hasTok = await existing.webContents.executeJavaScript(
+          "!!localStorage.getItem('api_token')", true);
+        if (!hasTok) {
+          log.info(`[local-teams] open ${id} → reused win.id=${existing.id} had no token, re-navigating`);
+          existing.loadURL(url);
+        }
+      } catch { /* page not ready / JS blocked — leave as-is */ }
+    }
     log.info(`[local-teams] open ${id} → reused win.id=${existing.id}`);
     return { ok: true, windowId: existing.id, reused: true };
   }

package/src/backends/sidecar-ipc.js CHANGED Viewed

@@ -116,16 +116,20 @@ function register({ sidecarLogPath } = {}) {
   // Update: stop + spawn cicy-code@latest (or reload the Docker image on
   // win32). The npx re-resolve / image pull can take a while on a cold cache,
   // so allow a longer window for :8008 to come back.
-  ipcMain.handle("sidecar:update", async () => {
+  ipcMain.handle("sidecar:update", async (e) => {
+    // Stream phase/progress events to the homepage so the user SEES the
+    // update working (download %, swap, restart) instead of a frozen label.
+    const emit = (ev) => { try { e.sender.send("sidecar:op-progress", { op: "update", ...ev }); } catch {} };
     try {
-      const child = await sidecar.update({ logPath: sidecarLogPath });
+      const child = await sidecar.update({ logPath: sidecarLogPath, port: PORT, emit });
       for (let i = 0; i < 240; i++) {
         if (await sidecar.probeExisting(PORT)) return { ok: true, pid: child?.pid || null };
         await new Promise((r) => setTimeout(r, 250));
       }
       return { ok: true, pid: child?.pid || null, warning: "updated but did not bind :8008 within 60s" };
-    } catch (e) {
-      return { ok: false, error: e.message };
+    } catch (err) {
+      emit({ phase: "done", status: "error", message: `更新失败：${err.message}` });
+      return { ok: false, error: err.message };
     }
   });
 }

package/src/sidecar/cicy-code.js CHANGED Viewed

@@ -46,9 +46,26 @@ async function start({ logPath, port = DEFAULT_PORT, force = false, version = nu
   }
   if (process.platform === "win32") {
-    // Windows runs cicy-code in Docker Desktop (the container's entrypoint
-    // npx-installs cicy-code). The docker module owns image-load-from-R2 +
-    // container run; here we just delegate. (Replaced the old WSL path.)
+    // NATIVE route (2026-06 方向): cicy-code.exe + bundled slim MSYS2, no
+    // Docker/WSL. Gated behind CICY_WIN_NATIVE=1 while in 联调; the Docker
+    // container route below remains the transitional default until native
+    // ships.
+    if (process.env.CICY_WIN_NATIVE === "1") {
+      try {
+        const native = require("./native");
+        const r = await native.start({ port, logPath });
+        if (!r) { console.warn("[cicy-code-sidecar] native start failed"); return null; }
+        child = r; // { native:true, pid|adopted, port }
+        console.log(`[cicy-code-sidecar] started native exe (${r.adopted ? "adopted" : `pid=${r.pid}`}) on :${port}`);
+        return child;
+      } catch (e) {
+        console.warn(`[cicy-code-sidecar] native start failed: ${e.message}`);
+        return null;
+      }
+    }
+    // Transitional: Windows runs cicy-code in Docker Desktop (the container's
+    // entrypoint npx-installs cicy-code). The docker module owns
+    // image-load-from-R2 + container run; here we just delegate.
     try {
       const docker = require("./docker");
       const r = await docker.start({ port });
@@ -138,7 +155,8 @@ async function killPortListeners(port = DEFAULT_PORT, timeoutMs = 5000) {
 }
 async function stop({ timeoutMs = 5000, port = DEFAULT_PORT } = {}) {
-  // 1) The child we spawned this session (npx) or the Docker container.
+  // 1) The child we spawned this session (npx), the Docker container, or the
+  // native exe.
   if (child) {
     const p = child;
     child = null;
@@ -146,6 +164,10 @@ async function stop({ timeoutMs = 5000, port = DEFAULT_PORT } = {}) {
       try { await require("./docker").stop(); } catch {}
       return;
     }
+    if (p.native) {
+      try { await require("./native").stop({ port }); } catch {}
+      return;
+    }
     try { p.kill("SIGTERM"); } catch {}
     const t0 = Date.now();
     while (p.exitCode === null && Date.now() - t0 < timeoutMs) {
@@ -197,17 +219,28 @@ async function restart({ logPath, port = DEFAULT_PORT } = {}) {
 //   win32  → reload the Docker image (from R2) and re-run the container.
 //   else   → clear the npx cache + spawn `cicy-code@latest` so npx re-resolves
 //            against the registry (npmmirror for CN) and pulls a newer build.
-async function update({ logPath, port = DEFAULT_PORT } = {}) {
-  await stop({ port });
+async function update({ logPath, port = DEFAULT_PORT, emit } = {}) {
+  const e = emit || (() => {});
   if (process.platform === "win32") {
-    try { await require("./docker").loadImage(); } catch (e) {
-      console.warn(`[cicy-code-sidecar] docker image reload failed: ${e.message}`);
+    // NATIVE route: safe-swap update with real download progress.
+    if (process.env.CICY_WIN_NATIVE === "1") {
+      return require("./native").update({ port, logPath, emit });
+    }
+    // Transitional Docker route. loadImage streams 下载镜像 % via emit.
+    await stop({ port });
+    try { await require("./docker").loadImage({ emit }); } catch (err) {
+      console.warn(`[cicy-code-sidecar] docker image reload failed: ${err.message}`);
+      e({ phase: "download", status: "error", message: `镜像更新失败：${err.message}` });
     }
     await new Promise(r => setTimeout(r, 300));
+    e({ phase: "swap", status: "running", message: "重启容器…" });
     return start({ logPath, port, force: true });
   }
+  e({ phase: "download", status: "running", message: "获取最新版 cicy-code…" });
+  await stop({ port });
   clearNpxCache();
   await new Promise(r => setTimeout(r, 300));
+  e({ phase: "swap", status: "running", message: "启动新版本…" });
   return start({ logPath, port, force: true, version: "latest" });
 }

package/src/sidecar/docker.js CHANGED Viewed

@@ -166,7 +166,7 @@ async function ensureDownloaded(url, dest, mirror, { emit, phase, label } = {})
   }
   const sources = mirror ? [url, mirror] : [url];
   let lastPct = -1; // throttle: chunks arrive dozens/s — only emit on whole-percent change
-  return withRetry(async (attempt) => {
+  const attempted = withRetry(async (attempt) => {
     const src = sources[Math.min(attempt - 1, sources.length - 1)];
     await download(src, dest, {
       resume: true,
@@ -187,6 +187,18 @@ async function ensureDownloaded(url, dest, mirror, { emit, phase, label } = {})
     onAttempt: ({ attempt, tries, error }) =>
       emit && emit({ phase, status: "retry", message: `${label}：重试 (${attempt}/${tries})`, error }),
   });
+  return attempted.catch((e) => {
+    // Offline fallback: the network (and HEAD) may be dead while a complete
+    // file from an earlier run sits on disk — use it instead of dying. Only
+    // when we CAN'T prove it incomplete (no expected size, or sizes match).
+    let have = 0; try { have = fs.statSync(dest).size; } catch {}
+    if (have > 0 && (expected === 0 || have === expected)) {
+      console.warn(`[docker-sidecar] download failed (${e.message}) — using existing ${dest} (${have}B, unverified)`);
+      emit && emit({ phase, status: "skip", message: `${label}：网络不可达，使用本地已有文件`, progress: 100 });
+      return dest;
+    }
+    throw e;
+  });
 }
 // The container's cicy-code mints its own api_token in its volume-persisted
@@ -372,4 +384,9 @@ async function bootstrap({ onProgress, port = 8008 } = {}) {
   return { ok: healthy, container: CONTAINER };
 }
-module.exports = { start, stop, checkStatus, loadImage, imagePresent, dockerOk, installDocker, bootstrap, probeHealth, readContainerToken };
+module.exports = {
+  start, stop, checkStatus, loadImage, imagePresent, dockerOk, installDocker,
+  bootstrap, probeHealth, readContainerToken,
+  // platform-agnostic download/retry primitives, reused by native.js
+  ensureDownloaded, withRetry, waitUntil, run,
+};

package/src/sidecar/native.js ADDED Viewed

@@ -0,0 +1,207 @@
+// Windows NATIVE sidecar backend: run cicy-code.exe directly — no Docker, no
+// WSL. (2026-06 方向变更: the Docker route in docker.js is transitional and
+// being retired; this module replaces it once stable.)
+//
+// The exe is a native Go build (w-10084's line). It shells out to a slim
+// bundled MSYS2 (bash/tmux/coreutils…) which it locates itself via
+// CICY_MSYS_ROOT probing — nothing to do here beyond optionally passing the
+// env through. Known exe-side behaviors we rely on:
+//   - reads PORT / CICY_CODE_PORT for the listen port
+//   - missing optional deps degrade to warnings (never os.Exit)
+//   - cold tmux-server start may need ConPTY (w-10084's ensureTmuxServer, WIP)
+//
+// Gate: cicy-code.js picks this module over docker.js when
+// CICY_WIN_NATIVE === "1" (dev flag until the native route ships by default).
+const { spawn, execFile } = require("child_process");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const docker = require("./docker"); // ensureDownloaded/withRetry/waitUntil/probeHealth/run
+// Exe acquisition (主人指令 2026-06-07): the PRODUCT path is npm — the
+// cicy-code-win32-x64 subpackage (optionalDependency of cicy-code, os/cpu
+// pinned) carries cicy-code.exe, installed via npmmirror with npm's own
+// caching/resume/version management. NO R2 download in product. The R2
+// direct-pull below survives ONLY for w-10084↔w-10026 联调, gated on an
+// explicitly set CICY_CODE_EXE_URL.
+// dev/联调 only — read LAZILY (not at require time) so tests/tools can set the
+// env var after loading the module.
+const devExeUrl = () => process.env.CICY_CODE_EXE_URL || "";
+const EXE_PKG  = process.env.CICY_CODE_EXE_PKG || "cicy-code-win32-x64";
+const REGISTRY = process.env.CICY_NPM_REGISTRY || "https://registry.npmmirror.com";
+const BIN_DIR  = path.join(os.homedir(), "cicy-ai", "bin");
+// npm prefix dir owned by the sidecar (isolated from the user's global npm).
+const NPM_PREFIX = path.join(os.homedir(), "cicy-ai", "sidecar-npm");
+const DEV_EXE_PATH = process.env.CICY_CODE_EXE_PATH || path.join(BIN_DIR, "cicy-code.exe");
+const PID_FILE = path.join(BIN_DIR, "cicy-code.pid");
+function npmExePath() {
+  return path.join(NPM_PREFIX, "node_modules", EXE_PKG, "cicy-code.exe");
+}
+const probeHealth = docker.probeHealth;
+// Acquire (or reuse) the exe.
+//   PRODUCT: npm-install the win32 subpackage into the sidecar's own prefix
+//   and resolve the exe inside it — npm brings caching/integrity/versioning,
+//   npmmirror keeps CN viable. `version` ("latest" from update()) re-resolves.
+//   DEV (联调 only): CICY_CODE_EXE_URL set → resumable R2 download.
+async function ensureExe({ emit, version = null } = {}) {
+  if (devExeUrl()) {
+    fs.mkdirSync(BIN_DIR, { recursive: true });
+    await docker.ensureDownloaded(devExeUrl(), DEV_EXE_PATH, null, {
+      emit, phase: "exe", label: "下载 cicy-code.exe (dev)",
+    });
+    return DEV_EXE_PATH;
+  }
+  const exe = npmExePath();
+  if (!version && fs.existsSync(exe)) return exe;
+  const e = emit || (() => {});
+  e({ phase: "exe", status: "running", message: "npm 安装 cicy-code (win32)…" });
+  fs.mkdirSync(NPM_PREFIX, { recursive: true });
+  const spec = `${EXE_PKG}@${version || "latest"}`;
+  // npm on Windows is npm.cmd — Node ≥18 (CVE-2024-27980) refuses to spawn
+  // .cmd/.bat without shell:true (spawn EINVAL). shell:true concatenates args
+  // un-escaped, so quote the one arg that can contain spaces (user dir).
+  const quotedPrefix = /\s/.test(NPM_PREFIX) ? `"${NPM_PREFIX}"` : NPM_PREFIX;
+  await new Promise((resolve, reject) => {
+    execFile("npm", ["i", spec, "--prefix", quotedPrefix, `--registry=${REGISTRY}`, "--no-audit", "--no-fund", "--loglevel=error"],
+      { windowsHide: true, timeout: 600000, shell: true },
+      (err, _o, stderr) => err ? reject(new Error(`npm i ${spec}: ${String(stderr).slice(0, 200)}`)) : resolve());
+  });
+  if (!fs.existsSync(exe)) throw new Error(`installed ${spec} but ${exe} missing`);
+  e({ phase: "exe", status: "done", message: "cicy-code.exe 就绪" });
+  return exe;
+}
+// One-time migration off the Docker route: the legacy containers (`cicy` from
+// the old flow, `cicy-code` from docker.js) hold :8008 and `--restart
+// unless-stopped` revives them on every daemon start — rm -f BOTH or the port
+// is never free. Best-effort: no Docker installed → nothing to clear.
+async function clearDockerLegacy() {
+  for (const name of ["cicy", "cicy-code"]) {
+    try { await docker.run(["rm", "-f", name], { timeout: 20000 }); console.log(`[native-sidecar] removed legacy container ${name}`); }
+    catch { /* absent or no docker — fine */ }
+  }
+}
+function readPid() {
+  try { return Number(fs.readFileSync(PID_FILE, "utf8").trim()) || 0; } catch { return 0; }
+}
+function pidAlive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+// PIDs listening on :port via netstat (Windows has no lsof).
+function listPortPids(port) {
+  return new Promise((resolve) => {
+    execFile("netstat", ["-ano", "-p", "TCP"], { windowsHide: true, timeout: 15000 }, (err, stdout) => {
+      if (err) return resolve([]);
+      const pids = new Set();
+      for (const line of String(stdout).split(/\r?\n/)) {
+        if (line.includes(`:${port} `) && /LISTENING/i.test(line)) {
+          const pid = Number(line.trim().split(/\s+/).pop());
+          if (pid) pids.add(pid);
+        }
+      }
+      resolve([...pids]);
+    });
+  });
+}
+function taskkill(pid) {
+  return new Promise((resolve) => {
+    execFile("taskkill", ["/f", "/t", "/pid", String(pid)], { windowsHide: true, timeout: 15000 }, () => resolve());
+  });
+}
+// Start cicy-code.exe on :port. Adopts an already-healthy instance. When
+// taking the canonical :8008, clears the legacy Docker containers first so
+// they can't fight for the bind.
+async function start({ port = 8008, logPath = null, emit, version = null } = {}) {
+  if (await probeHealth(port)) {
+    console.log(`[native-sidecar] :${port} already healthy — adopting`);
+    return { native: true, adopted: true, port };
+  }
+  const exe = await ensureExe({ emit, version });
+  if (port === 8008) await clearDockerLegacy();
+  let stdio = ["ignore", "ignore", "ignore"];
+  if (logPath) {
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    const fd = fs.openSync(logPath, "a");
+    stdio = ["ignore", fd, fd];
+  }
+  const env = {
+    ...process.env,
+    PORT: String(port),
+    CICY_CODE_PORT: String(port),
+  };
+  const child = spawn(exe, [], { stdio, detached: true, windowsHide: true, env });
+  child.unref();
+  try { fs.writeFileSync(PID_FILE, String(child.pid)); } catch {}
+  console.log(`[native-sidecar] spawned ${exe} pid=${child.pid} port=${port} log=${logPath || "(none)"}`);
+  const up = await docker.waitUntil(() => probeHealth(port), { totalMs: 60000, everyMs: 2000 });
+  if (!up) {
+    console.warn(`[native-sidecar] :${port} not healthy after 60s (exe may still be warming up)`);
+    return null;
+  }
+  return { native: true, pid: child.pid, port };
+}
+// Stop whatever serves :port — pidfile first, then netstat by port.
+async function stop({ port = 8008 } = {}) {
+  const pid = readPid();
+  if (pidAlive(pid)) await taskkill(pid);
+  for (const p of await listPortPids(port)) await taskkill(p);
+  try { fs.unlinkSync(PID_FILE); } catch {}
+}
+async function restart({ port = 8008, logPath = null } = {}) {
+  await stop({ port });
+  await new Promise((r) => setTimeout(r, 1000));
+  return start({ port, logPath });
+}
+// Update — SAFE swap order: acquire the new build FIRST (progress streamed),
+// only then stop the running instance and switch. A dead network therefore
+// fails the update loudly but never kills a working install. Dev route
+// downloads to .new and renames; npm route re-resolves @latest in place
+// (npm's own staging is already atomic).
+async function update({ port = 8008, logPath = null, emit } = {}) {
+  const e = emit || (() => {});
+  if (devExeUrl()) {
+    const tmp = DEV_EXE_PATH + ".new";
+    try { fs.unlinkSync(tmp); } catch {}
+    e({ phase: "download", status: "running", message: "下载新版 cicy-code.exe…", progress: 0 });
+    await docker.ensureDownloaded(devExeUrl(), tmp, null, { emit, phase: "download", label: "下载新版" });
+    if (!fs.existsSync(tmp)) throw new Error("下载未完成，保留当前版本");
+    e({ phase: "swap", status: "running", message: "停止旧版本…" });
+    await stop({ port });
+    try { fs.unlinkSync(DEV_EXE_PATH + ".bak"); } catch {}
+    try { fs.renameSync(DEV_EXE_PATH, DEV_EXE_PATH + ".bak"); } catch {}
+    fs.renameSync(tmp, DEV_EXE_PATH);
+  } else {
+    e({ phase: "download", status: "running", message: "npm 获取最新版…" });
+    await ensureExe({ emit, version: "latest" }); // service untouched until this succeeds
+    e({ phase: "swap", status: "running", message: "重启服务…" });
+    await stop({ port });
+  }
+  const r = await start({ port, logPath, emit });
+  e({ phase: "done", status: r ? "done" : "error", message: r ? "已更新并重启" : "更新后启动失败" });
+  return r;
+}
+async function checkStatus({ port = 8008 } = {}) {
+  return {
+    exePresent: fs.existsSync(devExeUrl() ? DEV_EXE_PATH : npmExePath()),
+    running: await probeHealth(port),
+    pid: readPid() || null,
+  };
+}
+module.exports = { start, stop, restart, update, checkStatus, ensureExe, clearDockerLegacy, probeHealth, npmExePath };

package/workers/render/src/App.css CHANGED Viewed

@@ -733,3 +733,21 @@ body {
   font-size: 11.5px; color: #9ca3af;
   word-break: break-word;
 }
+/* live op progress on the local team card (更新 download %/phase stream) */
+.bcard__prog {
+  display: flex; flex-direction: column; gap: 4px;
+  margin-top: 6px; font-size: 12px; line-height: 1.35;
+  color: var(--text-dim, #9da7b3);
+}
+.bcard__prog[data-status="error"] .bcard__progmsg { color: #f87171; }
+.bcard__prog[data-status="done"] .bcard__progmsg { color: #4ade80; }
+.bcard__progbar {
+  display: block; height: 4px; border-radius: 2px;
+  background: rgba(125, 135, 150, 0.25); overflow: hidden;
+}
+.bcard__progbar > span {
+  display: block; height: 100%; border-radius: 2px;
+  background: var(--accent, #3b82f6);
+  transition: width 0.25s ease;
+}

package/workers/render/src/App.jsx CHANGED Viewed

@@ -543,6 +543,7 @@ function LocalTeamCard({ team, onOpen, onRename, onRefresh }) {
   const running = team.status === "running";
   const [busy, setBusy] = useState("");   // "" | start | restart | update | stop
   const [opMsg, setOpMsg] = useState("");
+  const [opProg, setOpProg] = useState(null); // live {message, progress?, status} during 更新
   const [menuOpen, setMenuOpen] = useState(false);
   const [latest, setLatest] = useState(null); // newest cicy-code on the registry
   const [checking, setChecking] = useState(false);
@@ -610,7 +611,15 @@ function LocalTeamCard({ team, onOpen, onRename, onRefresh }) {
   const runOp = async (kind, fn, doneText) => {
     setMenuOpen(false);
     if (busy) return;
-    setBusy(kind); setOpMsg("");
+    setBusy(kind); setOpMsg(""); setOpProg(null);
+    // 更新 streams real phase/percent events from the main process — surface
+    // them live on the card so the user SEES the download/swap happening.
+    let unsub = null;
+    if (kind === "update" && window.cicy?.sidecar?.onOpProgress) {
+      unsub = window.cicy.sidecar.onOpProgress((ev) => {
+        if (ev?.op === "update") setOpProg(ev);
+      });
+    }
     try {
       const r = await fn();
       setOpMsg(r?.ok
@@ -619,8 +628,10 @@ function LocalTeamCard({ team, onOpen, onRename, onRefresh }) {
     } catch (err) {
       setOpMsg(tr("sidecar.failed", "操作失败") + `: ${err?.message || err}`);
     } finally {
-      setBusy("");
+      try { unsub && unsub(); } catch {}
+      setBusy(""); setOpProg(null);
       onRefresh?.(); // re-probe so the status dot/chip catches up
+      setTimeout(() => setOpMsg(""), 5000); // result line is transient
     }
   };
   const BUSY_LABEL = { start: "启动中…", restart: "重启中…", update: "更新中…", stop: "停止中…" };
@@ -771,6 +782,22 @@ function LocalTeamCard({ team, onOpen, onRename, onRefresh }) {
             <span className="bcard__ver" data-id="LocalTeamCard-version">v{team.version}</span>
           )}
         </div>
+        {busy && (
+          <div className="bcard__prog" data-id="LocalTeamCard-progress" data-status={opProg?.status || "running"}>
+            <span className="bcard__progmsg">
+              {opProg?.message || BUSY_LABEL[busy] || `${busy}…`}
+              {Number.isFinite(opProg?.progress) ? ` ${opProg.progress}%` : ""}
+            </span>
+            {Number.isFinite(opProg?.progress) && (
+              <span className="bcard__progbar"><span style={{ width: `${Math.min(100, opProg.progress)}%` }} /></span>
+            )}
+          </div>
+        )}
+        {!busy && opMsg && (
+          <div className="bcard__prog" data-id="LocalTeamCard-progress" data-status={/失败|error/i.test(opMsg) ? "error" : "done"}>
+            <span className="bcard__progmsg">{opMsg}</span>
+          </div>
+        )}
       </div>
       <button
         type="button"
@@ -779,8 +806,8 @@ function LocalTeamCard({ team, onOpen, onRename, onRefresh }) {
         disabled={!!busy || !team.base_url}
         onClick={handleOpen}
       >
-        {busy === "start" ? <Spinner /> : <ArrowIcon />}
-        <span>{openLabel}</span>
+        {busy && busy !== "stop" ? <Spinner /> : <ArrowIcon />}
+        <span>{busy ? (BUSY_LABEL[busy] || openLabel) : openLabel}</span>
       </button>
     </div>
   );