cocos-web-inspector-mcp 2.2.0 → 2.2.1

package/README.md

@@ -64,7 +64,9 @@ The V8 inspector has no page, so native mode registers only the tools that read
 - `cocos_console_messages` (with `--allow-browser-data`) reads the app process's `Cocos`-tagged logcat lines, so it includes logs from before the server attached, bounded by the device log buffer. `console.log` and `console.debug` both report as `log`; an uncaught error spans several `error` lines.
 - Not registered: `cocos_capture_node`, `cocos_emulate_device`, `cocos_highlight_node`, `cocos_get_selection` (DOM overlays draw nothing), `cocos_analyze_batches` (the native 2D batcher runs in C++), `cocos_step_frame` (stepping from the inspector renders outside the native frame loop and crashed the app), and the network and storage tools.
 
-The inspector accepts one session at a time, so the server connects per call; Chrome DevTools can attach between calls, and a call made while DevTools is attached fails with `CDP_UNAVAILABLE`. If calls start failing with `CDP_UNAVAILABLE` while the app runs, the adb server restarted and dropped the forward; run `adb forward` again.
+The inspector accepts one session at a time, so the server connects per call; Chrome DevTools can attach between calls, and a call made while DevTools is attached fails with `CDP_UNAVAILABLE`. If calls start failing with `CDP_UNAVAILABLE` while the app runs, the adb server restarted or the device dropped off USB, which takes the forward with it; run `adb forward` again. When a phone keeps dropping off USB (common through hubs), switch adb to Wi-Fi with `adb tcpip 5555` and `adb connect <phone-ip>:5555`, then forward and set `ANDROID_SERIAL=<phone-ip>:5555`; the endpoint stays `127.0.0.1`.
+
+Only a build with the inspector compiled in can attach. If a game's Debug build fails, setting `USE_V8_DEBUGGER_FORCE` and `CC_DEBUG_FORCE` to `ON` in `native/engine/common/CMakeLists.txt` keeps the inspector in a release build; never ship such a build.
 
 ## Install and run
 

package/dist/src/bridge.js

@@ -810,11 +810,9 @@ export function inspectCocos(request) {
             }
         }
         if (selected === node) {
-            for (const key of ['name', 'active', 'activeInHierarchy']) {
-                const value = dataProperty(node, key) ?? dataProperty(node, `_${key}`);
-                if (typeof value === 'string' || typeof value === 'boolean')
-                    displayFields[key] = typeof value === 'string' ? value.slice(0, 500) : value;
-            }
+            // Native (JSB) nodes keep these in C++ behind accessors; summary reads the same public getters the scene tree reports.
+            const { name, active, activeInHierarchy } = summary(node);
+            Object.assign(displayFields, { name, active, activeInHierarchy });
         }
         if (typeof cc.Sprite === 'function' && selected instanceof cc.Sprite) {
             const frame = dataProperty(selected, '_spriteFrame');
@@ -1162,7 +1160,21 @@ export function inspectCocos(request) {
     }
     // Asset helpers read backing fields only; refCount, width, and texture getters stay untouched.
     const assetName = (asset) => String(dataProperty(asset, '_name') ?? '').slice(0, 500);
-    const assetUuid = (asset) => String(dataProperty(asset, '_uuid') ?? '');
+    // Native (JSB) assets keep _uuid behind a C++ accessor, which data reads skip; the asset cache is keyed by uuid, so look it up there.
+    let cachedUuids;
+    const assetUuid = (asset) => {
+        const own = dataProperty(asset, '_uuid');
+        if (typeof own === 'string' && own)
+            return own;
+        if (!cachedUuids) {
+            cachedUuids = new Map();
+            const map = dataProperty(cc.assetManager?.assets ?? {}, '_map');
+            for (const [key, value] of Object.entries((map && typeof map === 'object' ? map : {})))
+                if (value && typeof value === 'object')
+                    cachedUuids.set(value, key);
+        }
+        return cachedUuids.get(asset) ?? '';
+    };
     const gfxBytes = (texture) => {
         const gfx = texture && typeof texture === 'object' ? dataProperty(texture, '_gfxTexture') : undefined;
         const size = gfx && typeof gfx === 'object' ? dataProperty(gfx, '_size') : undefined;
@@ -1681,10 +1693,13 @@ export function inspectCocos(request) {
         // Unused first, then by GPU bytes and refCount: the likeliest leaks lead.
         items.sort((a, b) => Number(b.status === 'unused') - Number(a.status === 'unused') || (b.bytes ?? 0) - (a.bytes ?? 0) || b.refCount - a.refCount);
         const memory = dataProperty(dataProperty(dataProperty(cc.director, '_root') ?? {}, '_device') ?? {}, '_memoryStatus');
+        // Native (JSB) GFX textures live in C++ and expose no byte size to JS; report that instead of zeros that read as "no textures".
+        const textureCount = Object.entries(byType).filter(([type]) => /Texture/.test(type)).reduce((sum, [, bucket]) => sum + bucket.count, 0);
+        const bytesUnavailable = totalBytes === 0 && textureCount > 0;
         return {
             version,
             assetCount: Math.min(total, 50_000),
-            textureBytes: totalBytes,
+            ...(bytesUnavailable ? { textureBytes: null, unavailableMetrics: { textureBytes: 'UNSUPPORTED_PUBLIC_API' } } : { textureBytes: totalBytes }),
             ...(memory ? { gpuMemory: { textureBytes: Number(dataProperty(memory, 'textureSize') ?? 0), bufferBytes: Number(dataProperty(memory, 'bufferSize') ?? 0) } } : {}),
             byType,
             assets: items.slice(0, limit),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cocos-web-inspector-mcp",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "MCP server to inspect and debug Cocos Creator 3.x web builds in local Chromium over CDP",
   "license": "MIT",
   "repository": {