init

utils/platform.ts

@@ -0,0 +1,150 @@
+import { readdir, readFile } from 'fs/promises'
+import memoize from 'lodash-es/memoize.js'
+import { release as osRelease } from 'os'
+import { getFsImplementation } from './fsOperations.js'
+import { logError } from './log.js'
+
+export type Platform = 'macos' | 'windows' | 'wsl' | 'linux' | 'unknown'
+
+export const SUPPORTED_PLATFORMS: Platform[] = ['macos', 'wsl']
+
+export const getPlatform = memoize((): Platform => {
+  try {
+    if (process.platform === 'darwin') {
+      return 'macos'
+    }
+
+    if (process.platform === 'win32') {
+      return 'windows'
+    }
+
+    if (process.platform === 'linux') {
+      // Check if running in WSL (Windows Subsystem for Linux)
+      try {
+        const procVersion = getFsImplementation().readFileSync(
+          '/proc/version',
+          { encoding: 'utf8' },
+        )
+        if (
+          procVersion.toLowerCase().includes('microsoft') ||
+          procVersion.toLowerCase().includes('wsl')
+        ) {
+          return 'wsl'
+        }
+      } catch (error) {
+        // Error reading /proc/version, assume regular Linux
+        logError(error)
+      }
+
+      // Regular Linux
+      return 'linux'
+    }
+
+    // Unknown platform
+    return 'unknown'
+  } catch (error) {
+    logError(error)
+    return 'unknown'
+  }
+})
+
+export const getWslVersion = memoize((): string | undefined => {
+  // Only check for WSL on Linux systems
+  if (process.platform !== 'linux') {
+    return undefined
+  }
+  try {
+    const procVersion = getFsImplementation().readFileSync('/proc/version', {
+      encoding: 'utf8',
+    })
+
+    // First check for explicit WSL version markers (e.g., "WSL2", "WSL3", etc.)
+    const wslVersionMatch = procVersion.match(/WSL(\d+)/i)
+    if (wslVersionMatch && wslVersionMatch[1]) {
+      return wslVersionMatch[1]
+    }
+
+    // If no explicit WSL version but contains Microsoft, assume WSL1
+    // This handles the original WSL1 format: "4.4.0-19041-Microsoft"
+    if (procVersion.toLowerCase().includes('microsoft')) {
+      return '1'
+    }
+
+    // Not WSL or unable to determine version
+    return undefined
+  } catch (error) {
+    logError(error)
+    return undefined
+  }
+})
+
+export type LinuxDistroInfo = {
+  linuxDistroId?: string
+  linuxDistroVersion?: string
+  linuxKernel?: string
+}
+
+export const getLinuxDistroInfo = memoize(
+  async (): Promise<LinuxDistroInfo | undefined> => {
+    if (process.platform !== 'linux') {
+      return undefined
+    }
+
+    const result: LinuxDistroInfo = {
+      linuxKernel: osRelease(),
+    }
+
+    try {
+      const content = await readFile('/etc/os-release', 'utf8')
+      for (const line of content.split('\n')) {
+        const match = line.match(/^(ID|VERSION_ID)=(.*)$/)
+        if (match && match[1] && match[2]) {
+          const value = match[2].replace(/^"|"$/g, '')
+          if (match[1] === 'ID') {
+            result.linuxDistroId = value
+          } else {
+            result.linuxDistroVersion = value
+          }
+        }
+      }
+    } catch {
+      // /etc/os-release may not exist on all Linux systems
+    }
+
+    return result
+  },
+)
+
+const VCS_MARKERS: Array<[string, string]> = [
+  ['.git', 'git'],
+  ['.hg', 'mercurial'],
+  ['.svn', 'svn'],
+  ['.p4config', 'perforce'],
+  ['$tf', 'tfs'],
+  ['.tfvc', 'tfs'],
+  ['.jj', 'jujutsu'],
+  ['.sl', 'sapling'],
+]
+
+export async function detectVcs(dir?: string): Promise<string[]> {
+  const detected = new Set<string>()
+
+  // Check for Perforce via env var
+  if (process.env.P4PORT) {
+    detected.add('perforce')
+  }
+
+  try {
+    const targetDir = dir ?? getFsImplementation().cwd()
+    const entries = new Set(await readdir(targetDir))
+    for (const [marker, vcs] of VCS_MARKERS) {
+      if (entries.has(marker)) {
+        detected.add(vcs)
+      }
+    }
+  } catch {
+    // Directory may not be readable
+  }
+
+  return [...detected]
+}