feat(paths): add fromUnixPath to convert MSYS paths to native Windows format

Author: jdalton

src/paths/normalize.ts

@@ -358,6 +358,62 @@ export function isRelative(pathLike: string | Buffer | URL): boolean {
   return !isAbsolute(filepath)
 }
 
+/**
+ * Convert Unix-style POSIX paths (MSYS/Git Bash format) back to native Windows paths.
+ *
+ * This is the inverse of {@link toUnixPath}. MSYS-style paths use `/c/` notation
+ * for drive letters, which PowerShell and cmd.exe cannot resolve. This function
+ * converts them back to native Windows format.
+ *
+ * Conversion rules:
+ * - On Windows: Converts Unix drive notation to Windows drive letters
+ *   - `/c/path/to/file` becomes `C:/path/to/file`
+ *   - `/d/projects/app` becomes `D:/projects/app`
+ *   - Drive letters are always uppercase in the output
+ * - On Unix: Returns the path unchanged (passes through normalization)
+ *
+ * This is particularly important for:
+ * - GitHub Actions runners where `command -v` returns MSYS paths
+ * - Tools like sfw that need to resolve real binary paths on Windows
+ * - Scripts that receive paths from Git Bash but need to pass them to native Windows tools
+ *
+ * @param {string | Buffer | URL} pathLike - The MSYS/Unix-style path to convert
+ * @returns {string} Native Windows path (e.g., `C:/path/to/file`) or normalized Unix path
+ *
+ * @example
+ * ```typescript
+ * // MSYS drive letter paths
+ * fromUnixPath('/c/projects/app/file.txt')    // 'C:/projects/app/file.txt'
+ * fromUnixPath('/d/projects/foo/bar')         // 'D:/projects/foo/bar'
+ *
+ * // Non-drive Unix paths (unchanged)
+ * fromUnixPath('/tmp/build/output')           // '/tmp/build/output'
+ * fromUnixPath('/usr/local/bin')              // '/usr/local/bin'
+ *
+ * // Already Windows paths (unchanged)
+ * fromUnixPath('C:/Windows/System32')         // 'C:/Windows/System32'
+ *
+ * // Edge cases
+ * fromUnixPath('/c')                          // 'C:/'
+ * fromUnixPath('')                            // '.'
+ * ```
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export function fromUnixPath(pathLike: string | Buffer | URL): string {
+  const normalized = normalizePath(pathLike)
+
+  // On Windows, convert MSYS drive notation back to native: /c/path → C:/path
+  if (WIN32) {
+    return normalized.replace(
+      /^\/([a-zA-Z])(\/|$)/,
+      (_, letter, sep) => `${letter.toUpperCase()}:${sep || '/'}`,
+    )
+  }
+
+  // On Unix, just return the normalized path
+  return normalized
+}
+
 /**
  * Normalize a path by converting backslashes to forward slashes and collapsing segments.
  *
@@ -1114,21 +1170,23 @@ export function relativeResolve(from: string, to: string): string {
 }
 
 /**
- * Convert Windows paths to Unix-style POSIX paths for Git Bash tools.
+ * Convert Windows paths to MSYS/Unix-style POSIX paths for Git Bash tools.
  *
- * Git for Windows tools (like tar, git, etc.) expect POSIX-style paths with
- * forward slashes and Unix drive letter notation (/c/ instead of C:\).
+ * Git for Windows and MSYS2 tools (like tar, git, etc.) expect POSIX-style
+ * paths with forward slashes and Unix drive letter notation (/c/ instead of C:\).
  * This function handles the conversion for cross-platform compatibility.
  *
+ * This is the inverse of {@link fromUnixPath}.
+ *
  * Conversion rules:
  * - On Windows: Normalizes separators and converts drive letters
  *   - `C:\path\to\file` becomes `/c/path/to/file`
- *   - `D:/Users/name` becomes `/d/Users/name`
+ *   - `D:/projects/app` becomes `/d/projects/app`
  *   - Drive letters are always lowercase in the output
  * - On Unix: Returns the path unchanged (passes through normalization)
  *
  * This is particularly important for:
- * - Git Bash tools that interpret `D:\` as a remote hostname
+ * - MSYS2/Git Bash tools that interpret `D:\` as a remote hostname
  * - Cross-platform build scripts using tar, git archive, etc.
  * - CI/CD environments where Git for Windows is used
  *

test/unit/paths/normalize.test.mts

@@ -12,12 +12,14 @@
  * - pathLikeToString() converts Buffer/URL to string
  * - relativeResolve() resolves relative paths
  * - toUnixPath() converts Windows paths to Unix-style POSIX paths for Git Bash tools
+ * - fromUnixPath() converts MSYS/Unix-style paths back to native Windows paths
  * Used throughout Socket tools for cross-platform path handling.
  */
 
 import process from 'node:process'
 import { describe, expect, it } from 'vitest'
 import {
+  fromUnixPath,
   isAbsolute,
   isNodeModules,
   isPath,
@@ -83,6 +85,120 @@ describe('paths/normalize', () => {
     })
   })
 
+  describe('fromUnixPath', () => {
+    const isWindows = process.platform === 'win32'
+
+    it('should convert MSYS drive letter paths to Windows format', () => {
+      if (isWindows) {
+        expect(fromUnixPath('/c/Users/name/file.txt')).toBe(
+          'C:/Users/name/file.txt',
+        )
+        expect(fromUnixPath('/d/projects/foo/bar')).toBe('D:/projects/foo/bar')
+      }
+    })
+
+    it('should convert lowercase drive letters to uppercase', () => {
+      if (isWindows) {
+        expect(fromUnixPath('/c/path')).toBe('C:/path')
+        expect(fromUnixPath('/d/path')).toBe('D:/path')
+        expect(fromUnixPath('/z/path')).toBe('Z:/path')
+      }
+    })
+
+    it('should handle all drive letters a-z', () => {
+      if (isWindows) {
+        expect(fromUnixPath('/a/path')).toBe('A:/path')
+        expect(fromUnixPath('/e/path')).toBe('E:/path')
+        expect(fromUnixPath('/z/path')).toBe('Z:/path')
+      }
+    })
+
+    it('should handle bare drive letter path', () => {
+      if (isWindows) {
+        expect(fromUnixPath('/c')).toBe('C:/')
+      }
+    })
+
+    it('should not convert non-drive Unix paths', () => {
+      if (isWindows) {
+        // Paths that don't match the /x/ MSYS drive pattern
+        expect(fromUnixPath('/home/user/file')).toBe('/home/user/file')
+        expect(fromUnixPath('/usr/local/bin')).toBe('/usr/local/bin')
+      }
+    })
+
+    it('should leave Unix paths unchanged on Unix', () => {
+      if (!isWindows) {
+        expect(fromUnixPath('/home/user/file')).toBe('/home/user/file')
+        expect(fromUnixPath('/usr/local/bin')).toBe('/usr/local/bin')
+        expect(fromUnixPath('/c/Users/name')).toBe('/c/Users/name')
+      }
+    })
+
+    it('should normalize paths on Unix', () => {
+      if (!isWindows) {
+        expect(fromUnixPath('/usr/local/../bin')).toBe('/usr/bin')
+        expect(fromUnixPath('/usr//local///bin')).toBe('/usr/local/bin')
+      }
+    })
+
+    it('should handle relative paths', () => {
+      const result1 = fromUnixPath('./src/index.ts')
+      const result2 = fromUnixPath('../lib/utils')
+      expect(result1).toContain('src')
+      expect(result2).toContain('lib')
+    })
+
+    it('should handle empty string', () => {
+      expect(fromUnixPath('')).toBe('.')
+    })
+
+    it('should handle paths with spaces', () => {
+      if (isWindows) {
+        expect(fromUnixPath('/c/Program Files/App')).toBe(
+          'C:/Program Files/App',
+        )
+      }
+    })
+
+    it('should handle paths with special characters', () => {
+      if (isWindows) {
+        expect(fromUnixPath('/c/Users/name/file (1).txt')).toBe(
+          'C:/Users/name/file (1).txt',
+        )
+        expect(fromUnixPath('/d/projects/@scope/package')).toBe(
+          'D:/projects/@scope/package',
+        )
+      }
+    })
+
+    it('should handle Buffer input', () => {
+      if (isWindows) {
+        const buffer = Buffer.from('/c/Users/name')
+        expect(fromUnixPath(buffer)).toBe('C:/Users/name')
+      } else {
+        const buffer = Buffer.from('/usr/local')
+        expect(fromUnixPath(buffer)).toBe('/usr/local')
+      }
+    })
+
+    it('should be the inverse of toUnixPath on Windows', () => {
+      if (isWindows) {
+        // Round-trip: Windows → Unix → Windows
+        const original = 'C:/Users/name/file.txt'
+        const unix = toUnixPath(original)
+        const backToWindows = fromUnixPath(unix)
+        expect(backToWindows).toBe(original)
+      }
+    })
+
+    it('should handle root path', () => {
+      if (!isWindows) {
+        expect(fromUnixPath('/')).toBe('/')
+      }
+    })
+  })
+
   describe('isAbsolute', () => {
     it('should detect Unix absolute paths', () => {
       expect(isAbsolute('/usr/local')).toBe(true)