@thehammer/schema-mcp-server 1.0.12 → 1.0.14

package/dist/index.js

@@ -14,17 +14,47 @@
  *   SCHEMA_API_TOKEN - Bearer token for SchemaMcpAuthMiddleware
  *   SCHEMA_DEFINITION_ID - ID of the schema being built
  */
-import { createRequire } from "node:module";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import * as api from "./api-client.js";
-const require = createRequire(import.meta.url);
-const pkg = require("../package.json");
+import { LOADED_VERSION, assertVersionCurrent } from "./version-check.js";
 const server = new McpServer({
     name: "schema-mcp-server",
-    version: pkg.version,
+    version: LOADED_VERSION,
 });
+/**
+ * Prepend the version check to every tool handler — ONE place, all tools.
+ *
+ * `server.tool(name, desc, schema, handler)` is called 35+ times throughout
+ * this file. Rather than editing every call site, we override `server.tool`
+ * once right after the server is constructed: the override wraps the handler
+ * (always the last argument across all SDK overloads) with assertVersionCurrent,
+ * then delegates to the original implementation. New tools added in the future
+ * are covered automatically — no per-tool bookkeeping required.
+ *
+ * Fail-loud invariants:
+ * - The handler is always the last argument across every current SDK overload.
+ *   A runtime `typeof` guard throws immediately if a future SDK overload
+ *   breaks this assumption — the wrapper never silently wraps the wrong arg.
+ * - `assertVersionCurrent()` reads package.json on every call via
+ *   `fs.readFileSync` (never `require()`, which caches). Sync reads of a
+ *   ~500-byte file are microsecond-scale — no throttling needed.
+ */
+const originalTool = server.tool.bind(server);
+server.tool = (...args) => {
+    const handlerIdx = args.length - 1;
+    const handler = args[handlerIdx];
+    if (typeof handler !== "function") {
+        throw new Error("[schema-mcp-server] server.tool override: expected last argument to be a handler function. SDK overload change detected — rewire the override before continuing.");
+    }
+    const originalHandler = handler;
+    args[handlerIdx] = async (...handlerArgs) => {
+        assertVersionCurrent();
+        return originalHandler(...handlerArgs);
+    };
+    return originalTool(...args);
+};
 /**
  * Role-based tool registration.
  *
@@ -80,7 +110,6 @@ const ROLE_TOOLS = {
         "schema_update_model",
         "schema_remove_model",
         "schema_update_root",
-        "quality_gate_submit_review",
     ]),
     "behavior-builder": new Set([
         ...COMMON_TOOLS,
@@ -88,7 +117,6 @@ const ROLE_TOOLS = {
         "directive_create",
         "directive_update",
         "directive_delete",
-        "quality_gate_submit_review",
     ]),
     "template-builder": new Set([
         ...COMMON_TOOLS,
@@ -97,7 +125,6 @@ const ROLE_TOOLS = {
         "template_update",
         "template_patch",
         "template_set_sample_data",
-        "quality_gate_submit_review",
         "style_list",
         "annotation_create", // Question annotations for missing fields → orchestrator decides
     ]),
@@ -107,6 +134,7 @@ const ROLE_TOOLS = {
         "style_list",
         "context_workflow_inputs",
         "context_workflow_input_pages",
+        "quality_gate_submit_review",
     ]),
 };
 /**

package/dist/version-check.d.ts

@@ -0,0 +1,15 @@
+export declare const LOADED_VERSION: string;
+/**
+ * Halt the process if the on-disk `package.json` version has drifted from
+ * `LOADED_VERSION`.
+ *
+ * Called from the `server.tool` override in `index.ts` before every tool
+ * handler runs. Uses `fs.readFileSync` + `JSON.parse` on every call —
+ * `require()` would cache the first read and defeat the check.
+ *
+ * Side effect: on mismatch (or if the disk read itself fails), writes a
+ * clear error line to stderr and calls `process.exit(1)`. There is no graceful
+ * shutdown window, no retry, no returned error object. The MCP stdio client
+ * sees the disconnect and surfaces it as a dispatch failure.
+ */
+export declare function assertVersionCurrent(): void;

package/dist/version-check.js

@@ -0,0 +1,66 @@
+/**
+ * Runtime version check — single source of truth for the MCP server's version
+ * identity.
+ *
+ * Owns BOTH:
+ *   1. `LOADED_VERSION`: the version captured into memory the first time this
+ *      module is loaded (one fs read at module load).
+ *   2. `assertVersionCurrent()`: compares the on-disk package.json version to
+ *      `LOADED_VERSION` and halts the process via `process.exit(1)` on
+ *      mismatch so stale-code runs fail loudly instead of serving old behavior
+ *      silently.
+ *
+ * Dist layout assumption: `../package.json` resolves from both
+ * `src/version-check.ts` AND `dist/version-check.js` to `mcp-server/package.json`
+ * because both files live one level below the package root. If tsconfig ever
+ * emits to a nested output dir (e.g. `dist/src/`), this assumption breaks and
+ * must be re-pinned here.
+ *
+ * Wired in once at the top of `index.ts` via a `server.tool` override — every
+ * tool handler runs the assertion before doing any work. See that override
+ * block for the single injection site.
+ */
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+const pkgPath = fileURLToPath(new URL("../package.json", import.meta.url));
+/**
+ * Version frozen into memory at module load. Any later mismatch between this
+ * value and the on-disk `package.json` triggers `assertVersionCurrent()` to
+ * halt the process — there is no recovery path, no graceful shutdown, no retry.
+ *
+ * Read at module load via `fs.readFileSync` (not `require()`, which would
+ * cache the result and make the runtime check always pass). If `package.json`
+ * is missing or malformed at startup, the exception is intentionally
+ * uncaught — fail-loud is the correct behavior before the server even begins
+ * serving requests.
+ */
+const loadedPkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+export const LOADED_VERSION = loadedPkg.version;
+/**
+ * Halt the process if the on-disk `package.json` version has drifted from
+ * `LOADED_VERSION`.
+ *
+ * Called from the `server.tool` override in `index.ts` before every tool
+ * handler runs. Uses `fs.readFileSync` + `JSON.parse` on every call —
+ * `require()` would cache the first read and defeat the check.
+ *
+ * Side effect: on mismatch (or if the disk read itself fails), writes a
+ * clear error line to stderr and calls `process.exit(1)`. There is no graceful
+ * shutdown window, no retry, no returned error object. The MCP stdio client
+ * sees the disconnect and surfaces it as a dispatch failure.
+ */
+export function assertVersionCurrent() {
+    let diskVersion;
+    try {
+        const diskPkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        diskVersion = diskPkg.version;
+    }
+    catch (err) {
+        console.error(`[schema-mcp-server] VERSION CHECK FAILED: unable to read ${pkgPath}. Restart required. Cause:`, err);
+        process.exit(1);
+    }
+    if (diskVersion !== LOADED_VERSION) {
+        console.error(`[schema-mcp-server] VERSION MISMATCH: loaded v${LOADED_VERSION} in memory, v${diskVersion} on disk. Restart required.`);
+        process.exit(1);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/schema-mcp-server",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "MCP server for Schema Builder - translates Claude Code tool calls into Laravel API requests",
   "license": "MIT",
   "repository": {
@@ -21,7 +21,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && chmod +x dist/index.js",
     "start": "node dist/index.js",
     "dev": "tsx watch src/index.ts"
   },