@strixgov/mcp-proxy 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.2]
+
+### Fixed
+- The published package now ships its test suite (`test/`, except the monorepo-only
+  `installed-tarball.test.mjs`) and `scripts/preflight.mjs`, so `npm test` runs in an installed
+  copy. `scripts/run-tests.mjs` exits non-zero if no test files are found, if the runner reports
+  zero or skipped-only tests, or if fewer than 60 tests run (Node counts an empty test file as one
+  passing test).
+
 ## [0.2.1]
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strixgov/mcp-proxy",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Strix MCP Proxy — the distribution wedge for governed agent tool execution. Point your MCP client at the proxy instead of the underlying server; every callTool is intercepted, evaluated against policy, and emits a signed Ed25519 receipt. Designed so Mode 3 (capability-enforced) is the v0.2.0 upgrade path, not a rewrite.",
   "license": "Elastic-2.0",
   "type": "module",
@@ -43,7 +43,9 @@
   "files": [
     "src/",
     "bin/",
-    "scripts/run-tests.mjs",
+    "scripts/",
+    "test/",
+    "!test/installed-tarball.test.mjs",
     "examples/",
     "README.md",
     "CHANGELOG.md",

package/scripts/preflight.mjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/**
+ * Fresh-clone guard for @strixgov/mcp-proxy's test suite.
+ *
+ * Sibling of packages/strixgov-mcp-adapter/scripts/preflight.mjs. The two are
+ * deliberately duplicated rather than shared: these packages publish
+ * independently, and importing a guard across the workspace would either add a
+ * dependency edge that does not exist at runtime or require shipping the guard
+ * in the tarball. The REQUIRED list below is this package's own, not a copy.
+ *
+ * This package resolves its Strix dependencies through pnpm workspace links
+ * (`workspace:^` entries resolved in pnpm-lock.yaml as `link:../<pkg>`). In a
+ * checkout that has not been installed, those links do not exist, and
+ * `node --test` fails with a wall of ERR_MODULE_NOT_FOUND traces that name the
+ * missing specifiers but never say what to do about it. Read cold, that looks
+ * like a broken package rather than an uninstalled tree.
+ *
+ * This guard prints the one command that fixes it and exits non-zero instead.
+ * It is silent on success, so CI — which runs `pnpm install --frozen-lockfile`
+ * first — never sees extra output.
+ *
+ * Why dynamic import() and not require.resolve():
+ * tool-gateway's package.json "exports" map declares only an "import"
+ * condition and does not export "./package.json", so BOTH
+ * require.resolve("@strixgov/tool-gateway") and
+ * require.resolve("@strixgov/tool-gateway/package.json") throw even when the
+ * package is correctly installed. import() is also the exact operation src/
+ * and the tests perform, which makes a pass here a faithful predicate for
+ * "the suite can load" rather than an approximation of it.
+ */
+
+/**
+ * Every specifier the suite needs in order to run.
+ *
+ * - @strixgov/tool-gateway and @strixgov/mcp-adapter are imported by
+ *   src/proxy.mjs at module scope.
+ * - @modelcontextprotocol/sdk is a registry dependency, not a workspace link,
+ *   but it fails the same way in an uninstalled tree and deserves the same
+ *   message. The subpath is checked rather than the bare name because the SDK
+ *   ships an "exports" map with no root export.
+ * - @strixgov/capabilities-mcp-common is dynamically imported by
+ *   resolveCapabilities() in src/config.mjs and exercised by
+ *   test/config.test.mjs, so its absence is a real test failure.
+ *
+ * Deliberately NOT listed: @strixgov/mcp-proxy itself. The only import of it
+ * lives inside a generated temp project in test/installed-tarball.test.mjs,
+ * which resolves it from that project's own install, not from this workspace.
+ */
+const REQUIRED = [
+  "@strixgov/tool-gateway",
+  "@strixgov/mcp-adapter",
+  "@modelcontextprotocol/sdk/client/index.js",
+  "@strixgov/capabilities-mcp-common/notion",
+];
+
+/**
+ * @param {string} specifier
+ * @returns {Promise<boolean>} true if the specifier loads.
+ */
+async function resolves(specifier) {
+  try {
+    await import(specifier);
+    return true;
+  } catch (err) {
+    if (err?.code === "ERR_MODULE_NOT_FOUND") return false;
+    // The package is present but threw while loading (a syntax error inside
+    // it, a broken transitive import). That is a real failure, but it is not
+    // the one this guard exists to explain — let the test run surface it
+    // verbatim rather than mislabelling it as "not installed".
+    return true;
+  }
+}
+
+/** @type {string[]} */
+const missing = [];
+for (const specifier of REQUIRED) {
+  if (!(await resolves(specifier))) missing.push(specifier);
+}
+
+if (missing.length > 0) {
+  // Deduplicate to package names: reporting several subpaths of one missing
+  // package is noise for what is a single missing install.
+  const packages = [
+    ...new Set(missing.map((s) => s.split("/").slice(0, 2).join("/"))),
+  ];
+
+  process.stderr.write(
+    [
+      "",
+      "  @strixgov/mcp-proxy: dependencies are not installed.",
+      "",
+      "  Cannot resolve:",
+      ...packages.map((p) => `    - ${p}`),
+      "",
+      "  This package resolves its Strix dependencies through the pnpm",
+      "  workspace (and the rest from the registry), so the repository has",
+      "  to be installed once before its tests can run:",
+      "",
+      "      pnpm install                                 # from the repo root",
+      "      pnpm --dir packages/strixgov-mcp-proxy test",
+      "",
+      "  Nothing is wrong with the published package: installing it from npm",
+      "  pulls these in automatically as regular dependencies. This only",
+      "  affects running the suite from a source checkout.",
+      "",
+    ].join("\n") + "\n",
+  );
+  process.exit(1);
+}

package/scripts/run-tests.mjs

@@ -2,13 +2,14 @@
 /**
  * `npm test` entry point for @strixgov/mcp-proxy.
  *
- * The suite needs a source checkout (devDependencies and pnpm workspace links),
- * so the npm tarball does not ship test/ or scripts/preflight.mjs. Previously
- * `test` called preflight.mjs directly, so `npm test` in an installed copy died
- * with "Cannot find module scripts/preflight.mjs". This wrapper fails closed
- * with an explanation instead: it never exits 0 having run zero tests.
+ * Works both in a source checkout and in an installed copy of the published
+ * tarball (the suite ships in the package; only test/installed-tarball.test.mjs,
+ * which needs sibling monorepo packages, is excluded from the tarball).
+ *
+ * Fails closed: a run that executes ZERO tests, finds no test files, or cannot
+ * read a test count exits non-zero. "No tests" must never read as a pass.
  */
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
@@ -16,26 +17,40 @@ const root = fileURLToPath(new URL("..", import.meta.url));
 const testDir = fileURLToPath(new URL("../test", import.meta.url));
 const preflight = fileURLToPath(new URL("./preflight.mjs", import.meta.url));
 
-if (!existsSync(testDir) || !existsSync(preflight)) {
-  process.stderr.write(
-    [
-      "",
-      "  @strixgov/mcp-proxy: no tests to run here.",
-      "",
-      "  The test suite is not included in the published npm package.",
-      "  Run it from a source checkout of https://github.com/Strixgov/strix:",
-      "",
-      "      pnpm install",
-      "      pnpm --dir packages/strixgov-mcp-proxy test",
-      "",
-      "  Exiting non-zero on purpose: zero tests run must not read as a pass.",
-      "",
-    ].join("\n"),
-  );
+// Node counts an empty test file as one passing test, so "> 0" is not enough:
+// an emptied suite would still pass. Require a floor close to the real size (66 at 0.2.2).
+const MIN_TESTS = 60;
+
+const fail = (msg) => {
+  process.stderr.write(`\n  @strixgov/mcp-proxy: ${msg}\n\n`);
   process.exit(1);
-}
+};
 
-for (const args of [[preflight], ["--test"]]) {
-  const r = spawnSync(process.execPath, args, { cwd: root, stdio: "inherit" });
-  if (r.status !== 0) process.exit(r.status ?? 1);
+const files = existsSync(testDir) ? readdirSync(testDir).filter((f) => f.endsWith(".test.mjs")) : [];
+if (files.length === 0 || !existsSync(preflight)) {
+  fail("no tests to run (test/*.test.mjs or scripts/preflight.mjs missing). Exiting non-zero: zero tests run must not read as a pass.");
 }
+
+const pre = spawnSync(process.execPath, [preflight], { cwd: root, stdio: "inherit" });
+if (pre.status !== 0) process.exit(pre.status ?? 1);
+
+// Run via the node test runner and read its own summary so we can refuse a zero count.
+const run = spawnSync(process.execPath, ["--test", ...files.map((f) => `test/${f}`)], {
+  cwd: root,
+  encoding: "utf8",
+  maxBuffer: 64 * 1024 * 1024,
+});
+process.stdout.write(run.stdout ?? "");
+process.stderr.write(run.stderr ?? "");
+if (run.status !== 0) process.exit(run.status ?? 1);
+
+const text = `${run.stdout}\n${run.stderr}`;
+const count = (label) => {
+  const m = text.match(new RegExp(`(?:ℹ|#)\\s+${label}\\s+(\\d+)`));
+  return m ? Number(m[1]) : null;
+};
+const tests = count("tests");
+const passed = count("pass");
+if (tests === null || passed === null) fail("could not read the test runner's summary; refusing to report success.");
+if (tests === 0 || passed === 0) fail(`test runner executed ${tests} tests (${passed} passed). Exiting non-zero: zero tests run must not read as a pass.`);
+if (tests < MIN_TESTS) fail(`test runner executed only ${tests} tests; expected at least ${MIN_TESTS}. A truncated or emptied suite must not read as a pass.`);

package/test/cli.test.mjs

@@ -0,0 +1,46 @@
+/**
+ * CLI sanity tests.
+ *
+ * Doesn't run the full MCP loop (covered by proxy-end-to-end), just
+ * confirms the CLI parses args correctly, surfaces --help / --version,
+ * and refuses to start without enough configuration.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import url from "node:url";
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+const BIN = path.resolve(__dirname, "..", "bin", "strix-mcp-proxy.mjs");
+
+function runCli(args, opts = {}) {
+  return spawnSync("node", [BIN, ...args], { encoding: "utf8", timeout: 10_000, ...opts });
+}
+
+test("--help prints usage and exits 0", () => {
+  const out = runCli(["--help"]);
+  assert.equal(out.status, 0);
+  assert.match(out.stdout, /strix-mcp-proxy/);
+  assert.match(out.stdout, /CONFIG-FILE MODE/);
+  assert.match(out.stdout, /FLAG MODE/);
+});
+
+test("--version prints the package version and exits 0", () => {
+  const out = runCli(["--version"]);
+  assert.equal(out.status, 0);
+  assert.match(out.stdout, /^strix-mcp-proxy \d+\.\d+\.\d+/);
+});
+
+test("no args: refuses to start with a clear error", () => {
+  const out = runCli([], { input: "" });
+  assert.notEqual(out.status, 0, "must exit non-zero without enough config");
+  assert.match(out.stderr, /missing --config or --upstream-command/);
+});
+
+test("missing --config file: clear error", () => {
+  const out = runCli(["--config", "/nonexistent/strix-proxy-cli-test.json"], { input: "" });
+  assert.notEqual(out.status, 0);
+  assert.match(out.stderr, /could not read/);
+});

package/test/config.test.mjs

@@ -0,0 +1,138 @@
+/**
+ * Config loader tests — the CLI's only durable input is the config
+ * file, so the loader's validation rules are the proxy's public
+ * contract for operator-managed deployments.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import path from "node:path";
+import { tmpdir } from "node:os";
+
+import { loadConfig, resolveCapabilities } from "../src/config.mjs";
+
+async function withTempConfig(contents, fn) {
+  const dir = mkdtempSync(path.join(tmpdir(), "strix-proxy-config-"));
+  const file = path.join(dir, "proxy.json");
+  writeFileSync(file, typeof contents === "string" ? contents : JSON.stringify(contents));
+  try { return await fn(file); } finally { rmSync(dir, { recursive: true, force: true }); }
+}
+
+test("loadConfig: rejects missing file", async () => {
+  await assert.rejects(loadConfig("/this/path/does/not/exist.json"), /could not read/);
+});
+
+test("loadConfig: rejects malformed JSON", async () => {
+  await withTempConfig("{ not: json }", async (file) => {
+    await assert.rejects(loadConfig(file), /not valid JSON/);
+  });
+});
+
+test("loadConfig: rejects non-object root", async () => {
+  await withTempConfig("[]", async (file) => {
+    await assert.rejects(loadConfig(file), /must be a JSON object/);
+  });
+});
+
+test("loadConfig: requires upstream.command", async () => {
+  await withTempConfig({ upstream: {} }, async (file) => {
+    await assert.rejects(loadConfig(file), /upstream\.command/);
+  });
+});
+
+test("loadConfig: rejects non-array upstream.args", async () => {
+  await withTempConfig({ upstream: { command: "npx", args: "oops" } }, async (file) => {
+    await assert.rejects(loadConfig(file), /upstream\.args/);
+  });
+});
+
+test("loadConfig: rejects non-object policy", async () => {
+  await withTempConfig({ upstream: { command: "x" }, policy: "deny-all" }, async (file) => {
+    await assert.rejects(loadConfig(file), /'policy' must be an object/);
+  });
+});
+
+test("loadConfig: expands a leading ~ in storagePath", async () => {
+  await withTempConfig(
+    { upstream: { command: "npx" }, storagePath: "~/strix-receipts" },
+    async (file) => {
+      const cfg = await loadConfig(file);
+      assert.ok(!cfg.storagePath.startsWith("~"), `expected ~ to expand; got ${cfg.storagePath}`);
+    },
+  );
+});
+
+test("loadConfig: returns the parsed config when valid", async () => {
+  await withTempConfig(
+    {
+      serverId: "notion",
+      upstream: { command: "npx", args: ["-y", "@notionhq/notion-mcp-server"] },
+      policy: { default: "DENY" },
+    },
+    async (file) => {
+      const cfg = await loadConfig(file);
+      assert.equal(cfg.serverId, "notion");
+      assert.equal(cfg.upstream.command, "npx");
+      assert.deepEqual(cfg.upstream.args, ["-y", "@notionhq/notion-mcp-server"]);
+    },
+  );
+});
+
+test("loadConfig: missing keyPath is fine (undefined passes through)", async () => {
+  await withTempConfig({ upstream: { command: "npx" } }, async (file) => {
+    const cfg = await loadConfig(file);
+    assert.equal(cfg.keyPath, undefined);
+  });
+});
+
+test("loadConfig: rejects non-string keyPath", async () => {
+  await withTempConfig({ upstream: { command: "npx" }, keyPath: 42 }, async (file) => {
+    await assert.rejects(loadConfig(file), /'keyPath' must be a string/);
+  });
+});
+
+test("loadConfig: expands a leading ~ in keyPath", async () => {
+  await withTempConfig(
+    { upstream: { command: "npx" }, keyPath: "~/.strix-mcp-proxy/my-server/keys" },
+    async (file) => {
+      const cfg = await loadConfig(file);
+      assert.ok(!cfg.keyPath.startsWith("~"), `expected ~ to expand; got ${cfg.keyPath}`);
+      assert.ok(cfg.keyPath.includes(".strix-mcp-proxy/my-server/keys"));
+    },
+  );
+});
+
+test("loadConfig: passes a valid string keyPath through unchanged", async () => {
+  await withTempConfig(
+    { upstream: { command: "npx" }, keyPath: "/opt/strix/keys" },
+    async (file) => {
+      const cfg = await loadConfig(file);
+      assert.equal(cfg.keyPath, "/opt/strix/keys");
+    },
+  );
+});
+
+test("resolveCapabilities: passes an inline array through unchanged", async () => {
+  const arr = [{ id: "x", name: "x", risk: "LOW", mode: "READ", description: "x" }];
+  const out = await resolveCapabilities(arr);
+  assert.equal(out, arr);
+});
+
+test("resolveCapabilities: returns undefined for null/undefined input", async () => {
+  assert.equal(await resolveCapabilities(undefined), undefined);
+  assert.equal(await resolveCapabilities(null), undefined);
+});
+
+test("resolveCapabilities: rejects non-string non-array input", async () => {
+  await assert.rejects(resolveCapabilities(42), /must be a string import path or an array/);
+});
+
+test("resolveCapabilities: resolves a companion-pack module by import path", async () => {
+  // Uses the workspace-symlinked package — exercises the real
+  // dynamic-import flow the CLI would use in production.
+  const caps = await resolveCapabilities("@strixgov/capabilities-mcp-common/notion");
+  assert.ok(Array.isArray(caps));
+  assert.ok(caps.length > 0);
+  assert.ok(caps.every((c) => c.id?.startsWith("mcp.notion.")));
+});

package/test/nvidia-nooa-profile.test.mjs

@@ -0,0 +1,69 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const exampleDir = path.resolve(here, "../examples/nvidia-nooa");
+
+test("NOOA .mcp.json launches the Strix proxy over stdio with trusted identity", async () => {
+  const config = JSON.parse(
+    await fs.readFile(path.join(exampleDir, ".mcp.json"), "utf8"),
+  );
+  const server = config.mcpServers.strix_secure_coding;
+  assert.equal(server.transport, "stdio");
+  assert.match(server.args.join(" "), /strix-mcp-proxy\.mjs/);
+  assert.equal(server.env.STRIX_REQUIRE_TRUSTED_IDENTITY, "true");
+  assert.match(server.env.STRIX_TRUSTED_ACTOR_ID, /^spiffe:\/\//);
+  assert.equal(server.env.STRIX_TENANT_ID, "nvidia-nooa-demo");
+  assert.equal(server.env.STRIX_ENVIRONMENT, "openshell");
+});
+
+test("NOOA proxy policy is fail-closed and protects consequential actions", async () => {
+  const config = JSON.parse(
+    await fs.readFile(path.join(exampleDir, "proxy-config.json"), "utf8"),
+  );
+  assert.equal(config.policy.default, "DENY");
+  assert.equal(
+    config.policy.rules["mcp.nooa-secure-coding.inspect_repository"],
+    "ALLOW",
+  );
+  assert.equal(
+    config.policy.rules["mcp.nooa-secure-coding.propose_patch"],
+    "ALLOW",
+  );
+  assert.equal(
+    config.policy.rules["mcp.nooa-secure-coding.merge_production"],
+    "APPROVAL_REQUIRED",
+  );
+  assert.equal(
+    config.policy.rules["mcp.nooa-secure-coding.rotate_credentials"],
+    "DENY",
+  );
+  assert.equal(config.approval.type, "file");
+  assert.ok(config.storagePath);
+  assert.ok(config.keyPath);
+});
+
+test("OpenShell template leaves Python without ordinary downstream egress", async () => {
+  const policy = await fs.readFile(
+    path.join(exampleDir, "openshell-policy.yaml"),
+    "utf8",
+  );
+  assert.match(policy, /^version: 1/m);
+  assert.match(policy, /run_as_user: sandbox/);
+  assert.match(policy, /api\.github\.com/);
+  assert.match(policy, /protocol: rest/);
+  assert.match(policy, /tls: terminate/);
+  assert.match(policy, /enforcement: enforce/);
+  assert.match(policy, /access: read-only/);
+  assert.doesNotMatch(policy, /path: \/usr\/bin\/python/);
+  assert.doesNotMatch(policy, /path: \/usr\/local\/bin\/python/);
+});
+
+test("NOOA agent uses MCPManager.create_from_server", async () => {
+  const source = await fs.readFile(path.join(exampleDir, "nooa_agent.py"), "utf8");
+  assert.match(source, /MCPManager\.create_from_server/);
+  assert.match(source, /strix_secure_coding/);
+});

package/test/package-contract.test.mjs

@@ -0,0 +1,20 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const pkg = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
+
+const covered = (rel) =>
+  pkg.files.some((f) => rel === f || (f.endsWith("/") && rel.startsWith(f)));
+
+test("every script file the `test` script runs ships in the tarball", () => {
+  const refs = [...pkg.scripts.test.matchAll(/\b(scripts\/[\w./-]+\.mjs)\b/g)].map((m) => m[1]);
+  assert.ok(refs.length > 0, "test script should reference a script file");
+  for (const rel of refs) {
+    assert.ok(existsSync(path.join(root, rel)), `${rel} is missing from the repo`);
+    assert.ok(covered(rel), `${rel} is used by \`npm test\` but excluded by package.json "files"`);
+  }
+});