mobbdev 1.2.28 → 1.2.32

package/dist/index.mjs

@@ -851,12 +851,15 @@ var init_client_generates = __esm({
 }
     `;
     AnalyzeCommitForExtensionAiBlameDocument = `
-    mutation AnalyzeCommitForExtensionAIBlame($repositoryURL: String!, $commitSha: String!, $organizationId: String!, $commitTimestamp: Timestamp) {
+    mutation AnalyzeCommitForExtensionAIBlame($repositoryURL: String!, $commitSha: String!, $organizationId: String!, $commitTimestamp: Timestamp, $commitAuthor: GitIdentityInput, $commitCommitter: GitIdentityInput, $commitCoAuthors: [GitIdentityInput!]) {
   analyzeCommitForAIBlame(
     repositoryURL: $repositoryURL
     commitSha: $commitSha
     organizationId: $organizationId
     commitTimestamp: $commitTimestamp
+    commitAuthor: $commitAuthor
+    commitCommitter: $commitCommitter
+    commitCoAuthors: $commitCoAuthors
   ) {
     __typename
     ... on ProcessAIBlameFinalResult {
@@ -2689,6 +2692,217 @@ var init_configs = __esm({
   }
 });
 
+// src/utils/blame/gitBlameTypes.ts
+import { z as z18 } from "zod";
+function parseCoAuthorValue(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const openBracket = trimmed.lastIndexOf("<");
+  const closeBracket = trimmed.lastIndexOf(">");
+  if (openBracket === -1 || closeBracket === -1 || closeBracket < openBracket) {
+    return null;
+  }
+  const name = trimmed.slice(0, openBracket).trim();
+  const email = trimmed.slice(openBracket + 1, closeBracket).trim();
+  if (!name || !email) {
+    return null;
+  }
+  return { name, email };
+}
+function parseCommitLine(line) {
+  const parts = line.split("\0");
+  if (parts.length < 7) {
+    return null;
+  }
+  return {
+    sha: parts[0],
+    author: { name: parts[2], email: parts[1] },
+    committer: { name: parts[4], email: parts[3] },
+    coAuthors: parts.slice(7).map(parseCoAuthorValue).filter((v) => v !== null),
+    timestamp: parseInt(parts[5], 10),
+    message: parts[6]
+  };
+}
+var PrepareGitBlameMessageZ, PrepareGitBlameResponseMessageZ, CommitMetadataZ, LineToCommitMapZ, CommitMetadataMapZ, BlameInfoZ, LineRangeZ, PrContextZ, PrepareCommitBlameMessageZ, BlameLineInfoZ, FileBlameDataZ, ChunkFetchResultZ, FileBlameResponseEntryZ, CommitBlameDataZ, CommitInfoZ, GitIdentityZ, COMMIT_LOG_FORMAT, CommitDataZ, PrDiffDataZ, PrStatsZ, CommitsManifestZ, BlameLineEntryZ, BlameLinesDataZ, PrepareCommitBlameResponseMessageZ;
+var init_gitBlameTypes = __esm({
+  "src/utils/blame/gitBlameTypes.ts"() {
+    "use strict";
+    PrepareGitBlameMessageZ = z18.object({
+      reportId: z18.string(),
+      repoArchivePath: z18.string()
+    });
+    PrepareGitBlameResponseMessageZ = z18.object({
+      reportId: z18.string()
+    });
+    CommitMetadataZ = z18.object({
+      author: z18.string().optional(),
+      "author-mail": z18.string().optional(),
+      "author-time": z18.string().optional(),
+      "author-tz": z18.string().optional(),
+      committer: z18.string().optional(),
+      "committer-mail": z18.string().optional(),
+      "committer-time": z18.string().optional(),
+      "committer-tz": z18.string().optional(),
+      summary: z18.string().optional(),
+      filename: z18.string().optional()
+    });
+    LineToCommitMapZ = z18.record(z18.string(), z18.string());
+    CommitMetadataMapZ = z18.record(z18.string(), CommitMetadataZ);
+    BlameInfoZ = z18.object({
+      lineToCommit: LineToCommitMapZ,
+      commitMetadata: CommitMetadataMapZ
+    });
+    LineRangeZ = z18.object({
+      /** First line in chunk (1-indexed) */
+      start: z18.number(),
+      /** Last line in chunk (inclusive) */
+      end: z18.number()
+    });
+    PrContextZ = z18.object({
+      prNumber: z18.number(),
+      repositoryUrl: z18.string(),
+      organizationId: z18.string(),
+      userEmail: z18.string(),
+      source: z18.enum(["pr", "github"]),
+      githubContext: z18.object({
+        prNumber: z18.number(),
+        installationId: z18.number(),
+        repositoryURL: z18.string()
+      }).optional()
+    });
+    PrepareCommitBlameMessageZ = z18.object({
+      /** Commit blame request ID from database (for tracking and updating status) */
+      commitBlameRequestId: z18.string(),
+      /** Organization ID (for org-scoped caching) */
+      organizationId: z18.string(),
+      /** Full repository URL (e.g., https://github.com/org/repo) */
+      repositoryUrl: z18.string(),
+      /** Commit SHA to analyze (typically PR head commit) */
+      commitSha: z18.string(),
+      /** Authentication headers for repository access (e.g., GitHub token) */
+      extraHeaders: z18.record(z18.string(), z18.string()).default({}),
+      // --- PR analysis fields ---
+      /** Target branch name (from getPr() base.ref). When set, enables PR analysis mode. */
+      targetBranch: z18.string().optional(),
+      /** Context for triggering blame attribution analysis after SCM agent completes. */
+      prContext: PrContextZ.optional(),
+      /** User email for blame attribution analysis trigger context (used for both PR and single commit flows). */
+      userEmail: z18.string().optional()
+    });
+    BlameLineInfoZ = z18.object({
+      /** Line number as it appeared in the introducing commit */
+      originalLineNumber: z18.number(),
+      /** Commit SHA that introduced this line */
+      commitSha: z18.string(),
+      /** Author name for this line */
+      authorName: z18.string().optional(),
+      /** Author email for this line */
+      authorEmail: z18.string().optional()
+    }).nullable();
+    FileBlameDataZ = z18.array(BlameLineInfoZ);
+    ChunkFetchResultZ = z18.object({
+      filePath: z18.string(),
+      lines: z18.array(z18.number()),
+      data: FileBlameDataZ.nullable()
+    });
+    FileBlameResponseEntryZ = z18.object({
+      /** Chunk index (0 for small files, 0-N for large file chunks) */
+      chunkIndex: z18.number(),
+      /** Blame data array (1-indexed, index 0 is null) */
+      blameData: FileBlameDataZ
+    });
+    CommitBlameDataZ = z18.record(
+      z18.string(),
+      // fileName
+      z18.array(FileBlameResponseEntryZ)
+    );
+    CommitInfoZ = z18.object({
+      /** Number of parent commits (1 = normal commit, 2+ = merge commit, null = failed to determine) */
+      parentCount: z18.number().nullable()
+    });
+    GitIdentityZ = z18.object({
+      name: z18.string(),
+      email: z18.string()
+    });
+    COMMIT_LOG_FORMAT = "%H%x00%ae%x00%an%x00%ce%x00%cn%x00%at%x00%s%x00%(trailers:key=Co-authored-by,valueonly,separator=%x00)";
+    CommitDataZ = z18.object({
+      diff: z18.string(),
+      author: GitIdentityZ,
+      committer: GitIdentityZ,
+      coAuthors: z18.array(GitIdentityZ),
+      timestamp: z18.number(),
+      // Unix timestamp in seconds
+      message: z18.string().optional(),
+      parentCount: z18.number().nullable()
+    });
+    PrDiffDataZ = z18.object({
+      diff: z18.string()
+    });
+    PrStatsZ = z18.object({
+      additions: z18.number(),
+      deletions: z18.number()
+    });
+    CommitsManifestZ = z18.object({
+      commits: z18.array(z18.string())
+      // Array of commit SHAs in order
+    });
+    BlameLineEntryZ = z18.object({
+      file: z18.string(),
+      line: z18.number(),
+      originalCommitSha: z18.string(),
+      originalLineNumber: z18.number()
+    });
+    BlameLinesDataZ = z18.object({
+      lines: z18.array(BlameLineEntryZ)
+    });
+    PrepareCommitBlameResponseMessageZ = z18.object({
+      /** Commit blame request ID (matches request, used to update specific DB record) */
+      commitBlameRequestId: z18.string(),
+      /** Organization ID (matches request) */
+      organizationId: z18.string(),
+      /** Repository URL (matches request) */
+      repositoryUrl: z18.string(),
+      /** Commit SHA analyzed (matches request) */
+      commitSha: z18.string(),
+      /** Processing status */
+      status: z18.enum(["success", "failure"]),
+      /** Error message (only present if status is 'failure') */
+      error: z18.string().optional(),
+      /**
+       * Blame data for all processed files/chunks.
+       * Empty dictionary if status is 'failure'.
+       * Contains line mappings as arrays if status is 'success'.
+       */
+      blameData: CommitBlameDataZ,
+      /**
+       * Info about each commit referenced in the blame data plus the head commit.
+       * Keyed by commit SHA, deduplicated.
+       * Empty dictionary if status is 'failure'.
+       */
+      commits: z18.record(z18.string(), CommitInfoZ).default({}),
+      // --- New PR diff computation response fields ---
+      /** S3 paths for commit-level data (commitSha → S3 key). Present in PR analysis mode and single commit mode. */
+      commitDataS3Paths: z18.record(z18.string(), z18.string()).optional(),
+      /** S3 key for PR diff JSON. Present in PR analysis mode. */
+      prDiffS3Path: z18.string().optional(),
+      /** S3 key for commits manifest. Present in PR analysis mode. */
+      commitsManifestS3Path: z18.string().optional(),
+      /** S3 key for per-line targeted blame data. Present in PR analysis mode. */
+      blameLinesS3Path: z18.string().optional(),
+      /** S3 key for PR stats (additions/deletions). Present in PR analysis mode. */
+      prStatsS3Path: z18.string().optional(),
+      /** PR context passed through from request for response handler. */
+      prContext: PrContextZ.optional(),
+      /** PR title from the request metadata (passed through). */
+      prTitle: z18.string().optional(),
+      /** User email passed through from request for single commit blame attribution analysis trigger. */
+      userEmail: z18.string().optional()
+    });
+  }
+});
+
 // src/features/analysis/scm/services/ExcludedDirs.ts
 var EXCLUDED_DIRS;
 var init_ExcludedDirs = __esm({
@@ -3361,6 +3575,7 @@ var init_GitService = __esm({
   "src/features/analysis/scm/services/GitService.ts"() {
     "use strict";
     init_configs();
+    init_gitBlameTypes();
     init_urlParser2();
     init_FileUtils();
     MAX_COMMIT_DIFF_SIZE_BYTES = 3 * 1024 * 1024;
@@ -3857,7 +4072,7 @@ ${rootContent}`;
           const DIFF_DELIMITER = "---MOBB_DIFF_START---";
           const output = await this.git.show([
             commitSha,
-            `--format=%cI%n${DIFF_DELIMITER}`,
+            `--format=${COMMIT_LOG_FORMAT}%n${DIFF_DELIMITER}`,
             "--patch"
           ]);
           const delimiterIndex = output.indexOf(DIFF_DELIMITER);
@@ -3878,16 +4093,16 @@ ${rootContent}`;
             });
             return null;
           }
-          const metadataLines = metadataOutput.trim().split("\n");
-          if (metadataLines.length < 1 || !metadataLines[0]) {
+          const metadataLine = metadataOutput.trim();
+          const parsed = parseCommitLine(metadataLine);
+          if (!parsed) {
             this.log("[GitService] Unexpected metadata format", "warning", {
               commitSha,
-              metadataLines
+              metadataLine
             });
             return null;
           }
-          const timestampStr = metadataLines[0];
-          const timestamp = new Date(timestampStr);
+          const timestamp = new Date(parsed.timestamp * 1e3);
           this.log("[GitService] Local commit data retrieved", "debug", {
             commitSha,
             diffSizeBytes,
@@ -3895,7 +4110,10 @@ ${rootContent}`;
           });
           return {
             diff,
-            timestamp
+            timestamp,
+            author: parsed.author,
+            committer: parsed.committer,
+            coAuthors: parsed.coAuthors
           };
         } catch (error) {
           const errorMessage = `Failed to get local commit data: ${error.message}`;
@@ -3908,7 +4126,7 @@ ${rootContent}`;
 });
 
 // src/index.ts
-import Debug19 from "debug";
+import Debug20 from "debug";
 import { hideBin } from "yargs/helpers";
 
 // src/args/yargs.ts
@@ -7381,34 +7599,34 @@ import querystring2 from "querystring";
 import * as bitbucketPkgNode from "bitbucket";
 import bitbucketPkg from "bitbucket";
 import Debug2 from "debug";
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/features/analysis/scm/bitbucket/validation.ts
-import { z as z18 } from "zod";
-var BitbucketAuthResultZ = z18.object({
-  access_token: z18.string(),
-  token_type: z18.string(),
-  refresh_token: z18.string()
+import { z as z19 } from "zod";
+var BitbucketAuthResultZ = z19.object({
+  access_token: z19.string(),
+  token_type: z19.string(),
+  refresh_token: z19.string()
 });
 
 // src/features/analysis/scm/bitbucket/bitbucket.ts
 var debug2 = Debug2("scm:bitbucket");
 var BITBUCKET_HOSTNAME = "bitbucket.org";
-var TokenExpiredErrorZ = z19.object({
-  status: z19.number(),
-  error: z19.object({
-    type: z19.string(),
-    error: z19.object({
-      message: z19.string()
+var TokenExpiredErrorZ = z20.object({
+  status: z20.number(),
+  error: z20.object({
+    type: z20.string(),
+    error: z20.object({
+      message: z20.string()
     })
   })
 });
 var BITBUCKET_ACCESS_TOKEN_URL = `https://${BITBUCKET_HOSTNAME}/site/oauth2/access_token`;
 var MAX_BITBUCKET_PR_BODY_LENGTH = 32768;
-var BitbucketParseResultZ = z19.object({
-  organization: z19.string(),
-  repoName: z19.string(),
-  hostname: z19.literal(BITBUCKET_HOSTNAME)
+var BitbucketParseResultZ = z20.object({
+  organization: z20.string(),
+  repoName: z20.string(),
+  hostname: z20.literal(BITBUCKET_HOSTNAME)
 });
 function parseBitbucketOrganizationAndRepo(bitbucketUrl) {
   const parsedGitHubUrl = normalizeUrl(bitbucketUrl);
@@ -7468,7 +7686,7 @@ function getBitbucketSdk(params) {
       if (!res.data.values) {
         return [];
       }
-      return res.data.values.filter((branch) => !!branch.name).map((branch) => z19.string().parse(branch.name));
+      return res.data.values.filter((branch) => !!branch.name).map((branch) => z20.string().parse(branch.name));
     },
     async getIsUserCollaborator(params2) {
       const { repoUrl } = params2;
@@ -7583,7 +7801,7 @@ function getBitbucketSdk(params) {
       return GetReferenceResultZ.parse({
         sha: tagRes.data.target?.hash,
         type: "TAG" /* TAG */,
-        date: new Date(z19.string().parse(tagRes.data.target?.date))
+        date: new Date(z20.string().parse(tagRes.data.target?.date))
       });
     },
     async getBranchRef(params2) {
@@ -7591,7 +7809,7 @@ function getBitbucketSdk(params) {
       return GetReferenceResultZ.parse({
         sha: getBranchRes.target?.hash,
         type: "BRANCH" /* BRANCH */,
-        date: new Date(z19.string().parse(getBranchRes.target?.date))
+        date: new Date(z20.string().parse(getBranchRes.target?.date))
       });
     },
     async getCommitRef(params2) {
@@ -7599,13 +7817,13 @@ function getBitbucketSdk(params) {
       return GetReferenceResultZ.parse({
         sha: getCommitRes.hash,
         type: "COMMIT" /* COMMIT */,
-        date: new Date(z19.string().parse(getCommitRes.date))
+        date: new Date(z20.string().parse(getCommitRes.date))
       });
     },
     async getDownloadUrl({ url, sha }) {
       this.getReferenceData({ ref: sha, url });
       const repoRes = await this.getRepo({ repoUrl: url });
-      const parsedRepoUrl = z19.string().url().parse(repoRes.links?.html?.href);
+      const parsedRepoUrl = z20.string().url().parse(repoRes.links?.html?.href);
       return `${parsedRepoUrl}/get/${sha}.zip`;
     },
     async getPullRequest(params2) {
@@ -7670,7 +7888,7 @@ async function validateBitbucketParams(params) {
 }
 async function getUsersWorkspacesSlugs(bitbucketClient) {
   const res = await bitbucketClient.workspaces.getWorkspaces({});
-  return res.data.values?.map((v) => z19.string().parse(v.slug));
+  return res.data.values?.map((v) => z20.string().parse(v.slug));
 }
 async function getAllUsersRepositories(bitbucketClient) {
   const userWorkspacesSlugs = await getUsersWorkspacesSlugs(bitbucketClient);
@@ -7698,10 +7916,10 @@ async function getRepositoriesByWorkspace(bitbucketClient, { workspaceSlug }) {
 
 // src/features/analysis/scm/bitbucket/BitbucketSCMLib.ts
 import { setTimeout as setTimeout3 } from "timers/promises";
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 function getUserAndPassword(token) {
   const [username, password] = token.split(":");
-  const safePasswordAndUsername = z20.object({ username: z20.string(), password: z20.string() }).parse({ username, password });
+  const safePasswordAndUsername = z21.object({ username: z21.string(), password: z21.string() }).parse({ username, password });
   return {
     username: safePasswordAndUsername.username,
     password: safePasswordAndUsername.password
@@ -7773,7 +7991,7 @@ var BitbucketSCMLib = class extends SCMLib {
         return { username, password, authType };
       }
       case "token": {
-        return { authType, token: z20.string().parse(this.accessToken) };
+        return { authType, token: z21.string().parse(this.accessToken) };
       }
       case "public":
         return { authType };
@@ -7787,7 +8005,7 @@ var BitbucketSCMLib = class extends SCMLib {
           ...params,
           repoUrl: this.url
         });
-        return String(z20.number().parse(pullRequestRes.id));
+        return String(z21.number().parse(pullRequestRes.id));
       } catch (e) {
         console.warn(
           `error creating pull request for BB. Try number ${String(i + 1).replace(/\n|\r/g, "")}`,
@@ -7872,7 +8090,7 @@ var BitbucketSCMLib = class extends SCMLib {
   async getUsername() {
     this._validateAccessToken();
     const res = await this.bitbucketSdk.getUser();
-    return z20.string().parse(res["username"]);
+    return z21.string().parse(res["username"]);
   }
   async getSubmitRequestStatus(_scmSubmitRequestId) {
     this._validateAccessTokenAndUrl();
@@ -7898,7 +8116,7 @@ var BitbucketSCMLib = class extends SCMLib {
   async getRepoDefaultBranch() {
     this._validateUrl();
     const repoRes = await this.bitbucketSdk.getRepo({ repoUrl: this.url });
-    return z20.string().parse(repoRes.mainbranch?.name);
+    return z21.string().parse(repoRes.mainbranch?.name);
   }
   getSubmitRequestUrl(submitRequestId) {
     this._validateUrl();
@@ -7964,7 +8182,7 @@ var REPORT_DEFAULT_FILE_NAME = "report.json";
 init_env();
 
 // src/features/analysis/scm/github/GithubSCMLib.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 init_client_generates();
 
 // src/features/analysis/scm/utils/cursorValidation.ts
@@ -8949,7 +9167,7 @@ var GithubSCMLib = class extends SCMLib {
       owner,
       repo
     });
-    return z21.string().parse(prRes.data);
+    return z22.string().parse(prRes.data);
   }
   async getRepoList(_scmOrg) {
     this._validateAccessToken();
@@ -9402,11 +9620,11 @@ var contextLogger = {
 init_env();
 
 // src/features/analysis/scm/gitlab/types.ts
-import { z as z22 } from "zod";
-var GitlabAuthResultZ = z22.object({
-  access_token: z22.string(),
-  token_type: z22.string(),
-  refresh_token: z22.string()
+import { z as z23 } from "zod";
+var GitlabAuthResultZ = z23.object({
+  access_token: z23.string(),
+  token_type: z23.string(),
+  refresh_token: z23.string()
 });
 
 // src/features/analysis/scm/gitlab/gitlab.ts
@@ -10442,7 +10660,7 @@ var GitlabSCMLib = class extends SCMLib {
 };
 
 // src/features/analysis/scm/scmFactory.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/features/analysis/scm/StubSCMLib.ts
 var StubSCMLib = class extends SCMLib {
@@ -10579,7 +10797,7 @@ async function createScmLib({ url, accessToken, scmType, scmOrg }, { propagateEx
     if (e instanceof InvalidRepoUrlError && url) {
       throw new RepoNoTokenAccessError(
         "no access to repo",
-        scmLibScmTypeToScmType[z23.nativeEnum(ScmLibScmType).parse(scmType)]
+        scmLibScmTypeToScmType[z24.nativeEnum(ScmLibScmType).parse(scmType)]
       );
     }
     console.error(`error validating scm: ${scmType} `, e);
@@ -11169,7 +11387,7 @@ import path6 from "path";
 import chalk from "chalk";
 import Debug4 from "debug";
 import * as dotenv from "dotenv";
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var debug5 = Debug4("mobbdev:constants");
 var runtimeConfigPath = path6.join(
   getModuleRootDir(),
@@ -11214,17 +11432,17 @@ var scannerToVulnerabilityReportVendorEnum = {
   [SCANNERS.Semgrep]: "semgrep" /* Semgrep */,
   [SCANNERS.Datadog]: "datadog" /* Datadog */
 };
-var SupportedScannersZ = z24.enum([SCANNERS.Checkmarx, SCANNERS.Snyk]);
-var envVariablesSchema = z24.object({
+var SupportedScannersZ = z25.enum([SCANNERS.Checkmarx, SCANNERS.Snyk]);
+var envVariablesSchema = z25.object({
   // These have safe defaults for production - the VS Code extension passes explicit URLs
-  WEB_APP_URL: z24.string().optional().default(DEFAULT_WEB_APP_URL),
-  API_URL: z24.string().optional().default(DEFAULT_API_URL),
+  WEB_APP_URL: z25.string().optional().default(DEFAULT_WEB_APP_URL),
+  API_URL: z25.string().optional().default(DEFAULT_API_URL),
   // These are only needed for local development with Hasura
-  HASURA_ACCESS_KEY: z24.string().optional().default(""),
-  LOCAL_GRAPHQL_ENDPOINT: z24.string().optional().default(""),
+  HASURA_ACCESS_KEY: z25.string().optional().default(""),
+  LOCAL_GRAPHQL_ENDPOINT: z25.string().optional().default(""),
   // Proxy settings
-  HTTP_PROXY: z24.string().optional().default(""),
-  HTTPS_PROXY: z24.string().optional().default("")
+  HTTP_PROXY: z25.string().optional().default(""),
+  HTTPS_PROXY: z25.string().optional().default("")
 });
 var envVariables = envVariablesSchema.parse(process.env);
 debug5("config %o", envVariables);
@@ -11469,17 +11687,17 @@ import path9 from "path";
 import { env as env2 } from "process";
 import { pipeline } from "stream/promises";
 import chalk6 from "chalk";
-import Debug18 from "debug";
+import Debug19 from "debug";
 import extract from "extract-zip";
 import { createSpinner as createSpinner4 } from "nanospinner";
 import fetch4 from "node-fetch";
 import open3 from "open";
 import tmp2 from "tmp";
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 
 // src/commands/handleMobbLogin.ts
 import chalk3 from "chalk";
-import Debug6 from "debug";
+import Debug7 from "debug";
 
 // src/commands/AuthManager.ts
 import crypto from "crypto";
@@ -11487,10 +11705,8 @@ import os from "os";
 import open from "open";
 
 // src/features/analysis/graphql/gql.ts
-import fetchOrig from "cross-fetch";
-import Debug5 from "debug";
+import Debug6 from "debug";
 import { GraphQLClient } from "graphql-request";
-import { HttpsProxyAgent } from "https-proxy-agent";
 import { v4 as uuidv4 } from "uuid";
 
 // src/mcp/core/Errors.ts
@@ -11565,6 +11781,71 @@ var _ReportDigestError = class _ReportDigestError extends Error {
 __publicField(_ReportDigestError, "defaultMessage", "\u{1F575}\uFE0F\u200D\u2642\uFE0F Digesting report failed. Please verify that the file provided is of a valid supported report format.");
 var ReportDigestError = _ReportDigestError;
 
+// src/utils/proxy.ts
+import fetchOrig from "cross-fetch";
+import Debug5 from "debug";
+import { HttpsProxyAgent } from "https-proxy-agent";
+
+// src/utils/url.ts
+function httpToWsUrl(url) {
+  const parsed = new URL(url);
+  parsed.protocol = parsed.protocol === "https:" ? "wss:" : "ws:";
+  return parsed.toString();
+}
+
+// src/utils/proxy.ts
+var debug6 = Debug5("mobbdev:proxy");
+function getHttpProxy() {
+  return process.env["HTTPS_PROXY"] || process.env["HTTP_PROXY"] || "";
+}
+function getHttpProxyOnly() {
+  return process.env["HTTP_PROXY"] || "";
+}
+function getProxyAgent(url) {
+  try {
+    const parsedUrl = new URL(url);
+    const hostname = parsedUrl.hostname.toLowerCase();
+    if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]") {
+      debug6("Skipping proxy for localhost URL: %s", url);
+      return void 0;
+    }
+    const noProxy = process.env["NO_PROXY"] || process.env["no_proxy"];
+    if (noProxy) {
+      const noProxyList = noProxy.split(",").map((h) => h.trim().toLowerCase());
+      if (noProxyList.includes(hostname) || noProxyList.includes("*")) {
+        debug6("Skipping proxy due to NO_PROXY for: %s", url);
+        return void 0;
+      }
+    }
+    const isHttp = parsedUrl.protocol === "http:";
+    const isHttps = parsedUrl.protocol === "https:";
+    const proxy = isHttps ? getHttpProxy() : isHttp ? getHttpProxyOnly() : null;
+    if (proxy) {
+      debug6("Using proxy %s", proxy);
+      debug6("Proxy agent %o", proxy);
+      return new HttpsProxyAgent(proxy);
+    }
+  } catch (err) {
+    debug6(`Skipping proxy for ${url}. Reason: ${err.message}`);
+  }
+  return void 0;
+}
+var fetchWithProxy = (url, options = {}) => {
+  try {
+    const agent = getProxyAgent(url.toString());
+    if (agent) {
+      return fetchOrig(url, {
+        ...options,
+        // @ts-expect-error Node-fetch doesn't type 'agent', but it's valid
+        agent
+      });
+    }
+  } catch (err) {
+    debug6(`Skipping proxy for ${url}. Reason: ${err.message}`);
+  }
+  return fetchOrig(url, options);
+};
+
 // src/utils/subscribe/subscribe.ts
 import { createClient } from "graphql-ws";
 import WebsocketNode from "isomorphic-ws";
@@ -11593,11 +11874,11 @@ function getGraphQlHeaders(options) {
 }
 
 // src/utils/subscribe/subscribe.ts
-var DEFAULT_API_URL2 = "https://api.mobb.ai/v1/graphql";
+var DEFAULT_API_URL2 = "wss://api.mobb.ai/v1/graphql";
 var SUBSCRIPTION_TIMEOUT_MS = 30 * 60 * 1e3;
 function createWSClient(options) {
-  const url = options.url || (process.env["API_URL"] || DEFAULT_API_URL2).replace("http", "ws");
-  const websocketImpl = options.websocket || (typeof WebSocket !== "undefined" ? WebSocket : WebsocketNode);
+  const url = options.url || (process.env["API_URL"] ? httpToWsUrl(process.env["API_URL"]) : DEFAULT_API_URL2);
+  const websocketImpl = options.websocket || WebsocketNode;
   const CustomWebSocket = options.proxyAgent ? (
     // biome-ignore lint/suspicious/noExplicitAny: Dynamic WebSocket extension requires any cast for cross-platform compatibility
     class extends websocketImpl {
@@ -11700,124 +11981,80 @@ init_client_generates();
 
 // src/features/analysis/graphql/types.ts
 init_client_generates();
-import { z as z25 } from "zod";
-var VulnerabilityReportIssueCodeNodeZ = z25.object({
-  vulnerabilityReportIssueId: z25.string(),
-  path: z25.string(),
-  startLine: z25.number(),
-  vulnerabilityReportIssue: z25.object({
-    fixId: z25.string(),
-    category: z25.nativeEnum(Vulnerability_Report_Issue_Category_Enum),
-    safeIssueType: z25.string(),
-    vulnerabilityReportIssueTags: z25.array(
-      z25.object({
-        tag: z25.nativeEnum(Vulnerability_Report_Issue_Tag_Enum)
+import { z as z26 } from "zod";
+var VulnerabilityReportIssueCodeNodeZ = z26.object({
+  vulnerabilityReportIssueId: z26.string(),
+  path: z26.string(),
+  startLine: z26.number(),
+  vulnerabilityReportIssue: z26.object({
+    fixId: z26.string(),
+    category: z26.nativeEnum(Vulnerability_Report_Issue_Category_Enum),
+    safeIssueType: z26.string(),
+    vulnerabilityReportIssueTags: z26.array(
+      z26.object({
+        tag: z26.nativeEnum(Vulnerability_Report_Issue_Tag_Enum)
       })
     )
   })
 });
-var VulnerabilityReportIssueNoFixCodeNodeZ = z25.object({
-  vulnerabilityReportIssues: z25.array(
-    z25.object({
-      id: z25.string(),
-      fixId: z25.string().nullable(),
-      category: z25.nativeEnum(Vulnerability_Report_Issue_Category_Enum),
-      safeIssueType: z25.string(),
-      fpId: z25.string().uuid().nullable(),
-      codeNodes: z25.array(
-        z25.object({
-          path: z25.string(),
-          startLine: z25.number()
+var VulnerabilityReportIssueNoFixCodeNodeZ = z26.object({
+  vulnerabilityReportIssues: z26.array(
+    z26.object({
+      id: z26.string(),
+      fixId: z26.string().nullable(),
+      category: z26.nativeEnum(Vulnerability_Report_Issue_Category_Enum),
+      safeIssueType: z26.string(),
+      fpId: z26.string().uuid().nullable(),
+      codeNodes: z26.array(
+        z26.object({
+          path: z26.string(),
+          startLine: z26.number()
         })
       ),
-      vulnerabilityReportIssueTags: z25.array(
-        z25.object({
-          tag: z25.nativeEnum(Vulnerability_Report_Issue_Tag_Enum)
+      vulnerabilityReportIssueTags: z26.array(
+        z26.object({
+          tag: z26.nativeEnum(Vulnerability_Report_Issue_Tag_Enum)
         })
       )
     })
   )
 });
-var GetVulByNodesMetadataZ = z25.object({
-  vulnerabilityReportIssueCodeNodes: z25.array(VulnerabilityReportIssueCodeNodeZ),
-  nonFixablePrVuls: z25.object({
-    aggregate: z25.object({
-      count: z25.number()
+var GetVulByNodesMetadataZ = z26.object({
+  vulnerabilityReportIssueCodeNodes: z26.array(VulnerabilityReportIssueCodeNodeZ),
+  nonFixablePrVuls: z26.object({
+    aggregate: z26.object({
+      count: z26.number()
     })
   }),
-  fixablePrVuls: z25.object({
-    aggregate: z25.object({
-      count: z25.number()
+  fixablePrVuls: z26.object({
+    aggregate: z26.object({
+      count: z26.number()
     })
   }),
-  totalScanVulnerabilities: z25.object({
-    aggregate: z25.object({
-      count: z25.number()
+  totalScanVulnerabilities: z26.object({
+    aggregate: z26.object({
+      count: z26.number()
     })
   }),
-  irrelevantVulnerabilityReportIssue: z25.array(
+  irrelevantVulnerabilityReportIssue: z26.array(
     VulnerabilityReportIssueNoFixCodeNodeZ
   )
 });
 
 // src/features/analysis/graphql/gql.ts
-var debug6 = Debug5("mobbdev:gql");
+var debug7 = Debug6("mobbdev:gql");
 var API_KEY_HEADER_NAME = "x-mobb-key";
 var REPORT_STATE_CHECK_DELAY = 5 * 1e3;
-function getProxyAgent(url) {
-  try {
-    const parsedUrl = new URL(url);
-    const hostname = parsedUrl.hostname.toLowerCase();
-    if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]") {
-      debug6("Skipping proxy for localhost URL: %s", url);
-      return void 0;
-    }
-    const noProxy = process.env["NO_PROXY"] || process.env["no_proxy"];
-    if (noProxy) {
-      const noProxyList = noProxy.split(",").map((h) => h.trim().toLowerCase());
-      if (noProxyList.includes(hostname) || noProxyList.includes("*")) {
-        debug6("Skipping proxy due to NO_PROXY for: %s", url);
-        return void 0;
-      }
-    }
-    const isHttp = parsedUrl.protocol === "http:";
-    const isHttps = parsedUrl.protocol === "https:";
-    const proxy = isHttps ? HTTPS_PROXY || HTTP_PROXY : isHttp ? HTTP_PROXY : null;
-    if (proxy) {
-      debug6("Using proxy %s", proxy);
-      debug6("Proxy agent %o", proxy);
-      return new HttpsProxyAgent(proxy);
-    }
-  } catch (err) {
-    debug6(`Skipping proxy for ${url}. Reason: ${err.message}`);
-  }
-  return void 0;
-}
-var fetchWithProxy = (url, options = {}) => {
-  try {
-    const agent = getProxyAgent(url.toString());
-    if (agent) {
-      return fetchOrig(url, {
-        ...options,
-        // @ts-expect-error Node-fetch doesn't type 'agent', but it's valid
-        agent
-      });
-    }
-  } catch (err) {
-    debug6(`Skipping proxy for ${url}. Reason: ${err.message}`);
-  }
-  return fetchOrig(url, options);
-};
 var GQLClient = class {
   constructor(args) {
     __publicField(this, "_client");
     __publicField(this, "_clientSdk");
     __publicField(this, "_apiUrl");
     __publicField(this, "_auth");
-    debug6(`init with  ${args}`);
+    debug7(`init with  ${args}`);
     this._auth = args;
     this._apiUrl = args.apiUrl || API_URL;
-    debug6(
+    debug7(
       "GQLClient constructor: resolved apiUrl=%s (from param: %s)",
       this._apiUrl,
       args.apiUrl || "fallback to API_URL constant"
@@ -11829,7 +12066,7 @@ var GQLClient = class {
       fetch: fetchWithProxy,
       requestMiddleware: (request) => {
         const requestId = uuidv4();
-        debug6(
+        debug7(
           `sending API request with id: ${requestId} and with request: ${request.body}`
         );
         return {
@@ -11866,7 +12103,7 @@ var GQLClient = class {
       await this.getUserInfo();
     } catch (e) {
       if (e?.toString().startsWith("FetchError")) {
-        debug6("verify connection failed %o", e);
+        debug7("verify connection failed %o", e);
         return false;
       }
     }
@@ -11878,7 +12115,7 @@ var GQLClient = class {
     try {
       info = await this.getUserInfo();
     } catch (e) {
-      debug6("verify token failed %o", e);
+      debug7("verify token failed %o", e);
       return false;
     }
     return info?.email || true;
@@ -11939,7 +12176,7 @@ var GQLClient = class {
     try {
       await this._clientSdk.CreateCommunityUser();
     } catch (e) {
-      debug6("create community user failed %o", e);
+      debug7("create community user failed %o", e);
     }
   }
   async updateScmToken(args) {
@@ -12119,11 +12356,13 @@ var GQLClient = class {
           this._auth.type === "apiKey" ? {
             apiKey: this._auth.apiKey,
             type: "apiKey",
+            url: httpToWsUrl(this._apiUrl),
             timeoutInMs: params.timeoutInMs,
             proxyAgent: getProxyAgent(this._apiUrl)
           } : {
             token: this._auth.token,
             type: "token",
+            url: httpToWsUrl(this._apiUrl),
             timeoutInMs: params.timeoutInMs,
             proxyAgent: getProxyAgent(this._apiUrl)
           }
@@ -12136,7 +12375,7 @@ var GQLClient = class {
     const startTime = Date.now();
     const maxDuration = timeoutInMs ?? 30 * 60 * 1e3;
     const pollingIntervalSec = REPORT_STATE_CHECK_DELAY / 1e3;
-    debug6(
+    debug7(
       `[pollForAnalysisState] Starting polling for analysis ${analysisId}, target states: ${callbackStates.join(", ")}, interval: ${pollingIntervalSec}s`
     );
     let isPolling = true;
@@ -12145,7 +12384,7 @@ var GQLClient = class {
       pollCount++;
       const elapsedSec = Math.round((Date.now() - startTime) / 1e3);
       if (Date.now() - startTime > maxDuration) {
-        debug6(
+        debug7(
           `[pollForAnalysisState] Timeout expired after ${pollCount} polls (${elapsedSec}s)`
         );
         throw new ReportDigestError(
@@ -12153,20 +12392,20 @@ var GQLClient = class {
           `Analysis timed out after ${Math.round(maxDuration / 6e4)} minutes. Please try again or check the Mobb platform for status.`
         );
       }
-      debug6(
+      debug7(
         `[pollForAnalysisState] Poll #${pollCount} (elapsed: ${elapsedSec}s) - fetching analysis state...`
       );
       const analysis = await this.getAnalysis(analysisId);
-      debug6(
+      debug7(
         `[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}`);
+        debug7(`[pollForAnalysisState] Analysis failed: ${errorMessage}`);
         throw new ReportDigestError(errorMessage, analysis.failReason ?? "");
       }
       if (callbackStates.includes(analysis.state)) {
-        debug6(
+        debug7(
           `[pollForAnalysisState] Target state reached: ${analysis.state} after ${pollCount} polls (${elapsedSec}s)`
         );
         await callback(analysis.id);
@@ -12179,7 +12418,7 @@ var GQLClient = class {
           }
         };
       }
-      debug6(
+      debug7(
         `[pollForAnalysisState] State ${analysis.state} not in target states, waiting ${pollingIntervalSec}s before next poll...`
       );
       await sleep(REPORT_STATE_CHECK_DELAY);
@@ -12468,7 +12707,7 @@ var AuthManager = class {
 };
 
 // src/commands/handleMobbLogin.ts
-var debug7 = Debug6("mobbdev:commands");
+var debug8 = Debug7("mobbdev:commands");
 var LOGIN_MAX_WAIT2 = 10 * 60 * 1e3;
 var LOGIN_CHECK_DELAY2 = 5 * 1e3;
 var MOBB_LOGIN_REQUIRED_MSG = `\u{1F513} Login to Mobb is Required, you will be redirected to our login page, once the authorization is complete return to this prompt, ${chalk3.bgBlue(
@@ -12480,7 +12719,7 @@ async function getAuthenticatedGQLClient({
   apiUrl,
   webAppUrl
 }) {
-  debug7(
+  debug8(
     "getAuthenticatedGQLClient called with: apiUrl=%s, webAppUrl=%s",
     apiUrl || "undefined",
     webAppUrl || "undefined"
@@ -12503,7 +12742,7 @@ async function handleMobbLogin({
   webAppUrl,
   loginContext
 }) {
-  debug7(
+  debug8(
     "handleMobbLogin: resolved URLs - apiUrl=%s (from param: %s), webAppUrl=%s (from param: %s)",
     apiUrl || "fallback",
     apiUrl || "fallback",
@@ -12522,7 +12761,7 @@ async function handleMobbLogin({
       return authManager.getGQLClient();
     }
   } catch (error) {
-    debug7("Authentication check failed:", error);
+    debug8("Authentication check failed:", error);
   }
   if (apiKey) {
     createSpinner5().start().error({
@@ -12569,12 +12808,12 @@ async function handleMobbLogin({
 }
 
 // src/features/analysis/add_fix_comments_for_pr/add_fix_comments_for_pr.ts
-import Debug10 from "debug";
+import Debug11 from "debug";
 
 // src/features/analysis/add_fix_comments_for_pr/utils/utils.ts
-import Debug9 from "debug";
+import Debug10 from "debug";
 import parseDiff from "parse-diff";
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 
 // src/features/analysis/utils/by_key.ts
 function keyBy(array, keyBy2) {
@@ -12584,9 +12823,9 @@ function keyBy(array, keyBy2) {
 }
 
 // src/features/analysis/utils/send_report.ts
-import Debug7 from "debug";
+import Debug8 from "debug";
 init_client_generates();
-var debug8 = Debug7("mobbdev:index");
+var debug9 = Debug8("mobbdev:index");
 async function sendReport({
   spinner,
   submitVulnerabilityReportVariables,
@@ -12598,7 +12837,7 @@ async function sendReport({
       submitVulnerabilityReportVariables
     );
     if (submitRes.submitVulnerabilityReport.__typename !== "VulnerabilityReport") {
-      debug8("error submit vul report %s", submitRes);
+      debug9("error submit vul report %s", submitRes);
       throw new Error("\u{1F575}\uFE0F\u200D\u2642\uFE0F Mobb analysis failed");
     }
     spinner.update({ text: progressMassages.processingVulnerabilityReport });
@@ -12610,7 +12849,7 @@ async function sendReport({
       "Finished" /* Finished */
     ];
     if (polling) {
-      debug8("[sendReport] Using POLLING mode for analysis state updates");
+      debug9("[sendReport] Using POLLING mode for analysis state updates");
       await gqlClient.pollForAnalysisState({
         analysisId: submitRes.submitVulnerabilityReport.fixReportId,
         callback,
@@ -12618,7 +12857,7 @@ async function sendReport({
         timeoutInMs: VUL_REPORT_DIGEST_TIMEOUT_MS
       });
     } else {
-      debug8("[sendReport] Using WEBSOCKET mode for analysis state updates");
+      debug9("[sendReport] Using WEBSOCKET mode for analysis state updates");
       await gqlClient.subscribeToAnalysis({
         subscribeToAnalysisParams: {
           analysisId: submitRes.submitVulnerabilityReport.fixReportId
@@ -12661,10 +12900,10 @@ var scannerToFriendlyString = {
 };
 
 // src/features/analysis/add_fix_comments_for_pr/utils/buildCommentBody.ts
-import Debug8 from "debug";
-import { z as z26 } from "zod";
+import Debug9 from "debug";
+import { z as z27 } from "zod";
 init_client_generates();
-var debug9 = Debug8("mobbdev:handle-finished-analysis");
+var debug10 = Debug9("mobbdev:handle-finished-analysis");
 var getCommitFixButton = (commitUrl) => `<a href="${commitUrl}"><img src=${COMMIT_FIX_SVG}></a>`;
 function buildFixCommentBody({
   fix,
@@ -12716,14 +12955,14 @@ function buildFixCommentBody({
   });
   const issueType = getIssueTypeFriendlyString(fix.safeIssueType);
   const title = `# ${MobbIconMarkdown} ${issueType} fix is ready`;
-  const validFixParseRes = z26.object({
+  const validFixParseRes = z27.object({
     patchAndQuestions: PatchAndQuestionsZ,
-    safeIssueLanguage: z26.nativeEnum(IssueLanguage_Enum),
-    severityText: z26.nativeEnum(Vulnerability_Severity_Enum),
-    safeIssueType: z26.nativeEnum(IssueType_Enum)
+    safeIssueLanguage: z27.nativeEnum(IssueLanguage_Enum),
+    severityText: z27.nativeEnum(Vulnerability_Severity_Enum),
+    safeIssueType: z27.nativeEnum(IssueType_Enum)
   }).safeParse(fix);
   if (!validFixParseRes.success) {
-    debug9(
+    debug10(
       `fix ${fixId} has custom issue type or language, therefore the commit description will not be added`,
       validFixParseRes.error
     );
@@ -12787,7 +13026,7 @@ ${issuePageLink}`;
 }
 
 // src/features/analysis/add_fix_comments_for_pr/utils/utils.ts
-var debug10 = Debug9("mobbdev:handle-finished-analysis");
+var debug11 = Debug10("mobbdev:handle-finished-analysis");
 function calculateRanges(integers) {
   if (integers.length === 0) {
     return [];
@@ -12821,7 +13060,7 @@ function deleteAllPreviousComments({
     try {
       return scm.deleteComment({ comment_id: comment.id });
     } catch (e) {
-      debug10("delete comment failed %s", e);
+      debug11("delete comment failed %s", e);
       return Promise.resolve();
     }
   });
@@ -12837,7 +13076,7 @@ function deleteAllPreviousGeneralPrComments(params) {
     try {
       return scm.deleteGeneralPrComment({ commentId: comment.id });
     } catch (e) {
-      debug10("delete comment failed %s", e);
+      debug11("delete comment failed %s", e);
       return Promise.resolve();
     }
   });
@@ -12954,7 +13193,7 @@ async function getRelevantVulenrabilitiesFromDiff(params) {
     });
     const lineAddedRanges = calculateRanges(fileNumbers);
     const fileFilter = {
-      path: z27.string().parse(file.to),
+      path: z28.string().parse(file.to),
       ranges: lineAddedRanges.map(([startLine, endLine]) => ({
         endLine,
         startLine
@@ -12981,7 +13220,7 @@ async function postAnalysisInsightComment(params) {
     fixablePrVuls,
     nonFixablePrVuls
   } = prVulenrabilities;
-  debug10({
+  debug11({
     fixablePrVuls,
     nonFixablePrVuls,
     vulnerabilitiesOutsidePr,
@@ -13036,7 +13275,7 @@ ${contactUsMarkdown}`;
 }
 
 // src/features/analysis/add_fix_comments_for_pr/add_fix_comments_for_pr.ts
-var debug11 = Debug10("mobbdev:handle-finished-analysis");
+var debug12 = Debug11("mobbdev:handle-finished-analysis");
 async function addFixCommentsForPr({
   analysisId,
   scm: _scm,
@@ -13048,7 +13287,7 @@ async function addFixCommentsForPr({
   }
   const scm = _scm;
   const getAnalysisRes = await gqlClient.getAnalysis(analysisId);
-  debug11("getAnalysis %o", getAnalysisRes);
+  debug12("getAnalysis %o", getAnalysisRes);
   const {
     vulnerabilityReport: {
       projectId,
@@ -13158,8 +13397,8 @@ ${contextString}` : description;
 
 // src/features/analysis/auto_pr_handler.ts
 init_client_generates();
-import Debug11 from "debug";
-var debug12 = Debug11("mobbdev:handleAutoPr");
+import Debug12 from "debug";
+var debug13 = Debug12("mobbdev:handleAutoPr");
 async function handleAutoPr(params) {
   const {
     gqlClient,
@@ -13180,7 +13419,7 @@ async function handleAutoPr(params) {
       prId,
       prStrategy: createOnePr ? "CONDENSE" /* Condense */ : "SPREAD" /* Spread */
     });
-    debug12("auto pr analysis res %o", autoPrAnalysisRes);
+    debug13("auto pr analysis res %o", autoPrAnalysisRes);
     if (autoPrAnalysisRes.autoPrAnalysis?.__typename === "AutoPrError") {
       createAutoPrSpinner.error({
         text: `\u{1F504} Automatic pull request failed - ${autoPrAnalysisRes.autoPrAnalysis.error}`
@@ -13202,14 +13441,14 @@ async function handleAutoPr(params) {
   };
   const callbackStates = ["Finished" /* Finished */];
   if (polling) {
-    debug12("[handleAutoPr] Using POLLING mode for analysis state updates");
+    debug13("[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");
+    debug13("[handleAutoPr] Using WEBSOCKET mode for analysis state updates");
     return await gqlClient.subscribeToAnalysis({
       subscribeToAnalysisParams: {
         analysisId
@@ -13222,15 +13461,15 @@ async function handleAutoPr(params) {
 
 // src/features/analysis/git.ts
 init_GitService();
-import Debug12 from "debug";
-var debug13 = Debug12("mobbdev:git");
+import Debug13 from "debug";
+var debug14 = Debug13("mobbdev:git");
 async function getGitInfo(srcDirPath) {
-  debug13("getting git info for %s", srcDirPath);
+  debug14("getting git info for %s", srcDirPath);
   const gitService = new GitService(srcDirPath);
   try {
     const validationResult = await gitService.validateRepository();
     if (!validationResult.isValid) {
-      debug13("folder is not a git repo");
+      debug14("folder is not a git repo");
       return {
         success: false,
         hash: void 0,
@@ -13245,9 +13484,9 @@ async function getGitInfo(srcDirPath) {
     };
   } catch (e) {
     if (e instanceof Error) {
-      debug13("failed to run git %o", e);
+      debug14("failed to run git %o", e);
       if (e.message.includes(" spawn ")) {
-        debug13("git cli not installed");
+        debug14("git cli not installed");
       } else {
         throw e;
       }
@@ -13261,20 +13500,20 @@ init_configs();
 import fs9 from "fs";
 import path7 from "path";
 import AdmZip from "adm-zip";
-import Debug13 from "debug";
+import Debug14 from "debug";
 import { globby } from "globby";
 import { isBinary as isBinary2 } from "istextorbinary";
 import { simpleGit as simpleGit3 } from "simple-git";
 import { parseStringPromise } from "xml2js";
-import { z as z28 } from "zod";
-var debug14 = Debug13("mobbdev:pack");
-var FPR_SOURCE_CODE_FILE_MAPPING_SCHEMA = z28.object({
-  properties: z28.object({
-    entry: z28.array(
-      z28.object({
-        _: z28.string(),
-        $: z28.object({
-          key: z28.string()
+import { z as z29 } from "zod";
+var debug15 = Debug14("mobbdev:pack");
+var FPR_SOURCE_CODE_FILE_MAPPING_SCHEMA = z29.object({
+  properties: z29.object({
+    entry: z29.array(
+      z29.object({
+        _: z29.string(),
+        $: z29.object({
+          key: z29.string()
         })
       })
     )
@@ -13289,7 +13528,7 @@ function getManifestFilesSuffixes() {
   return ["package.json", "pom.xml"];
 }
 async function pack(srcDirPath, vulnFiles, isIncludeAllFiles = false) {
-  debug14("pack folder %s", srcDirPath);
+  debug15("pack folder %s", srcDirPath);
   let git = void 0;
   try {
     git = simpleGit3({
@@ -13299,13 +13538,13 @@ async function pack(srcDirPath, vulnFiles, isIncludeAllFiles = false) {
     });
     await git.status();
   } catch (e) {
-    debug14("failed to run git %o", e);
+    debug15("failed to run git %o", e);
     git = void 0;
     if (e instanceof Error) {
       if (e.message.includes(" spawn ")) {
-        debug14("git cli not installed");
+        debug15("git cli not installed");
       } else if (e.message.includes("not a git repository")) {
-        debug14("folder is not a git repo");
+        debug15("folder is not a git repo");
       } else {
         throw e;
       }
@@ -13320,9 +13559,9 @@ async function pack(srcDirPath, vulnFiles, isIncludeAllFiles = false) {
     followSymbolicLinks: false,
     dot: true
   });
-  debug14("files found %d", filepaths.length);
+  debug15("files found %d", filepaths.length);
   const zip = new AdmZip();
-  debug14("compressing files");
+  debug15("compressing files");
   for (const filepath of filepaths) {
     const absFilepath = path7.join(srcDirPath, filepath.toString());
     if (!isIncludeAllFiles) {
@@ -13331,12 +13570,12 @@ async function pack(srcDirPath, vulnFiles, isIncludeAllFiles = false) {
         absFilepath.toString().replaceAll(path7.win32.sep, path7.posix.sep),
         vulnFiles
       )) {
-        debug14("ignoring %s because it is not a vulnerability file", filepath);
+        debug15("ignoring %s because it is not a vulnerability file", filepath);
         continue;
       }
     }
     if (fs9.lstatSync(absFilepath).size > MCP_MAX_FILE_SIZE) {
-      debug14("ignoring %s because the size is > 5MB", filepath);
+      debug15("ignoring %s because the size is > 5MB", filepath);
       continue;
     }
     let data;
@@ -13350,16 +13589,16 @@ async function pack(srcDirPath, vulnFiles, isIncludeAllFiles = false) {
       data = fs9.readFileSync(absFilepath);
     }
     if (isBinary2(null, data)) {
-      debug14("ignoring %s because is seems to be a binary file", filepath);
+      debug15("ignoring %s because is seems to be a binary file", filepath);
       continue;
     }
     zip.addFile(filepath.toString(), data);
   }
-  debug14("get zip file buffer");
+  debug15("get zip file buffer");
   return zip.toBuffer();
 }
 async function repackFpr(fprPath) {
-  debug14("repack fpr file %s", fprPath);
+  debug15("repack fpr file %s", fprPath);
   const zipIn = new AdmZip(fprPath);
   const zipOut = new AdmZip();
   const mappingXML = zipIn.readAsText("src-archive/index.xml", "utf-8");
@@ -13374,7 +13613,7 @@ async function repackFpr(fprPath) {
       zipOut.addFile(realPath, buf);
     }
   }
-  debug14("get repacked zip file buffer");
+  debug15("get repacked zip file buffer");
   return zipOut.toBuffer();
 }
 
@@ -13445,7 +13684,7 @@ async function snykArticlePrompt() {
 // src/features/analysis/scanners/checkmarx.ts
 import { createRequire } from "module";
 import chalk4 from "chalk";
-import Debug15 from "debug";
+import Debug16 from "debug";
 import { existsSync } from "fs";
 import { createSpinner as createSpinner2 } from "nanospinner";
 import { type } from "os";
@@ -13457,7 +13696,7 @@ var cxOperatingSystemSupportMessage = `Your operating system does not support ch
 
 // src/utils/child_process.ts
 import cp from "child_process";
-import Debug14 from "debug";
+import Debug15 from "debug";
 import * as process2 from "process";
 function createFork({ args, processPath, name }, options) {
   const child = cp.fork(processPath, args, {
@@ -13475,16 +13714,16 @@ function createSpawn({ args, processPath, name, cwd }, options) {
   return createChildProcess({ childProcess: child, name }, options);
 }
 function createChildProcess({ childProcess, name }, options) {
-  const debug20 = Debug14(`mobbdev:${name}`);
+  const debug21 = Debug15(`mobbdev:${name}`);
   const { display } = options;
   return new Promise((resolve, reject) => {
     let out = "";
     const onData = (chunk) => {
-      debug20(`chunk received from ${name} std ${chunk}`);
+      debug21(`chunk received from ${name} std ${chunk}`);
       out += chunk;
     };
     if (!childProcess?.stdout || !childProcess?.stderr) {
-      debug20(`unable to fork ${name}`);
+      debug21(`unable to fork ${name}`);
       reject(new Error(`unable to fork ${name}`));
     }
     childProcess.stdout?.on("data", onData);
@@ -13494,18 +13733,18 @@ function createChildProcess({ childProcess, name }, options) {
       childProcess.stderr?.pipe(process2.stderr);
     }
     childProcess.on("exit", (code) => {
-      debug20(`${name} exit code ${code}`);
+      debug21(`${name} exit code ${code}`);
       resolve({ message: out, code });
     });
     childProcess.on("error", (err) => {
-      debug20(`${name} error %o`, err);
+      debug21(`${name} error %o`, err);
       reject(err);
     });
   });
 }
 
 // src/features/analysis/scanners/checkmarx.ts
-var debug15 = Debug15("mobbdev:checkmarx");
+var debug16 = Debug16("mobbdev:checkmarx");
 var moduleUrl;
 if (typeof __filename !== "undefined") {
   moduleUrl = __filename;
@@ -13564,14 +13803,14 @@ function validateCheckmarxInstallation() {
   existsSync(getCheckmarxPath());
 }
 async function forkCheckmarx(args, { display }) {
-  debug15("fork checkmarx with args %o %s", args.join(" "), display);
+  debug16("fork checkmarx with args %o %s", args.join(" "), display);
   return createSpawn(
     { args, processPath: getCheckmarxPath(), name: "checkmarx" },
     { display }
   );
 }
 async function getCheckmarxReport({ reportPath, repositoryRoot, branch, projectName }, { skipPrompts = false }) {
-  debug15("get checkmarx report start %s %s", reportPath, repositoryRoot);
+  debug16("get checkmarx report start %s %s", reportPath, repositoryRoot);
   const { code: loginCode } = await forkCheckmarx(VALIDATE_COMMAND, {
     display: false
   });
@@ -13639,10 +13878,10 @@ async function validateCheckamxCredentials() {
 // src/features/analysis/scanners/snyk.ts
 import { createRequire as createRequire2 } from "module";
 import chalk5 from "chalk";
-import Debug16 from "debug";
+import Debug17 from "debug";
 import { createSpinner as createSpinner3 } from "nanospinner";
 import open2 from "open";
-var debug16 = Debug16("mobbdev:snyk");
+var debug17 = Debug17("mobbdev:snyk");
 var moduleUrl2;
 if (typeof __filename !== "undefined") {
   moduleUrl2 = __filename;
@@ -13664,13 +13903,13 @@ if (typeof __filename !== "undefined") {
 var costumeRequire2 = createRequire2(moduleUrl2);
 var SNYK_PATH = costumeRequire2.resolve("snyk/bin/snyk");
 var SNYK_ARTICLE_URL = "https://docs.snyk.io/scan-using-snyk/snyk-code/configure-snyk-code#enable-snyk-code";
-debug16("snyk executable path %s", SNYK_PATH);
+debug17("snyk executable path %s", SNYK_PATH);
 async function forkSnyk(args, { display }) {
-  debug16("fork snyk with args %o %s", args, display);
+  debug17("fork snyk with args %o %s", args, display);
   return createFork({ args, processPath: SNYK_PATH, name: "snyk" }, { display });
 }
 async function getSnykReport(reportPath, repoRoot, { skipPrompts = false }) {
-  debug16("get snyk report start %s %s", reportPath, repoRoot);
+  debug17("get snyk report start %s %s", reportPath, repoRoot);
   const config2 = await forkSnyk(["config"], { display: false });
   const { message: configMessage } = config2;
   if (!configMessage.includes("api: ")) {
@@ -13684,7 +13923,7 @@ async function getSnykReport(reportPath, repoRoot, { skipPrompts = false }) {
     snykLoginSpinner.update({
       text: "\u{1F513} Waiting for Snyk login to complete"
     });
-    debug16("no token in the config %s", config2);
+    debug17("no token in the config %s", config2);
     await forkSnyk(["auth"], { display: true });
     snykLoginSpinner.success({ text: "\u{1F513} Login to Snyk Successful" });
   }
@@ -13694,12 +13933,12 @@ async function getSnykReport(reportPath, repoRoot, { skipPrompts = false }) {
     { display: true }
   );
   if (scanOutput.includes("Snyk Code is not supported for org")) {
-    debug16("snyk code is not enabled %s", scanOutput);
+    debug17("snyk code is not enabled %s", scanOutput);
     snykSpinner.error({ text: "\u{1F50D} Snyk configuration needed" });
     const answer = await snykArticlePrompt();
-    debug16("answer %s", answer);
+    debug17("answer %s", answer);
     if (answer) {
-      debug16("opening the browser");
+      debug17("opening the browser");
       await open2(SNYK_ARTICLE_URL);
     }
     console.log(
@@ -13717,9 +13956,9 @@ async function getSnykReport(reportPath, repoRoot, { skipPrompts = false }) {
 init_client_generates();
 
 // src/features/analysis/upload-file.ts
-import Debug17 from "debug";
+import Debug18 from "debug";
 import fetch3, { File, fileFrom, FormData } from "node-fetch";
-var debug17 = Debug17("mobbdev:upload-file");
+var debug18 = Debug18("mobbdev:upload-file");
 async function uploadFile({
   file,
   url,
@@ -13732,9 +13971,9 @@ async function uploadFile({
   logInfo2(`FileUpload: upload file start ${url}`);
   logInfo2(`FileUpload: upload fields`, uploadFields);
   logInfo2(`FileUpload: upload key ${uploadKey}`);
-  debug17("upload file start %s", url);
-  debug17("upload fields %o", uploadFields);
-  debug17("upload key %s", uploadKey);
+  debug18("upload file start %s", url);
+  debug18("upload fields %o", uploadFields);
+  debug18("upload key %s", uploadKey);
   const form = new FormData();
   Object.entries(uploadFields).forEach(([key, value]) => {
     form.append(key, value);
@@ -13743,11 +13982,11 @@ async function uploadFile({
     form.append("key", uploadKey);
   }
   if (typeof file === "string") {
-    debug17("upload file from path %s", file);
+    debug18("upload file from path %s", file);
     logInfo2(`FileUpload: upload file from path ${file}`);
     form.append("file", await fileFrom(file));
   } else {
-    debug17("upload file from buffer");
+    debug18("upload file from buffer");
     logInfo2(`FileUpload: upload file from buffer`);
     form.append("file", new File([new Uint8Array(file)], "file"));
   }
@@ -13758,11 +13997,11 @@ async function uploadFile({
     agent
   });
   if (!response.ok) {
-    debug17("error from S3 %s %s", response.body, response.status);
+    debug18("error from S3 %s %s", response.body, response.status);
     logInfo2(`FileUpload: error from S3 ${response.body} ${response.status}`);
     throw new Error(`Failed to upload the file: ${response.status}`);
   }
-  debug17("upload file done");
+  debug18("upload file done");
   logInfo2(`FileUpload: upload file done`);
 }
 
@@ -13797,9 +14036,9 @@ async function downloadRepo({
 }) {
   const { createSpinner: createSpinner5 } = Spinner2({ ci });
   const repoSpinner = createSpinner5("\u{1F4BE} Downloading Repo").start();
-  debug18("download repo %s %s %s", repoUrl, dirname);
+  debug19("download repo %s %s %s", repoUrl, dirname);
   const zipFilePath = path9.join(dirname, "repo.zip");
-  debug18("download URL: %s auth headers: %o", downloadUrl, authHeaders);
+  debug19("download URL: %s auth headers: %o", downloadUrl, authHeaders);
   const response = await fetch4(downloadUrl, {
     method: "GET",
     headers: {
@@ -13807,7 +14046,7 @@ async function downloadRepo({
     }
   });
   if (!response.ok) {
-    debug18("SCM zipball request failed %s %s", response.body, response.status);
+    debug19("SCM zipball request failed %s %s", response.body, response.status);
     repoSpinner.error({ text: "\u{1F4BE} Repo download failed" });
     throw new Error(`Can't access ${chalk6.bold(repoUrl)}`);
   }
@@ -13821,7 +14060,7 @@ async function downloadRepo({
   if (!repoRoot) {
     throw new Error("Repo root not found");
   }
-  debug18("repo root %s", repoRoot);
+  debug19("repo root %s", repoRoot);
   repoSpinner.success({ text: "\u{1F4BE} Repo downloaded successfully" });
   return path9.join(dirname, repoRoot);
 }
@@ -13830,7 +14069,7 @@ var getReportUrl = ({
   projectId,
   fixReportId
 }) => `${WEB_APP_URL}/organization/${organizationId}/project/${projectId}/report/${fixReportId}`;
-var debug18 = Debug18("mobbdev:index");
+var debug19 = Debug19("mobbdev:index");
 async function runAnalysis(params, options) {
   const tmpObj = tmp2.dirSync({
     unsafeCleanup: true
@@ -13976,7 +14215,7 @@ async function _scan(params, { skipPrompts = false } = {}) {
     pullRequest,
     polling
   } = params;
-  debug18("start %s %s", dirname, repo);
+  debug19("start %s %s", dirname, repo);
   const { createSpinner: createSpinner5 } = Spinner2({ ci });
   skipPrompts = skipPrompts || ci;
   const gqlClient = await getAuthenticatedGQLClient({
@@ -14045,8 +14284,8 @@ async function _scan(params, { skipPrompts = false } = {}) {
     );
   }
   const { sha } = getReferenceDataRes.gitReference;
-  debug18("project id %s", projectId);
-  debug18("default branch %s", reference);
+  debug19("project id %s", projectId);
+  debug19("default branch %s", reference);
   if (command === "scan") {
     reportPath = await getReport(
       {
@@ -14096,7 +14335,7 @@ async function _scan(params, { skipPrompts = false } = {}) {
     spinner: mobbSpinner,
     submitVulnerabilityReportVariables: {
       fixReportId: reportUploadInfo.fixReportId,
-      repoUrl: z29.string().parse(repo),
+      repoUrl: z30.string().parse(repo),
       reference,
       projectId,
       vulnerabilityReportFileName: shouldScan ? void 0 : REPORT_DEFAULT_FILE_NAME,
@@ -14374,7 +14613,7 @@ async function _digestReport({
       text: progressMassages.processingVulnerabilityReportSuccess
     });
     if (polling) {
-      debug18(
+      debug19(
         "[_digestReport] Using POLLING mode for analysis state updates (--polling flag enabled)"
       );
       console.log(
@@ -14389,7 +14628,7 @@ async function _digestReport({
         timeoutInMs: VUL_REPORT_DIGEST_TIMEOUT_MS
       });
     } else {
-      debug18(
+      debug19(
         "[_digestReport] Using WEBSOCKET mode for analysis state updates (default)"
       );
       console.log(
@@ -14429,9 +14668,9 @@ async function waitForAnaysisAndReviewPr({
   gqlClient,
   polling
 }) {
-  const params = z29.object({
-    repo: z29.string().url(),
-    githubActionToken: z29.string()
+  const params = z30.object({
+    repo: z30.string().url(),
+    githubActionToken: z30.string()
   }).parse({ repo, githubActionToken });
   const scm = await createScmLib(
     {
@@ -14449,11 +14688,11 @@ async function waitForAnaysisAndReviewPr({
       analysisId: analysisId2,
       gqlClient,
       scm,
-      scanner: z29.nativeEnum(SCANNERS).parse(scanner)
+      scanner: z30.nativeEnum(SCANNERS).parse(scanner)
     });
   };
   if (polling) {
-    debug18(
+    debug19(
       "[waitForAnaysisAndReviewPr] Using POLLING mode for analysis state updates"
     );
     console.log(
@@ -14467,7 +14706,7 @@ async function waitForAnaysisAndReviewPr({
       callbackStates: ["Finished" /* Finished */]
     });
   } else {
-    debug18(
+    debug19(
       "[waitForAnaysisAndReviewPr] Using WEBSOCKET mode for analysis state updates"
     );
     console.log(
@@ -14763,7 +15002,7 @@ async function scanSkill(options) {
 // src/args/validation.ts
 import chalk8 from "chalk";
 import path11 from "path";
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 function throwRepoUrlErrorMessage({
   error,
   repoUrl,
@@ -14780,11 +15019,11 @@ Example:
   )}`;
   throw new CliError(formattedErrorMessage);
 }
-var UrlZ = z30.string({
+var UrlZ = z31.string({
   invalid_type_error: `is not a valid ${Object.values(ScmType).join("/ ")} URL`
 });
 function validateOrganizationId(organizationId) {
-  const orgIdValidation = z30.string().uuid().nullish().safeParse(organizationId);
+  const orgIdValidation = z31.string().uuid().nullish().safeParse(organizationId);
   if (!orgIdValidation.success) {
     throw new CliError(`organizationId: ${organizationId} is not a valid UUID`);
   }
@@ -14892,7 +15131,7 @@ async function analyzeHandler(args) {
 }
 
 // src/features/claude_code/data_collector.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 
 // src/args/commands/upload_ai_blame.ts
 import fsPromises3 from "fs/promises";
@@ -14900,7 +15139,7 @@ import * as os3 from "os";
 import path12 from "path";
 import chalk10 from "chalk";
 import { withFile } from "tmp-promise";
-import z31 from "zod";
+import z32 from "zod";
 init_client_generates();
 init_GitService();
 init_urlParser2();
@@ -14999,7 +15238,8 @@ import { OpenRedaction } from "@openredaction/openredaction";
 var openRedaction = new OpenRedaction({
   patterns: [
     // Core Personal Data
-    "EMAIL",
+    // Removed EMAIL - causes false positives in code/test snippets (e.g. --author="Eve Author <eve@example.com>")
+    // Prefer false negatives over false positives for this use case.
     "SSN",
     "NATIONAL_INSURANCE_UK",
     "DATE_OF_BIRTH",
@@ -15014,7 +15254,8 @@ var openRedaction = new OpenRedaction({
     "VISA_MRZ",
     "TAX_ID",
     // Financial Data (removed SWIFT_BIC, CARD_AUTH_CODE - too broad, causing false positives with authentication words)
-    "CREDIT_CARD",
+    // Removed CREDIT_CARD - causes false positives on zero-filled UUIDs (e.g. '00000000-0000-0000-0000-000000000000')
+    // Prefer false negatives over false positives for this use case.
     "IBAN",
     "BANK_ACCOUNT_UK",
     "ROUTING_NUMBER_US",
@@ -15100,15 +15341,6 @@ async function sanitizeDataWithCounts(obj) {
         ...piiDetections.low
       ];
       for (const detection of allDetections) {
-        if (detection.type === "CREDIT_CARD") {
-          const start = detection.position[0];
-          const end = detection.position[1];
-          const charBefore = (start > 0 ? str[start - 1] : "") ?? "";
-          const charAfter = str[end] ?? "";
-          if (charBefore === "." || charBefore >= "0" && charBefore <= "9" || charAfter >= "0" && charAfter <= "9") {
-            continue;
-          }
-        }
         counts.detections.total++;
         if (detection.severity === "high") counts.detections.high++;
         else if (detection.severity === "medium") counts.detections.medium++;
@@ -15161,8 +15393,8 @@ var defaultLogger2 = {
     }
   }
 };
-var PromptItemZ = z31.object({
-  type: z31.enum([
+var PromptItemZ = z32.object({
+  type: z32.enum([
     "USER_PROMPT",
     "AI_RESPONSE",
     "TOOL_EXECUTION",
@@ -15170,32 +15402,32 @@ var PromptItemZ = z31.object({
     "MCP_TOOL_CALL"
     // MCP (Model Context Protocol) tool invocation
   ]),
-  attachedFiles: z31.array(
-    z31.object({
-      relativePath: z31.string(),
-      startLine: z31.number().optional()
+  attachedFiles: z32.array(
+    z32.object({
+      relativePath: z32.string(),
+      startLine: z32.number().optional()
     })
   ).optional(),
-  tokens: z31.object({
-    inputCount: z31.number(),
-    outputCount: z31.number()
+  tokens: z32.object({
+    inputCount: z32.number(),
+    outputCount: z32.number()
   }).optional(),
-  text: z31.string().optional(),
-  date: z31.date().optional(),
-  tool: z31.object({
-    name: z31.string(),
-    parameters: z31.string(),
-    result: z31.string(),
-    rawArguments: z31.string().optional(),
-    accepted: z31.boolean().optional(),
+  text: z32.string().optional(),
+  date: z32.date().optional(),
+  tool: z32.object({
+    name: z32.string(),
+    parameters: z32.string(),
+    result: z32.string(),
+    rawArguments: z32.string().optional(),
+    accepted: z32.boolean().optional(),
     // MCP-specific fields (only populated for MCP_TOOL_CALL type)
-    mcpServer: z31.string().optional(),
+    mcpServer: z32.string().optional(),
     // MCP server name (e.g., "datadog", "mobb-mcp")
-    mcpToolName: z31.string().optional()
+    mcpToolName: z32.string().optional()
     // MCP tool name without prefix (e.g., "scan_and_fix_vulnerabilities")
   }).optional()
 });
-var PromptItemArrayZ = z31.array(PromptItemZ);
+var PromptItemArrayZ = z32.array(PromptItemZ);
 async function getRepositoryUrl() {
   try {
     const gitService = new GitService(process.cwd());
@@ -15585,46 +15817,46 @@ async function parseTranscriptAndCreateTrace(transcriptPath, hookData, inference
 }
 
 // src/features/claude_code/data_collector.ts
-var StructuredPatchItemSchema = z32.object({
-  oldStart: z32.number(),
-  oldLines: z32.number(),
-  newStart: z32.number(),
-  newLines: z32.number(),
-  lines: z32.array(z32.string())
+var StructuredPatchItemSchema = z33.object({
+  oldStart: z33.number(),
+  oldLines: z33.number(),
+  newStart: z33.number(),
+  newLines: z33.number(),
+  lines: z33.array(z33.string())
 });
-var EditToolInputSchema = z32.object({
-  file_path: z32.string(),
-  old_string: z32.string(),
-  new_string: z32.string()
+var EditToolInputSchema = z33.object({
+  file_path: z33.string(),
+  old_string: z33.string(),
+  new_string: z33.string()
 });
-var WriteToolInputSchema = z32.object({
-  file_path: z32.string(),
-  content: z32.string()
+var WriteToolInputSchema = z33.object({
+  file_path: z33.string(),
+  content: z33.string()
 });
-var EditToolResponseSchema = z32.object({
-  filePath: z32.string(),
-  oldString: z32.string().optional(),
-  newString: z32.string().optional(),
-  originalFile: z32.string().optional(),
-  structuredPatch: z32.array(StructuredPatchItemSchema),
-  userModified: z32.boolean().optional(),
-  replaceAll: z32.boolean().optional()
+var EditToolResponseSchema = z33.object({
+  filePath: z33.string(),
+  oldString: z33.string().optional(),
+  newString: z33.string().optional(),
+  originalFile: z33.string().optional(),
+  structuredPatch: z33.array(StructuredPatchItemSchema),
+  userModified: z33.boolean().optional(),
+  replaceAll: z33.boolean().optional()
 });
-var WriteToolResponseSchema = z32.object({
-  type: z32.string().optional(),
-  filePath: z32.string(),
-  content: z32.string().optional(),
-  structuredPatch: z32.array(z32.any()).optional()
+var WriteToolResponseSchema = z33.object({
+  type: z33.string().optional(),
+  filePath: z33.string(),
+  content: z33.string().optional(),
+  structuredPatch: z33.array(z33.any()).optional()
 });
-var HookDataSchema = z32.object({
-  session_id: z32.string(),
-  transcript_path: z32.string(),
-  cwd: z32.string(),
-  permission_mode: z32.string().optional(),
-  hook_event_name: z32.literal("PostToolUse"),
-  tool_name: z32.enum(["Edit", "Write"]),
-  tool_input: z32.union([EditToolInputSchema, WriteToolInputSchema]),
-  tool_response: z32.union([EditToolResponseSchema, WriteToolResponseSchema])
+var HookDataSchema = z33.object({
+  session_id: z33.string(),
+  transcript_path: z33.string(),
+  cwd: z33.string(),
+  permission_mode: z33.string().optional(),
+  hook_event_name: z33.literal("PostToolUse"),
+  tool_name: z33.enum(["Edit", "Write"]),
+  tool_input: z33.union([EditToolInputSchema, WriteToolInputSchema]),
+  tool_response: z33.union([EditToolResponseSchema, WriteToolResponseSchema])
 });
 async function readStdinData() {
   return new Promise((resolve, reject) => {
@@ -16091,138 +16323,137 @@ var log = logger.log.bind(logger);
 // src/mcp/services/McpGQLClient.ts
 import crypto3 from "crypto";
 import { GraphQLClient as GraphQLClient2 } from "graphql-request";
-import { HttpsProxyAgent as HttpsProxyAgent2 } from "https-proxy-agent";
 import { v4 as uuidv42 } from "uuid";
 init_client_generates();
 init_configs();
 
 // src/mcp/types.ts
 init_client_generates();
-import { z as z33 } from "zod";
-var ScanAndFixVulnerabilitiesToolSchema = z33.object({
-  path: z33.string()
+import { z as z34 } from "zod";
+var ScanAndFixVulnerabilitiesToolSchema = z34.object({
+  path: z34.string()
 });
-var VulnerabilityReportIssueTagSchema = z33.object({
-  vulnerability_report_issue_tag_value: z33.nativeEnum(
+var VulnerabilityReportIssueTagSchema = z34.object({
+  vulnerability_report_issue_tag_value: z34.nativeEnum(
     Vulnerability_Report_Issue_Tag_Enum
   )
 });
-var VulnerabilityReportIssueSchema = z33.object({
-  category: z33.any().optional().nullable(),
-  parsedIssueType: z33.nativeEnum(IssueType_Enum).nullable().optional(),
-  parsedSeverity: z33.nativeEnum(Vulnerability_Severity_Enum).nullable().optional(),
-  vulnerabilityReportIssueTags: z33.array(VulnerabilityReportIssueTagSchema)
+var VulnerabilityReportIssueSchema = z34.object({
+  category: z34.any().optional().nullable(),
+  parsedIssueType: z34.nativeEnum(IssueType_Enum).nullable().optional(),
+  parsedSeverity: z34.nativeEnum(Vulnerability_Severity_Enum).nullable().optional(),
+  vulnerabilityReportIssueTags: z34.array(VulnerabilityReportIssueTagSchema)
 });
-var SharedStateSchema = z33.object({
-  __typename: z33.literal("fix_shared_state").optional(),
-  id: z33.any(),
+var SharedStateSchema = z34.object({
+  __typename: z34.literal("fix_shared_state").optional(),
+  id: z34.any(),
   // GraphQL uses `any` type for UUID
-  downloadedBy: z33.array(z33.any().nullable()).optional().nullable()
+  downloadedBy: z34.array(z34.any().nullable()).optional().nullable()
 });
-var UnstructuredFixExtraContextSchema = z33.object({
-  __typename: z33.literal("UnstructuredFixExtraContext").optional(),
-  key: z33.string(),
-  value: z33.any()
+var UnstructuredFixExtraContextSchema = z34.object({
+  __typename: z34.literal("UnstructuredFixExtraContext").optional(),
+  key: z34.string(),
+  value: z34.any()
   // GraphQL JSON type
 });
-var FixExtraContextResponseSchema = z33.object({
-  __typename: z33.literal("FixExtraContextResponse").optional(),
-  extraContext: z33.array(UnstructuredFixExtraContextSchema),
-  fixDescription: z33.string()
+var FixExtraContextResponseSchema = z34.object({
+  __typename: z34.literal("FixExtraContextResponse").optional(),
+  extraContext: z34.array(UnstructuredFixExtraContextSchema),
+  fixDescription: z34.string()
 });
-var FixDataSchema = z33.object({
-  __typename: z33.literal("FixData"),
-  patch: z33.string(),
-  patchOriginalEncodingBase64: z33.string(),
+var FixDataSchema = z34.object({
+  __typename: z34.literal("FixData"),
+  patch: z34.string(),
+  patchOriginalEncodingBase64: z34.string(),
   extraContext: FixExtraContextResponseSchema
 });
-var GetFixNoFixErrorSchema = z33.object({
-  __typename: z33.literal("GetFixNoFixError")
+var GetFixNoFixErrorSchema = z34.object({
+  __typename: z34.literal("GetFixNoFixError")
 });
-var PatchAndQuestionsSchema = z33.union([FixDataSchema, GetFixNoFixErrorSchema]);
-var McpFixSchema = z33.object({
-  __typename: z33.literal("fix").optional(),
-  id: z33.any(),
+var PatchAndQuestionsSchema = z34.union([FixDataSchema, GetFixNoFixErrorSchema]);
+var McpFixSchema = z34.object({
+  __typename: z34.literal("fix").optional(),
+  id: z34.any(),
   // GraphQL uses `any` type for UUID
-  confidence: z33.number(),
-  safeIssueType: z33.string().nullable(),
-  severityText: z33.string().nullable(),
-  gitBlameLogin: z33.string().nullable().optional(),
+  confidence: z34.number(),
+  safeIssueType: z34.string().nullable(),
+  severityText: z34.string().nullable(),
+  gitBlameLogin: z34.string().nullable().optional(),
   // Optional in GraphQL
-  severityValue: z33.number().nullable(),
-  vulnerabilityReportIssues: z33.array(VulnerabilityReportIssueSchema),
+  severityValue: z34.number().nullable(),
+  vulnerabilityReportIssues: z34.array(VulnerabilityReportIssueSchema),
   sharedState: SharedStateSchema.nullable().optional(),
   // Optional in GraphQL
   patchAndQuestions: PatchAndQuestionsSchema,
   // Additional field added by the client
-  fixUrl: z33.string().optional()
+  fixUrl: z34.string().optional()
 });
-var FixAggregateSchema = z33.object({
-  __typename: z33.literal("fix_aggregate").optional(),
-  aggregate: z33.object({
-    __typename: z33.literal("fix_aggregate_fields").optional(),
-    count: z33.number()
+var FixAggregateSchema = z34.object({
+  __typename: z34.literal("fix_aggregate").optional(),
+  aggregate: z34.object({
+    __typename: z34.literal("fix_aggregate_fields").optional(),
+    count: z34.number()
   }).nullable()
 });
-var VulnerabilityReportIssueAggregateSchema = z33.object({
-  __typename: z33.literal("vulnerability_report_issue_aggregate").optional(),
-  aggregate: z33.object({
-    __typename: z33.literal("vulnerability_report_issue_aggregate_fields").optional(),
-    count: z33.number()
+var VulnerabilityReportIssueAggregateSchema = z34.object({
+  __typename: z34.literal("vulnerability_report_issue_aggregate").optional(),
+  aggregate: z34.object({
+    __typename: z34.literal("vulnerability_report_issue_aggregate_fields").optional(),
+    count: z34.number()
   }).nullable()
 });
-var RepoSchema = z33.object({
-  __typename: z33.literal("repo").optional(),
-  originalUrl: z33.string()
+var RepoSchema = z34.object({
+  __typename: z34.literal("repo").optional(),
+  originalUrl: z34.string()
 });
-var ProjectSchema = z33.object({
-  id: z33.any(),
+var ProjectSchema = z34.object({
+  id: z34.any(),
   // GraphQL uses `any` type for UUID
-  organizationId: z33.any()
+  organizationId: z34.any()
   // GraphQL uses `any` type for UUID
 });
-var VulnerabilityReportSchema = z33.object({
-  scanDate: z33.any().nullable(),
+var VulnerabilityReportSchema = z34.object({
+  scanDate: z34.any().nullable(),
   // GraphQL uses `any` type for timestamp
-  vendor: z33.string(),
+  vendor: z34.string(),
   // GraphQL generates as string, not enum
-  projectId: z33.any().optional(),
+  projectId: z34.any().optional(),
   // GraphQL uses `any` type for UUID
   project: ProjectSchema,
   totalVulnerabilityReportIssuesCount: VulnerabilityReportIssueAggregateSchema,
   notFixableVulnerabilityReportIssuesCount: VulnerabilityReportIssueAggregateSchema
 });
-var FixReportSummarySchema = z33.object({
-  __typename: z33.literal("fixReport").optional(),
-  id: z33.any(),
+var FixReportSummarySchema = z34.object({
+  __typename: z34.literal("fixReport").optional(),
+  id: z34.any(),
   // GraphQL uses `any` type for UUID
-  createdOn: z33.any(),
+  createdOn: z34.any(),
   // GraphQL uses `any` type for timestamp
   repo: RepoSchema.nullable(),
-  issueTypes: z33.any().nullable(),
+  issueTypes: z34.any().nullable(),
   // GraphQL uses `any` type for JSON
   CRITICAL: FixAggregateSchema,
   HIGH: FixAggregateSchema,
   MEDIUM: FixAggregateSchema,
   LOW: FixAggregateSchema,
-  fixes: z33.array(McpFixSchema),
-  userFixes: z33.array(McpFixSchema).optional(),
+  fixes: z34.array(McpFixSchema),
+  userFixes: z34.array(McpFixSchema).optional(),
   // Present in some responses but can be omitted
   filteredFixesCount: FixAggregateSchema,
   totalFixesCount: FixAggregateSchema,
   vulnerabilityReport: VulnerabilityReportSchema
 });
-var ExpiredReportSchema = z33.object({
-  __typename: z33.literal("fixReport").optional(),
-  id: z33.any(),
+var ExpiredReportSchema = z34.object({
+  __typename: z34.literal("fixReport").optional(),
+  id: z34.any(),
   // GraphQL uses `any` type for UUID
-  expirationOn: z33.any().nullable()
+  expirationOn: z34.any().nullable()
   // GraphQL uses `any` type for timestamp
 });
-var GetLatestReportByRepoUrlResponseSchema = z33.object({
-  __typename: z33.literal("query_root").optional(),
-  fixReport: z33.array(FixReportSummarySchema),
-  expiredReport: z33.array(ExpiredReportSchema)
+var GetLatestReportByRepoUrlResponseSchema = z34.object({
+  __typename: z34.literal("query_root").optional(),
+  fixReport: z34.array(FixReportSummarySchema),
+  expiredReport: z34.array(ExpiredReportSchema)
 });
 
 // src/mcp/services/McpAuthService.ts
@@ -16306,23 +16537,6 @@ var McpAuthService = class {
 };
 
 // src/mcp/services/McpGQLClient.ts
-function getProxyAgent2(url) {
-  try {
-    const parsedUrl = new URL(url);
-    const isHttp = parsedUrl.protocol === "http:";
-    const isHttps = parsedUrl.protocol === "https:";
-    const proxy = isHttps ? HTTPS_PROXY || HTTP_PROXY : isHttp ? HTTP_PROXY : null;
-    if (proxy) {
-      logDebug("[GraphQL] Using proxy for websocket subscriptions", { proxy });
-      return new HttpsProxyAgent2(proxy);
-    }
-  } catch (err) {
-    logDebug(`[GraphQL] Skipping proxy for ${url}`, {
-      error: err.message
-    });
-  }
-  return void 0;
-}
 var McpGQLClient = class {
   constructor(args) {
     __publicField(this, "client");
@@ -16339,6 +16553,7 @@ var McpGQLClient = class {
       headers: args.type === "apiKey" ? { [MCP_API_KEY_HEADER_NAME]: args.apiKey || "" } : {
         Authorization: `Bearer ${args.token}`
       },
+      fetch: fetchWithProxy,
       requestMiddleware: (request) => {
         const requestId = uuidv42();
         return {
@@ -16521,13 +16736,15 @@ var McpGQLClient = class {
             this._auth.type === "apiKey" ? {
               apiKey: this._auth.apiKey,
               type: "apiKey",
+              url: httpToWsUrl(this.apiUrl),
               timeoutInMs: params.timeoutInMs,
-              proxyAgent: getProxyAgent2(this.apiUrl)
+              proxyAgent: getProxyAgent(this.apiUrl)
             } : {
               token: this._auth.token,
               type: "token",
+              url: httpToWsUrl(this.apiUrl),
               timeoutInMs: params.timeoutInMs,
-              proxyAgent: getProxyAgent2(this.apiUrl)
+              proxyAgent: getProxyAgent(this.apiUrl)
             }
           );
         }
@@ -18147,10 +18364,10 @@ var McpServer = class {
 };
 
 // src/mcp/prompts/CheckForNewVulnerabilitiesPrompt.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 
 // src/mcp/prompts/base/BasePrompt.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var BasePrompt = class {
   getDefinition() {
     return {
@@ -18179,7 +18396,7 @@ var BasePrompt = class {
       const argsToValidate = args === void 0 ? {} : args;
       return this.argumentsValidationSchema.parse(argsToValidate);
     } catch (error) {
-      if (error instanceof z34.ZodError) {
+      if (error instanceof z35.ZodError) {
         const errorDetails = error.errors.map((e) => {
           const fieldPath = e.path.length > 0 ? e.path.join(".") : "root";
           const message = e.message === "Required" ? `Missing required argument '${fieldPath}'` : `Invalid value for '${fieldPath}': ${e.message}`;
@@ -18208,8 +18425,8 @@ var BasePrompt = class {
 };
 
 // src/mcp/prompts/CheckForNewVulnerabilitiesPrompt.ts
-var CheckForNewVulnerabilitiesArgsSchema = z35.object({
-  path: z35.string().optional()
+var CheckForNewVulnerabilitiesArgsSchema = z36.object({
+  path: z36.string().optional()
 });
 var CheckForNewVulnerabilitiesPrompt = class extends BasePrompt {
   constructor() {
@@ -18454,9 +18671,9 @@ Call the \`check_for_new_available_fixes\` tool now${args?.path ? ` for ${args.p
 };
 
 // src/mcp/prompts/FullSecurityAuditPrompt.ts
-import { z as z36 } from "zod";
-var FullSecurityAuditArgsSchema = z36.object({
-  path: z36.string().optional()
+import { z as z37 } from "zod";
+var FullSecurityAuditArgsSchema = z37.object({
+  path: z37.string().optional()
 });
 var FullSecurityAuditPrompt = class extends BasePrompt {
   constructor() {
@@ -18907,9 +19124,9 @@ Begin the audit now${args?.path ? ` for ${args.path}` : ""}.
 };
 
 // src/mcp/prompts/ReviewAndFixCriticalPrompt.ts
-import { z as z37 } from "zod";
-var ReviewAndFixCriticalArgsSchema = z37.object({
-  path: z37.string().optional()
+import { z as z38 } from "zod";
+var ReviewAndFixCriticalArgsSchema = z38.object({
+  path: z38.string().optional()
 });
 var ReviewAndFixCriticalPrompt = class extends BasePrompt {
   constructor() {
@@ -19213,9 +19430,9 @@ Start by scanning${args?.path ? ` ${args.path}` : " the repository"} and priorit
 };
 
 // src/mcp/prompts/ScanRecentChangesPrompt.ts
-import { z as z38 } from "zod";
-var ScanRecentChangesArgsSchema = z38.object({
-  path: z38.string().optional()
+import { z as z39 } from "zod";
+var ScanRecentChangesArgsSchema = z39.object({
+  path: z39.string().optional()
 });
 var ScanRecentChangesPrompt = class extends BasePrompt {
   constructor() {
@@ -19426,9 +19643,9 @@ You now have the guidance needed to perform a fast, targeted security scan of re
 };
 
 // src/mcp/prompts/ScanRepositoryPrompt.ts
-import { z as z39 } from "zod";
-var ScanRepositoryArgsSchema = z39.object({
-  path: z39.string().optional()
+import { z as z40 } from "zod";
+var ScanRepositoryArgsSchema = z40.object({
+  path: z40.string().optional()
 });
 var ScanRepositoryPrompt = class extends BasePrompt {
   constructor() {
@@ -19826,7 +20043,7 @@ import * as os11 from "os";
 import * as path18 from "path";
 
 // src/mcp/tools/checkForNewAvailableFixes/CheckForNewAvailableFixesTool.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 
 // src/mcp/services/PathValidation.ts
 import fs19 from "fs";
@@ -19902,7 +20119,7 @@ async function validatePath(inputPath) {
 }
 
 // src/mcp/tools/base/BaseTool.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 var BaseTool = class {
   getDefinition() {
     return {
@@ -19935,7 +20152,7 @@ var BaseTool = class {
     try {
       return this.inputValidationSchema.parse(args);
     } catch (error) {
-      if (error instanceof z40.ZodError) {
+      if (error instanceof z41.ZodError) {
         const errorDetails = error.errors.map((e) => {
           const fieldPath = e.path.length > 0 ? e.path.join(".") : "root";
           const message = e.message === "Required" ? `Missing required parameter '${fieldPath}'` : `Invalid value for '${fieldPath}': ${e.message}`;
@@ -20654,13 +20871,13 @@ init_client_generates();
 init_GitService();
 import fs21 from "fs";
 import path20 from "path";
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 function extractPathFromPatch(patch) {
   const match = patch?.match(/diff --git a\/([^\s]+) b\//);
   return match?.[1] ?? null;
 }
 function parsedIssueTypeRes(issueType) {
-  return z41.nativeEnum(IssueType_Enum).safeParse(issueType);
+  return z42.nativeEnum(IssueType_Enum).safeParse(issueType);
 }
 var LocalMobbFolderService = class {
   /**
@@ -23357,8 +23574,8 @@ Example payload:
       },
       required: ["path"]
     });
-    __publicField(this, "inputValidationSchema", z42.object({
-      path: z42.string().describe(
+    __publicField(this, "inputValidationSchema", z43.object({
+      path: z43.string().describe(
         "Full local path to the cloned git repository to check for new available fixes"
       )
     }));
@@ -23388,7 +23605,7 @@ Example payload:
 
 // src/mcp/tools/fetchAvailableFixes/FetchAvailableFixesTool.ts
 init_GitService();
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 
 // src/mcp/tools/fetchAvailableFixes/FetchAvailableFixesService.ts
 init_configs();
@@ -23531,16 +23748,16 @@ Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only
       },
       required: ["path"]
     });
-    __publicField(this, "inputValidationSchema", z43.object({
-      path: z43.string().describe(
+    __publicField(this, "inputValidationSchema", z44.object({
+      path: z44.string().describe(
         "Full local path to the cloned git repository to check for available fixes"
       ),
-      offset: z43.number().optional().describe("Optional offset for pagination"),
-      limit: z43.number().optional().describe("Optional maximum number of fixes to return"),
-      fileFilter: z43.array(z43.string()).optional().describe(
+      offset: z44.number().optional().describe("Optional offset for pagination"),
+      limit: z44.number().optional().describe("Optional maximum number of fixes to return"),
+      fileFilter: z44.array(z44.string()).optional().describe(
         "Optional list of file paths relative to the path parameter to filter fixes by. INCOMPATIBLE with fetchFixesFromAnyFile"
       ),
-      fetchFixesFromAnyFile: z43.boolean().optional().describe(
+      fetchFixesFromAnyFile: z44.boolean().optional().describe(
         "Optional boolean to fetch fixes for all files. INCOMPATIBLE with fileFilter"
       )
     }));
@@ -23605,7 +23822,7 @@ Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only
 };
 
 // src/mcp/tools/mcpChecker/mcpCheckerTool.ts
-import z44 from "zod";
+import z45 from "zod";
 
 // src/mcp/tools/mcpChecker/mcpCheckerService.ts
 var _McpCheckerService = class _McpCheckerService {
@@ -23666,7 +23883,7 @@ var McpCheckerTool = class extends BaseTool {
     __publicField(this, "displayName", "MCP Checker");
     // A detailed description to guide the LLM on when and how to invoke this tool.
     __publicField(this, "description", "Check the MCP servers running on this IDE against organization policies.");
-    __publicField(this, "inputValidationSchema", z44.object({}));
+    __publicField(this, "inputValidationSchema", z45.object({}));
     __publicField(this, "inputSchema", {
       type: "object",
       properties: {},
@@ -23692,7 +23909,7 @@ var McpCheckerTool = class extends BaseTool {
 };
 
 // src/mcp/tools/scanAndFixVulnerabilities/ScanAndFixVulnerabilitiesTool.ts
-import z45 from "zod";
+import z46 from "zod";
 init_configs();
 
 // src/mcp/tools/scanAndFixVulnerabilities/ScanAndFixVulnerabilitiesService.ts
@@ -23880,17 +24097,17 @@ Example payload:
   "rescan": false
 }`);
     __publicField(this, "hasAuthentication", true);
-    __publicField(this, "inputValidationSchema", z45.object({
-      path: z45.string().describe(
+    __publicField(this, "inputValidationSchema", z46.object({
+      path: z46.string().describe(
         "Full local path to repository to scan and fix vulnerabilities"
       ),
-      offset: z45.number().optional().describe("Optional offset for pagination"),
-      limit: z45.number().optional().describe("Optional maximum number of results to return"),
-      maxFiles: z45.number().optional().describe(
+      offset: z46.number().optional().describe("Optional offset for pagination"),
+      limit: z46.number().optional().describe("Optional maximum number of results to return"),
+      maxFiles: z46.number().optional().describe(
         `Optional maximum number of files to scan (default: ${MCP_DEFAULT_MAX_FILES_TO_SCAN}). Increase for comprehensive scans of larger codebases or decrease for faster focused scans.`
       ),
-      rescan: z45.boolean().optional().describe("Optional whether to rescan the repository"),
-      scanRecentlyChangedFiles: z45.boolean().optional().describe(
+      rescan: z46.boolean().optional().describe("Optional whether to rescan the repository"),
+      scanRecentlyChangedFiles: z46.boolean().optional().describe(
         "Optional whether to automatically scan recently changed files when no changed files are found in git status. If false, the tool will prompt the user instead."
       )
     }));
@@ -24198,7 +24415,7 @@ async function addScmTokenHandler(args) {
 }
 
 // src/features/codeium_intellij/data_collector.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 init_client_generates();
 init_urlParser2();
 
@@ -24339,8 +24556,8 @@ function findRunningCodeiumLanguageServers() {
 }
 
 // src/features/codeium_intellij/data_collector.ts
-var HookDataSchema2 = z46.object({
-  trajectory_id: z46.string()
+var HookDataSchema2 = z47.object({
+  trajectory_id: z47.string()
 });
 async function processAndUploadHookData2() {
   const tracePayload = await getTraceDataForHook();
@@ -24720,13 +24937,13 @@ var parseArgs = async (args) => {
 };
 
 // src/index.ts
-var debug19 = Debug19("mobbdev:index");
+var debug20 = Debug20("mobbdev:index");
 async function run() {
   return parseArgs(hideBin(process.argv));
 }
 (async () => {
   try {
-    debug19("Bugsy CLI v%s running...", packageJson.version);
+    debug20("Bugsy CLI v%s running...", packageJson.version);
     await run();
     process.exit(0);
   } catch (err) {