@letsrunit/mcp-server 0.13.3 → 0.14.1

package/src/bootstrap.ts

@@ -0,0 +1,115 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync, realpathSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+
+export type McpRuntimeMode = 'project' | 'standalone';
+
+export type HandoffDecision = {
+  shouldHandoff: boolean;
+  runtimeMode: McpRuntimeMode;
+};
+
+type PackageJsonLike = {
+  bin?: string | Record<string, string>;
+};
+
+function resolveProjectRoot(): string {
+  return resolve(process.env.LETSRUNIT_PROJECT_CWD ?? process.cwd());
+}
+
+function resolveFromProject(moduleId: string, projectRoot: string): string | null {
+  try {
+    const req = createRequire(resolve(projectRoot, 'package.json'));
+    return req.resolve(moduleId);
+  } catch {
+    return null;
+  }
+}
+
+function toRealpath(path: string | null): string | null {
+  if (!path) return null;
+  try {
+    return realpathSync(path);
+  } catch {
+    return null;
+  }
+}
+
+function samePackageRoot(a: string | null, b: string | null): boolean {
+  if (!a || !b) return false;
+  return dirname(a) === dirname(b);
+}
+
+function resolveBinPath(packageJsonPath: string): string {
+  const text = readFileSync(packageJsonPath, 'utf8');
+  const pkg = JSON.parse(text) as PackageJsonLike;
+
+  if (typeof pkg.bin === 'string') {
+    return resolve(dirname(packageJsonPath), pkg.bin);
+  }
+
+  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}`);
+}
+
+export function decideHandoff(
+  currentPackageJsonPath: string | null,
+  projectPackageJsonPath: string | null,
+  isBootstrapped: boolean,
+): HandoffDecision {
+  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: string): never {
+  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);
+}
+
+export function bootstrapProjectServer(): McpRuntimeMode {
+  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;
+}

package/src/index.ts

@@ -1,10 +1,13 @@
 import { createRequire } from 'module';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { SessionManager } from './sessions';
+import { bootstrapProjectServer } from './bootstrap';
 
 const { version } = createRequire(import.meta.url)('../package.json') as { version: string };
-import {
+bootstrapProjectServer();
+
+const { SessionManager } = await import('./sessions');
+const {
   registerDebug,
   registerDiagnostics,
   registerDiff,
@@ -15,7 +18,7 @@ import {
   registerSessionClose,
   registerSessionStart,
   registerSnapshot,
-} from './tools';
+} = await import('./tools');
 
 const sessions = new SessionManager();
 

package/src/tools/session-start.ts

@@ -20,7 +20,9 @@ export function registerSessionStart(server: McpServer, sessions: SessionManager
     },
     async (input) => {
       try {
-        await loadSupportFiles();
+        if (process.env.LETSRUNIT_MCP_RUNTIME_MODE === 'project') {
+          await loadSupportFiles();
+        }
 
         const viewport =
           input.viewportWidth || input.viewportHeight