cicy-desktop 2.1.121 → 2.1.123

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cicy-desktop",
-  "version": "2.1.121",
+  "version": "2.1.123",
   "description": "CiCy - AI-powered operating system browser",
   "main": "src/main.js",
   "bin": {
@@ -135,11 +135,11 @@
   "//optionalDependencies": "Runtime Bundle v1 (主人指令): platform binaries delivered by `npm i -g cicy-desktop` itself — npm installs only the current-platform subpackage (os/cpu pinned in each), so first start seeds the runtime store with ZERO network, ZERO npx. Windows packages are named *-windows-* (npm spam filter 403s new names containing win32). cicy-msys2 added once published.",
   "optionalDependencies": {
     "electron": "41.0.3",
-    "cicy-code-darwin-x64": "2.3.19",
-    "cicy-code-darwin-arm64": "2.3.19",
-    "cicy-code-linux-x64": "2.3.19",
-    "cicy-code-linux-arm64": "2.3.19",
-    "cicy-code-windows-x64": "2.3.19",
+    "cicy-code-darwin-x64": "2.3.20",
+    "cicy-code-darwin-arm64": "2.3.20",
+    "cicy-code-linux-x64": "2.3.20",
+    "cicy-code-linux-arm64": "2.3.20",
+    "cicy-code-windows-x64": "2.3.20",
     "cicy-mihomo-darwin-x64": "1.10.4",
     "cicy-mihomo-darwin-arm64": "1.10.4",
     "cicy-mihomo-linux-x64": "1.10.4",

package/src/backends/local-teams.js

@@ -562,6 +562,19 @@ async function addTeam(spec) {
     : slugifyId(spec.id || baseUrlKey || (port ? `local-${port}` : "local"));
   if (!id) return { ok: false, error: "could not derive id" };
 
+  // The Docker app node MUST self-identify as is_docker AT CREATION — atomically,
+  // in the SAME writeNodes as the node itself — not in a later updateTeam. Reason:
+  // addTeam fires syncNameToCloud(id) below (fire-and-forget). If is_docker isn't
+  // already on the node, that first sync sees a plain local team, device-registers
+  // it, and the cloud hands back THIS DEVICE's shared team (= the 8008 team) — so
+  // :8009 and :8008 end up on one cloud_team_id and renaming one renames both
+  // ("串名"). Marking is_docker here (explicit spec OR by the docker app port, which
+  // doesn't depend on the caller setting a flag) closes that window for ALL creation
+  // paths (sidecar registerAppTeam, a cloud deeplink, a manual add). cloud_team_id
+  // (the node's OWN independent team) is written the same atomic way when known.
+  const DOCKER_PORT = String(process.env.CICY_DOCKER_APP_PORT || 8009);
+  const isDockerNode = !!spec.is_docker || (port != null && String(port) === DOCKER_PORT);
+
   const now = new Date().toISOString();
   const patch = {
     name:           spec.name           !== undefined ? String(spec.name || unnamedName()) : undefined,
@@ -574,6 +587,11 @@ async function addTeam(spec) {
     install_path:   spec.install_path   ?? undefined,
     container_name: spec.container_name ?? undefined,
     image:          spec.image          ?? undefined,
+    // is_docker: only ever set TRUE (never flip an existing node to false).
+    is_docker:      isDockerNode ? true : undefined,
+    // cloud_team_id: set only when the caller passes a real id — a falsy value is
+    // dropped so we never clobber an already-correct independent team with null.
+    cloud_team_id:  spec.cloud_team_id ? spec.cloud_team_id : undefined,
   };
   // Drop undefined keys so we never overwrite existing fields with null.
   Object.keys(patch).forEach(k => patch[k] === undefined && delete patch[k]);

package/src/backends/sidecar-ipc.js

@@ -203,9 +203,20 @@ function register({ sidecarLogPath } = {}) {
     const lt = require("./local-teams");
     await ensureDockerTeam(); // 确保独立云端 team 存在 + 拿到 teamId/title
     const title = (dockerTeamReg && dockerTeamReg.title) || "Docker 团队";
-    const r = await lt.addTeam({ base_url: `http://127.0.0.1:${APP_PORT}`, name: title, skipTokenAutofill: true });
-    // 把 docker 独立 team 的 cloud_team_id 写到这个本地节点(DockerCard 据此账单 + 改名),
-    // 并标记 is_docker(syncNameToCloud 跳过它,不被本机 deviceId 复用回 8008)。
+    // is_docker + cloud_team_id are passed INTO addTeam so they land in the SAME
+    // writeNodes as the node — before addTeam's fire-and-forget syncNameToCloud
+    // runs. That's what stops the freshly-created :8009 node from device-registering
+    // into THIS device's shared (8008) team and 串名. (addTeam also self-detects
+    // is_docker by the :8009 port, so this is belt-and-suspenders.)
+    const r = await lt.addTeam({
+      base_url: `http://127.0.0.1:${APP_PORT}`,
+      name: title,
+      skipTokenAutofill: true,
+      is_docker: true,
+      cloud_team_id: (dockerTeamReg && dockerTeamReg.teamId) || undefined,
+    });
+    // Belt: re-affirm on the persisted node (no-op when addTeam already set them;
+    // also late-binds cloud_team_id if ensureDockerTeam minted the team just now).
     if (r && r.id) {
       try { await lt.updateTeam(r.id, { is_docker: true, ...(dockerTeamReg && dockerTeamReg.teamId ? { cloud_team_id: dockerTeamReg.teamId } : {}) }); } catch {}
     }

package/src/sidecar/wsl-docker.js

@@ -16,6 +16,7 @@ const path = require("path");
 const os = require("os");
 const fs = require("fs");
 const docker = require("./docker"); // shared: downloads, waitUntil, probeHealth, launchElevated, ensureWsl…
+const log = require("electron-log"); // persisted main.log — bootstrap timing/failures land here
 
 // Dedicated distro name — NEVER reuse/clobber a user's own "Ubuntu" distro.
 const DISTRO   = process.env.CICY_WSL_DISTRO || "cicy-code-wsl";
@@ -182,6 +183,8 @@ async function startEngine() {
   // runtime files, (re)launches dockerd, and waits for the socket; between
   // attempts we hard-kill any half-dead daemon so the next launch is clean.
   for (let attempt = 1; attempt <= 3; attempt++) {
+    const at0 = Date.now();
+    log.info(`[startEngine] attempt ${attempt}/3 — (re)launch dockerd + wait for socket`);
     try {
       await wslRun(
         "update-alternatives --set iptables /usr/sbin/iptables-legacy >/dev/null 2>&1; " +
@@ -199,8 +202,9 @@ async function startEngine() {
         // cold again (a restart loop → 「引擎没起来」even though dockerd was fine).
         "for i in $(seq 1 120); do [ -S /var/run/docker.sock ] && docker version >/dev/null 2>&1 && break; sleep 1; done",
         { timeout: 150000 });
-    } catch {}
-    if (await dockerEngineUp()) return true;
+    } catch (e) { log.warn(`[startEngine] attempt ${attempt} launch/wait errored: ${e.message}`); }
+    if (await dockerEngineUp()) { log.info(`[startEngine] ✓ dockerd up on attempt ${attempt} (${((Date.now() - at0) / 1000).toFixed(1)}s)`); return true; }
+    log.warn(`[startEngine] attempt ${attempt} dockerd still not up after ${((Date.now() - at0) / 1000).toFixed(1)}s`);
     // Not up after the wait. Only hard-reset when dockerd actually DIED (crash) —
     // if it's still alive it's just slow/mid-init, so leave it and let the next
     // attempt's wait loop keep polling instead of killing a healthy daemon.
@@ -210,6 +214,7 @@ async function startEngine() {
         { timeout: 15000 });
     } catch {}
   }
+  log.error("[startEngine] ✗ dockerd NOT up after 3 attempts");
   return false;
 }
 
@@ -310,7 +315,11 @@ function ensureAutostart() {
   return new Promise((res) => {
     const tr = `wsl.exe -d ${DISTRO} -u root -e /usr/local/sbin/start-dockerd.sh`;
     execFile("schtasks", ["/create", "/tn", "cicy-docker-autostart", "/tr", tr, "/sc", "onlogon", "/rl", "HIGHEST", "/f"],
-      { windowsHide: true }, () => res());
+      { windowsHide: true }, (err, _stdout, stderr) => {
+        if (err) log.warn(`[ensureAutostart] schtasks create FAILED (dockerd won't auto-start after reboot): ${err.message}${stderr ? ` / ${String(stderr).trim()}` : ""}`);
+        else log.info("[ensureAutostart] logon task 'cicy-docker-autostart' registered → dockerd starts on next logon");
+        res();
+      });
   });
 }
 
@@ -375,65 +384,104 @@ async function bootstrap(opts = {}) {
 async function _bootstrap({ onProgress, port = 8009, container = "cicy-code-docker", volume = "cicy-team", env = {} } = {}) {
   const emit = (ev) => { try { onProgress && onProgress(ev); } catch {} };
 
+  // Structured, PERSISTED trace of the whole run (electron-log → main.log) so a
+  // failed "重启后起不来" is diagnosable AFTER the fact instead of staring at the
+  // ephemeral progress modal. Each step logs ▶start / ✓done(+duration, or "skip"
+  // when already satisfied) / ✗fail(+reason+duration); the final line gives the
+  // total time and the SLOWEST step, plus a [name,ms] breakdown of every step.
+  const BT0 = Date.now();
+  const secs = (t) => `${((Date.now() - t) / 1000).toFixed(1)}s`;
+  const steps = [];
+  let _pt = BT0, _pname = "";
+  const begin = (name) => { _pname = name; _pt = Date.now(); log.info(`[bootstrap] ▶ ${name}`); };
+  const done  = (skip) => { steps.push([_pname, Date.now() - _pt]); log.info(`[bootstrap] ✓ ${_pname}${skip ? " (skip)" : ""} ${secs(_pt)}`); };
+  const fail  = (reason, extra) => { steps.push([`${_pname}:FAIL`, Date.now() - _pt]); log.error(`[bootstrap] ✗ ${_pname} reason=${reason} ${secs(_pt)}${extra ? `\n${extra}` : ""}`); };
+  const finish = (ok, reason) => {
+    const slow = steps.slice().sort((a, b) => b[1] - a[1])[0];
+    log.info(`[bootstrap] ${ok ? "DONE ✓" : `ABORT ✗ reason=${reason}`} total=${secs(BT0)} slowest=${slow ? `${slow[0]} ${(slow[1] / 1000).toFixed(1)}s` : "n/a"} steps=${JSON.stringify(steps.map(([n, d]) => [n, Math.round(d)]))}`);
+  };
+  log.info(`[bootstrap] START port=${port} container=${container} volume=${volume}`);
+
   // 0) Fast path: already healthy → instant no-op (idempotent one-shot).
+  begin("probe-healthy");
   if (await probeHealth(port)) {
+    done();
     emit({ phase: "done", status: "done", message: "Docker cicy-code 已就绪 🎉" });
+    finish(true);
     return { ok: true, container };
   }
+  done();
 
   // 1) WSL2 platform
+  begin("ensure-wsl");
   if (docker.wslMissing()) {
     const w = await docker.ensureWsl({ emit });
-    if (w.needsReboot) { emit({ phase: "done", status: "reboot", message: "WSL2 正在安装——请【重启 Windows】后回来点「重试」继续。" }); return { ok: false, reason: "wsl_reboot_required" }; }
-  }
+    if (w.needsReboot) { fail("wsl_reboot_required"); emit({ phase: "done", status: "reboot", message: "WSL2 正在安装——请【重启 Windows】后回来点「重试」继续。" }); finish(false, "wsl_reboot_required"); return { ok: false, reason: "wsl_reboot_required" }; }
+    done();
+  } else done(true);
 
   // 2) Ubuntu distro
+  begin("ensure-distro");
   if (!distroInstalled()) {
-    try { await installDistro({ emit }); } catch (e) { emit({ phase: "install-docker", status: "error", message: `Ubuntu 安装失败：${e.message}（点重试）` }); return { ok: false, reason: "distro_install_failed" }; }
+    try { await installDistro({ emit }); } catch (e) { fail("distro_install_failed", e.message); emit({ phase: "install-docker", status: "error", message: `Ubuntu 安装失败：${e.message}（点重试）` }); finish(false, "distro_install_failed"); return { ok: false, reason: "distro_install_failed" }; }
     const t0 = Date.now();
     const ok = await docker.waitUntil(() => distroInstalled(), { totalMs: 600000, everyMs: 5000, onTick: () => emit({ phase: "install-docker", status: "running", message: `正在下载/注册 Ubuntu…（已 ${Math.round((Date.now() - t0) / 1000)}s,首次较慢请耐心）` }) });
-    if (!ok) { emit({ phase: "install-docker", status: "error", message: "Ubuntu 还没装好——稍等或点「重试」" }); return { ok: false, reason: "distro_not_ready" }; }
-  }
+    if (!ok) { fail("distro_not_ready"); emit({ phase: "install-docker", status: "error", message: "Ubuntu 还没装好——稍等或点「重试」" }); finish(false, "distro_not_ready"); return { ok: false, reason: "distro_not_ready" }; }
+    done();
+  } else done(true);
 
   // 3) Docker Engine inside Ubuntu
+  begin("install-docker-engine");
   if (!(await dockerInstalled())) {
-    try { await installDockerEngine({ emit }); } catch (e) { emit({ phase: "install-docker", status: "error", message: `Docker 安装失败：${e.message}（点重试）` }); return { ok: false, reason: "docker_install_failed" }; }
-  }
+    try { await installDockerEngine({ emit }); } catch (e) { fail("docker_install_failed", e.message); emit({ phase: "install-docker", status: "error", message: `Docker 安装失败：${e.message}（点重试）` }); finish(false, "docker_install_failed"); return { ok: false, reason: "docker_install_failed" }; }
+    done();
+  } else done(true);
 
   // 4) dockerd up (phase "container" = 启动服务)
+  begin("start-dockerd");
   if (!(await dockerEngineUp())) {
     emit({ phase: "container", status: "running", message: "启动 Docker 引擎（首次较慢，请耐心）…" });
     const started = await startEngine(); // 3 clean attempts internally
     const up = started || await docker.waitUntil(dockerEngineUp, { totalMs: 120000, everyMs: 3000 });
     if (!up) {
-      const log = await dockerdLogTail();
-      emit({ phase: "container", status: "error", message: "Docker 引擎没起来——点「重试」" + (log ? `\n\ndockerd 日志（最后几行）:\n${log}` : "") });
+      const dlog = await dockerdLogTail();
+      fail("dockerd_not_up", dlog ? `dockerd log:\n${dlog}` : "");
+      emit({ phase: "container", status: "error", message: "Docker 引擎没起来——点「重试」" + (dlog ? `\n\ndockerd 日志（最后几行）:\n${dlog}` : "") });
+      finish(false, "dockerd_not_up");
       return { ok: false, reason: "dockerd_not_up" };
     }
-  }
+    done();
+  } else done(true);
 
   // 5) Base image — pre-baked into the package, so this normally just confirms.
   //    The download-tarball path is a fallback for a non-pre-baked rootfs.
+  begin("ensure-image");
   if (!(await imagePresent())) {
     let tarball;
     try { tarball = await docker.downloadImageTarball({ emit }); }
-    catch (e) { emit({ phase: "image", status: "error", message: `镜像下载失败：${e.message}（点重试续传）` }); return { ok: false, reason: "image_download_failed" }; }
+    catch (e) { fail("image_download_failed", e.message); emit({ phase: "image", status: "error", message: `镜像下载失败：${e.message}（点重试续传）` }); finish(false, "image_download_failed"); return { ok: false, reason: "image_download_failed" }; }
     try { await loadImage(tarball, { emit }); }
-    catch (e) { emit({ phase: "image", status: "error", message: `镜像导入失败：${e.message}（点重试）` }); return { ok: false, reason: "image_load_failed" }; }
-  }
+    catch (e) { fail("image_load_failed", e.message); emit({ phase: "image", status: "error", message: `镜像导入失败：${e.message}（点重试）` }); finish(false, "image_load_failed"); return { ok: false, reason: "image_load_failed" }; }
+    done();
+  } else done(true);
 
   // 6) Container (phase "container" = 启动服务)
+  begin("run-container");
   if (!(await probeHealth(port))) {
     emit({ phase: "container", status: "running", message: "启动 cicy-code 服务…" });
     try { await runContainer({ port, container, volume, env }); }
-    catch (e) { emit({ phase: "container", status: "error", message: `服务启动失败：${e.message}（点重试）` }); return { ok: false, reason: "container_start_failed" }; }
-  }
+    catch (e) { fail("container_start_failed", e.message); emit({ phase: "container", status: "error", message: `服务启动失败：${e.message}（点重试）` }); finish(false, "container_start_failed"); return { ok: false, reason: "container_start_failed" }; }
+    done();
+  } else done(true);
 
   // 7) Health — the ONLY path to ok:true.
+  begin("wait-health");
   emit({ phase: "container", status: "running", message: "等待 cicy-code 就绪…" });
   const healthy = await docker.waitUntil(() => probeHealth(port), { totalMs: 120000, everyMs: 3000 });
-  if (healthy) { await ensureAutostart(); await ensureDesktopShortcut(volume, port); } // survive reboot + desktop shortcut
+  if (healthy) { done(); await ensureAutostart(); await ensureDesktopShortcut(volume, port); } // survive reboot + desktop shortcut
+  else fail("health_timeout");
   emit({ phase: healthy ? "done" : "container", status: healthy ? "done" : "error", message: healthy ? "Docker cicy-code 已就绪 🎉" : `服务起来了但 :${port} 还没响应——稍等或点「重试」` });
+  finish(healthy, healthy ? null : "health_timeout");
   return { ok: healthy, container };
 }