@vitest-agent/mcp 2.4.6 → 2.4.7

package/index.js

@@ -12,7 +12,7 @@ import { parseSessionEnvExports, recoverSessionContextFromSessionEnv } from "./s
 *
 * @public
 */
-const CURRENT_MCP_VERSION = "2.4.6";
+const CURRENT_MCP_VERSION = "2.4.7";
 
 //#endregion
 export { CURRENT_MCP_VERSION, McpLive, appRouter, buildMcpServer, createCallerFactory, createCurrentSessionIdRef, createSessionContextRef, parseSessionEnvExports, recoverSessionContextFromSessionEnv, startMcpServer };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/mcp",
-	"version": "2.4.6",
+	"version": "2.4.7",
 	"private": false,
 	"description": "Model Context Protocol server for vitest-agent. Exposes 53 tools for agent access to test data, TDD lifecycle, and session management.",
 	"keywords": [

package/server.js

@@ -405,11 +405,11 @@ function buildMcpServer(ctx) {
 		};
 	});
 	server.registerTool("run_tests", {
-		description: "Use to run Vitest tests, with optional file, project, and tag filters. structuredContent carries the typed AgentReport plus per-test classifications (discriminate on `kind`: ok, timeout, error, no-match). Unknown parameters are rejected — accepted keys are files, project, tags, passWithNoTests, timeout, projectRoot. The server's Vitest root is normally frozen at boot (ctx.cwd) — projectRoot overrides it for this call, but only after validation: it must be an existing directory belonging to the same git repository as ctx.cwd (checked via `git rev-parse --git-common-dir`, which is identical across a repo and all its worktrees, including a sibling worktree checked out from the same repo). A path in a different repository, or a non-existent path, is rejected with `{ kind: \"error\" }` naming both paths — never a silent fallback to ctx.cwd. The resolved root actually used is always echoed back on success. The legacy format=json arg is dropped — structuredContent supersedes it.",
+		description: "Use to run Vitest tests, with optional file, project, and tag filters. structuredContent carries the typed AgentReport plus per-test classifications (discriminate on `kind`: ok, timeout, error, no-match). Unknown parameters are rejected — accepted keys are files, project, tags, passWithNoTests, timeout, projectRoot. When projectRoot is omitted, the server anchors the Vitest root at the directory of the vitest (or vite) config Vitest would load anyway, walking up from its boot dir and stopping at the git root — so a server booted inside a package subtree still resolves the root config's relative globalSetup/setupFiles correctly. projectRoot overrides that for this call and is used verbatim, but only after validation: it must be an existing directory belonging to the same git repository as ctx.cwd (checked via `git rev-parse --git-common-dir`, which is identical across a repo and all its worktrees, including a sibling worktree checked out from the same repo). A path in a different repository, or a non-existent path, is rejected with `{ kind: \"error\" }` naming both paths — never a silent fallback to ctx.cwd. The resolved root actually used is always echoed back on success. The legacy format=json arg is dropped — structuredContent supersedes it.",
 		inputSchema: strict({
 			files: z.optional(z.array(z.string())).describe("Test file paths to run"),
 			project: z.optional(z.string()).describe("Project name to filter"),
-			projectRoot: z.optional(z.string()).describe("Explicit Vitest root to use instead of the server's boot-time ctx.cwd. Prefer an absolute path; a relative path is resolved against ctx.cwd, not the server process's cwd. Validated: must be an existing directory in the same git repository as ctx.cwd (same git-common-dir, e.g. a sibling worktree). Rejected with { kind: 'error' } naming both paths otherwise."),
+			projectRoot: z.optional(z.string()).describe("Explicit Vitest root for this call, used verbatim. Omit it to get the config-anchored default (walk up from the server's boot dir for a vitest/vite config, bounded at the git root). Prefer an absolute path; a relative path is resolved against ctx.cwd, not the server process's cwd. Validated: must be an existing directory in the same git repository as ctx.cwd (same git-common-dir, e.g. a sibling worktree). Rejected with { kind: 'error' } naming both paths otherwise."),
 			tags: z.optional(strict({
 				all: z.optional(z.array(z.string())).describe("Require every listed tag"),
 				any: z.optional(z.array(z.string())).describe("Require at least one listed tag"),

package/tools/run-tests.js

@@ -1,13 +1,15 @@
 import { publicProcedure } from "../context.js";
+import { createRequire } from "node:module";
 import { AgentReport, DataReader, DataStore, buildAgentReport, buildConsoleLeaks, coerceErrorField, collectConsoleLeakEntries } from "@vitest-agent/sdk";
 import { Effect, Schema, SchemaGetter } from "effect";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { execFile } from "node:child_process";
-import { mkdtempSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
 import { realpath, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { Writable } from "node:stream";
+import { pathToFileURL } from "node:url";
 import { promisify } from "node:util";
 
 //#region src/tools/run-tests.ts
@@ -192,15 +194,52 @@ async function resolveGitCommonDir(dir) {
 		return null;
 	}
 }
+const VITEST_CONFIG_EXTENSIONS = [
+	"ts",
+	"mts",
+	"cts",
+	"js",
+	"mjs",
+	"cjs"
+];
+function dirHasVitestOrViteConfig(dir) {
+	for (const prefix of ["vitest.config.", "vite.config."]) for (const ext of VITEST_CONFIG_EXTENSIONS) if (existsSync(join(dir, `${prefix}${ext}`))) return true;
+	return false;
+}
+/**
+* Walk UP from `startDir` looking for the vitest/vite config Vitest would
+* load anyway, returning the directory that holds it. Bounded at the git
+* root (inclusive — the directory containing `.git` is still examined
+* before the walk stops). Returns `startDir` unchanged when no config is
+* found in range, or when anything about the walk throws. See the
+* issue #259 comment above `validateProjectRoot` for the full rationale.
+*
+* @internal exported for tests
+*/
+function resolveConfigAnchoredRoot(startDir) {
+	try {
+		let dir = resolve(startDir);
+		for (;;) {
+			if (dirHasVitestOrViteConfig(dir)) return dir;
+			if (existsSync(join(dir, ".git"))) return startDir;
+			const parent = dirname(dir);
+			if (parent === dir) return startDir;
+			dir = parent;
+		}
+	} catch {
+		return startDir;
+	}
+}
 /**
 * Validate an optional caller-supplied `projectRoot` against `ctxCwd`
-* (the MCP server's boot-time root). `undefined` always resolves to
-* `ctxCwd` unchanged (issue #252's option 1: explicit opt-in only —
-* never inferred, never defaulted to anything but the historical
-* behavior when the caller says nothing).
+* (the MCP server's boot-time root). `undefined` anchors at the directory
+* of the vitest/vite config Vitest would load anyway (issue #259, via
+* `resolveConfigAnchoredRoot`) — never inferred beyond that, never
+* defaulted to anything else when no config is found in range.
 *
-* A supplied `projectRoot` is VALIDATED, not trusted: it must resolve to
-* an existing directory that shares a git common directory with
+* A supplied `projectRoot` is VALIDATED, not trusted, and used VERBATIM
+* once validated — explicit is explicit, no anchoring applied. It must
+* resolve to an existing directory that shares a git common directory with
 * `ctxCwd` (same repository, including across worktrees). Any failure
 * returns `{ ok: false, message }` naming both paths — never a silent
 * fallback to `ctxCwd`, never a raw throw.
@@ -210,7 +249,7 @@ async function resolveGitCommonDir(dir) {
 async function validateProjectRoot(projectRoot, ctxCwd) {
 	if (projectRoot === void 0) return {
 		ok: true,
-		root: ctxCwd
+		root: resolveConfigAnchoredRoot(ctxCwd)
 	};
 	const resolvedRoot = resolve(ctxCwd, projectRoot);
 	let isDirectory;
@@ -236,6 +275,57 @@ async function validateProjectRoot(projectRoot, ctxCwd) {
 		root: resolvedRoot
 	};
 }
+/**
+* Issue #303: resolve `vitest/node` anchored at the run's project root
+* instead of the bare `"vitest/node"` specifier, which resolves relative to
+* `@vitest-agent/mcp`'s OWN install location. `vitest` is a peerDependency
+* of this package, and pnpm routinely materializes MORE THAN ONE physical
+* instance of the same vitest version when peer-resolution hashes differ
+* (e.g. `vitest@4.1.11_@types+node@26.2.0_...` alongside
+* `vitest@4.1.11_@types+node@26.3.0_...` under `node_modules/.pnpm`). When
+* the bare specifier resolves to a DIFFERENT physical copy than the one the
+* project's test files import, `SnapshotClient.setup()` runs against one
+* copy's module-level `_client` singleton while `expect(...).toMatchSnapshot()`
+* inside the test file goes through the other copy's singleton, which has
+* no state — every snapshot assertion then fails with "The snapshot state
+* for '<file>' is not found. Did you call 'SnapshotClient.setup()'?" while
+* every non-snapshot assertion still passes.
+*
+* `createRequire` needs a file path (not a bare directory) to anchor
+* resolution, hence the synthetic, never-created `__vitest-agent-resolver__.js`
+* filename joined onto `root`. vitest's package.json `exports` map for
+* `./node` carries a `default` condition (`./dist/node.js`) and vitest ships
+* `"type": "module"`, so `require.resolve("vitest/node")` resolves correctly
+* even though vitest itself is ESM — the result is then converted to a
+* `file://` URL, which is what dynamic `import()` needs.
+*
+* Falls back to the bare `"vitest/node"` specifier when root-anchored
+* resolution throws (e.g. a project root with no local vitest install) so
+* that case keeps working exactly as it did before this fix.
+*
+* @internal exported for tests
+*/
+function resolveVitestNodeEntry(root) {
+	try {
+		const req = createRequire(join(root, "__vitest-agent-resolver__.js"));
+		return pathToFileURL(req.resolve("vitest/node")).href;
+	} catch {
+		return "vitest/node";
+	}
+}
+/**
+* Indirection seam around `import(<vitest/node entry>)`. vitest's own
+* vite-node externalizes "vitest"/"vitest/node" for every importer, and
+* `vi.mock("vitest/node", ...)` only special-cases AST-literal
+* `import("vitest/node")` call sites for interception — a computed
+* specifier (unavoidable here; see `resolveVitestNodeEntry`) silently
+* bypasses that interception and loads the real module. Tests substitute
+* `.load` directly (mutating this shared object's property — no `vi.mock`
+* required) instead of trying to mock the module.
+*
+* @internal exported for tests
+*/
+const vitestLoader = { load: (entry) => import(entry) };
 let _runTestsChain = Promise.resolve();
 function serializeRunTests(fn) {
 	const next = _runTestsChain.then(fn, fn);
@@ -416,7 +506,7 @@ const runTests = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 	const nullStream = new Writable({ write(_chunk, _encoding, cb) {
 		cb();
 	} });
-	const { createVitest } = await import("vitest/node");
+	const { createVitest } = await vitestLoader.load(resolveVitestNodeEntry(resolvedRoot));
 	let vitest;
 	let covOverride;
 	try {
@@ -522,4 +612,4 @@ const runTests = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 }));
 
 //#endregion
-export { RunTestsAsMarkdown, RunTestsResult, coerceErrors, composeTagExpression, formatNoMatchMarkdown, formatReportMarkdown, formatRunTestsMarkdown, makeCoverageDirOverride, readDiscoveryLastScannedAt, resolveGitCommonDir, runTests, sanitizeTestArgs, validateProjectRoot, withStdioCaptured };
+export { RunTestsAsMarkdown, RunTestsResult, coerceErrors, composeTagExpression, formatNoMatchMarkdown, formatReportMarkdown, formatRunTestsMarkdown, makeCoverageDirOverride, readDiscoveryLastScannedAt, resolveConfigAnchoredRoot, resolveGitCommonDir, resolveVitestNodeEntry, runTests, sanitizeTestArgs, validateProjectRoot, vitestLoader, withStdioCaptured };