socket 1.0.11 → 1.0.12

package/dist/cli.js

@@ -959,8 +959,8 @@ async function fetchReportData(orgSlug, scanId, includeLicensePolicy) {
     return sockSdkResult;
   }
   const sockSdk = sockSdkResult.data;
-  let scanStatus = 'requested..';
-  let policyStatus = 'requested..';
+  let policyStatus = 'requested...';
+  let scanStatus = 'requested...';
   let finishedFetching = false;
 
   // Lazily access constants.spinner.
@@ -989,10 +989,10 @@ async function fetchReportData(orgSlug, scanId, includeLicensePolicy) {
     if (!result.ok) {
       return result;
     }
-    const jsonsString = result.data;
+    const ndJsonString = result.data;
 
     // This is nd-json; each line is a json object.
-    const lines = jsonsString.split('\n').filter(Boolean);
+    const lines = ndJsonString.split('\n').filter(Boolean);
     let ok = true;
     const data = lines.map(line => {
       try {
@@ -1004,13 +1004,13 @@ async function fetchReportData(orgSlug, scanId, includeLicensePolicy) {
       }
     });
     if (ok) {
-      updateScan(`success`);
+      updateScan('success');
       return {
         ok: true,
         data
       };
     }
-    updateScan(`received invalid JSON response`);
+    updateScan('received invalid JSON response');
     return {
       ok: false,
       message: 'Invalid API response',
@@ -1024,14 +1024,14 @@ async function fetchReportData(orgSlug, scanId, includeLicensePolicy) {
   }
   updateProgress();
   const [scan, securityPolicy] = await Promise.all([fetchScanResult().catch(e => {
-    updateScan(`failure; unknown blocking problem occurred`);
+    updateScan('failure; unknown blocking problem occurred');
     return {
       ok: false,
       message: 'Unexpected API problem',
       cause: `We encountered an unexpected problem while requesting the Scan from the API: ${e?.message || '(no error message found)'}${e?.cause ? ` (cause: ${e.cause})` : ''}`
     };
   }), fetchSecurityPolicy().catch(e => {
-    updatePolicy(`failure; unknown blocking problem occurred`);
+    updatePolicy('failure; unknown blocking problem occurred');
     return {
       ok: false,
       message: 'Unexpected API problem',
@@ -1487,7 +1487,7 @@ async function outputCreateNewScan(result, outputKind, interactive) {
 async function detectManifestActions(
 // Passing in null means we attempt detection for every supported language
 // regardless of local socket.json status. Sometimes we want that.
-socketJson, cwd = process.cwd()) {
+sockJson, cwd = process.cwd()) {
   const output = {
     cdxgen: false,
     // TODO
@@ -1496,21 +1496,21 @@ socketJson, cwd = process.cwd()) {
     gradle: false,
     sbt: false
   };
-  if (socketJson?.defaults?.manifest?.sbt?.disabled) {
+  if (sockJson?.defaults?.manifest?.sbt?.disabled) {
     debug.debugLog('[DEBUG] - sbt auto-detection is disabled in socket.json');
   } else if (fs$1.existsSync(path.join(cwd, 'build.sbt'))) {
     debug.debugLog('[DEBUG] - Detected a Scala sbt build file');
     output.sbt = true;
     output.count += 1;
   }
-  if (socketJson?.defaults?.manifest?.gradle?.disabled) {
+  if (sockJson?.defaults?.manifest?.gradle?.disabled) {
     debug.debugLog('[DEBUG] - gradle auto-detection is disabled in socket.json');
   } else if (fs$1.existsSync(path.join(cwd, 'gradlew'))) {
     debug.debugLog('[DEBUG] - Detected a gradle build file');
     output.gradle = true;
     output.count += 1;
   }
-  if (socketJson?.defaults?.manifest?.conda?.disabled) {
+  if (sockJson?.defaults?.manifest?.conda?.disabled) {
     debug.debugLog('[DEBUG] - conda auto-detection is disabled in socket.json');
   } else {
     const envyml = path.join(cwd, 'environment.yml');
@@ -1922,41 +1922,41 @@ async function generateAutoManifest({
   outputKind,
   verbose
 }) {
-  const socketJson = await utils.readOrDefaultSocketJson(cwd);
+  const sockJson = await utils.readOrDefaultSocketJson(cwd);
   if (verbose) {
-    logger.logger.info('Using this socket.json for defaults:', socketJson);
+    logger.logger.info('Using this socket.json for defaults:', sockJson);
   }
-  if (!socketJson?.defaults?.manifest?.sbt?.disabled && detected.sbt) {
+  if (!sockJson?.defaults?.manifest?.sbt?.disabled && detected.sbt) {
     logger.logger.log('Detected a Scala sbt build, generating pom files with sbt...');
     await convertSbtToMaven({
       // Note: `sbt` is more likely to be resolved against PATH env
-      bin: socketJson.defaults?.manifest?.sbt?.bin ?? 'sbt',
+      bin: sockJson.defaults?.manifest?.sbt?.bin ?? 'sbt',
       cwd,
-      out: socketJson.defaults?.manifest?.sbt?.outfile ?? './socket.sbt.pom.xml',
-      sbtOpts: socketJson.defaults?.manifest?.sbt?.sbtOpts?.split(' ').map(s => s.trim()).filter(Boolean) ?? [],
-      verbose: Boolean(socketJson.defaults?.manifest?.sbt?.verbose)
+      out: sockJson.defaults?.manifest?.sbt?.outfile ?? './socket.sbt.pom.xml',
+      sbtOpts: sockJson.defaults?.manifest?.sbt?.sbtOpts?.split(' ').map(s => s.trim()).filter(Boolean) ?? [],
+      verbose: Boolean(sockJson.defaults?.manifest?.sbt?.verbose)
     });
   }
-  if (!socketJson?.defaults?.manifest?.gradle?.disabled && detected.gradle) {
+  if (!sockJson?.defaults?.manifest?.gradle?.disabled && detected.gradle) {
     logger.logger.log('Detected a gradle build (Gradle, Kotlin, Scala), running default gradle generator...');
     await convertGradleToMaven({
       // Note: `gradlew` is more likely to be resolved against cwd
       // Note: .resolve() wont butcher an absolute path
       // TODO: `gradlew` (or anything else given) may want to resolve against PATH
-      bin: socketJson.defaults?.manifest?.gradle?.bin ? path.resolve(cwd, socketJson.defaults.manifest.gradle.bin) : path.join(cwd, 'gradlew'),
+      bin: sockJson.defaults?.manifest?.gradle?.bin ? path.resolve(cwd, sockJson.defaults.manifest.gradle.bin) : path.join(cwd, 'gradlew'),
       cwd,
-      verbose: Boolean(socketJson.defaults?.manifest?.gradle?.verbose),
-      gradleOpts: socketJson.defaults?.manifest?.gradle?.gradleOpts?.split(' ').map(s => s.trim()).filter(Boolean) ?? []
+      verbose: Boolean(sockJson.defaults?.manifest?.gradle?.verbose),
+      gradleOpts: sockJson.defaults?.manifest?.gradle?.gradleOpts?.split(' ').map(s => s.trim()).filter(Boolean) ?? []
     });
   }
-  if (!socketJson?.defaults?.manifest?.conda?.disabled && detected.conda) {
+  if (!sockJson?.defaults?.manifest?.conda?.disabled && detected.conda) {
     logger.logger.log('Detected an environment.yml file, running default Conda generator...');
     await handleManifestConda({
       cwd,
-      filename: socketJson.defaults?.manifest?.conda?.infile ?? 'environment.yml',
+      filename: sockJson.defaults?.manifest?.conda?.infile ?? 'environment.yml',
       outputKind,
-      out: socketJson.defaults?.manifest?.conda?.outfile ?? 'requirements.txt',
-      verbose: Boolean(socketJson.defaults?.manifest?.conda?.verbose)
+      out: sockJson.defaults?.manifest?.conda?.outfile ?? 'requirements.txt',
+      verbose: Boolean(sockJson.defaults?.manifest?.conda?.verbose)
     });
   }
 }
@@ -1982,8 +1982,8 @@ async function handleCreateNewScan({
 }) {
   if (autoManifest) {
     logger.logger.info('Auto generating manifest files ...');
-    const socketJson = await utils.readOrDefaultSocketJson(cwd);
-    const detected = await detectManifestActions(socketJson, cwd);
+    const sockJson = await utils.readOrDefaultSocketJson(cwd);
+    const detected = await detectManifestActions(sockJson, cwd);
     await generateAutoManifest({
       detected,
       cwd,
@@ -3311,13 +3311,13 @@ async function readCache(key,
 ttlMs = 5 * 60 * 1000) {
   // Lazily access constants.githubCachePath.
   const cacheJsonPath = path.join(constants.githubCachePath, `${key}.json`);
-  try {
-    const stat = fs$1.statSync(cacheJsonPath);
+  const stat = utils.safeStatsSync(cacheJsonPath);
+  if (stat) {
     const isExpired = Date.now() - stat.mtimeMs > ttlMs;
     if (!isExpired) {
       return await fs$2.readJson(cacheJsonPath);
     }
-  } catch {}
+  }
   return null;
 }
 async function writeCache(key, data) {
@@ -4943,21 +4943,21 @@ const cmdInstall = {
 
 async function outputCmdJson(cwd) {
   logger.logger.info('Target cwd:', constants.ENV.VITEST ? '<redacted>' : utils.tildify(cwd));
-  const sjpath = path.join(cwd, 'socket.json');
-  const tildeSjpath = constants.ENV.VITEST ? '<redacted>' : utils.tildify(sjpath);
-  if (!fs$1.existsSync(sjpath)) {
-    logger.logger.fail(`Not found: ${tildeSjpath}`);
+  const sockJsonPath = path.join(cwd, 'socket.json');
+  const tildeSockJsonPath = constants.ENV.VITEST ? '<redacted>' : utils.tildify(sockJsonPath);
+  if (!fs$1.existsSync(sockJsonPath)) {
+    logger.logger.fail(`Not found: ${tildeSockJsonPath}`);
     process.exitCode = 1;
     return;
   }
-  if (!fs$1.lstatSync(sjpath).isFile()) {
-    logger.logger.fail(`This is not a regular file (maybe a directory?): ${tildeSjpath}`);
+  if (!utils.safeStatsSync(sockJsonPath)?.isFile()) {
+    logger.logger.fail(`This is not a regular file (maybe a directory?): ${tildeSockJsonPath}`);
     process.exitCode = 1;
     return;
   }
-  const data = fs$1.readFileSync(sjpath, 'utf8');
-  logger.logger.success(`This is the contents of ${tildeSjpath}:`);
+  logger.logger.success(`This is the contents of ${tildeSockJsonPath}:`);
   logger.logger.error('');
+  const data = utils.safeReadFileSync(sockJsonPath);
   logger.logger.log(data);
 }
 
@@ -5666,8 +5666,8 @@ async function run$B(argv, importMeta, {
     logger.logger.log('- cwd:', cwd);
     logger.logger.groupEnd();
   }
-  const socketJson = await utils.readOrDefaultSocketJson(cwd);
-  const detected = await detectManifestActions(socketJson, cwd);
+  const sockJson = await utils.readOrDefaultSocketJson(cwd);
+  const detected = await detectManifestActions(sockJson, cwd);
   debug.debugLog('[DEBUG]', detected);
   if (cli.flags['dryRun']) {
     logger.logger.log(DRY_RUN_BAILING_NOW$A);
@@ -5774,39 +5774,39 @@ async function run$A(argv, importMeta, {
   // Note: path.resolve vs .join:
   // If given path is absolute then cwd should not affect it.
   cwd = path.resolve(process.cwd(), cwd);
-  const socketJson = await utils.readOrDefaultSocketJson(cwd);
+  const sockJson = await utils.readOrDefaultSocketJson(cwd);
 
   // Set defaults for any flag/arg that is not given. Check socket.json first.
-  if (stdin === undefined && socketJson.defaults?.manifest?.conda?.stdin !== undefined) {
-    stdin = socketJson.defaults?.manifest?.conda?.stdin;
+  if (stdin === undefined && sockJson.defaults?.manifest?.conda?.stdin !== undefined) {
+    stdin = sockJson.defaults?.manifest?.conda?.stdin;
     logger.logger.info('Using default --stdin from socket.json:', stdin);
   }
   if (stdin) {
     filename = '-';
   } else if (!filename) {
-    if (socketJson.defaults?.manifest?.conda?.infile) {
-      filename = socketJson.defaults?.manifest?.conda?.infile;
+    if (sockJson.defaults?.manifest?.conda?.infile) {
+      filename = sockJson.defaults?.manifest?.conda?.infile;
       logger.logger.info('Using default --file from socket.json:', filename);
     } else {
       filename = 'environment.yml';
     }
   }
-  if (stdout === undefined && socketJson.defaults?.manifest?.conda?.stdout !== undefined) {
-    stdout = socketJson.defaults?.manifest?.conda?.stdout;
+  if (stdout === undefined && sockJson.defaults?.manifest?.conda?.stdout !== undefined) {
+    stdout = sockJson.defaults?.manifest?.conda?.stdout;
     logger.logger.info('Using default --stdout from socket.json:', stdout);
   }
   if (stdout) {
     out = '-';
   } else if (!out) {
-    if (socketJson.defaults?.manifest?.conda?.outfile) {
-      out = socketJson.defaults?.manifest?.conda?.outfile;
+    if (sockJson.defaults?.manifest?.conda?.outfile) {
+      out = sockJson.defaults?.manifest?.conda?.outfile;
       logger.logger.info('Using default --out from socket.json:', out);
     } else {
       out = 'requirements.txt';
     }
   }
-  if (verbose === undefined && socketJson.defaults?.manifest?.conda?.verbose !== undefined) {
-    verbose = socketJson.defaults?.manifest?.conda?.verbose;
+  if (verbose === undefined && sockJson.defaults?.manifest?.conda?.verbose !== undefined) {
+    verbose = sockJson.defaults?.manifest?.conda?.verbose;
     logger.logger.info('Using default --verbose from socket.json:', verbose);
   } else if (verbose === undefined) {
     verbose = false;
@@ -5932,29 +5932,29 @@ async function run$z(argv, importMeta, {
   // Note: path.resolve vs .join:
   // If given path is absolute then cwd should not affect it.
   cwd = path.resolve(process.cwd(), cwd);
-  const socketJson = await utils.readOrDefaultSocketJson(cwd);
-  debug.debugLog('[DEBUG] socket.json gradle override:', socketJson?.defaults?.manifest?.gradle);
+  const sockJson = await utils.readOrDefaultSocketJson(cwd);
+  debug.debugFn('override: socket.json gradle', sockJson?.defaults?.manifest?.gradle);
 
   // Set defaults for any flag/arg that is not given. Check socket.json first.
   if (!bin) {
-    if (socketJson.defaults?.manifest?.gradle?.bin) {
-      bin = socketJson.defaults?.manifest?.gradle?.bin;
+    if (sockJson.defaults?.manifest?.gradle?.bin) {
+      bin = sockJson.defaults?.manifest?.gradle?.bin;
       logger.logger.info('Using default --bin from socket.json:', bin);
     } else {
       bin = path.join(cwd, 'gradlew');
     }
   }
   if (!gradleOpts) {
-    if (socketJson.defaults?.manifest?.gradle?.gradleOpts) {
-      gradleOpts = socketJson.defaults?.manifest?.gradle?.gradleOpts;
+    if (sockJson.defaults?.manifest?.gradle?.gradleOpts) {
+      gradleOpts = sockJson.defaults?.manifest?.gradle?.gradleOpts;
       logger.logger.info('Using default --gradleOpts from socket.json:', gradleOpts);
     } else {
       gradleOpts = '';
     }
   }
   if (verbose === undefined) {
-    if (socketJson.defaults?.manifest?.gradle?.verbose !== undefined) {
-      verbose = socketJson.defaults?.manifest?.gradle?.verbose;
+    if (sockJson.defaults?.manifest?.gradle?.verbose !== undefined) {
+      verbose = sockJson.defaults?.manifest?.gradle?.verbose;
       logger.logger.info('Using default --verbose from socket.json:', verbose);
     } else {
       verbose = false;
@@ -6089,29 +6089,29 @@ async function run$y(argv, importMeta, {
   // Note: path.resolve vs .join:
   // If given path is absolute then cwd should not affect it.
   cwd = path.resolve(process.cwd(), cwd);
-  const socketJson = await utils.readOrDefaultSocketJson(cwd);
-  debug.debugLog('[DEBUG] socket.json gradle override:', socketJson?.defaults?.manifest?.gradle);
+  const sockJson = await utils.readOrDefaultSocketJson(cwd);
+  debug.debugFn('override: socket.json gradle', sockJson?.defaults?.manifest?.gradle);
 
   // Set defaults for any flag/arg that is not given. Check socket.json first.
   if (!bin) {
-    if (socketJson.defaults?.manifest?.gradle?.bin) {
-      bin = socketJson.defaults?.manifest?.gradle?.bin;
+    if (sockJson.defaults?.manifest?.gradle?.bin) {
+      bin = sockJson.defaults?.manifest?.gradle?.bin;
       logger.logger.info('Using default --bin from socket.json:', bin);
     } else {
       bin = path.join(cwd, 'gradlew');
     }
   }
   if (!gradleOpts) {
-    if (socketJson.defaults?.manifest?.gradle?.gradleOpts) {
-      gradleOpts = socketJson.defaults?.manifest?.gradle?.gradleOpts;
+    if (sockJson.defaults?.manifest?.gradle?.gradleOpts) {
+      gradleOpts = sockJson.defaults?.manifest?.gradle?.gradleOpts;
       logger.logger.info('Using default --gradleOpts from socket.json:', gradleOpts);
     } else {
       gradleOpts = '';
     }
   }
   if (verbose === undefined) {
-    if (socketJson.defaults?.manifest?.gradle?.verbose !== undefined) {
-      verbose = socketJson.defaults?.manifest?.gradle?.verbose;
+    if (sockJson.defaults?.manifest?.gradle?.verbose !== undefined) {
+      verbose = sockJson.defaults?.manifest?.gradle?.verbose;
       logger.logger.info('Using default --verbose from socket.json:', verbose);
     } else {
       verbose = false;
@@ -6255,42 +6255,42 @@ async function run$x(argv, importMeta, {
   // Note: path.resolve vs .join:
   // If given path is absolute then cwd should not affect it.
   cwd = path.resolve(process.cwd(), cwd);
-  const socketJson = await utils.readOrDefaultSocketJson(cwd);
-  debug.debugLog('[DEBUG] socket.json sbt override:', socketJson?.defaults?.manifest?.sbt);
+  const sockJson = await utils.readOrDefaultSocketJson(cwd);
+  debug.debugFn('override: socket.json sbt', sockJson?.defaults?.manifest?.sbt);
 
   // Set defaults for any flag/arg that is not given. Check socket.json first.
   if (!bin) {
-    if (socketJson.defaults?.manifest?.sbt?.bin) {
-      bin = socketJson.defaults?.manifest?.sbt?.bin;
+    if (sockJson.defaults?.manifest?.sbt?.bin) {
+      bin = sockJson.defaults?.manifest?.sbt?.bin;
       logger.logger.info('Using default --bin from socket.json:', bin);
     } else {
       bin = 'sbt';
     }
   }
-  if (stdout === undefined && socketJson.defaults?.manifest?.sbt?.stdout !== undefined) {
-    stdout = socketJson.defaults?.manifest?.sbt?.stdout;
+  if (stdout === undefined && sockJson.defaults?.manifest?.sbt?.stdout !== undefined) {
+    stdout = sockJson.defaults?.manifest?.sbt?.stdout;
     logger.logger.info('Using default --stdout from socket.json:', stdout);
   }
   if (stdout) {
     out = '-';
   } else if (!out) {
-    if (socketJson.defaults?.manifest?.sbt?.outfile) {
-      out = socketJson.defaults?.manifest?.sbt?.outfile;
+    if (sockJson.defaults?.manifest?.sbt?.outfile) {
+      out = sockJson.defaults?.manifest?.sbt?.outfile;
       logger.logger.info('Using default --out from socket.json:', out);
     } else {
       out = './socket.pom.xml';
     }
   }
   if (!sbtOpts) {
-    if (socketJson.defaults?.manifest?.sbt?.sbtOpts) {
-      sbtOpts = socketJson.defaults?.manifest?.sbt?.sbtOpts;
+    if (sockJson.defaults?.manifest?.sbt?.sbtOpts) {
+      sbtOpts = sockJson.defaults?.manifest?.sbt?.sbtOpts;
       logger.logger.info('Using default --sbtOpts from socket.json:', sbtOpts);
     } else {
       sbtOpts = '';
     }
   }
-  if (verbose === undefined && socketJson.defaults?.manifest?.sbt?.verbose !== undefined) {
-    verbose = socketJson.defaults?.manifest?.sbt?.verbose;
+  if (verbose === undefined && sockJson.defaults?.manifest?.sbt?.verbose !== undefined) {
+    verbose = sockJson.defaults?.manifest?.sbt?.verbose;
     logger.logger.info('Using default --verbose from socket.json:', verbose);
   } else if (verbose === undefined) {
     verbose = false;
@@ -6424,41 +6424,41 @@ async function setupManifestConfig(cwd, defaultOnReadError = false) {
     message: 'Select eco system manifest generator to configure',
     choices
   });
-  const socketJsonResult = await utils.readSocketJson(cwd, defaultOnReadError);
-  if (!socketJsonResult.ok) {
-    return socketJsonResult;
+  const sockJsonCResult = await utils.readSocketJson(cwd, defaultOnReadError);
+  if (!sockJsonCResult.ok) {
+    return sockJsonCResult;
   }
-  const socketJson = socketJsonResult.data;
-  if (!socketJson.defaults) {
-    socketJson.defaults = {};
+  const sockJson = sockJsonCResult.data;
+  if (!sockJson.defaults) {
+    sockJson.defaults = {};
   }
-  if (!socketJson.defaults.manifest) {
-    socketJson.defaults.manifest = {};
+  if (!sockJson.defaults.manifest) {
+    sockJson.defaults.manifest = {};
   }
   let result;
   switch (targetEco) {
     case 'conda':
       {
-        if (!socketJson.defaults.manifest.conda) {
-          socketJson.defaults.manifest.conda = {};
+        if (!sockJson.defaults.manifest.conda) {
+          sockJson.defaults.manifest.conda = {};
         }
-        result = await setupConda(socketJson.defaults.manifest.conda);
+        result = await setupConda(sockJson.defaults.manifest.conda);
         break;
       }
     case 'gradle':
       {
-        if (!socketJson.defaults.manifest.gradle) {
-          socketJson.defaults.manifest.gradle = {};
+        if (!sockJson.defaults.manifest.gradle) {
+          sockJson.defaults.manifest.gradle = {};
         }
-        result = await setupGradle(socketJson.defaults.manifest.gradle);
+        result = await setupGradle(sockJson.defaults.manifest.gradle);
         break;
       }
     case 'sbt':
       {
-        if (!socketJson.defaults.manifest.sbt) {
-          socketJson.defaults.manifest.sbt = {};
+        if (!sockJson.defaults.manifest.sbt) {
+          sockJson.defaults.manifest.sbt = {};
         }
-        result = await setupSbt(socketJson.defaults.manifest.sbt);
+        result = await setupSbt(sockJson.defaults.manifest.sbt);
         break;
       }
     default:
@@ -6484,7 +6484,7 @@ async function setupManifestConfig(cwd, defaultOnReadError = false) {
       description: 'Do not update the config'
     }]
   })) {
-    return await utils.writeSocketJson(cwd, socketJson);
+    return await utils.writeSocketJson(cwd, sockJson);
   }
   return canceledByUser$1();
 }
@@ -8875,7 +8875,7 @@ function formatReportCard(artifact, color) {
   };
   const alertString = getAlertString(artifact.alerts, !color);
   if (!artifact.ecosystem) {
-    debug.debugFn('miss: Artifact ecosystem', artifact);
+    debug.debugFn('miss: artifact ecosystem', artifact);
   }
   const purl = `pkg:${artifact.ecosystem}/${artifact.name}${artifact.version ? '@' + artifact.version : ''}`;
   return ['Package: ' + (color ? vendor.yoctocolorsCjsExports.bold(purl) : purl), '', ...Object.entries(scoreResult).map(score => `- ${score[0]}:`.padEnd(20, ' ') + `  ${formatScore(score[1], !color, true)}`), alertString].join('\n');
@@ -10476,36 +10476,36 @@ async function run$c(argv, importMeta, {
   // Accept zero or more paths. Default to cwd() if none given.
   let targets = cli.input || [process.cwd()];
   const cwd = cwdOverride && cwdOverride !== 'process.cwd()' ? path.resolve(process.cwd(), String(cwdOverride)) : process.cwd();
-  const socketJson = await utils.readOrDefaultSocketJson(cwd);
+  const sockJson = await utils.readOrDefaultSocketJson(cwd);
 
   // Note: This needs meow booleanDefault=undefined
   if (typeof autoManifest !== 'boolean') {
-    if (socketJson.defaults?.scan?.create?.autoManifest !== undefined) {
-      autoManifest = socketJson.defaults.scan.create.autoManifest;
+    if (sockJson.defaults?.scan?.create?.autoManifest !== undefined) {
+      autoManifest = sockJson.defaults.scan.create.autoManifest;
       logger.logger.info('Using default --autoManifest from socket.json:', autoManifest);
     } else {
       autoManifest = false;
     }
   }
   if (!branchName) {
-    if (socketJson.defaults?.scan?.create?.branch) {
-      branchName = socketJson.defaults.scan.create.branch;
+    if (sockJson.defaults?.scan?.create?.branch) {
+      branchName = sockJson.defaults.scan.create.branch;
       logger.logger.info('Using default --branch from socket.json:', branchName);
     } else {
       branchName = 'socket-default-branch';
     }
   }
   if (!repoName) {
-    if (socketJson.defaults?.scan?.create?.repo) {
-      repoName = socketJson.defaults.scan.create.repo;
+    if (sockJson.defaults?.scan?.create?.repo) {
+      repoName = sockJson.defaults.scan.create.repo;
       logger.logger.info('Using default --repo from socket.json:', repoName);
     } else {
       repoName = 'socket-default-repository';
     }
   }
   if (typeof report !== 'boolean') {
-    if (socketJson.defaults?.scan?.create?.report !== undefined) {
-      report = socketJson.defaults.scan.create.report;
+    if (sockJson.defaults?.scan?.create?.report !== undefined) {
+      report = sockJson.defaults.scan.create.report;
       logger.logger.info('Using default --report from socket.json:', report);
     } else {
       report = false;
@@ -10548,7 +10548,7 @@ async function run$c(argv, importMeta, {
       updatedInput = true;
     }
   }
-  const detected = await detectManifestActions(socketJson, cwd);
+  const detected = await detectManifestActions(sockJson, cwd);
   if (detected.count > 0 && !autoManifest) {
     logger.logger.info(`Detected ${detected.count} manifest targets we could try to generate. Please set the --autoManifest flag if you want to include languages covered by \`socket manifest auto\` in the Scan.`);
   }
@@ -11813,32 +11813,32 @@ async function run$9(argv, importMeta, {
     // Tmp. just for TS. will drop this later.
     defaultOrgSlug = '';
   }
-  const socketJson = await utils.readOrDefaultSocketJson(cwd);
+  const sockJson = await utils.readOrDefaultSocketJson(cwd);
   if (all === undefined) {
-    if (socketJson.defaults?.scan?.github?.all !== undefined) {
-      all = socketJson.defaults?.scan?.github?.all;
+    if (sockJson.defaults?.scan?.github?.all !== undefined) {
+      all = sockJson.defaults?.scan?.github?.all;
     } else {
       all = false;
     }
   }
   if (!githubApiUrl) {
-    if (socketJson.defaults?.scan?.github?.githubApiUrl !== undefined) {
-      githubApiUrl = socketJson.defaults.scan.github.githubApiUrl;
+    if (sockJson.defaults?.scan?.github?.githubApiUrl !== undefined) {
+      githubApiUrl = sockJson.defaults.scan.github.githubApiUrl;
     } else {
       githubApiUrl = 'https://api.github.com';
     }
   }
   if (!orgGithub) {
-    if (socketJson.defaults?.scan?.github?.orgGithub !== undefined) {
-      orgGithub = socketJson.defaults.scan.github.orgGithub;
+    if (sockJson.defaults?.scan?.github?.orgGithub !== undefined) {
+      orgGithub = sockJson.defaults.scan.github.orgGithub;
     } else {
       // Default to Socket org slug. Often that's fine. Vanity and all that.
       orgGithub = orgSlug;
     }
   }
   if (!all && !repos) {
-    if (socketJson.defaults?.scan?.github?.repos !== undefined) {
-      repos = socketJson.defaults.scan.github.repos;
+    if (sockJson.defaults?.scan?.github?.repos !== undefined) {
+      repos = sockJson.defaults.scan.github.repos;
     } else {
       repos = '';
     }
@@ -12593,16 +12593,16 @@ async function setupScanConfig(cwd, defaultOnReadError = false) {
   logger.logger.log('');
   logger.logger.log('Note: For details on a flag you can run `socket <cmd> --help`');
   logger.logger.log('');
-  const socketJsonResult = await utils.readSocketJson(cwd, defaultOnReadError);
-  if (!socketJsonResult.ok) {
-    return socketJsonResult;
+  const sockJsonCResult = await utils.readSocketJson(cwd, defaultOnReadError);
+  if (!sockJsonCResult.ok) {
+    return sockJsonCResult;
   }
-  const socketJson = socketJsonResult.data;
-  if (!socketJson.defaults) {
-    socketJson.defaults = {};
+  const sockJson = sockJsonCResult.data;
+  if (!sockJson.defaults) {
+    sockJson.defaults = {};
   }
-  if (!socketJson.defaults.scan) {
-    socketJson.defaults.scan = {};
+  if (!sockJson.defaults.scan) {
+    sockJson.defaults.scan = {};
   }
   const targetCommand = await prompts.select({
     message: 'Which scan command do you want to configure?',
@@ -12621,10 +12621,10 @@ async function setupScanConfig(cwd, defaultOnReadError = false) {
   switch (targetCommand) {
     case 'create':
       {
-        if (!socketJson.defaults.scan.create) {
-          socketJson.defaults.scan.create = {};
+        if (!sockJson.defaults.scan.create) {
+          sockJson.defaults.scan.create = {};
         }
-        const result = await configureScan(socketJson.defaults.scan.create);
+        const result = await configureScan(sockJson.defaults.scan.create);
         if (!result.ok || result.data.canceled) {
           return result;
         }
@@ -12632,10 +12632,10 @@ async function setupScanConfig(cwd, defaultOnReadError = false) {
       }
     case 'github':
       {
-        if (!socketJson.defaults.scan.github) {
-          socketJson.defaults.scan.github = {};
+        if (!sockJson.defaults.scan.github) {
+          sockJson.defaults.scan.github = {};
         }
-        const result = await configureGithub(socketJson.defaults.scan.github);
+        const result = await configureGithub(sockJson.defaults.scan.github);
         if (!result.ok || result.data.canceled) {
           return result;
         }
@@ -12661,7 +12661,7 @@ async function setupScanConfig(cwd, defaultOnReadError = false) {
       description: 'Do not update the config'
     }]
   })) {
-    return await utils.writeSocketJson(cwd, socketJson);
+    return await utils.writeSocketJson(cwd, sockJson);
   }
   return canceledByUser();
 }
@@ -13855,25 +13855,30 @@ async function installSafeNpm(query) {
   }
 }
 
-function removeSocketWrapper(file) {
-  return fs$1.readFile(file, 'utf8', function (err, data) {
-    if (err) {
-      logger.logger.fail('There was an error removing the alias:');
-      logger.logger.error(err);
-      return;
+function removeSocketWrapper(filepath) {
+  let content;
+  try {
+    content = fs$1.readFileSync(filepath, 'utf8');
+  } catch (e) {
+    logger.logger.fail(`There was an error removing the alias${e ? ':' : '.'}`);
+    if (e) {
+      logger.logger.error(e);
     }
-    const linesWithoutSocketAlias = data.split('\n').filter(l => l !== 'alias npm="socket npm"' && l !== 'alias npx="socket npx"');
-    const updatedFileContent = linesWithoutSocketAlias.join('\n');
-    fs$1.writeFile(file, updatedFileContent, function (err) {
-      if (err) {
-        logger.logger.error(err);
-        return;
-      }
-      logger.logger.success(`The alias was removed from ${file}. Running 'npm install' will now run the standard npm command in new terminals going forward.`);
-      logger.logger.log('');
-      logger.logger.info(`Note: We cannot deactivate the alias from current terminal sessions. You have to restart existing terminal sessions to finalize this step.`);
-    });
-  });
+    return;
+  }
+  const linesWithoutSocketAlias = content.split('\n').filter(l => l !== 'alias npm="socket npm"' && l !== 'alias npx="socket npx"');
+  const updatedContent = linesWithoutSocketAlias.join('\n');
+  try {
+    fs$1.writeFileSync(filepath, updatedContent, 'utf8');
+  } catch (e) {
+    if (e) {
+      logger.logger.error(e);
+    }
+    return;
+  }
+  logger.logger.success(`The alias was removed from ${filepath}. Running 'npm install' will now run the standard npm command in new terminals going forward.`);
+  logger.logger.log('');
+  logger.logger.info(`Note: We cannot deactivate the alias from current terminal sessions. You have to restart existing terminal sessions to finalize this step.`);
 }
 
 const {
@@ -14175,5 +14180,5 @@ void (async () => {
     await utils.captureException(e);
   }
 })();
-//# debugId=50b201bd-872f-4cc2-a080-a88cc2f0878
+//# debugId=6563e8a4-fb02-463b-9448-1c01e45e1721
 //# sourceMappingURL=cli.js.map