Something went wrong. Try again.
source dump of claude code forked from oppi.li/claude-code
Something went wrong. Try again.
47 kB · 1494 lines
TypeScript
at main
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495import 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 resultslet 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 }}