@unity-china/codely-cli 1.0.0-beta.35 → 1.0.0-beta.37

package/README.md

@@ -321,6 +321,7 @@ Remove an MCP server with the specified name.
 ## Troubleshooting
 
 If you encounter issues, please check the error messages and ensure:
+
 - Node.js version is 20 or higher
 - All dependencies are properly installed
 - API keys are correctly configured in settings

package/README.zh-CN.md

@@ -321,15 +321,16 @@ codely mcp add my-server python /path/to/server.py --scope user
 ## 故障排除
 
 如果您遇到问题，请检查错误消息并确保：
+
 - Node.js 版本为 20 或更高
 - 所有依赖项已正确安装
 - API 密钥在设置中正确配置
 
 如需更多帮助，请访问：
+
 - 🌐 [官方网站](https://codely.tuanjie.cn/)
 - 📖 [使用手册](https://yousandi.feishu.cn/wiki/Sqmlw31sYiTm8qkh7s1cSlbenmb)
 
 ## 许可证
 
 [LICENSE](./LICENSE)
-

package/bundle/gemini.js

@@ -417144,7 +417144,7 @@ async function getPackageJson2() {
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson2();
-  return "1.0.0-beta.35";
+  return "1.0.0-beta.37";
 }
 
 // packages/cli/src/ui/commands/types.ts
@@ -417636,7 +417636,7 @@ import process30 from "node:process";
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_polyfill();
-var GIT_COMMIT_INFO = "193365d8";
+var GIT_COMMIT_INFO = "8dcb2033";
 
 // packages/cli/src/ui/commands/bugCommand.ts
 var bugCommand = {
@@ -421906,6 +421906,7 @@ var UnityTcpClient = class extends EventEmitter10 {
     this.ioLock = false;
     this.connLock = false;
     this.debugMode = false;
+    this.lastConnectFailureHintAtMs = 0;
     this.host = host;
     this.port = port;
     this.debugMode = debugMode;
@@ -421924,6 +421925,31 @@ var UnityTcpClient = class extends EventEmitter10 {
       console.log(message);
     }
   }
+  formatConnectError(error2) {
+    try {
+      if (error2 instanceof AggregateError) {
+        const parts = (error2.errors || []).map((e3) => e3 instanceof Error ? e3.message : String(e3)).filter(Boolean);
+        const detail = parts.length > 0 ? parts.join(" | ") : error2.message || String(error2);
+        return `AggregateError: ${detail}`;
+      }
+      if (error2 instanceof Error) {
+        return error2.message || error2.name;
+      }
+      return String(error2);
+    } catch {
+      return "Unknown connect error";
+    }
+  }
+  maybeLogConnectFailureHint(error2) {
+    const now = Date.now();
+    const minIntervalMs = 2e3;
+    if (now - this.lastConnectFailureHintAtMs < minIntervalMs) {
+      return;
+    }
+    this.lastConnectFailureHintAtMs = now;
+    const brief = this.formatConnectError(error2);
+    console.log(`\u{1F504} Unity TCP not reachable at ${this.host}:${this.port} (${brief}). This is often normal during Unity compilation/domain reload; retrying...`);
+  }
   /**
    * Establish connection to Unity Editor with handshake
    */
@@ -421959,7 +421985,11 @@ var UnityTcpClient = class extends EventEmitter10 {
       this.emit("connected");
       return true;
     } catch (error2) {
-      console.error(`\u274C Failed to connect to Unity: ${error2}`);
+      if (this.debugMode) {
+        this.debugLog(`\u26A0\uFE0F Unity connect failed (${this.host}:${this.port}): ${this.formatConnectError(error2)}`);
+      } else {
+        this.maybeLogConnectFailureHint(error2);
+      }
       if (this.socket) {
         this.socket.destroy();
         this.socket = null;
@@ -457817,7 +457847,9 @@ var UnityConnectionManager = class extends EventEmitter12 {
       // -1 means unlimited
       debugMode: config3.debugMode ?? false,
       projectPath: config3.projectPath,
-      unityConfigPath: void 0
+      unityConfigPath: void 0,
+      expectedProjectRoot: void 0,
+      unityLastHeartbeat: void 0
     };
     UnityTcpClientManager.setDebugMode(this.config.debugMode);
     if (this.config.projectPath) {
@@ -457906,6 +457938,8 @@ var UnityConnectionManager = class extends EventEmitter12 {
     const { config: config3, configPath } = this.readUnityConfigFromProjectPath();
     const host = config3.unity_host && config3.unity_host.trim().length > 0 ? config3.unity_host : "localhost";
     const port = config3.unity_port;
+    const expectedProjectRoot = path70.dirname(configPath);
+    const unityLastHeartbeat = config3.last_heartbeat;
     const configChanged = host !== previousHost || port !== previousPort || configPath !== previousConfigPath;
     if (configChanged) {
       this.debugLog(
@@ -457927,6 +457961,77 @@ var UnityConnectionManager = class extends EventEmitter12 {
     this.config.host = host;
     this.config.port = port;
     this.config.unityConfigPath = configPath;
+    this.config.expectedProjectRoot = expectedProjectRoot;
+    this.config.unityLastHeartbeat = unityLastHeartbeat;
+  }
+  normalizeProjectRootPath(input) {
+    let normalized2 = input.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (process.platform === "win32") {
+      normalized2 = normalized2.toLowerCase();
+    }
+    return normalized2;
+  }
+  formatHeartbeatAge(lastHeartbeat) {
+    if (!lastHeartbeat || typeof lastHeartbeat !== "string") {
+      return null;
+    }
+    const parsed = Date.parse(lastHeartbeat);
+    if (Number.isNaN(parsed)) {
+      return null;
+    }
+    const ageMs = Date.now() - parsed;
+    if (ageMs < 0) {
+      return null;
+    }
+    const ageSec = Math.round(ageMs / 100) / 10;
+    return `${ageSec}s`;
+  }
+  async verifyConnectedUnityProjectRoot() {
+    if (!this.tcpClient) {
+      throw new Error("Cannot verify Unity project root: no TCP client");
+    }
+    const expectedRoot = this.config.expectedProjectRoot;
+    if (!expectedRoot) {
+      this.debugLog(
+        "Skipping Unity project root verification: expectedProjectRoot unavailable"
+      );
+      return;
+    }
+    let response;
+    try {
+      response = await this.tcpClient.sendCommand("manage_editor", {
+        action: "get_project_root"
+      });
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      throw new Error(`Failed to verify Unity project root: ${message}`);
+    }
+    const inner = response?.data ?? response;
+    const reportedRoot = inner?.data?.projectRoot ?? inner?.projectRoot ?? response?.data?.projectRoot;
+    if (typeof reportedRoot !== "string" || reportedRoot.trim().length === 0) {
+      throw new Error(
+        `Unity project root verification returned invalid response: ${JSON.stringify(
+          response
+        )}`
+      );
+    }
+    const expectedNorm = this.normalizeProjectRootPath(expectedRoot);
+    const reportedNorm = this.normalizeProjectRootPath(reportedRoot);
+    if (expectedNorm !== reportedNorm) {
+      const heartbeatAge = this.formatHeartbeatAge(
+        this.config.unityLastHeartbeat
+      );
+      const heartbeatHint = this.config.unityLastHeartbeat ? ` (last_heartbeat: ${this.config.unityLastHeartbeat}${heartbeatAge ? `, age: ${heartbeatAge}` : ""})` : "";
+      throw new Error(
+        [
+          `Connected Unity Bridge appears to belong to a different Unity project.`,
+          `Target: ${this.config.host}:${this.config.port}`,
+          `Expected project root (from ${this.config.unityConfigPath ?? ".com-unity-codely.json"}): ${expectedRoot}${heartbeatHint}`,
+          `Unity reports project root: ${reportedRoot}`,
+          `Hint: You may have another Unity project open on the same port, or the config heartbeat is stale. Open the correct Unity project (or regenerate .com-unity-codely.json) and retry.`
+        ].join("\n")
+      );
+    }
   }
   /**
    * Start the connection manager and attempt to connect with retry logic
@@ -458029,6 +458134,24 @@ var UnityConnectionManager = class extends EventEmitter12 {
       this.setupEventHandlers();
       const connected = await this.tcpClient.connect();
       if (connected) {
+        try {
+          await this.verifyConnectedUnityProjectRoot();
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : String(error2);
+          console.error(`
+\u274C ${message}`);
+          this.emit("error", { message });
+          if (this.tcpClient) {
+            try {
+              this.tcpClient.removeAllListeners();
+              this.tcpClient.disconnect();
+            } catch {
+            }
+          }
+          this.tcpClient = null;
+          UnityTcpClientManager.resetInstance();
+          return false;
+        }
         console.log(`\u2705 Connected to Unity Bridge at ${host}:${port}`);
         this.emit("connected", { host, port });
         return true;
@@ -459525,7 +459648,108 @@ var BuiltinUpmManager = class _BuiltinUpmManager {
       console.log(...args);
     }
   }
-  async connect(port = 25916, host = "localhost") {
+  normalizeProjectRootPath(input) {
+    let normalizedInput = input;
+    try {
+      normalizedInput = fs73.realpathSync(normalizedInput);
+    } catch {
+    }
+    let normalized2 = normalizedInput.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (process.platform === "win32") {
+      normalized2 = normalized2.toLowerCase();
+    }
+    return normalized2;
+  }
+  formatHeartbeatAge(lastHeartbeat) {
+    if (!lastHeartbeat || typeof lastHeartbeat !== "string") {
+      return null;
+    }
+    const parsed = Date.parse(lastHeartbeat);
+    if (Number.isNaN(parsed)) {
+      return null;
+    }
+    const ageMs = Date.now() - parsed;
+    if (ageMs < 0) {
+      return null;
+    }
+    const ageSec = Math.round(ageMs / 100) / 10;
+    return `${ageSec}s`;
+  }
+  getHeartbeatAgeSeconds(lastHeartbeat) {
+    if (!lastHeartbeat || typeof lastHeartbeat !== "string") {
+      return null;
+    }
+    const parsed = Date.parse(lastHeartbeat);
+    if (Number.isNaN(parsed)) {
+      return null;
+    }
+    const ageMs = Date.now() - parsed;
+    if (ageMs < 0) {
+      return 0;
+    }
+    return ageMs / 1e3;
+  }
+  deriveExpectedProjectRoot(unityConfig) {
+    const unityConfigPath = path73.join(process.cwd(), ".com-unity-codely.json");
+    const expectedProjectRoot = (() => {
+      const projectPathRaw = typeof unityConfig?.project_path === "string" ? unityConfig.project_path : void 0;
+      if (projectPathRaw && projectPathRaw.trim().length > 0) {
+        const trimmed2 = projectPathRaw.replace(/[\\/]+$/, "");
+        return path73.dirname(trimmed2);
+      }
+      return path73.dirname(unityConfigPath);
+    })();
+    return {
+      expectedProjectRoot,
+      unityConfigPath,
+      unityLastHeartbeat: typeof unityConfig?.last_heartbeat === "string" ? unityConfig.last_heartbeat : void 0
+    };
+  }
+  async verifyConnectedUnityProjectRootOrThrow(expectedProjectRoot, unityConfigPath, unityLastHeartbeat) {
+    if (!expectedProjectRoot) {
+      this.debugLog(
+        "Skipping Unity project root verification: expectedProjectRoot unavailable"
+      );
+      return;
+    }
+    if (!this.tcpClient) {
+      throw new Error("Cannot verify Unity project root: no TCP client");
+    }
+    let response;
+    try {
+      response = await this.tcpClient.sendCommand("manage_editor", {
+        action: "get_project_root"
+      });
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      throw new Error(`Failed to verify Unity project root: ${message}`);
+    }
+    const inner = response?.data ?? response;
+    const reportedRoot = inner?.data?.projectRoot ?? inner?.projectRoot ?? response?.data?.projectRoot;
+    if (typeof reportedRoot !== "string" || reportedRoot.trim().length === 0) {
+      throw new Error(
+        `Unity project root verification returned invalid response: ${JSON.stringify(
+          response
+        )}`
+      );
+    }
+    const expectedNorm = this.normalizeProjectRootPath(expectedProjectRoot);
+    const reportedNorm = this.normalizeProjectRootPath(reportedRoot);
+    if (expectedNorm !== reportedNorm) {
+      const heartbeatAge = this.formatHeartbeatAge(unityLastHeartbeat);
+      const heartbeatHint = unityLastHeartbeat ? ` (last_heartbeat: ${unityLastHeartbeat}${heartbeatAge ? `, age: ${heartbeatAge}` : ""})` : "";
+      throw new Error(
+        [
+          `Connected Unity Bridge appears to belong to a different Unity project.`,
+          `Target: ${this.status.host ?? "localhost"}:${this.status.port ?? "unknown"}`,
+          `Expected project root (from ${unityConfigPath}): ${expectedProjectRoot}${heartbeatHint}`,
+          `Unity reports project root: ${reportedRoot}`,
+          `Hint: The config heartbeat may be stale, or you have another Unity project open on the same port. Open the correct Unity project (or regenerate .com-unity-codely.json) and retry.`
+        ].join("\n")
+      );
+    }
+  }
+  async connect(port = 25916, host = "localhost", options2) {
     if (this.status.status === "connecting") {
       throw new Error("Already connecting to Unity server");
     }
@@ -459549,6 +459773,20 @@ var BuiltinUpmManager = class _BuiltinUpmManager {
       if (!connected) {
         throw new Error("Failed to establish TCP connection");
       }
+      await this.verifyConnectedUnityProjectRootOrThrow(
+        options2?.expectedProjectRoot ?? null,
+        options2?.unityConfigPath ?? path73.join(process.cwd(), ".com-unity-codely.json"),
+        options2?.unityLastHeartbeat
+      );
+      this.status = {
+        status: "connected",
+        host,
+        port,
+        lastConnected: /* @__PURE__ */ new Date(),
+        toolsAvailable: 10
+      };
+      this.debugLog(`\u2705 Connected to Unity TCP server on ${host}:${port}`);
+      await this.notifyConnectionEstablished();
     } catch (error2) {
       this.status = {
         status: "error",
@@ -459573,27 +459811,38 @@ var BuiltinUpmManager = class _BuiltinUpmManager {
     }
     const host = unityConfig.unity_host || "localhost";
     const port = unityConfig.unity_port;
+    const { expectedProjectRoot, unityConfigPath, unityLastHeartbeat } = this.deriveExpectedProjectRoot(unityConfig);
+    const envMaxAgeRaw = process.env.CODELY_UNITY_HEARTBEAT_MAX_AGE_S;
+    const envMaxAge = envMaxAgeRaw ? Number.parseInt(envMaxAgeRaw, 10) : Number.NaN;
+    const maxAgeS = Number.isFinite(envMaxAge) && envMaxAge >= 0 ? envMaxAge : 60;
+    const heartbeatAgeS = this.getHeartbeatAgeSeconds(unityLastHeartbeat);
+    if (maxAgeS > 0 && heartbeatAgeS !== null && heartbeatAgeS > maxAgeS) {
+      const ageRounded = Math.floor(heartbeatAgeS);
+      const ageHint = this.formatHeartbeatAge(unityLastHeartbeat);
+      throw new Error(
+        [
+          `Unity heartbeat is stale; refusing to connect.`,
+          `Config: ${unityConfigPath}`,
+          `last_heartbeat: ${unityLastHeartbeat ?? "n/a"}${ageHint ? ` (age: ${ageHint})` : ""}`,
+          `age_seconds: ${ageRounded}, max_allowed_seconds: ${maxAgeS}`,
+          `Hint: Open the correct Unity project to refresh heartbeat (or set CODELY_UNITY_HEARTBEAT_MAX_AGE_S=0 to disable fail-fast).`
+        ].join("\n")
+      );
+    }
     this.debugLog(
       `\u{1F4D6} Unity config: ${host}:${port} (reason: ${unityConfig.reason}, reloading: ${unityConfig.reloading})`
     );
-    await this.connect(port, host);
+    await this.connect(port, host, {
+      expectedProjectRoot,
+      unityConfigPath,
+      unityLastHeartbeat
+    });
   }
   /**
    * Setup TCP client event handlers
    */
   setupEventHandlers(host, port) {
     if (!this.tcpClient) return;
-    this.tcpClient.on("connected", async () => {
-      this.status = {
-        status: "connected",
-        host,
-        port,
-        lastConnected: /* @__PURE__ */ new Date(),
-        toolsAvailable: 10
-      };
-      this.debugLog(`\u2705 Connected to Unity TCP server on ${host}:${port}`);
-      await this.notifyConnectionEstablished();
-    });
     this.tcpClient.on("error", (error2) => {
       this.status = {
         status: "error",
@@ -484292,6 +484541,7 @@ var RenderThinkBlockInternal = ({
   terminalWidth: _terminalWidth
 }) => {
   const MAX_VISIBLE_THINK_LINES = 10;
+  const MAX_VISIBLE_THINK_CHARS_WHEN_COLLAPSED = 500;
   const shouldCollapse = isPending && isStreaming;
   const filteredContent = content.filter((line) => line.trim().length > 0);
   if (filteredContent.length === 0) {
@@ -484303,8 +484553,41 @@ var RenderThinkBlockInternal = ({
   if (cleanedContent.length === 0) {
     return null;
   }
-  const hiddenLineCount = shouldCollapse ? Math.max(0, cleanedContent.length - MAX_VISIBLE_THINK_LINES) : 0;
-  const visibleContent = shouldCollapse && hiddenLineCount > 0 ? cleanedContent.slice(-MAX_VISIBLE_THINK_LINES) : cleanedContent;
+  let visibleContent = cleanedContent;
+  let hiddenLineCount = 0;
+  if (shouldCollapse) {
+    const lastIndex = cleanedContent.length - 1;
+    const lastLine = cleanedContent[lastIndex] ?? "";
+    let lastOverlongIndex = -1;
+    for (let i3 = lastIndex; i3 >= 0; i3--) {
+      if (cleanedContent[i3].length > MAX_VISIBLE_THINK_CHARS_WHEN_COLLAPSED) {
+        lastOverlongIndex = i3;
+        break;
+      }
+    }
+    if (lastLine.length > MAX_VISIBLE_THINK_CHARS_WHEN_COLLAPSED) {
+      visibleContent = [lastLine];
+      hiddenLineCount = Math.max(0, cleanedContent.length - 1);
+    } else {
+      const resetStartIndex = lastOverlongIndex === -1 ? 0 : lastOverlongIndex + 1;
+      const candidate = cleanedContent.slice(resetStartIndex);
+      const selectedReversed = [];
+      let totalChars = 0;
+      for (let i3 = candidate.length - 1; i3 >= 0; i3--) {
+        if (selectedReversed.length >= MAX_VISIBLE_THINK_LINES) break;
+        const line = candidate[i3];
+        const nextTotal = totalChars + line.length;
+        if (nextTotal > MAX_VISIBLE_THINK_CHARS_WHEN_COLLAPSED) break;
+        selectedReversed.push(line);
+        totalChars = nextTotal;
+      }
+      if (selectedReversed.length === 0 && candidate.length > 0) {
+        selectedReversed.push(candidate[candidate.length - 1]);
+      }
+      visibleContent = selectedReversed.reverse();
+      hiddenLineCount = resetStartIndex + Math.max(0, candidate.length - visibleContent.length);
+    }
+  }
   return /* @__PURE__ */ (0, import_jsx_runtime35.jsxs)(
     Box_default,
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unity-china/codely-cli",
-  "version": "1.0.0-beta.35",
+  "version": "1.0.0-beta.37",
   "engines": {
     "node": ">=20.0.0"
   },