mobbdev 1.0.179 → 1.0.181

package/dist/index.mjs

@@ -10604,7 +10604,9 @@ var GQLClient = class {
         `The user with email:${email}  is not associated with any organization`
       );
     }
-    const organization = orgAndProjectRes.user?.at(0)?.userOrganizationsAndUserOrganizationRoles.map((org) => org.organization).filter(
+    const organization = orgAndProjectRes.user?.at(0)?.userOrganizationsAndUserOrganizationRoles.map(
+      (org) => org.organization
+    ).filter(
       (org) => userDefinedOrganizationId ? org.id === userDefinedOrganizationId : true
     )?.at(0);
     if (!organization) {
@@ -12354,15 +12356,111 @@ import {
 
 // src/mcp/Logger.ts
 import Configstore3 from "configstore";
+
+// src/mcp/services/WorkspaceService.ts
+var WorkspaceService = class {
+  /**
+   * Sets a known workspace path that was discovered through successful validation
+   * @param path The validated workspace path to store
+   */
+  static setKnownWorkspacePath(path17) {
+    this.knownWorkspacePath = path17;
+  }
+  /**
+   * Gets the known workspace path that was previously validated
+   * @returns The known workspace path or undefined if none stored
+   */
+  static getKnownWorkspacePath() {
+    return this.knownWorkspacePath;
+  }
+  /**
+   * Gets the workspace folder path from known path or environment variables
+   * @returns The workspace folder path or undefined if none found
+   */
+  static getWorkspaceFolderPath() {
+    if (this.knownWorkspacePath) {
+      return this.knownWorkspacePath;
+    }
+    const workspaceEnvVars = [
+      "WORKSPACE_FOLDER_PATHS",
+      // Cursor IDE
+      "PWD",
+      // Claude Code and general shell
+      "WORKSPACE_ROOT",
+      // Generic workspace root
+      "PROJECT_ROOT"
+      // Generic project root
+    ];
+    for (const envVar of workspaceEnvVars) {
+      const value = process.env[envVar];
+      if (value?.trim()) {
+        return value.trim();
+      }
+    }
+    return void 0;
+  }
+  ///this should be deleted, use instead the host detection from the McpUsageService
+  /**
+   * Detects the IDE/editor host based on environment variables
+   * @returns The detected IDE host
+   */
+  static getHost() {
+    if (process.env["WORKSPACE_FOLDER_PATHS"]) {
+      return "CURSOR";
+    }
+    if (process.env["VSCODE_IPC_HOOK"] || process.env["VSCODE_PID"] || process.env["TERM_PROGRAM"] === "vscode") {
+      return "VSCODE";
+    }
+    if (process.env["WINDSURF_IPC_HOOK"] || process.env["WINDSURF_PID"] || process.env["TERM_PROGRAM"] === "windsurf") {
+      return "WINDSURF";
+    }
+    if (process.env["CLAUDE_DESKTOP"] || process.env["ANTHROPIC_CLAUDE"]) {
+      return "CLAUDE";
+    }
+    if (process.env["WEBSTORM_VM_OPTIONS"] || process.env["IDEA_VM_OPTIONS"] || process.env["JETBRAINS_IDE"]) {
+      return "WEBSTORM";
+    }
+    return "UNKNOWN";
+  }
+};
+__publicField(WorkspaceService, "knownWorkspacePath");
+
+// src/mcp/Logger.ts
 var MAX_LOGS_SIZE = 1e3;
 var Logger = class {
   constructor() {
     __publicField(this, "mobbConfigStore");
-    __publicField(this, "path");
-    this.path = process.env["WORKSPACE_FOLDER_PATHS"] || "unknown";
+    __publicField(this, "host");
+    __publicField(this, "unknownPathSuffix");
+    __publicField(this, "lastKnownPath", null);
+    this.host = WorkspaceService.getHost();
+    this.unknownPathSuffix = Math.floor(1e3 + Math.random() * 9e3).toString();
     this.mobbConfigStore = new Configstore3("mobb-logs", {});
     this.mobbConfigStore.set("version", packageJson.version);
   }
+  /**
+   * Gets the current log path, fetching workspace path dynamically
+   */
+  getCurrentLogPath() {
+    const workspacePath = WorkspaceService.getWorkspaceFolderPath();
+    if (workspacePath) {
+      return `${this.host}:${workspacePath}`;
+    }
+    return `${this.host}:unknown-${this.unknownPathSuffix}`;
+  }
+  /**
+   * Migrates logs from unknown path to known workspace path
+   */
+  migrateLogs(fromPath, toPath) {
+    const existingLogs = this.mobbConfigStore.get(fromPath) || [];
+    const targetLogs = this.mobbConfigStore.get(toPath) || [];
+    if (existingLogs.length > 0) {
+      const combinedLogs = [...targetLogs, ...existingLogs];
+      const finalLogs = combinedLogs.slice(-MAX_LOGS_SIZE);
+      this.mobbConfigStore.set(toPath, finalLogs);
+      this.mobbConfigStore.delete(fromPath);
+    }
+  }
   /**
    * Log a message to the console.
    * @param message - The message to log.
@@ -12370,17 +12468,27 @@ var Logger = class {
    * @param data - The data to log.
    */
   log(message, level = "info", data) {
+    const currentPath = this.getCurrentLogPath();
+    const workspacePath = WorkspaceService.getWorkspaceFolderPath();
+    if (workspacePath && this.lastKnownPath !== workspacePath) {
+      const unknownPath = `${this.host}:unknown-${this.unknownPathSuffix}`;
+      const knownPath = `${this.host}:${workspacePath}`;
+      if (this.lastKnownPath === null || this.lastKnownPath.includes("unknown-")) {
+        this.migrateLogs(unknownPath, knownPath);
+      }
+      this.lastKnownPath = workspacePath;
+    }
     const logMessage = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       level,
       message,
       data
     };
-    const logs = this.mobbConfigStore.get(this.path) || [];
+    const logs = this.mobbConfigStore.get(currentPath) || [];
     if (logs.length >= MAX_LOGS_SIZE) {
       logs.shift();
     }
-    this.mobbConfigStore.set(this.path, [...logs, logMessage]);
+    this.mobbConfigStore.set(currentPath, [...logs, logMessage]);
   }
 };
 var logger = new Logger();
@@ -13206,7 +13314,7 @@ var McpGQLClient = class {
   }
 };
 async function createAuthenticatedMcpGQLClient({
-  isBackgoundCall = false
+  isBackgroundCall = false
 } = {}) {
   logDebug("[GraphQL] Getting config", {
     apiToken: configStore.get("apiToken")
@@ -13227,7 +13335,7 @@ async function createAuthenticatedMcpGQLClient({
     return initialClient;
   }
   const authService = new McpAuthService(initialClient);
-  const newApiToken = await authService.authenticate(isBackgoundCall);
+  const newApiToken = await authService.authenticate(isBackgroundCall);
   configStore.set("apiToken", newApiToken);
   return new McpGQLClient({ apiKey: newApiToken, type: "apiKey" });
 }
@@ -13475,6 +13583,12 @@ var McpUsageService = class {
     }
   }
   startPeriodicTracking() {
+    if (!this.hasOrganizationId()) {
+      logDebug(
+        `[UsageService] Not starting periodic tracking - organization ID not available`
+      );
+      return;
+    }
     logDebug(`[UsageService] Starting periodic tracking for mcps`, {});
     this.intervalId = setInterval(async () => {
       logDebug(`[UsageService] Triggering periodic usage service`, {
@@ -13509,6 +13623,10 @@ var McpUsageService = class {
     }
     return "";
   }
+  hasOrganizationId() {
+    const organizationId = configStore.get("GOV-ORG-ID") || "";
+    return !!organizationId;
+  }
   createUsageData(mcpHostId, organizationId, status) {
     const { user, mcps } = getHostInfo();
     return {
@@ -13644,6 +13762,9 @@ var McpServer = class {
     __publicField(this, "toolRegistry");
     __publicField(this, "isEventHandlersSetup", false);
     __publicField(this, "eventHandlers", /* @__PURE__ */ new Map());
+    __publicField(this, "parentProcessCheckInterval");
+    __publicField(this, "parentPid");
+    this.parentPid = process.ppid;
     this.server = new Server(
       {
         name: config4.name,
@@ -13658,11 +13779,21 @@ var McpServer = class {
     this.toolRegistry = new ToolRegistry();
     this.setupHandlers();
     this.setupProcessEventHandlers();
+    this.setupParentProcessMonitoring();
     logInfo("MCP server instance created");
-    logDebug("MCP server instance config", { config: config4 });
+    logDebug("MCP server instance config", {
+      config: config4,
+      parentPid: this.parentPid
+    });
   }
   async trackServerUsage(action, signalOrError) {
     try {
+      if (!mcpUsageService.hasOrganizationId()) {
+        logDebug(
+          `[McpServer] Skipping ${action} usage tracking - organization ID not available`
+        );
+        return;
+      }
       if (action === "start") {
         await mcpUsageService.trackServerStart();
       }
@@ -13684,6 +13815,12 @@ var McpServer = class {
     const messages = {
       SIGINT: "MCP server interrupted",
       SIGTERM: "MCP server terminated",
+      SIGHUP: "MCP server hangup signal received",
+      SIGQUIT: "MCP server quit signal received",
+      SIGABRT: "MCP server abort signal received",
+      SIGPIPE: "MCP server broken pipe signal received",
+      SIGCHLD: "MCP server child process signal received",
+      SIGTSTP: "MCP server terminal stop signal received",
       exit: "MCP server exiting",
       uncaughtException: "Uncaught exception in MCP server",
       unhandledRejection: "Unhandled promise rejection in MCP server",
@@ -13714,7 +13851,10 @@ var McpServer = class {
     } else {
       logDebug(message, { signal });
     }
-    if (signal === "SIGINT" || signal === "SIGTERM") {
+    if (signal === "SIGCHLD") {
+      return;
+    }
+    if (signal === "SIGINT" || signal === "SIGTERM" || signal === "SIGHUP" || signal === "SIGQUIT" || signal === "SIGABRT" || signal === "SIGPIPE" || signal === "SIGTSTP") {
       await this.trackServerUsage("stop", signal);
       process.exit(0);
     }
@@ -13723,6 +13863,62 @@ var McpServer = class {
       process.exit(1);
     }
   }
+  isParentProcessAlive() {
+    try {
+      process.kill(this.parentPid, 0);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  async handleParentProcessDeath(source) {
+    logInfo(`Parent process death detected via ${source}`, {
+      parentPid: this.parentPid
+    });
+    await this.trackServerUsage("stop", `parent-death-${source}`);
+    process.exit(0);
+  }
+  setupParentProcessMonitoring() {
+    logInfo("Setting up parent process monitoring", {
+      parentPid: this.parentPid
+    });
+    process.stdin.on("close", async () => {
+      logDebug("stdin closed - parent likely terminated");
+      await this.handleParentProcessDeath("stdin-close");
+    });
+    process.stdin.on("end", async () => {
+      logDebug("stdin ended - parent likely terminated");
+      await this.handleParentProcessDeath("stdin-end");
+    });
+    process.stdout.on("error", async (error) => {
+      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) => {
+      logWarn("stderr error - parent may have terminated", { error });
+      if (error.message.includes("EPIPE") || error.message.includes("ECONNRESET")) {
+        await this.handleParentProcessDeath("stderr-error");
+      }
+    });
+    if (process.send) {
+      process.on("disconnect", async () => {
+        logDebug("IPC disconnected - parent terminated");
+        await this.handleParentProcessDeath("ipc-disconnect");
+      });
+      logDebug("IPC monitoring enabled");
+    } else {
+      logDebug("IPC not available - skipping IPC monitoring");
+    }
+    this.parentProcessCheckInterval = setInterval(async () => {
+      if (!this.isParentProcessAlive()) {
+        logDebug("Parent process not alive during periodic check");
+        await this.handleParentProcessDeath("periodic-check");
+      }
+    }, 1e4);
+    logInfo("Parent process monitoring setup complete");
+  }
   setupProcessEventHandlers() {
     if (this.isEventHandlersSetup) {
       logDebug("Process event handlers already setup, skipping");
@@ -13731,6 +13927,12 @@ var McpServer = class {
     const signals = [
       "SIGINT",
       "SIGTERM",
+      "SIGHUP",
+      "SIGQUIT",
+      "SIGABRT",
+      "SIGPIPE",
+      "SIGCHLD",
+      "SIGTSTP",
       "exit",
       "uncaughtException",
       "unhandledRejection",
@@ -13754,29 +13956,32 @@ var McpServer = class {
       };
       process.once("SIGINT", cleanup);
       process.once("SIGTERM", cleanup);
+      process.once("SIGHUP", cleanup);
+      process.once("SIGQUIT", cleanup);
+      process.once("SIGABRT", cleanup);
+      process.once("SIGPIPE", cleanup);
+      process.once("SIGTSTP", cleanup);
     });
   }
   async triggerScanForNewAvailableFixes() {
     try {
       const gqlClient = await createAuthenticatedMcpGQLClient({
-        isBackgoundCall: true
+        isBackgroundCall: true
       });
       const isConnected = await gqlClient.verifyApiConnection();
       if (!isConnected) {
         logError("Failed to connect to the API, skipping background scan");
         return;
       }
-      if (process.env["WORKSPACE_FOLDER_PATHS"]) {
-        logDebug("WORKSPACE_FOLDER_PATHS is set", {
-          WORKSPACE_FOLDER_PATHS: process.env["WORKSPACE_FOLDER_PATHS"]
-        });
+      const workspacePath = WorkspaceService.getWorkspaceFolderPath();
+      if (workspacePath) {
         try {
           const checkForNewAvailableFixesTool = this.toolRegistry.getTool(
             MCP_TOOL_CHECK_FOR_NEW_AVAILABLE_FIXES
           );
           logInfo("Triggering periodic scan for new available fixes");
           checkForNewAvailableFixesTool.triggerScan({
-            path: process.env["WORKSPACE_FOLDER_PATHS"],
+            path: workspacePath,
             gqlClient
           });
         } catch (error) {
@@ -13884,6 +14089,12 @@ var McpServer = class {
     this.toolRegistry.registerTool(tool);
     logInfo(`Tool registered: ${tool.name}`);
   }
+  getParentProcessId() {
+    return this.parentPid;
+  }
+  checkParentProcessAlive() {
+    return this.isParentProcessAlive();
+  }
   async start() {
     try {
       logInfo("Starting MCP server");
@@ -13902,6 +14113,11 @@ var McpServer = class {
   async stop() {
     logDebug("MCP server shutting down");
     await this.trackServerUsage("stop");
+    if (this.parentProcessCheckInterval) {
+      clearInterval(this.parentProcessCheckInterval);
+      this.parentProcessCheckInterval = void 0;
+      logDebug("Parent process check interval cleared");
+    }
     this.eventHandlers.forEach((handler, signal) => {
       process.removeListener(signal, handler);
     });
@@ -13923,14 +14139,19 @@ async function validatePath(inputPath) {
     inputPath = inputPath.slice(1);
   }
   if (inputPath === "." || inputPath === "./") {
-    if (process.env["WORKSPACE_FOLDER_PATHS"]) {
+    const workspaceFolderPath = WorkspaceService.getWorkspaceFolderPath();
+    if (workspaceFolderPath) {
       logDebug("Fallback to workspace folder path", {
         inputPath,
-        workspaceFolderPaths: process.env["WORKSPACE_FOLDER_PATHS"]
+        workspaceFolderPaths: [workspaceFolderPath]
+      });
+      WorkspaceService.setKnownWorkspacePath(workspaceFolderPath);
+      logDebug("Stored workspace folder path as known path", {
+        workspaceFolderPath
       });
       return {
         isValid: true,
-        path: process.env["WORKSPACE_FOLDER_PATHS"]
+        path: workspaceFolderPath
       };
     } else {
       const error = `"." is not a valid path, please provide a full localpath to the repository`;
@@ -13972,6 +14193,8 @@ async function validatePath(inputPath) {
   try {
     await fs11.promises.access(inputPath);
     logDebug("Path exists and is accessible", { inputPath });
+    WorkspaceService.setKnownWorkspacePath(inputPath);
+    logDebug("Stored validated path in WorkspaceService", { inputPath });
     return { isValid: true, path: inputPath };
   } catch (error) {
     const errorMessage = `Path does not exist or is not accessible: ${inputPath}`;
@@ -14084,7 +14307,15 @@ To retrieve the available fixes, use one of these approaches:
 
 **\u{1F4CB} Valid offset range:** 0 to ${Math.max(0, totalCount - 1)}
 
-To fetch the fixes, run the \`${currentTool}\` tool again with the corrected parameters.
+### \u26A0\uFE0F CRITICAL INSTRUCTION FOR AI AGENTS \u26A0\uFE0F
+
+**DO NOT AUTOMATICALLY FETCH FIXES WITHOUT EXPLICIT USER REQUEST**
+
+- **DO NOT** run the \`${currentTool}\` tool again on your own
+- **ONLY** fetch fixes if the user explicitly asks for them
+- **WAIT** for the user to specifically request fixes before proceeding
+
+If the user wants to fetch the fixes, they should explicitly ask you to run the \`${currentTool}\` tool again with the corrected parameters.
 `;
 var applyFixesPrompt = ({
   fixes,
@@ -14206,12 +14437,23 @@ ${hasMore ? `---
 
 You have viewed ${shownCount} out of ${totalCount} available fixes.
 
-To fetch additional fixes, run the \`${currentTool}\` tool again with the following parameters:
+### \u26A0\uFE0F CRITICAL INSTRUCTION FOR AI AGENTS \u26A0\uFE0F
+
+**DO NOT AUTOMATICALLY FETCH ADDITIONAL FIXES WITHOUT EXPLICIT USER REQUEST**
+
+- **DO NOT** run the \`${currentTool}\` tool again on your own
+- **DO NOT** automatically retrieve more fixes
+- **ONLY** fetch additional fixes if the user explicitly asks for them
+- **WAIT** for the user to specifically request more fixes before proceeding
+
+### How Users Can Request Additional Fixes
+
+If the user wants to see more fixes, they should explicitly ask you to run the \`${currentTool}\` tool again with the following parameters:
 
 - **offset**: ${nextOffset}  _(start index for the next batch)_
 - **limit**:  <number_of_fixes_to_return>  _(optional \u2013 default is ${MCP_DEFAULT_LIMIT})_
 
-If you omit both **offset** and **limit**, the command will automatically return the next ${MCP_DEFAULT_LIMIT} fixes.
+If they omit both **offset** and **limit**, the command will automatically return the next ${MCP_DEFAULT_LIMIT} fixes.
 ` : ""}
 `;
 };
@@ -14252,7 +14494,7 @@ var expiredReportPrompt = ({
 Your most recent vulnerability report for this repository **expired on ${lastReportDate}** and is no longer available for fetching automated fixes.
 
 ### \u{1F4CB} Why Did This Happen?
-- Reports are automatically purged after a retention period for security and storage optimisation.
+- Reports are automatically purged after a retention period for security and storage optimization.
 - No new scans have been run since the last report expired.
 
 ### \u{1F3AF} Recommended Actions
@@ -14333,13 +14575,21 @@ This will scan up to the specified number of recently changed files.
 
 ### \u{1F504} Running a Fresh Scan
 
-To perform a **rescan** of your repository (fetching a brand-new vulnerability report and updated fixes), include the additional parameter:
+### \u26A0\uFE0F CRITICAL INSTRUCTION FOR AI AGENTS \u26A0\uFE0F
+
+**DO NOT AUTOMATICALLY RUN RESCANS WITHOUT EXPLICIT USER REQUEST**
+
+- **DO NOT** run rescans on your own
+- **ONLY** perform rescans if the user explicitly asks for them
+- **WAIT** for the user to specifically request a rescan before proceeding
+
+If the user wants to perform a **rescan** of their repository (fetching a brand-new vulnerability report and updated fixes), they should explicitly ask you to include the additional parameter:
 
 - **rescan**: true
 
 This will start a new analysis, discard any cached results.
 
-\u26A0\uFE0F *Note:* A full rescan may take longer to complete than simply fetching additional fixes because your repository is re-uploaded and re-analyzed from scratch.
+\u26A0\uFE0F *Note:* A full rescan may take longer to complete than simply fetching additional fixes because the repository is re-uploaded and re-analyzed from scratch.
 `;
 var noFixesFoundPrompt = ({
   scannedFiles

package/package.json

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