mobbdev 1.4.48 → 1.4.49

package/dist/index.mjs

@@ -5227,7 +5227,7 @@ async function getAdoSdk(params) {
       const url = new URL(repoUrl);
       const origin = 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 path37 = [
+      const path38 = [
         prefixPath,
         owner,
         projectName,
@@ -5238,7 +5238,7 @@ async function getAdoSdk(params) {
         "items",
         "items"
       ].filter(Boolean).join("/");
-      return new URL(`${path37}?${params2}`, origin).toString();
+      return new URL(`${path38}?${params2}`, origin).toString();
     },
     async getAdoBranchList({ repoUrl }) {
       try {
@@ -5327,8 +5327,8 @@ async function getAdoSdk(params) {
         const changeType = entry.changeType;
         return changeType !== 16 && entry.item?.path;
       }).map((entry) => {
-        const path37 = entry.item.path;
-        return path37.startsWith("/") ? path37.slice(1) : path37;
+        const path38 = entry.item.path;
+        return path38.startsWith("/") ? path38.slice(1) : path38;
       });
     },
     async searchAdoPullRequests({
@@ -6265,7 +6265,6 @@ var AdoSCMLib = class extends SCMLib {
 // src/features/analysis/scm/bitbucket/bitbucket.ts
 import querystring2 from "querystring";
 import * as bitbucketPkgNode from "bitbucket";
-import bitbucketPkg from "bitbucket";
 import Debug2 from "debug";
 import { z as z16 } from "zod";
 
@@ -6278,6 +6277,7 @@ var BitbucketAuthResultZ = z15.object({
 });
 
 // src/features/analysis/scm/bitbucket/bitbucket.ts
+var bitbucketPkg = bitbucketPkgNode.default;
 var debug3 = Debug2("scm:bitbucket");
 function isBitbucketPermissionDenied(e) {
   const status = e?.status;
@@ -10417,6 +10417,7 @@ __export(utils_exports, {
   getDirName: () => getDirName,
   getModuleRootDir: () => getModuleRootDir,
   getTopLevelDirName: () => getTopLevelDirName,
+  isStandaloneBinary: () => isStandaloneBinary,
   keypress: () => keypress,
   packageJson: () => packageJson,
   sleep: () => sleep
@@ -10427,6 +10428,10 @@ import fs3 from "fs";
 import path3 from "path";
 import { fileURLToPath } from "url";
 function getModuleRootDir() {
+  const seaRoot = process.env["MOBBDEV_MODULE_ROOT"];
+  if (seaRoot) {
+    return seaRoot;
+  }
   let manifestDir = getDirName();
   for (let i = 0; i < 10; i++) {
     const manifestPath = path3.join(manifestDir, "package.json");
@@ -10523,6 +10528,16 @@ function Spinner({ ci = false } = {}) {
   };
 }
 
+// src/utils/standalone_binary.ts
+function isStandaloneBinary() {
+  try {
+    const getBuiltin = process.getBuiltinModule;
+    return Boolean(getBuiltin?.("node:sea")?.isSea());
+  } catch {
+    return false;
+  }
+}
+
 // src/utils/check_node_version.ts
 import fs4 from "fs";
 import path4 from "path";
@@ -11306,7 +11321,7 @@ var ScanContext = {
 };
 
 // src/args/commands/analyze.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import chalk10 from "chalk";
 
 // src/commands/index.ts
@@ -11314,11 +11329,11 @@ import chalk8 from "chalk";
 import chalkAnimation from "chalk-animation";
 
 // src/features/analysis/index.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import fsPromises3 from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 import { env as env2 } from "process";
-import { pipeline } from "stream/promises";
+import { pipeline as pipeline2 } from "stream/promises";
 import chalk7 from "chalk";
 import Debug22 from "debug";
 import extract from "extract-zip";
@@ -14019,7 +14034,7 @@ async function postIssueComment(params) {
     fpDescription
   } = params;
   const {
-    path: path37,
+    path: path38,
     startLine,
     vulnerabilityReportIssue: {
       vulnerabilityReportIssueTags,
@@ -14034,7 +14049,7 @@ async function postIssueComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path37,
+    path: path38,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -14068,7 +14083,7 @@ async function postFixComment(params) {
     scanner
   } = params;
   const {
-    path: path37,
+    path: path38,
     startLine,
     vulnerabilityReportIssue: { fixId, vulnerabilityReportIssueTags, category },
     vulnerabilityReportIssueId
@@ -14086,7 +14101,7 @@ async function postFixComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path37,
+    path: path38,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -14636,7 +14651,7 @@ function createFork({ args, processPath, name }, options) {
 }
 function createSpawn({ args, processPath, name, cwd, env: env3 }, options) {
   const child = cp.spawn(processPath, args, {
-    stdio: ["inherit", "pipe", "pipe", "ipc"],
+    stdio: ["inherit", "pipe", "pipe"],
     env: { ...process2.env, ...env3 },
     cwd
   });
@@ -14694,11 +14709,16 @@ if (typeof __filename !== "undefined") {
 }
 var costumeRequire = createRequire(moduleUrl);
 var getCheckmarxPath = () => {
-  const os19 = type();
-  const cxFileName = os19 === "Windows_NT" ? "cx.exe" : "cx";
+  const os20 = type();
+  const cxFileName = os20 === "Windows_NT" ? "cx.exe" : "cx";
   try {
     return costumeRequire.resolve(`.bin/${cxFileName}`);
   } catch (e) {
+    if (isStandaloneBinary()) {
+      throw new CliError(
+        "The Checkmarx scanner is not available in the standalone mobbdev binary yet. Use the npm package instead: npx mobbdev@latest"
+      );
+    }
     throw new CliError(cxOperatingSystemSupportMessage);
   }
 };
@@ -14805,7 +14825,13 @@ async function validateCheckamxCredentials() {
 }
 
 // src/features/analysis/scanners/snyk.ts
+import crypto2 from "crypto";
+import fs10 from "fs";
 import { createRequire as createRequire2 } from "module";
+import os4 from "os";
+import path10 from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
 import chalk6 from "chalk";
 import Debug21 from "debug";
 import { createSpinner as createSpinner3 } from "nanospinner";
@@ -14830,31 +14856,130 @@ 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";
-debug21("snyk executable path %s", SNYK_PATH);
+var SNYK_VERSION = packageJson.dependencies.snyk;
+var SNYK_DOWNLOAD_BASE = process.env["MOBB_SNYK_DOWNLOAD_BASE"] || "https://downloads.snyk.io/cli";
+var SNYK_BINARY_ASSETS = {
+  "darwin-x64": "snyk-macos",
+  "darwin-arm64": "snyk-macos-arm64",
+  "linux-x64": "snyk-linux",
+  "linux-arm64": "snyk-linux-arm64",
+  "win32-x64": "snyk-win.exe"
+};
+async function downloadSnykBinary(asset, dest) {
+  if (!/^\d+\.\d+\.\d+$/.test(SNYK_VERSION)) {
+    throw new CliError(
+      `Cannot build the Snyk CLI download URL: expected an exact version in the "snyk" dependency of package.json, got "${SNYK_VERSION}".`
+    );
+  }
+  const url = `${SNYK_DOWNLOAD_BASE}/v${SNYK_VERSION}/${asset}`;
+  const tmpPath = `${dest}.download.${process.pid}`;
+  const spinner = createSpinner3(
+    `\u2B07\uFE0F  Downloading Snyk CLI v${SNYK_VERSION}`
+  ).start();
+  try {
+    fs10.mkdirSync(path10.dirname(dest), { recursive: true });
+    const timeout = () => AbortSignal.timeout(10 * 60 * 1e3);
+    const [binRes, shaRes] = await Promise.all([
+      fetchWithProxy(url, { signal: timeout() }),
+      fetchWithProxy(`${url}.sha256`, { signal: timeout() })
+    ]);
+    if (!binRes.ok || !shaRes.ok || !binRes.body) {
+      throw new CliError(
+        `Snyk CLI download failed with HTTP ${binRes.ok ? shaRes.status : binRes.status}: ${url}
+If downloads.snyk.io is unreachable from this network, point MOBB_SNYK_DOWNLOAD_BASE at a mirror.`
+      );
+    }
+    const hash = crypto2.createHash("sha256");
+    await pipeline(
+      Readable.fromWeb(binRes.body),
+      async function* (source) {
+        for await (const chunk of source) {
+          hash.update(chunk);
+          yield chunk;
+        }
+      },
+      fs10.createWriteStream(tmpPath, { mode: 493 })
+    );
+    const expected = (await shaRes.text()).trim().split(/\s+/)[0];
+    const actual = hash.digest("hex");
+    if (actual !== expected) {
+      throw new CliError(
+        `Snyk CLI download checksum mismatch (expected ${expected}, got ${actual}) \u2014 refusing to install it. Please try again.`
+      );
+    }
+    fs10.renameSync(tmpPath, dest);
+    spinner.success({ text: `\u2B07\uFE0F  Snyk CLI v${SNYK_VERSION} installed` });
+  } catch (e) {
+    fs10.rmSync(tmpPath, { force: true });
+    spinner.error({ text: "\u2B07\uFE0F  Snyk CLI download failed" });
+    throw e;
+  }
+}
+async function getSnykExecutable() {
+  try {
+    return {
+      processPath: costumeRequire2.resolve("snyk/bin/snyk"),
+      isNodeScript: true
+    };
+  } catch (e) {
+    if (!isStandaloneBinary()) {
+      throw e;
+    }
+    debug21("running as standalone binary, using standalone snyk binary");
+  }
+  const asset = SNYK_BINARY_ASSETS[`${process.platform}-${process.arch}`];
+  if (!asset) {
+    throw new CliError(
+      `Snyk scan is not supported on this platform (${process.platform}-${process.arch}) when running the standalone mobbdev binary. Use the npm package instead: npx mobbdev@latest`
+    );
+  }
+  const dest = path10.join(
+    os4.homedir(),
+    ".mobb",
+    "tools",
+    "snyk",
+    `v${SNYK_VERSION}`,
+    asset
+  );
+  if (!fs10.existsSync(dest)) {
+    await downloadSnykBinary(asset, dest);
+  }
+  return { processPath: dest, isNodeScript: false };
+}
 async function forkSnyk(args, { display }) {
   debug21("fork snyk with args %o %s", args, display);
-  return createFork({ args, processPath: SNYK_PATH, name: "snyk" }, { display });
+  const { processPath, isNodeScript } = await getSnykExecutable();
+  const create = isNodeScript ? createFork : createSpawn;
+  return create({ args, processPath, name: "snyk" }, { display });
 }
 async function getSnykReport(reportPath, repoRoot, { skipPrompts = false }) {
   debug21("get snyk report start %s %s", reportPath, repoRoot);
   const config2 = await forkSnyk(["config"], { display: false });
   const { message: configMessage } = config2;
-  if (!configMessage.includes("api: ")) {
-    const snykLoginSpinner = createSpinner3().start();
-    if (!skipPrompts) {
+  const hasStoredCredential = configMessage.includes("api: ") || configMessage.includes("INTERNAL_OAUTH_TOKEN_STORAGE");
+  if (!hasStoredCredential) {
+    const hasSnykToken = !!process.env["SNYK_TOKEN"];
+    if (skipPrompts) {
+      if (!hasSnykToken) {
+        throw new CliError(
+          "Snyk authentication is required. In CI / non-interactive mode, set the SNYK_TOKEN environment variable (Snyk API token). Interactive `snyk auth` (browser) is not available with --ci."
+        );
+      }
+      debug21("skipPrompts: using SNYK_TOKEN for snyk authentication");
+    } else {
+      const snykLoginSpinner = createSpinner3().start();
       snykLoginSpinner.update({
         text: "\u{1F513} Login to Snyk is required, press any key to continue"
       });
       await keypress();
+      snykLoginSpinner.update({
+        text: "\u{1F513} Waiting for Snyk login to complete"
+      });
+      debug21("no token in the config %s", config2);
+      await forkSnyk(["auth"], { display: true });
+      snykLoginSpinner.success({ text: "\u{1F513} Login to Snyk Successful" });
     }
-    snykLoginSpinner.update({
-      text: "\u{1F513} Waiting for Snyk login to complete"
-    });
-    debug21("no token in the config %s", config2);
-    await forkSnyk(["auth"], { display: true });
-    snykLoginSpinner.success({ text: "\u{1F513} Login to Snyk Successful" });
   }
   const snykSpinner = createSpinner3("\u{1F50D} Scanning your repo with Snyk ").start();
   const { message: scanOutput } = await forkSnyk(
@@ -14916,7 +15041,7 @@ async function downloadRepo({
   const { createSpinner: createSpinner5 } = Spinner2({ ci });
   const repoSpinner = createSpinner5("\u{1F4BE} Downloading Repo").start();
   debug22("download repo %s %s %s", repoUrl, dirname);
-  const zipFilePath = path10.join(dirname, "repo.zip");
+  const zipFilePath = path11.join(dirname, "repo.zip");
   debug22("download URL: %s auth headers: %o", downloadUrl, authHeaders);
   const response = await fetch4(downloadUrl, {
     method: "GET",
@@ -14929,19 +15054,19 @@ async function downloadRepo({
     repoSpinner.error({ text: "\u{1F4BE} Repo download failed" });
     throw new Error(`Can't access ${chalk7.bold(repoUrl)}`);
   }
-  const fileWriterStream = fs10.createWriteStream(zipFilePath);
+  const fileWriterStream = fs11.createWriteStream(zipFilePath);
   if (!response.body) {
     throw new Error("Response body is empty");
   }
-  await pipeline(response.body, fileWriterStream);
+  await pipeline2(response.body, fileWriterStream);
   await extract(zipFilePath, { dir: dirname });
-  const repoRoot = fs10.readdirSync(dirname, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name)[0];
+  const repoRoot = fs11.readdirSync(dirname, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name)[0];
   if (!repoRoot) {
     throw new Error("Repo root not found");
   }
   debug22("repo root %s", repoRoot);
   repoSpinner.success({ text: "\u{1F4BE} Repo downloaded successfully" });
-  return path10.join(dirname, repoRoot);
+  return path11.join(dirname, repoRoot);
 }
 var getReportUrl = ({
   organizationId,
@@ -15049,7 +15174,7 @@ async function getReport(params, { skipPrompts }) {
     authHeaders: scm.getAuthHeaders(),
     downloadUrl
   });
-  const reportPath = path10.join(dirname, REPORT_DEFAULT_FILE_NAME);
+  const reportPath = path11.join(dirname, REPORT_DEFAULT_FILE_NAME);
   switch (scanner) {
     case "snyk":
       await getSnykReport(reportPath, repositoryRoot, { skipPrompts });
@@ -15461,7 +15586,7 @@ async function _zipAndUploadRepo({
   const zippingSpinner = createSpinner4("\u{1F4E6} Zipping repo").start();
   let zipBuffer;
   let gitInfo2 = { success: false };
-  if (srcFileStatus.isFile() && path10.extname(srcPath).toLowerCase() === ".fpr") {
+  if (srcFileStatus.isFile() && path11.extname(srcPath).toLowerCase() === ".fpr") {
     zipBuffer = await repackFpr(srcPath);
   } else {
     gitInfo2 = await getGitInfo(srcPath);
@@ -15634,17 +15759,17 @@ async function waitForAnaysisAndReviewPr({
 }
 
 // src/commands/scan_skill_input.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs12 from "fs";
+import path12 from "path";
 import AdmZip2 from "adm-zip";
 var LOCAL_SKILL_ZIP_DATA_URL_PREFIX = "data:application/zip;base64,";
 var MAX_LOCAL_SKILL_ARCHIVE_BYTES = 2 * 1024 * 1024;
 async function resolveSkillScanInput(skillInput) {
-  const resolvedPath = path11.resolve(skillInput);
-  if (!fs11.existsSync(resolvedPath)) {
+  const resolvedPath = path12.resolve(skillInput);
+  if (!fs12.existsSync(resolvedPath)) {
     return skillInput;
   }
-  const stat5 = fs11.statSync(resolvedPath);
+  const stat5 = fs12.statSync(resolvedPath);
   if (!stat5.isDirectory()) {
     throw new CliError(
       "Local skill input must be a directory containing SKILL.md"
@@ -15654,18 +15779,18 @@ async function resolveSkillScanInput(skillInput) {
 }
 function packageLocalSkillDirectory(directoryPath) {
   const zip = new AdmZip2();
-  const rootPath = path11.resolve(directoryPath);
+  const rootPath = path12.resolve(directoryPath);
   const filePaths = listDirectoryFiles(rootPath);
   let hasSkillMd = false;
   for (const relativePath of filePaths) {
-    const fullPath = path11.join(rootPath, relativePath);
-    const normalizedFullPath = path11.resolve(fullPath);
-    if (normalizedFullPath !== rootPath && !normalizedFullPath.startsWith(rootPath + path11.sep)) {
+    const fullPath = path12.join(rootPath, relativePath);
+    const normalizedFullPath = path12.resolve(fullPath);
+    if (normalizedFullPath !== rootPath && !normalizedFullPath.startsWith(rootPath + path12.sep)) {
       continue;
     }
-    const fileContent = fs11.readFileSync(normalizedFullPath);
+    const fileContent = fs12.readFileSync(normalizedFullPath);
     zip.addFile(relativePath, fileContent);
-    if (path11.basename(relativePath).toLowerCase() === "skill.md") {
+    if (path12.basename(relativePath).toLowerCase() === "skill.md") {
       hasSkillMd = true;
     }
   }
@@ -15683,17 +15808,17 @@ function packageLocalSkillDirectory(directoryPath) {
 function listDirectoryFiles(rootPath) {
   const files = [];
   function walk(relativeDir) {
-    const absoluteDir = path11.join(rootPath, relativeDir);
-    const entries = fs11.readdirSync(absoluteDir, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+    const absoluteDir = path12.join(rootPath, relativeDir);
+    const entries = fs12.readdirSync(absoluteDir, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
-      const safeEntryName = path11.basename(entry.name).replace(/\0/g, "");
+      const safeEntryName = path12.basename(entry.name).replace(/\0/g, "");
       if (!safeEntryName) {
         continue;
       }
-      const relativePath = relativeDir ? path11.posix.join(relativeDir, safeEntryName) : safeEntryName;
-      const absolutePath = path11.join(rootPath, relativePath);
-      const normalizedAbsolutePath = path11.resolve(absolutePath);
-      if (normalizedAbsolutePath !== rootPath && !normalizedAbsolutePath.startsWith(rootPath + path11.sep)) {
+      const relativePath = relativeDir ? path12.posix.join(relativeDir, safeEntryName) : safeEntryName;
+      const absolutePath = path12.join(rootPath, relativePath);
+      const normalizedAbsolutePath = path12.resolve(absolutePath);
+      if (normalizedAbsolutePath !== rootPath && !normalizedAbsolutePath.startsWith(rootPath + path12.sep)) {
         continue;
       }
       if (entry.isSymbolicLink()) {
@@ -15914,7 +16039,7 @@ async function scanSkill(options) {
 
 // src/args/validation.ts
 import chalk9 from "chalk";
-import path12 from "path";
+import path13 from "path";
 import { z as z28 } from "zod";
 function throwRepoUrlErrorMessage({
   error,
@@ -15958,7 +16083,7 @@ function validateRepoUrl(args) {
 }
 var supportExtensions = [".json", ".xml", ".fpr", ".sarif", ".zip"];
 function validateReportFileFormat(reportFile) {
-  if (!supportExtensions.includes(path12.extname(reportFile))) {
+  if (!supportExtensions.includes(path13.extname(reportFile))) {
     throw new CliError(
       `
 ${chalk9.bold(
@@ -16006,7 +16131,7 @@ function analyzeBuilder(yargs2) {
   ).help();
 }
 function validateAnalyzeOptions(argv) {
-  if (argv.f && !fs12.existsSync(argv.f)) {
+  if (argv.f && !fs13.existsSync(argv.f)) {
     throw new CliError(`
 Can't access ${chalk10.bold(argv.f)}`);
   }
@@ -16054,8 +16179,8 @@ import { spawn } from "child_process";
 
 // src/features/claude_code/daemon.ts
 import { readFileSync, writeFileSync as writeFileSync2 } from "fs";
-import * as os8 from "os";
-import path24 from "path";
+import * as os9 from "os";
+import path25 from "path";
 import { setTimeout as sleep4 } from "timers/promises";
 import Configstore4 from "configstore";
 
@@ -16234,7 +16359,7 @@ function loadBreaker(store) {
 // src/features/analysis/skill_quarantine/runQuarantineCheck.ts
 import { stat as stat3 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import path19 from "path";
+import path20 from "path";
 
 // src/features/analysis/skill_quarantine/constants.ts
 var HEARTBEAT_DEBOUNCE_MS = (() => {
@@ -16249,11 +16374,11 @@ var STUB_MARKER = "\u26D4 QUARANTINED BY TRACY";
 
 // src/features/analysis/skill_quarantine/enumerateInstalledSkills.ts
 import { homedir as homedir2 } from "os";
-import path15 from "path";
+import path16 from "path";
 
 // src/features/analysis/context_file_processor.ts
 import { createHash } from "crypto";
-import path13 from "path";
+import path14 from "path";
 import AdmZip3 from "adm-zip";
 import pLimit5 from "p-limit";
 var SANITIZE_CONCURRENCY = 5;
@@ -16287,7 +16412,7 @@ async function processContextFiles(regularFiles, skillGroups) {
         );
         for (const file of sortedFiles) {
           const sanitizedContent = await sanitizeFileContent(file.content);
-          const zipEntryName = group.isFolder ? path13.relative(group.skillPath, file.path).replace(/\\/g, "/") : path13.basename(file.path);
+          const zipEntryName = group.isFolder ? path14.relative(group.skillPath, file.path).replace(/\\/g, "/") : path14.basename(file.path);
           zip.addFile(zipEntryName, Buffer.from(sanitizedContent, "utf-8"));
           const entry = zip.getEntry(zipEntryName);
           if (entry) {
@@ -16306,7 +16431,7 @@ async function processContextFiles(regularFiles, skillGroups) {
 // src/features/analysis/context_file_scanner.ts
 import { lstat, readdir, readFile, realpath, stat } from "fs/promises";
 import { homedir } from "os";
-import path14 from "path";
+import path15 from "path";
 import { globby as globby2 } from "globby";
 import { parse as parseJsoncLib } from "jsonc-parser";
 
@@ -16638,25 +16763,25 @@ function resolveCustomLocationPath(raw, workspaceRoot, home) {
     return null;
   }
   if (s.startsWith("~/") || s === "~") {
-    s = path14.join(home, s.slice(1));
+    s = path15.join(home, s.slice(1));
   }
-  if (!path14.isAbsolute(s)) {
-    s = path14.resolve(workspaceRoot, s);
+  if (!path15.isAbsolute(s)) {
+    s = path15.resolve(workspaceRoot, s);
   }
-  const resolved = path14.normalize(s);
+  const resolved = path15.normalize(s);
   if (resolved === "/" || resolved === home) {
     return null;
   }
   for (const sub of SENSITIVE_HOME_SUBDIRS) {
-    const sensitive = path14.join(home, sub);
-    if (resolved === sensitive || resolved.startsWith(`${sensitive}${path14.sep}`)) {
+    const sensitive = path15.join(home, sub);
+    if (resolved === sensitive || resolved.startsWith(`${sensitive}${path15.sep}`)) {
       return null;
     }
   }
-  const relWorkspace = path14.relative(workspaceRoot, resolved);
-  const relHome = path14.relative(home, resolved);
-  const escapesWorkspace = relWorkspace.startsWith("..") || path14.isAbsolute(relWorkspace);
-  const escapesHome = relHome.startsWith("..") || path14.isAbsolute(relHome);
+  const relWorkspace = path15.relative(workspaceRoot, resolved);
+  const relHome = path15.relative(home, resolved);
+  const escapesWorkspace = relWorkspace.startsWith("..") || path15.isAbsolute(relWorkspace);
+  const escapesHome = relHome.startsWith("..") || path15.isAbsolute(relHome);
   if (escapesWorkspace && escapesHome) {
     return null;
   }
@@ -16707,15 +16832,15 @@ async function readJsoncSettings(settingsPath) {
   putSettingsCache(settingsPath, { mtimeMs, parsed: payload });
   return payload;
 }
-function putSettingsCache(path37, entry) {
-  if (!settingsCache.has(path37) && settingsCache.size >= MAX_SETTINGS_CACHE_SIZE) {
+function putSettingsCache(path38, entry) {
+  if (!settingsCache.has(path38) && settingsCache.size >= MAX_SETTINGS_CACHE_SIZE) {
     settingsCache.delete(settingsCache.keys().next().value);
   }
-  settingsCache.set(path37, entry);
+  settingsCache.set(path38, entry);
 }
 async function readCopilotCustomLocations(workspaceRoot) {
   const parsed = await readJsoncSettings(
-    path14.join(workspaceRoot, ".vscode", "settings.json")
+    path15.join(workspaceRoot, ".vscode", "settings.json")
   );
   if (!parsed) {
     return [];
@@ -16762,7 +16887,7 @@ async function readCopilotCustomLocations(workspaceRoot) {
 async function readClaudeCodeCustomLocations() {
   const home = homedir();
   const parsed = await readJsoncSettings(
-    path14.join(home, ".claude", "settings.json")
+    path15.join(home, ".claude", "settings.json")
   );
   if (!parsed) {
     return [];
@@ -16804,7 +16929,7 @@ function groupSkills(files, root, baseDir) {
   const folderMap = /* @__PURE__ */ new Map();
   const standalone = [];
   for (const f of skillFiles) {
-    const rel = path14.relative(baseDir, f.path).replace(/\\/g, "/");
+    const rel = path15.relative(baseDir, f.path).replace(/\\/g, "/");
     const skillsMarker = "skills/";
     const skillsIdx = rel.indexOf(skillsMarker);
     if (skillsIdx === -1) {
@@ -16831,8 +16956,8 @@ function groupSkills(files, root, baseDir) {
   }
   const groups = [];
   for (const f of standalone) {
-    const name = path14.basename(f.path, path14.extname(f.path));
-    const standaloneRel = path14.relative(baseDir, f.path).replace(/\\/g, "/");
+    const name = path15.basename(f.path, path15.extname(f.path));
+    const standaloneRel = path15.relative(baseDir, f.path).replace(/\\/g, "/");
     const sessionKey = `skill:${root}:${standaloneRel}`;
     groups.push({
       name,
@@ -16846,7 +16971,7 @@ function groupSkills(files, root, baseDir) {
   }
   for (const [folderKey, { folderName, files: folderFiles }] of folderMap) {
     const maxMtimeMs = Math.max(...folderFiles.map((f) => f.mtimeMs));
-    const skillPath = path14.join(baseDir, folderKey);
+    const skillPath = path15.join(baseDir, folderKey);
     const sessionKey = `skill:${root}:${folderKey}`;
     groups.push({
       name: folderName,
@@ -16967,10 +17092,10 @@ async function enumerateGlob(pattern, cwd, category, isDynamic) {
   } catch {
     return [];
   }
-  return files.map((path37) => ({ path: path37, category }));
+  return files.map((path38) => ({ path: path38, category }));
 }
 async function enumerateSkillBundle(baseDir, skillsRoot) {
-  const skillsDir = path14.resolve(baseDir, skillsRoot);
+  const skillsDir = path15.resolve(baseDir, skillsRoot);
   let manifests;
   try {
     manifests = await globby2("*/SKILL.md", {
@@ -16986,7 +17111,7 @@ async function enumerateSkillBundle(baseDir, skillsRoot) {
   }
   const perSkillResults = await Promise.all(
     manifests.map(async (manifest) => {
-      const skillDir = path14.dirname(manifest);
+      const skillDir = path15.dirname(manifest);
       try {
         return await globby2("**/*", {
           cwd: skillDir,
@@ -17035,11 +17160,11 @@ async function enumerateSymlinkedSkills(skillsDir) {
   const results = [];
   for (const entry of dirEntries) {
     if (!entry.isSymbolicLink()) continue;
-    const entryPath = path14.join(skillsDir, entry.name);
+    const entryPath = path15.join(skillsDir, entry.name);
     try {
       const st = await stat(entryPath);
       if (st.isDirectory()) {
-        const hasManifest = await stat(path14.join(entryPath, "SKILL.md")).then(() => true).catch(() => false);
+        const hasManifest = await stat(path15.join(entryPath, "SKILL.md")).then(() => true).catch(() => false);
         if (!hasManifest) continue;
         const realDir = await realpath(entryPath);
         const realFiles = await globby2("**/*", {
@@ -17052,7 +17177,7 @@ async function enumerateSymlinkedSkills(skillsDir) {
         }).catch(() => []);
         for (const f of realFiles) {
           results.push({
-            path: path14.join(entryPath, path14.relative(realDir, f)),
+            path: path15.join(entryPath, path15.relative(realDir, f)),
             category: "skill"
           });
         }
@@ -17084,11 +17209,11 @@ function scopeForRoot(root) {
   return void 0;
 }
 function deriveIdentifier(filePath, baseDir) {
-  const relative2 = path14.relative(baseDir, filePath);
+  const relative2 = path15.relative(baseDir, filePath);
   if (!relative2.startsWith("..")) {
     return relative2.replace(/\\/g, "/");
   }
-  return path14.basename(filePath);
+  return path15.basename(filePath);
 }
 
 // src/features/analysis/skill_quarantine/enumerateInstalledSkills.ts
@@ -17100,8 +17225,8 @@ async function enumerateInstalledSkills(workspaceRoot) {
   );
   const home = homedir2();
   const agentGroups = regularFiles.filter((f) => f.category === "agent-config").map((f) => ({
-    name: path15.basename(f.path, path15.extname(f.path)),
-    root: f.path.startsWith(home + path15.sep) ? "home" : "workspace",
+    name: path16.basename(f.path, path16.extname(f.path)),
+    root: f.path.startsWith(home + path16.sep) ? "home" : "workspace",
     skillPath: f.path,
     files: [f],
     isFolder: false,
@@ -17185,32 +17310,32 @@ import {
   unlink,
   writeFile
 } from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 import AdmZip4 from "adm-zip";
 
 // src/features/analysis/skill_quarantine/paths.ts
 import { homedir as homedir3 } from "os";
-import path16 from "path";
+import path17 from "path";
 function getQuarantineRoot() {
-  return path16.join(homedir3(), ".tracy", "quarantine", "claude", "skills");
+  return path17.join(homedir3(), ".tracy", "quarantine", "claude", "skills");
 }
 function getQuarantineZipPath(md5) {
-  return path16.join(getQuarantineRoot(), `${md5}.zip`);
+  return path17.join(getQuarantineRoot(), `${md5}.zip`);
 }
 function getTmpZipPath(md5, uuid) {
-  return path16.join(getQuarantineRoot(), `${md5}_tmp_${uuid}.zip`);
+  return path17.join(getQuarantineRoot(), `${md5}_tmp_${uuid}.zip`);
 }
 var TMP_ZIP_REGEX = /^([0-9a-f]{32})_tmp_[0-9a-f-]+\.zip$/;
 var COMMITTED_ZIP_REGEX = /^([0-9a-f]{32})\.zip$/;
 
 // src/features/analysis/skill_quarantine/stubTemplate.ts
-import path17 from "path";
+import path18 from "path";
 import { quote } from "shell-quote";
 var LEGACY_SUMMARY_FALLBACK = "not available (scan predates current schema)";
 function renderStub(params) {
   const folderOrFile = params.isFolder ? "skill folder" : "skill file";
   const reason = params.summary ?? LEGACY_SUMMARY_FALLBACK;
-  const extractParent = path17.dirname(params.origPath);
+  const extractParent = path18.dirname(params.origPath);
   const recoverCommand = `rm -rf ${quote([params.origPath])} && unzip -o ${quote([params.quarantinedZipPath])} -d ${quote([extractParent])}`;
   return `# ${STUB_MARKER}
 
@@ -17324,7 +17449,7 @@ async function quarantineSkill(params) {
 }
 async function preregisterStubMd5(params) {
   const { skillPath, isFolder, origName, log: log2 } = params;
-  const stubFilePath = isFolder ? path18.join(skillPath, "SKILL.md") : skillPath;
+  const stubFilePath = isFolder ? path19.join(skillPath, "SKILL.md") : skillPath;
   const stubEntryName = isFolder ? `${origName}/SKILL.md` : origName;
   const content = await readFile2(stubFilePath, "utf-8");
   const fileStat = await stat2(stubFilePath);
@@ -17337,7 +17462,7 @@ async function preregisterStubMd5(params) {
     mtimeMs: fileStat.mtimeMs
   };
   const stubGroup = {
-    name: isFolder ? origName : path18.basename(skillPath, path18.extname(skillPath)),
+    name: isFolder ? origName : path19.basename(skillPath, path19.extname(skillPath)),
     root: "workspace",
     // unused by md5 computation
     skillPath,
@@ -17384,7 +17509,7 @@ async function writeStub(params) {
   if (isFolder) {
     await rm(skillPath, { recursive: true, force: true });
     await mkdir(skillPath, { recursive: true });
-    await writeFile(path18.join(skillPath, "SKILL.md"), stubContent, "utf8");
+    await writeFile(path19.join(skillPath, "SKILL.md"), stubContent, "utf8");
   } else {
     await writeFile(skillPath, stubContent, "utf8");
   }
@@ -17406,7 +17531,7 @@ async function reconcileAndSweep(log2) {
   for (const entry of entries) {
     const md5 = TMP_ZIP_REGEX.exec(entry)?.[1];
     if (md5 === void 0) continue;
-    const full = path18.join(root, entry);
+    const full = path19.join(root, entry);
     if (committed.has(md5)) {
       await unlink(full).catch(
         (err) => log2.warn(
@@ -17466,8 +17591,8 @@ async function addFolderAsync(zip, root, prefix) {
   async function walk(dir, relPrefix) {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const e of entries) {
-      const full = path18.join(dir, e.name);
-      const rel = path18.posix.join(relPrefix, e.name);
+      const full = path19.join(dir, e.name);
+      const rel = path19.posix.join(relPrefix, e.name);
       if (e.isDirectory()) await walk(full, rel);
       else if (e.isFile()) zip.addFile(rel, await readFile2(full));
     }
@@ -17513,8 +17638,8 @@ var SKILL_PARENT_DIRS = [
 async function getSkillDirsMtimeMs(cwd) {
   const home = homedir4();
   const dirs = SKILL_PARENT_DIRS.flatMap((d) => [
-    path19.join(cwd, d),
-    path19.join(home, d)
+    path20.join(cwd, d),
+    path20.join(home, d)
   ]);
   let max = 0;
   for (const dir of dirs) {
@@ -17627,9 +17752,9 @@ async function runQuarantineCheckIfNeeded(opts) {
 }
 
 // src/features/claude_code/daemon_pid_file.ts
-import fs13 from "fs";
-import os4 from "os";
-import path20 from "path";
+import fs14 from "fs";
+import os5 from "os";
+import path21 from "path";
 
 // src/features/claude_code/data_collector_constants.ts
 var CC_VERSION_CACHE_KEY = "claudeCode.detectedCCVersion";
@@ -17655,26 +17780,26 @@ var DAEMON_SHUTDOWN_DRAIN_MS = 6e3;
 
 // src/features/claude_code/daemon_pid_file.ts
 function getMobbdevDir() {
-  return path20.join(os4.homedir(), ".mobbdev");
+  return path21.join(os5.homedir(), ".mobbdev");
 }
 function getDaemonCheckScriptPath() {
-  return path20.join(getMobbdevDir(), "daemon-check.js");
+  return path21.join(getMobbdevDir(), "daemon-check.js");
 }
 var DaemonPidFile = class {
   constructor() {
     __publicField(this, "data", null);
   }
   get filePath() {
-    return path20.join(getMobbdevDir(), "daemon.pid");
+    return path21.join(getMobbdevDir(), "daemon.pid");
   }
   /** Ensure ~/.mobbdev/ directory exists. */
   ensureDir() {
-    fs13.mkdirSync(getMobbdevDir(), { recursive: true });
+    fs14.mkdirSync(getMobbdevDir(), { recursive: true });
   }
   /** Read the PID file from disk. Returns the parsed data or null. */
   read() {
     try {
-      const raw = fs13.readFileSync(this.filePath, "utf8");
+      const raw = fs14.readFileSync(this.filePath, "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.pid !== "number" || typeof parsed.startedAt !== "number" || typeof parsed.heartbeat !== "number") {
         this.data = null;
@@ -17694,14 +17819,14 @@ var DaemonPidFile = class {
       heartbeat: Date.now(),
       version
     };
-    fs13.writeFileSync(this.filePath, JSON.stringify(this.data), "utf8");
+    fs14.writeFileSync(this.filePath, JSON.stringify(this.data), "utf8");
   }
   /** Update the heartbeat timestamp of the current PID file. */
   updateHeartbeat() {
     if (!this.data) this.read();
     if (!this.data) return;
     this.data.heartbeat = Date.now();
-    fs13.writeFileSync(this.filePath, JSON.stringify(this.data), "utf8");
+    fs14.writeFileSync(this.filePath, JSON.stringify(this.data), "utf8");
   }
   /** Check whether the previously read PID data represents a live daemon. */
   isAlive() {
@@ -17718,7 +17843,7 @@ var DaemonPidFile = class {
   remove() {
     this.data = null;
     try {
-      fs13.unlinkSync(this.filePath);
+      fs14.unlinkSync(this.filePath);
     } catch {
     }
   }
@@ -17728,7 +17853,7 @@ var DaemonPidFile = class {
 import { execFile } from "child_process";
 import { createHash as createHash3 } from "crypto";
 import { access as access2, open as open4, readdir as readdir3, readFile as readFile3, unlink as unlink2 } from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 import { promisify } from "util";
 
 // src/features/analysis/context_file_uploader.ts
@@ -18092,8 +18217,8 @@ function createConfigstoreStream(store, opts) {
       heartbeatBuffer.length = 0;
     }
   }
-  function setScopePath(path37) {
-    scopePath = path37;
+  function setScopePath(path38) {
+    scopePath = path38;
   }
   return { writable, flush, setScopePath };
 }
@@ -18175,22 +18300,22 @@ function createDdBatch(config2) {
 
 // src/utils/shared-logger/hostname.ts
 import { createHash as createHash2 } from "crypto";
-import os5 from "os";
+import os6 from "os";
 function hashString(input) {
   return createHash2("sha256").update(input).digest("hex").slice(0, 16);
 }
 function getPlainHostname() {
   try {
-    return `${os5.userInfo().username}@${os5.hostname()}`;
+    return `${os6.userInfo().username}@${os6.hostname()}`;
   } catch {
-    return `unknown@${os5.hostname()}`;
+    return `unknown@${os6.hostname()}`;
   }
 }
 function getHashedHostname() {
   try {
-    return `${hashString(os5.userInfo().username)}@${hashString(os5.hostname())}`;
+    return `${hashString(os6.userInfo().username)}@${hashString(os6.hostname())}`;
   } catch {
-    return `unknown@${hashString(os5.hostname())}`;
+    return `unknown@${hashString(os6.hostname())}`;
   }
 }
 
@@ -18317,7 +18442,7 @@ function createLogger(config2) {
 
 // src/features/claude_code/hook_logger.ts
 var DD_RUM_TOKEN = true ? "pubf59c0182545bfb4c299175119f1abf9b" : "";
-var CLI_VERSION = true ? "1.4.48" : "unknown";
+var CLI_VERSION = true ? "1.4.49" : "unknown";
 var NAMESPACE = "mobbdev-claude-code-hook-logs";
 var claudeCodeVersion;
 function buildDdTags() {
@@ -18434,12 +18559,12 @@ async function resolveTranscriptPath(transcriptPath, sessionId) {
     return transcriptPath;
   } catch {
   }
-  const filename = path21.basename(transcriptPath);
-  const dirName = path21.basename(path21.dirname(transcriptPath));
-  const projectsDir = path21.dirname(path21.dirname(transcriptPath));
+  const filename = path22.basename(transcriptPath);
+  const dirName = path22.basename(path22.dirname(transcriptPath));
+  const projectsDir = path22.dirname(path22.dirname(transcriptPath));
   const baseDirName = dirName.replace(/[-.]claude-worktrees-.+$/, "");
   if (baseDirName !== dirName) {
-    const candidate = path21.join(projectsDir, baseDirName, filename);
+    const candidate = path22.join(projectsDir, baseDirName, filename);
     try {
       await access2(candidate);
       hookLog.info(
@@ -18461,7 +18586,7 @@ async function resolveTranscriptPath(transcriptPath, sessionId) {
     const dirs = await readdir3(projectsDir);
     for (const dir of dirs) {
       if (dir === dirName) continue;
-      const candidate = path21.join(projectsDir, dir, filename);
+      const candidate = path22.join(projectsDir, dir, filename);
       try {
         await access2(candidate);
         hookLog.info(
@@ -18683,7 +18808,7 @@ async function cleanupStaleSessions(configDir) {
     );
     let deletedCount = 0;
     for (const file of sessionFiles) {
-      const filePath = path21.join(configDir, file);
+      const filePath = path22.join(configDir, file);
       try {
         const content = JSON.parse(await readFile3(filePath, "utf-8"));
         let newest = 0;
@@ -18980,17 +19105,17 @@ function summarizeUploadErrTypes(errs) {
 }
 
 // src/features/claude_code/install_hook.ts
-import fs14 from "fs";
+import fs15 from "fs";
 import fsPromises4 from "fs/promises";
-import os6 from "os";
-import path22 from "path";
+import os7 from "os";
+import path23 from "path";
 import chalk11 from "chalk";
 
 // src/features/claude_code/daemon-check-shim.tmpl.js
 var daemon_check_shim_tmpl_default = "// Mobb daemon shim \u2014 checks if daemon is alive, spawns if dead.\n// Auto-generated by mobbdev CLI. Do not edit.\nvar fs = require('fs')\nvar spawn = require('child_process').spawn\nvar path = require('path')\nvar os = require('os')\n\nvar pidFile = path.join(os.homedir(), '.mobbdev', 'daemon.pid')\nvar HEARTBEAT_STALE_MS = __HEARTBEAT_STALE_MS__\n\ntry {\n  var data = JSON.parse(fs.readFileSync(pidFile, 'utf8'))\n  if (Date.now() - data.heartbeat > HEARTBEAT_STALE_MS) throw new Error('stale')\n  process.kill(data.pid, 0) // throws ESRCH if the process is gone\n} catch (e) {\n  var localCli = process.env.MOBBDEV_LOCAL_CLI\n  var child = localCli\n    ? spawn('node', [localCli, 'claude-code-daemon'], { detached: true, stdio: 'ignore', windowsHide: true })\n    : spawn('npx', ['--yes', 'mobbdev@latest', 'claude-code-daemon'], { detached: true, stdio: 'ignore', shell: true, windowsHide: true })\n  child.unref()\n}\n";
 
 // src/features/claude_code/install_hook.ts
-var CLAUDE_SETTINGS_PATH = path22.join(os6.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = path23.join(os7.homedir(), ".claude", "settings.json");
 var RECOMMENDED_MATCHER = "*";
 async function claudeSettingsExists() {
   try {
@@ -19025,8 +19150,8 @@ function getDaemonCheckScript() {
   );
 }
 function writeDaemonCheckScript() {
-  fs14.mkdirSync(getMobbdevDir(), { recursive: true });
-  fs14.writeFileSync(getDaemonCheckScriptPath(), getDaemonCheckScript(), "utf8");
+  fs15.mkdirSync(getMobbdevDir(), { recursive: true });
+  fs15.writeFileSync(getDaemonCheckScriptPath(), getDaemonCheckScript(), "utf8");
 }
 function buildHookCommand(envPrefix) {
   const nodeBin = process.execPath || "node";
@@ -19137,17 +19262,17 @@ async function installMobbHooks(options = {}) {
 
 // src/features/claude_code/transcript_scanner.ts
 import { lstat as lstat2, open as open5, readdir as readdir4, stat as stat4 } from "fs/promises";
-import os7 from "os";
-import path23 from "path";
+import os8 from "os";
+import path24 from "path";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function getClaudeProjectsDirs() {
   const dirs = [];
   const configDir = process.env["CLAUDE_CONFIG_DIR"];
   if (configDir) {
-    dirs.push(path23.join(configDir, "projects"));
+    dirs.push(path24.join(configDir, "projects"));
   }
-  dirs.push(path23.join(os7.homedir(), ".config", "claude", "projects"));
-  dirs.push(path23.join(os7.homedir(), ".claude", "projects"));
+  dirs.push(path24.join(os8.homedir(), ".config", "claude", "projects"));
+  dirs.push(path24.join(os8.homedir(), ".claude", "projects"));
   return dirs;
 }
 var META_MAX_BYTES = 4096;
@@ -19203,7 +19328,7 @@ async function collectJsonlFiles(files, dir, projectDir, seen, now, results, ove
       sessionId = basename2;
       isSubagent = false;
     }
-    const filePath = path23.join(dir, file);
+    const filePath = path24.join(dir, file);
     if (seen.has(filePath)) continue;
     seen.add(filePath);
     let fileStat;
@@ -19237,7 +19362,7 @@ async function scanForTranscripts(projectsDirs = getClaudeProjectsDirs()) {
       continue;
     }
     for (const projName of projectDirs) {
-      const projPath = path23.join(projectsDir, projName);
+      const projPath = path24.join(projectsDir, projName);
       let projStat;
       try {
         projStat = await stat4(projPath);
@@ -19254,7 +19379,7 @@ async function scanForTranscripts(projectsDirs = getClaudeProjectsDirs()) {
       await collectJsonlFiles(files, projPath, projPath, seen, now, results);
       for (const entry of files) {
         if (!UUID_RE.test(entry)) continue;
-        const subagentsDir = path23.join(projPath, entry, "subagents");
+        const subagentsDir = path24.join(projPath, entry, "subagents");
         if (knownAbsentSubagentDirs.has(subagentsDir)) continue;
         try {
           const s = await stat4(subagentsDir);
@@ -19360,8 +19485,8 @@ async function startDaemon() {
   const sessionCwdCache = /* @__PURE__ */ new Map();
   let lastContextScanMs = 0;
   const machineContext = {
-    cpuCount: os8.cpus().length,
-    totalMemGB: Math.round(os8.totalmem() / 1024 ** 3),
+    cpuCount: os9.cpus().length,
+    totalMemGB: Math.round(os9.totalmem() / 1024 ** 3),
     nodeVersion: process.version
   };
   while (true) {
@@ -19384,7 +19509,7 @@ async function startDaemon() {
       for (const transcript of changed) {
         const sessionStore = createSessionConfigStore(transcript.sessionId);
         if (!cleanupConfigDir) {
-          cleanupConfigDir = path24.dirname(sessionStore.path);
+          cleanupConfigDir = path25.dirname(sessionStore.path);
         }
         pidFile.updateHeartbeat();
         const drainStart = Date.now();
@@ -19672,6 +19797,12 @@ var claudeCodeDaemonBuilder = (yargs2) => {
   ).strict();
 };
 var claudeCodeInstallHookHandler = async (argv) => {
+  if (isStandaloneBinary()) {
+    console.error(
+      "Claude Code hooks are not available in the standalone mobbdev binary (they need a Node.js runtime). Install them with the npm package instead: npx mobbdev@latest claude-code-install-hook"
+    );
+    process.exit(1);
+  }
   try {
     await getAuthenticatedGQLClient({ isSkipPrompts: false });
     await installMobbHooks({ saveEnv: argv["save-env"] });
@@ -19740,8 +19871,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(path37) {
-    this.knownWorkspacePath = path37;
+  static setKnownWorkspacePath(path38) {
+    this.knownWorkspacePath = path38;
   }
   /**
    * Gets the known workspace path that was previously validated
@@ -19882,7 +20013,7 @@ var logDebug = (message, data) => logger2.log(message, "debug", data);
 var log = logger2.log.bind(logger2);
 
 // src/mcp/services/McpGQLClient.ts
-import os9 from "os";
+import os10 from "os";
 init_client_generates();
 init_configs();
 
@@ -20393,7 +20524,7 @@ var McpGQLClient = class extends GQLClient {
         projectId: params.projectId ?? null,
         repoUrl: params.repoUrl ?? null,
         riskCount: params.riskCount ?? null,
-        computerName: os9.hostname(),
+        computerName: os10.hostname(),
         computerUser: getComputerUser() ?? null,
         clientVersion: packageJson.version
       });
@@ -20676,9 +20807,9 @@ async function createAuthenticatedMcpGQLClient({
 
 // src/mcp/services/McpUsageService/host.ts
 import { execSync as execSync2 } from "child_process";
-import fs15 from "fs";
-import os10 from "os";
-import path25 from "path";
+import fs16 from "fs";
+import os11 from "os";
+import path26 from "path";
 var IDEs = ["cursor", "windsurf", "webstorm", "vscode", "claude"];
 var runCommand = (cmd) => {
   try {
@@ -20692,18 +20823,18 @@ var gitInfo = {
   email: runCommand("git config user.email")
 };
 var getClaudeWorkspacePaths = () => {
-  const home = os10.homedir();
-  const claudeIdePath = path25.join(home, ".claude", "ide");
+  const home = os11.homedir();
+  const claudeIdePath = path26.join(home, ".claude", "ide");
   const workspacePaths = [];
-  if (!fs15.existsSync(claudeIdePath)) {
+  if (!fs16.existsSync(claudeIdePath)) {
     return workspacePaths;
   }
   try {
-    const lockFiles = fs15.readdirSync(claudeIdePath).filter((file) => file.endsWith(".lock"));
+    const lockFiles = fs16.readdirSync(claudeIdePath).filter((file) => file.endsWith(".lock"));
     for (const lockFile of lockFiles) {
-      const lockFilePath = path25.join(claudeIdePath, lockFile);
+      const lockFilePath = path26.join(claudeIdePath, lockFile);
       try {
-        const lockContent = JSON.parse(fs15.readFileSync(lockFilePath, "utf8"));
+        const lockContent = JSON.parse(fs16.readFileSync(lockFilePath, "utf8"));
         if (lockContent.workspaceFolders && Array.isArray(lockContent.workspaceFolders)) {
           workspacePaths.push(...lockContent.workspaceFolders);
         }
@@ -20721,29 +20852,29 @@ var getClaudeWorkspacePaths = () => {
   return workspacePaths;
 };
 var getMCPConfigPaths = (hostName) => {
-  const home = os10.homedir();
+  const home = os11.homedir();
   const currentDir = process.env["WORKSPACE_FOLDER_PATHS"] || process.env["PWD"] || process.cwd();
   switch (hostName.toLowerCase()) {
     case "cursor":
       return [
-        path25.join(currentDir, ".cursor", "mcp.json"),
+        path26.join(currentDir, ".cursor", "mcp.json"),
         // local first
-        path25.join(home, ".cursor", "mcp.json")
+        path26.join(home, ".cursor", "mcp.json")
       ];
     case "windsurf":
       return [
-        path25.join(currentDir, ".codeium", "mcp_config.json"),
+        path26.join(currentDir, ".codeium", "mcp_config.json"),
         // local first
-        path25.join(home, ".codeium", "windsurf", "mcp_config.json")
+        path26.join(home, ".codeium", "windsurf", "mcp_config.json")
       ];
     case "webstorm":
       return [];
     case "visualstudiocode":
     case "vscode":
       return [
-        path25.join(currentDir, ".vscode", "mcp.json"),
+        path26.join(currentDir, ".vscode", "mcp.json"),
         // local first
-        process.platform === "win32" ? path25.join(home, "AppData", "Roaming", "Code", "User", "mcp.json") : path25.join(
+        process.platform === "win32" ? path26.join(home, "AppData", "Roaming", "Code", "User", "mcp.json") : path26.join(
           home,
           "Library",
           "Application Support",
@@ -20754,13 +20885,13 @@ var getMCPConfigPaths = (hostName) => {
       ];
     case "claude": {
       const claudePaths = [
-        path25.join(currentDir, ".claude.json"),
+        path26.join(currentDir, ".claude.json"),
         // local first
-        path25.join(home, ".claude.json")
+        path26.join(home, ".claude.json")
       ];
       const workspacePaths = getClaudeWorkspacePaths();
       for (const workspacePath of workspacePaths) {
-        claudePaths.push(path25.join(workspacePath, ".mcp.json"));
+        claudePaths.push(path26.join(workspacePath, ".mcp.json"));
       }
       return claudePaths;
     }
@@ -20769,9 +20900,9 @@ var getMCPConfigPaths = (hostName) => {
   }
 };
 var readConfigFile = (filePath) => {
-  if (!fs15.existsSync(filePath)) return null;
+  if (!fs16.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs15.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs16.readFileSync(filePath, "utf8"));
   } catch (error) {
     logWarn(`[UsageService] Failed to read MCP config: ${filePath}`);
     return null;
@@ -20811,7 +20942,7 @@ var readMCPConfig = (hostName) => {
 };
 var getRunningProcesses = () => {
   try {
-    return os10.platform() === "win32" ? execSync2("tasklist", { encoding: "utf8" }) : execSync2("ps aux", { encoding: "utf8" });
+    return os11.platform() === "win32" ? execSync2("tasklist", { encoding: "utf8" }) : execSync2("ps aux", { encoding: "utf8" });
   } catch {
     return "";
   }
@@ -20886,7 +21017,7 @@ var versionCommands = {
   }
 };
 var getProcessInfo = (pid) => {
-  const platform2 = os10.platform();
+  const platform2 = os11.platform();
   try {
     if (platform2 === "linux" || platform2 === "darwin") {
       const output = execSync2(`ps -o pid=,ppid=,comm= -p ${pid}`, {
@@ -20921,10 +21052,10 @@ var getHostInfo = (additionalMcpList) => {
   const ideConfigPaths = /* @__PURE__ */ new Set();
   for (const ide of IDEs) {
     const configPaths = getMCPConfigPaths(ide);
-    configPaths.forEach((path37) => ideConfigPaths.add(path37));
+    configPaths.forEach((path38) => ideConfigPaths.add(path38));
   }
   const uniqueAdditionalPaths = additionalMcpList.filter(
-    (path37) => !ideConfigPaths.has(path37)
+    (path38) => !ideConfigPaths.has(path38)
   );
   for (const ide of IDEs) {
     const cfg = readMCPConfig(ide);
@@ -21005,7 +21136,7 @@ var getHostInfo = (additionalMcpList) => {
     const config2 = allConfigs[ide] || null;
     const ideName = ide.charAt(0).toUpperCase() + ide.slice(1) || "Unknown";
     let ideVersion = "Unknown";
-    const platform2 = os10.platform();
+    const platform2 = os11.platform();
     const cmds = versionCommands[ideName]?.[platform2] ?? [];
     for (const cmd of cmds) {
       try {
@@ -21038,15 +21169,15 @@ var getHostInfo = (additionalMcpList) => {
 
 // src/mcp/services/McpUsageService/McpUsageService.ts
 import fetch6 from "node-fetch";
-import os12 from "os";
+import os13 from "os";
 import { v4 as uuidv42, v5 as uuidv5 } from "uuid";
 init_configs();
 
 // src/mcp/services/McpUsageService/system.ts
 init_configs();
-import fs16 from "fs";
-import os11 from "os";
-import path26 from "path";
+import fs17 from "fs";
+import os12 from "os";
+import path27 from "path";
 var MAX_DEPTH = 2;
 var patterns = ["mcp", "claude"];
 var isFileMatch = (fileName) => {
@@ -21055,7 +21186,7 @@ var isFileMatch = (fileName) => {
 };
 var safeAccess = async (filePath) => {
   try {
-    await fs16.promises.access(filePath, fs16.constants.R_OK);
+    await fs17.promises.access(filePath, fs17.constants.R_OK);
     return true;
   } catch {
     return false;
@@ -21064,9 +21195,9 @@ var safeAccess = async (filePath) => {
 var searchDir = async (dir, depth = 0) => {
   const results = [];
   if (depth > MAX_DEPTH) return results;
-  const entries = await fs16.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs17.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
-    const fullPath = path26.join(dir, entry.name);
+    const fullPath = path27.join(dir, entry.name);
     if (entry.isFile() && isFileMatch(entry.name)) {
       results.push(fullPath);
     } else if (entry.isDirectory()) {
@@ -21080,17 +21211,17 @@ var searchDir = async (dir, depth = 0) => {
 };
 var findSystemMCPConfigs = async () => {
   try {
-    const home = os11.homedir();
-    const platform2 = os11.platform();
+    const home = os12.homedir();
+    const platform2 = os12.platform();
     const knownDirs = platform2 === "win32" ? [
-      path26.join(home, ".cursor"),
-      path26.join(home, "Documents"),
-      path26.join(home, "Downloads")
+      path27.join(home, ".cursor"),
+      path27.join(home, "Documents"),
+      path27.join(home, "Downloads")
     ] : [
-      path26.join(home, ".cursor"),
-      process.env["XDG_CONFIG_HOME"] || path26.join(home, ".config"),
-      path26.join(home, "Documents"),
-      path26.join(home, "Downloads")
+      path27.join(home, ".cursor"),
+      process.env["XDG_CONFIG_HOME"] || path27.join(home, ".config"),
+      path27.join(home, "Documents"),
+      path27.join(home, "Downloads")
     ];
     const timeoutPromise = new Promise(
       (resolve) => setTimeout(() => {
@@ -21102,7 +21233,7 @@ var findSystemMCPConfigs = async () => {
     );
     const searchPromise = Promise.all(
       knownDirs.map(
-        (dir) => fs16.existsSync(dir) ? searchDir(dir) : Promise.resolve([])
+        (dir) => fs17.existsSync(dir) ? searchDir(dir) : Promise.resolve([])
       )
     ).then((results) => results.flat());
     return await Promise.race([timeoutPromise, searchPromise]);
@@ -21153,7 +21284,7 @@ var McpUsageService = class {
   generateHostId() {
     const stored = configStore.get(this.configKey);
     if (stored?.mcpHostId) return stored.mcpHostId;
-    const interfaces = os12.networkInterfaces();
+    const interfaces = os13.networkInterfaces();
     const macs = [];
     for (const iface of Object.values(interfaces)) {
       if (!iface) continue;
@@ -21161,7 +21292,7 @@ var McpUsageService = class {
         if (net.mac && net.mac !== "00:00:00:00:00:00") macs.push(net.mac);
       }
     }
-    const macString = macs.length ? macs.sort().join(",") : `${os12.hostname()}-${uuidv42()}`;
+    const macString = macs.length ? macs.sort().join(",") : `${os13.hostname()}-${uuidv42()}`;
     const hostId = uuidv5(macString, uuidv5.DNS);
     logDebug("[UsageService] Generated new host ID", { hostId });
     return hostId;
@@ -21184,7 +21315,7 @@ var McpUsageService = class {
       mcpHostId,
       organizationId,
       mcpVersion: packageJson.version,
-      mcpOsName: os12.platform(),
+      mcpOsName: os13.platform(),
       mcps: JSON.stringify(mcps),
       status,
       userName: user.name,
@@ -23505,31 +23636,31 @@ For a complete security audit workflow, use the \`full-security-audit\` prompt.
 };
 
 // src/mcp/services/McpDetectionService/CursorMcpDetectionService.ts
-import * as fs19 from "fs";
-import * as os14 from "os";
-import * as path28 from "path";
+import * as fs20 from "fs";
+import * as os15 from "os";
+import * as path29 from "path";
 
 // src/mcp/services/McpDetectionService/BaseMcpDetectionService.ts
 init_configs();
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 import fetch7 from "node-fetch";
-import * as path27 from "path";
+import * as path28 from "path";
 
 // src/mcp/services/McpDetectionService/McpDetectionServiceUtils.ts
-import * as fs17 from "fs";
-import * as os13 from "os";
+import * as fs18 from "fs";
+import * as os14 from "os";
 
 // src/mcp/services/McpDetectionService/VscodeMcpDetectionService.ts
-import * as fs20 from "fs";
-import * as os15 from "os";
-import * as path29 from "path";
+import * as fs21 from "fs";
+import * as os16 from "os";
+import * as path30 from "path";
 
 // src/mcp/tools/checkForNewAvailableFixes/CheckForNewAvailableFixesTool.ts
 import { z as z37 } from "zod";
 
 // src/mcp/services/PathValidation.ts
-import fs21 from "fs";
-import path30 from "path";
+import fs22 from "fs";
+import path31 from "path";
 async function validatePath(inputPath) {
   logDebug("Validating MCP path", { inputPath });
   if (/^\/[a-zA-Z]:\//.test(inputPath)) {
@@ -23561,7 +23692,7 @@ async function validatePath(inputPath) {
     logError(error);
     return { isValid: false, error, path: inputPath };
   }
-  const normalizedPath = path30.normalize(inputPath);
+  const normalizedPath = path31.normalize(inputPath);
   if (normalizedPath.includes("..")) {
     const error = `Normalized path contains path traversal patterns: ${inputPath}`;
     logError(error);
@@ -23588,7 +23719,7 @@ async function validatePath(inputPath) {
   logDebug("Path validation successful", { inputPath });
   logDebug("Checking path existence", { inputPath });
   try {
-    await fs21.promises.access(inputPath);
+    await fs22.promises.access(inputPath);
     logDebug("Path exists and is accessible", { inputPath });
     WorkspaceService.setKnownWorkspacePath(inputPath);
     logDebug("Stored validated path in WorkspaceService", { inputPath });
@@ -24342,10 +24473,10 @@ If you wish to scan files that were recently changed in your git history call th
 init_FileUtils();
 init_GitService();
 init_configs();
-import fs22 from "fs/promises";
+import fs23 from "fs/promises";
 import nodePath from "path";
 var getLocalFiles = async ({
-  path: path37,
+  path: path38,
   maxFileSize = MCP_MAX_FILE_SIZE,
   maxFiles,
   isAllFilesScan,
@@ -24353,17 +24484,17 @@ var getLocalFiles = async ({
   scanRecentlyChangedFiles
 }) => {
   logDebug(`[${scanContext}] Starting getLocalFiles`, {
-    path: path37,
+    path: path38,
     maxFileSize,
     maxFiles,
     isAllFilesScan,
     scanRecentlyChangedFiles
   });
   try {
-    const resolvedRepoPath = await fs22.realpath(path37);
+    const resolvedRepoPath = await fs23.realpath(path38);
     logDebug(`[${scanContext}] Resolved repository path`, {
       resolvedRepoPath,
-      originalPath: path37
+      originalPath: path38
     });
     const gitService = new GitService(resolvedRepoPath, log);
     const gitValidation = await gitService.validateRepository();
@@ -24376,7 +24507,7 @@ var getLocalFiles = async ({
     if (!gitValidation.isValid || isAllFilesScan) {
       try {
         files = await FileUtils.getLastChangedFiles({
-          dir: path37,
+          dir: path38,
           maxFileSize,
           maxFiles,
           isAllFilesScan
@@ -24440,7 +24571,7 @@ var getLocalFiles = async ({
           absoluteFilePath
         );
         try {
-          const fileStat = await fs22.stat(absoluteFilePath);
+          const fileStat = await fs23.stat(absoluteFilePath);
           return {
             filename: nodePath.basename(absoluteFilePath),
             relativePath,
@@ -24468,7 +24599,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: path37
+      path: path38
     });
     throw error;
   }
@@ -24477,8 +24608,8 @@ var getLocalFiles = async ({
 // src/mcp/services/LocalMobbFolderService.ts
 init_GitService();
 init_issueTypeCatalog();
-import fs23 from "fs";
-import path31 from "path";
+import fs24 from "fs";
+import path32 from "path";
 function extractPathFromPatch(patch) {
   const match = patch?.match(/diff --git a\/([^\s]+) b\//);
   return match?.[1] ?? null;
@@ -24560,19 +24691,19 @@ var LocalMobbFolderService = class {
           "[LocalMobbFolderService] Non-git repository detected, skipping .gitignore operations"
         );
       }
-      const mobbFolderPath = path31.join(
+      const mobbFolderPath = path32.join(
         this.repoPath,
         this.defaultMobbFolderName
       );
-      if (!fs23.existsSync(mobbFolderPath)) {
+      if (!fs24.existsSync(mobbFolderPath)) {
         logInfo("[LocalMobbFolderService] Creating .mobb folder", {
           mobbFolderPath
         });
-        fs23.mkdirSync(mobbFolderPath, { recursive: true });
+        fs24.mkdirSync(mobbFolderPath, { recursive: true });
       } else {
         logDebug("[LocalMobbFolderService] .mobb folder already exists");
       }
-      const stats = fs23.statSync(mobbFolderPath);
+      const stats = fs24.statSync(mobbFolderPath);
       if (!stats.isDirectory()) {
         throw new Error(`Path exists but is not a directory: ${mobbFolderPath}`);
       }
@@ -24613,13 +24744,13 @@ var LocalMobbFolderService = class {
       logDebug("[LocalMobbFolderService] Git repository validated successfully");
     } else {
       try {
-        const stats = fs23.statSync(this.repoPath);
+        const stats = fs24.statSync(this.repoPath);
         if (!stats.isDirectory()) {
           throw new Error(
             `Path exists but is not a directory: ${this.repoPath}`
           );
         }
-        fs23.accessSync(this.repoPath, fs23.constants.R_OK | fs23.constants.W_OK);
+        fs24.accessSync(this.repoPath, fs24.constants.R_OK | fs24.constants.W_OK);
         logDebug(
           "[LocalMobbFolderService] Non-git directory validated successfully"
         );
@@ -24732,8 +24863,8 @@ var LocalMobbFolderService = class {
         mobbFolderPath,
         baseFileName
       );
-      const filePath = path31.join(mobbFolderPath, uniqueFileName);
-      await fs23.promises.writeFile(filePath, patch, "utf8");
+      const filePath = path32.join(mobbFolderPath, uniqueFileName);
+      await fs24.promises.writeFile(filePath, patch, "utf8");
       logInfo("[LocalMobbFolderService] Patch saved successfully", {
         filePath,
         fileName: uniqueFileName,
@@ -24790,11 +24921,11 @@ var LocalMobbFolderService = class {
    * @returns Unique filename that doesn't conflict with existing files
    */
   getUniqueFileName(folderPath, baseFileName) {
-    const baseName = path31.parse(baseFileName).name;
-    const extension = path31.parse(baseFileName).ext;
+    const baseName = path32.parse(baseFileName).name;
+    const extension = path32.parse(baseFileName).ext;
     let uniqueFileName = baseFileName;
     let index = 1;
-    while (fs23.existsSync(path31.join(folderPath, uniqueFileName))) {
+    while (fs24.existsSync(path32.join(folderPath, uniqueFileName))) {
       uniqueFileName = `${baseName}-${index}${extension}`;
       index++;
       if (index > 1e3) {
@@ -24825,18 +24956,18 @@ var LocalMobbFolderService = class {
     logDebug("[LocalMobbFolderService] Logging patch info", { fixId: fix.id });
     try {
       const mobbFolderPath = await this.getFolder();
-      const patchInfoPath = path31.join(mobbFolderPath, "patchInfo.md");
+      const patchInfoPath = path32.join(mobbFolderPath, "patchInfo.md");
       const markdownContent = this.generateFixMarkdown(fix, savedPatchFileName);
       let existingContent = "";
-      if (fs23.existsSync(patchInfoPath)) {
-        existingContent = await fs23.promises.readFile(patchInfoPath, "utf8");
+      if (fs24.existsSync(patchInfoPath)) {
+        existingContent = await fs24.promises.readFile(patchInfoPath, "utf8");
         logDebug("[LocalMobbFolderService] Existing patchInfo.md found");
       } else {
         logDebug("[LocalMobbFolderService] Creating new patchInfo.md file");
       }
       const separator = existingContent ? "\n\n================================================================================\n\n" : "";
       const updatedContent = `${markdownContent}${separator}${existingContent}`;
-      await fs23.promises.writeFile(patchInfoPath, updatedContent, "utf8");
+      await fs24.promises.writeFile(patchInfoPath, updatedContent, "utf8");
       logInfo("[LocalMobbFolderService] Patch info logged successfully", {
         patchInfoPath,
         fixId: fix.id,
@@ -24867,7 +24998,7 @@ var LocalMobbFolderService = class {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const patch = this.extractPatchFromFix(fix);
     const relativePatchedFilePath = patch ? extractPathFromPatch(patch) : null;
-    const patchedFilePath = relativePatchedFilePath ? path31.resolve(this.repoPath, relativePatchedFilePath) : null;
+    const patchedFilePath = relativePatchedFilePath ? path32.resolve(this.repoPath, relativePatchedFilePath) : null;
     const fixIdentifier = savedPatchFileName ? savedPatchFileName.replace(".patch", "") : fix.id;
     let markdown = `# Fix ${fixIdentifier}
 
@@ -25209,16 +25340,16 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync3
 } from "fs";
-import fs24 from "fs/promises";
+import fs25 from "fs/promises";
 import parseDiff2 from "parse-diff";
-import path32 from "path";
+import path33 from "path";
 var PatchApplicationService = class {
   /**
    * Gets the appropriate comment syntax for a file based on its extension
    */
   static getCommentSyntax(filePath) {
-    const ext = path32.extname(filePath).toLowerCase();
-    const basename2 = path32.basename(filePath);
+    const ext = path33.extname(filePath).toLowerCase();
+    const basename2 = path33.basename(filePath);
     const commentMap = {
       // C-style languages (single line comments)
       ".js": "//",
@@ -25426,7 +25557,7 @@ var PatchApplicationService = class {
         }
       );
     }
-    const dirPath = path32.dirname(normalizedFilePath);
+    const dirPath = path33.dirname(normalizedFilePath);
     mkdirSync(dirPath, { recursive: true });
     writeFileSync3(normalizedFilePath, finalContent, "utf8");
     return normalizedFilePath;
@@ -25435,9 +25566,9 @@ var PatchApplicationService = class {
     repositoryPath,
     targetPath
   }) {
-    const repoRoot = path32.resolve(repositoryPath);
-    const normalizedPath = path32.resolve(repoRoot, targetPath);
-    const repoRootWithSep = repoRoot.endsWith(path32.sep) ? repoRoot : `${repoRoot}${path32.sep}`;
+    const repoRoot = path33.resolve(repositoryPath);
+    const normalizedPath = path33.resolve(repoRoot, targetPath);
+    const repoRootWithSep = repoRoot.endsWith(path33.sep) ? repoRoot : `${repoRoot}${path33.sep}`;
     if (normalizedPath !== repoRoot && !normalizedPath.startsWith(repoRootWithSep)) {
       throw new Error(
         `Security violation: target path ${targetPath} resolves outside repository`
@@ -25446,7 +25577,7 @@ var PatchApplicationService = class {
     return {
       repoRoot,
       normalizedPath,
-      relativePath: path32.relative(repoRoot, normalizedPath)
+      relativePath: path33.relative(repoRoot, normalizedPath)
     };
   }
   /**
@@ -25728,9 +25859,9 @@ var PatchApplicationService = class {
         continue;
       }
       try {
-        const absolutePath = path32.resolve(repositoryPath, targetFile);
+        const absolutePath = path33.resolve(repositoryPath, targetFile);
         if (existsSync6(absolutePath)) {
-          const stats = await fs24.stat(absolutePath);
+          const stats = await fs25.stat(absolutePath);
           const fileModTime = stats.mtime.getTime();
           if (fileModTime > scanStartTime) {
             logError(
@@ -25772,7 +25903,7 @@ var PatchApplicationService = class {
     const appliedFixes = [];
     const failedFixes = [];
     const skippedFixes = [];
-    const resolvedRepoPath = await fs24.realpath(repositoryPath);
+    const resolvedRepoPath = await fs25.realpath(repositoryPath);
     logInfo(
       `[${scanContext}] Starting patch application for ${fixes.length} fixes`,
       {
@@ -25961,7 +26092,7 @@ var PatchApplicationService = class {
       fix,
       scanContext
     });
-    appliedFiles.push(path32.relative(repositoryPath, actualPath));
+    appliedFiles.push(path33.relative(repositoryPath, actualPath));
     logDebug(`[${scanContext}] Created new file: ${relativePath}`);
   }
   /**
@@ -26010,7 +26141,7 @@ var PatchApplicationService = class {
         fix,
         scanContext
       });
-      appliedFiles.push(path32.relative(repositoryPath, actualPath));
+      appliedFiles.push(path33.relative(repositoryPath, actualPath));
       logDebug(`[${scanContext}] Modified file: ${relativePath}`);
     }
   }
@@ -26202,13 +26333,13 @@ var PatchApplicationService = class {
 // src/mcp/services/ScanFiles.ts
 init_client_generates();
 init_GitService();
-import os16 from "os";
+import os17 from "os";
 init_configs();
 
 // src/mcp/services/FileOperations.ts
 init_FileUtils();
-import fs25 from "fs";
-import path33 from "path";
+import fs26 from "fs";
+import path34 from "path";
 import AdmZip5 from "adm-zip";
 var FileOperations = class {
   /**
@@ -26228,10 +26359,10 @@ var FileOperations = class {
     let packedFilesCount = 0;
     const packedFiles = [];
     const excludedFiles = [];
-    const resolvedRepoPath = path33.resolve(repositoryPath);
+    const resolvedRepoPath = path34.resolve(repositoryPath);
     for (const filepath of fileList) {
-      const absoluteFilepath = path33.join(repositoryPath, filepath);
-      const resolvedFilePath = path33.resolve(absoluteFilepath);
+      const absoluteFilepath = path34.join(repositoryPath, filepath);
+      const resolvedFilePath = path34.resolve(absoluteFilepath);
       if (!resolvedFilePath.startsWith(resolvedRepoPath)) {
         const reason = "potential path traversal security risk";
         logDebug(`[FileOperations] Skipping ${filepath} due to ${reason}`);
@@ -26278,11 +26409,11 @@ var FileOperations = class {
     fileList,
     repositoryPath
   }) {
-    const resolvedRepoPath = path33.resolve(repositoryPath);
+    const resolvedRepoPath = path34.resolve(repositoryPath);
     const validatedPaths = [];
     for (const filepath of fileList) {
-      const absoluteFilepath = path33.join(repositoryPath, filepath);
-      const resolvedFilePath = path33.resolve(absoluteFilepath);
+      const absoluteFilepath = path34.join(repositoryPath, filepath);
+      const resolvedFilePath = path34.resolve(absoluteFilepath);
       if (!resolvedFilePath.startsWith(resolvedRepoPath)) {
         logDebug(
           `[FileOperations] Rejecting ${filepath} - path traversal attempt detected`
@@ -26290,7 +26421,7 @@ var FileOperations = class {
         continue;
       }
       try {
-        await fs25.promises.access(absoluteFilepath, fs25.constants.R_OK);
+        await fs26.promises.access(absoluteFilepath, fs26.constants.R_OK);
         validatedPaths.push(filepath);
       } catch (error) {
         logDebug(
@@ -26309,8 +26440,8 @@ var FileOperations = class {
     const fileDataArray = [];
     for (const absolutePath of filePaths) {
       try {
-        const content = await fs25.promises.readFile(absolutePath);
-        const relativePath = path33.basename(absolutePath);
+        const content = await fs26.promises.readFile(absolutePath);
+        const relativePath = path34.basename(absolutePath);
         fileDataArray.push({
           relativePath,
           absolutePath,
@@ -26335,7 +26466,7 @@ var FileOperations = class {
     relativeFilepath
   }) {
     try {
-      return await fs25.promises.readFile(absoluteFilepath);
+      return await fs26.promises.readFile(absoluteFilepath);
     } catch (fsError) {
       logError(
         `[FileOperations] Failed to read ${relativeFilepath} from filesystem: ${fsError}`
@@ -26479,7 +26610,7 @@ var executeSecurityScan = async ({
     fileCount,
     // MVS device attribution: a developer appears in the MVS Developers grid
     // from scanning alone (no fresh login needed).
-    computerName: os16.hostname(),
+    computerName: os17.hostname(),
     computerUser: getComputerUser(),
     clientVersion: packageJson.version
   };
@@ -26629,14 +26760,14 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
    * since the last scan.
    */
   async scanForSecurityVulnerabilities({
-    path: path37,
+    path: path38,
     isAllDetectionRulesScan,
     isAllFilesScan,
     scanContext
   }) {
     this.hasAuthenticationFailed = false;
     logDebug(`[${scanContext}] Scanning for new security vulnerabilities`, {
-      path: path37
+      path: path38
     });
     if (!this.gqlClient) {
       logInfo(`[${scanContext}] No GQL client found, skipping scan`);
@@ -26652,11 +26783,11 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       logDebug(
         `[${scanContext}] Connected to the API, assembling list of files to scan`,
-        { path: path37 }
+        { path: path38 }
       );
       const isBackgroundScan = scanContext === ScanContext.BACKGROUND_INITIAL || scanContext === ScanContext.BACKGROUND_PERIODIC;
       const files = await getLocalFiles({
-        path: path37,
+        path: path38,
         isAllFilesScan,
         scanContext,
         scanRecentlyChangedFiles: !isBackgroundScan
@@ -26682,13 +26813,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
       const { fixReportId, projectId } = await scanFiles({
         fileList: filesToScan.map((file) => file.relativePath),
-        repositoryPath: path37,
+        repositoryPath: path38,
         gqlClient: this.gqlClient,
         isAllDetectionRulesScan,
         scanContext
       });
       logInfo(
-        `[${scanContext}] Security scan completed for ${path37} reportId: ${fixReportId} projectId: ${projectId}`
+        `[${scanContext}] Security scan completed for ${path38} reportId: ${fixReportId} projectId: ${projectId}`
       );
       if (isAllFilesScan) {
         return;
@@ -26992,13 +27123,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     });
     return scannedFiles.some((file) => file.relativePath === fixFile);
   }
-  async getFreshFixes({ path: path37 }) {
+  async getFreshFixes({ path: path38 }) {
     const scanContext = ScanContext.USER_REQUEST;
-    logDebug(`[${scanContext}] Getting fresh fixes`, { path: path37 });
-    if (this.path !== path37) {
-      this.path = path37;
+    logDebug(`[${scanContext}] Getting fresh fixes`, { path: path38 });
+    if (this.path !== path38) {
+      this.path = path38;
       this.reset();
-      logInfo(`[${scanContext}] Reset service state for new path`, { path: path37 });
+      logInfo(`[${scanContext}] Reset service state for new path`, { path: path38 });
     }
     try {
       const loginContext = createMcpLoginContext("check_new_fixes");
@@ -27017,7 +27148,7 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       throw error;
     }
-    this.triggerScan({ path: path37, gqlClient: this.gqlClient });
+    this.triggerScan({ path: path38, gqlClient: this.gqlClient });
     let isMvsAutoFixEnabled = null;
     try {
       isMvsAutoFixEnabled = await this.gqlClient.getMvsAutoFixSettings();
@@ -27051,33 +27182,33 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     return noFreshFixesPrompt;
   }
   triggerScan({
-    path: path37,
+    path: path38,
     gqlClient
   }) {
-    if (this.path !== path37) {
-      this.path = path37;
+    if (this.path !== path38) {
+      this.path = path38;
       this.reset();
-      logInfo(`Reset service state for new path in triggerScan`, { path: path37 });
+      logInfo(`Reset service state for new path in triggerScan`, { path: path38 });
     }
     this.gqlClient = gqlClient;
     if (!this.intervalId) {
-      this.startPeriodicScanning(path37);
-      this.executeInitialScan(path37);
-      void this.executeInitialFullScan(path37);
+      this.startPeriodicScanning(path38);
+      this.executeInitialScan(path38);
+      void this.executeInitialFullScan(path38);
     }
   }
-  startPeriodicScanning(path37) {
+  startPeriodicScanning(path38) {
     const scanContext = ScanContext.BACKGROUND_PERIODIC;
     logDebug(
       `[${scanContext}] Starting periodic scan for new security vulnerabilities`,
       {
-        path: path37
+        path: path38
       }
     );
     this.intervalId = setInterval(() => {
-      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path37 });
+      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path38 });
       this.scanForSecurityVulnerabilities({
-        path: path37,
+        path: path38,
         scanContext
       }).catch((error) => {
         logError(`[${scanContext}] Error during periodic security scan`, {
@@ -27086,45 +27217,45 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
     }, MCP_PERIODIC_CHECK_INTERVAL);
   }
-  async executeInitialFullScan(path37) {
+  async executeInitialFullScan(path38) {
     const scanContext = ScanContext.FULL_SCAN;
-    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path37 });
+    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path38 });
     logDebug(`[${scanContext}] Full scan paths scanned`, {
       fullScanPathsScanned: this.fullScanPathsScanned
     });
-    if (this.fullScanPathsScanned.includes(path37)) {
+    if (this.fullScanPathsScanned.includes(path38)) {
       logDebug(`[${scanContext}] Full scan already executed for this path`, {
-        path: path37
+        path: path38
       });
       return;
     }
     configStore.set("fullScanPathsScanned", [
       ...this.fullScanPathsScanned,
-      path37
+      path38
     ]);
     try {
       await this.scanForSecurityVulnerabilities({
-        path: path37,
+        path: path38,
         isAllFilesScan: true,
         isAllDetectionRulesScan: true,
         scanContext: ScanContext.FULL_SCAN
       });
-      if (!this.fullScanPathsScanned.includes(path37)) {
-        this.fullScanPathsScanned.push(path37);
+      if (!this.fullScanPathsScanned.includes(path38)) {
+        this.fullScanPathsScanned.push(path38);
         configStore.set("fullScanPathsScanned", this.fullScanPathsScanned);
       }
-      logInfo(`[${scanContext}] Full scan completed`, { path: path37 });
+      logInfo(`[${scanContext}] Full scan completed`, { path: path38 });
     } catch (error) {
       logError(`[${scanContext}] Error during initial full security scan`, {
         error
       });
     }
   }
-  executeInitialScan(path37) {
+  executeInitialScan(path38) {
     const scanContext = ScanContext.BACKGROUND_INITIAL;
-    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path37 });
+    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path38 });
     this.scanForSecurityVulnerabilities({
-      path: path37,
+      path: path38,
       scanContext: ScanContext.BACKGROUND_INITIAL
     }).catch((error) => {
       logError(`[${scanContext}] Error during initial security scan`, { error });
@@ -27225,9 +27356,9 @@ Example payload:
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path37 = pathValidationResult.path;
+    const path38 = pathValidationResult.path;
     const resultText = await this.newFixesService.getFreshFixes({
-      path: path37
+      path: path38
     });
     logInfo("CheckForNewAvailableFixesTool execution completed", {
       resultText
@@ -27408,8 +27539,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 path37 = pathValidationResult.path;
-    const gitService = new GitService(path37, log);
+    const path38 = pathValidationResult.path;
+    const gitService = new GitService(path38, log);
     const gitValidation = await gitService.validateRepository();
     if (!gitValidation.isValid) {
       throw new Error(`Invalid git repository: ${gitValidation.error}`);
@@ -27446,7 +27577,7 @@ Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only
     }
     const fixResult = await this.availableFixesService.checkForAvailableFixes({
       repoUrl: originUrl,
-      repositoryPath: path37,
+      repositoryPath: path38,
       limit: args.limit,
       offset: args.offset,
       fileFilter: actualFileFilter
@@ -28031,7 +28162,7 @@ Example payload (Mode B \u2014 abstain from every interactive fix, no rescan):
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path37 = pathValidationResult.path;
+    const path38 = pathValidationResult.path;
     if (args.interactiveAnswers !== void 0) {
       if (args.interactiveAnswers.length === 0) {
         return this.createSuccessResponse(
@@ -28041,7 +28172,7 @@ Example payload (Mode B \u2014 abstain from every interactive fix, no rescan):
       try {
         const result = await this.vulnerabilityFixService.applyInteractiveAnswers({
           interactiveAnswers: args.interactiveAnswers,
-          repositoryPath: path37
+          repositoryPath: path38
         });
         return this.createSuccessResponse(result);
       } catch (error) {
@@ -28053,7 +28184,7 @@ Example payload (Mode B \u2014 abstain from every interactive fix, no rescan):
       }
     }
     const files = await getLocalFiles({
-      path: path37,
+      path: path38,
       maxFileSize: MCP_MAX_FILE_SIZE,
       maxFiles: args.maxFiles,
       scanContext: ScanContext.USER_REQUEST,
@@ -28073,7 +28204,7 @@ Example payload (Mode B \u2014 abstain from every interactive fix, no rescan):
     try {
       const fixResult = await this.vulnerabilityFixService.processVulnerabilities({
         fileList: files.map((file) => file.relativePath),
-        repositoryPath: path37,
+        repositoryPath: path38,
         offset: args.offset,
         limit: args.limit,
         isRescan: args.rescan || !!args.maxFiles
@@ -28177,7 +28308,7 @@ var mcpHandler = async (_args) => {
 };
 
 // src/args/commands/review.ts
-import fs26 from "fs";
+import fs27 from "fs";
 import chalk12 from "chalk";
 function reviewBuilder(yargs2) {
   return yargs2.option("f", {
@@ -28214,7 +28345,7 @@ function reviewBuilder(yargs2) {
   ).help();
 }
 function validateReviewOptions(argv) {
-  if (!fs26.existsSync(argv.f)) {
+  if (!fs27.existsSync(argv.f)) {
     throw new CliError(`
 Can't access ${chalk12.bold(argv.f)}`);
   }
@@ -28374,10 +28505,10 @@ init_client_generates();
 init_urlParser2();
 
 // src/features/codeium_intellij/codeium_language_server_grpc_client.ts
-import path34 from "path";
+import path35 from "path";
 import * as grpc from "@grpc/grpc-js";
 import * as protoLoader from "@grpc/proto-loader";
-var PROTO_PATH = path34.join(
+var PROTO_PATH = path35.join(
   getModuleRootDir(),
   "src/features/codeium_intellij/proto/exa/language_server_pb/language_server.proto"
 );
@@ -28389,7 +28520,7 @@ function loadProto() {
     defaults: true,
     oneofs: true,
     includeDirs: [
-      path34.join(getModuleRootDir(), "src/features/codeium_intellij/proto")
+      path35.join(getModuleRootDir(), "src/features/codeium_intellij/proto")
     ]
   });
   return grpc.loadPackageDefinition(
@@ -28443,30 +28574,30 @@ async function getGrpcClient(port, csrf) {
 }
 
 // src/features/codeium_intellij/parse_intellij_logs.ts
-import fs27 from "fs";
-import os17 from "os";
-import path35 from "path";
+import fs28 from "fs";
+import os18 from "os";
+import path36 from "path";
 function getLogsDir() {
   if (process.platform === "darwin") {
-    return path35.join(os17.homedir(), "Library/Logs/JetBrains");
+    return path36.join(os18.homedir(), "Library/Logs/JetBrains");
   } else if (process.platform === "win32") {
-    return path35.join(
-      process.env["LOCALAPPDATA"] || path35.join(os17.homedir(), "AppData/Local"),
+    return path36.join(
+      process.env["LOCALAPPDATA"] || path36.join(os18.homedir(), "AppData/Local"),
       "JetBrains"
     );
   } else {
-    return path35.join(os17.homedir(), ".cache/JetBrains");
+    return path36.join(os18.homedir(), ".cache/JetBrains");
   }
 }
 function parseIdeLogDir(ideLogDir) {
-  const logFiles = fs27.readdirSync(ideLogDir).filter((f) => /^idea(\.\d+)?\.log$/.test(f)).map((f) => ({
+  const logFiles = fs28.readdirSync(ideLogDir).filter((f) => /^idea(\.\d+)?\.log$/.test(f)).map((f) => ({
     name: f,
-    mtime: fs27.statSync(path35.join(ideLogDir, f)).mtimeMs
+    mtime: fs28.statSync(path36.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 = fs27.readFileSync(path35.join(ideLogDir, logFile), "utf-8").split("\n");
+    const lines = fs28.readFileSync(path36.join(ideLogDir, logFile), "utf-8").split("\n");
     for (const line of lines) {
       if (!line.includes(
         "com.codeium.intellij.language_server.LanguageServerProcessHandler"
@@ -28492,13 +28623,13 @@ function parseIdeLogDir(ideLogDir) {
 function findRunningCodeiumLanguageServers() {
   const results = [];
   const logsDir = getLogsDir();
-  if (!fs27.existsSync(logsDir)) return results;
-  for (const ide of fs27.readdirSync(logsDir)) {
-    let ideLogDir = path35.join(logsDir, ide);
+  if (!fs28.existsSync(logsDir)) return results;
+  for (const ide of fs28.readdirSync(logsDir)) {
+    let ideLogDir = path36.join(logsDir, ide);
     if (process.platform !== "darwin") {
-      ideLogDir = path35.join(ideLogDir, "log");
+      ideLogDir = path36.join(ideLogDir, "log");
     }
-    if (!fs27.existsSync(ideLogDir) || !fs27.statSync(ideLogDir).isDirectory()) {
+    if (!fs28.existsSync(ideLogDir) || !fs28.statSync(ideLogDir).isDirectory()) {
       continue;
     }
     const result = parseIdeLogDir(ideLogDir);
@@ -28678,11 +28809,11 @@ function processChatStepCodeAction(step) {
 
 // src/features/codeium_intellij/install_hook.ts
 import fsPromises5 from "fs/promises";
-import os18 from "os";
-import path36 from "path";
+import os19 from "os";
+import path37 from "path";
 import chalk14 from "chalk";
 function getCodeiumHooksPath() {
-  return path36.join(os18.homedir(), ".codeium", "hooks.json");
+  return path37.join(os19.homedir(), ".codeium", "hooks.json");
 }
 async function readCodeiumHooks() {
   const hooksPath = getCodeiumHooksPath();
@@ -28695,7 +28826,7 @@ async function readCodeiumHooks() {
 }
 async function writeCodeiumHooks(config2) {
   const hooksPath = getCodeiumHooksPath();
-  const dir = path36.dirname(hooksPath);
+  const dir = path37.dirname(hooksPath);
   await fsPromises5.mkdir(dir, { recursive: true });
   await fsPromises5.writeFile(
     hooksPath,