mixdog 0.7.14 → 0.7.16

package/src/shared/open-url.mjs

@@ -1,4 +1,5 @@
 import { spawn } from 'child_process';
+import { isWSL } from './wsl.mjs';
 
 /**
  * Open a URL in the user's default browser. Best-effort and non-blocking —
@@ -11,27 +12,51 @@ import { spawn } from 'child_process';
  *    treats the first quoted string as the WINDOW TITLE, so the URL is dropped
  *    and nothing opens.
  *  - macOS: `open <url>`.
+ *  - WSL: xdg-open usually fails (no Linux GUI), so reach the Windows-HOST
+ *    browser — prefer `wslview` (wslu), else `powershell.exe Start-Process`.
+ *    cmd.exe `start` is deliberately NOT used: cmd re-parses URL metacharacters
+ *    so a query-string `&` (e.g. `?a=1&b=2`) is treated as a command separator
+ *    and the URL truncates. PowerShell's Start-Process takes the URL as one
+ *    argument and does not reparse `&`; the URL is passed inside a single-quoted
+ *    PowerShell literal (single quotes doubled) so `&`, spaces and quotes
+ *    survive and no injection is possible. Falls back through the chain when an
+ *    opener is missing.
  *  - Linux/other: `xdg-open <url>`.
  */
 export function openInBrowser(url) {
   const u = String(url);
-  let cmd;
-  let args;
+  // Ordered [cmd, args] candidates. Every platform but WSL has exactly one;
+  // WSL has a fallback chain since the first opener may be absent.
+  let candidates;
   if (process.platform === 'win32') {
-    cmd = 'rundll32';
-    args = ['url.dll,FileProtocolHandler', u];
+    candidates = [['rundll32', ['url.dll,FileProtocolHandler', u]]];
   } else if (process.platform === 'darwin') {
-    cmd = 'open';
-    args = [u];
+    candidates = [['open', [u]]];
+  } else if (isWSL()) {
+    // Single-quoted PowerShell literal: double any embedded single quote.
+    // Everything else (incl. `&`) is literal inside a single-quoted string.
+    const psUrl = `'${u.replace(/'/g, "''")}'`;
+    candidates = [
+      ['wslview', [u]],
+      ['powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', `Start-Process -FilePath ${psUrl}`]],
+    ];
   } else {
-    cmd = 'xdg-open';
-    args = [u];
+    candidates = [['xdg-open', [u]]];
   }
+  tryOpenCandidates(candidates, 0);
+}
+
+// Spawn candidates[index]; on spawn error (opener missing) advance to the next.
+// Always non-blocking — the caller prints the URL, so exhausting the chain is
+// never fatal.
+function tryOpenCandidates(candidates, index) {
+  if (index >= candidates.length) return;
+  const [cmd, args] = candidates[index];
   try {
     const child = spawn(cmd, args, { stdio: 'ignore', detached: true, windowsHide: true });
-    child.on('error', () => { /* opener missing — user uses the printed URL */ });
+    child.on('error', () => { tryOpenCandidates(candidates, index + 1); });
     child.unref();
   } catch {
-    /* spawn threw synchronously — user opens the printed URL manually */
+    tryOpenCandidates(candidates, index + 1);
   }
 }

package/src/shared/user-cwd.mjs

@@ -54,8 +54,20 @@ export function _safeProcessCwd() {
 function _normalizePlatformCwd(p) {
   if (!p || typeof p !== 'string') return p
   if (process.platform !== 'win32') return resolve(p)
-  const m = p.match(/^[\/\\]([a-zA-Z])[\/\\](.*)$/)
-  const native = m ? `${m[1].toUpperCase()}:\\${m[2].replace(/\//g, '\\')}` : p
+  // Map all three POSIX drive-prefix shapes to native Windows paths before
+  // resolution, aligned with path-utils.mjs posixPathToWindowsPath:
+  //   /cygdrive/c/... (Cygwin), /mnt/c/... (WSL), /c/... (MSYS/Git-Bash) → C:\...
+  // Cygwin/WSL prefixes must be tested before the bare single-letter form
+  // because their slice offsets differ.
+  const cyg = p.match(/^\/cygdrive\/([a-zA-Z])\//)
+  const wsl = p.match(/^\/mnt\/([a-zA-Z])\//)
+  let native = p
+  if (cyg) native = `${cyg[1].toUpperCase()}:\\${p.slice(11).replace(/\//g, '\\')}`
+  else if (wsl) native = `${wsl[1].toUpperCase()}:\\${p.slice(7).replace(/\//g, '\\')}`
+  else {
+    const m = p.match(/^[\/\\]([a-zA-Z])[\/\\](.*)$/)
+    if (m) native = `${m[1].toUpperCase()}:\\${m[2].replace(/\//g, '\\')}`
+  }
   return resolve(native)
 }
 

package/src/shared/wsl.mjs

@@ -0,0 +1,35 @@
+// WSL (Windows Subsystem for Linux) detection.
+//
+// process.platform reports 'linux' inside WSL, so any caller that needs
+// Windows-HOST behavior — opening the Windows default browser, reaching the
+// Windows credential store, translating Windows drive paths — must branch on
+// this explicitly rather than on process.platform alone. Plain-Linux behavior
+// stays the default; this only flags the WSL special case.
+//
+// Detection order (cheapest / most reliable first):
+//   1. WSL_DISTRO_NAME / WSL_INTEROP env vars (set by the WSL init for every
+//      interactive and most non-interactive sessions).
+//   2. /proc/version containing "microsoft"/"wsl" (the kernel is a Microsoft
+//      build under WSL1/WSL2). Read once and memoized.
+import { readFileSync } from 'node:fs';
+
+let _isWSL;
+
+export function isWSL() {
+  if (_isWSL !== undefined) return _isWSL;
+  if (process.platform !== 'linux') {
+    _isWSL = false;
+    return _isWSL;
+  }
+  if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) {
+    _isWSL = true;
+    return _isWSL;
+  }
+  try {
+    const v = readFileSync('/proc/version', 'utf8').toLowerCase();
+    _isWSL = v.includes('microsoft') || v.includes('wsl');
+  } catch {
+    _isWSL = false;
+  }
+  return _isWSL;
+}