feat(local-mcp): report the real plugin version

package.json

@@ -19,7 +19,7 @@
     "test:bundle": "vitest run --root sources/local-mcp",
     "validate": "pluginpack validate --target claude --dir dist/claude && pluginpack validate --target cursor --dir dist/cursor && pluginpack validate --target codex --dir dist/codex",
     "test": "npm run build && npm run validate",
-    "prebuild": "node scripts/sync-changelog.mjs && npm run build:bundle",
+    "prebuild": "node scripts/sync-release-metadata.mjs && npm run build:bundle",
     "release": "release-it"
   },
   "dependencies": {

scripts/sync-release-metadata.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// Propagate canonical root release metadata into each source bucket so every
+// built plugin ships the same values. Runs automatically via the `prebuild`
+// npm script. The root CHANGELOG.md and package.json are the single sources of
+// truth (managed by release-it); the copies below are derived and should not be
+// hand-edited.
+import { copyFileSync, readFileSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const { version } = JSON.parse(
+  readFileSync(join(root, "package.json"), "utf8"),
+);
+
+const changelog = join(root, "CHANGELOG.md");
+const buckets = [
+  "sources/claude",
+  "sources/codex",
+  "sources/cursor",
+  "sources/dev-docs",
+];
+
+for (const bucket of buckets) {
+  copyFileSync(changelog, join(root, bucket, "CHANGELOG.md"));
+  console.log(`synced CHANGELOG.md -> ${bucket}`);
+}
+
+// Textual replace, not a JSON round-trip, to keep the release diff to one line.
+const manifestPath = join(root, "sources/local-mcp/package.json");
+const before = readFileSync(manifestPath, "utf8");
+if (!/"version":\s*"[^"]*"/.test(before)) {
+  throw new Error(
+    `No "version" field in ${manifestPath} to sync. Add one — the local MCP ` +
+      `server reads it at runtime to report its own version.`,
+  );
+}
+writeFileSync(
+  manifestPath,
+  before.replace(/("version":\s*")[^"]*"/, `$1${version}"`),
+);
+console.log(`synced version ${version} -> sources/local-mcp`);

sources/local-mcp/package.json

@@ -1,5 +1,6 @@
 {
   "name": "glean",
+  "version": "3.2.0",
   "type": "module",
   "private": true,
   "engines": {

sources/local-mcp/src/index.ts

@@ -45,6 +45,7 @@ import {
 } from "./tools/remote-passthrough.js";
 import { resolveSessionId } from "./session-id.js";
 import { resolveServerUrlFromEmail } from "./config-search.js";
+import { PLUGIN_VERSION } from "./version.js";
 
 function readEnv(...keys: string[]): string | undefined {
   for (const key of keys) {
@@ -126,7 +127,7 @@ function resolveSkillsBaseDir(): string {
 }
 
 const server = new Server(
-  { name: "glean", version: "1.0.0" },
+  { name: "glean", version: PLUGIN_VERSION },
   { capabilities: { tools: { listChanged: true } } },
 );
 

sources/local-mcp/src/remote-client.ts

@@ -3,6 +3,7 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import type { GleanOAuthClientProvider } from "./auth-provider.js";
+import { PLUGIN_VERSION } from "./version.js";
 
 const GLEAN_PLUGIN = "GLEAN_PLUGIN";
 
@@ -209,7 +210,7 @@ export async function createRemoteClient(
   }
 
   const client = new Client(
-    { name: "glean", version: "1.0.0" },
+    { name: "glean", version: PLUGIN_VERSION },
     { capabilities: {} },
   );
 

sources/local-mcp/src/version.ts

@@ -0,0 +1,9 @@
+// Read at runtime rather than injected at build time: `../package.json` hits the
+// shipped manifest from both src/ and dist/, and that file has to exist anyway
+// for Node to load the bundle as ESM. Kept in step with the root manifest by
+// scripts/sync-release-metadata.mjs.
+import { readFileSync } from "node:fs";
+
+export const PLUGIN_VERSION: string = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+).version;

sources/local-mcp/tests/version.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect } from "vitest";
+import {
+  readFileSync,
+  mkdtempSync,
+  mkdirSync,
+  copyFileSync,
+  rmSync,
+} from "node:fs";
+import { execFileSync, spawn } from "node:child_process";
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import { createInterface } from "node:readline";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { PLUGIN_VERSION } from "../src/version.js";
+
+// Anchor to the test file, not cwd — vitest runs with --root sources/local-mcp
+// while the process cwd stays at the repo root.
+const here = path.dirname(fileURLToPath(import.meta.url));
+const serverDir = path.resolve(here, "..");
+const repoRoot = path.resolve(here, "../../..");
+
+const readVersion = (manifest: string): string =>
+  JSON.parse(readFileSync(manifest, "utf8")).version;
+
+describe("plugin version", () => {
+  it("reports the shipped manifest's version when run from source", () => {
+    expect(PLUGIN_VERSION).toBe(
+      readVersion(path.join(serverDir, "package.json")),
+    );
+  });
+
+  it("stays in step with the repo-root version that release-it bumps", () => {
+    // prebuild syncs these; drift means a release would misreport its version.
+    expect(readVersion(path.join(serverDir, "package.json"))).toBe(
+      readVersion(path.join(repoRoot, "package.json")),
+    );
+  });
+
+  it("advertises the version over MCP from the built bundle", async () => {
+    // Guards esbuild's handling of import.meta.url: unbundled the read resolves
+    // from src/, shipped it resolves from dist/.
+    execFileSync("node", ["sources/local-mcp/build.mjs"], {
+      cwd: repoRoot,
+      stdio: "pipe",
+    });
+
+    const staged = mkdtempSync(path.join(tmpdir(), "glean-plugin-layout-"));
+    let child: ChildProcessWithoutNullStreams | undefined;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    try {
+      mkdirSync(path.join(staged, "dist"));
+      copyFileSync(
+        path.join(serverDir, "dist/index.js"),
+        path.join(staged, "dist/index.js"),
+      );
+      copyFileSync(
+        path.join(serverDir, "package.json"),
+        path.join(staged, "package.json"),
+      );
+
+      const server = spawn("node", [path.join(staged, "dist/index.js")], {
+        // Keep all server state inside the temp dir — never touch ~/.glean.
+        env: {
+          ...process.env,
+          CLAUDE_PLUGIN_DATA: path.join(staged, "plugin-data"),
+          SKILLS_BASE_DIR: path.join(staged, "skills"),
+        },
+        stdio: "pipe",
+      });
+      child = server;
+
+      const version = await new Promise<string>((resolve, reject) => {
+        timer = setTimeout(
+          () => reject(new Error("no initialize response within 15s")),
+          15_000,
+        );
+        createInterface({ input: server.stdout }).on("line", (line) => {
+          try {
+            const msg = JSON.parse(line);
+            if (msg.id === 1 && msg.result?.serverInfo) {
+              resolve(msg.result.serverInfo.version);
+            }
+          } catch {
+            // Not a JSON-RPC frame.
+          }
+        });
+        // Fail fast with the server's own diagnostics instead of waiting out
+        // the timeout when it dies during startup.
+        let stderr = "";
+        server.stderr.on("data", (chunk) => (stderr += chunk.toString()));
+        server.on("exit", (code) =>
+          reject(
+            new Error(`server exited (${code}) before replying: ${stderr}`),
+          ),
+        );
+        server.on("error", reject);
+        server.stdin.write(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "initialize",
+            params: {
+              protocolVersion: "2025-06-18",
+              capabilities: {},
+              clientInfo: { name: "version-test", version: "0.0.0" },
+            },
+          }) + "\n",
+        );
+      });
+
+      expect(version).toBe(readVersion(path.join(repoRoot, "package.json")));
+    } finally {
+      clearTimeout(timer);
+      child?.kill();
+      rmSync(staged, { recursive: true, force: true });
+    }
+  }, 30_000);
+});