@thehammer/danx-dashboard-mcp 0.1.26 → 0.1.27

package/dist/entrypoint.js

@@ -0,0 +1,35 @@
+import { realpathSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+/**
+ * True when this module is the process entrypoint (the published bin) rather
+ * than an `import` — the DX-1606 tool-defs generator + its drift test import
+ * the module to introspect tool schemas without booting the stdio server, so
+ * `boot()` + `server.connect()` must run ONLY for the real bin invocation.
+ *
+ * Why the realpath resolve matters (DX-1647): `import.meta.url` reports the
+ * module's REALPATH — Node resolves symlinks for ESM module URLs by default.
+ * When the bin runs via a SYMLINK — both `npx` and global installs link
+ * `node_modules/.bin/danx-dashboard-mcp` → `dist/index.js` — `process.argv[1]`
+ * is the symlink path, which `pathToFileURL` would NOT match against the
+ * realpath `import.meta.url` carries. So resolve argv[1]'s realpath first; then
+ * the entrypoint is detected under BOTH direct `node dist/index.js` and the
+ * symlinked `npx -y @thehammer/danx-dashboard-mcp` the worker spawns.
+ *
+ * Without this, npx imports the module, registers the tools, and exits 0
+ * WITHOUT starting the server — every dispatch then fails the worker's
+ * "MCP loaded" preflight (`declared-not-loaded=[danx-dashboard]`).
+ */
+export function isEntrypointModule(moduleUrl, argvPath) {
+    if (typeof argvPath !== "string" || argvPath.length === 0)
+        return false;
+    let resolved;
+    try {
+        resolved = realpathSync(argvPath);
+    }
+    catch {
+        // argv[1] may not resolve on disk (synthetic paths in tests) — fall back to
+        // the raw path so a non-symlinked match still holds.
+        resolved = argvPath;
+    }
+    return moduleUrl === pathToFileURL(resolved).href;
+}

package/dist/entrypoint.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { mkdtempSync, writeFileSync, symlinkSync, rmSync, realpathSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { isEntrypointModule } from "./entrypoint.js";
+describe("isEntrypointModule (DX-1647)", () => {
+    let dir;
+    let real;
+    let link;
+    beforeAll(() => {
+        dir = mkdtempSync(join(tmpdir(), "entrypoint-test-"));
+        real = join(dir, "index.js");
+        writeFileSync(real, "// stub entry\n");
+        link = join(dir, "danx-dashboard-mcp"); // mimics node_modules/.bin symlink
+        symlinkSync(real, link);
+    });
+    afterAll(() => {
+        rmSync(dir, { recursive: true, force: true });
+    });
+    // import.meta.url always reports the module REALPATH — model that here.
+    const moduleUrl = () => pathToFileURL(realpathSync(real)).href;
+    it("true when argv[1] is the real file (direct `node index.js`)", () => {
+        expect(isEntrypointModule(moduleUrl(), real)).toBe(true);
+    });
+    it("true when argv[1] is a SYMLINK to the file (npx / global bin) — the fleet regression", () => {
+        // The symlink path !== the realpath, but the entrypoint MUST still be
+        // detected, or npx imports the module and exits without booting the server.
+        expect(link).not.toBe(realpathSync(link));
+        expect(isEntrypointModule(moduleUrl(), link)).toBe(true);
+    });
+    it("false when argv[1] is undefined (module imported, not run as bin)", () => {
+        expect(isEntrypointModule(moduleUrl(), undefined)).toBe(false);
+    });
+    it("false when argv[1] is an empty string", () => {
+        expect(isEntrypointModule(moduleUrl(), "")).toBe(false);
+    });
+    it("false when argv[1] points at a different real file", () => {
+        const other = join(dir, "other.js");
+        writeFileSync(other, "// other\n");
+        expect(isEntrypointModule(moduleUrl(), other)).toBe(false);
+    });
+});

package/dist/index.js

@@ -48,7 +48,7 @@
  * agent reads `body.error` + structured fields to decide next action.
  * 5xx and network failures throw — never silently swallowed.
  */
-import { pathToFileURL } from "node:url";
+import { isEntrypointModule } from "./entrypoint.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
@@ -382,10 +382,10 @@ async function main() {
 // Boot the stdio server ONLY when run as the entrypoint (the published bin).
 // Importing this module (the tool-defs generator + its drift test) registers
 // the tools on `server` without reading env or attaching stdin — so the
-// schemas can be introspected without spawning a dispatch.
-const isEntrypoint = typeof process.argv[1] === "string" &&
-    import.meta.url === pathToFileURL(process.argv[1]).href;
-if (isEntrypoint) {
+// schemas can be introspected without spawning a dispatch. The check is
+// symlink-aware (DX-1647) so it holds under the symlinked `npx` bin the worker
+// spawns, not just a direct `node dist/index.js`.
+if (isEntrypointModule(import.meta.url, process.argv[1])) {
     main().catch((err) => {
         console.error(`[danx-dashboard-mcp] fatal: ${err.message}`);
         process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/danx-dashboard-mcp",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "Stdio MCP server wrapping danxbot's dashboard /api/issues/* normalized DB-backed HTTP routes for dispatched agents (DX-704 Phase 2).",
   "license": "MIT",
   "type": "module",