@sparkelf/dsh-plus 0.2.1-rc.2.4 → 0.2.2-alpha.2.10

package/patches/wsl-native-open.patch

@@ -0,0 +1,265 @@
+diff --git a/packages/host/open-in-app/src/icons.ts b/packages/host/open-in-app/src/icons.ts
+index 4b07441c8c..519ba1344b 100644
+--- a/packages/host/open-in-app/src/icons.ts
++++ b/packages/host/open-in-app/src/icons.ts
+@@ -98,6 +98,41 @@ const EXTRACT_ICON_PS1 = [
+   '',
+ ].join('\n')
+ 
++/**
++ * Translate POSIX paths for the Windows interpreter when this host is WSL.
++ *
++ * `Convert-Path` and `System.Drawing` reject a Linux path: the extension host maps
++ * `/mnt/c/...` itself, but PowerShell running as a Windows process resolves
++ * `\\wsl.localhost\...` and refuses to treat it as a file. `wslpath -w` produces the
++ * form it accepts. A non-WSL host returns its paths unchanged.
++ *
++ * @param paths - absolute POSIX paths to hand to the interpreter.
++ * @param timeoutMs - per-command deadline for the translation.
++ * @param internals - platform and runner hooks for deterministic tests.
++ * @returns the translated paths, or null when a translation failed.
++ */
++async function windowsPaths(
++  paths: readonly string[], timeoutMs: number, internals: ResolvedInternals,
++): Promise<string[] | null> {
++  if (!isWslHost(internals)) return [...paths]
++  const translated: string[] = []
++  for (const path of paths) {
++    const windows = await output('wslpath', ['-w', path], timeoutMs, internals)
++    const trimmed = windows?.replace(/[\r\n]+$/u, '') ?? ''
++    if (trimmed === '') return null
++    translated.push(trimmed)
++  }
++  return translated
++}
++
++/** Whether this Host is a WSL distribution, whose Windows desktop takes the path. */
++function isWslHost(internals: ResolvedInternals): boolean {
++  if (internals.platform !== 'linux') return false
++  const env = internals.env
++  if ((env.WSL_DISTRO_NAME ?? '') !== '' || (env.WSL_INTEROP ?? '') !== '') return true
++  return internals.osRelease.toLowerCase().includes('microsoft')
++}
++
+ /** Extract one Windows executable's associated icon as a 32px PNG. */
+ async function extractExecutableIconPng(
+   executablePath: string, timeoutMs: number, internals: ResolvedInternals,
+@@ -107,8 +142,12 @@ async function extractExecutableIconPng(
+     const script = join(workDir, 'extract-icon.ps1')
+     const outPng = join(workDir, 'icon.png')
+     await writeFile(script, EXTRACT_ICON_PS1, 'utf8')
++    // Windows PowerShell reads Windows paths, so a WSL host translates all three before
++    // handing them over; the unmounted caller passes them through unchanged.
++    const args = await windowsPaths([script, executablePath, outPng], timeoutMs, internals)
++    if (args === null) return null
+     const ran = await output('powershell.exe', [
+-      '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', script, executablePath, outPng,
++      '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', ...args,
+     ], timeoutMs, internals)
+     if (ran === null) return null
+     try {
+@@ -148,6 +187,13 @@ export async function extractAppIcon(
+ ): Promise<OpenInAppIcon | null> {
+   const completed = resolveInternals(internals)
+   if (completed.platform === 'linux') {
++    // A resolved executable icon takes precedence on Linux: WSL reaches the Windows
++    // shell open and its Explorer icon lives in the executable, while the desktop-entry
++    // lookup below has nothing to read on a host with no Linux desktop at all.
++    if (resolved.icon?.kind === 'executable') {
++      const bytes = await extractExecutableIconPng(resolved.icon.path, timeoutMs, completed)
++      return bytes === null ? null : { bytes, contentType: 'image/png' }
++    }
+     const desktopId = specFor(app, completed.platform)?.desktopId
+     return desktopId === undefined ? null : extractLinuxIcon(desktopId, completed)
+   }
+diff --git a/packages/host/open-in-app/src/resolver.ts b/packages/host/open-in-app/src/resolver.ts
+index 970118e22a..ad8d176da4 100644
+--- a/packages/host/open-in-app/src/resolver.ts
++++ b/packages/host/open-in-app/src/resolver.ts
+@@ -14,10 +14,11 @@
+ 
+ import { spawn } from 'node:child_process'
+ import { readdir, readFile, stat } from 'node:fs/promises'
+-import { homedir, platform as osPlatform } from 'node:os'
++import { homedir, release as osRelease, platform as osPlatform } from 'node:os'
+ import { dirname, isAbsolute, join } from 'node:path'
+ import {
+-  canOpenNativePath, openNativePath, runNativeCommand, desktopEntryFields, desktopDataDirectories, type NativeCommandRunner,
++  canOpenLinuxDesktop, canOpenNativePath, openNativePath, runNativeCommand,
++  desktopEntryFields, desktopDataDirectories, type NativeCommandRunner,
+ } from '@deepseek-ai/dsh-native-command'
+ import { scrubbedParentEnv } from '@deepseek-ai/dsh-subprocess'
+ import {
+@@ -98,6 +99,8 @@ export const launchDetachedApp: OpenInAppLauncher = (command, args, options) =>
+ /** Injectable platform facts for deterministic tests. */
+ export interface OpenInAppInternals {
+   platform?: NodeJS.Platform
++  /** Kernel release override; distinguishes WSL from desktop Linux without a probe. */
++  osRelease?: string
+   /** SSH launch fact from the inherited process layer, independent of `.env` values. */
+   ssh?: boolean
+   /** Bundle-directory roots replacing `/Applications` and `~/Applications`. */
+@@ -115,6 +118,7 @@ export interface OpenInAppInternals {
+ /** Platform facts after the one explicit defaulting step at each public entry. */
+ export interface ResolvedInternals {
+   platform: NodeJS.Platform
++  osRelease: string
+   ssh: boolean
+   applicationRoots: readonly string[]
+   env: Readonly<Record<string, string | undefined>>
+@@ -140,6 +144,7 @@ export function resolveInternals(internals: OpenInAppInternals): ResolvedInterna
+   }
+   return {
+     platform: internals.platform ?? osPlatform(),
++    osRelease: internals.osRelease ?? osRelease(),
+     ssh: internals.ssh ?? false,
+     applicationRoots: internals.applicationRoots ?? ['/Applications', join(home, 'Applications')],
+     env: internals.env ?? process.env,
+@@ -453,6 +458,14 @@ export function specFor(app: OpenInAppApp, platform: NodeJS.Platform): OpenInApp
+     : undefined
+ }
+ 
++/**
++ * Explorer icon for the Windows shell open a WSL host resolves to.
++ *
++ * \`SystemRoot\` is unset inside WSL, so the mounted drive is named directly; the
++ * command-line \`openWindowsPath\` reaches the same interpreter through the same mount.
++ */
++const WINDOWS_EXPLORER_ICON = '/mnt/c/Windows/explorer.exe'
++
+ /** Icon source for a resolved executable: Windows extracts from the binary itself. */
+ function executableIcon(path: string, internals: ResolvedInternals): OpenInAppIconSource | undefined {
+   return internals.platform === 'win32' ? { kind: 'executable', path } : undefined
+@@ -504,10 +517,29 @@ async function locate(
+       }
+     }
+     case 'cli': {
+-      if (locator.requiresDesktop === true && !canOpenNativePath({
+-        platform: internals.platform,
+-        env: { ...internals.env },
+-      })) return null
++      // A desktop CLI locator names a program that draws on the host's own Linux
++      // desktop. WSL has no such program, but it does have the Windows desktop, so
++      // the entry stays and resolves to the Windows shell open instead of a launcher
++      // this host cannot run.
++      if (locator.requiresDesktop === true) {
++        const facts = {
++          platform: internals.platform,
++          osRelease: internals.osRelease,
++          env: { ...internals.env },
++        }
++        const linuxDesktop = canOpenLinuxDesktop(facts)
++        // WSL answers no here yet can still open a path, because the Windows desktop
++        // takes it. That combination is what selects the shell open below; a headless
++        // Linux host answers no to both and keeps dropping the entry.
++        if (!linuxDesktop && canOpenNativePath(facts)) {
++          const iconPath = expandCandidate(WINDOWS_EXPLORER_ICON, internals)
++          return {
++            launch: { kind: 'shell-open' },
++            icon: iconPath === null ? undefined : { kind: 'executable', path: iconPath },
++          }
++        }
++        if (!linuxDesktop) return null
++      }
+       const found = await internals.resolveExecutable(locator.name)
+       return found === null
+         ? null
+diff --git a/packages/util/native-command/src/index.ts b/packages/util/native-command/src/index.ts
+index 9ad8e0883c..3377ddcb6f 100644
+--- a/packages/util/native-command/src/index.ts
++++ b/packages/util/native-command/src/index.ts
+@@ -6,6 +6,7 @@
+ export { runNativeCommand } from './runner.ts'
+ export type { NativeCommandRunner } from './runner.ts'
+ export {
++  canOpenLinuxDesktop,
+   canOpenNativePath,
+   nativeFileManager,
+   revealNativePath,
+diff --git a/packages/util/native-command/src/path-opener.ts b/packages/util/native-command/src/path-opener.ts
+index 67bbc35902..dd062cc003 100644
+--- a/packages/util/native-command/src/path-opener.ts
++++ b/packages/util/native-command/src/path-opener.ts
+@@ -150,8 +150,55 @@ async function runExplorer(args: readonly string[], signal: AbortSignal, run: Pa
+  * @param signal - caller lifetime; abort terminates the command.
+  * @param run - shell-free command runner.
+  */
++/**
++ * Windows PowerShell locations to try when PATH carries no Windows entry.
++ *
++ * WSL injects its Windows directories into PATH only for the processes it starts
++ * interactively, so a service, a scheduled job, or any process started after that
++ * injection was lost resolves nothing by name. The interpreter is still present on
++ * the volume the distribution mounts, and naming it there is what keeps the Windows
++ * desktop reachable from those processes.
++ */
++const WINDOWS_EXPLORER_CANDIDATES = [
++  '/mnt/c/Windows/explorer.exe',
++  '/c/Windows/explorer.exe',
++] as const
++
++/**
++ * Open one Windows-resolvable path through its registered desktop application.
++ *
++ * Explorer resolves the association, but a process whose PATH lost its Windows entries
++ * cannot name the shell. WSL injects those entries only for the processes it starts
++ * interactively, so a service or scheduled job resolves nothing by name; naming the
++ * shell on the volume the distribution mounts keeps the Windows desktop reachable.
++ * @param path - Windows-resolvable path.
++ * @param signal - caller lifetime; abort terminates the command.
++ * @param run - shell-free command runner.
++ */
+ async function openWindowsPath(path: string, signal: AbortSignal, run: PathOpenerRunner): Promise<void> {
+-  await runExplorer([explorerTarget(path)], signal, run)
++  const target = explorerTarget(path)
++  try {
++    await runExplorer([target], signal, run)
++    return
++  } catch (error) {
++    // A missing executable is the one failure a mounted path can answer; any other
++    // failure is Explorer's own and must stay reported.
++    if (!isMissingExecutable(error)) throw error
++  }
++  for (const candidate of WINDOWS_EXPLORER_CANDIDATES) {
++    try {
++      await run(candidate, [target], signal, 'visible')
++      return
++    } catch (error) {
++      if (!isMissingExecutable(error)) throw error
++    }
++  }
++  throw new Error('Windows Explorer is not reachable from this WSL mount')
++}
++
++/** Whether a spawn failed because the executable could not be found at all. */
++function isMissingExecutable(error: unknown): boolean {
++  return (error as { code?: unknown } | null | undefined)?.code === 'ENOENT'
+ }
+ 
+ /** Translate a WSL path before handing it to the Windows desktop. */
+@@ -200,6 +247,25 @@ async function openNativePathWithIntent(
+   throw new Error(`native path opener is unsupported on ${platform}`)
+ }
+ 
++/**
++ * Whether this host can reach a Linux desktop application.
++ *
++ * WSL hands every path to the Windows desktop, so a Linux GUI program such as
++ * `xdg-open` is not what opens anything there: a surface asking this question
++ * wants to know whether a Linux display is attached, and WSL is not one even
++ * though it can open a path.
++ *
++ * @param internals - platform and environment seam for deterministic tests.
++ * @returns true when a Linux desktop application can receive the path.
++ */
++export function canOpenLinuxDesktop(internals: PathOpenerInternals = {}): boolean {
++  const platform = internals.platform ?? process.platform
++  if (platform !== 'linux') return false
++  if (isWsl(internals)) return false
++  const env = internals.env ?? process.env
++  return present(env.DISPLAY) || present(env.WAYLAND_DISPLAY)
++}
++
+ /**
+  * Whether {@link openNativePath} plausibly reaches a desktop on this host.
+  *