@letsrunit/mcp-server 0.23.1 → 0.23.2

package/dist/index.js

@@ -1,46 +1,797 @@
 #!/usr/bin/env node
 import * as __m from 'node:module';
-import { bootstrapProjectServer } from './chunk-4A4A2HLV.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { spawnSync, execSync } from 'child_process';
+import { loadLetsrunitEnv } from '@letsrunit/utils';
+import { readFileSync, realpathSync, existsSync } from 'fs';
+import { createRequire } from 'module';
+import { join, dirname, resolve, isAbsolute } from 'path';
+import { Controller } from '@letsrunit/controller';
+import { MemorySink, Journal } from '@letsrunit/journal';
+import { z } from 'zod';
+import { loadConfiguration } from '@cucumber/cucumber/api';
+import { registry } from '@letsrunit/bdd';
+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 { scenarioIdFromGherkin } from '@letsrunit/gherkin';
 
 __m.createRequire(import.meta.url);
-var version = "0.23.1" ;
-var runtimeMode = bootstrapProjectServer();
-var { SessionManager } = await import('./sessions-BUPV6ET4.js');
-var {
-  registerDebug,
-  registerDiagnostics,
-  registerDiff,
-  registerListSteps,
-  registerListSessions,
-  registerReload,
-  registerRun,
-  registerScreenshot,
-  registerSessionClose,
-  registerSessionStart,
-  registerSnapshot
-} = await import('./tools-INA4ALAI.js');
-var sessions = new SessionManager();
-var server = new McpServer({
-  name: "letsrunit",
-  version,
-  websiteUrl: "https://letsrunit.ai"
+function resolveProjectRoot() {
+  return resolve(process.env.LETSRUNIT_PROJECT_CWD ?? process.cwd());
+}
+function resolveFromProject(moduleId, projectRoot) {
+  try {
+    const req = createRequire(resolve(projectRoot, "package.json"));
+    return req.resolve(moduleId);
+  } catch {
+    return null;
+  }
+}
+function toRealpath(path) {
+  if (!path) return null;
+  try {
+    return realpathSync(path);
+  } catch {
+    return null;
+  }
+}
+function sameEntrypoint(a, b) {
+  if (!a || !b) return false;
+  return a === b;
+}
+function resolveRuntimeModeOverride() {
+  const runtimeMode = process.env.LETSRUNIT_MCP_RUNTIME_MODE;
+  if (runtimeMode == null || runtimeMode === "") {
+    return null;
+  }
+  if (runtimeMode === "project" || runtimeMode === "standalone") {
+    return runtimeMode;
+  }
+  throw new Error(`Invalid LETSRUNIT_MCP_RUNTIME_MODE: ${runtimeMode}. Expected "project" or "standalone".`);
+}
+function decideHandoff(currentEntrypointPath, projectEntrypointPath, runtimeModeOverride) {
+  if (runtimeModeOverride) {
+    return { shouldHandoff: false, runtimeMode: runtimeModeOverride };
+  }
+  if (!projectEntrypointPath) {
+    return { shouldHandoff: false, runtimeMode: "standalone" };
+  }
+  if (sameEntrypoint(currentEntrypointPath, projectEntrypointPath)) {
+    return { shouldHandoff: false, runtimeMode: "project" };
+  }
+  return { shouldHandoff: true, runtimeMode: "project" };
+}
+function runProjectLocalServer(projectEntrypointPath) {
+  const result = spawnSync(process.execPath, [projectEntrypointPath, ...process.argv.slice(2)], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      LETSRUNIT_MCP_RUNTIME_MODE: "project"
+    }
+  });
+  if (result.error) throw result.error;
+  process.exit(result.status ?? 1);
+}
+function bootstrapProjectServer(currentEntrypointPath) {
+  const projectRoot = resolveProjectRoot();
+  loadLetsrunitEnv(projectRoot);
+  const runtimeModeOverride = resolveRuntimeModeOverride();
+  const currentEntryPath = toRealpath(currentEntrypointPath ?? process.argv[1] ?? null);
+  const projectEntryPath = toRealpath(resolveFromProject("@letsrunit/mcp-server", projectRoot));
+  const decision = decideHandoff(currentEntryPath, projectEntryPath, runtimeModeOverride);
+  if (decision.shouldHandoff && projectEntryPath) {
+    runProjectLocalServer(projectEntryPath);
+  }
+  return decision.runtimeMode;
+}
+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);
+}
+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, capture: false });
+    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(server, sessions) {
+  server.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 = sessions.get(input.sessionId);
+        sessions.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 })) {
+        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 })) {
+        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 getSupportLoadState() {
+  return {
+    loadedProjectRoots: [...loadedProjectRoots].sort(),
+    loadedSupportEntries: [...loadedSupportEntries].sort()
+  };
+}
+function clearSupportLoadState() {
+  loadedProjectRoots.clear();
+  loadedSupportEntries.clear();
+}
+function buildReloadedFileUrl(path) {
+  const url = pathToFileURL(path);
+  url.searchParams.set("letsrunitReload", Date.now().toString(36));
+  return url.href;
+}
+async function loadSupportFiles(cwd, options) {
+  const projectRoot = resolve(resolveEffectiveCwd(cwd));
+  const forceReload = options?.forceReload === true;
+  if (!forceReload && loadedProjectRoots.has(projectRoot)) {
+    return { projectRoot, supportEntriesLoaded: 0, ignoredEntries: 0 };
+  }
+  const { useConfiguration } = await loadConfiguration({}, { cwd: projectRoot });
+  const supportPatterns = [...toStrings(useConfiguration.require), ...toStrings(useConfiguration.import)];
+  if (supportPatterns.length === 0) {
+    loadedProjectRoots.add(projectRoot);
+    return { projectRoot, supportEntriesLoaded: 0, ignoredEntries: 0 };
+  }
+  const ignorePatterns = await loadLetsrunitIgnorePatterns(projectRoot);
+  const ignoredPaths = await expandPathPatterns(projectRoot, ignorePatterns);
+  const supportEntries = await resolveSupportEntries(projectRoot, supportPatterns);
+  let supportEntriesLoaded = 0;
+  let ignoredEntries = 0;
+  for (const entry of supportEntries) {
+    if (entry.kind === "path" && ignoredPaths.has(entry.value)) {
+      ignoredEntries += 1;
+      continue;
+    }
+    const key = `${entry.kind}:${entry.value}`;
+    if (!forceReload && loadedSupportEntries.has(key)) continue;
+    if (entry.kind === "path") {
+      await (forceReload ? import(buildReloadedFileUrl(entry.value)) : import(pathToFileURL(entry.value).href));
+    } else {
+      await import(entry.value);
+    }
+    supportEntriesLoaded += 1;
+    loadedSupportEntries.add(key);
+  }
+  loadedProjectRoots.add(projectRoot);
+  return { projectRoot, supportEntriesLoaded, ignoredEntries };
+}
+async function reloadSupportFiles(cwd) {
+  clearSupportLoadState();
+  return loadSupportFiles(cwd, { forceReload: true });
+}
+
+// src/utility/diagnostics.ts
+function resolveFrom(moduleId, fromPath) {
+  try {
+    const req = createRequire(fromPath);
+    return req.resolve(moduleId);
+  } catch {
+    return null;
+  }
+}
+function toRealpath2(path) {
+  if (!path) return null;
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+function pickLetsrunitEnv() {
+  return Object.fromEntries(
+    Object.entries(process.env).filter(([key, value]) => key.startsWith("LETSRUNIT_") && typeof value === "string").map(([key, value]) => [key, value])
+  );
+}
+async function collectDiagnostics(cwd) {
+  const effectiveCwd = resolveEffectiveCwd(cwd);
+  const projectRoot = resolve(effectiveCwd);
+  const cucumberConfigPath = findCucumberConfig(projectRoot);
+  const { useConfiguration } = await loadConfiguration({}, { cwd: projectRoot });
+  const supportPatterns = [...useConfiguration.require ?? [], ...useConfiguration.import ?? []];
+  const ignorePatterns = await loadLetsrunitIgnorePatterns(projectRoot);
+  const ignoredPaths = await expandPathPatterns(projectRoot, ignorePatterns);
+  const supportEntries = await resolveSupportEntries(projectRoot, supportPatterns);
+  const supportLoadState = getSupportLoadState();
+  const serverBddPath = toRealpath2(resolveFrom("@letsrunit/bdd", import.meta.url));
+  const projectBddPath = toRealpath2(resolveFrom("@letsrunit/bdd", resolve(projectRoot, "package.json")));
+  const projectMcpEntryPath = resolveFrom("@letsrunit/mcp-server", resolve(projectRoot, "package.json"));
+  const currentEntrypointPath = toRealpath2(process.argv[1] ?? null);
+  const projectEntrypointPath = toRealpath2(projectMcpEntryPath);
+  const handoffDecision = decideHandoff(
+    currentEntrypointPath,
+    projectEntrypointPath,
+    resolveRuntimeModeOverride()
+  );
+  const serverMcpPath = toRealpath2(resolveFrom("@letsrunit/mcp-server", import.meta.url));
+  const projectMcpPath = toRealpath2(projectMcpEntryPath);
+  const executablePath = toRealpath2(process.argv[1] ?? null);
+  const version2 = "0.23.2" ;
+  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: supportLoadState.loadedProjectRoots,
+    loadedSupportEntries: supportLoadState.loadedSupportEntries,
+    mcpServer: {
+      version: version2,
+      executablePath,
+      projectServerUsed: handoffDecision.runtimeMode === "project",
+      handoffDecision: {
+        shouldHandoff: handoffDecision.shouldHandoff,
+        runtimeMode: handoffDecision.runtimeMode
+      },
+      serverMcpPath,
+      projectMcpPath
+    },
+    letsrunitEnv: pickLetsrunitEnv(),
+    moduleResolution: {
+      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
+    }
+  };
+}
+
+// src/tools/diagnostics.ts
+function registerDiagnostics(server, sessions) {
+  server.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: {
+        sessionId: z.string().describe("Session ID returned by letsrunit_session_start")
+      }
+    },
+    async (input) => {
+      try {
+        const diagnostics = await collectDiagnostics();
+        const session = sessions.get(input.sessionId);
+        const sessionInfo = {
+          sessionId: session.id,
+          createdAt: session.createdAt,
+          lastActivity: session.lastActivity,
+          stepCount: session.stepCount,
+          artifactDir: session.artifactDir,
+          pageUrl: session.controller.page.url()
+        };
+        return text(JSON.stringify({ ...diagnostics, session: sessionInfo }));
+      } 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() {
+  try {
+    const output = execSync("git log --format=%H", { encoding: "utf8" });
+    return output.trim().split("\n").filter(Boolean);
+  } catch {
+    return void 0;
+  }
+}
+function registerDiff(server, sessions) {
+  server.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 = sessions.get(input.sessionId);
+        sessions.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(server, sessions) {
+  server.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 = sessions.get(input.sessionId);
+        sessions.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(server, sessions) {
+  server.registerTool(
+    "letsrunit_list_sessions",
+    {
+      description: "List all active browser sessions.",
+      inputSchema: {}
+    },
+    async () => {
+      const list = sessions.list().map((s) => ({
+        sessionId: s.id,
+        createdAt: s.createdAt,
+        lastActivity: s.lastActivity,
+        stepCount: s.stepCount,
+        artifactDir: s.artifactDir
+      }));
+      return text(JSON.stringify({ sessions: list }));
+    }
+  );
+}
+
+// src/utility/gherkin.ts
+function normalizeGherkin(input) {
+  const trimmed = input.trim();
+  if (/^(Feature|Scenario|Background):/im.test(trimmed)) {
+    return trimmed;
+  }
+  return `Feature: MCP
+
+Scenario: Steps
+  ${trimmed.split("\n").join("\n  ")}`;
+}
+
+// src/tools/run.ts
+function registerRun(server, sessions) {
+  server.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 = sessions.get(input.sessionId);
+        sessions.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}`);
+      }
+    }
+  );
+}
+async function resetBuiltInStepRegistry() {
+  const bdd = await import('@letsrunit/bdd');
+  const reset = bdd.resetRegistryToBuiltInSteps;
+  if (typeof reset !== "function") {
+    throw new Error(
+      "Installed @letsrunit/bdd does not expose resetRegistryToBuiltInSteps. Update @letsrunit/bdd to a compatible version."
+    );
+  }
+  reset();
+}
+function registerReload(server, options) {
+  server.registerTool(
+    "letsrunit_reload",
+    {
+      description: "Reload built-in and project support step definitions without restarting the MCP server.",
+      inputSchema: {
+        cwd: z.string().optional().describe("Project directory to resolve cucumber support files from. Defaults to current project cwd.")
+      }
+    },
+    async (input) => {
+      if (options.runtimeMode !== "project") {
+        return err("Reload failed: letsrunit_reload is only available in project runtime mode.");
+      }
+      try {
+        await resetBuiltInStepRegistry();
+        const result = await reloadSupportFiles(input.cwd);
+        return text(
+          JSON.stringify({
+            reloaded: true,
+            projectRoot: result.projectRoot,
+            supportEntriesLoaded: result.supportEntriesLoaded,
+            ignoredEntries: result.ignoredEntries
+          })
+        );
+      } catch (e) {
+        return err(`Reload failed: ${e.message}`);
+      }
+    }
+  );
+}
+function registerScreenshot(server, sessions) {
+  server.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 = sessions.get(input.sessionId);
+        sessions.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(server, sessions) {
+  server.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 sessions.close(input.sessionId);
+        return text(JSON.stringify({ closed: true }));
+      } catch (e) {
+        return err(`Failed to close session: ${e.message}`);
+      }
+    }
+  );
+}
+function registerSessionStart(server, sessions, opts) {
+  server.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 {
+        if (opts?.runtimeMode === "project") {
+          await loadSupportFiles();
+        }
+        const viewport = input.viewportWidth || input.viewportHeight ? { width: input.viewportWidth ?? 1280, height: input.viewportHeight ?? 720 } : void 0;
+        const session = await sessions.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}`);
+      }
+    }
+  );
+}
+var stripAttributesSchema = z.nativeEnum({
+  none: 0,
+  semantic: 1,
+  aggressive: 2
 });
-registerSessionStart(server, sessions, { runtimeMode });
-registerRun(server, sessions);
-registerSnapshot(server, sessions);
-registerScreenshot(server, sessions);
-registerDebug(server, sessions);
-registerSessionClose(server, sessions);
-registerListSteps(server, sessions);
-registerListSessions(server, sessions);
-registerReload(server, { runtimeMode });
-registerDiff(server, sessions);
-if (process.env.LETSRUNIT_MCP_DIAGNOSTICS === "enabled") {
-  registerDiagnostics(server, sessions);
-}
-var transport = new StdioServerTransport();
-await server.connect(transport);
+function registerSnapshot(server, sessions) {
+  server.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 = sessions.get(input.sessionId);
+        sessions.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}`);
+      }
+    }
+  );
+}
+
+// src/index.ts
+var version = "0.23.2" ;
+async function main() {
+  const runtimeMode = bootstrapProjectServer(process.argv[1] ?? null);
+  const sessions = new SessionManager();
+  const server = new McpServer({
+    name: "letsrunit",
+    version,
+    websiteUrl: "https://letsrunit.ai"
+  });
+  registerSessionStart(server, sessions, { runtimeMode });
+  registerRun(server, sessions);
+  registerSnapshot(server, sessions);
+  registerScreenshot(server, sessions);
+  registerDebug(server, sessions);
+  registerSessionClose(server, sessions);
+  registerListSteps(server, sessions);
+  registerListSessions(server, sessions);
+  registerReload(server, { runtimeMode });
+  registerDiff(server, sessions);
+  if (process.env.LETSRUNIT_MCP_DIAGNOSTICS === "enabled") {
+    registerDiagnostics(server, sessions);
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+void main();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map