@sparkelf/dsh-patch-wsl-native-open 0.2.0-rc.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,36 @@
+{
+  "description": "Data-only exact official-source patch translating POSIX paths for the Windows interpreter on a WSL host",
+  "dshPatch": {
+    "formatVersion": 1,
+    "variants": [
+      {
+        "dsh": ">=0.1.6-alpha.1",
+        "file": "./patches/wsl-native-open.patch",
+        "id": "wsl-native-path-translation",
+        "target": {
+          "baseRevision": "0a15e36e7f82b6ed45af6fa9759f29b40dcd965d",
+          "kind": "dsh-source",
+          "paths": [
+            "packages/host/open-in-app/",
+            "packages/util/native-command/"
+          ]
+        }
+      }
+    ]
+  },
+  "files": [
+    "patches/*.patch"
+  ],
+  "license": "MIT",
+  "name": "@sparkelf/dsh-patch-wsl-native-open",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "directory": "patches/npm/wsl-native-open",
+    "type": "git",
+    "url": "git+https://github.com/SparkElf/deepseek-harness-plus.git"
+  },
+  "type": "module",
+  "version": "0.2.0-rc.5"
+}

package/patches/wsl-native-open.patch

@@ -0,0 +1,259 @@
+diff --git a/packages/host/open-in-app/src/icons.ts b/packages/host/open-in-app/src/icons.ts
+index 6908ce7..570dc45 100644
+--- a/packages/host/open-in-app/src/icons.ts
++++ b/packages/host/open-in-app/src/icons.ts
+@@ -97,6 +97,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,
+@@ -106,8 +141,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 {
+@@ -192,6 +231,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 7ab964b..8ea7318 100644
+--- a/packages/host/open-in-app/src/resolver.ts
++++ b/packages/host/open-in-app/src/resolver.ts
+@@ -14,10 +14,10 @@
+ 
+ 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, type NativeCommandRunner,
++  canOpenLinuxDesktop, canOpenNativePath, openNativePath, runNativeCommand, type NativeCommandRunner,
+ } from '@deepseek-ai/dsh-native-command'
+ import { scrubbedParentEnv } from '@deepseek-ai/dsh-subprocess'
+ import {
+@@ -98,6 +98,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 +117,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 +143,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,
+@@ -467,6 +471,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
+@@ -518,10 +530,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 a2e23a3..f1ea7c6 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 8f3443b..79e7ace 100644
+--- a/packages/util/native-command/src/path-opener.ts
++++ b/packages/util/native-command/src/path-opener.ts
+@@ -99,13 +99,49 @@ function isWsl(internals: PathOpenerInternals): boolean {
+   return (internals.osRelease ?? osRelease()).toLowerCase().includes('microsoft')
+ }
+ 
++/**
++ * 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_POWERSHELL_CANDIDATES = [
++  '/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe',
++  '/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe',
++] as const
++
+ /** Open one Windows-resolvable path through its registered desktop application. */
+ async function openWindowsPath(path: string, signal: AbortSignal, run: PathOpenerRunner): Promise<void> {
+-  await run('powershell.exe', [
++  const args = [
+     '-NoProfile',
+     '-Command',
+     `Invoke-Item -LiteralPath ${powershellLiteral(path)}`,
+-  ], signal)
++  ]
++  try {
++    await run('powershell.exe', args, signal)
++    return
++  } catch (error) {
++    // A missing executable is the one failure a mounted path can answer; a non-zero
++    // exit from PowerShell itself is a real launch failure and must stay reported.
++    if (!isMissingExecutable(error)) throw error
++  }
++  for (const candidate of WINDOWS_POWERSHELL_CANDIDATES) {
++    try {
++      await run(candidate, args, signal)
++      return
++    } catch (error) {
++      if (!isMissingExecutable(error)) throw error
++    }
++  }
++  throw new Error('Windows PowerShell 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. */
+@@ -154,6 +190,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.
+  *