mobbdev 1.2.0 → 1.2.1

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
@@ -11555,7 +11555,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",
@@ -12885,7 +12886,7 @@ async function postIssueComment(params) {
     fpDescription
   } = params;
   const {
-    path: path24,
+    path: path25,
     startLine,
     vulnerabilityReportIssue: {
       vulnerabilityReportIssueTags,
@@ -12900,7 +12901,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 +12935,7 @@ async function postFixComment(params) {
     scanner
   } = params;
   const {
-    path: path24,
+    path: path25,
     startLine,
     vulnerabilityReportIssue: { fixId, vulnerabilityReportIssueTags, category },
     vulnerabilityReportIssueId
@@ -12952,7 +12953,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;
@@ -13542,8 +13543,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) {
@@ -15698,8 +15699,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 +16973,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 +20269,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 +20277,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 +20300,7 @@ var getLocalFiles = async ({
     if (!gitValidation.isValid || isAllFilesScan) {
       try {
         files = await FileUtils.getLastChangedFiles({
-          dir: path24,
+          dir: path25,
           maxFileSize,
           maxFiles,
           isAllFilesScan
@@ -20391,7 +20392,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 +22540,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 +22563,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 +22593,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 +22893,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 +22918,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 +22952,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 +22987,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 +23122,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 +23302,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 +23688,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 +23710,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
@@ -23922,10 +23923,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 +24064,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 +24112,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 +24214,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 +24230,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"]}"`);
+    }
+    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(", ")}`
+        )
+      );
     }
-  } catch (e) {
-    console.warn("Failed to upload trace data:", e);
   }
+  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 {
-    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 getAuthenticatedGQLClient({ isSkipPrompts: false });
+    await installWindsurfHooks({ saveEnv: argv["save-env"] });
+    process.exit(0);
   } catch (error) {
-    console.error("Windsurf IntelliJ monitor failed:", error);
+    console.error("Failed to install Windsurf IntelliJ hooks:", error);
+    process.exit(1);
+  }
+};
+var windsurfIntellijProcessHookHandler = async () => {
+  try {
+    await processAndUploadHookData2();
+    process.exit(0);
+  } catch (error) {
+    console.error("Failed to process Windsurf IntelliJ hook data:", error);
     process.exit(1);
   }
 };
@@ -24263,78 +24351,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 +24436,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

package/package.json

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