subagent-cli 0.3.0 → 0.3.1

package/src/utils/ide.ts

@@ -1,1494 +0,0 @@
-import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import axios from 'axios'
-import { execa } from 'execa'
-import capitalize from 'lodash-es/capitalize.js'
-import memoize from 'lodash-es/memoize.js'
-import { createConnection } from 'net'
-import * as os from 'os'
-import { basename, join, sep as pathSeparator, resolve } from 'path'
-import { logEvent } from 'src/services/analytics/index.js'
-import { getIsScrollDraining, getOriginalCwd } from '../bootstrap/state.js'
-import { callIdeRpc } from '../services/mcp/client.js'
-import type {
-  ConnectedMCPServer,
-  MCPServerConnection,
-} from '../services/mcp/types.js'
-import { getGlobalConfig, saveGlobalConfig } from './config.js'
-import { env } from './env.js'
-import { getClaudeConfigHomeDir, isEnvTruthy } from './envUtils.js'
-import {
-  execFileNoThrow,
-  execFileNoThrowWithCwd,
-  execSyncWithDefaults_DEPRECATED,
-} from './execFileNoThrow.js'
-import { getFsImplementation } from './fsOperations.js'
-import { getAncestorPidsAsync } from './genericProcessUtils.js'
-import { isJetBrainsPluginInstalledCached } from './jetbrains.js'
-import { logError } from './log.js'
-import { getPlatform } from './platform.js'
-import { lt } from './semver.js'
-
-// Lazy: IdeOnboardingDialog.tsx pulls React/ink; only needed in interactive onboarding path
-/* eslint-disable @typescript-eslint/no-require-imports */
-const ideOnboardingDialog =
-  (): typeof import('src/components/IdeOnboardingDialog.js') =>
-    require('src/components/IdeOnboardingDialog.js')
-
-import { createAbortController } from './abortController.js'
-import { logForDebugging } from './debug.js'
-import { envDynamic } from './envDynamic.js'
-import { errorMessage, isFsInaccessible } from './errors.js'
-/* eslint-enable @typescript-eslint/no-require-imports */
-import {
-  checkWSLDistroMatch,
-  WindowsToWSLConverter,
-} from './idePathConversion.js'
-import { sleep } from './sleep.js'
-import { jsonParse } from './slowOperations.js'
-
-function isProcessRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch {
-    return false
-  }
-}
-
-// Returns a function that lazily fetches our process's ancestor PID chain,
-// caching within the closure's lifetime. Callers should scope this to a
-// single detection pass — PIDs recycle and process trees change over time.
-function makeAncestorPidLookup(): () => Promise<Set<number>> {
-  let promise: Promise<Set<number>> | null = null
-  return () => {
-    if (!promise) {
-      promise = getAncestorPidsAsync(process.ppid, 10).then(
-        pids => new Set(pids),
-      )
-    }
-    return promise
-  }
-}
-
-type LockfileJsonContent = {
-  workspaceFolders?: string[]
-  pid?: number
-  ideName?: string
-  transport?: 'ws' | 'sse'
-  runningInWindows?: boolean
-  authToken?: string
-}
-
-type IdeLockfileInfo = {
-  workspaceFolders: string[]
-  port: number
-  pid?: number
-  ideName?: string
-  useWebSocket: boolean
-  runningInWindows: boolean
-  authToken?: string
-}
-
-export type DetectedIDEInfo = {
-  name: string
-  port: number
-  workspaceFolders: string[]
-  url: string
-  isValid: boolean
-  authToken?: string
-  ideRunningInWindows?: boolean
-}
-
-export type IdeType =
-  | 'cursor'
-  | 'windsurf'
-  | 'vscode'
-  | 'pycharm'
-  | 'intellij'
-  | 'webstorm'
-  | 'phpstorm'
-  | 'rubymine'
-  | 'clion'
-  | 'goland'
-  | 'rider'
-  | 'datagrip'
-  | 'appcode'
-  | 'dataspell'
-  | 'aqua'
-  | 'gateway'
-  | 'fleet'
-  | 'androidstudio'
-
-type IdeConfig = {
-  ideKind: 'vscode' | 'jetbrains'
-  displayName: string
-  processKeywordsMac: string[]
-  processKeywordsWindows: string[]
-  processKeywordsLinux: string[]
-}
-
-const supportedIdeConfigs: Record<IdeType, IdeConfig> = {
-  cursor: {
-    ideKind: 'vscode',
-    displayName: 'Cursor',
-    processKeywordsMac: ['Cursor Helper', 'Cursor.app'],
-    processKeywordsWindows: ['cursor.exe'],
-    processKeywordsLinux: ['cursor'],
-  },
-  windsurf: {
-    ideKind: 'vscode',
-    displayName: 'Windsurf',
-    processKeywordsMac: ['Windsurf Helper', 'Windsurf.app'],
-    processKeywordsWindows: ['windsurf.exe'],
-    processKeywordsLinux: ['windsurf'],
-  },
-  vscode: {
-    ideKind: 'vscode',
-    displayName: 'VS Code',
-    processKeywordsMac: ['Visual Studio Code', 'Code Helper'],
-    processKeywordsWindows: ['code.exe'],
-    processKeywordsLinux: ['code'],
-  },
-  intellij: {
-    ideKind: 'jetbrains',
-    displayName: 'IntelliJ IDEA',
-    processKeywordsMac: ['IntelliJ IDEA'],
-    processKeywordsWindows: ['idea64.exe'],
-    processKeywordsLinux: ['idea', 'intellij'],
-  },
-  pycharm: {
-    ideKind: 'jetbrains',
-    displayName: 'PyCharm',
-    processKeywordsMac: ['PyCharm'],
-    processKeywordsWindows: ['pycharm64.exe'],
-    processKeywordsLinux: ['pycharm'],
-  },
-  webstorm: {
-    ideKind: 'jetbrains',
-    displayName: 'WebStorm',
-    processKeywordsMac: ['WebStorm'],
-    processKeywordsWindows: ['webstorm64.exe'],
-    processKeywordsLinux: ['webstorm'],
-  },
-  phpstorm: {
-    ideKind: 'jetbrains',
-    displayName: 'PhpStorm',
-    processKeywordsMac: ['PhpStorm'],
-    processKeywordsWindows: ['phpstorm64.exe'],
-    processKeywordsLinux: ['phpstorm'],
-  },
-  rubymine: {
-    ideKind: 'jetbrains',
-    displayName: 'RubyMine',
-    processKeywordsMac: ['RubyMine'],
-    processKeywordsWindows: ['rubymine64.exe'],
-    processKeywordsLinux: ['rubymine'],
-  },
-  clion: {
-    ideKind: 'jetbrains',
-    displayName: 'CLion',
-    processKeywordsMac: ['CLion'],
-    processKeywordsWindows: ['clion64.exe'],
-    processKeywordsLinux: ['clion'],
-  },
-  goland: {
-    ideKind: 'jetbrains',
-    displayName: 'GoLand',
-    processKeywordsMac: ['GoLand'],
-    processKeywordsWindows: ['goland64.exe'],
-    processKeywordsLinux: ['goland'],
-  },
-  rider: {
-    ideKind: 'jetbrains',
-    displayName: 'Rider',
-    processKeywordsMac: ['Rider'],
-    processKeywordsWindows: ['rider64.exe'],
-    processKeywordsLinux: ['rider'],
-  },
-  datagrip: {
-    ideKind: 'jetbrains',
-    displayName: 'DataGrip',
-    processKeywordsMac: ['DataGrip'],
-    processKeywordsWindows: ['datagrip64.exe'],
-    processKeywordsLinux: ['datagrip'],
-  },
-  appcode: {
-    ideKind: 'jetbrains',
-    displayName: 'AppCode',
-    processKeywordsMac: ['AppCode'],
-    processKeywordsWindows: ['appcode.exe'],
-    processKeywordsLinux: ['appcode'],
-  },
-  dataspell: {
-    ideKind: 'jetbrains',
-    displayName: 'DataSpell',
-    processKeywordsMac: ['DataSpell'],
-    processKeywordsWindows: ['dataspell64.exe'],
-    processKeywordsLinux: ['dataspell'],
-  },
-  aqua: {
-    ideKind: 'jetbrains',
-    displayName: 'Aqua',
-    processKeywordsMac: [], // Do not auto-detect since aqua is too common
-    processKeywordsWindows: ['aqua64.exe'],
-    processKeywordsLinux: [],
-  },
-  gateway: {
-    ideKind: 'jetbrains',
-    displayName: 'Gateway',
-    processKeywordsMac: [], // Do not auto-detect since gateway is too common
-    processKeywordsWindows: ['gateway64.exe'],
-    processKeywordsLinux: [],
-  },
-  fleet: {
-    ideKind: 'jetbrains',
-    displayName: 'Fleet',
-    processKeywordsMac: [], // Do not auto-detect since fleet is too common
-    processKeywordsWindows: ['fleet.exe'],
-    processKeywordsLinux: [],
-  },
-  androidstudio: {
-    ideKind: 'jetbrains',
-    displayName: 'Android Studio',
-    processKeywordsMac: ['Android Studio'],
-    processKeywordsWindows: ['studio64.exe'],
-    processKeywordsLinux: ['android-studio'],
-  },
-}
-
-export function isVSCodeIde(ide: IdeType | null): boolean {
-  if (!ide) return false
-  const config = supportedIdeConfigs[ide]
-  return config && config.ideKind === 'vscode'
-}
-
-export function isJetBrainsIde(ide: IdeType | null): boolean {
-  if (!ide) return false
-  const config = supportedIdeConfigs[ide]
-  return config && config.ideKind === 'jetbrains'
-}
-
-export const isSupportedVSCodeTerminal = memoize(() => {
-  return isVSCodeIde(env.terminal as IdeType)
-})
-
-export const isSupportedJetBrainsTerminal = memoize(() => {
-  return isJetBrainsIde(envDynamic.terminal as IdeType)
-})
-
-export const isSupportedTerminal = memoize(() => {
-  return (
-    isSupportedVSCodeTerminal() ||
-    isSupportedJetBrainsTerminal() ||
-    Boolean(process.env.FORCE_CODE_TERMINAL)
-  )
-})
-
-export function getTerminalIdeType(): IdeType | null {
-  if (!isSupportedTerminal()) {
-    return null
-  }
-  return env.terminal as IdeType
-}
-
-/**
- * Gets sorted IDE lockfiles from ~/.claude/ide directory
- * @returns Array of full lockfile paths sorted by modification time (newest first)
- */
-export async function getSortedIdeLockfiles(): Promise<string[]> {
-  try {
-    const ideLockFilePaths = await getIdeLockfilesPaths()
-
-    // Collect all lockfiles from all directories
-    const allLockfiles: Array<{ path: string; mtime: Date }>[] =
-      await Promise.all(
-        ideLockFilePaths.map(async ideLockFilePath => {
-          try {
-            const entries = await getFsImplementation().readdir(ideLockFilePath)
-            const lockEntries = entries.filter(file =>
-              file.name.endsWith('.lock'),
-            )
-            // Stat all lockfiles in parallel; skip ones that fail
-            const stats = await Promise.all(
-              lockEntries.map(async file => {
-                const fullPath = join(ideLockFilePath, file.name)
-                try {
-                  const fileStat = await getFsImplementation().stat(fullPath)
-                  return { path: fullPath, mtime: fileStat.mtime }
-                } catch {
-                  return null
-                }
-              }),
-            )
-            return stats.filter(s => s !== null)
-          } catch (error) {
-            // Candidate paths are pushed without pre-checking existence, so
-            // missing/inaccessible dirs are expected here — skip silently.
-            if (!isFsInaccessible(error)) {
-              logError(error)
-            }
-            return []
-          }
-        }),
-      )
-
-    // Flatten and sort all lockfiles by last modified date (newest first)
-    return allLockfiles
-      .flat()
-      .sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
-      .map(file => file.path)
-  } catch (error) {
-    logError(error as Error)
-    return []
-  }
-}
-
-async function readIdeLockfile(path: string): Promise<IdeLockfileInfo | null> {
-  try {
-    const content = await getFsImplementation().readFile(path, {
-      encoding: 'utf-8',
-    })
-
-    let workspaceFolders: string[] = []
-    let pid: number | undefined
-    let ideName: string | undefined
-    let useWebSocket = false
-    let runningInWindows = false
-    let authToken: string | undefined
-
-    try {
-      const parsedContent = jsonParse(content) as LockfileJsonContent
-      if (parsedContent.workspaceFolders) {
-        workspaceFolders = parsedContent.workspaceFolders
-      }
-      pid = parsedContent.pid
-      ideName = parsedContent.ideName
-      useWebSocket = parsedContent.transport === 'ws'
-      runningInWindows = parsedContent.runningInWindows === true
-      authToken = parsedContent.authToken
-    } catch (_) {
-      // Older format- just a list of paths.
-      workspaceFolders = content.split('\n').map(line => line.trim())
-    }
-
-    // Extract the port from the filename (e.g., 12345.lock -> 12345)
-    const filename = path.split(pathSeparator).pop()
-    if (!filename) return null
-
-    const port = filename.replace('.lock', '')
-
-    return {
-      workspaceFolders,
-      port: parseInt(port),
-      pid,
-      ideName,
-      useWebSocket,
-      runningInWindows,
-      authToken,
-    }
-  } catch (error) {
-    logError(error as Error)
-    return null
-  }
-}
-
-/**
- * Checks if the IDE connection is responding by testing if the port is open
- * @param host Host to connect to
- * @param port Port to connect to
- * @param timeout Optional timeout in milliseconds (defaults to 500ms)
- * @returns true if the port is open, false otherwise
- */
-async function checkIdeConnection(
-  host: string,
-  port: number,
-  timeout = 500,
-): Promise<boolean> {
-  try {
-    return new Promise(resolve => {
-      const socket = createConnection({
-        host: host,
-        port: port,
-        timeout: timeout,
-      })
-
-      socket.on('connect', () => {
-        socket.destroy()
-        void resolve(true)
-      })
-
-      socket.on('error', () => {
-        void resolve(false)
-      })
-
-      socket.on('timeout', () => {
-        socket.destroy()
-        void resolve(false)
-      })
-    })
-  } catch (_) {
-    // Invalid URL or other errors
-    return false
-  }
-}
-
-/**
- * Resolve the Windows USERPROFILE path. WSL often doesn't pass USERPROFILE
- * through, so fall back to shelling out to powershell.exe. That spawn is
- * ~500ms–2s cold; the value is static per session.
- */
-const getWindowsUserProfile = memoize(async (): Promise<string | undefined> => {
-  if (process.env.USERPROFILE) return process.env.USERPROFILE
-  const { stdout, code } = await execFileNoThrow('powershell.exe', [
-    '-NoProfile',
-    '-NonInteractive',
-    '-Command',
-    '$env:USERPROFILE',
-  ])
-  if (code === 0 && stdout.trim()) return stdout.trim()
-  logForDebugging(
-    'Unable to get Windows USERPROFILE via PowerShell - IDE detection may be incomplete',
-  )
-  return undefined
-})
-
-/**
- * Gets the potential IDE lockfiles directories path based on platform.
- * Paths are not pre-checked for existence — the consumer readdirs each
- * and handles ENOENT. Pre-checking with stat() would double syscalls,
- * and on WSL (where /mnt/c access is 2-10x slower) the per-user-dir
- * stat loop compounded startup latency.
- */
-export async function getIdeLockfilesPaths(): Promise<string[]> {
-  const paths: string[] = [join(getClaudeConfigHomeDir(), 'ide')]
-
-  if (getPlatform() !== 'wsl') {
-    return paths
-  }
-
-  // For Windows, use heuristics to find the potential paths.
-  // See https://learn.microsoft.com/en-us/windows/wsl/filesystems
-
-  const windowsHome = await getWindowsUserProfile()
-
-  if (windowsHome) {
-    const converter = new WindowsToWSLConverter(process.env.WSL_DISTRO_NAME)
-    const wslPath = converter.toLocalPath(windowsHome)
-    paths.push(resolve(wslPath, '.claude', 'ide'))
-  }
-
-  // Construct the path based on the standard Windows WSL locations
-  // This can fail if the current user does not have "List folder contents" permission on C:\Users
-  try {
-    const usersDir = '/mnt/c/Users'
-    const userDirs = await getFsImplementation().readdir(usersDir)
-
-    for (const user of userDirs) {
-      // Skip files (e.g. desktop.ini) — readdir on a file path throws ENOTDIR.
-      // isFsInaccessible covers ENOTDIR, but pre-filtering here avoids the
-      // cost of attempting to readdir non-directories. Symlinks are kept since
-      // Windows creates junction points for user profiles.
-      if (!user.isDirectory() && !user.isSymbolicLink()) {
-        continue
-      }
-      if (
-        user.name === 'Public' ||
-        user.name === 'Default' ||
-        user.name === 'Default User' ||
-        user.name === 'All Users'
-      ) {
-        continue // Skip system directories
-      }
-      paths.push(join(usersDir, user.name, '.claude', 'ide'))
-    }
-  } catch (error: unknown) {
-    if (isFsInaccessible(error)) {
-      // Expected on WSL when C: drive is not mounted or user lacks permissions
-      logForDebugging(
-        `WSL IDE lockfile path detection failed (${error.code}): ${errorMessage(error)}`,
-      )
-    } else {
-      logError(error)
-    }
-  }
-  return paths
-}
-
-/**
- * Cleans up stale IDE lockfiles
- * - Removes lockfiles for processes that are no longer running
- * - Removes lockfiles for ports that are not responding
- */
-export async function cleanupStaleIdeLockfiles(): Promise<void> {
-  try {
-    const lockfiles = await getSortedIdeLockfiles()
-
-    for (const lockfilePath of lockfiles) {
-      const lockfileInfo = await readIdeLockfile(lockfilePath)
-
-      if (!lockfileInfo) {
-        // If we can't read the lockfile, delete it
-        try {
-          await getFsImplementation().unlink(lockfilePath)
-        } catch (error) {
-          logError(error as Error)
-        }
-        continue
-      }
-
-      const host = await detectHostIP(
-        lockfileInfo.runningInWindows,
-        lockfileInfo.port,
-      )
-
-      let shouldDelete = false
-
-      if (lockfileInfo.pid) {
-        // Check if the process is still running
-        if (!isProcessRunning(lockfileInfo.pid)) {
-          if (getPlatform() !== 'wsl') {
-            shouldDelete = true
-          } else {
-            // The process id may not be reliable in wsl, so also check the connection
-            const isResponding = await checkIdeConnection(
-              host,
-              lockfileInfo.port,
-            )
-            if (!isResponding) {
-              shouldDelete = true
-            }
-          }
-        }
-      } else {
-        // No PID, check if the URL is responding
-        const isResponding = await checkIdeConnection(host, lockfileInfo.port)
-        if (!isResponding) {
-          shouldDelete = true
-        }
-      }
-
-      if (shouldDelete) {
-        try {
-          await getFsImplementation().unlink(lockfilePath)
-        } catch (error) {
-          logError(error as Error)
-        }
-      }
-    }
-  } catch (error) {
-    logError(error as Error)
-  }
-}
-
-export interface IDEExtensionInstallationStatus {
-  installed: boolean
-  error: string | null
-  installedVersion: string | null
-  ideType: IdeType | null
-}
-
-export async function maybeInstallIDEExtension(
-  ideType: IdeType,
-): Promise<IDEExtensionInstallationStatus | null> {
-  try {
-    // Install/update the extension
-    const installedVersion = await installIDEExtension(ideType)
-    // Only track successful installations
-    logEvent('tengu_ext_installed', {})
-
-    // Set diff tool config to auto if it has not been set already
-    const globalConfig = getGlobalConfig()
-    if (!globalConfig.diffTool) {
-      saveGlobalConfig(current => ({ ...current, diffTool: 'auto' }))
-    }
-    return {
-      installed: true,
-      error: null,
-      installedVersion,
-      ideType: ideType,
-    }
-  } catch (error) {
-    logEvent('tengu_ext_install_error', {})
-    // Handle installation errors
-    const errorMessage = error instanceof Error ? error.message : String(error)
-    logError(error as Error)
-    return {
-      installed: false,
-      error: errorMessage,
-      installedVersion: null,
-      ideType: ideType,
-    }
-  }
-}
-
-let currentIDESearch: AbortController | null = null
-
-export async function findAvailableIDE(): Promise<DetectedIDEInfo | null> {
-  if (currentIDESearch) {
-    currentIDESearch.abort()
-  }
-  currentIDESearch = createAbortController()
-  const signal = currentIDESearch.signal
-
-  // Clean up stale IDE lockfiles first so we don't check them at all.
-  await cleanupStaleIdeLockfiles()
-  const startTime = Date.now()
-  while (Date.now() - startTime < 30_000 && !signal.aborted) {
-    // Skip iteration during scroll drain — detectIDEs reads lockfiles +
-    // shells out to ps, competing for the event loop with scroll frames.
-    // Next tick after scroll settles resumes the search.
-    if (getIsScrollDraining()) {
-      await sleep(1000, signal)
-      continue
-    }
-    const ides = await detectIDEs(false)
-    if (signal.aborted) {
-      return null
-    }
-    // Return the IDE if and only if there is exactly one match, otherwise the user must
-    // use /ide to select an IDE. When running from a supported built-in terminal, detectIDEs()
-    // should return at most one IDE.
-    if (ides.length === 1) {
-      return ides[0]!
-    }
-    await sleep(1000, signal)
-  }
-  return null
-}
-
-/**
- * Detects IDEs that have a running extension/plugin.
- * @param includeInvalid If true, also return IDEs that are invalid (ie. where
- * the workspace directory does not match the cwd)
- */
-export async function detectIDEs(
-  includeInvalid: boolean,
-): Promise<DetectedIDEInfo[]> {
-  const detectedIDEs: DetectedIDEInfo[] = []
-
-  try {
-    // Get the CLAUDE_CODE_SSE_PORT if set
-    const ssePort = process.env.CLAUDE_CODE_SSE_PORT
-    const envPort = ssePort ? parseInt(ssePort) : null
-
-    // Get the current working directory, normalized to NFC for consistent
-    // comparison. macOS returns NFD paths (decomposed Unicode), while IDEs
-    // like VS Code report NFC paths (composed Unicode). Without normalization,
-    // paths containing accented/CJK characters fail to match.
-    const cwd = getOriginalCwd().normalize('NFC')
-
-    // Get sorted lockfiles (full paths) and read them all in parallel.
-    // findAvailableIDE() polls this every 1s for up to 30s; serial I/O here was
-    // showing up as ~500ms self-time in CPU profiles.
-    const lockfiles = await getSortedIdeLockfiles()
-    const lockfileInfos = await Promise.all(lockfiles.map(readIdeLockfile))
-
-    // Ancestor PID walk shells out (ps in a loop, up to 10x). Make it lazy and
-    // single-shot per detectIDEs() call; with the workspace-check-first ordering
-    // below, this often never fires at all.
-    const getAncestors = makeAncestorPidLookup()
-    const needsAncestryCheck = getPlatform() !== 'wsl' && isSupportedTerminal()
-
-    // Try to find a lockfile that contains our current working directory
-    for (const lockfileInfo of lockfileInfos) {
-      if (!lockfileInfo) continue
-
-      let isValid = false
-      if (isEnvTruthy(process.env.CLAUDE_CODE_IDE_SKIP_VALID_CHECK)) {
-        isValid = true
-      } else if (lockfileInfo.port === envPort) {
-        // If the port matches the environment variable, mark as valid regardless of directory
-        isValid = true
-      } else {
-        // Otherwise, check if the current working directory is within the workspace folders
-        isValid = lockfileInfo.workspaceFolders.some(idePath => {
-          if (!idePath) return false
-
-          let localPath = idePath
-
-          // Handle WSL-specific path conversion and distro matching
-          if (
-            getPlatform() === 'wsl' &&
-            lockfileInfo.runningInWindows &&
-            process.env.WSL_DISTRO_NAME
-          ) {
-            // Check for WSL distro mismatch
-            if (!checkWSLDistroMatch(idePath, process.env.WSL_DISTRO_NAME)) {
-              return false
-            }
-
-            // Try both the original path and the converted path
-            // This handles cases where the IDE might report either format
-            const resolvedOriginal = resolve(localPath).normalize('NFC')
-            if (
-              cwd === resolvedOriginal ||
-              cwd.startsWith(resolvedOriginal + pathSeparator)
-            ) {
-              return true
-            }
-
-            // Convert Windows IDE path to WSL local path and check that too
-            const converter = new WindowsToWSLConverter(
-              process.env.WSL_DISTRO_NAME,
-            )
-            localPath = converter.toLocalPath(idePath)
-          }
-
-          const resolvedPath = resolve(localPath).normalize('NFC')
-
-          // On Windows, normalize paths for case-insensitive drive letter comparison
-          if (getPlatform() === 'windows') {
-            const normalizedCwd = cwd.replace(/^[a-zA-Z]:/, match =>
-              match.toUpperCase(),
-            )
-            const normalizedResolvedPath = resolvedPath.replace(
-              /^[a-zA-Z]:/,
-              match => match.toUpperCase(),
-            )
-            return (
-              normalizedCwd === normalizedResolvedPath ||
-              normalizedCwd.startsWith(normalizedResolvedPath + pathSeparator)
-            )
-          }
-
-          return (
-            cwd === resolvedPath || cwd.startsWith(resolvedPath + pathSeparator)
-          )
-        })
-      }
-
-      if (!isValid && !includeInvalid) {
-        continue
-      }
-
-      // PID ancestry check: when running in a supported IDE's built-in terminal,
-      // ensure this lockfile's IDE is actually our parent process. This
-      // disambiguates when multiple IDE windows have overlapping workspace folders.
-      // Runs AFTER the workspace check so non-matching lockfiles skip it entirely —
-      // previously this shelled out once per lockfile and dominated CPU profiles
-      // during findAvailableIDE() polling.
-      if (needsAncestryCheck) {
-        const portMatchesEnv = envPort !== null && lockfileInfo.port === envPort
-        if (!portMatchesEnv) {
-          if (!lockfileInfo.pid || !isProcessRunning(lockfileInfo.pid)) {
-            continue
-          }
-          if (process.ppid !== lockfileInfo.pid) {
-            const ancestors = await getAncestors()
-            if (!ancestors.has(lockfileInfo.pid)) {
-              continue
-            }
-          }
-        }
-      }
-
-      const ideName =
-        lockfileInfo.ideName ??
-        (isSupportedTerminal() ? toIDEDisplayName(envDynamic.terminal) : 'IDE')
-
-      const host = await detectHostIP(
-        lockfileInfo.runningInWindows,
-        lockfileInfo.port,
-      )
-      let url
-      if (lockfileInfo.useWebSocket) {
-        url = `ws://${host}:${lockfileInfo.port}`
-      } else {
-        url = `http://${host}:${lockfileInfo.port}/sse`
-      }
-
-      detectedIDEs.push({
-        url: url,
-        name: ideName,
-        workspaceFolders: lockfileInfo.workspaceFolders,
-        port: lockfileInfo.port,
-        isValid: isValid,
-        authToken: lockfileInfo.authToken,
-        ideRunningInWindows: lockfileInfo.runningInWindows,
-      })
-    }
-
-    // The envPort should be defined for supported IDE terminals. If there is
-    // an extension with a matching envPort, then we will single that one out
-    // and return it, otherwise we return all the valid ones.
-    if (!includeInvalid && envPort) {
-      const envPortMatch = detectedIDEs.filter(
-        ide => ide.isValid && ide.port === envPort,
-      )
-      if (envPortMatch.length === 1) {
-        return envPortMatch
-      }
-    }
-  } catch (error) {
-    logError(error as Error)
-  }
-
-  return detectedIDEs
-}
-
-export async function maybeNotifyIDEConnected(client: Client) {
-  await client.notification({
-    method: 'ide_connected',
-    params: {
-      pid: process.pid,
-    },
-  })
-}
-
-export function hasAccessToIDEExtensionDiffFeature(
-  mcpClients: MCPServerConnection[],
-): boolean {
-  // Check if there's a connected IDE client in the provided MCP clients list
-  return mcpClients.some(
-    client => client.type === 'connected' && client.name === 'ide',
-  )
-}
-
-const EXTENSION_ID =
-  process.env.USER_TYPE === 'ant'
-    ? 'anthropic.claude-code-internal'
-    : 'anthropic.claude-code'
-
-export async function isIDEExtensionInstalled(
-  ideType: IdeType,
-): Promise<boolean> {
-  if (isVSCodeIde(ideType)) {
-    const command = await getVSCodeIDECommand(ideType)
-    if (command) {
-      try {
-        const result = await execFileNoThrowWithCwd(
-          command,
-          ['--list-extensions'],
-          {
-            env: getInstallationEnv(),
-          },
-        )
-        if (result.stdout?.includes(EXTENSION_ID)) {
-          return true
-        }
-      } catch {
-        // eat the error
-      }
-    }
-  } else if (isJetBrainsIde(ideType)) {
-    return await isJetBrainsPluginInstalledCached(ideType)
-  }
-  return false
-}
-
-async function installIDEExtension(ideType: IdeType): Promise<string | null> {
-  if (isVSCodeIde(ideType)) {
-    const command = await getVSCodeIDECommand(ideType)
-
-    if (command) {
-      if (process.env.USER_TYPE === 'ant') {
-        return await installFromArtifactory(command)
-      }
-      let version = await getInstalledVSCodeExtensionVersion(command)
-      // If it's not installed or the version is older than the one we have bundled,
-      if (!version || lt(version, getClaudeCodeVersion())) {
-        // `code` may crash when invoked too quickly in succession
-        await sleep(500)
-        const result = await execFileNoThrowWithCwd(
-          command,
-          ['--force', '--install-extension', 'anthropic.claude-code'],
-          {
-            env: getInstallationEnv(),
-          },
-        )
-        if (result.code !== 0) {
-          throw new Error(`${result.code}: ${result.error} ${result.stderr}`)
-        }
-        version = getClaudeCodeVersion()
-      }
-      return version
-    }
-  }
-  // No automatic installation for JetBrains IDEs as it is not supported in native
-  // builds. We show a prominent notice for them to download from the marketplace
-  // instead.
-  return null
-}
-
-function getInstallationEnv(): NodeJS.ProcessEnv | undefined {
-  // Cursor on Linux may incorrectly implement
-  // the `code` command and actually launch the UI.
-  // Make this error out if this happens by clearing the DISPLAY
-  // environment variable.
-  if (getPlatform() === 'linux') {
-    return {
-      ...process.env,
-      DISPLAY: '',
-    }
-  }
-  return undefined
-}
-
-function getClaudeCodeVersion() {
-  return MACRO.VERSION
-}
-
-async function getInstalledVSCodeExtensionVersion(
-  command: string,
-): Promise<string | null> {
-  const { stdout } = await execFileNoThrow(
-    command,
-    ['--list-extensions', '--show-versions'],
-    {
-      env: getInstallationEnv(),
-    },
-  )
-  const lines = stdout?.split('\n') || []
-  for (const line of lines) {
-    const [extensionId, version] = line.split('@')
-    if (extensionId === 'anthropic.claude-code' && version) {
-      return version
-    }
-  }
-  return null
-}
-
-function getVSCodeIDECommandByParentProcess(): string | null {
-  try {
-    const platform = getPlatform()
-
-    // Only supported on OSX, where Cursor has the ability to
-    // register itself as the 'code' command.
-    if (platform !== 'macos') {
-      return null
-    }
-
-    let pid = process.ppid
-
-    // Walk up the process tree to find the actual app
-    for (let i = 0; i < 10; i++) {
-      if (!pid || pid === 0 || pid === 1) break
-
-      // Get the command for this PID
-      // this function already returned if not running on macos
-      const command = execSyncWithDefaults_DEPRECATED(
-        // eslint-disable-next-line custom-rules/no-direct-ps-commands
-        `ps -o command= -p ${pid}`,
-      )?.trim()
-
-      if (command) {
-        // Check for known applications and extract the path up to and including .app
-        const appNames = {
-          'Visual Studio Code.app': 'code',
-          'Cursor.app': 'cursor',
-          'Windsurf.app': 'windsurf',
-          'Visual Studio Code - Insiders.app': 'code',
-          'VSCodium.app': 'codium',
-        }
-        const pathToExecutable = '/Contents/MacOS/Electron'
-
-        for (const [appName, executableName] of Object.entries(appNames)) {
-          const appIndex = command.indexOf(appName + pathToExecutable)
-          if (appIndex !== -1) {
-            // Extract the path from the beginning to the end of the .app name
-            const folderPathEnd = appIndex + appName.length
-            // These are all known VSCode variants with the same structure
-            return (
-              command.substring(0, folderPathEnd) +
-              '/Contents/Resources/app/bin/' +
-              executableName
-            )
-          }
-        }
-      }
-
-      // Get parent PID
-      // this function already returned if not running on macos
-      const ppidStr = execSyncWithDefaults_DEPRECATED(
-        // eslint-disable-next-line custom-rules/no-direct-ps-commands
-        `ps -o ppid= -p ${pid}`,
-      )?.trim()
-      if (!ppidStr) {
-        break
-      }
-      pid = parseInt(ppidStr.trim())
-    }
-
-    return null
-  } catch {
-    return null
-  }
-}
-async function getVSCodeIDECommand(ideType: IdeType): Promise<string | null> {
-  const parentExecutable = getVSCodeIDECommandByParentProcess()
-  if (parentExecutable) {
-    // Verify the parent executable actually exists
-    try {
-      await getFsImplementation().stat(parentExecutable)
-      return parentExecutable
-    } catch {
-      // Parent executable doesn't exist
-    }
-  }
-
-  // On Windows, explicitly request the .cmd wrapper. VS Code 1.110.0 began
-  // prepending the install root (containing Code.exe, the Electron GUI binary)
-  // to the integrated terminal's PATH ahead of bin\ (containing code.cmd, the
-  // CLI wrapper) when launched via Start-Menu/Taskbar shortcuts. A bare 'code'
-  // then resolves to Code.exe via PATHEXT which opens a new editor window
-  // instead of running the CLI. Asking for 'code.cmd' forces cross-spawn/which
-  // to skip Code.exe. See microsoft/vscode#299416 (fixed in Insiders) and
-  // anthropics/claude-code#30975.
-  const ext = getPlatform() === 'windows' ? '.cmd' : ''
-  switch (ideType) {
-    case 'vscode':
-      return 'code' + ext
-    case 'cursor':
-      return 'cursor' + ext
-    case 'windsurf':
-      return 'windsurf' + ext
-    default:
-      break
-  }
-  return null
-}
-
-export async function isCursorInstalled(): Promise<boolean> {
-  const result = await execFileNoThrow('cursor', ['--version'])
-  return result.code === 0
-}
-
-export async function isWindsurfInstalled(): Promise<boolean> {
-  const result = await execFileNoThrow('windsurf', ['--version'])
-  return result.code === 0
-}
-
-export async function isVSCodeInstalled(): Promise<boolean> {
-  const result = await execFileNoThrow('code', ['--help'])
-  // Check if the output indicates this is actually Visual Studio Code
-  return (
-    result.code === 0 && Boolean(result.stdout?.includes('Visual Studio Code'))
-  )
-}
-
-// Cache for IDE detection results
-let cachedRunningIDEs: IdeType[] | null = null
-
-/**
- * Internal implementation of IDE detection.
- */
-async function detectRunningIDEsImpl(): Promise<IdeType[]> {
-  const runningIDEs: IdeType[] = []
-
-  try {
-    const platform = getPlatform()
-    if (platform === 'macos') {
-      // On macOS, use ps with process name matching
-      const result = await execa(
-        'ps aux | grep -E "Visual Studio Code|Code Helper|Cursor Helper|Windsurf Helper|IntelliJ IDEA|PyCharm|WebStorm|PhpStorm|RubyMine|CLion|GoLand|Rider|DataGrip|AppCode|DataSpell|Aqua|Gateway|Fleet|Android Studio" | grep -v grep',
-        { shell: true, reject: false },
-      )
-      const stdout = result.stdout ?? ''
-      for (const [ide, config] of Object.entries(supportedIdeConfigs)) {
-        for (const keyword of config.processKeywordsMac) {
-          if (stdout.includes(keyword)) {
-            runningIDEs.push(ide as IdeType)
-            break
-          }
-        }
-      }
-    } else if (platform === 'windows') {
-      // On Windows, use tasklist with findstr for multiple patterns
-      const result = await execa(
-        'tasklist | findstr /I "Code.exe Cursor.exe Windsurf.exe idea64.exe pycharm64.exe webstorm64.exe phpstorm64.exe rubymine64.exe clion64.exe goland64.exe rider64.exe datagrip64.exe appcode.exe dataspell64.exe aqua64.exe gateway64.exe fleet.exe studio64.exe"',
-        { shell: true, reject: false },
-      )
-      const stdout = result.stdout ?? ''
-
-      const normalizedStdout = stdout.toLowerCase()
-
-      for (const [ide, config] of Object.entries(supportedIdeConfigs)) {
-        for (const keyword of config.processKeywordsWindows) {
-          if (normalizedStdout.includes(keyword.toLowerCase())) {
-            runningIDEs.push(ide as IdeType)
-            break
-          }
-        }
-      }
-    } else if (platform === 'linux') {
-      // On Linux, use ps with process name matching
-      const result = await execa(
-        'ps aux | grep -E "code|cursor|windsurf|idea|pycharm|webstorm|phpstorm|rubymine|clion|goland|rider|datagrip|dataspell|aqua|gateway|fleet|android-studio" | grep -v grep',
-        { shell: true, reject: false },
-      )
-      const stdout = result.stdout ?? ''
-
-      const normalizedStdout = stdout.toLowerCase()
-
-      for (const [ide, config] of Object.entries(supportedIdeConfigs)) {
-        for (const keyword of config.processKeywordsLinux) {
-          if (normalizedStdout.includes(keyword)) {
-            if (ide !== 'vscode') {
-              runningIDEs.push(ide as IdeType)
-              break
-            } else if (
-              !normalizedStdout.includes('cursor') &&
-              !normalizedStdout.includes('appcode')
-            ) {
-              // Special case conflicting keywords from some of the IDEs.
-              runningIDEs.push(ide as IdeType)
-              break
-            }
-          }
-        }
-      }
-    }
-  } catch (error) {
-    // If process detection fails, return empty array
-    logError(error as Error)
-  }
-
-  return runningIDEs
-}
-
-/**
- * Detects running IDEs and returns an array of IdeType for those that are running.
- * This performs fresh detection (~150ms) and updates the cache for subsequent
- * detectRunningIDEsCached() calls.
- */
-export async function detectRunningIDEs(): Promise<IdeType[]> {
-  const result = await detectRunningIDEsImpl()
-  cachedRunningIDEs = result
-  return result
-}
-
-/**
- * Returns cached IDE detection results, or performs detection if cache is empty.
- * Use this for performance-sensitive paths like tips where fresh results aren't needed.
- */
-export async function detectRunningIDEsCached(): Promise<IdeType[]> {
-  if (cachedRunningIDEs === null) {
-    return detectRunningIDEs()
-  }
-  return cachedRunningIDEs
-}
-
-/**
- * Resets the cache for detectRunningIDEsCached.
- * Exported for testing - allows resetting state between tests.
- */
-export function resetDetectRunningIDEs(): void {
-  cachedRunningIDEs = null
-}
-
-export function getConnectedIdeName(
-  mcpClients: MCPServerConnection[],
-): string | null {
-  const ideClient = mcpClients.find(
-    client => client.type === 'connected' && client.name === 'ide',
-  )
-  return getIdeClientName(ideClient)
-}
-
-export function getIdeClientName(
-  ideClient?: MCPServerConnection,
-): string | null {
-  const config = ideClient?.config
-  return config?.type === 'sse-ide' || config?.type === 'ws-ide'
-    ? config.ideName
-    : isSupportedTerminal()
-      ? toIDEDisplayName(envDynamic.terminal)
-      : null
-}
-
-const EDITOR_DISPLAY_NAMES: Record<string, string> = {
-  code: 'VS Code',
-  cursor: 'Cursor',
-  windsurf: 'Windsurf',
-  antigravity: 'Antigravity',
-  vi: 'Vim',
-  vim: 'Vim',
-  nano: 'nano',
-  notepad: 'Notepad',
-  'start /wait notepad': 'Notepad',
-  emacs: 'Emacs',
-  subl: 'Sublime Text',
-  atom: 'Atom',
-}
-
-export function toIDEDisplayName(terminal: string | null): string {
-  if (!terminal) return 'IDE'
-
-  const config = supportedIdeConfigs[terminal as IdeType]
-  if (config) {
-    return config.displayName
-  }
-
-  // Check editor command names (exact match first)
-  const editorName = EDITOR_DISPLAY_NAMES[terminal.toLowerCase().trim()]
-  if (editorName) {
-    return editorName
-  }
-
-  // Extract command name from path/arguments (e.g., "/usr/bin/code --wait" -> "code")
-  const command = terminal.split(' ')[0]
-  const commandName = command ? basename(command).toLowerCase() : null
-  if (commandName) {
-    const mappedName = EDITOR_DISPLAY_NAMES[commandName]
-    if (mappedName) {
-      return mappedName
-    }
-    // Fallback: capitalize the command basename
-    return capitalize(commandName)
-  }
-
-  // Fallback: capitalize first letter
-  return capitalize(terminal)
-}
-
-export { callIdeRpc }
-
-/**
- * Gets the connected IDE client from a list of MCP clients
- * @param mcpClients - Array of wrapped MCP clients
- * @returns The connected IDE client, or undefined if not found
- */
-export function getConnectedIdeClient(
-  mcpClients?: MCPServerConnection[],
-): ConnectedMCPServer | undefined {
-  if (!mcpClients) {
-    return undefined
-  }
-
-  const ideClient = mcpClients.find(
-    client => client.type === 'connected' && client.name === 'ide',
-  )
-
-  // Type guard to ensure we return the correct type
-  return ideClient?.type === 'connected' ? ideClient : undefined
-}
-
-/**
- * Notifies the IDE that a new prompt has been submitted.
- * This triggers IDE-specific actions like closing all diff tabs.
- */
-export async function closeOpenDiffs(
-  ideClient: ConnectedMCPServer,
-): Promise<void> {
-  try {
-    await callIdeRpc('closeAllDiffTabs', {}, ideClient)
-  } catch (_) {
-    // Silently ignore errors when closing diff tabs
-    // This prevents exceptions if the IDE doesn't support this operation
-  }
-}
-
-/**
- * Initializes IDE detection and extension installation, then calls the provided callback
- * with the detected IDE information and installation status.
- * @param ideToInstallExtension The ide to install the extension to (if installing from external terminal)
- * @param onIdeDetected Callback to be called when an IDE is detected (including null)
- * @param onInstallationComplete Callback to be called when extension installation is complete
- */
-export async function initializeIdeIntegration(
-  onIdeDetected: (ide: DetectedIDEInfo | null) => void,
-  ideToInstallExtension: IdeType | null,
-  onShowIdeOnboarding: () => void,
-  onInstallationComplete: (
-    status: IDEExtensionInstallationStatus | null,
-  ) => void,
-): Promise<void> {
-  // Don't await so we don't block startup, but return a promise that resolves with the status
-  void findAvailableIDE().then(onIdeDetected)
-
-  const shouldAutoInstall = getGlobalConfig().autoInstallIdeExtension ?? true
-  if (
-    !isEnvTruthy(process.env.CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL) &&
-    shouldAutoInstall
-  ) {
-    const ideType = ideToInstallExtension ?? getTerminalIdeType()
-    if (ideType) {
-      if (isVSCodeIde(ideType)) {
-        void isIDEExtensionInstalled(ideType).then(async isAlreadyInstalled => {
-          void maybeInstallIDEExtension(ideType)
-            .catch(error => {
-              const ideInstallationStatus: IDEExtensionInstallationStatus = {
-                installed: false,
-                error: error.message || 'Installation failed',
-                installedVersion: null,
-                ideType: ideType,
-              }
-              return ideInstallationStatus
-            })
-            .then(status => {
-              onInstallationComplete(status)
-
-              if (status?.installed) {
-                // If we installed and don't yet have an IDE, search again.
-                void findAvailableIDE().then(onIdeDetected)
-              }
-
-              if (
-                !isAlreadyInstalled &&
-                status?.installed === true &&
-                !ideOnboardingDialog().hasIdeOnboardingDialogBeenShown()
-              ) {
-                onShowIdeOnboarding()
-              }
-            })
-        })
-      } else if (isJetBrainsIde(ideType)) {
-        // Always check installation to populate the sync cache used by status notices
-        void isIDEExtensionInstalled(ideType).then(async installed => {
-          if (
-            installed &&
-            !ideOnboardingDialog().hasIdeOnboardingDialogBeenShown()
-          ) {
-            onShowIdeOnboarding()
-          }
-        })
-      }
-    }
-  }
-}
-
-/**
- * Detects the host IP to use to connect to the extension.
- */
-const detectHostIP = memoize(
-  async (isIdeRunningInWindows: boolean, port: number) => {
-    if (process.env.CLAUDE_CODE_IDE_HOST_OVERRIDE) {
-      return process.env.CLAUDE_CODE_IDE_HOST_OVERRIDE
-    }
-
-    if (getPlatform() !== 'wsl' || !isIdeRunningInWindows) {
-      return '127.0.0.1'
-    }
-
-    // If we are running under the WSL2 VM but the extension/plugin is running in
-    // Windows, then we must use a different IP address to connect to the extension.
-    // https://learn.microsoft.com/en-us/windows/wsl/networking
-    try {
-      const routeResult = await execa('ip route show | grep -i default', {
-        shell: true,
-        reject: false,
-      })
-      if (routeResult.exitCode === 0 && routeResult.stdout) {
-        const gatewayMatch = routeResult.stdout.match(
-          /default via (\d+\.\d+\.\d+\.\d+)/,
-        )
-        if (gatewayMatch) {
-          const gatewayIP = gatewayMatch[1]!
-          if (await checkIdeConnection(gatewayIP, port)) {
-            return gatewayIP
-          }
-        }
-      }
-    } catch (_) {
-      // Suppress any errors
-    }
-
-    // Fallback to the default if we cannot find anything
-    return '127.0.0.1'
-  },
-  (isIdeRunningInWindows, port) => `${isIdeRunningInWindows}:${port}`,
-)
-
-async function installFromArtifactory(command: string): Promise<string> {
-  // Read auth token from ~/.npmrc
-  const npmrcPath = join(os.homedir(), '.npmrc')
-  let authToken: string | null = null
-  const fs = getFsImplementation()
-
-  try {
-    const npmrcContent = await fs.readFile(npmrcPath, {
-      encoding: 'utf8',
-    })
-    const lines = npmrcContent.split('\n')
-    for (const line of lines) {
-      // Look for the artifactory auth token line
-      const match = line.match(
-        /\/\/artifactory\.infra\.ant\.dev\/artifactory\/api\/npm\/npm-all\/:_authToken=(.+)/,
-      )
-      if (match && match[1]) {
-        authToken = match[1].trim()
-        break
-      }
-    }
-  } catch (error) {
-    logError(error as Error)
-    throw new Error(`Failed to read npm authentication: ${error}`)
-  }
-
-  if (!authToken) {
-    throw new Error('No artifactory auth token found in ~/.npmrc')
-  }
-
-  // Fetch the version from artifactory
-  const versionUrl =
-    'https://artifactory.infra.ant.dev/artifactory/armorcode-claude-code-internal/claude-vscode-releases/stable'
-
-  try {
-    const versionResponse = await axios.get(versionUrl, {
-      headers: {
-        Authorization: `Bearer ${authToken}`,
-      },
-    })
-
-    const version = versionResponse.data.trim()
-    if (!version) {
-      throw new Error('No version found in artifactory response')
-    }
-
-    // Download the .vsix file from artifactory
-    const vsixUrl = `https://artifactory.infra.ant.dev/artifactory/armorcode-claude-code-internal/claude-vscode-releases/${version}/claude-code.vsix`
-    const tempVsixPath = join(
-      os.tmpdir(),
-      `claude-code-${version}-${Date.now()}.vsix`,
-    )
-
-    try {
-      const vsixResponse = await axios.get(vsixUrl, {
-        headers: {
-          Authorization: `Bearer ${authToken}`,
-        },
-        responseType: 'stream',
-      })
-
-      // Write the downloaded file to disk
-      const writeStream = getFsImplementation().createWriteStream(tempVsixPath)
-      await new Promise<void>((resolve, reject) => {
-        vsixResponse.data.pipe(writeStream)
-        writeStream.on('finish', resolve)
-        writeStream.on('error', reject)
-      })
-
-      // Install the .vsix file
-      // Add delay to prevent code command crashes
-      await sleep(500)
-
-      const result = await execFileNoThrowWithCwd(
-        command,
-        ['--force', '--install-extension', tempVsixPath],
-        {
-          env: getInstallationEnv(),
-        },
-      )
-
-      if (result.code !== 0) {
-        throw new Error(`${result.code}: ${result.error} ${result.stderr}`)
-      }
-
-      return version
-    } finally {
-      // Clean up the temporary file
-      try {
-        await fs.unlink(tempVsixPath)
-      } catch {
-        // Ignore cleanup errors
-      }
-    }
-  } catch (error) {
-    if (axios.isAxiosError(error)) {
-      throw new Error(
-        `Failed to fetch extension version from artifactory: ${error.message}`,
-      )
-    }
-    throw error
-  }
-}