mobbdev 1.0.183 → 1.0.185

package/dist/index.mjs

@@ -12498,29 +12498,6 @@ var logWarn = (message, data) => logger.log(message, "warn", data);
 var logDebug = (message, data) => logger.log(message, "debug", data);
 var log = logger.log.bind(logger);
 
-// src/mcp/services/ConfigStoreService.ts
-init_configs();
-import Configstore4 from "configstore";
-function createConfigStore(defaultValues = { apiToken: "" }) {
-  const API_URL2 = process.env["API_URL"] || MCP_DEFAULT_API_URL;
-  let domain = "";
-  try {
-    const url = new URL(API_URL2);
-    domain = url.hostname;
-  } catch (e) {
-    domain = API_URL2.replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/:\d+$/, "");
-  }
-  const sanitizedDomain = domain.replace(/\./g, "_");
-  return new Configstore4(
-    `${packageJson.name}-${sanitizedDomain}`,
-    defaultValues
-  );
-}
-function getConfigStore() {
-  return createConfigStore();
-}
-var configStore = getConfigStore();
-
 // src/mcp/services/McpGQLClient.ts
 import crypto3 from "crypto";
 import { GraphQLClient as GraphQLClient2 } from "graphql-request";
@@ -12653,6 +12630,29 @@ var GetLatestReportByRepoUrlResponseSchema = z31.object({
   expiredReport: z31.array(ExpiredReportSchema)
 });
 
+// src/mcp/services/ConfigStoreService.ts
+init_configs();
+import Configstore4 from "configstore";
+function createConfigStore(defaultValues = { apiToken: "" }) {
+  const API_URL2 = process.env["API_URL"] || MCP_DEFAULT_API_URL;
+  let domain = "";
+  try {
+    const url = new URL(API_URL2);
+    domain = url.hostname;
+  } catch (e) {
+    domain = API_URL2.replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/:\d+$/, "");
+  }
+  const sanitizedDomain = domain.replace(/\./g, "_");
+  return new Configstore4(
+    `${packageJson.name}-${sanitizedDomain}`,
+    defaultValues
+  );
+}
+function getConfigStore() {
+  return createConfigStore();
+}
+var configStore = getConfigStore();
+
 // src/mcp/services/McpAuthService.ts
 import crypto2 from "crypto";
 import os2 from "os";
@@ -13340,18 +13340,12 @@ async function createAuthenticatedMcpGQLClient({
   return new McpGQLClient({ apiKey: newApiToken, type: "apiKey" });
 }
 
-// src/mcp/services/McpUsageService/McpUsageService.ts
-init_configs();
-import fetch5 from "node-fetch";
-import os4 from "os";
-import { v4 as uuidv43, v5 as uuidv5 } from "uuid";
-
 // src/mcp/services/McpUsageService/host.ts
 import { execSync } from "child_process";
 import fs10 from "fs";
 import os3 from "os";
 import path11 from "path";
-var IDEs = ["cursor", "windsurf", "webstorm", "vscode"];
+var IDEs = ["cursor", "windsurf", "webstorm", "vscode", "claude"];
 var runCommand = (cmd) => {
   try {
     return execSync(cmd, { encoding: "utf8" }).trim();
@@ -13363,33 +13357,119 @@ var gitInfo = {
   name: runCommand("git config user.name"),
   email: runCommand("git config user.email")
 };
-var getMCPConfigPath = (hostName) => {
+var getClaudeWorkspacePaths = () => {
+  const home = os3.homedir();
+  const claudeIdePath = path11.join(home, ".claude", "ide");
+  const workspacePaths = [];
+  if (!fs10.existsSync(claudeIdePath)) {
+    return workspacePaths;
+  }
+  try {
+    const lockFiles = fs10.readdirSync(claudeIdePath).filter((file) => file.endsWith(".lock"));
+    for (const lockFile of lockFiles) {
+      const lockFilePath = path11.join(claudeIdePath, lockFile);
+      try {
+        const lockContent = JSON.parse(fs10.readFileSync(lockFilePath, "utf8"));
+        if (lockContent.workspaceFolders && Array.isArray(lockContent.workspaceFolders)) {
+          workspacePaths.push(...lockContent.workspaceFolders);
+        }
+      } catch (error) {
+        logWarn(
+          `[UsageService] Failed to read Claude lock file: ${lockFilePath}`
+        );
+      }
+    }
+  } catch (error) {
+    logWarn(
+      `[UsageService] Failed to read Claude IDE directory: ${claudeIdePath}`
+    );
+  }
+  return workspacePaths;
+};
+var getMCPConfigPaths = (hostName) => {
   const home = os3.homedir();
+  const currentDir = process.env["WORKSPACE_FOLDER_PATHS"] || process.env["PWD"] || process.cwd();
   switch (hostName.toLowerCase()) {
     case "cursor":
-      return path11.join(home, ".cursor", "mcp.json");
+      return [
+        path11.join(currentDir, ".cursor", "mcp.json"),
+        // local first
+        path11.join(home, ".cursor", "mcp.json")
+      ];
     case "windsurf":
-      return path11.join(home, ".codeium", "windsurf", "mcp_config.json");
+      return [
+        path11.join(currentDir, ".codeium", "mcp_config.json"),
+        // local first
+        path11.join(home, ".codeium", "windsurf", "mcp_config.json")
+      ];
     case "webstorm":
-      return "";
+      return [];
     case "visualstudiocode":
     case "vscode":
-      return process.platform === "win32" ? path11.join(home, "AppData", "Roaming", "Code", "User", "mcp.json") : path11.join(
-        home,
-        "Library",
-        "Application Support",
-        "Code",
-        "User",
-        "mcp.json"
-      );
+      return [
+        path11.join(currentDir, ".vscode", "mcp.json"),
+        // local first
+        process.platform === "win32" ? path11.join(home, "AppData", "Roaming", "Code", "User", "mcp.json") : path11.join(
+          home,
+          "Library",
+          "Application Support",
+          "Code",
+          "User",
+          "mcp.json"
+        )
+      ];
+    case "claude": {
+      const claudePaths = [
+        path11.join(currentDir, ".claude.json"),
+        // local first
+        path11.join(home, ".claude.json")
+      ];
+      const workspacePaths = getClaudeWorkspacePaths();
+      for (const workspacePath of workspacePaths) {
+        claudePaths.push(path11.join(workspacePath, ".mcp.json"));
+      }
+      return claudePaths;
+    }
     default:
       throw new Error(`Unknown hostName: ${hostName}`);
   }
 };
-var readMCPConfig = (hostName) => {
-  const filePath = getMCPConfigPath(hostName);
+var readConfigFile = (filePath) => {
   if (!fs10.existsSync(filePath)) return null;
-  return JSON.parse(fs10.readFileSync(filePath, "utf8"));
+  try {
+    return JSON.parse(fs10.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    logWarn(`[UsageService] Failed to read MCP config: ${filePath}`);
+    return null;
+  }
+};
+var readMCPConfig = (hostName) => {
+  const configPaths = getMCPConfigPaths(hostName);
+  const mergedConfig = {};
+  for (const configPath of configPaths) {
+    const config4 = readConfigFile(configPath);
+    if (hostName === "claude" && config4?.projects) {
+      const allMcpServers = {};
+      for (const projectPath in config4.projects) {
+        const project = config4.projects[projectPath];
+        if (project?.mcpServers) {
+          Object.assign(allMcpServers, project.mcpServers);
+        }
+      }
+      mergedConfig.mcpServers = { ...mergedConfig.mcpServers, ...allMcpServers };
+      continue;
+    }
+    if (config4?.mcpServers) {
+      mergedConfig.mcpServers = {
+        ...mergedConfig.mcpServers,
+        ...config4.mcpServers
+      };
+    }
+    if (config4?.servers) {
+      mergedConfig.servers = { ...mergedConfig.servers, ...config4.servers };
+    }
+  }
+  return Object.keys(mergedConfig).length > 0 ? mergedConfig : null;
 };
 var getRunningProcesses = () => {
   try {
@@ -13398,11 +13478,29 @@ var getRunningProcesses = () => {
     return "";
   }
 };
+var checkUrlAccessibility = (url) => {
+  try {
+    execSync(`curl -s --connect-timeout 5 --max-time 3 "${url}"`, {
+      encoding: "utf8",
+      stdio: "ignore"
+    });
+    return true;
+  } catch (error) {
+    if (error && typeof error === "object" && "status" in error) {
+      const exitCode = error.status;
+      if (exitCode === 28) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
 var knownHosts = {
   webstorm: "WebStorm",
   cursor: "Cursor",
   windsurf: "Windsurf",
-  code: "Vscode"
+  code: "Vscode",
+  claude: "Claude"
 };
 var versionCommands = {
   WebStorm: {
@@ -13437,6 +13535,16 @@ var versionCommands = {
     win32: [
       `(Get-Item "$env:LOCALAPPDATA\\Programs\\Microsoft VS Code\\Code.exe").VersionInfo.ProductVersion`
     ]
+  },
+  Claude: {
+    darwin: [
+      "claude --version",
+      `grep -A1 CFBundleVersion "/Applications/Claude.app/Contents/Info.plist" | grep '<string>' | sed -E 's/.*<string>(.*)<\\/string>.*/\\1/'`
+    ],
+    win32: [
+      "claude --version",
+      `(Get-Item "$env:LOCALAPPDATA\\Programs\\Claude\\Claude.exe").VersionInfo.ProductVersion`
+    ]
   }
 };
 var getProcessInfo = (pid) => {
@@ -13481,50 +13589,46 @@ var getHostInfo = () => {
     for (const [name, server] of Object.entries(
       cfg.mcpServers || cfg.servers || {}
     )) {
-      servers.push({
-        ide,
-        name,
-        command: server.command || "",
-        isRunning: false
-      });
+      if (server.command || server.url) {
+        servers.push({
+          ide,
+          name,
+          command: `${server.command} ${server.args ? server.args?.join(" ") : ""}`,
+          isRunning: false,
+          ...server.url && { url: server.url }
+        });
+      }
     }
   }
   const runningLines = runningProcesses.split("\n");
   for (const line of runningLines) {
     if (line.includes("mcp")) {
       const cmdLower = line.toLowerCase();
+      let ideName = "Unknown";
+      const pidMatch = line.trim().split(/\s+/)[1];
+      const pid = parseInt(String(pidMatch), 10);
+      if (!isNaN(pid)) {
+        let currentPid = pid;
+        while (currentPid && currentPid !== 0) {
+          const proc = getProcessInfo(currentPid);
+          if (!proc) break;
+          const cmdProc = proc.cmd.toLowerCase();
+          const found = Object.keys(knownHosts).find(
+            (key) => cmdProc.includes(key)
+          );
+          if (found) {
+            ideName = knownHosts[found] || "Unknown";
+            break;
+          }
+          currentPid = parseInt(proc.ppid, 10);
+        }
+      }
       const existingServer = servers.find(
-        (s) => s.command && cmdLower.includes(s.command.toLowerCase())
+        (s) => s.command && cmdLower.includes(s.command.toLowerCase()) && s.ide.toLowerCase() === ideName.toLowerCase()
       );
       if (existingServer) {
         existingServer.isRunning = true;
       } else {
-        let ideName = "Unknown";
-        const foundHostKey = Object.keys(knownHosts).find(
-          (key) => cmdLower.includes(key)
-        );
-        if (foundHostKey) {
-          ideName = knownHosts[foundHostKey] || "Unknown";
-        } else {
-          const pidMatch = line.trim().split(/\s+/)[1];
-          const pid = parseInt(String(pidMatch), 10);
-          if (!isNaN(pid)) {
-            let currentPid = pid;
-            while (currentPid && currentPid !== 0) {
-              const proc = getProcessInfo(currentPid);
-              if (!proc) break;
-              const cmdProc = proc.cmd.toLowerCase();
-              const found = Object.keys(knownHosts).find(
-                (key) => cmdProc.includes(key)
-              );
-              if (found) {
-                ideName = knownHosts[found] || "Unknown";
-                break;
-              }
-              currentPid = parseInt(proc.ppid, 10);
-            }
-          }
-        }
         servers.push({
           ide: ideName.toLowerCase(),
           name: "unknown",
@@ -13534,6 +13638,14 @@ var getHostInfo = () => {
       }
     }
   }
+  for (const server of servers) {
+    if (server.url && !server.isRunning) {
+      const isUrlAccessible = checkUrlAccessibility(server.url);
+      if (isUrlAccessible) {
+        server.isRunning = true;
+      }
+    }
+  }
   for (const { ide, name, command, isRunning } of servers) {
     const config4 = allConfigs[ide] || null;
     const ideName = ide.charAt(0).toUpperCase() + ide.slice(1) || "Unknown";
@@ -13570,11 +13682,17 @@ var getHostInfo = () => {
 };
 
 // src/mcp/services/McpUsageService/McpUsageService.ts
+init_configs();
+import fetch5 from "node-fetch";
+import os4 from "os";
+import { v4 as uuidv43, v5 as uuidv5 } from "uuid";
 var McpUsageService = class {
-  constructor() {
+  constructor(govOrgId) {
     __publicField(this, "configKey", "mcpUsage");
     __publicField(this, "intervalId", null);
     __publicField(this, "REST_API_URL", MCP_DEFAULT_REST_API_URL);
+    __publicField(this, "govOrgId");
+    this.govOrgId = govOrgId;
     this.startPeriodicTracking();
     if (process.env["API_URL"]) {
       const url = new URL(process.env["API_URL"]);
@@ -13594,7 +13712,7 @@ var McpUsageService = class {
       logDebug(`[UsageService] Triggering periodic usage service`, {
         MCP_PERIODIC_TRACK_INTERVAL
       });
-      await mcpUsageService.trackServerStart();
+      await this.trackServerStart();
     }, 1e4);
   }
   generateHostId() {
@@ -13614,18 +13732,16 @@ var McpUsageService = class {
     return hostId;
   }
   getOrganizationId() {
-    const organizationId = configStore.get("GOV-ORG-ID") || "";
-    if (organizationId) {
-      logDebug("[UsageService] Using stored organization ID", {
-        organizationId
+    if (this.govOrgId) {
+      logDebug("[UsageService] Using provided organization ID", {
+        organizationId: this.govOrgId
       });
-      return organizationId;
+      return this.govOrgId;
     }
     return "";
   }
   hasOrganizationId() {
-    const organizationId = configStore.get("GOV-ORG-ID") || "";
-    return !!organizationId;
+    return !!this.govOrgId;
   }
   createUsageData(mcpHostId, organizationId, status) {
     const { user, mcps } = getHostInfo();
@@ -13711,12 +13827,12 @@ var McpUsageService = class {
     this.intervalId = null;
   }
 };
-var mcpUsageService = new McpUsageService();
 
 // src/mcp/tools/toolNames.ts
 var MCP_TOOL_CHECK_FOR_NEW_AVAILABLE_FIXES = "check_for_new_available_fixes";
 var MCP_TOOL_FETCH_AVAILABLE_FIXES = "fetch_available_fixes";
 var MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES = "scan_and_fix_vulnerabilities";
+var MCP_TOOL_CHECKER = "mcp_checker";
 
 // src/mcp/core/McpServer.ts
 init_configs();
@@ -13741,6 +13857,9 @@ var ToolRegistry = class {
   getTool(name) {
     return this.tools.get(name);
   }
+  getToolDefinition(name) {
+    return this.tools.get(name)?.getDefinition();
+  }
   getAllTools() {
     return Array.from(this.tools.values()).map((tool) => tool.getDefinition());
   }
@@ -13757,14 +13876,16 @@ var ToolRegistry = class {
 
 // src/mcp/core/McpServer.ts
 var McpServer = class {
-  constructor(config4) {
+  constructor(config4, govOrgId = "") {
     __publicField(this, "server");
     __publicField(this, "toolRegistry");
     __publicField(this, "isEventHandlersSetup", false);
     __publicField(this, "eventHandlers", /* @__PURE__ */ new Map());
     __publicField(this, "parentProcessCheckInterval");
     __publicField(this, "parentPid");
+    __publicField(this, "mcpUsageService");
     this.parentPid = process.ppid;
+    this.mcpUsageService = govOrgId ? new McpUsageService(govOrgId) : null;
     this.server = new Server(
       {
         name: config4.name,
@@ -13788,18 +13909,18 @@ var McpServer = class {
   }
   async trackServerUsage(action, signalOrError) {
     try {
-      if (!mcpUsageService.hasOrganizationId()) {
+      if (!this.mcpUsageService?.hasOrganizationId()) {
         logDebug(
           `[McpServer] Skipping ${action} usage tracking - organization ID not available`
         );
         return;
       }
       if (action === "start") {
-        await mcpUsageService.trackServerStart();
+        await this.mcpUsageService?.trackServerStart();
       }
       if (action === "stop") {
-        await mcpUsageService.trackServerStop();
-        mcpUsageService.reset();
+        await this.mcpUsageService?.trackServerStop();
+        this.mcpUsageService?.reset();
       }
     } catch (usageError) {
       logWarn(`Failed to track MCP server ${action}`, {
@@ -14002,10 +14123,21 @@ var McpServer = class {
     }
   }
   async handleListToolsRequest(request) {
-    const govOrgId = configStore.get("GOV-ORG-ID") || "";
-    if (govOrgId) {
+    const mcpCheckerTool = this.toolRegistry.getToolDefinition(MCP_TOOL_CHECKER);
+    if (mcpCheckerTool) {
       return {
-        tools: []
+        tools: [
+          {
+            name: mcpCheckerTool.name,
+            display_name: mcpCheckerTool.display_name || mcpCheckerTool.name,
+            description: mcpCheckerTool.description,
+            inputSchema: {
+              type: "object",
+              properties: mcpCheckerTool.inputSchema.properties || {},
+              required: mcpCheckerTool.inputSchema.required || []
+            }
+          }
+        ]
       };
     }
     logInfo("Received list_tools request");
@@ -14215,10 +14347,12 @@ var BaseTool = class {
     };
   }
   async execute(args) {
-    logDebug(`Authenticating tool: ${this.name}`, { args });
-    const mcpGqlClient = await createAuthenticatedMcpGQLClient();
-    const userInfo = await mcpGqlClient.getUserInfo();
-    logDebug("User authenticated successfully", { userInfo });
+    if (this.hasAuthentication) {
+      logDebug(`Authenticating tool: ${this.name}`, { args });
+      const mcpGqlClient = await createAuthenticatedMcpGQLClient();
+      const userInfo = await mcpGqlClient.getUserInfo();
+      logDebug("User authenticated successfully", { userInfo });
+    }
     const validatedArgs = this.validateInput(args);
     logDebug(`Tool ${this.name} input validation successful`, {
       validatedArgs
@@ -17590,6 +17724,7 @@ Example payload:
 {
   "path": "/home/user/my-project"
 }`);
+    __publicField(this, "hasAuthentication", true);
     __publicField(this, "inputSchema", {
       type: "object",
       properties: {
@@ -17732,6 +17867,7 @@ The tool will:
 3. Query the MOBB service by the origin remote URL and return a textual summary of available fixes (total and by severity) or a message if none are found.
 
 Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only need a fixes summary and do NOT want to perform scanning or code modifications.`);
+    __publicField(this, "hasAuthentication", true);
     __publicField(this, "inputSchema", {
       type: "object",
       properties: {
@@ -17794,9 +17930,96 @@ Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only
   }
 };
 
+// src/mcp/tools/mcpChecker/mcpCheckerTool.ts
+import z36 from "zod";
+
+// src/mcp/tools/mcpChecker/mcpCheckerService.ts
+var _McpCheckerService = class _McpCheckerService {
+  constructor(govOrgId) {
+    __publicField(this, "govOrgId");
+    this.govOrgId = govOrgId;
+  }
+  static getInstance(govOrgId) {
+    if (!_McpCheckerService.instances.has(govOrgId)) {
+      _McpCheckerService.instances.set(govOrgId, new _McpCheckerService(govOrgId));
+    }
+    return _McpCheckerService.instances.get(govOrgId);
+  }
+  processMcpCheck() {
+    if (!this.govOrgId) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: ""
+          }
+        ]
+      };
+    }
+    logInfo("Executing built-in mcp_checker tool");
+    const hostInfo = getHostInfo();
+    const mcpServersInfo = hostInfo.mcps.filter((mcp) => mcp.mcpName !== "unknown").map(
+      (mcp) => `- ${mcp.mcpName} (${mcp.ideName} ${mcp.ideVersion}): ${mcp.isRunning ? "\u2705 Running" : "\u274C Not Running"}`
+    ).join("\n");
+    const response = {
+      content: [
+        {
+          type: "text",
+          text: `MCP Server Status Report
+
+User: ${hostInfo.user.name} (${hostInfo.user.email})
+
+Configured MCP Servers:
+${mcpServersInfo}
+
+Total Servers: ${hostInfo.mcps.length}
+Running Servers: ${hostInfo.mcps.filter((mcp) => mcp.isRunning).length}`
+        }
+      ]
+    };
+    logInfo("mcp_checker tool executed successfully");
+    return response;
+  }
+};
+__publicField(_McpCheckerService, "instances", /* @__PURE__ */ new Map());
+var McpCheckerService = _McpCheckerService;
+
+// src/mcp/tools/mcpChecker/mcpCheckerTool.ts
+var McpCheckerTool = class extends BaseTool {
+  constructor(govOrgId) {
+    super();
+    __publicField(this, "name", MCP_TOOL_CHECKER);
+    __publicField(this, "displayName", "MCP Checker");
+    // A detailed description to guide the LLM on when and how to invoke this tool.
+    __publicField(this, "description", "Check the MCP servers running on this IDE against organization policies.");
+    __publicField(this, "inputValidationSchema", z36.object({}));
+    __publicField(this, "inputSchema", {
+      type: "object",
+      properties: {},
+      required: []
+    });
+    __publicField(this, "hasAuthentication", false);
+    __publicField(this, "mcpCheckerService");
+    this.mcpCheckerService = McpCheckerService.getInstance(govOrgId);
+  }
+  async executeInternal(args) {
+    logDebug(`Executing tool: ${this.name}`, { args });
+    try {
+      return this.mcpCheckerService.processMcpCheck();
+    } catch (error) {
+      const errorResponse = this.createSuccessResponse(error.message);
+      logError("Tool execution failed", {
+        error: error.message,
+        result: errorResponse
+      });
+      return errorResponse;
+    }
+  }
+};
+
 // src/mcp/tools/scanAndFixVulnerabilities/ScanAndFixVulnerabilitiesTool.ts
 init_configs();
-import z36 from "zod";
+import z37 from "zod";
 
 // src/mcp/tools/scanAndFixVulnerabilities/ScanAndFixVulnerabilitiesService.ts
 init_configs();
@@ -17981,16 +18204,17 @@ Example payload:
   "maxFiles": 50,
   "rescan": false
 }`);
-    __publicField(this, "inputValidationSchema", z36.object({
-      path: z36.string().describe(
+    __publicField(this, "hasAuthentication", true);
+    __publicField(this, "inputValidationSchema", z37.object({
+      path: z37.string().describe(
         "Full local path to repository to scan and fix vulnerabilities"
       ),
-      offset: z36.number().optional().describe("Optional offset for pagination"),
-      limit: z36.number().optional().describe("Optional maximum number of results to return"),
-      maxFiles: z36.number().optional().describe(
+      offset: z37.number().optional().describe("Optional offset for pagination"),
+      limit: z37.number().optional().describe("Optional maximum number of results to return"),
+      maxFiles: z37.number().optional().describe(
         `Optional maximum number of files to scan (default: ${MCP_DEFAULT_MAX_FILES_TO_SCAN}). Increase for comprehensive scans of larger codebases or decrease for faster focused scans.`
       ),
-      rescan: z36.boolean().optional().describe("Optional whether to rescan the repository")
+      rescan: z37.boolean().optional().describe("Optional whether to rescan the repository")
     }));
     __publicField(this, "inputSchema", {
       type: "object",
@@ -18023,7 +18247,7 @@ Example payload:
     this.vulnerabilityFixService.reset();
   }
   async executeInternal(args) {
-    logDebug(`Executing tool: ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES}`, {
+    logDebug(`Executing tool: ${this.name}`, {
       path: args.path
     });
     if (!args.path) {
@@ -18080,12 +18304,15 @@ Example payload:
 };
 
 // src/mcp/index.ts
-function createMcpServer() {
+function createMcpServer(govOrgId) {
   logDebug("Creating MCP server");
-  const server = new McpServer({
-    name: "mobb-mcp",
-    version: packageJson.version
-  });
+  const server = new McpServer(
+    {
+      name: "mobb-mcp",
+      version: packageJson.version
+    },
+    govOrgId
+  );
   const enabledToolsEnv = process.env["TOOLS_ENABLED"];
   const enabledToolsSet = enabledToolsEnv ? new Set(
     enabledToolsEnv.split(",").map((t) => t.trim()).filter((t) => t.length > 0)
@@ -18104,6 +18331,10 @@ function createMcpServer() {
   registerIfEnabled(scanAndFixVulnerabilitiesTool);
   registerIfEnabled(fetchAvailableFixesTool);
   registerIfEnabled(checkForNewAvailableFixesTool);
+  if (govOrgId) {
+    const mcpCheckerTool = new McpCheckerTool(govOrgId);
+    registerIfEnabled(mcpCheckerTool);
+  }
   logInfo("MCP server created and configured");
   return server;
 }
@@ -18112,8 +18343,7 @@ async function startMcpServer({
 }) {
   try {
     logDebug("Initializing MCP server");
-    configStore.set("GOV-ORG-ID", govOrgId);
-    const server = createMcpServer();
+    const server = createMcpServer(govOrgId);
     await server.start();
   } catch (error) {
     logError("Failed to start MCP server", { error });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobbdev",
-  "version": "1.0.183",
+  "version": "1.0.185",
   "description": "Automated secure code remediation tool",
   "repository": "git+https://github.com/mobb-dev/bugsy.git",
   "main": "dist/index.mjs",