mobbdev 1.1.45 → 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 path22 = [
+      const path25 = [
         prefixPath,
         owner,
         projectName,
@@ -6583,7 +6583,7 @@ async function getAdoSdk(params) {
         "items",
         "items"
       ].filter(Boolean).join("/");
-      return new URL(`${path22}?${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 (path22, index) => {
-    const escapedPath = safeGraphQLString(path22, "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 [path22, blameData] of batchResult) {
-      result.set(path22, 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: path22 } = params2;
+      const { ref, gitHubUrl, path: path25 } = params2;
       const { owner, repo } = parseGithubOwnerAndRepo(gitHubUrl);
       const res = await octokit.graphql(
         GET_BLAME_DOCUMENT,
         {
           owner,
           repo,
-          path: path22,
+          path: path25,
           ref
         }
       );
@@ -9030,8 +9030,8 @@ function getGithubSdk(params = {}) {
       return executeBatchGraphQL(octokit, params2.owner, params2.repo, {
         items: params2.filePaths,
         aliasPrefix: "file",
-        buildFragment: (path22, index) => {
-          const escapedPath = safeGraphQLString(path22, "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, path22) {
+  async getRepoBlameRanges(ref, path25) {
     this._validateUrl();
     return await this.githubSdk.getGithubBlameRanges({
       ref,
-      path: path22,
+      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: path22 }, 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, path22, 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, path22) {
+  async getRepoBlameRanges(ref, path25) {
     this._validateUrl();
     return await getGitlabBlameRanges(
-      { ref, path: path22, gitlabUrl: this.url },
+      { ref, path: path25, gitlabUrl: this.url },
       {
         url: this.url,
         gitlabAuthToken: this.accessToken
@@ -11554,7 +11554,9 @@ var mobbCliCommand = {
   mcp: "mcp",
   uploadAiBlame: "upload-ai-blame",
   claudeCodeInstallHook: "claude-code-install-hook",
-  claudeCodeProcessHook: "claude-code-process-hook"
+  claudeCodeProcessHook: "claude-code-process-hook",
+  windsurfIntellijInstallHook: "windsurf-intellij-install-hook",
+  windsurfIntellijProcessHook: "windsurf-intellij-process-hook"
 };
 var ScanContext = {
   FULL_SCAN: "FULL_SCAN",
@@ -12884,7 +12886,7 @@ async function postIssueComment(params) {
     fpDescription
   } = params;
   const {
-    path: path22,
+    path: path25,
     startLine,
     vulnerabilityReportIssue: {
       vulnerabilityReportIssueTags,
@@ -12899,7 +12901,7 @@ async function postIssueComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path22,
+    path: path25,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -12933,7 +12935,7 @@ async function postFixComment(params) {
     scanner
   } = params;
   const {
-    path: path22,
+    path: path25,
     startLine,
     vulnerabilityReportIssue: { fixId, vulnerabilityReportIssueTags, category },
     vulnerabilityReportIssueId
@@ -12951,7 +12953,7 @@ async function postFixComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path22,
+    path: path25,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -13541,8 +13543,8 @@ if (typeof __filename !== "undefined") {
 }
 var costumeRequire = createRequire(moduleUrl);
 var getCheckmarxPath = () => {
-  const os12 = type();
-  const cxFileName = os12 === "Windows_NT" ? "cx.exe" : "cx";
+  const os14 = type();
+  const cxFileName = os14 === "Windows_NT" ? "cx.exe" : "cx";
   try {
     return costumeRequire.resolve(`.bin/${cxFileName}`);
   } catch (e) {
@@ -15697,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(path22) {
-    this.knownWorkspacePath = path22;
+  static setKnownWorkspacePath(path25) {
+    this.knownWorkspacePath = path25;
   }
   /**
    * Gets the known workspace path that was previously validated
@@ -16971,10 +16973,10 @@ var getHostInfo = (additionalMcpList) => {
   const ideConfigPaths = /* @__PURE__ */ new Set();
   for (const ide of IDEs) {
     const configPaths = getMCPConfigPaths(ide);
-    configPaths.forEach((path22) => ideConfigPaths.add(path22));
+    configPaths.forEach((path25) => ideConfigPaths.add(path25));
   }
   const uniqueAdditionalPaths = additionalMcpList.filter(
-    (path22) => !ideConfigPaths.has(path22)
+    (path25) => !ideConfigPaths.has(path25)
   );
   for (const ide of IDEs) {
     const cfg = readMCPConfig(ide);
@@ -20267,7 +20269,7 @@ init_configs();
 import fs19 from "fs/promises";
 import nodePath from "path";
 var getLocalFiles = async ({
-  path: path22,
+  path: path25,
   maxFileSize = MCP_MAX_FILE_SIZE,
   maxFiles,
   isAllFilesScan,
@@ -20275,17 +20277,17 @@ var getLocalFiles = async ({
   scanRecentlyChangedFiles
 }) => {
   logDebug(`[${scanContext}] Starting getLocalFiles`, {
-    path: path22,
+    path: path25,
     maxFileSize,
     maxFiles,
     isAllFilesScan,
     scanRecentlyChangedFiles
   });
   try {
-    const resolvedRepoPath = await fs19.realpath(path22);
+    const resolvedRepoPath = await fs19.realpath(path25);
     logDebug(`[${scanContext}] Resolved repository path`, {
       resolvedRepoPath,
-      originalPath: path22
+      originalPath: path25
     });
     const gitService = new GitService(resolvedRepoPath, log);
     const gitValidation = await gitService.validateRepository();
@@ -20298,7 +20300,7 @@ var getLocalFiles = async ({
     if (!gitValidation.isValid || isAllFilesScan) {
       try {
         files = await FileUtils.getLastChangedFiles({
-          dir: path22,
+          dir: path25,
           maxFileSize,
           maxFiles,
           isAllFilesScan
@@ -20390,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: path22
+      path: path25
     });
     throw error;
   }
@@ -22538,14 +22540,14 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
    * since the last scan.
    */
   async scanForSecurityVulnerabilities({
-    path: path22,
+    path: path25,
     isAllDetectionRulesScan,
     isAllFilesScan,
     scanContext
   }) {
     this.hasAuthenticationFailed = false;
     logDebug(`[${scanContext}] Scanning for new security vulnerabilities`, {
-      path: path22
+      path: path25
     });
     if (!this.gqlClient) {
       logInfo(`[${scanContext}] No GQL client found, skipping scan`);
@@ -22561,11 +22563,11 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       logDebug(
         `[${scanContext}] Connected to the API, assembling list of files to scan`,
-        { path: path22 }
+        { path: path25 }
       );
       const isBackgroundScan = scanContext === ScanContext.BACKGROUND_INITIAL || scanContext === ScanContext.BACKGROUND_PERIODIC;
       const files = await getLocalFiles({
-        path: path22,
+        path: path25,
         isAllFilesScan,
         scanContext,
         scanRecentlyChangedFiles: !isBackgroundScan
@@ -22591,13 +22593,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
       const { fixReportId, projectId } = await scanFiles({
         fileList: filesToScan.map((file) => file.relativePath),
-        repositoryPath: path22,
+        repositoryPath: path25,
         gqlClient: this.gqlClient,
         isAllDetectionRulesScan,
         scanContext
       });
       logInfo(
-        `[${scanContext}] Security scan completed for ${path22} reportId: ${fixReportId} projectId: ${projectId}`
+        `[${scanContext}] Security scan completed for ${path25} reportId: ${fixReportId} projectId: ${projectId}`
       );
       if (isAllFilesScan) {
         return;
@@ -22891,13 +22893,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     });
     return scannedFiles.some((file) => file.relativePath === fixFile);
   }
-  async getFreshFixes({ path: path22 }) {
+  async getFreshFixes({ path: path25 }) {
     const scanContext = ScanContext.USER_REQUEST;
-    logDebug(`[${scanContext}] Getting fresh fixes`, { path: path22 });
-    if (this.path !== path22) {
-      this.path = path22;
+    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: path22 });
+      logInfo(`[${scanContext}] Reset service state for new path`, { path: path25 });
     }
     try {
       const loginContext = createMcpLoginContext("check_new_fixes");
@@ -22916,7 +22918,7 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       throw error;
     }
-    this.triggerScan({ path: path22, gqlClient: this.gqlClient });
+    this.triggerScan({ path: path25, gqlClient: this.gqlClient });
     let isMvsAutoFixEnabled = null;
     try {
       isMvsAutoFixEnabled = await this.gqlClient.getMvsAutoFixSettings();
@@ -22950,33 +22952,33 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     return noFreshFixesPrompt;
   }
   triggerScan({
-    path: path22,
+    path: path25,
     gqlClient
   }) {
-    if (this.path !== path22) {
-      this.path = path22;
+    if (this.path !== path25) {
+      this.path = path25;
       this.reset();
-      logInfo(`Reset service state for new path in triggerScan`, { path: path22 });
+      logInfo(`Reset service state for new path in triggerScan`, { path: path25 });
     }
     this.gqlClient = gqlClient;
     if (!this.intervalId) {
-      this.startPeriodicScanning(path22);
-      this.executeInitialScan(path22);
-      void this.executeInitialFullScan(path22);
+      this.startPeriodicScanning(path25);
+      this.executeInitialScan(path25);
+      void this.executeInitialFullScan(path25);
     }
   }
-  startPeriodicScanning(path22) {
+  startPeriodicScanning(path25) {
     const scanContext = ScanContext.BACKGROUND_PERIODIC;
     logDebug(
       `[${scanContext}] Starting periodic scan for new security vulnerabilities`,
       {
-        path: path22
+        path: path25
       }
     );
     this.intervalId = setInterval(() => {
-      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path22 });
+      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path25 });
       this.scanForSecurityVulnerabilities({
-        path: path22,
+        path: path25,
         scanContext
       }).catch((error) => {
         logError(`[${scanContext}] Error during periodic security scan`, {
@@ -22985,45 +22987,45 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
     }, MCP_PERIODIC_CHECK_INTERVAL);
   }
-  async executeInitialFullScan(path22) {
+  async executeInitialFullScan(path25) {
     const scanContext = ScanContext.FULL_SCAN;
-    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path22 });
+    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path25 });
     logDebug(`[${scanContext}] Full scan paths scanned`, {
       fullScanPathsScanned: this.fullScanPathsScanned
     });
-    if (this.fullScanPathsScanned.includes(path22)) {
+    if (this.fullScanPathsScanned.includes(path25)) {
       logDebug(`[${scanContext}] Full scan already executed for this path`, {
-        path: path22
+        path: path25
       });
       return;
     }
     configStore.set("fullScanPathsScanned", [
       ...this.fullScanPathsScanned,
-      path22
+      path25
     ]);
     try {
       await this.scanForSecurityVulnerabilities({
-        path: path22,
+        path: path25,
         isAllFilesScan: true,
         isAllDetectionRulesScan: true,
         scanContext: ScanContext.FULL_SCAN
       });
-      if (!this.fullScanPathsScanned.includes(path22)) {
-        this.fullScanPathsScanned.push(path22);
+      if (!this.fullScanPathsScanned.includes(path25)) {
+        this.fullScanPathsScanned.push(path25);
         configStore.set("fullScanPathsScanned", this.fullScanPathsScanned);
       }
-      logInfo(`[${scanContext}] Full scan completed`, { path: path22 });
+      logInfo(`[${scanContext}] Full scan completed`, { path: path25 });
     } catch (error) {
       logError(`[${scanContext}] Error during initial full security scan`, {
         error
       });
     }
   }
-  executeInitialScan(path22) {
+  executeInitialScan(path25) {
     const scanContext = ScanContext.BACKGROUND_INITIAL;
-    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path22 });
+    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path25 });
     this.scanForSecurityVulnerabilities({
-      path: path22,
+      path: path25,
       scanContext: ScanContext.BACKGROUND_INITIAL
     }).catch((error) => {
       logError(`[${scanContext}] Error during initial security scan`, { error });
@@ -23120,9 +23122,9 @@ Example payload:
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path22 = pathValidationResult.path;
+    const path25 = pathValidationResult.path;
     const resultText = await this.newFixesService.getFreshFixes({
-      path: path22
+      path: path25
     });
     logInfo("CheckForNewAvailableFixesTool execution completed", {
       resultText
@@ -23300,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 path22 = pathValidationResult.path;
-    const gitService = new GitService(path22, 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}`);
@@ -23686,9 +23688,9 @@ Example payload:
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path22 = pathValidationResult.path;
+    const path25 = pathValidationResult.path;
     const files = await getLocalFiles({
-      path: path22,
+      path: path25,
       maxFileSize: MCP_MAX_FILE_SIZE,
       maxFiles: args.maxFiles,
       scanContext: ScanContext.USER_REQUEST,
@@ -23708,7 +23710,7 @@ Example payload:
     try {
       const fixResult = await this.vulnerabilityFixService.processVulnerabilities({
         fileList: files.map((file) => file.relativePath),
-        repositoryPath: path22,
+        repositoryPath: path25,
         offset: args.offset,
         limit: args.limit,
         isRescan: args.rescan || !!args.maxFiles
@@ -23921,77 +23923,511 @@ async function addScmTokenHandler(args) {
   await addScmToken(args);
 }
 
+// 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
+import path22 from "path";
+import * as grpc from "@grpc/grpc-js";
+import * as protoLoader from "@grpc/proto-loader";
+var PROTO_PATH = path22.join(
+  getModuleRootDir(),
+  "src/features/codeium_intellij/proto/exa/language_server_pb/language_server.proto"
+);
+function loadProto() {
+  const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
+    keepCase: false,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true,
+    includeDirs: [
+      path22.join(getModuleRootDir(), "src/features/codeium_intellij/proto")
+    ]
+  });
+  return grpc.loadPackageDefinition(
+    packageDefinition
+  );
+}
+var PROTO = loadProto();
+function createCsrfInterceptor(csrfToken) {
+  return (options, nextCall) => {
+    return new grpc.InterceptingCall(nextCall(options), {
+      start(metadata, listener, next) {
+        metadata.set("x-codeium-csrf-token", csrfToken);
+        next(metadata, listener);
+      }
+    });
+  };
+}
+function promisifyClient(client) {
+  return new Proxy(client, {
+    get(target, prop) {
+      const method = target[prop];
+      if (typeof method === "function") {
+        return (request) => new Promise((resolve, reject) => {
+          const grpcMethod = method;
+          grpcMethod.call(target, request, (err, res) => {
+            if (err) reject(err);
+            else if (res) resolve(res);
+            else reject(new Error("No response"));
+          });
+        });
+      }
+      return method;
+    }
+  });
+}
+async function getGrpcClient(port, csrf3) {
+  const client = promisifyClient(
+    new PROTO.exa.language_server_pb.LanguageServerService(
+      `localhost:${port}`,
+      grpc.credentials.createInsecure(),
+      { interceptors: [createCsrfInterceptor(csrf3)] }
+    )
+  );
+  try {
+    await client.GetAllCascadeTrajectories({});
+  } catch (e) {
+    console.log(e);
+    return null;
+  }
+  return client;
+}
+
+// src/features/codeium_intellij/parse_intellij_logs.ts
+import fs24 from "fs";
+import os12 from "os";
+import path23 from "path";
+function getLogsDir() {
+  if (process.platform === "darwin") {
+    return path23.join(os12.homedir(), "Library/Logs/JetBrains");
+  } else if (process.platform === "win32") {
+    return path23.join(
+      process.env["LOCALAPPDATA"] || path23.join(os12.homedir(), "AppData/Local"),
+      "JetBrains"
+    );
+  } else {
+    return path23.join(os12.homedir(), ".cache/JetBrains");
+  }
+}
+function parseIdeLogDir(ideLogDir) {
+  const logFiles = fs24.readdirSync(ideLogDir).filter((f) => /^idea(\.\d+)?\.log$/.test(f)).map((f) => ({
+    name: f,
+    mtime: fs24.statSync(path23.join(ideLogDir, f)).mtimeMs
+  })).sort((a, b) => a.mtime - b.mtime).map((f) => f.name);
+  let latestCsrf = null;
+  let latestPort = null;
+  for (const logFile of logFiles) {
+    const lines = fs24.readFileSync(path23.join(ideLogDir, logFile), "utf-8").split("\n");
+    for (const line of lines) {
+      if (!line.includes(
+        "com.codeium.intellij.language_server.LanguageServerProcessHandler"
+      )) {
+        continue;
+      }
+      const csrfMatch = line.match(/--csrf_token\s+([a-f0-9-]{36})/);
+      if (csrfMatch?.[1]) {
+        latestCsrf = csrfMatch[1];
+        latestPort = null;
+      }
+      const portMatch = line.match(/listening on random port at (\d+)/);
+      if (portMatch?.[1]) {
+        latestPort = parseInt(portMatch[1]);
+      }
+    }
+  }
+  if (latestCsrf && latestPort) {
+    return { csrf: latestCsrf, port: latestPort };
+  }
+  return null;
+}
+function findRunningCodeiumLanguageServers() {
+  const results = [];
+  const logsDir = getLogsDir();
+  if (!fs24.existsSync(logsDir)) return results;
+  for (const ide of fs24.readdirSync(logsDir)) {
+    let ideLogDir = path23.join(logsDir, ide);
+    if (process.platform !== "darwin") {
+      ideLogDir = path23.join(ideLogDir, "log");
+    }
+    if (!fs24.existsSync(ideLogDir) || !fs24.statSync(ideLogDir).isDirectory()) {
+      continue;
+    }
+    const result = parseIdeLogDir(ideLogDir);
+    if (result) {
+      results.push({ ide, ...result });
+    }
+  }
+  return results;
+}
+
+// src/features/codeium_intellij/data_collector.ts
+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();
+  for (const instance of instances) {
+    const client = await getGrpcClient(instance.port, instance.csrf);
+    if (!client) {
+      continue;
+    }
+    const chats = await client.GetAllCascadeTrajectories({});
+    for (const [cascadeId, chatSummary] of Object.entries(
+      chats.trajectorySummaries
+    )) {
+      if (chatSummary.trajectoryId !== trajectoryId) {
+        continue;
+      }
+      return await processChat(client, cascadeId);
+    }
+  }
+  return null;
+}
+async function processChat(client, cascadeId) {
+  const chatDetails = await client.GetCascadeTrajectory({
+    cascadeId
+  });
+  const allPrompts = [];
+  const allInferences = [];
+  const steps = chatDetails.trajectory?.steps || [];
+  for (const step of steps) {
+    const result = processChatStep(step);
+    allPrompts.push(...result.prompts);
+    allInferences.push(...result.inferences);
+  }
+  if (allInferences.length === 0) {
+    return null;
+  }
+  const generatorMetadata = chatDetails.trajectory?.generatorMetadata || [];
+  const model = generatorMetadata.find((m) => m.chatModel?.modelUid)?.chatModel?.modelUid || "unknown";
+  const lastStep = steps[steps.length - 1];
+  const completedAt = lastStep?.metadata?.completedAt;
+  const responseTime = completedAt?.seconds ? new Date(Number(completedAt.seconds) * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+  const repoOrigin = chatDetails.trajectory?.metadata?.workspaces?.[0]?.repository?.gitOriginUrl;
+  let repositoryUrl;
+  if (repoOrigin) {
+    const normalizedUrl = normalizeGitUrl(repoOrigin);
+    if (isGitHubUrl(normalizedUrl)) {
+      repositoryUrl = normalizedUrl;
+    }
+  }
+  return {
+    prompts: allPrompts,
+    inference: allInferences.join("\n"),
+    model,
+    tool: "Windsurf Intellij",
+    responseTime,
+    sessionId: cascadeId,
+    repositoryUrl
+  };
+}
+function processChatStep(step) {
+  switch (step.type) {
+    case "CORTEX_STEP_TYPE_USER_INPUT":
+      return processChatStepUserInput(step);
+    case "CORTEX_STEP_TYPE_PLANNER_RESPONSE":
+      return processChatStepPlannerResponse(step);
+    case "CORTEX_STEP_TYPE_CODE_ACTION":
+      return processChatStepCodeAction(step);
+    default:
+      return { prompts: [], inferences: [] };
+  }
+}
+function processChatStepUserInput(step) {
+  const query = step.userInput?.query || step.userInput?.userResponse || "";
+  if (!query) {
+    return { prompts: [], inferences: [] };
+  }
+  return {
+    prompts: [
+      {
+        type: "USER_PROMPT",
+        text: query,
+        date: /* @__PURE__ */ new Date()
+      }
+    ],
+    inferences: []
+  };
+}
+function processChatStepPlannerResponse(step) {
+  const prompts = [];
+  const date = /* @__PURE__ */ new Date();
+  const text = step.plannerResponse?.response || step.plannerResponse?.modifiedResponse || "";
+  if (text) {
+    prompts.push({
+      type: "AI_RESPONSE",
+      text,
+      date
+    });
+  }
+  for (const toolCall of step.plannerResponse?.toolCalls || []) {
+    prompts.push({
+      type: "TOOL_EXECUTION",
+      date,
+      tool: {
+        name: toolCall.name,
+        parameters: toolCall.argumentsJson,
+        result: "",
+        rawArguments: toolCall.argumentsJson,
+        accepted: true
+      }
+    });
+  }
+  return { prompts, inferences: [] };
+}
+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 };
+  }
+  for (const line of unifiedDiff.lines) {
+    if (line.type === "UNIFIED_DIFF_LINE_TYPE_INSERT") {
+      inferences.push(line.text);
+    }
+  }
+  return { prompts: [], inferences };
+}
+
+// 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 readCodeiumHooks() {
+  const hooksPath = getCodeiumHooksPath();
+  try {
+    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(", ")}`
+        )
+      );
+    }
+  }
+  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 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-process-hook",
+    "Process Windsurf IntelliJ hook data and upload to backend"
+  ).strict();
+};
+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 {
+    await processAndUploadHookData2();
+    process.exit(0);
+  } catch (error) {
+    console.error("Failed to process Windsurf IntelliJ hook data:", error);
+    process.exit(1);
+  }
+};
+
 // src/args/yargs.ts
 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.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"
@@ -24000,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