no-mistakes(document): correct stale engine platform counts in client docs

Author: anvanster

jetbrains/README.md

@@ -39,8 +39,8 @@ the dependency ever becomes a problem.
 ## Engine resolution
 
 The plugin does **not** bundle engine binaries, and neither does any other
-client any more: bundling all four platforms meant a ~120 MB download for the
-one binary a given user can actually run.
+client any more: bundling every platform meant a download several times the size
+of the one binary a given user can actually run.
 The engine is published once as GitHub release assets and each client fetches
 what its platform needs, into the shared `~/.codegraph/bin`.
 

jetbrains/src/main/kotlin/ai/codegraph/jetbrains/server/CodeGraphServerResolver.kt

@@ -59,13 +59,13 @@ data class ResolverEnvironment(
 /**
  * Locates the `codegraph-server` engine binary.
  *
- * Resolution order mirrors `vscode/src/server.ts`, with one deliberate
- * difference: the JetBrains plugin does not bundle platform binaries. The VSIX
- * carries four of them (100-126 MB each) because VS Code can ship per-platform
- * artifacts; the JetBrains Marketplace cannot, so a bundled plugin would be a
- * ~120 MB download for every user regardless of platform. Instead the binary is
- * resolved from an existing install and, failing that, downloaded once into the
- * managed install directory (Phase 1).
+ * Resolution order mirrors `vscode/src/server.ts`. No client bundles platform
+ * binaries any more (each engine is 100-126 MB), and the case against it is
+ * strongest here: VS Code could at least ship one artifact per platform, while
+ * the JetBrains Marketplace serves a single artifact to everyone, so a bundled
+ * plugin would carry every published engine to every user. Instead the binary
+ * is resolved from an existing install and, failing that, downloaded once into
+ * the managed install directory (Phase 1).
  *
  * Order:
  *  1. Explicit user override (settings)

jetbrains/src/main/kotlin/ai/codegraph/jetbrains/server/EngineDownloader.kt

@@ -18,10 +18,10 @@ import java.util.Locale
  * Fetches the engine for this platform into the managed install directory.
  *
  * The plugin does not bundle engines: the JetBrains Marketplace serves one
- * artifact to every platform, so bundling all four would mean a ~120 MB
- * download for every user to obtain the ~30 MB they can run. The alternative
- * for users without Node is worse - install a 498 MB npm package for one
- * binary - so the engine is fetched directly from the release that
+ * artifact to every platform, so bundling every published engine would mean a
+ * download several times the size of the one a given user can run. The
+ * alternative for users without Node is worse - install a 498 MB npm package
+ * for one binary - so the engine is fetched directly from the release that
  * `scripts/publish-release-assets.sh` produces.
  *
  * Downloads are verified against the checksum published beside each asset. An

jetbrains/src/test/kotlin/ai/codegraph/jetbrains/server/EngineDownloaderTest.kt

@@ -84,6 +84,21 @@ class EngineDownloaderTest : BasePlatformTestCase() {
         assertTrue("the engine must be executable", path.toFile().canExecute())
     }
 
+    fun `test an arm64 linux ide installs the arm64 engine`() {
+        // The platform this channel gained. Both Linux assets are published, so
+        // a mapping that fell back to x64 would install cleanly here and only
+        // fail when the IDE tried to start the engine - which is why the whole
+        // download is exercised and not just the name it resolves to.
+        publish("0.20.1", "codegraph-server-linux-arm64", "arm64 engine".toByteArray())
+        publish("0.20.1", "codegraph-server-linux-x64", "x64 engine".toByteArray())
+
+        val path = downloader("Linux").download("0.20.1")
+
+        assertEquals("codegraph-server-linux-arm64", path.fileName.toString())
+        assertEquals("arm64 engine", Files.readString(path))
+        assertTrue("the engine must be executable", path.toFile().canExecute())
+    }
+
     fun `test windows also installs the runtime library the engine loads`() {
         publish("0.19.1", "codegraph-server-win32-x64.exe", "engine".toByteArray())
         publish("0.19.1", EngineDownloader.WINDOWS_SIDECAR, "onnx".toByteArray())

mcp-package/test/fetch-engine.test.js

@@ -110,6 +110,39 @@ async function run() {
     }
   }
 
+  // --- an arm64 linux machine installs the arm64 engine ----------------
+  // The whole install, not just the name mapping: before linux-arm64 was
+  // published this threw, and the failure worth guarding against now is the
+  // quiet one - the x64 asset is served alongside, so a rule that fell back to
+  // it would install cleanly here and only fail when the user tried to run it.
+  {
+    const dir = scratch();
+    const release = await startRelease({
+      "codegraph-server-linux-arm64": { content: "arm64 engine" },
+      "codegraph-server-linux-x64": { content: "x64 engine" },
+    });
+    try {
+      const { binary, fetched } = await ensureEngine(VERSION, dir, {
+        platform: "linux",
+        arch: "arm64",
+        baseUrl: release.baseUrl,
+      });
+      check(
+        path.basename(binary) === "codegraph-server-linux-arm64",
+        "an arm64 linux install fetches the arm64 engine"
+      );
+      check(fs.readFileSync(binary, "utf8") === "arm64 engine", "and it is the arm64 build");
+      check(
+        fetched.length === 1 && !fs.existsSync(path.join(dir, "codegraph-server-linux-x64")),
+        "and nothing else, least of all the x64 build"
+      );
+      check(installedVersion(dir) === VERSION, "and the release it came from is recorded");
+    } finally {
+      release.server.close();
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  }
+
   // --- a corrupted download installs nothing ---------------------------
   {
     const dir = scratch();

scripts/package-npm.sh

@@ -102,8 +102,7 @@ fi
 # a rate limit part-way through leaves the release with some platforms attached
 # and others missing - and a one-platform probe would wave that through, giving
 # users on the missing platforms exactly the empty install this gate exists to
-# prevent. The list mirrors BINARIES + WINDOWS_SIDECAR there, which is the same
-# set bin/fetch-engine.js resolves against.
+# prevent.
 ENGINE_VERSION=$(node -e "console.log(require('$PKG_DIR/bin/fetch-engine').ENGINE_VERSION)")
 # Read from fetch-engine.js rather than repeating it here. A copy of this list
 # drifts silently: it stays green while probing a set that no longer matches

scripts/publish-release-assets.sh

@@ -13,7 +13,9 @@
 #
 # This does not build anything. It uploads what ./scripts/package-*.sh already
 # expect to find in vscode/bin/, so it slots in after the existing
-# cross-platform build (see cross-platform-builds.md).
+# cross-platform build (see cross-platform-builds.md). The one exception is
+# linux-arm64, which has no build host of its own: ./scripts/build-linux-arm64.sh
+# builds it in a container and stages and stamps it into vscode/bin/ itself.
 #
 # Usage:
 #   ./scripts/publish-release-assets.sh              # stage + verify only