mobbdev 1.2.0 → 1.2.3

package/dist/index.mjs

@@ -1371,7 +1371,7 @@ import Debug19 from "debug";
 import { hideBin } from "yargs/helpers";
 
 // src/args/yargs.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 import yargs from "yargs/yargs";
 
 // src/args/commands/convert_to_sarif.ts
@@ -6572,7 +6572,7 @@ async function getAdoSdk(params) {
       const url = new URL(repoUrl);
       const origin2 = url.origin.toLowerCase().endsWith(".visualstudio.com") ? DEFUALT_ADO_ORIGIN : url.origin.toLowerCase();
       const params2 = `path=/&versionDescriptor[versionOptions]=0&versionDescriptor[versionType]=commit&versionDescriptor[version]=${branch}&resolveLfs=true&$format=zip&api-version=5.0&download=true`;
-      const path24 = [
+      const path25 = [
         prefixPath,
         owner,
         projectName,
@@ -6583,7 +6583,7 @@ async function getAdoSdk(params) {
         "items",
         "items"
       ].filter(Boolean).join("/");
-      return new URL(`${path24}?${params2}`, origin2).toString();
+      return new URL(`${path25}?${params2}`, origin2).toString();
     },
     async getAdoBranchList({ repoUrl }) {
       try {
@@ -8180,8 +8180,8 @@ function extractBlameRanges(data) {
 }
 function buildBlameFragment(ref) {
   const escapedRef = safeGraphQLString(ref, "ref");
-  return (path24, index) => {
-    const escapedPath = safeGraphQLString(path24, "path");
+  return (path25, index) => {
+    const escapedPath = safeGraphQLString(path25, "path");
     return `
     file${index}: object(expression: "${escapedRef}") {
       ... on Commit {
@@ -8229,8 +8229,8 @@ async function processBlameAttempt(params) {
     )
   );
   for (const batchResult of batchResults) {
-    for (const [path24, blameData] of batchResult) {
-      result.set(path24, blameData);
+    for (const [path25, blameData] of batchResult) {
+      result.set(path25, blameData);
     }
   }
   return result;
@@ -8550,14 +8550,14 @@ function getGithubSdk(params = {}) {
       };
     },
     async getGithubBlameRanges(params2) {
-      const { ref, gitHubUrl, path: path24 } = params2;
+      const { ref, gitHubUrl, path: path25 } = params2;
       const { owner, repo } = parseGithubOwnerAndRepo(gitHubUrl);
       const res = await octokit.graphql(
         GET_BLAME_DOCUMENT,
         {
           owner,
           repo,
-          path: path24,
+          path: path25,
           ref
         }
       );
@@ -9030,8 +9030,8 @@ function getGithubSdk(params = {}) {
       return executeBatchGraphQL(octokit, params2.owner, params2.repo, {
         items: params2.filePaths,
         aliasPrefix: "file",
-        buildFragment: (path24, index) => {
-          const escapedPath = safeGraphQLString(path24, "path");
+        buildFragment: (path25, index) => {
+          const escapedPath = safeGraphQLString(path25, "path");
           return `
           file${index}: object(expression: "${escapedRef}") {
             ... on Commit {
@@ -9346,11 +9346,11 @@ var GithubSCMLib = class _GithubSCMLib extends SCMLib {
       markdownComment: comment
     });
   }
-  async getRepoBlameRanges(ref, path24) {
+  async getRepoBlameRanges(ref, path25) {
     this._validateUrl();
     return await this.githubSdk.getGithubBlameRanges({
       ref,
-      path: path24,
+      path: path25,
       gitHubUrl: this.url
     });
   }
@@ -10282,13 +10282,13 @@ function parseGitlabOwnerAndRepo(gitlabUrl) {
   const { organization, repoName, projectPath } = parsingResult;
   return { owner: organization, repo: repoName, projectPath };
 }
-async function getGitlabBlameRanges({ ref, gitlabUrl, path: path24 }, options) {
+async function getGitlabBlameRanges({ ref, gitlabUrl, path: path25 }, options) {
   const { projectPath } = parseGitlabOwnerAndRepo(gitlabUrl);
   const api2 = getGitBeaker({
     url: gitlabUrl,
     gitlabAuthToken: options?.gitlabAuthToken
   });
-  const resp = await api2.RepositoryFiles.allFileBlames(projectPath, path24, ref);
+  const resp = await api2.RepositoryFiles.allFileBlames(projectPath, path25, ref);
   let lineNumber = 1;
   return resp.filter((range) => range.lines).map((range) => {
     const oldLineNumber = lineNumber;
@@ -10462,10 +10462,10 @@ var GitlabSCMLib = class extends SCMLib {
       markdownComment: comment
     });
   }
-  async getRepoBlameRanges(ref, path24) {
+  async getRepoBlameRanges(ref, path25) {
     this._validateUrl();
     return await getGitlabBlameRanges(
-      { ref, path: path24, gitlabUrl: this.url },
+      { ref, path: path25, gitlabUrl: this.url },
       {
         url: this.url,
         gitlabAuthToken: this.accessToken
@@ -11524,6 +11524,13 @@ var convertToSarifCodePathPatternsOption = {
   type: "string",
   array: true
 };
+var pollingOption = {
+  describe: chalk2.bold(
+    "Use HTTP polling instead of WebSocket for status updates. Useful for proxy environments or firewalls that block WebSocket connections. Polling interval: 5 seconds, timeout: 30 minutes."
+  ),
+  type: "boolean",
+  default: false
+};
 
 // src/args/commands/convert_to_sarif.ts
 function convertToSarifBuilder(args) {
@@ -11555,7 +11562,8 @@ var mobbCliCommand = {
   uploadAiBlame: "upload-ai-blame",
   claudeCodeInstallHook: "claude-code-install-hook",
   claudeCodeProcessHook: "claude-code-process-hook",
-  windsurfIntellijMonitor: "windsurf-intellij-monitor"
+  windsurfIntellijInstallHook: "windsurf-intellij-install-hook",
+  windsurfIntellijProcessHook: "windsurf-intellij-process-hook"
 };
 var ScanContext = {
   FULL_SCAN: "FULL_SCAN",
@@ -12235,6 +12243,61 @@ var GQLClient = class {
       }
     );
   }
+  async pollForAnalysisState(params) {
+    const { analysisId, callbackStates, callback, timeoutInMs } = params;
+    const startTime = Date.now();
+    const maxDuration = timeoutInMs ?? 30 * 60 * 1e3;
+    const pollingIntervalSec = REPORT_STATE_CHECK_DELAY / 1e3;
+    debug6(
+      `[pollForAnalysisState] Starting polling for analysis ${analysisId}, target states: ${callbackStates.join(", ")}, interval: ${pollingIntervalSec}s`
+    );
+    let isPolling = true;
+    let pollCount = 0;
+    while (isPolling) {
+      pollCount++;
+      const elapsedSec = Math.round((Date.now() - startTime) / 1e3);
+      if (Date.now() - startTime > maxDuration) {
+        debug6(
+          `[pollForAnalysisState] Timeout expired after ${pollCount} polls (${elapsedSec}s)`
+        );
+        throw new ReportDigestError(
+          `Polling timeout expired for analysis: ${analysisId} with timeout: ${maxDuration}ms`,
+          `Analysis timed out after ${Math.round(maxDuration / 6e4)} minutes. Please try again or check the Mobb platform for status.`
+        );
+      }
+      debug6(
+        `[pollForAnalysisState] Poll #${pollCount} (elapsed: ${elapsedSec}s) - fetching analysis state...`
+      );
+      const analysis = await this.getAnalysis(analysisId);
+      debug6(
+        `[pollForAnalysisState] Poll #${pollCount} - current state: ${analysis.state}`
+      );
+      if (!analysis.state || analysis.state === "Failed" /* Failed */) {
+        const errorMessage = analysis.failReason || `Analysis failed with id: ${analysis.id}`;
+        debug6(`[pollForAnalysisState] Analysis failed: ${errorMessage}`);
+        throw new ReportDigestError(errorMessage, analysis.failReason ?? "");
+      }
+      if (callbackStates.includes(analysis.state)) {
+        debug6(
+          `[pollForAnalysisState] Target state reached: ${analysis.state} after ${pollCount} polls (${elapsedSec}s)`
+        );
+        await callback(analysis.id);
+        isPolling = false;
+        return {
+          analysis: {
+            id: analysis.id,
+            state: analysis.state,
+            failReason: analysis.failReason
+          }
+        };
+      }
+      debug6(
+        `[pollForAnalysisState] State ${analysis.state} not in target states, waiting ${pollingIntervalSec}s before next poll...`
+      );
+      await sleep(REPORT_STATE_CHECK_DELAY);
+    }
+    throw new Error(`Unexpected end of polling for analysis: ${analysisId}`);
+  }
   async getFixReportsByRepoUrl({ repoUrl }) {
     const res = await this._clientSdk.GetFixReportsByRepoUrl({
       repoUrl
@@ -12635,7 +12698,8 @@ var debug8 = Debug7("mobbdev:index");
 async function sendReport({
   spinner,
   submitVulnerabilityReportVariables,
-  gqlClient
+  gqlClient,
+  polling
 }) {
   try {
     const submitRes = await gqlClient.submitVulnerabilityReport(
@@ -12646,19 +12710,32 @@ async function sendReport({
       throw new Error("\u{1F575}\uFE0F\u200D\u2642\uFE0F Mobb analysis failed");
     }
     spinner.update({ text: progressMassages.processingVulnerabilityReport });
-    await gqlClient.subscribeToAnalysis({
-      subscribeToAnalysisParams: {
-        analysisId: submitRes.submitVulnerabilityReport.fixReportId
-      },
-      callback: () => spinner.update({
-        text: "\u2699\uFE0F Vulnerability report processed successfully"
-      }),
-      callbackStates: [
-        "Digested" /* Digested */,
-        "Finished" /* Finished */
-      ],
-      timeoutInMs: VUL_REPORT_DIGEST_TIMEOUT_MS
+    const callback = (_analysisId) => spinner.update({
+      text: "\u2699\uFE0F Vulnerability report processed successfully"
     });
+    const callbackStates = [
+      "Digested" /* Digested */,
+      "Finished" /* Finished */
+    ];
+    if (polling) {
+      debug8("[sendReport] Using POLLING mode for analysis state updates");
+      await gqlClient.pollForAnalysisState({
+        analysisId: submitRes.submitVulnerabilityReport.fixReportId,
+        callback,
+        callbackStates,
+        timeoutInMs: VUL_REPORT_DIGEST_TIMEOUT_MS
+      });
+    } else {
+      debug8("[sendReport] Using WEBSOCKET mode for analysis state updates");
+      await gqlClient.subscribeToAnalysis({
+        subscribeToAnalysisParams: {
+          analysisId: submitRes.submitVulnerabilityReport.fixReportId
+        },
+        callback,
+        callbackStates,
+        timeoutInMs: VUL_REPORT_DIGEST_TIMEOUT_MS
+      });
+    }
     return submitRes;
   } catch (e) {
     spinner.error({ text: "\u{1F575}\uFE0F\u200D\u2642\uFE0F Mobb analysis failed" });
@@ -12885,7 +12962,7 @@ async function postIssueComment(params) {
     fpDescription
   } = params;
   const {
-    path: path24,
+    path: path25,
     startLine,
     vulnerabilityReportIssue: {
       vulnerabilityReportIssueTags,
@@ -12900,7 +12977,7 @@ async function postIssueComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path24,
+    path: path25,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -12934,7 +13011,7 @@ async function postFixComment(params) {
     scanner
   } = params;
   const {
-    path: path24,
+    path: path25,
     startLine,
     vulnerabilityReportIssue: { fixId, vulnerabilityReportIssueTags, category },
     vulnerabilityReportIssueId
@@ -12952,7 +13029,7 @@ async function postFixComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path24,
+    path: path25,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -13196,44 +13273,57 @@ async function handleAutoPr(params) {
     commitDirectly,
     prId,
     createSpinner: createSpinner5,
-    createOnePr
+    createOnePr,
+    polling
   } = params;
   const createAutoPrSpinner = createSpinner5(
     "\u{1F504} Waiting for the analysis to finish before initiating automatic pull request creation"
   ).start();
-  return await gqlClient.subscribeToAnalysis({
-    subscribeToAnalysisParams: {
-      analysisId
-    },
-    callback: async (analysisId2) => {
-      const autoPrAnalysisRes = await gqlClient.autoPrAnalysis({
-        analysisId: analysisId2,
-        commitDirectly,
-        prId,
-        prStrategy: createOnePr ? "CONDENSE" /* Condense */ : "SPREAD" /* Spread */
+  const callback = async (analysisId2) => {
+    const autoPrAnalysisRes = await gqlClient.autoPrAnalysis({
+      analysisId: analysisId2,
+      commitDirectly,
+      prId,
+      prStrategy: createOnePr ? "CONDENSE" /* Condense */ : "SPREAD" /* Spread */
+    });
+    debug12("auto pr analysis res %o", autoPrAnalysisRes);
+    if (autoPrAnalysisRes.autoPrAnalysis?.__typename === "AutoPrError") {
+      createAutoPrSpinner.error({
+        text: `\u{1F504} Automatic pull request failed - ${autoPrAnalysisRes.autoPrAnalysis.error}`
       });
-      debug12("auto pr analysis res %o", autoPrAnalysisRes);
-      if (autoPrAnalysisRes.autoPrAnalysis?.__typename === "AutoPrError") {
-        createAutoPrSpinner.error({
-          text: `\u{1F504} Automatic pull request failed - ${autoPrAnalysisRes.autoPrAnalysis.error}`
-        });
-        return;
-      }
-      if (autoPrAnalysisRes.autoPrAnalysis?.__typename === "AutoPrSuccess") {
-        const { appliedAutoPrIssueTypes } = autoPrAnalysisRes.autoPrAnalysis;
-        if (appliedAutoPrIssueTypes.length === 0) {
-          createAutoPrSpinner.success({
-            text: "\u{1F504} Automatic pull request did not find any new fixes to open a pull request for"
-          });
-          return;
-        }
+      return;
+    }
+    if (autoPrAnalysisRes.autoPrAnalysis?.__typename === "AutoPrSuccess") {
+      const { appliedAutoPrIssueTypes } = autoPrAnalysisRes.autoPrAnalysis;
+      if (appliedAutoPrIssueTypes.length === 0) {
         createAutoPrSpinner.success({
-          text: `\u{1F504} Automatic pull request creation initiated successfully for the following issue types: ${appliedAutoPrIssueTypes}`
+          text: "\u{1F504} Automatic pull request did not find any new fixes to open a pull request for"
         });
+        return;
       }
-    },
-    callbackStates: ["Finished" /* Finished */]
-  });
+      createAutoPrSpinner.success({
+        text: `\u{1F504} Automatic pull request creation initiated successfully for the following issue types: ${appliedAutoPrIssueTypes}`
+      });
+    }
+  };
+  const callbackStates = ["Finished" /* Finished */];
+  if (polling) {
+    debug12("[handleAutoPr] Using POLLING mode for analysis state updates");
+    return await gqlClient.pollForAnalysisState({
+      analysisId,
+      callback,
+      callbackStates
+    });
+  } else {
+    debug12("[handleAutoPr] Using WEBSOCKET mode for analysis state updates");
+    return await gqlClient.subscribeToAnalysis({
+      subscribeToAnalysisParams: {
+        analysisId
+      },
+      callback,
+      callbackStates
+    });
+  }
 }
 
 // src/features/analysis/git.ts
@@ -13542,8 +13632,8 @@ if (typeof __filename !== "undefined") {
 }
 var costumeRequire = createRequire(moduleUrl);
 var getCheckmarxPath = () => {
-  const os13 = type();
-  const cxFileName = os13 === "Windows_NT" ? "cx.exe" : "cx";
+  const os14 = type();
+  const cxFileName = os14 === "Windows_NT" ? "cx.exe" : "cx";
   try {
     return costumeRequire.resolve(`.bin/${cxFileName}`);
   } catch (e) {
@@ -13986,7 +14076,8 @@ async function _scan(params, { skipPrompts = false } = {}) {
     autoPr,
     createOnePr,
     commitDirectly,
-    pullRequest
+    pullRequest,
+    polling
   } = params;
   debug18("start %s %s", dirname, repo);
   const { createSpinner: createSpinner5 } = Spinner2({ ci });
@@ -14098,7 +14189,8 @@ async function _scan(params, { skipPrompts = false } = {}) {
     repoUrl: repo,
     sha,
     reference,
-    shouldScan
+    shouldScan,
+    polling
   });
   uploadReportSpinner.success({ text: "\u{1F4C1} Report uploaded successfully" });
   const mobbSpinner = createSpinner5("\u{1F575}\uFE0F\u200D\u2642\uFE0F Initiating Mobb analysis").start();
@@ -14116,7 +14208,8 @@ async function _scan(params, { skipPrompts = false } = {}) {
       pullRequest: params.pullRequest,
       scanSource: _getScanSource(command, ci),
       scanContext: ScanContext.BUGSY
-    }
+    },
+    polling
   });
   if (sendReportRes.submitVulnerabilityReport.__typename !== "VulnerabilityReport") {
     mobbSpinner.error({ text: "\u{1F575}\uFE0F\u200D\u2642\uFE0F Mobb analysis failed" });
@@ -14132,7 +14225,8 @@ async function _scan(params, { skipPrompts = false } = {}) {
       commitDirectly,
       prId: pullRequest,
       createSpinner: createSpinner5,
-      createOnePr
+      createOnePr,
+      polling
     });
   }
   await askToOpenAnalysis();
@@ -14142,7 +14236,8 @@ async function _scan(params, { skipPrompts = false } = {}) {
       githubActionToken,
       analysisId: reportUploadInfo.fixReportId,
       scanner,
-      gqlClient
+      gqlClient,
+      polling
     });
   }
   return reportUploadInfo.fixReportId;
@@ -14237,7 +14332,8 @@ async function _scan(params, { skipPrompts = false } = {}) {
         projectId,
         command,
         ci,
-        shouldScan: shouldScan2
+        shouldScan: shouldScan2,
+        polling
       });
       const res = await _zipAndUploadRepo({
         srcPath,
@@ -14260,7 +14356,8 @@ async function _scan(params, { skipPrompts = false } = {}) {
         projectId,
         command,
         ci,
-        shouldScan: shouldScan2
+        shouldScan: shouldScan2,
+        polling
       });
     }
     const mobbSpinner2 = createSpinner5("\u{1F575}\uFE0F\u200D\u2642\uFE0F Initiating Mobb analysis").start();
@@ -14278,7 +14375,8 @@ async function _scan(params, { skipPrompts = false } = {}) {
           pullRequest: params.pullRequest,
           experimentalEnabled: !!experimentalEnabled,
           scanContext: ScanContext.BUGSY
-        }
+        },
+        polling
       });
       if (command === "review") {
         await waitForAnaysisAndReviewPr({
@@ -14286,7 +14384,8 @@ async function _scan(params, { skipPrompts = false } = {}) {
           githubActionToken,
           analysisId: reportUploadInfo.fixReportId,
           scanner,
-          gqlClient
+          gqlClient,
+          polling
         });
       }
     } catch (e) {
@@ -14303,7 +14402,8 @@ async function _scan(params, { skipPrompts = false } = {}) {
         commitDirectly,
         prId: pullRequest,
         createSpinner: createSpinner5,
-        createOnePr
+        createOnePr,
+        polling
       });
     }
     await askToOpenAnalysis();
@@ -14351,7 +14451,8 @@ async function _digestReport({
   repoUrl,
   sha,
   reference,
-  shouldScan
+  shouldScan,
+  polling
 }) {
   const digestSpinner = createSpinner4(
     progressMassages.processingVulnerabilityReport
@@ -14368,19 +14469,46 @@ async function _digestReport({
         shouldScan
       }
     );
-    await gqlClient.subscribeToAnalysis({
-      subscribeToAnalysisParams: {
-        analysisId: fixReportId
-      },
-      callback: () => digestSpinner.update({
-        text: progressMassages.processingVulnerabilityReportSuccess
-      }),
-      callbackStates: [
-        "Digested" /* Digested */,
-        "Finished" /* Finished */
-      ],
-      timeoutInMs: VUL_REPORT_DIGEST_TIMEOUT_MS
+    const callbackStates = [
+      "Digested" /* Digested */,
+      "Finished" /* Finished */
+    ];
+    const callback = (_analysisId) => digestSpinner.update({
+      text: progressMassages.processingVulnerabilityReportSuccess
     });
+    if (polling) {
+      debug18(
+        "[_digestReport] Using POLLING mode for analysis state updates (--polling flag enabled)"
+      );
+      console.log(
+        chalk6.cyan(
+          "\u{1F504} [Polling Mode] Using HTTP polling instead of WebSocket for status updates"
+        )
+      );
+      await gqlClient.pollForAnalysisState({
+        analysisId: fixReportId,
+        callback,
+        callbackStates,
+        timeoutInMs: VUL_REPORT_DIGEST_TIMEOUT_MS
+      });
+    } else {
+      debug18(
+        "[_digestReport] Using WEBSOCKET mode for analysis state updates (default)"
+      );
+      console.log(
+        chalk6.cyan(
+          "\u{1F50C} [WebSocket Mode] Using WebSocket subscription for status updates"
+        )
+      );
+      await gqlClient.subscribeToAnalysis({
+        subscribeToAnalysisParams: {
+          analysisId: fixReportId
+        },
+        callback,
+        callbackStates,
+        timeoutInMs: VUL_REPORT_DIGEST_TIMEOUT_MS
+      });
+    }
     const vulnFiles = await gqlClient.getVulnerabilityReportPaths(
       vulnerabilityReportId
     );
@@ -14401,7 +14529,8 @@ async function waitForAnaysisAndReviewPr({
   githubActionToken,
   analysisId,
   scanner,
-  gqlClient
+  gqlClient,
+  polling
 }) {
   const params = z29.object({
     repo: z29.string().url(),
@@ -14418,20 +14547,45 @@ async function waitForAnaysisAndReviewPr({
       propagateExceptions: true
     }
   );
-  await gqlClient.subscribeToAnalysis({
-    subscribeToAnalysisParams: {
-      analysisId
-    },
-    callback: (analysisId2) => {
-      return addFixCommentsForPr({
-        analysisId: analysisId2,
-        gqlClient,
-        scm,
-        scanner: z29.nativeEnum(SCANNERS).parse(scanner)
-      });
-    },
-    callbackStates: ["Finished" /* Finished */]
-  });
+  const callback = (analysisId2) => {
+    return addFixCommentsForPr({
+      analysisId: analysisId2,
+      gqlClient,
+      scm,
+      scanner: z29.nativeEnum(SCANNERS).parse(scanner)
+    });
+  };
+  if (polling) {
+    debug18(
+      "[waitForAnaysisAndReviewPr] Using POLLING mode for analysis state updates"
+    );
+    console.log(
+      chalk6.cyan(
+        "\u{1F504} [Polling Mode] Waiting for analysis completion using HTTP polling"
+      )
+    );
+    await gqlClient.pollForAnalysisState({
+      analysisId,
+      callback,
+      callbackStates: ["Finished" /* Finished */]
+    });
+  } else {
+    debug18(
+      "[waitForAnaysisAndReviewPr] Using WEBSOCKET mode for analysis state updates"
+    );
+    console.log(
+      chalk6.cyan(
+        "\u{1F50C} [WebSocket Mode] Waiting for analysis completion using WebSocket"
+      )
+    );
+    await gqlClient.subscribeToAnalysis({
+      subscribeToAnalysisParams: {
+        analysisId
+      },
+      callback,
+      callbackStates: ["Finished" /* Finished */]
+    });
+  }
 }
 
 // src/commands/index.ts
@@ -14446,7 +14600,8 @@ async function review(params, { skipPrompts = true } = {}) {
     pullRequest,
     githubToken,
     scanner,
-    srcPath
+    srcPath,
+    polling
   } = params;
   await runAnalysis(
     {
@@ -14462,7 +14617,8 @@ async function review(params, { skipPrompts = true } = {}) {
       githubToken,
       scanner,
       command: "review",
-      srcPath
+      srcPath,
+      polling
     },
     { skipPrompts }
   );
@@ -14480,7 +14636,8 @@ async function analyze({
   autoPr,
   createOnePr,
   commitDirectly,
-  pullRequest
+  pullRequest,
+  polling
 }, { skipPrompts = false } = {}) {
   !ci && await showWelcomeMessage(skipPrompts);
   await runAnalysis(
@@ -14498,7 +14655,8 @@ async function analyze({
       autoPr,
       commitDirectly,
       pullRequest,
-      createOnePr
+      createOnePr,
+      polling
     },
     { skipPrompts }
   );
@@ -14638,7 +14796,7 @@ function analyzeBuilder(yargs2) {
     describe: chalk8.bold("Number of the pull request"),
     type: "number",
     demandOption: false
-  }).example(
+  }).option("polling", pollingOption).example(
     "npx mobbdev@latest analyze -r https://github.com/WebGoat/WebGoat -f <your_vulnerability_report_path>",
     "analyze an existing repository"
   ).help();
@@ -14947,7 +15105,14 @@ var defaultLogger2 = {
   }
 };
 var PromptItemZ = z31.object({
-  type: z31.enum(["USER_PROMPT", "AI_RESPONSE", "TOOL_EXECUTION", "AI_THINKING"]),
+  type: z31.enum([
+    "USER_PROMPT",
+    "AI_RESPONSE",
+    "TOOL_EXECUTION",
+    "AI_THINKING",
+    "MCP_TOOL_CALL"
+    // MCP (Model Context Protocol) tool invocation
+  ]),
   attachedFiles: z31.array(
     z31.object({
       relativePath: z31.string(),
@@ -14965,7 +15130,12 @@ var PromptItemZ = z31.object({
     parameters: z31.string(),
     result: z31.string(),
     rawArguments: z31.string().optional(),
-    accepted: z31.boolean().optional()
+    accepted: z31.boolean().optional(),
+    // MCP-specific fields (only populated for MCP_TOOL_CALL type)
+    mcpServer: z31.string().optional(),
+    // MCP server name (e.g., "datadog", "mobb-mcp")
+    mcpToolName: z31.string().optional()
+    // MCP tool name without prefix (e.g., "scan_and_fix_vulnerabilities")
   }).optional()
 });
 var PromptItemArrayZ = z31.array(PromptItemZ);
@@ -15698,8 +15868,8 @@ var WorkspaceService = class {
    * Sets a known workspace path that was discovered through successful validation
    * @param path The validated workspace path to store
    */
-  static setKnownWorkspacePath(path24) {
-    this.knownWorkspacePath = path24;
+  static setKnownWorkspacePath(path25) {
+    this.knownWorkspacePath = path25;
   }
   /**
    * Gets the known workspace path that was previously validated
@@ -16972,10 +17142,10 @@ var getHostInfo = (additionalMcpList) => {
   const ideConfigPaths = /* @__PURE__ */ new Set();
   for (const ide of IDEs) {
     const configPaths = getMCPConfigPaths(ide);
-    configPaths.forEach((path24) => ideConfigPaths.add(path24));
+    configPaths.forEach((path25) => ideConfigPaths.add(path25));
   }
   const uniqueAdditionalPaths = additionalMcpList.filter(
-    (path24) => !ideConfigPaths.has(path24)
+    (path25) => !ideConfigPaths.has(path25)
   );
   for (const ide of IDEs) {
     const cfg = readMCPConfig(ide);
@@ -20268,7 +20438,7 @@ init_configs();
 import fs19 from "fs/promises";
 import nodePath from "path";
 var getLocalFiles = async ({
-  path: path24,
+  path: path25,
   maxFileSize = MCP_MAX_FILE_SIZE,
   maxFiles,
   isAllFilesScan,
@@ -20276,17 +20446,17 @@ var getLocalFiles = async ({
   scanRecentlyChangedFiles
 }) => {
   logDebug(`[${scanContext}] Starting getLocalFiles`, {
-    path: path24,
+    path: path25,
     maxFileSize,
     maxFiles,
     isAllFilesScan,
     scanRecentlyChangedFiles
   });
   try {
-    const resolvedRepoPath = await fs19.realpath(path24);
+    const resolvedRepoPath = await fs19.realpath(path25);
     logDebug(`[${scanContext}] Resolved repository path`, {
       resolvedRepoPath,
-      originalPath: path24
+      originalPath: path25
     });
     const gitService = new GitService(resolvedRepoPath, log);
     const gitValidation = await gitService.validateRepository();
@@ -20299,7 +20469,7 @@ var getLocalFiles = async ({
     if (!gitValidation.isValid || isAllFilesScan) {
       try {
         files = await FileUtils.getLastChangedFiles({
-          dir: path24,
+          dir: path25,
           maxFileSize,
           maxFiles,
           isAllFilesScan
@@ -20391,7 +20561,7 @@ var getLocalFiles = async ({
     logError(`${scanContext}Unexpected error in getLocalFiles`, {
       error: error instanceof Error ? error.message : String(error),
       stack: error instanceof Error ? error.stack : void 0,
-      path: path24
+      path: path25
     });
     throw error;
   }
@@ -22539,14 +22709,14 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
    * since the last scan.
    */
   async scanForSecurityVulnerabilities({
-    path: path24,
+    path: path25,
     isAllDetectionRulesScan,
     isAllFilesScan,
     scanContext
   }) {
     this.hasAuthenticationFailed = false;
     logDebug(`[${scanContext}] Scanning for new security vulnerabilities`, {
-      path: path24
+      path: path25
     });
     if (!this.gqlClient) {
       logInfo(`[${scanContext}] No GQL client found, skipping scan`);
@@ -22562,11 +22732,11 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       logDebug(
         `[${scanContext}] Connected to the API, assembling list of files to scan`,
-        { path: path24 }
+        { path: path25 }
       );
       const isBackgroundScan = scanContext === ScanContext.BACKGROUND_INITIAL || scanContext === ScanContext.BACKGROUND_PERIODIC;
       const files = await getLocalFiles({
-        path: path24,
+        path: path25,
         isAllFilesScan,
         scanContext,
         scanRecentlyChangedFiles: !isBackgroundScan
@@ -22592,13 +22762,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
       const { fixReportId, projectId } = await scanFiles({
         fileList: filesToScan.map((file) => file.relativePath),
-        repositoryPath: path24,
+        repositoryPath: path25,
         gqlClient: this.gqlClient,
         isAllDetectionRulesScan,
         scanContext
       });
       logInfo(
-        `[${scanContext}] Security scan completed for ${path24} reportId: ${fixReportId} projectId: ${projectId}`
+        `[${scanContext}] Security scan completed for ${path25} reportId: ${fixReportId} projectId: ${projectId}`
       );
       if (isAllFilesScan) {
         return;
@@ -22892,13 +23062,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     });
     return scannedFiles.some((file) => file.relativePath === fixFile);
   }
-  async getFreshFixes({ path: path24 }) {
+  async getFreshFixes({ path: path25 }) {
     const scanContext = ScanContext.USER_REQUEST;
-    logDebug(`[${scanContext}] Getting fresh fixes`, { path: path24 });
-    if (this.path !== path24) {
-      this.path = path24;
+    logDebug(`[${scanContext}] Getting fresh fixes`, { path: path25 });
+    if (this.path !== path25) {
+      this.path = path25;
       this.reset();
-      logInfo(`[${scanContext}] Reset service state for new path`, { path: path24 });
+      logInfo(`[${scanContext}] Reset service state for new path`, { path: path25 });
     }
     try {
       const loginContext = createMcpLoginContext("check_new_fixes");
@@ -22917,7 +23087,7 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       throw error;
     }
-    this.triggerScan({ path: path24, gqlClient: this.gqlClient });
+    this.triggerScan({ path: path25, gqlClient: this.gqlClient });
     let isMvsAutoFixEnabled = null;
     try {
       isMvsAutoFixEnabled = await this.gqlClient.getMvsAutoFixSettings();
@@ -22951,33 +23121,33 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     return noFreshFixesPrompt;
   }
   triggerScan({
-    path: path24,
+    path: path25,
     gqlClient
   }) {
-    if (this.path !== path24) {
-      this.path = path24;
+    if (this.path !== path25) {
+      this.path = path25;
       this.reset();
-      logInfo(`Reset service state for new path in triggerScan`, { path: path24 });
+      logInfo(`Reset service state for new path in triggerScan`, { path: path25 });
     }
     this.gqlClient = gqlClient;
     if (!this.intervalId) {
-      this.startPeriodicScanning(path24);
-      this.executeInitialScan(path24);
-      void this.executeInitialFullScan(path24);
+      this.startPeriodicScanning(path25);
+      this.executeInitialScan(path25);
+      void this.executeInitialFullScan(path25);
     }
   }
-  startPeriodicScanning(path24) {
+  startPeriodicScanning(path25) {
     const scanContext = ScanContext.BACKGROUND_PERIODIC;
     logDebug(
       `[${scanContext}] Starting periodic scan for new security vulnerabilities`,
       {
-        path: path24
+        path: path25
       }
     );
     this.intervalId = setInterval(() => {
-      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path24 });
+      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path25 });
       this.scanForSecurityVulnerabilities({
-        path: path24,
+        path: path25,
         scanContext
       }).catch((error) => {
         logError(`[${scanContext}] Error during periodic security scan`, {
@@ -22986,45 +23156,45 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
     }, MCP_PERIODIC_CHECK_INTERVAL);
   }
-  async executeInitialFullScan(path24) {
+  async executeInitialFullScan(path25) {
     const scanContext = ScanContext.FULL_SCAN;
-    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path24 });
+    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path25 });
     logDebug(`[${scanContext}] Full scan paths scanned`, {
       fullScanPathsScanned: this.fullScanPathsScanned
     });
-    if (this.fullScanPathsScanned.includes(path24)) {
+    if (this.fullScanPathsScanned.includes(path25)) {
       logDebug(`[${scanContext}] Full scan already executed for this path`, {
-        path: path24
+        path: path25
       });
       return;
     }
     configStore.set("fullScanPathsScanned", [
       ...this.fullScanPathsScanned,
-      path24
+      path25
     ]);
     try {
       await this.scanForSecurityVulnerabilities({
-        path: path24,
+        path: path25,
         isAllFilesScan: true,
         isAllDetectionRulesScan: true,
         scanContext: ScanContext.FULL_SCAN
       });
-      if (!this.fullScanPathsScanned.includes(path24)) {
-        this.fullScanPathsScanned.push(path24);
+      if (!this.fullScanPathsScanned.includes(path25)) {
+        this.fullScanPathsScanned.push(path25);
         configStore.set("fullScanPathsScanned", this.fullScanPathsScanned);
       }
-      logInfo(`[${scanContext}] Full scan completed`, { path: path24 });
+      logInfo(`[${scanContext}] Full scan completed`, { path: path25 });
     } catch (error) {
       logError(`[${scanContext}] Error during initial full security scan`, {
         error
       });
     }
   }
-  executeInitialScan(path24) {
+  executeInitialScan(path25) {
     const scanContext = ScanContext.BACKGROUND_INITIAL;
-    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path24 });
+    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path25 });
     this.scanForSecurityVulnerabilities({
-      path: path24,
+      path: path25,
       scanContext: ScanContext.BACKGROUND_INITIAL
     }).catch((error) => {
       logError(`[${scanContext}] Error during initial security scan`, { error });
@@ -23121,9 +23291,9 @@ Example payload:
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path24 = pathValidationResult.path;
+    const path25 = pathValidationResult.path;
     const resultText = await this.newFixesService.getFreshFixes({
-      path: path24
+      path: path25
     });
     logInfo("CheckForNewAvailableFixesTool execution completed", {
       resultText
@@ -23301,8 +23471,8 @@ Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path24 = pathValidationResult.path;
-    const gitService = new GitService(path24, log);
+    const path25 = pathValidationResult.path;
+    const gitService = new GitService(path25, log);
     const gitValidation = await gitService.validateRepository();
     if (!gitValidation.isValid) {
       throw new Error(`Invalid git repository: ${gitValidation.error}`);
@@ -23687,9 +23857,9 @@ Example payload:
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path24 = pathValidationResult.path;
+    const path25 = pathValidationResult.path;
     const files = await getLocalFiles({
-      path: path24,
+      path: path25,
       maxFileSize: MCP_MAX_FILE_SIZE,
       maxFiles: args.maxFiles,
       scanContext: ScanContext.USER_REQUEST,
@@ -23709,7 +23879,7 @@ Example payload:
     try {
       const fixResult = await this.vulnerabilityFixService.processVulnerabilities({
         fileList: files.map((file) => file.relativePath),
-        repositoryPath: path24,
+        repositoryPath: path25,
         offset: args.offset,
         limit: args.limit,
         isRescan: args.rescan || !!args.maxFiles
@@ -23844,7 +24014,7 @@ function reviewBuilder(yargs2) {
     ),
     type: "string",
     demandOption: false
-  }).example(
+  }).option("polling", pollingOption).example(
     "npx mobbdev@latest review -r https://github.com/WebGoat/WebGoat -f <your_vulnerability_report_path>  --ch <pr_last_commit>   --pr <pr_number> --ref <pr_branch_name>  --api-key <api_key> --src-path <your_repo_path>",
     "add fixes to your pr"
   ).help();
@@ -23864,7 +24034,7 @@ async function reviewHandler(args) {
 
 // src/args/commands/scan.ts
 function scanBuilder(args) {
-  return args.coerce("scanner", (arg) => arg.toLowerCase()).option("repo", repoOption).option("ref", refOption).option("scanner", scannerOptions).option("org", organizationIdOptions).option("mobb-project-name", mobbProjectNameOption).option("y", yesOption).option("ci", ciOption).option("api-key", apiKeyOption).option("cx-project-name", projectNameOption).option("auto-pr", autoPrOption).example(
+  return args.coerce("scanner", (arg) => arg.toLowerCase()).option("repo", repoOption).option("ref", refOption).option("scanner", scannerOptions).option("org", organizationIdOptions).option("mobb-project-name", mobbProjectNameOption).option("y", yesOption).option("ci", ciOption).option("api-key", apiKeyOption).option("cx-project-name", projectNameOption).option("auto-pr", autoPrOption).option("polling", pollingOption).example(
     "npx mobbdev@latest scan -r https://github.com/WebGoat/WebGoat",
     "Scan an existing repository"
   ).help();
@@ -23922,10 +24092,8 @@ async function addScmTokenHandler(args) {
   await addScmToken(args);
 }
 
-// src/features/codeium_intellij/data_collector_monitor.ts
-import { setTimeout as setTimeout4 } from "timers/promises";
-
 // src/features/codeium_intellij/data_collector.ts
+import { z as z46 } from "zod";
 init_GitService();
 
 // src/features/codeium_intellij/codeium_language_server_grpc_client.ts
@@ -24065,9 +24233,45 @@ function findRunningCodeiumLanguageServers() {
 }
 
 // src/features/codeium_intellij/data_collector.ts
-async function getLatestInferences(startFrom) {
+var HookDataSchema2 = z46.object({
+  trajectory_id: z46.string()
+});
+async function processAndUploadHookData2() {
+  const tracePayload = await getTraceDataForHook();
+  if (!tracePayload) {
+    console.warn("Warning: Failed to retrieve chat data.");
+    return;
+  }
+  try {
+    const uploadSuccess = await uploadAiBlameHandlerFromExtension({
+      prompts: tracePayload.prompts,
+      inference: tracePayload.inference,
+      model: tracePayload.model,
+      tool: tracePayload.tool,
+      responseTime: tracePayload.responseTime,
+      blameType: "CHAT" /* Chat */,
+      sessionId: tracePayload.sessionId,
+      repositoryUrl: tracePayload.repositoryUrl
+    });
+    if (uploadSuccess) {
+      console.log("Uploaded trace data.");
+    } else {
+      console.warn("Failed to upload trace data.");
+    }
+  } catch (e) {
+    console.warn("Failed to upload trace data:", e);
+  }
+}
+function validateHookData2(data) {
+  return HookDataSchema2.parse(data);
+}
+async function getTraceDataForHook() {
+  const rawData = await readStdinData();
+  const hookData = validateHookData2(rawData);
+  return await getTraceDataForTrajectory(hookData.trajectory_id);
+}
+async function getTraceDataForTrajectory(trajectoryId) {
   const instances = findRunningCodeiumLanguageServers();
-  const results = [];
   for (const instance of instances) {
     const client = await getGrpcClient(instance.port, instance.csrf);
     if (!client) {
@@ -24077,20 +24281,13 @@ async function getLatestInferences(startFrom) {
     for (const [cascadeId, chatSummary] of Object.entries(
       chats.trajectorySummaries
     )) {
-      const chatLastModifiedSecStr = chatSummary.lastModifiedTime?.seconds;
-      if (!chatLastModifiedSecStr) {
+      if (chatSummary.trajectoryId !== trajectoryId) {
         continue;
       }
-      const chatLastModifiedSec = Number(chatLastModifiedSecStr);
-      if (chatLastModifiedSec >= Math.floor(startFrom.getTime() / 1e3)) {
-        const traceData = await processChat(client, cascadeId);
-        if (traceData) {
-          results.push(traceData);
-        }
-      }
+      return await processChat(client, cascadeId);
     }
   }
-  return results;
+  return null;
 }
 async function processChat(client, cascadeId) {
   const chatDetails = await client.GetCascadeTrajectory({
@@ -24186,7 +24383,11 @@ function processChatStepPlannerResponse(step) {
 }
 function processChatStepCodeAction(step) {
   const inferences = [];
+  const toolCallName = step.metadata?.toolCall?.name;
   const unifiedDiff = step.codeAction?.actionResult?.edit?.diff?.unifiedDiff;
+  if (!toolCallName) {
+    return { prompts: [], inferences };
+  }
   if (!unifiedDiff) {
     return { prompts: [], inferences };
   }
@@ -24198,63 +24399,119 @@ function processChatStepCodeAction(step) {
   return { prompts: [], inferences };
 }
 
-// src/features/codeium_intellij/data_collector_monitor.ts
-var POLL_INTERVAL = 5 * 1e3;
-async function startMonitoring() {
-  await getAuthenticatedGQLClient({ isSkipPrompts: true });
-  let lastUpdateTs = /* @__PURE__ */ new Date();
-  for (; ; ) {
-    let tracePayloads = [];
-    try {
-      const startFrom = lastUpdateTs;
-      lastUpdateTs = /* @__PURE__ */ new Date();
-      tracePayloads = await getLatestInferences(startFrom);
-    } catch (e) {
-      console.error("Failed to retrieve Windsurf IntelliJ inferences.", e);
-    }
-    for (const tracePayload of tracePayloads) {
-      await tryUpload(tracePayload);
-    }
-    await setTimeout4(POLL_INTERVAL);
-  }
+// src/features/codeium_intellij/install_hook.ts
+import fsPromises6 from "fs/promises";
+import os13 from "os";
+import path24 from "path";
+import chalk12 from "chalk";
+function getCodeiumHooksPath() {
+  return path24.join(os13.homedir(), ".codeium", "hooks.json");
 }
-async function tryUpload(tracePayload) {
+async function readCodeiumHooks() {
+  const hooksPath = getCodeiumHooksPath();
   try {
-    const uploadSuccess = await uploadAiBlameHandlerFromExtension({
-      prompts: tracePayload.prompts,
-      inference: tracePayload.inference,
-      model: tracePayload.model,
-      tool: tracePayload.tool,
-      responseTime: tracePayload.responseTime,
-      blameType: "CHAT" /* Chat */,
-      sessionId: tracePayload.sessionId,
-      repositoryUrl: tracePayload.repositoryUrl
-    });
-    if (uploadSuccess) {
-      console.log("Uploaded trace data.");
-    } else {
-      console.warn("Failed to upload trace data.");
+    const content = await fsPromises6.readFile(hooksPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeCodeiumHooks(config2) {
+  const hooksPath = getCodeiumHooksPath();
+  const dir = path24.dirname(hooksPath);
+  await fsPromises6.mkdir(dir, { recursive: true });
+  await fsPromises6.writeFile(
+    hooksPath,
+    JSON.stringify(config2, null, 2),
+    "utf-8"
+  );
+}
+async function installWindsurfHooks(options = {}) {
+  const hooksPath = getCodeiumHooksPath();
+  console.log(chalk12.blue("Installing Mobb hooks in Windsurf IntelliJ..."));
+  const config2 = await readCodeiumHooks();
+  if (!config2.hooks) {
+    config2.hooks = {};
+  }
+  if (!config2.hooks.post_write_code) {
+    config2.hooks.post_write_code = [];
+  }
+  let command = "npx --yes mobbdev@latest windsurf-intellij-process-hook";
+  if (options.saveEnv) {
+    const envVars = [];
+    if (process.env["WEB_APP_URL"]) {
+      envVars.push(`WEB_APP_URL="${process.env["WEB_APP_URL"]}"`);
     }
-  } catch (e) {
-    console.warn("Failed to upload trace data:", e);
+    if (process.env["API_URL"]) {
+      envVars.push(`API_URL="${process.env["API_URL"]}"`);
+    }
+    if (envVars.length > 0) {
+      command = `${envVars.join(" ")} ${command}`;
+      console.log(
+        chalk12.blue(
+          `Adding environment variables to hook command: ${envVars.join(", ")}`
+        )
+      );
+    }
+  }
+  const mobbHook = {
+    command,
+    show_output: true
+  };
+  const existingHookIndex = config2.hooks.post_write_code.findIndex(
+    (hook) => hook.command?.includes("mobbdev@latest windsurf-intellij-process-hook")
+  );
+  if (existingHookIndex >= 0) {
+    console.log(chalk12.yellow("Mobb hook already exists, updating..."));
+    config2.hooks.post_write_code[existingHookIndex] = mobbHook;
+  } else {
+    console.log(chalk12.green("Adding new Mobb hook..."));
+    config2.hooks.post_write_code.push(mobbHook);
   }
+  await writeCodeiumHooks(config2);
+  console.log(
+    chalk12.green(
+      `\u2705 Mobb hooks ${options.saveEnv ? "and environment variables " : ""}installed successfully in ${hooksPath}`
+    )
+  );
 }
 
 // src/args/commands/windsurf_intellij.ts
-var windsurfIntellijMonitorBuilder = (yargs2) => {
+var windsurfIntellijInstallHookBuilder = (yargs2) => {
+  return yargs2.option("save-env", {
+    type: "boolean",
+    description: "Save WEB_APP_URL, and API_URL environment variables to hooks config",
+    default: false
+  }).example(
+    "$0 windsurf-intellij-install-hook",
+    "Install Windsurf IntelliJ hooks for data collection"
+  ).example(
+    "$0 windsurf-intellij-install-hook --save-env",
+    "Install hooks and save environment variables to config"
+  ).strict();
+};
+var windsurfIntellijProcessHookBuilder = (yargs2) => {
   return yargs2.example(
-    "$0 windsurf-intellij-monitor",
-    "Start monitoring Windsurf IntelliJ for AI inference data"
+    "$0 windsurf-intellij-process-hook",
+    "Process Windsurf IntelliJ hook data and upload to backend"
   ).strict();
 };
-var windsurfIntellijMonitorHandler = async () => {
+var windsurfIntellijInstallHookHandler = async (argv) => {
+  try {
+    await getAuthenticatedGQLClient({ isSkipPrompts: false });
+    await installWindsurfHooks({ saveEnv: argv["save-env"] });
+    process.exit(0);
+  } catch (error) {
+    console.error("Failed to install Windsurf IntelliJ hooks:", error);
+    process.exit(1);
+  }
+};
+var windsurfIntellijProcessHookHandler = async () => {
   try {
-    console.log("Starting Windsurf IntelliJ monitor...");
-    console.log("Polling for AI inference data from running IDE instances.");
-    console.log("Press Ctrl+C to stop.\n");
-    await startMonitoring();
+    await processAndUploadHookData2();
+    process.exit(0);
   } catch (error) {
-    console.error("Windsurf IntelliJ monitor failed:", error);
+    console.error("Failed to process Windsurf IntelliJ hook data:", error);
     process.exit(1);
   }
 };
@@ -24263,78 +24520,83 @@ var windsurfIntellijMonitorHandler = async () => {
 var parseArgs = async (args) => {
   const yargsInstance = yargs(args);
   return yargsInstance.updateStrings({
-    "Commands:": chalk12.yellow.underline.bold("Commands:"),
-    "Options:": chalk12.yellow.underline.bold("Options:"),
-    "Examples:": chalk12.yellow.underline.bold("Examples:"),
-    "Show help": chalk12.bold("Show help")
+    "Commands:": chalk13.yellow.underline.bold("Commands:"),
+    "Options:": chalk13.yellow.underline.bold("Options:"),
+    "Examples:": chalk13.yellow.underline.bold("Examples:"),
+    "Show help": chalk13.bold("Show help")
   }).usage(
-    `${chalk12.bold(
+    `${chalk13.bold(
       "\n Bugsy - Trusted, Automatic Vulnerability Fixer \u{1F575}\uFE0F\u200D\u2642\uFE0F\n\n"
-    )} ${chalk12.yellow.underline.bold("Usage:")} 
-  $0 ${chalk12.green(
+    )} ${chalk13.yellow.underline.bold("Usage:")} 
+  $0 ${chalk13.green(
       "<command>"
-    )} ${chalk12.dim("[options]")}
+    )} ${chalk13.dim("[options]")}
             `
   ).version(false).command(
     mobbCliCommand.scan,
-    chalk12.bold(
+    chalk13.bold(
       "Scan your code for vulnerabilities, get automated fixes right away."
     ),
     scanBuilder,
     scanHandler
   ).command(
     mobbCliCommand.analyze,
-    chalk12.bold(
+    chalk13.bold(
       "Provide a code repository, get automated fixes right away. You can also provide a vulnerability report to analyze or have Mobb scan the code for you."
     ),
     analyzeBuilder,
     analyzeHandler
   ).command(
     mobbCliCommand.review,
-    chalk12.bold(
+    chalk13.bold(
       "Mobb will review your github pull requests and provide comments with fixes "
     ),
     reviewBuilder,
     reviewHandler
   ).command(
     mobbCliCommand.addScmToken,
-    chalk12.bold(
+    chalk13.bold(
       "Add your SCM (Github, Gitlab, Azure DevOps) token to Mobb to enable automated fixes."
     ),
     addScmTokenBuilder,
     addScmTokenHandler
   ).command(
     mobbCliCommand.convertToSarif,
-    chalk12.bold("Convert an existing SAST report to SARIF format."),
+    chalk13.bold("Convert an existing SAST report to SARIF format."),
     convertToSarifBuilder,
     convertToSarifHandler
   ).command(
     mobbCliCommand.mcp,
-    chalk12.bold("Launch the MCP (Model Context Protocol) server."),
+    chalk13.bold("Launch the MCP (Model Context Protocol) server."),
     mcpBuilder,
     mcpHandler
   ).command(
     mobbCliCommand.uploadAiBlame,
-    chalk12.bold(
+    chalk13.bold(
       "Upload AI Blame inference artifacts (prompt + inference) and finalize them."
     ),
     uploadAiBlameBuilder,
     uploadAiBlameCommandHandler
   ).command(
     mobbCliCommand.claudeCodeInstallHook,
-    chalk12.bold("Install Claude Code hooks for data collection."),
+    chalk13.bold("Install Claude Code hooks for data collection."),
     claudeCodeInstallHookBuilder,
     claudeCodeInstallHookHandler
   ).command(
     mobbCliCommand.claudeCodeProcessHook,
-    chalk12.bold("Process Claude Code hook data and upload to backend."),
+    chalk13.bold("Process Claude Code hook data and upload to backend."),
     claudeCodeProcessHookBuilder,
     claudeCodeProcessHookHandler
   ).command(
-    mobbCliCommand.windsurfIntellijMonitor,
-    chalk12.bold("Monitor Windsurf IntelliJ for AI inference data."),
-    windsurfIntellijMonitorBuilder,
-    windsurfIntellijMonitorHandler
+    mobbCliCommand.windsurfIntellijInstallHook,
+    chalk13.bold("Install Windsurf IntelliJ hooks for data collection."),
+    windsurfIntellijInstallHookBuilder,
+    windsurfIntellijInstallHookHandler
+  ).command(
+    mobbCliCommand.windsurfIntellijProcessHook,
+    chalk13.bold("Process Windsurf IntelliJ hook data and upload to backend."),
+    windsurfIntellijProcessHookBuilder,
+    windsurfIntellijProcessHookHandler
   ).example(
     "npx mobbdev@latest scan -r https://github.com/WebGoat/WebGoat",
     "Scan an existing repository"
@@ -24343,7 +24605,7 @@ var parseArgs = async (args) => {
     handler() {
       yargsInstance.showHelp();
     }
-  }).strictOptions().help("h").alias("h", "help").epilog(chalk12.bgBlue("Made with \u2764\uFE0F by Mobb")).showHelpOnFail(true).wrap(Math.min(120, yargsInstance.terminalWidth())).parse();
+  }).strictOptions().help("h").alias("h", "help").epilog(chalk13.bgBlue("Made with \u2764\uFE0F by Mobb")).showHelpOnFail(true).wrap(Math.min(120, yargsInstance.terminalWidth())).parse();
 };
 
 // src/index.ts