@letsrunit/mcp-server 0.13.3 → 0.14.0

package/README.md

@@ -50,6 +50,17 @@ args = ["-y", "@letsrunit/mcp-server@latest"]
 }
 ```
 
+## Project-local support files
+
+Keep using the same MCP command (`npx -y @letsrunit/mcp-server@latest`).
+
+At runtime, letsrunit checks the current project:
+
+- If the project has `@letsrunit/mcp-server` installed, it hands off to that project-local server and loads support files/custom steps.
+- If not, it stays in standalone mode and runs built-in letsrunit steps only.
+
+So custom steps from `features/support/**` are available when `@letsrunit/mcp-server` is installed in that project.
+
 ## Tools
 
 | Tool | Description |

package/dist/index.js

@@ -3,581 +3,105 @@ import * as __m from 'node:module';
 import { createRequire } from 'module';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { Controller } from '@letsrunit/controller';
-import { MemorySink, Journal } from '@letsrunit/journal';
-import { join, dirname, resolve, isAbsolute } from 'path';
-import { z } from 'zod';
-import { loadConfiguration } from '@cucumber/cucumber/api';
-import { registry } from '@letsrunit/bdd';
-import { readFileSync, existsSync } from 'fs';
-import { mkdir, writeFile, glob } from 'fs/promises';
-import { pathToFileURL } from 'url';
-import { scrubHtml, screenshotElement, screenshot, unifiedHtmlDiff } from '@letsrunit/playwright';
-import { openStore, findLastTest, findArtifacts } from '@letsrunit/store';
-import { execSync } from 'child_process';
-import { scenarioIdFromGherkin } from '@letsrunit/gherkin';
+import { spawnSync } from 'child_process';
+import { realpathSync, readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
 
 __m.createRequire(import.meta.url);
-var SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
-var BASE_ARTIFACT_DIR = process.env.LETSRUNIT_ARTIFACT_DIR ?? join(process.env.HOME ?? "/tmp", ".letsrunit", "artifacts");
-function sessionId() {
-  return Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+function resolveProjectRoot() {
+  return resolve(process.env.LETSRUNIT_PROJECT_CWD ?? process.cwd());
 }
-var SessionManager = class {
-  sessions = /* @__PURE__ */ new Map();
-  timers = /* @__PURE__ */ new Map();
-  async create(options = {}) {
-    const id = sessionId();
-    const artifactDir = join(BASE_ARTIFACT_DIR, id);
-    const sink = new MemorySink(artifactDir);
-    const journal = new Journal(sink);
-    const controller = await Controller.launch({ ...options, journal });
-    const session = {
-      id,
-      controller,
-      sink,
-      journal,
-      artifactDir,
-      createdAt: Date.now(),
-      lastActivity: Date.now(),
-      stepCount: 0
-    };
-    this.sessions.set(id, session);
-    this.resetTimer(id);
-    return session;
-  }
-  get(id) {
-    const session = this.sessions.get(id);
-    if (!session) throw new Error(`Session not found: ${id}`);
-    return session;
-  }
-  has(id) {
-    return this.sessions.has(id);
-  }
-  touch(id) {
-    const session = this.sessions.get(id);
-    if (session) {
-      session.lastActivity = Date.now();
-      this.resetTimer(id);
-    }
-  }
-  list() {
-    return Array.from(this.sessions.values());
-  }
-  async close(id) {
-    const session = this.sessions.get(id);
-    if (!session) return;
-    clearTimeout(this.timers.get(id));
-    this.timers.delete(id);
-    this.sessions.delete(id);
-    await session.controller.close();
-  }
-  resetTimer(id) {
-    clearTimeout(this.timers.get(id));
-    const timer = setTimeout(() => this.close(id), SESSION_TIMEOUT_MS);
-    if (typeof timer === "object" && "unref" in timer) timer.unref();
-    this.timers.set(id, timer);
-  }
-};
-
-// src/utility/response.ts
-function text(content) {
-  return { content: [{ type: "text", text: content }] };
-}
-function err(message) {
-  return { content: [{ type: "text", text: message }], isError: true };
-}
-
-// src/tools/debug.ts
-function registerDebug(server2, sessions2) {
-  server2.registerTool(
-    "letsrunit_debug",
-    {
-      description: "Evaluate JavaScript on the current page via Playwright page.evaluate(). Use for debugging \u2014 not for test logic.",
-      inputSchema: {
-        sessionId: z.string().describe("Session ID"),
-        script: z.string().describe("JavaScript expression or function body to evaluate in the page context")
-      }
-    },
-    async (input) => {
-      try {
-        const session = sessions2.get(input.sessionId);
-        sessions2.touch(input.sessionId);
-        const result = await session.controller.page.evaluate(input.script);
-        return text(JSON.stringify({ result }));
-      } catch (e) {
-        return text(JSON.stringify({ result: null, error: e.message }));
-      }
-    }
-  );
-}
-var CUCUMBER_CONFIG_FILES = [
-  "cucumber.js",
-  "cucumber.mjs",
-  "cucumber.cjs",
-  "cucumber.ts",
-  "cucumber.mts",
-  "cucumber.cts"
-];
-var loadedProjectRoots = /* @__PURE__ */ new Set();
-var loadedSupportEntries = /* @__PURE__ */ new Set();
-function toStrings(value) {
-  if (!Array.isArray(value)) return [];
-  return value.filter((entry) => typeof entry === "string");
-}
-function hasGlobMagic(input) {
-  return /[*?[\]{}]/.test(input);
-}
-function isPathLike(input) {
-  return input.startsWith(".") || input.startsWith("/") || /^[A-Za-z]:[\\/]/.test(input);
-}
-function toAbsolutePath(baseDir, input) {
-  return isAbsolute(input) ? resolve(input) : resolve(baseDir, input);
-}
-function normalizeMatch(baseDir, match) {
-  return isAbsolute(match) ? resolve(match) : resolve(baseDir, match);
-}
-async function expandPathPatterns(baseDir, patterns) {
-  const files = /* @__PURE__ */ new Set();
-  for (const pattern of patterns) {
-    if (hasGlobMagic(pattern)) {
-      for await (const match of glob(pattern, { cwd: baseDir, absolute: true, withFileTypes: false })) {
-        files.add(normalizeMatch(baseDir, match));
-      }
-      continue;
-    }
-    files.add(toAbsolutePath(baseDir, pattern));
-  }
-  return files;
-}
-async function resolveSupportEntries(baseDir, entries) {
-  const resolved = [];
-  for (const entry of entries) {
-    if (hasGlobMagic(entry)) {
-      for await (const match of glob(entry, { cwd: baseDir, absolute: true, withFileTypes: false })) {
-        resolved.push({ kind: "path", value: normalizeMatch(baseDir, match) });
-      }
-      continue;
-    }
-    if (!isPathLike(entry)) {
-      resolved.push({ kind: "module", value: entry });
-      continue;
-    }
-    resolved.push({ kind: "path", value: toAbsolutePath(baseDir, entry) });
-  }
-  return resolved;
-}
-function findCucumberConfig(cwd) {
-  for (const filename of CUCUMBER_CONFIG_FILES) {
-    const path = resolve(cwd, filename);
-    if (existsSync(path)) return path;
-  }
-  return null;
-}
-async function loadLetsrunitIgnorePatterns(cwd) {
-  const configPath = findCucumberConfig(cwd);
-  if (!configPath) return [];
-  const configModule = await import(pathToFileURL(configPath).href);
-  const config = configModule.default ?? configModule;
-  return toStrings(config.letsrunit?.ignore);
-}
-function resolveEffectiveCwd(cwd) {
-  return cwd ?? process.env.LETSRUNIT_PROJECT_CWD ?? process.cwd();
-}
-function resolveFrom(moduleId, fromPath) {
+function resolveFromProject(moduleId, projectRoot) {
   try {
-    const req = createRequire(fromPath);
+    const req = createRequire(resolve(projectRoot, "package.json"));
     return req.resolve(moduleId);
   } catch {
     return null;
   }
 }
-async function collectSupportDiagnostics(cwd) {
-  const effectiveCwd = resolveEffectiveCwd(cwd);
-  const projectRoot = resolve(effectiveCwd);
-  const cucumberConfigPath = findCucumberConfig(projectRoot);
-  const { useConfiguration } = await loadConfiguration({}, { cwd: projectRoot });
-  const supportPatterns = [...toStrings(useConfiguration.require), ...toStrings(useConfiguration.import)];
-  const ignorePatterns = await loadLetsrunitIgnorePatterns(projectRoot);
-  const ignoredPaths = await expandPathPatterns(projectRoot, ignorePatterns);
-  const supportEntries = await resolveSupportEntries(projectRoot, supportPatterns);
-  const serverBddPath = resolveFrom("@letsrunit/bdd", import.meta.url);
-  const projectBddPath = resolveFrom("@letsrunit/bdd", resolve(projectRoot, "package.json"));
-  const registryDefinitions = registry.defs.map((def) => ({
-    type: def.type,
-    source: def.source,
-    comment: def.comment
-  }));
-  return {
-    envProjectCwd: process.env.LETSRUNIT_PROJECT_CWD ?? null,
-    processCwd: process.cwd(),
-    inputCwd: cwd ?? null,
-    effectiveCwd,
-    projectRoot,
-    cucumberConfigPath,
-    supportPatterns,
-    ignorePatterns,
-    ignoredPaths: [...ignoredPaths].sort(),
-    supportEntries,
-    loadedProjectRoots: [...loadedProjectRoots].sort(),
-    loadedSupportEntries: [...loadedSupportEntries].sort(),
-    moduleResolution: {
-      serverBddPath,
-      projectBddPath,
-      sameModule: !!serverBddPath && !!projectBddPath && serverBddPath === projectBddPath
-    },
-    registry: {
-      total: registryDefinitions.length,
-      byType: {
-        Given: registryDefinitions.filter((d) => d.type === "Given").length,
-        When: registryDefinitions.filter((d) => d.type === "When").length,
-        Then: registryDefinitions.filter((d) => d.type === "Then").length
-      },
-      definitions: registryDefinitions
-    }
-  };
-}
-async function loadSupportFiles(cwd) {
-  const projectRoot = resolve(resolveEffectiveCwd(cwd));
-  if (loadedProjectRoots.has(projectRoot)) return;
-  const { useConfiguration } = await loadConfiguration({}, { cwd: projectRoot });
-  const supportPatterns = [...toStrings(useConfiguration.require), ...toStrings(useConfiguration.import)];
-  if (supportPatterns.length === 0) {
-    loadedProjectRoots.add(projectRoot);
-    return;
-  }
-  const ignorePatterns = await loadLetsrunitIgnorePatterns(projectRoot);
-  const ignoredPaths = await expandPathPatterns(projectRoot, ignorePatterns);
-  const supportEntries = await resolveSupportEntries(projectRoot, supportPatterns);
-  for (const entry of supportEntries) {
-    if (entry.kind === "path" && ignoredPaths.has(entry.value)) {
-      continue;
-    }
-    const key = `${entry.kind}:${entry.value}`;
-    if (loadedSupportEntries.has(key)) continue;
-    if (entry.kind === "path") {
-      await import(pathToFileURL(entry.value).href);
-    } else {
-      await import(entry.value);
-    }
-    loadedSupportEntries.add(key);
-  }
-  loadedProjectRoots.add(projectRoot);
-}
-
-// src/tools/diagnostics.ts
-function registerDiagnostics(server2) {
-  server2.registerTool(
-    "letsrunit_diagnostics",
-    {
-      description: "Return runtime diagnostics for MCP support-file loading (cwd resolution, cucumber config path, support entries). Available only when LETSRUNIT_MCP_DIAGNOSTICS=enabled.",
-      inputSchema: {}
-    },
-    async () => {
-      try {
-        const diagnostics = await collectSupportDiagnostics();
-        return text(JSON.stringify(diagnostics));
-      } catch (e) {
-        return err(`Diagnostics failed: ${e.message}`);
-      }
-    }
-  );
-}
-var DEFAULT_DB_PATH = join(process.cwd(), ".letsrunit", "letsrunit.db");
-function getDbPath() {
-  return process.env.LETSRUNIT_DB_PATH ?? DEFAULT_DB_PATH;
-}
-function resolveAllowedCommits() {
+function toRealpath(path) {
+  if (!path) return null;
   try {
-    const output = execSync("git log --format=%H", { encoding: "utf8" });
-    return output.trim().split("\n").filter(Boolean);
+    return realpathSync(path);
   } catch {
-    return void 0;
+    return null;
   }
 }
-function registerDiff(server2, sessions2) {
-  server2.registerTool(
-    "letsrunit_diff",
-    {
-      description: "Diff the current live page against the HTML snapshot from the last passing test of a scenario. Pass the scenarioId returned by letsrunit_run. Returns a unified HTML diff and paths to baseline screenshots. By default only considers baseline tests from the current git ancestry (gitTreeOnly: true).",
-      inputSchema: {
-        sessionId: z.string().describe("Session ID returned by letsrunit_session_start"),
-        scenarioId: z.string().describe("Scenario UUID returned by letsrunit_run"),
-        gitTreeOnly: z.boolean().optional().describe("Restrict baseline to tests from the current git ancestry (default: true)")
-      }
-    },
-    async (input) => {
-      const dbPath = getDbPath();
-      const artifactDir = join(dirname(dbPath), "artifacts");
-      let db;
-      try {
-        try {
-          db = openStore(dbPath);
-        } catch {
-          return err("Could not open the letsrunit store. Run cucumber with the store formatter first.");
-        }
-        const allowedCommits = input.gitTreeOnly ?? true ? resolveAllowedCommits() : void 0;
-        const test = findLastTest(db, input.scenarioId, "passed", allowedCommits ?? void 0);
-        if (!test) {
-          return err(
-            allowedCommits ? "No passing test found for this scenario in the current git ancestry. Try gitTreeOnly: false or run cucumber first." : "No passing test found for this scenario."
-          );
-        }
-        const artifacts = findArtifacts(db, test.id);
-        const htmlArtifact = [...artifacts].reverse().find((a) => a.filename.endsWith(".html"));
-        if (!htmlArtifact) {
-          return err("No HTML snapshot found in the baseline test. Ensure the store formatter is configured.");
-        }
-        const storedHtml = readFileSync(join(artifactDir, htmlArtifact.filename), "utf-8");
-        const session = sessions2.get(input.sessionId);
-        sessions2.touch(input.sessionId);
-        const diff = await unifiedHtmlDiff({ html: storedHtml, url: "about:blank" }, session.controller.page);
-        const screenshots = artifacts.filter((a) => a.stepIdx === htmlArtifact.stepIdx && a.filename.endsWith(".png")).map((a) => join(artifactDir, a.filename));
-        return text(
-          JSON.stringify({
-            diff,
-            baseline: {
-              testId: test.id,
-              commit: test.gitCommit,
-              screenshots
-            }
-          })
-        );
-      } catch (e) {
-        return err(`Diff failed: ${e.message}`);
-      } finally {
-        db?.close();
-      }
-    }
-  );
-}
-var stepTypeSchema = z.enum(["Given", "When", "Then"]);
-function registerListSteps(server2, sessions2) {
-  server2.registerTool(
-    "letsrunit_list_steps",
-    {
-      description: "List available step definitions for a session. Optionally filter by step type (Given/When/Then).",
-      inputSchema: {
-        sessionId: z.string().describe("Session ID returned by letsrunit_session_start"),
-        type: stepTypeSchema.optional().describe("Optional step type filter")
-      }
-    },
-    async (input) => {
-      try {
-        const session = sessions2.get(input.sessionId);
-        sessions2.touch(input.sessionId);
-        const steps = session.controller.listSteps(input.type);
-        return text(JSON.stringify({ steps }));
-      } catch (e) {
-        return err(`List steps failed: ${e.message}`);
-      }
-    }
-  );
-}
-
-// src/tools/list-sessions.ts
-function registerListSessions(server2, sessions2) {
-  server2.registerTool(
-    "letsrunit_list_sessions",
-    {
-      description: "List all active browser sessions.",
-      inputSchema: {}
-    },
-    async () => {
-      const list = sessions2.list().map((s) => ({
-        sessionId: s.id,
-        createdAt: s.createdAt,
-        lastActivity: s.lastActivity,
-        stepCount: s.stepCount,
-        artifactDir: s.artifactDir
-      }));
-      return text(JSON.stringify({ sessions: list }));
-    }
-  );
+function samePackageRoot(a, b) {
+  if (!a || !b) return false;
+  return dirname(a) === dirname(b);
 }
-
-// src/utility/gherkin.ts
-function normalizeGherkin(input) {
-  const trimmed = input.trim();
-  if (/^(Feature|Scenario|Background):/im.test(trimmed)) {
-    return trimmed;
+function resolveBinPath(packageJsonPath) {
+  const text = readFileSync(packageJsonPath, "utf8");
+  const pkg = JSON.parse(text);
+  if (typeof pkg.bin === "string") {
+    return resolve(dirname(packageJsonPath), pkg.bin);
   }
-  return `Feature: MCP
-
-Scenario: Steps
-  ${trimmed.split("\n").join("\n  ")}`;
-}
-
-// src/tools/run.ts
-function registerRun(server2, sessions2) {
-  server2.registerTool(
-    "letsrunit_run",
-    {
-      description: "Execute Gherkin steps or a complete feature in the browser. Accepts a single step line, multiple step lines, a full Scenario, or a full Feature. Returns status, steps, reason on failure, and journal entries. Does not return a page snapshot \u2014 call letsrunit_snapshot explicitly if you need the DOM.",
-      inputSchema: {
-        sessionId: z.string().describe("Session ID returned by letsrunit_session_start"),
-        input: z.string().describe(
-          'Gherkin text to execute: one or more step lines (e.g. "Given I am on \\"https://example.com\\""), a Scenario block, or a full Feature block.'
-        )
-      }
-    },
-    async (input) => {
-      try {
-        const session = sessions2.get(input.sessionId);
-        sessions2.touch(input.sessionId);
-        const feature = normalizeGherkin(input.input);
-        session.sink.clear();
-        const result = await session.controller.run(feature);
-        session.stepCount += result.steps.length;
-        return text(
-          JSON.stringify({
-            status: result.status,
-            steps: result.steps,
-            reason: result.reason?.message,
-            journal: session.sink.getEntries(),
-            scenarioId: scenarioIdFromGherkin(input.input)
-          })
-        );
-      } catch (e) {
-        return err(`Run failed: ${e.message}`);
-      }
-    }
-  );
-}
-function registerScreenshot(server2, sessions2) {
-  server2.registerTool(
-    "letsrunit_screenshot",
-    {
-      description: "Take a screenshot of the current page. Optionally crop to a specific element (selector) or highlight elements before capturing (mask).",
-      inputSchema: {
-        sessionId: z.string().describe("Session ID"),
-        selector: z.string().optional().describe("CSS selector \u2014 crop screenshot to the bounding box of this element"),
-        mask: z.array(z.string()).optional().describe("CSS selectors whose matching elements are highlighted (dark overlay, element spotlighted)."),
-        fullPage: z.boolean().optional().describe("Capture the full scrollable page (default: false)")
-      }
-    },
-    async (input) => {
-      try {
-        const session = sessions2.get(input.sessionId);
-        sessions2.touch(input.sessionId);
-        const page = session.controller.page;
-        let file;
-        if (input.selector) {
-          file = await screenshotElement(page, input.selector);
-        } else {
-          const masks = input.mask?.map((sel) => page.locator(sel)) ?? [];
-          file = await screenshot(page, {
-            fullPage: input.fullPage ?? false,
-            ...masks.length ? { mask: masks } : {}
-          });
-        }
-        await mkdir(session.artifactDir, { recursive: true });
-        const path = join(session.artifactDir, file.name);
-        await writeFile(path, await file.bytes());
-        return text(JSON.stringify({ path, mimeType: "image/png" }));
-      } catch (e) {
-        return err(`Screenshot failed: ${e.message}`);
-      }
-    }
-  );
-}
-function registerSessionClose(server2, sessions2) {
-  server2.registerTool(
-    "letsrunit_session_close",
-    {
-      description: "Close a browser session and release its resources.",
-      inputSchema: {
-        sessionId: z.string().describe("Session ID to close")
-      }
-    },
-    async (input) => {
-      try {
-        await sessions2.close(input.sessionId);
-        return text(JSON.stringify({ closed: true }));
-      } catch (e) {
-        return err(`Failed to close session: ${e.message}`);
-      }
-    }
-  );
-}
-function registerSessionStart(server2, sessions2) {
-  server2.registerTool(
-    "letsrunit_session_start",
-    {
-      description: `Launch a new browser session. Does not navigate anywhere \u2014 use letsrunit_run with a Given step to navigate. Set baseURL to enable relative paths like "Given I'm on the homepage".`,
-      inputSchema: {
-        baseURL: z.string().optional().describe(`Base URL for the session, e.g. "http://localhost:3000". Enables relative paths in Given steps like "Given I'm on the homepage" or "Given I'm on page \\"/login\\""`),
-        language: z.string().optional().describe("Browser language code, e.g. 'en', 'fr'"),
-        headless: z.boolean().optional().describe("Run browser in headless mode (default: true)"),
-        viewportWidth: z.number().int().optional().describe("Viewport width in pixels (default: 1280)"),
-        viewportHeight: z.number().int().optional().describe("Viewport height in pixels (default: 720)")
-      }
-    },
-    async (input) => {
-      try {
-        await loadSupportFiles();
-        const viewport = input.viewportWidth || input.viewportHeight ? { width: input.viewportWidth ?? 1280, height: input.viewportHeight ?? 720 } : void 0;
-        const session = await sessions2.create({
-          baseURL: input.baseURL,
-          headless: input.headless ?? true,
-          locale: input.language,
-          viewport
-        });
-        return text(JSON.stringify({ sessionId: session.id }));
-      } catch (e) {
-        return err(`Failed to start session: ${e.message}`);
-      }
+  if (pkg.bin && typeof pkg.bin === "object") {
+    const named = pkg.bin["letsrunit-mcp"];
+    const first = Object.values(pkg.bin)[0];
+    const bin = named ?? first;
+    if (typeof bin === "string") {
+      return resolve(dirname(packageJsonPath), bin);
     }
-  );
+  }
+  throw new Error(`Unable to resolve mcp bin from ${packageJsonPath}`);
 }
-var stripAttributesSchema = z.nativeEnum({
-  none: 0,
-  semantic: 1,
-  aggressive: 2
-});
-function registerSnapshot(server2, sessions2) {
-  server2.registerTool(
-    "letsrunit_snapshot",
-    {
-      description: "Get the current page HTML, scrubbed for LLM consumption. Use selector to scope to a DOM subtree.",
-      inputSchema: {
-        sessionId: z.string().describe("Session ID"),
-        selector: z.string().optional().describe("CSS selector \u2014 return only the matching element's outer HTML instead of the full page"),
-        dropHidden: z.boolean().optional().describe("Remove hidden/inert nodes (default: true)"),
-        dropHead: z.boolean().optional().describe("Remove the <head> element (default: true)"),
-        pickMain: z.boolean().optional().describe("Keep only the <main> element (default: auto)"),
-        stripAttributes: stripAttributesSchema.optional().describe("Attribute allowlist level: 0=none, 1=semantic (default), 2=aggressive")
-      }
-    },
-    async (input) => {
-      try {
-        const session = sessions2.get(input.sessionId);
-        sessions2.touch(input.sessionId);
-        const page = session.controller.page;
-        const url = page.url();
-        const opts = {
-          dropHidden: input.dropHidden,
-          dropHead: input.dropHead,
-          pickMain: input.pickMain,
-          stripAttributes: input.stripAttributes
-        };
-        let html;
-        if (input.selector) {
-          const rawHtml = await page.locator(input.selector).first().evaluate((el) => el.outerHTML);
-          html = await scrubHtml({ html: rawHtml, url }, opts);
-        } else {
-          html = await scrubHtml(page, opts);
-        }
-        return text(JSON.stringify({ url, html }));
-      } catch (e) {
-        return err(`Snapshot failed: ${e.message}`);
-      }
-    }
-  );
+function decideHandoff(currentPackageJsonPath, projectPackageJsonPath, isBootstrapped) {
+  if (!projectPackageJsonPath) {
+    return { shouldHandoff: false, runtimeMode: "standalone" };
+  }
+  if (samePackageRoot(currentPackageJsonPath, projectPackageJsonPath)) {
+    return { shouldHandoff: false, runtimeMode: "project" };
+  }
+  if (isBootstrapped) {
+    return { shouldHandoff: false, runtimeMode: "standalone" };
+  }
+  return { shouldHandoff: true, runtimeMode: "project" };
+}
+function runProjectLocalServer(projectPackageJsonPath) {
+  const entry = resolveBinPath(projectPackageJsonPath);
+  const result = spawnSync(process.execPath, [entry, ...process.argv.slice(2)], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      LETSRUNIT_MCP_BOOTSTRAPPED: "1",
+      LETSRUNIT_MCP_RUNTIME_MODE: "project"
+    }
+  });
+  if (result.error) throw result.error;
+  process.exit(result.status ?? 1);
+}
+function bootstrapProjectServer() {
+  const projectRoot = resolveProjectRoot();
+  const isBootstrapped = process.env.LETSRUNIT_MCP_BOOTSTRAPPED === "1";
+  const currentReq = createRequire(import.meta.url);
+  const currentPackageJsonPath = toRealpath(currentReq.resolve("../package.json"));
+  const projectPackageJsonPath = toRealpath(resolveFromProject("@letsrunit/mcp-server/package.json", projectRoot));
+  const decision = decideHandoff(currentPackageJsonPath, projectPackageJsonPath, isBootstrapped);
+  if (decision.shouldHandoff && projectPackageJsonPath) {
+    runProjectLocalServer(projectPackageJsonPath);
+  }
+  process.env.LETSRUNIT_MCP_RUNTIME_MODE = decision.runtimeMode;
+  return decision.runtimeMode;
 }
 
 // src/index.ts
 var { version } = createRequire(import.meta.url)("../package.json");
+bootstrapProjectServer();
+var { SessionManager } = await import('./sessions-BYH3NJQG.js');
+var {
+  registerDebug,
+  registerDiagnostics,
+  registerDiff,
+  registerListSteps,
+  registerListSessions,
+  registerRun,
+  registerScreenshot,
+  registerSessionClose,
+  registerSessionStart,
+  registerSnapshot
+} = await import('./tools-SAB75FOF.js');
 var sessions = new SessionManager();
 var server = new McpServer({
   name: "letsrunit",