code-ai-installer 4.3.0 → 4.3.1

package/README.md

@@ -157,8 +157,9 @@ Depending on `--target`, `code-ai` restructures your project:
 
 ## 🧬 Versions & migration
 
-`code-ai-installer` is on **v4.3.0**.
+`code-ai-installer` is on **v4.3.1**.
 
+- **v4.3.1** — the `code-ai-mcp` registration is now **pinned** to the installed version (`npx -p code-ai-installer@<version>`) and re-pinned on every reinstall, so an updated server actually takes effect instead of an unpinned `npx` silently reusing a stale global/cache copy. The server also logs `code-ai-mcp v<version> · domain=<domain>` to stderr at startup, so the live build is visible in Claude's MCP logs.
 - **v4.3.0** — `render_diff` MCP tool (unified diff → a standalone HTML review page); MCP gate-flow + stop-at-user-gate sections added to the content / analytics / product conductors; Auditor trigger — a `/audit` command plus a Release-Gate nudge that surfaces after every 3rd completed run (development pilot).
 - **v4.1.0** — MCP servers now register in your **global (user-scope)** config via a direct, idempotent `~/.claude.json` merge (no dependency on the `claude` CLI); the conductor halts at each user gate — one at a time, no batching, no auto-pass on green.
 - **v4.0.0** — consolidated the previously separate `code-ai-mcp` and types packages into this single package with **two bins** (`code-ai` + `code-ai-mcp`). Installing the CLI now also delivers the MCP server; for Claude it is auto-registered in your global (user-scope) MCP config. Existing 3.x CLI behavior is unchanged.

package/dist/index.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import prompts from "prompts";
@@ -13,10 +12,9 @@ import { setupMcp, teardownMcp } from "./mcp_setup.js";
 import { getPlatformAdapters } from "./platforms/adapters.js";
 import { resolveSourceRoot } from "./sourceResolver.js";
 import { printBanner } from "./banner.js";
+import { readInstallerVersion } from "./version.js";
 const program = new Command();
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const requireJson = createRequire(import.meta.url);
-const pkg = requireJson("../package.json");
 const WIZARD_TEXT = {
     en: {
         cancelled: "Installation cancelled.",
@@ -76,7 +74,7 @@ const WIZARD_TEXT = {
 program
     .name("code-ai")
     .description("Install code-ai agents and skills for AI coding assistants")
-    .version(pkg.version);
+    .version(readInstallerVersion());
 program
     .command("targets")
     .description("List supported AI targets")
@@ -228,7 +226,7 @@ program
             });
             for (const notice of report.notices)
                 info(`  ${notice}`);
-            info(`  MCP (${report.registration}): registered [${report.serversRegistered.join(", ") || "—"}], already present [${report.serversAlreadyPresent.join(", ") || "—"}]`);
+            info(`  MCP (${report.registration}): registered [${report.serversRegistered.join(", ") || "—"}], re-pinned [${report.serversUpdated.join(", ") || "—"}], already present [${report.serversAlreadyPresent.join(", ") || "—"}]`);
             info(`  .code-ai/config.json: written at ${report.configPath} (decision_store=${report.mempalaceUsed ? "mempalace" : "jsonl"})`);
         }
         if (dryRun) {
@@ -494,7 +492,7 @@ async function runInteractiveWizard() {
             });
             for (const notice of report.notices)
                 info(`  ${notice}`);
-            info(`  MCP (${report.registration}): registered [${report.serversRegistered.join(", ") || "—"}], already present [${report.serversAlreadyPresent.join(", ") || "—"}]`);
+            info(`  MCP (${report.registration}): registered [${report.serversRegistered.join(", ") || "—"}], re-pinned [${report.serversUpdated.join(", ") || "—"}], already present [${report.serversAlreadyPresent.join(", ") || "—"}]`);
             info(`  .code-ai/config.json: written at ${report.configPath} (decision_store=${report.mempalaceUsed ? "mempalace" : "jsonl"})`);
         }
         success("Install completed.");

package/dist/mcp/cli.d.ts

@@ -11,6 +11,10 @@
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { type ToolName } from "../shared/index.js";
+declare const SERVER_INFO: {
+    name: string;
+    version: string;
+};
 /**
  * One-line description per tool. Not stored in the shared types module (src/shared) because the
  * registry there is pure I/O contracts; descriptions live with the transport
@@ -18,4 +22,4 @@ import { type ToolName } from "../shared/index.js";
  */
 declare const TOOL_DESCRIPTIONS: Record<ToolName, string>;
 declare function buildServer(): McpServer;
-export { buildServer, TOOL_DESCRIPTIONS };
+export { buildServer, TOOL_DESCRIPTIONS, SERVER_INFO };

package/dist/mcp/cli.js

@@ -14,9 +14,11 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { TOOL_REGISTRY } from "../shared/index.js";
 import { CodeAiMcpServer } from "./server.js";
 import { NotImplementedError } from "./tools/stubs.js";
+import { readInstallerVersion } from "../version.js";
+import { resolveActiveDomain } from "./config.js";
 const SERVER_INFO = {
     name: "code-ai-mcp",
-    version: "0.0.0",
+    version: readInstallerVersion(),
 };
 /**
  * One-line description per tool. Not stored in the shared types module (src/shared) because the
@@ -108,6 +110,11 @@ async function main() {
     const mcp = buildServer();
     const transport = new StdioServerTransport();
     await mcp.connect(transport);
+    // Startup banner to STDERR — never stdout, which carries the JSON-RPC stream.
+    // Makes the live build + active domain visible in Claude's MCP logs, so a
+    // stale-server mismatch is obvious instead of silent.
+    const domain = await resolveActiveDomain();
+    console.error(`code-ai-mcp v${SERVER_INFO.version} · domain=${domain}`);
 }
 // Allow importing buildServer in tests without starting the stdio loop.
 const isDirectRun = (() => {
@@ -125,4 +132,4 @@ if (isDirectRun) {
         process.exit(1);
     });
 }
-export { buildServer, TOOL_DESCRIPTIONS };
+export { buildServer, TOOL_DESCRIPTIONS, SERVER_INFO };

package/dist/mcp_setup.d.ts

@@ -69,6 +69,8 @@ export interface McpSetupReport {
     registration: "user-scope" | "manual-fallback";
     /** Server names freshly added to the user config this run. */
     serversRegistered: string[];
+    /** Installer-owned server names whose entry was refreshed (e.g. re-pinned to a new version). */
+    serversUpdated: string[];
     /** Server names already present in the user config (left untouched). */
     serversAlreadyPresent: string[];
     /** Server names whose registration failed (config unwritable). */
@@ -128,13 +130,16 @@ export declare function userConfigPath(): string;
 export declare function createUserConfigIO(configPath: string): UserConfigIO;
 /**
  * Idempotently merge `servers` into the config's top-level `mcpServers`. Pure —
- * returns a new config object plus which names were freshly added vs already
- * present. An existing key is NEVER overwritten (so a pre-existing global
- * `mempalace` is preserved untouched). Exported for unit testing.
+ * returns a new config object plus which names were added / updated / already
+ * present. A FOREIGN existing key is never overwritten (so a pre-existing global
+ * `mempalace` is preserved). An OWNED server (named in `ownedServers`) whose
+ * entry differs is refreshed in place — that is how a reinstall re-pins
+ * `code-ai-mcp` to the new version. Exported for unit testing.
  */
-export declare function mergeUserScopeServers(config: Record<string, unknown>, servers: Record<string, McpServerEntry>): {
+export declare function mergeUserScopeServers(config: Record<string, unknown>, servers: Record<string, McpServerEntry>, ownedServers?: readonly string[]): {
     config: Record<string, unknown>;
     registered: string[];
+    updated: string[];
     alreadyPresent: string[];
 };
 /**

package/dist/mcp_setup.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { copyFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { readInstallerVersion } from "./version.js";
 /**
  * Try `mempalace-mcp --help` — the dedicated MCP-server bin, which is exactly
  * what we register. Resolves true on exit code 0, false otherwise (including
@@ -120,25 +121,38 @@ function readMcpServers(config) {
 }
 /**
  * Idempotently merge `servers` into the config's top-level `mcpServers`. Pure —
- * returns a new config object plus which names were freshly added vs already
- * present. An existing key is NEVER overwritten (so a pre-existing global
- * `mempalace` is preserved untouched). Exported for unit testing.
+ * returns a new config object plus which names were added / updated / already
+ * present. A FOREIGN existing key is never overwritten (so a pre-existing global
+ * `mempalace` is preserved). An OWNED server (named in `ownedServers`) whose
+ * entry differs is refreshed in place — that is how a reinstall re-pins
+ * `code-ai-mcp` to the new version. Exported for unit testing.
  */
-export function mergeUserScopeServers(config, servers) {
+export function mergeUserScopeServers(config, servers, ownedServers = []) {
     const next = { ...config };
     const mcpServers = readMcpServers(config);
+    const owned = new Set(ownedServers);
     const registered = [];
+    const updated = [];
     const alreadyPresent = [];
     for (const [name, entry] of Object.entries(servers)) {
+        const desired = toUserScopeEntry(entry);
         if (Object.prototype.hasOwnProperty.call(mcpServers, name)) {
-            alreadyPresent.push(name);
+            // Refresh ONLY our own servers (e.g. re-pin to a new version). A foreign
+            // server we also register (mempalace) is never overwritten.
+            if (owned.has(name) && JSON.stringify(mcpServers[name]) !== JSON.stringify(desired)) {
+                mcpServers[name] = desired;
+                updated.push(name);
+            }
+            else {
+                alreadyPresent.push(name);
+            }
             continue;
         }
-        mcpServers[name] = toUserScopeEntry(entry);
+        mcpServers[name] = desired;
         registered.push(name);
     }
     next.mcpServers = mcpServers;
-    return { config: next, registered, alreadyPresent };
+    return { config: next, registered, updated, alreadyPresent };
 }
 /**
  * Idempotently remove `names` from the config's `mcpServers`. Pure — returns a
@@ -184,10 +198,14 @@ function buildServerEntries(mempalaceUsed) {
     // DEV-100 consolidation: the code-ai-mcp bin lives inside the
     // `code-ai-installer` npm package. `npx -p <package> <bin>` tells npm to
     // install that package and run the named bin from it.
+    // Pin to THIS installer's version so the spawned server is explicit and
+    // reproducible. An unpinned `npx` silently runs whatever global/cache copy
+    // exists — that is how a stale, pre-fix server kept running after a reinstall.
+    // A reinstall re-pins this (mergeUserScopeServers refreshes owned servers).
     const servers = {
         "code-ai-mcp": {
             command: "npx",
-            args: ["-y", "-p", "code-ai-installer", "code-ai-mcp"],
+            args: ["-y", "-p", `code-ai-installer@${readInstallerVersion()}`, "code-ai-mcp"],
         },
     };
     if (mempalaceUsed) {
@@ -249,6 +267,7 @@ export async function setupMcp(opts, io = defaultUserConfigIO) {
     }
     const servers = buildServerEntries(mempalaceUsed);
     const serversRegistered = [];
+    const serversUpdated = [];
     const serversAlreadyPresent = [];
     const serversFailed = [];
     let registration;
@@ -268,12 +287,13 @@ export async function setupMcp(opts, io = defaultUserConfigIO) {
                 notices.push(manualEntryLine(name, entry));
         }
         else {
-            const merged = mergeUserScopeServers(read.data, servers);
+            const merged = mergeUserScopeServers(read.data, servers, INSTALLER_OWNED_SERVERS);
             serversAlreadyPresent.push(...merged.alreadyPresent);
             for (const name of merged.alreadyPresent) {
                 notices.push(`MCP server '${name}' already in user config — left untouched.`);
             }
-            if (merged.registered.length === 0) {
+            const changed = [...merged.registered, ...merged.updated];
+            if (changed.length === 0) {
                 registration = "user-scope";
             }
             else {
@@ -281,16 +301,22 @@ export async function setupMcp(opts, io = defaultUserConfigIO) {
                 if (written.ok) {
                     registration = "user-scope";
                     serversRegistered.push(...merged.registered);
-                    notices.push(`Registered MCP server(s) [${merged.registered.join(", ")}] in Claude user config ${io.configPath}` +
+                    serversUpdated.push(...merged.updated);
+                    const parts = [];
+                    if (merged.registered.length)
+                        parts.push(`registered [${merged.registered.join(", ")}]`);
+                    if (merged.updated.length)
+                        parts.push(`re-pinned [${merged.updated.join(", ")}]`);
+                    notices.push(`MCP server(s) ${parts.join(", ")} in Claude user config ${io.configPath}` +
                         (written.backupPath ? ` (backup: ${written.backupPath})` : "") +
                         ". Restart your Claude Code session to load them.");
                 }
                 else {
                     registration = "manual-fallback";
-                    serversFailed.push(...merged.registered);
+                    serversFailed.push(...changed);
                     notices.push(`Failed to write Claude user config at ${io.configPath} (${written.error ?? "unknown error"}). ` +
                         `No changes made — add these entries to its "mcpServers" object by hand:`);
-                    for (const name of merged.registered)
+                    for (const name of changed)
                         notices.push(manualEntryLine(name, servers[name]));
                 }
             }
@@ -308,6 +334,7 @@ export async function setupMcp(opts, io = defaultUserConfigIO) {
         userConfigPath: io.configPath,
         registration,
         serversRegistered,
+        serversUpdated,
         serversAlreadyPresent,
         serversFailed,
         configPath: cfg.path,

package/dist/version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The installed `code-ai-installer` package version — the single source for the
+ * CLI `--version`, the MCP server registration pin, and the server startup
+ * banner. Resolves `package.json` relative to THIS module (dist/version.js →
+ * ../package.json = package root), so every caller gets the right path
+ * regardless of its own depth in the tree.
+ */
+export declare function readInstallerVersion(): string;

package/dist/version.js

@@ -0,0 +1,13 @@
+import { createRequire } from "node:module";
+/**
+ * The installed `code-ai-installer` package version — the single source for the
+ * CLI `--version`, the MCP server registration pin, and the server startup
+ * banner. Resolves `package.json` relative to THIS module (dist/version.js →
+ * ../package.json = package root), so every caller gets the right path
+ * regardless of its own depth in the tree.
+ */
+export function readInstallerVersion() {
+    const requireJson = createRequire(import.meta.url);
+    const pkg = requireJson("../package.json");
+    return pkg.version;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-ai-installer",
-  "version": "4.3.0",
+  "version": "4.3.1",
   "description": "Production-ready CLI to install code-ai agents and skills for multiple AI coding assistants. Bundles the code-ai-mcp MCP server for Claude Code.",
   "license": "MIT",
   "author": "Denish1209",