@teambit/cli-mcp-server 0.0.0-00149e000ea14bbdcb0391c0d576b4a2b40f8cde

package/dist/cli-mcp-server.main.runtime.js

@@ -0,0 +1,1519 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.CliMcpServerMain = void 0;
+function _cli() {
+  const data = require("@teambit/cli");
+  _cli = function () {
+    return data;
+  };
+  return data;
+}
+function _child_process() {
+  const data = _interopRequireDefault(require("child_process"));
+  _child_process = function () {
+    return data;
+  };
+  return data;
+}
+function _stripAnsi() {
+  const data = _interopRequireDefault(require("strip-ansi"));
+  _stripAnsi = function () {
+    return data;
+  };
+  return data;
+}
+function _fsExtra() {
+  const data = _interopRequireDefault(require("fs-extra"));
+  _fsExtra = function () {
+    return data;
+  };
+  return data;
+}
+function _commentJson() {
+  const data = require("comment-json");
+  _commentJson = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _cliMcpServer() {
+  const data = require("./cli-mcp-server.aspect");
+  _cliMcpServer = function () {
+    return data;
+  };
+  return data;
+}
+function _mcpServer() {
+  const data = require("./mcp-server.cmd");
+  _mcpServer = function () {
+    return data;
+  };
+  return data;
+}
+function _mcp() {
+  const data = require("@modelcontextprotocol/sdk/server/mcp.js");
+  _mcp = function () {
+    return data;
+  };
+  return data;
+}
+function _stdio() {
+  const data = require("@modelcontextprotocol/sdk/server/stdio.js");
+  _stdio = function () {
+    return data;
+  };
+  return data;
+}
+function _zod() {
+  const data = require("zod");
+  _zod = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@teambit/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _scope() {
+  const data = require("@teambit/scope.network");
+  _scope = function () {
+    return data;
+  };
+  return data;
+}
+function _scopeModules() {
+  const data = require("@teambit/scope.modules.find-scope-path");
+  _scopeModules = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.constants");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _nodeFetch() {
+  const data = _interopRequireDefault(require("node-fetch"));
+  _nodeFetch = function () {
+    return data;
+  };
+  return data;
+}
+function _setupCmd() {
+  const data = require("./setup-cmd");
+  _setupCmd = function () {
+    return data;
+  };
+  return data;
+}
+function _rulesCmd() {
+  const data = require("./rules-cmd");
+  _rulesCmd = function () {
+    return data;
+  };
+  return data;
+}
+function _remoteComponentUtils() {
+  const data = require("./remote-component-utils");
+  _remoteComponentUtils = function () {
+    return data;
+  };
+  return data;
+}
+function _mcp2() {
+  const data = require("@teambit/mcp.mcp-config-writer");
+  _mcp2 = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /* eslint-disable import/extensions */ /* eslint-disable import/no-unresolved */
+class CliMcpServerMain {
+  constructor(cli, logger) {
+    this.cli = cli;
+    this.logger = logger;
+    _defineProperty(this, "bitBin", 'bit');
+    _defineProperty(this, "_http", void 0);
+    _defineProperty(this, "isConsumerProjectMode", false);
+    _defineProperty(this, "serverPort", void 0);
+    _defineProperty(this, "serverUrl", void 0);
+    _defineProperty(this, "serverToken", void 0);
+    _defineProperty(this, "serverProcess", null);
+    // In-flight init promise so concurrent callers share a single bit-server
+    // discovery/spawn. Without this, parallel tool calls race in the
+    // `if (!this.serverPort)` block below — each spawns its own bit-server, the
+    // second `writeServerToken` overwrites the first, and the earlier caller's
+    // cached token no longer matches its server (401 "requires authentication").
+    _defineProperty(this, "serverInitPromise", void 0);
+    // Whitelist of commands that are considered read-only/query operations
+    _defineProperty(this, "readOnlyCommands", new Set(['status', 'list', 'info', 'show', 'schema', 'artifacts', 'diff', 'log', 'graph', 'deps get', 'deps blame', 'why', 'config get', 'envs list', 'envs get', 'remote list', 'templates', 'cat-component', 'cat-lane', 'cat-object', 'cat-scope', 'lane show', 'lane list', 'lane diff', 'lane history', 'lane history-diff', 'test', 'help', 'version']));
+    // Validate the default bitBin on construction
+    this.bitBin = this.validateBitBin(this.bitBin);
+  }
+  async getHttp() {
+    if (!this._http) {
+      this._http = await _scope().Http.connect(_legacy().SYMPHONY_GRAPHQL, _legacy().CENTRAL_BIT_HUB_NAME);
+    }
+    return this._http;
+  }
+
+  /**
+   * Discover or spawn a bit-server, then read its bearer token. Concurrent
+   * callers share a single in-flight promise so they can't race each other
+   * into spawning duplicate servers (which would otherwise overwrite the
+   * shared `server-token.txt`).
+   */
+  async ensureBitServer(cwd) {
+    if (this.serverPort) return;
+    if (!this.serverInitPromise) {
+      this.serverInitPromise = (async () => {
+        const existingPort = await this.getBitServerPort(cwd);
+        if (existingPort) {
+          this.serverPort = existingPort;
+        } else {
+          this.logger.debug('[MCP-DEBUG] No bit-server found, attempting to start one');
+          const startedPort = await this.startBitServer(cwd);
+          if (startedPort) this.serverPort = startedPort;
+        }
+        if (this.serverPort) {
+          this.serverUrl = this.buildServerUrl(this.serverPort);
+          // bit-server 1.13.166+ requires a bearer token; older versions don't
+          // write the token file and getBitServerToken returns undefined.
+          this.serverToken = this.getBitServerToken(cwd);
+        }
+      })().finally(() => {
+        // On failure (no port resolved), clear so a later call can retry.
+        if (!this.serverPort) this.serverInitPromise = undefined;
+      });
+    }
+    await this.serverInitPromise;
+  }
+  async getBitServerPort(cwd, skipValidatePortFlag = false) {
+    try {
+      const args = ['cli-server-port'];
+      if (skipValidatePortFlag) {
+        args.push(String(skipValidatePortFlag));
+      }
+      const result = _child_process().default.spawnSync(this.bitBin, args, {
+        cwd,
+        env: _objectSpread(_objectSpread({}, process.env), {}, {
+          BIT_CLI_SERVER: 'true'
+        }),
+        encoding: 'utf8'
+      });
+      if (result.error) {
+        throw result.error;
+      }
+      if (result.status !== 0) {
+        throw new Error(`Command failed with status ${result.status}: ${result.stderr}`);
+      }
+      const existingPort = result.stdout.trim();
+      if (!existingPort) return undefined;
+      return parseInt(existingPort, 10);
+    } catch (err) {
+      this.logger.error(`[MCP-DEBUG] error getting existing port from bit server at ${cwd}. err: ${err.message}`);
+      return undefined;
+    }
+  }
+
+  /**
+   * Build the URL used to dial the local bit-server. Mirrors the api-server's
+   * bind host: `BIT_SERVER_HOST` lets hosted environments (e.g. cloud
+   * workspaces) reach bit-server on a non-loopback interface. `0.0.0.0` /
+   * `::` are bind-only wildcards (not valid destinations) so dial loopback
+   * instead; raw IPv6 addresses get bracketed for URL safety.
+   */
+  buildServerUrl(port) {
+    const override = process.env.BIT_SERVER_HOST?.trim();
+    let host;
+    if (!override || override === '0.0.0.0') host = '127.0.0.1';else if (override === '::') host = '[::1]';else if (override.includes(':') && override.split(':').length > 2 && !override.startsWith('[')) host = `[${override}]`;else host = override;
+    return `http://${host}:${port}/api`;
+  }
+
+  /**
+   * Read the bearer token written by bit-server (1.13.166+) for authenticating
+   * to the local HTTP API. Returns undefined for older bit-server versions
+   * that don't write a token file (no auth required), or when the workspace
+   * has no scope yet. Other read errors (EACCES, etc.) surface so the user
+   * sees the real cause instead of a misleading 401.
+   */
+  getBitServerToken(cwd) {
+    const scopePath = (0, _scopeModules().findScopePath)(cwd);
+    if (!scopePath) return undefined;
+    const filePath = _path().default.join(scopePath, 'server-token.txt');
+    try {
+      const token = _fsExtra().default.readFileSync(filePath, 'utf8').trim();
+      return token || undefined;
+    } catch (err) {
+      if (err.code === 'ENOENT') return undefined;
+      throw err;
+    }
+  }
+
+  /**
+   * Start a new bit-server process
+   */
+  async startBitServer(cwd) {
+    this.logger.debug('[MCP-DEBUG] Starting new bit-server process');
+    return new Promise((resolve, reject) => {
+      try {
+        const serverProcess = _child_process().default.spawn(this.bitBin, ['server'], {
+          cwd,
+          stdio: ['pipe', 'pipe', 'pipe'],
+          detached: false
+        });
+        this.serverProcess = serverProcess;
+        let serverStarted = false;
+        let outputBuffer = '';
+        const timeout = setTimeout(() => {
+          if (!serverStarted) {
+            this.logger.error('[MCP-DEBUG] Timeout waiting for bit-server to start');
+            serverProcess.kill();
+            resolve(null);
+          }
+        }, 30000); // 30 second timeout
+
+        serverProcess.stdout?.on('data', data => {
+          const output = data.toString();
+          outputBuffer += output;
+          this.logger.debug(`[MCP-DEBUG] bit-server stdout: ${output}`);
+          if (output.includes('listening on port')) {
+            clearTimeout(timeout);
+            if (!serverStarted) {
+              serverStarted = true;
+              // Extract the port from the output
+              const portMatch = output.match(/listening on port (\d+)/);
+              if (portMatch && portMatch[1]) {
+                const port = parseInt(portMatch[1], 10);
+                this.logger.debug(`[MCP-DEBUG] bit-server started on port ${port}`);
+                this.serverPort = port;
+                this.serverUrl = this.buildServerUrl(port);
+                resolve(port);
+              }
+            }
+          }
+        });
+        serverProcess.stderr?.on('data', data => {
+          const error = data.toString();
+          outputBuffer += error;
+          this.logger.debug(`[MCP-DEBUG] bit-server stderr: ${error}`);
+        });
+        serverProcess.on('error', err => {
+          clearTimeout(timeout);
+          this.logger.error(`[MCP-DEBUG] Failed to start bit-server: ${err.message}`);
+          reject(err);
+        });
+        serverProcess.on('exit', (code, signal) => {
+          clearTimeout(timeout);
+          if (!serverStarted) {
+            this.logger.error(`[MCP-DEBUG] bit-server exited with code ${code}, signal ${signal}`);
+            this.logger.debug(`[MCP-DEBUG] bit-server output: ${outputBuffer}`);
+            resolve(null);
+          }
+        });
+        const killServerProcess = () => {
+          if (this.serverProcess && !this.serverProcess.killed) {
+            this.logger.debug('[MCP-DEBUG] Killing bit-server process');
+            this.serverProcess.kill();
+          }
+        };
+
+        // Handle process cleanup
+        process.on('exit', () => {
+          killServerProcess();
+        });
+        process.on('SIGINT', () => {
+          killServerProcess();
+          process.exit();
+        });
+        process.on('SIGTERM', () => {
+          killServerProcess();
+          process.exit();
+        });
+      } catch (err) {
+        this.logger.error(`[MCP-DEBUG] Error spawning bit-server: ${err.message}`);
+        reject(err);
+      }
+    });
+  }
+
+  /**
+   * Call bit-server API endpoint using cli-raw route
+   */
+  async callBitServerAPI(command, args = [], flags = {}, cwd, isReTrying = false) {
+    return this.callBitServerAPIWithRoute('cli-raw', command, args, flags, cwd, isReTrying);
+  }
+
+  /**
+   * Call bit-server API endpoint using IDE route
+   */
+  async callBitServerIDEAPI(method, args = [], cwd, isReTrying = false) {
+    return this.callBitServerAPIWithRoute('ide', method, args, {}, cwd, isReTrying, true);
+  }
+
+  /**
+   * Generic method to call bit-server API with different routes
+   */
+  async callBitServerAPIWithRoute(route, commandOrMethod, argsOrParams = [], flags = {}, cwd, isReTrying = false, isIDERoute = false) {
+    if (!this.serverPort) {
+      if (!cwd) throw new Error('CWD is required to call bit-server API');
+      await this.ensureBitServer(cwd);
+    }
+    if (!this.serverUrl) {
+      throw new Error('Unable to connect to bit-server. Please ensure you are in a valid Bit workspace.');
+    }
+
+    // Resolve the real path to handle symlinks (e.g., /tmp -> /private/tmp on macOS)
+    const realCwd = _fsExtra().default.realpathSync(cwd);
+    let body;
+    let url;
+    if (isIDERoute) {
+      // For IDE route, use the method name and args directly
+      body = {
+        args: argsOrParams
+      };
+      url = `${this.serverUrl}/${route}/${commandOrMethod}`;
+    } else {
+      // For CLI route, build command array with flags
+      const commandArray = [commandOrMethod, ...argsOrParams];
+
+      // Convert flags to command line arguments
+      for (const [key, value] of Object.entries(flags)) {
+        if (value === true) {
+          commandArray.push(`--${key}`);
+        } else if (value !== false && value !== undefined) {
+          commandArray.push(`--${key}`, String(value));
+        }
+      }
+      body = {
+        command: commandArray,
+        pwd: realCwd
+      };
+      url = `${this.serverUrl}/${route}`;
+    }
+    const headers = {
+      'Content-Type': 'application/json'
+    };
+    if (this.serverToken) headers.Authorization = `Bearer ${this.serverToken}`;
+    try {
+      const response = await (0, _nodeFetch().default)(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body)
+      });
+      if (response.status === 401 && !isReTrying) {
+        // Token may be stale (server restarted with a new one); refresh and retry once.
+        this.logger.debug('[MCP-DEBUG] 401 from bit-server, refreshing token and retrying');
+        this.serverToken = this.getBitServerToken(cwd);
+        return this.callBitServerAPIWithRoute(route, commandOrMethod, argsOrParams, flags, cwd, true, isIDERoute);
+      }
+      if (!response.ok) {
+        let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+        try {
+          const errorJson = await response.json();
+          errorMessage = errorJson.message || errorJson || errorMessage;
+        } catch {
+          // Ignore JSON parse errors
+        }
+        throw new Error(errorMessage);
+      }
+      return await response.json();
+    } catch (err) {
+      if (err.code === 'ECONNREFUSED' && !isReTrying) {
+        // Server is no longer running, reset cached values and try to restart
+        this.serverPort = undefined;
+        this.serverUrl = undefined;
+        this.serverToken = undefined;
+        this.serverInitPromise = undefined;
+        this.logger.debug('[MCP-DEBUG] Connection refused, attempting to restart bit-server');
+        return this.callBitServerAPIWithRoute(route, commandOrMethod, argsOrParams, flags, cwd, true, isIDERoute);
+      }
+      throw err;
+    }
+  }
+  async runMcpServer(options) {
+    this.logger.debug(`[MCP-DEBUG] Starting MCP server with options: ${JSON.stringify(options)}. CWD: ${process.cwd()}`);
+    const commands = this.cli.commands;
+
+    // Validate and set bitBin with security checks
+    if (options.bitBin) {
+      this.bitBin = this.validateBitBin(options.bitBin);
+    }
+    // If no bitBin provided, keep the default 'bit'
+
+    // Tools to always exclude
+    const alwaysExcludeTools = new Set(['login', 'logout', 'completion', 'mcp-server', 'start', 'run-action', 'watch', 'run', 'resume-export', 'server', 'serve-preview']);
+
+    // Parse command strings from flag options
+    let additionalCommandsSet;
+    if (options.includeAdditional) {
+      additionalCommandsSet = new Set(options.includeAdditional.split(',').map(cmd => cmd.trim()));
+      this.logger.debug(`[MCP-DEBUG] Including additional commands: ${Array.from(additionalCommandsSet).join(', ')}`);
+    }
+    const server = new (_mcp().McpServer)({
+      name: 'bit-cli-mcp',
+      version: '0.0.1'
+    });
+
+    // Set of tools for consumer projects (non-Bit workspaces)
+    const consumerProjectTools = new Set();
+    const consumerProject = Boolean(options.consumerProject);
+
+    // Store consumer project mode globally in the class
+    this.isConsumerProjectMode = consumerProject;
+
+    // Validate flags combination
+    if (consumerProject) {
+      this.logger.debug(`[MCP-DEBUG] Running MCP server in consumer project mode (for non-Bit workspaces) with tools: bit_remote_search, bit_remote_component_details`);
+      if (options.includeAdditional) {
+        this.logger.debug(`[MCP-DEBUG] Additional tools enabled in consumer project mode: ${options.includeAdditional}`);
+      }
+    }
+    const filterOptions = {
+      additionalCommandsSet,
+      alwaysExcludeTools,
+      consumerProject,
+      consumerProjectTools
+    };
+    commands.forEach(cmd => {
+      const cmdName = (0, _cli().getCommandName)(cmd);
+      if (this.shouldIncludeCommand(cmdName, filterOptions)) {
+        this.registerToolForCommand(server, cmd);
+      }
+
+      // Process sub-commands
+      if (cmd.commands && cmd.commands.length) {
+        this.processSubCommands(server, cmd, filterOptions);
+      }
+    });
+
+    // Always register remote-search tool
+    this.registerRemoteSearchTool(server);
+
+    // In consumer project mode, only register bit_remote_search and bit_remote_component_details
+    // All other tools should not be available in consumer project mode
+    if (consumerProject) {
+      // Register the new combined remote component details tool
+      this.registerRemoteComponentDetailsTool(server);
+    } else {
+      // Register the bit_workspace_info tool
+      this.registerWorkspaceInfoTool(server);
+
+      // Register the bit_component_details tool
+      this.registerComponentDetailsTool(server);
+
+      // Register the bit_create tool
+      this.registerCreateTool(server);
+
+      // Register command discovery and help tools
+      this.registerCommandsListTool(server);
+      this.registerCommandHelpTool(server);
+      this.registerQueryTool(server);
+      this.registerExecuteTool(server);
+    }
+    await server.connect(new (_stdio().StdioServerTransport)());
+  }
+  shouldIncludeCommand(cmdName, options) {
+    // Always exclude certain commands
+    if (options.alwaysExcludeTools.has(cmdName)) return false;
+
+    // Consumer project mode: only include consumer project tools + any additional specified
+    if (options.consumerProject) {
+      const shouldInclude = options.consumerProjectTools.has(cmdName) || (options.additionalCommandsSet?.has(cmdName) ?? false);
+      if (shouldInclude) {
+        this.logger.debug(`[MCP-DEBUG] Including command in consumer project mode: ${cmdName}`);
+      }
+      return shouldInclude;
+    }
+
+    // Default mode: only include additional specified commands (no default tools anymore)
+    return options.additionalCommandsSet?.has(cmdName) ?? false;
+  }
+  buildZodSchema(config) {
+    const schema = {
+      // Add cwd parameter as mandatory to all commands
+      cwd: _zod().z.string().describe('Path to workspace')
+    };
+    config.argsData.forEach(arg => {
+      const desc = arg.description || `Positional argument: ${arg.nameRaw}`;
+      if (arg.isArray) {
+        schema[arg.nameCamelCase] = arg.required ? _zod().z.array(_zod().z.string()).describe(desc) : _zod().z.array(_zod().z.string()).optional().describe(desc);
+      } else {
+        schema[arg.nameCamelCase] = arg.required ? _zod().z.string().describe(desc) : _zod().z.string().optional().describe(desc);
+      }
+    });
+    config.flagsData.forEach(flag => {
+      const type = flag.type;
+      schema[flag.name] = type === 'string' ? _zod().z.string().optional().describe(flag.description) : _zod().z.boolean().optional().describe(flag.description);
+    });
+    return schema;
+  }
+  buildCommandArgs(config, params) {
+    // Split the command name on spaces to properly handle subcommands
+    const args = config.name.split(' ');
+
+    // Add positional arguments in order
+    config.argsData.forEach(arg => {
+      const val = params[arg.nameCamelCase];
+      if (val === undefined) return;
+      if (arg.isArray && Array.isArray(val)) {
+        val.forEach(item => args.push(item));
+      } else {
+        args.push(val);
+      }
+    });
+
+    // Add options as flags
+    config.flagsData.forEach(flag => {
+      const name = flag.name;
+      const type = flag.type;
+      const val = params[name];
+      if (val === undefined) return;
+      if (type === 'boolean' && val) {
+        args.push(`--${name}`);
+      } else if (type === 'string' && val) {
+        // Check if the string value contains spaces and quote it if necessary
+        const stringValue = String(val);
+        if (stringValue.includes(' ')) {
+          args.push(`--${name}`, `"${stringValue}"`);
+        } else {
+          args.push(`--${name}`, stringValue);
+        }
+      }
+    });
+    return args;
+  }
+  getToolName(name) {
+    // replace white spaces (\s) and dashes (-) with underscores (_)
+    return `bit_${name}`.replace(/[-\s]/g, '_');
+  }
+  registerToolForCommand(server, cmd, parentCmd) {
+    const cmdName = parentCmd ? `${(0, _cli().getCommandName)(parentCmd)} ${(0, _cli().getCommandName)(cmd)}` : (0, _cli().getCommandName)(cmd);
+    const toolName = this.getToolName(cmdName);
+
+    // Modify description for show and schema commands in consumer project mode
+    let description = `${cmd.description}${cmd.extendedDescription ? `.\n(${cmd.extendedDescription})` : ''}`;
+    if (this.isConsumerProjectMode && (cmdName === 'show' || cmdName === 'schema')) {
+      description += `\n(In consumer project mode, --remote flag is automatically added)`;
+    }
+    const config = {
+      name: cmdName,
+      description,
+      argsData: (0, _cli().getArgsData)(cmd),
+      flagsData: (0, _cli().getFlagsData)(cmd)
+    };
+    const schema = this.buildZodSchema(config);
+    server.tool(toolName, config.description, schema, async params => {
+      const argsToRun = this.buildCommandArgs(config, params);
+
+      // Special handling for consumer projects - auto-add --remote flag for show and schema commands
+      if (this.isConsumerProjectMode && (cmdName === 'show' || cmdName === 'schema')) {
+        if (!argsToRun.includes('--remote')) {
+          this.logger.debug(`[MCP-DEBUG] Auto-adding --remote flag for ${cmdName} in consumer project mode`);
+          argsToRun.push('--remote');
+        }
+        if (cmdName === 'show' && !argsToRun.includes('--legacy')) {
+          this.logger.debug(`[MCP-DEBUG] Auto-adding --legacy flag for ${cmdName} in consumer project mode`);
+          argsToRun.push('--legacy');
+        }
+      }
+      return this.runBit(argsToRun, params.cwd);
+    });
+  }
+
+  /**
+   * Read and parse workspace.jsonc file from a given directory
+   */
+  async readWorkspaceJsonc(workspaceDir) {
+    try {
+      const workspaceJsoncPath = _path().default.join(workspaceDir, 'workspace.jsonc');
+      const fileExists = await _fsExtra().default.pathExists(workspaceJsoncPath);
+      if (!fileExists) {
+        this.logger.debug(`[MCP-DEBUG] workspace.jsonc not found at ${workspaceJsoncPath}`);
+        return null;
+      }
+      const content = await _fsExtra().default.readFile(workspaceJsoncPath, 'utf-8');
+      return (0, _commentJson().parse)(content);
+    } catch (error) {
+      this.logger.debug(`[MCP-DEBUG] Failed to read workspace.jsonc: ${error}`);
+      return null;
+    }
+  }
+
+  /**
+   * Extract owner from defaultScope in workspace.jsonc
+   * If defaultScope contains a dot, split by dot and take the first part
+   */
+  extractOwnerFromWorkspace(workspaceConfig) {
+    try {
+      const workspaceSection = workspaceConfig?.['teambit.workspace/workspace'];
+      const defaultScope = workspaceSection?.defaultScope;
+      if (!defaultScope || typeof defaultScope !== 'string') {
+        return null;
+      }
+
+      // If defaultScope contains a dot, split by dot and take the first part (owner)
+      if (defaultScope.includes('.')) {
+        const parts = defaultScope.split('.');
+        return parts[0];
+      }
+
+      // If no dot, the entire defaultScope is treated as the owner
+      return defaultScope;
+    } catch (error) {
+      this.logger.debug(`[MCP-DEBUG] Failed to extract owner from workspace config: ${error}`);
+      return null;
+    }
+  }
+  registerRemoteSearchTool(server) {
+    const toolName = 'bit_remote_search';
+    const description = `Search for components in remote scopes using parallel queries for efficient discovery. Always provide multiple search terms - either variations/synonyms of one component type, or different components needed for a task. Examples: ["button", "btn", "click"] for variations, or ["input", "button", "validation"] for form components.`;
+    const schema = {
+      queries: _zod().z.array(_zod().z.string()).describe(`Array of search query strings for parallel searching. Each query should be a single keyword or a few broad keywords. Search for variations/synonyms of one component type, or different components needed for a task. Examples: ["btn", "button"] for variations, or ["table", "pagination", "filter"] for data display features.`),
+      cwd: _zod().z.string().optional().describe('Path to workspace directory'),
+      owners: _zod().z.array(_zod().z.string()).optional().describe('Filter results by specific owners or organizations. AVOID using this parameter - let the system automatically extract the owner from workspace.jsonc defaultScope for better relevance. Only use when you need to override the automatic behavior or search across different owners'),
+      skipAutoOwner: _zod().z.boolean().optional().describe('Set to true to disable automatic owner extraction from workspace.jsonc. When false or omitted, the system will try to automatically extract owner from workspace defaultScope')
+    };
+    server.tool(toolName, description, schema, async params => {
+      const http = await this.getHttp();
+
+      // Validate that queries parameter is provided and valid
+      if (!params.queries || !Array.isArray(params.queries) || params.queries.length === 0) {
+        return {
+          content: [{
+            type: 'text',
+            text: 'Error: queries parameter must be provided as a non-empty array of search terms. Example: ["button", "btn", "click"]'
+          }]
+        };
+      }
+      const searchQueries = params.queries;
+
+      // Determine the owners to use for the search
+      let ownersToUse = params.owners && params.owners.length > 0 ? params.owners : undefined;
+
+      // If owners not explicitly provided and skipAutoOwner is not true, try to extract from workspace.jsonc
+      if (!ownersToUse && !params.skipAutoOwner) {
+        try {
+          // Use provided cwd parameter or fall back to current working directory
+          const workspaceDir = params.cwd || process.cwd();
+          this.logger.debug(`[MCP-DEBUG] Attempting to auto-extract owner from workspace.jsonc in: ${workspaceDir}`);
+          const workspaceConfig = await this.readWorkspaceJsonc(workspaceDir);
+          if (workspaceConfig) {
+            const extractedOwner = this.extractOwnerFromWorkspace(workspaceConfig);
+            if (extractedOwner) {
+              ownersToUse = [extractedOwner];
+              this.logger.debug(`[MCP-DEBUG] Auto-extracted owner from workspace.jsonc: ${extractedOwner}`);
+            }
+          }
+        } catch (error) {
+          this.logger.debug(`[MCP-DEBUG] Failed to auto-extract owner: ${error}`);
+          // Continue without auto-extracted owner
+        }
+      } else {
+        this.logger.debug(`[MCP-DEBUG] Using provided owners for search: ${ownersToUse ? ownersToUse.join(', ') : 'none'}`);
+      }
+
+      // Execute searches in parallel
+      this.logger.debug(`[MCP-DEBUG] Executing ${searchQueries.length} search(es) in parallel: ${searchQueries.join(', ')}`);
+      try {
+        const searchPromises = searchQueries.map(async query => {
+          try {
+            const result = await http.search(query, ownersToUse);
+            return {
+              query,
+              success: true,
+              components: result?.components || [],
+              totalCount: result?.components?.length || 0
+            };
+          } catch (error) {
+            this.logger.warn(`[MCP-DEBUG] Search failed for query "${query}": ${error.message}`);
+            return {
+              query,
+              success: false,
+              error: error.message,
+              components: [],
+              totalCount: 0
+            };
+          }
+        });
+        const searchResults = await Promise.all(searchPromises);
+
+        // Process and consolidate results
+        const allComponents = new Set();
+        const resultsByQuery = [];
+        let totalComponentsFound = 0;
+        searchResults.forEach(result => {
+          resultsByQuery.push({
+            query: result.query,
+            success: result.success,
+            count: result.totalCount,
+            error: result.error || undefined
+          });
+          if (result.success && result.components.length > 0) {
+            result.components.forEach(component => allComponents.add(component));
+            totalComponentsFound += result.totalCount;
+          }
+        });
+
+        // Format the consolidated results
+        if (allComponents.size === 0) {
+          const failedQueries = searchResults.filter(r => !r.success);
+          let message = 'No results found';
+          if (failedQueries.length > 0) {
+            message += `\n\nSome searches failed:`;
+            failedQueries.forEach(r => {
+              message += `\n- "${r.query}": ${r.error}`;
+            });
+          }
+          return {
+            content: [{
+              type: 'text',
+              text: message
+            }]
+          };
+        }
+
+        // Build the response text
+        let responseText = `Found ${allComponents.size} unique components from ${searchQueries.length} parallel search${searchQueries.length > 1 ? 'es' : ''}:\n\n`;
+
+        // Show per-query results summary
+        responseText += 'Search Summary:\n';
+        resultsByQuery.forEach(result => {
+          if (result.success) {
+            responseText += `- "${result.query}": ${result.count} components\n`;
+          } else {
+            responseText += `- "${result.query}": FAILED (${result.error})\n`;
+          }
+        });
+        responseText += '\nConsolidated Results:\n';
+        responseText += Array.from(allComponents).join('\n');
+        const formattedResults = {
+          type: 'text',
+          text: responseText
+        };
+        this.logger.debug(`[MCP-DEBUG] Consolidated search results: ${allComponents.size} unique components from ${totalComponentsFound} total results`);
+        return {
+          content: [formattedResults]
+        };
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error during parallel search execution: ${error.message}`);
+        return {
+          content: [{
+            type: 'text',
+            text: `Error executing searches: ${error.message}`
+          }]
+        };
+      }
+    });
+  }
+  registerRemoteComponentDetailsTool(server) {
+    const toolName = 'bit_remote_component_details';
+    const description = 'Get detailed information about a remote component including basic info, docs, usage examples, and public API schema. Uses global scope to provide comprehensive component details.';
+    const schema = {
+      cwd: _zod().z.string().describe('Path to workspace directory'),
+      componentName: _zod().z.string().describe('Component name or component ID to get details for'),
+      includeSchema: _zod().z.boolean().optional().describe('Include component public API schema (default: false)')
+    };
+    server.tool(toolName, description, schema, async params => {
+      try {
+        const {
+          componentName,
+          includeSchema = false,
+          cwd
+        } = params;
+
+        // Get enhanced details using remote.show()
+        const result = await (0, _remoteComponentUtils().getRemoteComponentWithDetails)(componentName);
+
+        // Add schema if requested
+        if (includeSchema) {
+          try {
+            const schemaArgs = ['schema', componentName, '--remote'];
+            const schemaResult = await this.runBit(schemaArgs, cwd);
+            const content = schemaResult.content[0];
+            if (content.type !== 'text') {
+              throw new Error(`Expected text content but got ${content.type}`);
+            }
+            result.publicAPI = content.text;
+          } catch (schemaError) {
+            this.logger.warn(`[MCP-DEBUG] Failed to get schema for ${componentName}: ${schemaError.message}`);
+            result.publicAPI = `Error fetching schema: ${schemaError.message}`;
+          }
+        }
+        return this.formatAsCallToolResult(result);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_remote_component_details tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'getting remote component details');
+      }
+    });
+  }
+  registerWorkspaceInfoTool(server) {
+    const toolName = 'bit_workspace_info';
+    const description = 'Get comprehensive workspace information including status, components list, apps, templates, dependency graph, and workspace dependencies';
+    const schema = {
+      cwd: _zod().z.string().describe('Path to workspace directory'),
+      includeTemplates: _zod().z.boolean().optional().describe('Include templates list (default: false)'),
+      includeApps: _zod().z.boolean().optional().describe('Include apps list (default: false)'),
+      includeGraph: _zod().z.boolean().optional().describe('Include dependency graph (default: false)'),
+      json: _zod().z.boolean().optional().describe('Return output in JSON format - WARNING: This produces verbose output and should be used when structured data is specifically needed (default: false)')
+    };
+    server.tool(toolName, description, schema, async params => {
+      try {
+        const includeTemplates = params.includeTemplates === true; // default: false
+        const includeApps = params.includeApps === true;
+        const includeGraph = params.includeGraph === true;
+        const useJson = params.json === true;
+        const workspaceInfo = {};
+        const flags = useJson ? {
+          json: true
+        } : {};
+        const statusExecution = await this.safeBitCommandExecution('status', [], flags, params.cwd, 'get workspace status', true);
+        workspaceInfo.status = statusExecution.result;
+        const listExecution = await this.safeBitCommandExecution('list', [], flags, params.cwd, 'get components list', true);
+        workspaceInfo.list = listExecution.result;
+
+        // Get apps list if requested
+        if (includeApps) {
+          const appsExecution = await this.safeBitCommandExecution('app', ['list'], flags, params.cwd, 'get apps list', true);
+          workspaceInfo.apps = appsExecution.result;
+        }
+
+        // Get templates list if requested
+        if (includeTemplates) {
+          const templatesExecution = await this.safeBitCommandExecution('templates', [], flags, params.cwd, 'get templates list', true);
+          workspaceInfo.templates = templatesExecution.result;
+        }
+
+        // Get dependency graph if requested
+        if (includeGraph) {
+          const graphExecution = await this.safeBitCommandExecution('graph', [], {
+            json: true
+          }, params.cwd, 'get dependency graph', true);
+          workspaceInfo.graph = graphExecution.result;
+        }
+
+        // Get workspace dependencies if requested
+        try {
+          const workspaceDependencies = await this.callBitServerIDEAPI('getWorkspaceDependencies', [], params.cwd);
+          workspaceInfo.workspaceDependencies = workspaceDependencies;
+        } catch (error) {
+          this.logger.error(`[MCP-DEBUG] Error getting workspace dependencies: ${error.message}`);
+          workspaceInfo.workspaceDependencies = {
+            error: `Failed to get workspace dependencies: ${error.message}`
+          };
+        }
+
+        // Get current lane name with scope
+        try {
+          const laneId = await this.callBitServerIDEAPI('getCurrentLaneName', [true], params.cwd);
+          workspaceInfo.laneId = laneId;
+        } catch (error) {
+          this.logger.error(`[MCP-DEBUG] Error getting current lane name: ${error.message}`);
+          workspaceInfo.laneId = {
+            error: `Failed to get current lane name: ${error.message}`
+          };
+        }
+        return this.formatAsCallToolResult(workspaceInfo);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_workspace_info tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'getting workspace info');
+      }
+    });
+  }
+  registerComponentDetailsTool(server) {
+    const toolName = 'bit_component_details';
+    const description = 'Get detailed information about multiple components in parallel. Supports batch requests for efficient component discovery. Limited to 5 components max to prevent context overload.';
+    const schema = {
+      cwd: _zod().z.string().describe('Path to workspace directory'),
+      componentIds: _zod().z.array(_zod().z.string()).describe('Array of component IDs to get details for. Limited to 5 components max. Examples: ["acme.design/ui/button", "acme.design/forms/input", "teambit.base-ui/navigation/link"]'),
+      includeSchema: _zod().z.boolean().optional().describe('Include component public API schema (default: false)')
+    };
+    server.tool(toolName, description, schema, async params => {
+      try {
+        // Schema validation is handled automatically by the SDK
+        const includeSchema = params.includeSchema === true;
+        const componentIds = params.componentIds;
+
+        // Check limit of 5 components to prevent context overload
+        const maxComponents = 5;
+        if (componentIds.length > maxComponents) {
+          return {
+            content: [{
+              type: 'text',
+              text: `Error: Too many components requested. Maximum allowed is ${maxComponents} components, but ${componentIds.length} were requested. Please reduce the number of components in your request.`
+            }]
+          };
+        }
+
+        // Execute component detail requests in parallel
+        this.logger.debug(`[MCP-DEBUG] Fetching details for ${componentIds.length} component(s) in parallel: ${componentIds.join(', ')}`);
+        const detailPromises = componentIds.map(async componentId => {
+          try {
+            const result = await this.callBitServerIDEAPI('getCompDetails', [componentId, includeSchema], params.cwd);
+            return {
+              componentId,
+              success: true,
+              details: result
+            };
+          } catch (error) {
+            this.logger.warn(`[MCP-DEBUG] Failed to get details for component "${componentId}": ${error.message}`);
+            return {
+              componentId,
+              success: false,
+              error: error.message
+            };
+          }
+        });
+        const detailResults = await Promise.all(detailPromises);
+
+        // Process and consolidate results
+        const successfulResults = detailResults.filter(r => r.success);
+        const failedResults = detailResults.filter(r => !r.success);
+        if (successfulResults.length === 0) {
+          let message = 'Failed to get details for any components';
+          if (failedResults.length > 0) {
+            message += '\n\nErrors:';
+            failedResults.forEach(r => {
+              message += `\n- "${r.componentId}": ${r.error}`;
+            });
+          }
+          return {
+            content: [{
+              type: 'text',
+              text: message
+            }]
+          };
+        }
+
+        // Build the response
+        const response = {
+          summary: {
+            requested: componentIds.length,
+            successful: successfulResults.length,
+            failed: failedResults.length,
+            includeSchema
+          },
+          components: {}
+        };
+
+        // Add successful component details
+        successfulResults.forEach(result => {
+          response.components[result.componentId] = result.details;
+        });
+
+        // Add failed components info if any
+        if (failedResults.length > 0) {
+          response.failures = {};
+          failedResults.forEach(result => {
+            response.failures[result.componentId] = result.error;
+          });
+        }
+        this.logger.debug(`[MCP-DEBUG] Component details fetched: ${successfulResults.length} successful, ${failedResults.length} failed`);
+        return this.formatAsCallToolResult(response);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_component_details tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'getting component details');
+      }
+    });
+  }
+  registerCreateTool(server) {
+    const toolName = 'bit_create';
+    const description = 'Create a new component (source files and config) using a template.';
+    const schema = {
+      cwd: _zod().z.string().describe('Path to workspace directory'),
+      templateName: _zod().z.string().describe('The template for generating the component (run "bit templates" for a list of available templates)'),
+      componentNames: _zod().z.array(_zod().z.string()).describe('A list of component names to generate'),
+      namespace: _zod().z.string().optional().describe("Sets the component's namespace and nested dirs inside the scope"),
+      scope: _zod().z.string().optional().describe("Sets the component's scope-name. If not entered, the default-scope will be used"),
+      aspect: _zod().z.string().optional().describe('Aspect-id of the template. Helpful when multiple aspects use the same template name'),
+      template: _zod().z.string().optional().describe('Env-id of the template. Alias for --aspect'),
+      path: _zod().z.string().optional().describe('Relative path in the workspace. By default the path is <scope>/<namespace>/<name>'),
+      env: _zod().z.string().optional().describe("Set the component's environment. (overrides the env from variants and the template)"),
+      force: _zod().z.boolean().optional().describe('Replace existing files at the target location')
+    };
+    server.tool(toolName, description, schema, async params => {
+      try {
+        const args = params.componentNames;
+        const flags = {};
+
+        // Add optional flags
+        if (params.namespace) flags.namespace = params.namespace;
+        if (params.scope) flags.scope = params.scope;
+        if (params.aspect) flags.aspect = params.aspect;
+        if (params.template) flags.template = params.template;
+        if (params.path) flags.path = params.path;
+        if (params.env) flags.env = params.env;
+        if (params.force) flags.force = true;
+
+        // Add template name as first argument
+        const allArgs = [params.templateName, ...args];
+        const execution = await this.safeBitCommandExecution('create', allArgs, flags, params.cwd, 'create component');
+        return this.formatAsCallToolResult(execution.result);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_create tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'creating component');
+      }
+    });
+  }
+  registerCommandsListTool(server) {
+    const toolName = 'bit_commands_list';
+    const description = 'Get all available Bit commands with descriptions and groups. Use this to discover what commands are available.';
+    const schema = {
+      extendedDescription: _zod().z.boolean().optional().describe('Include extended descriptions for commands (default: false)'),
+      internal: _zod().z.boolean().optional().describe('Include internal/debug commands (default: false)')
+    };
+    server.tool(toolName, description, schema, async params => {
+      try {
+        const {
+          extendedDescription = false,
+          internal = false
+        } = params;
+        const commandsInfo = [];
+        const shouldSkipCommand = cmd => {
+          return Boolean(cmd.private && !internal || cmd.description.startsWith('DEPRECATED'));
+        };
+
+        // Build list of all commands
+        this.cli.commands.forEach(cmd => {
+          if (shouldSkipCommand(cmd)) return;
+          const mainCmdName = (0, _cli().getCommandName)(cmd);
+          const groupKey = cmd.group;
+          const commandInfo = {
+            name: mainCmdName,
+            description: cmd.description || ''
+          };
+          if (extendedDescription && cmd.extendedDescription) {
+            commandInfo.extendedDescription = cmd.extendedDescription;
+          }
+          if (groupKey) commandInfo.group = this.cli.groups[groupKey] || groupKey;
+
+          // Add subcommands summary
+          if (cmd.commands && cmd.commands.length > 0) {
+            commandInfo.subcommands = cmd.commands.filter(subCmd => !shouldSkipCommand(subCmd)).map(subCmd => ({
+              name: (0, _cli().getCommandName)(subCmd),
+              description: subCmd.description || ''
+            }));
+          }
+          commandsInfo.push(commandInfo);
+        });
+        commandsInfo.sort((a, b) => a.name.localeCompare(b.name));
+        const result = JSON.stringify({
+          total: commandsInfo.length,
+          commands: commandsInfo
+        }, null, 2);
+        this.logger.debug(`[MCP-DEBUG] Successfully retrieved commands list. Total: ${commandsInfo.length}`);
+        return this.formatAsCallToolResult(result);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_commands_list tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'getting commands list');
+      }
+    });
+  }
+  registerCommandHelpTool(server) {
+    const toolName = 'bit_command_help';
+    const description = 'Get detailed help for a specific Bit command including syntax, arguments, flags, and usage examples. Use this to understand exactly how to use a command.';
+    const schema = {
+      command: _zod().z.string().describe('The command name to get help for (e.g., "status", "install", "create")'),
+      subcommand: _zod().z.string().optional().describe('Optional subcommand name (e.g., for "lane show", use command="lane" and subcommand="show")')
+    };
+    server.tool(toolName, description, schema, async params => {
+      try {
+        const {
+          command: requestedCommand,
+          subcommand: requestedSubcommand
+        } = params;
+        let commandInfo = null;
+        const buildDetailedCommandInfo = (cmd, parentName) => {
+          const cmdName = parentName ? `${parentName} ${(0, _cli().getCommandName)(cmd)}` : (0, _cli().getCommandName)(cmd);
+          const info = {
+            name: cmdName,
+            description: cmd.description || '',
+            extendedDescription: cmd.extendedDescription || '',
+            group: cmd.group ? this.cli.groups[cmd.group] || cmd.group : ''
+          };
+
+          // Add arguments information
+          const argsData = (0, _cli().getArgsData)(cmd);
+          if (argsData.length > 0) {
+            info.arguments = argsData.map(arg => ({
+              name: arg.nameRaw,
+              description: arg.description || '',
+              required: arg.required,
+              isArray: arg.isArray
+            }));
+          }
+
+          // Add options/flags information
+          info.options = (0, _cli().getFlagsData)(cmd);
+
+          // Add examples if available
+          if (cmd.examples) {
+            info.examples = cmd.examples;
+          }
+
+          // Add subcommands if available (including private ones for help purposes)
+          if (cmd.commands && cmd.commands.length > 0) {
+            info.subcommands = cmd.commands.map(subCmd => ({
+              name: (0, _cli().getCommandName)(subCmd),
+              description: subCmd.description || ''
+            }));
+          }
+          return info;
+        };
+
+        // Search for the requested command
+        this.cli.commands.forEach(cmd => {
+          const mainCmdName = (0, _cli().getCommandName)(cmd);
+          if (requestedSubcommand) {
+            // Looking for a subcommand
+            if (mainCmdName === requestedCommand && cmd.commands) {
+              const subCmd = cmd.commands.find(sub => (0, _cli().getCommandName)(sub) === requestedSubcommand);
+              if (subCmd) {
+                commandInfo = buildDetailedCommandInfo(subCmd, requestedCommand);
+              }
+            }
+          } else {
+            // Looking for a main command
+            if (mainCmdName === requestedCommand) {
+              commandInfo = buildDetailedCommandInfo(cmd);
+            }
+          }
+        });
+        if (!commandInfo) {
+          const commandFullName = requestedSubcommand ? `${requestedCommand} ${requestedSubcommand}` : requestedCommand;
+          return this.formatAsCallToolResult(`Command not found: ${commandFullName}`);
+        }
+        const result = JSON.stringify(commandInfo, null, 2);
+        this.logger.debug(`[MCP-DEBUG] Successfully retrieved command help for: ${commandInfo.name}`);
+        return this.formatAsCallToolResult(result);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_command_help tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'getting command help');
+      }
+    });
+  }
+  registerQueryTool(server) {
+    const toolName = 'bit_query';
+    const description = 'Execute read-only Bit commands that safely inspect workspace and component state without making modifications. Only whitelisted query commands are allowed for safety.';
+    const schema = {
+      cwd: _zod().z.string().describe('Path to workspace directory'),
+      command: _zod().z.string().describe('The Bit command to execute (e.g., "status", "show", "list")'),
+      args: _zod().z.array(_zod().z.string()).optional().describe('Arguments to pass to the command'),
+      flags: _zod().z.record(_zod().z.union([_zod().z.string(), _zod().z.boolean()])).optional().describe('Flags to pass to the command as key-value pairs')
+    };
+    server.tool(toolName, description, schema, async params => {
+      try {
+        const {
+          command,
+          args = [],
+          flags = {},
+          cwd
+        } = params;
+
+        // Check if command is in the read-only whitelist
+        // Support both single commands and subcommands (e.g., "lane show")
+        const fullCommand = args.length > 0 ? `${command} ${args[0]}` : command;
+        const isAllowed = this.readOnlyCommands.has(command) || this.readOnlyCommands.has(fullCommand);
+        if (!isAllowed) {
+          const allowedCommands = Array.from(this.readOnlyCommands).sort().join(', ');
+          return this.formatAsCallToolResult(`Error: Command "${command}" is not allowed in query mode. Allowed read-only commands: ${allowedCommands}`);
+        }
+
+        // Build command arguments
+        const commandArgs = [command, ...args];
+
+        // Add flags to arguments
+        Object.entries(flags).forEach(([key, value]) => {
+          if (typeof value === 'boolean' && value) {
+            commandArgs.push(`--${key}`);
+          } else if (typeof value === 'string' && value) {
+            commandArgs.push(`--${key}`);
+            commandArgs.push(value);
+          }
+        });
+        this.logger.debug(`[MCP-DEBUG] Executing query command: ${command} with args: ${JSON.stringify(commandArgs)}`);
+        const execution = await this.safeBitCommandExecution(command, args, flags, cwd, `execute query command ${command}`);
+        return this.formatAsCallToolResult(execution.result);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_query tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'executing query command');
+      }
+    });
+  }
+  registerExecuteTool(server) {
+    const toolName = 'bit_execute';
+    const description = 'Execute Bit commands that make changes to workspace or components (not read-only).';
+    const schema = {
+      cwd: _zod().z.string().describe('Path to workspace directory'),
+      command: _zod().z.string().describe('The Bit command to execute (e.g., "import", "tag", "export", "remove")'),
+      args: _zod().z.array(_zod().z.string()).optional().describe('Arguments to pass to the command'),
+      flags: _zod().z.record(_zod().z.union([_zod().z.string(), _zod().z.boolean()])).optional().describe('Flags to pass to the command as key-value pairs')
+    };
+    server.tool(toolName, description, schema, async params => {
+      try {
+        let {
+          command,
+          args = []
+        } = params;
+        const {
+          flags = {},
+          cwd
+        } = params;
+
+        // Handle sub-commands: if command has multiple words, move the second word to args
+        const commandParts = command.trim().split(/\s+/);
+        if (commandParts.length > 1) {
+          command = commandParts[0];
+          args = [commandParts[1], ...args];
+        }
+
+        // Check for lane commands that modify workspace state and require direct user interaction
+        if (command === 'lane') {
+          const subcommand = args[0];
+          if (subcommand === 'switch' || subcommand === 'merge') {
+            return this.formatAsCallToolResult(`Error: The "lane ${subcommand}" command is not available through the MCP server. ` + `This workspace-modifying operation must be run directly in the terminal where the user has full visibility and control.`);
+          }
+        }
+
+        // Also check for the shorthand 'switch' command (which is an alias for 'lane switch')
+        if (command === 'switch') {
+          return this.formatAsCallToolResult(`Error: The "switch" command (alias for "lane switch") is not available through the MCP server. ` + `This workspace-modifying operation must be run directly in the terminal where the user has full visibility and control.`);
+        }
+        this.logger.debug(`[MCP-DEBUG] Executing command: ${command} with args: ${JSON.stringify(args)} and flags: ${JSON.stringify(flags)}`);
+        const execution = await this.safeBitCommandExecution(command, args, flags, cwd, `execute command ${command}`);
+        return this.formatAsCallToolResult(execution.result);
+      } catch (error) {
+        this.logger.error(`[MCP-DEBUG] Error in bit_execute tool: ${error.message}`);
+        return this.formatErrorAsCallToolResult(error, 'executing command');
+      }
+    });
+  }
+  processSubCommands(server, parentCmd, options) {
+    const parentCmdName = (0, _cli().getCommandName)(parentCmd);
+    parentCmd.commands?.forEach(subCmd => {
+      const subCmdName = (0, _cli().getCommandName)(subCmd);
+      const fullCmdName = `${parentCmdName} ${subCmdName}`;
+      if (this.shouldIncludeCommand(fullCmdName, options)) {
+        this.registerToolForCommand(server, subCmd, parentCmd);
+      }
+    });
+  }
+  async runBit(args, cwd) {
+    this.logger.debug(`[MCP-DEBUG] Running: ${this.bitBin} ${args.join(' ')} in ${cwd}`);
+    try {
+      const result = _child_process().default.spawnSync(this.bitBin, args, {
+        cwd,
+        env: _objectSpread(_objectSpread({}, process.env), {}, {
+          BIT_DISABLE_SPINNER: '1'
+        }),
+        encoding: 'utf8'
+      });
+      if (result.error) {
+        throw result.error;
+      }
+      if (result.status !== 0) {
+        const errorMessage = result.stderr || `Command failed with status ${result.status}`;
+        throw new Error(errorMessage);
+      }
+      this.logger.debug(`[MCP-DEBUG] result. stdout: ${result.stdout}`);
+      return {
+        content: [{
+          type: 'text',
+          text: result.stdout
+        }]
+      };
+    } catch (error) {
+      this.logger.error(`[MCP-DEBUG] Error executing ${this.bitBin} ${args.join(' ')}`, error);
+      return {
+        content: [{
+          type: 'text',
+          text: error.message
+        }]
+      };
+    }
+  }
+
+  /**
+   * Helper method to execute a bit-server API call with standardized error handling
+   */
+  async executeBitServerCommand(command, args = [], flags = {}, cwd, operationName) {
+    try {
+      const result = await this.callBitServerAPI(command, args, flags, cwd);
+      this.logger.debug(`[MCP-DEBUG] Successfully executed ${operationName} via bit-server`);
+      return result;
+    } catch (error) {
+      this.logger.warn(`[MCP-DEBUG] Failed to execute ${operationName} via bit-server: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Helper method to format any result as CallToolResult
+   */
+  formatAsCallToolResult(result) {
+    if (typeof result === 'string') {
+      return {
+        content: [{
+          type: 'text',
+          text: result
+        }]
+      };
+    } else if (typeof result === 'object') {
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify(result, null, 2)
+        }]
+      };
+    } else {
+      return {
+        content: [{
+          type: 'text',
+          text: String(result)
+        }]
+      };
+    }
+  }
+
+  /**
+   * Helper method to format error as CallToolResult
+   */
+  formatErrorAsCallToolResult(error, operation) {
+    return {
+      content: [{
+        type: 'text',
+        text: `Error ${operation}: ${error.message}`
+      }]
+    };
+  }
+
+  /**
+   * Helper method to safely execute a bit command with error handling
+   */
+  async safeBitCommandExecution(command, args = [], flags = {}, cwd, operationName, includeErrorInResult = false) {
+    try {
+      let result = await this.executeBitServerCommand(command, args, flags, cwd, operationName);
+
+      // Unwrap the result from data wrapper if it exists and we have a successful result
+      if (result && typeof result === 'object' && 'data' in result && result.data !== undefined) {
+        result = result.data;
+      }
+
+      // Clean up output by removing ANSI color codes when not using JSON format
+      const useJson = flags && flags.json === true;
+      if (!useJson && typeof result === 'string') {
+        result = (0, _stripAnsi().default)(result);
+      }
+      return {
+        success: true,
+        result
+      };
+    } catch (error) {
+      if (includeErrorInResult) {
+        return {
+          success: false,
+          result: {
+            error: `Failed to ${operationName}: ${error.message}`
+          },
+          error: error.message
+        };
+      } else {
+        throw error;
+      }
+    }
+  }
+  validateBitBin(bitBin) {
+    const trimmed = bitBin?.trim();
+    // Check for shell metacharacters and spaces. Protect against command injection.
+    if (!trimmed || /[;&|`$(){}[\]<>'"\\]/.test(trimmed) || /\s/.test(trimmed)) throw new Error('Invalid bitBin');
+    return trimmed;
+  }
+
+  // Setup command business logic methods
+  getEditorDisplayName(editor) {
+    return _mcp2().McpConfigWriter.getEditorDisplayName(editor);
+  }
+
+  /**
+   * Get the path to the editor config file based on editor type and scope
+   */
+  getEditorConfigPath(editor, isGlobal, workspaceDir) {
+    return _mcp2().McpConfigWriter.getEditorConfigPath(editor, isGlobal, workspaceDir);
+  }
+  async setupEditor(editor, options, workspaceDir) {
+    // Add workspaceDir to options if provided
+    const setupOptions = _objectSpread({}, options);
+    if (workspaceDir) {
+      setupOptions.workspaceDir = workspaceDir;
+    }
+    await _mcp2().McpConfigWriter.setupEditor(editor, setupOptions);
+  }
+  async writeRulesFile(editor, options, workspaceDir) {
+    // Add workspaceDir to options if provided
+    const rulesOptions = _objectSpread({}, options);
+    if (workspaceDir) {
+      rulesOptions.workspaceDir = workspaceDir;
+    }
+    await _mcp2().McpConfigWriter.writeRulesFile(editor, rulesOptions);
+  }
+  async getRulesContent(consumerProject = false, forceStandard = false) {
+    return _mcp2().McpConfigWriter.getDefaultRulesContent(consumerProject, process.cwd(), forceStandard);
+  }
+
+  /**
+   * Get the path to the rules file based on editor type and scope
+   */
+  getRulesFilePath(editor, isGlobal, workspaceDir) {
+    const editorLower = editor.toLowerCase();
+    if (editorLower === 'vscode') {
+      return _mcp2().McpConfigWriter.getVSCodePromptsPath(isGlobal, workspaceDir);
+    } else if (editorLower === 'cursor') {
+      return _mcp2().McpConfigWriter.getCursorPromptsPath(isGlobal, workspaceDir);
+    } else if (editorLower === 'roo') {
+      return _mcp2().McpConfigWriter.getRooCodePromptsPath(isGlobal, workspaceDir);
+    } else if (editorLower === 'cline') {
+      return _mcp2().McpConfigWriter.getClinePromptsPath(isGlobal, workspaceDir);
+    } else if (editorLower === 'claude-code') {
+      return _mcp2().McpConfigWriter.getClaudeCodePromptsPath(isGlobal, workspaceDir);
+    }
+    throw new Error(`Editor "${editor}" is not supported yet for rules files.`);
+  }
+  static async provider([cli, loggerMain]) {
+    const logger = loggerMain.createLogger(_cliMcpServer().CliMcpServerAspect.id);
+    const mcpServer = new CliMcpServerMain(cli, logger);
+    const mcpServerCmd = new (_mcpServer().McpServerCmd)(mcpServer);
+    mcpServerCmd.commands = [new (_mcpServer().McpStartCmd)(mcpServer), new (_setupCmd().McpSetupCmd)(mcpServer), new (_rulesCmd().McpRulesCmd)(mcpServer)];
+    cli.register(mcpServerCmd);
+    return mcpServer;
+  }
+}
+exports.CliMcpServerMain = CliMcpServerMain;
+_defineProperty(CliMcpServerMain, "slots", []);
+_defineProperty(CliMcpServerMain, "dependencies", [_cli().CLIAspect, _logger().LoggerAspect]);
+_defineProperty(CliMcpServerMain, "runtime", _cli().MainRuntime);
+_cliMcpServer().CliMcpServerAspect.addRuntime(CliMcpServerMain);
+var _default = exports.default = CliMcpServerMain;
+
+//# sourceMappingURL=cli-mcp-server.main.runtime.js.map