mobbdev 1.0.184 → 1.0.186

package/dist/index.mjs

@@ -1692,6 +1692,7 @@ var IssueType_Enum = /* @__PURE__ */ ((IssueType_Enum2) => {
   IssueType_Enum2["DeclareVariableExplicitly"] = "DECLARE_VARIABLE_EXPLICITLY";
   IssueType_Enum2["DefaultRightsInObjDefinition"] = "DEFAULT_RIGHTS_IN_OBJ_DEFINITION";
   IssueType_Enum2["DeprecatedFunction"] = "DEPRECATED_FUNCTION";
+  IssueType_Enum2["DjangoBlankFieldNeedsNullOrDefault"] = "DJANGO_BLANK_FIELD_NEEDS_NULL_OR_DEFAULT";
   IssueType_Enum2["DosStringBuilder"] = "DOS_STRING_BUILDER";
   IssueType_Enum2["DoNotRaiseException"] = "DO_NOT_RAISE_EXCEPTION";
   IssueType_Enum2["DoNotThrowGenericException"] = "DO_NOT_THROW_GENERIC_EXCEPTION";
@@ -2916,7 +2917,8 @@ var fixDetailsData = {
   ["FUNCTION_CALL_WITHOUT_PARENTHESES" /* FunctionCallWithoutParentheses */]: void 0,
   ["SPRING_DEFAULT_PERMIT" /* SpringDefaultPermit */]: void 0,
   ["RETURN_IN_INIT" /* ReturnInInit */]: void 0,
-  ["ACTION_NOT_PINNED_TO_COMMIT_SHA" /* ActionNotPinnedToCommitSha */]: void 0
+  ["ACTION_NOT_PINNED_TO_COMMIT_SHA" /* ActionNotPinnedToCommitSha */]: void 0,
+  ["DJANGO_BLANK_FIELD_NEEDS_NULL_OR_DEFAULT" /* DjangoBlankFieldNeedsNullOrDefault */]: void 0
 };
 
 // src/features/analysis/scm/shared/src/getIssueType.ts
@@ -3054,7 +3056,8 @@ var issueTypeMap = {
   ["FUNCTION_CALL_WITHOUT_PARENTHESES" /* FunctionCallWithoutParentheses */]: "Function Call Without Parentheses",
   ["SPRING_DEFAULT_PERMIT" /* SpringDefaultPermit */]: "Spring Default Permit",
   ["RETURN_IN_INIT" /* ReturnInInit */]: "Return in Init",
-  ["ACTION_NOT_PINNED_TO_COMMIT_SHA" /* ActionNotPinnedToCommitSha */]: "Action Not Pinned to Commit Sha"
+  ["ACTION_NOT_PINNED_TO_COMMIT_SHA" /* ActionNotPinnedToCommitSha */]: "Action Not Pinned to Commit Sha",
+  ["DJANGO_BLANK_FIELD_NEEDS_NULL_OR_DEFAULT" /* DjangoBlankFieldNeedsNullOrDefault */]: "Django Blank Field Needs Null or Default"
 };
 var issueTypeZ = z.nativeEnum(IssueType_Enum);
 var getIssueTypeFriendlyString = (issueType) => {
@@ -12373,6 +12376,12 @@ var WorkspaceService = class {
   static getKnownWorkspacePath() {
     return this.knownWorkspacePath;
   }
+  /**
+   * Clears the known workspace path cache
+   */
+  static clearKnownWorkspacePath() {
+    this.knownWorkspacePath = void 0;
+  }
   /**
    * Gets the workspace folder path from known path or environment variables
    * @returns The workspace folder path or undefined if none found
@@ -13357,52 +13366,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"
-      );
-    case "claude":
-      return path11.join(home, ".claude.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;
-  const config4 = JSON.parse(fs10.readFileSync(filePath, "utf8"));
-  if (hostName === "claude" && config4.projects) {
-    const allMcpServers = {};
-    for (const projectPath in config4.projects) {
-      const project = config4.projects[projectPath];
-      if (project?.mcpServers) {
-        for (const [serverName, serverConfig] of Object.entries(
-          project.mcpServers
-        )) {
-          allMcpServers[serverName] = serverConfig;
+  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 {
-      mcpServers: allMcpServers
-    };
   }
-  return config4;
+  return Object.keys(mergedConfig).length > 0 ? mergedConfig : null;
 };
 var getRunningProcesses = () => {
   try {
@@ -13816,6 +13892,7 @@ var McpServer = class {
     __publicField(this, "eventHandlers", /* @__PURE__ */ new Map());
     __publicField(this, "parentProcessCheckInterval");
     __publicField(this, "parentPid");
+    __publicField(this, "socketEventHandlers", /* @__PURE__ */ new Map());
     __publicField(this, "mcpUsageService");
     this.parentPid = process.ppid;
     this.mcpUsageService = govOrgId ? new McpUsageService(govOrgId) : null;
@@ -13936,31 +14013,43 @@ var McpServer = class {
     logInfo("Setting up parent process monitoring", {
       parentPid: this.parentPid
     });
-    process.stdin.on("close", async () => {
+    const stdinCloseHandler = async () => {
       logDebug("stdin closed - parent likely terminated");
       await this.handleParentProcessDeath("stdin-close");
-    });
-    process.stdin.on("end", async () => {
+    };
+    const stdinEndHandler = async () => {
       logDebug("stdin ended - parent likely terminated");
       await this.handleParentProcessDeath("stdin-end");
-    });
-    process.stdout.on("error", async (error) => {
+    };
+    const stdoutErrorHandler = async (...args) => {
+      const error = args[0];
       logWarn("stdout error - parent may have terminated", { error });
       if (error.message.includes("EPIPE") || error.message.includes("ECONNRESET")) {
         await this.handleParentProcessDeath("stdout-error");
       }
-    });
-    process.stderr.on("error", async (error) => {
+    };
+    const stderrErrorHandler = async (...args) => {
+      const error = args[0];
       logWarn("stderr error - parent may have terminated", { error });
       if (error.message.includes("EPIPE") || error.message.includes("ECONNRESET")) {
         await this.handleParentProcessDeath("stderr-error");
       }
-    });
+    };
+    const disconnectHandler = async () => {
+      logDebug("IPC disconnected - parent terminated");
+      await this.handleParentProcessDeath("ipc-disconnect");
+    };
+    this.socketEventHandlers.set("stdin-close", stdinCloseHandler);
+    this.socketEventHandlers.set("stdin-end", stdinEndHandler);
+    this.socketEventHandlers.set("stdout-error", stdoutErrorHandler);
+    this.socketEventHandlers.set("stderr-error", stderrErrorHandler);
+    this.socketEventHandlers.set("disconnect", disconnectHandler);
+    process.stdin.on("close", stdinCloseHandler);
+    process.stdin.on("end", stdinEndHandler);
+    process.stdout.on("error", stdoutErrorHandler);
+    process.stderr.on("error", stderrErrorHandler);
     if (process.send) {
-      process.on("disconnect", async () => {
-        logDebug("IPC disconnected - parent terminated");
-        await this.handleParentProcessDeath("ipc-disconnect");
-      });
+      process.on("disconnect", disconnectHandler);
       logDebug("IPC monitoring enabled");
     } else {
       logDebug("IPC not available - skipping IPC monitoring");
@@ -14027,6 +14116,7 @@ var McpServer = class {
         logError("Failed to connect to the API, skipping background scan");
         return;
       }
+      WorkspaceService.clearKnownWorkspacePath();
       const workspacePath = WorkspaceService.getWorkspaceFolderPath();
       if (workspacePath) {
         try {
@@ -14183,6 +14273,31 @@ var McpServer = class {
       this.parentProcessCheckInterval = void 0;
       logDebug("Parent process check interval cleared");
     }
+    this.socketEventHandlers.forEach((handler, eventType) => {
+      try {
+        switch (eventType) {
+          case "stdin-close":
+            process.stdin.removeListener("close", handler);
+            break;
+          case "stdin-end":
+            process.stdin.removeListener("end", handler);
+            break;
+          case "stdout-error":
+            process.stdout.removeListener("error", handler);
+            break;
+          case "stderr-error":
+            process.stderr.removeListener("error", handler);
+            break;
+          case "disconnect":
+            process.removeListener("disconnect", handler);
+            break;
+        }
+      } catch (error) {
+        logWarn(`Failed to remove ${eventType} listener`, { error });
+      }
+    });
+    this.socketEventHandlers.clear();
+    logDebug("Socket event handlers cleaned up");
     this.eventHandlers.forEach((handler, signal) => {
       process.removeListener(signal, handler);
     });
@@ -15901,28 +16016,21 @@ var PatchApplicationService = class {
     let finalContent = content;
     if (MCP_AUTO_FIX_DEBUG_MODE) {
       const fixType = fix.safeIssueType || "Security Issue";
-      let fixLink;
-      if (fix.fixUrl) {
-        fixLink = fix.fixUrl;
-      } else {
-        const apiUrl = process.env["API_URL"] || MCP_DEFAULT_API_URL;
-        const appBaseUrl = apiUrl.replace("/v1/graphql", "").replace("api.", "");
-        fixLink = `${appBaseUrl}/fixes/${fix.id}`;
-      }
       const commentPrefix = this.getCommentSyntax(filePath);
       const lines = content.split("\n");
       const lastLine = lines[lines.length - 1]?.trim() || "";
       const isMobbComment = lastLine.includes("Mobb security fix applied:");
       const spacing = isMobbComment ? "\n" : "\n\n";
+      const fixComment = `Mobb security fix applied: ${fixType} ${fix.fixUrl || ""}`;
       let comment;
       if (commentPrefix === "<!--") {
-        comment = `${spacing}<!-- Mobb security fix applied: ${fixType} ${fixLink} -->`;
+        comment = `${spacing}<!-- ${fixComment} -->`;
       } else if (commentPrefix === "/*") {
-        comment = `${spacing}/* Mobb security fix applied: ${fixType} ${fixLink} */`;
+        comment = `${spacing}/* ${fixComment} */`;
       } else if (commentPrefix === "(*") {
-        comment = `${spacing}(* Mobb security fix applied: ${fixType} ${fixLink} *)`;
+        comment = `${spacing}(* ${fixComment} *)`;
       } else {
-        comment = `${spacing}${commentPrefix} Mobb security fix applied: ${fixType} ${fixLink}`;
+        comment = `${spacing}${commentPrefix} ${fixComment}`;
       }
       finalContent = content + comment;
       logInfo(
@@ -15930,7 +16038,7 @@ var PatchApplicationService = class {
         {
           fixId: fix.id,
           fixType,
-          fixLink,
+          fixLink: fix.fixUrl,
           commentSyntax: commentPrefix,
           spacing: isMobbComment ? "single line" : "empty line above"
         }

package/package.json

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