dsh-wsl-workspace 0.7.2 → 0.7.4

package/src/index.ts

@@ -1,15 +1,18 @@
 /**
  * Host half of dsh-wsl-workspace. Three responsibilities:
  *
- * 1. Materialize a `wsl-<mode>` variant for every healthy roster preset
- *    under `<dshHome>/.agent-presets/` (the roster's auto-scanned user
- *    root), so the WSL execution world — `shell-wsl` + `fs-wsl` behind one
- *    entry-local realm, with `tool-bash`/`tool-fs` consumers — composes with
- *    ANY mode instead of being a mode itself; the legacy standalone `wsl`
- *    preset directory and stale variants are removed on boot. The preset
- *    rows name THIS package's built lib files by absolute path, which the
- *    preset mount resolves to `file:` URLs without relying on bare specifier
- *    resolution from the preset's home directory.
+ * 1. Publish a `wsl-<mode>` variant for every healthy roster preset, so the
+ *    WSL execution world — `shell-wsl` + `fs-wsl` behind one entry-local
+ *    realm, with `tool-bash`/`tool-fs` consumers — composes with ANY mode
+ *    instead of being a mode itself. The channel follows the release:
+ *    `0.1.7-alpha.1+` stopped scanning any user preset root and builds its roster
+ *    from declarative `@deepseek-ai/dsh-agent-preset` rows, so there a variant
+ *    is a *declaration registered through `ctx.agentPresets`* — and only that
+ *    path rewrites the absolute provider specifiers below into `file:` URLs,
+ *    because a registered preset's entry tree does not translate them the way
+ *    the boot-time Include does; earlier releases still get a variant directory
+ *    under `<dshHome>/.agent-presets/`, whose legacy standalone `wsl` directory
+ *    and stale variants are removed on boot.
  *
  * 2. Serve the browser dialog's data route (`/wsl-workspace/api`):
  *    distribution discovery, one-level directory listing, path checks, and
@@ -26,8 +29,8 @@
 import { Context } from '@deepseek-ai/cordis'
 import z from '@deepseek-ai/schemastery'
 import { cpSync, existsSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { dirname, join } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { dirname, isAbsolute, join } from 'node:path'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { homedir } from 'node:os'
 import { joinUnc, mntToWindowsPath, normalizeLinuxPath, isAbsoluteLinuxPath, isValidWslUsername, parseWslUnc } from './shared/paths.ts'
@@ -47,10 +50,18 @@ export const DEFAULT_ROUTE = '/wsl-workspace/api'
  * preset.yml text verbatim, so the plugin writes one bilingual string so
  * both locales can identify each variant. Custom presets keep their own
  * name.
+ *
+ * This table is consulted before anything the release publishes, so every id
+ * the mode has ever carried needs an entry. `code` was the id up to
+ * `0.1.0-rc.8` and `ptc` is the id from `0.1.1` on; without the `ptc` entry the
+ * lookup returned undefined and the variant fell through to the release's own
+ * display name — which `0.1.7` does not publish at all, leaving the mode named
+ * `WSL · ptc` with the generic description `WSL execution world for ptc: …`.
  */
 const MODE_DISPLAY_LABELS: Readonly<Record<string, { en: string; zh: string }>> = {
   standard: { en: 'Standard mode', zh: '标准模式' },
   code: { en: 'Code mode', zh: 'PTC 模式' },
+  ptc: { en: 'PTC mode', zh: 'PTC 模式' },
   minimal: { en: 'Minimal mode', zh: '极简模式' },
   cordis: { en: 'Creator mode', zh: '创造模式' },
 }
@@ -352,10 +363,149 @@ async function dispatch(method: string, params: Record<string, unknown>): Promis
   }
 }
 
-/** The `ctx.agentPresets` roster face this plugin consumes (optional service). */
+/** One roster entry as the `ctx.agentPresets` face reports it. */
+interface AgentPresetRosterEntry {
+  id: string
+  name?: string
+  description?: string
+  /** Roster position; `list()` sorts by it. */
+  order?: number
+  broken?: string
+  /** Legacy (≤ 0.1.6-alpha.2) only: the source preset's directory. */
+  path?: string
+}
+
+/** One preset's declared composition, as the declaration channel reports it. */
+interface AgentPresetDocument {
+  agentPreset: string
+  /** The declared child plugin list as entry-list YAML, `!!js` expressions included. */
+  content: string
+  name?: string
+  description?: string
+}
+
+/** A declaration this plugin publishes; mirrors the Host's `PresetDefinition`. */
+interface PresetDeclaration {
+  id: string
+  name?: string
+  description?: string
+  order?: number
+  plugins: readonly unknown[]
+}
+
+/**
+ * The `ctx.agentPresets` roster face this plugin consumes (optional service).
+ *
+ * Two generations sit behind this one shape, so both are probed by capability
+ * rather than by version:
+ *
+ *  - `0.1.0-rc.7 … 0.1.6-alpha.2`: `list()` reports each preset's directory in
+ *    `path`, and `read(id)` returns the composition text. A variant is a
+ *    *directory* under the roster's scanned user root (`$DSH_HOME/.agent-presets/`).
+ *  - `0.1.7-alpha.1+`: `read()` is renamed `readDocument()` and returns a document
+ *    instead of a bare string, `AgentPreset.path` is gone, and **nothing scans
+ *    the user root any more** — the roster is built from declarative
+ *    `@deepseek-ai/dsh-agent-preset` rows carried by bundle patches. A variant
+ *    is therefore a declaration row published through `register()`.
+ */
 interface AgentPresetsService {
-  list(): Promise<{ id: string; broken?: string; path: string }[]>
-  read(id: string): Promise<string>
+  list(): Promise<AgentPresetRosterEntry[]>
+  /** Legacy (≤ 0.1.6-alpha.2): the source composition text. */
+  read?(id: string): Promise<string>
+  /** 0.1.7-alpha.1+: the declared composition beside its published metadata. */
+  readDocument?(id: string): Promise<AgentPresetDocument>
+  /** 0.1.7-alpha.1+: publish a declaration; the returned disposer retires it. */
+  register?(definition: PresetDeclaration): Promise<() => Promise<void>>
+}
+
+/**
+ * Read one preset's declared composition across both roster generations.
+ * @param agentPresets - the roster face.
+ * @param preset - the roster entry to read.
+ * @returns the composition text, plus the display name when the face publishes it.
+ */
+async function readPresetComposition(
+  agentPresets: AgentPresetsService,
+  preset: AgentPresetRosterEntry,
+): Promise<{ content: string; name?: string }> {
+  if (typeof agentPresets.readDocument === 'function') {
+    const document = await agentPresets.readDocument(preset.id)
+    return document.name === undefined
+      ? { content: document.content }
+      : { content: document.content, name: document.name }
+  }
+  if (typeof agentPresets.read === 'function') return { content: await agentPresets.read(preset.id) }
+  throw new Error(
+    `agentPresets: this DSH release exposes neither readDocument() nor read() (preset "${preset.id}")`,
+  )
+}
+
+/**
+ * Parse one transformed composition back into declaration rows.
+ *
+ * The composition is the entry-list YAML dialect, whose `!!js` scalars are
+ * expression nodes the Loader evaluates when it activates the row.
+ * `@deepseek-ai/cordis-plugin-include` exports `entryListSchema` precisely so
+ * config tooling can round-trip that dialect, and it is the same schema the
+ * harness parses preset patches with. Parsing the text back is what lets the
+ * (text-level) WSL transform keep working unchanged now that a variant is a
+ * declaration row instead of a directory of YAML.
+ *
+ * Both modules are resolved at call time rather than at module load: they are
+ * Host-provided (`dsh` depends on `cordis-plugin-include`, which depends on
+ * `js-yaml`), and a release that ever drops them must fail this one variant
+ * rather than refuse to load the whole plugin.
+ * @param content - the variant composition text.
+ * @returns the declaration's plugin rows.
+ */
+async function parseVariantComposition(content: string): Promise<unknown[]> {
+  const includeSpecifier = '@deepseek-ai/cordis-plugin-include'
+  const yamlSpecifier = 'js-yaml'
+  const [include, yamlModule] = await Promise.all([
+    import(includeSpecifier) as Promise<{ entryListSchema: unknown }>,
+    import(yamlSpecifier) as Promise<{
+      load?(source: string, options: { schema: unknown }): unknown
+      default?: { load(source: string, options: { schema: unknown }): unknown }
+    }>,
+  ])
+  const load = yamlModule.load ?? yamlModule.default?.load
+  if (typeof load !== 'function') throw new Error('js-yaml: no load() export')
+  const rows = load(content, { schema: include.entryListSchema })
+  if (!Array.isArray(rows)) throw new Error('the transformed composition did not parse as an entry list')
+  return toImportableSpecifiers(rows)
+}
+
+/**
+ * Rewrite every absolute local module specifier as a `file:` URL.
+ *
+ * The generated world names THIS package's built providers (`shell.js`,
+ * `fs.js`, …) by absolute path. That is what the directory mechanism needed:
+ * those rows sat in an Include-backed tree, and the boot-time Include
+ * translates an absolute path into a `file:` URL before importing it. A preset
+ * mounted from a *declaration* is loaded by the registry's own entry tree,
+ * which has no such translation — handing it `C:/…/lib/shell.js` leaves those
+ * rows without a fiber, the audit reports them "never started", and the whole
+ * variant is refused. Rewriting the specifier is therefore part of adapting to
+ * the declaration mechanism, not a change to what the variant mounts.
+ *
+ * Only `name` is touched: config values (the relay path handed to the PTY
+ * backend, the interpreter path in `shellPath`) must stay native filesystem
+ * paths. Group rows carry their children in a `config` array, so those are
+ * walked too.
+ * @param rows - the parsed declaration rows.
+ * @returns the same rows with their module specifiers made importable.
+ */
+function toImportableSpecifiers(rows: unknown[]): unknown[] {
+  const rewrite = (row: unknown): unknown => {
+    if (row === null || typeof row !== 'object') return row
+    const entry = row as { name?: unknown; config?: unknown }
+    if (typeof entry.name === 'string' && isAbsolute(entry.name)) {
+      entry.name = pathToFileURL(entry.name).href
+    }
+    if (Array.isArray(entry.config)) entry.config = entry.config.map(rewrite)
+    return row
+  }
+  return rows.map(rewrite)
 }
 
 /**
@@ -469,6 +619,7 @@ async function materializeVariants(
   dshHome: string,
   paths: { shell: string; fs: string; relay: string; node: string; sandbox: string; search: string; jobs: string },
   persistentShell: boolean,
+  track: (dispose: unknown) => void,
 ): Promise<void> {
   const presets = await agentPresets.list()
   const userRoot = join(dshHome, '.agent-presets')
@@ -477,12 +628,33 @@ async function materializeVariants(
     if (preset.broken !== undefined) continue
     if (isWslVariantId(preset.id)) continue
     const variantId = variantIdFor(preset.id)
-    const source = await agentPresets.read(preset.id)
-    const transformed = transformPresetForWsl(source, paths.shell, paths.fs, persistentShell ? {
+    const composition = await readPresetComposition(agentPresets, preset)
+    const transformed = transformPresetForWsl(composition.content, paths.shell, paths.fs, persistentShell ? {
       relayPath: paths.relay,
       nodePath: paths.node,
       sandboxPath: paths.sandbox,
     } : undefined, paths.search, paths.jobs)
+    // 0.1.7-alpha.1+ publishes a variant as a declaration row (the composition is
+    // already the exact entry-list dialect the declaration wants, so the only
+    // conversion is YAML back to rows); earlier releases still discover one as
+    // a directory under the roster's scanned user root.
+    if (typeof agentPresets.register === 'function') {
+      const plugins = await parseVariantComposition(transformed)
+      // A shipped mode keeps its bilingual label; a custom preset keeps the
+      // display name it published, falling back to its id.
+      const declaration: PresetDeclaration = {
+        id: variantId,
+        name: variantName(preset.id, composition.name ?? preset.name ?? preset.id),
+        description: variantDescription(preset.id),
+        ...(preset.order === undefined ? {} : { order: preset.order }),
+        plugins,
+      }
+      track(await agentPresets.register(declaration))
+      continue
+    }
+    if (preset.path === undefined) {
+      throw new Error(`agentPresets: roster entry "${preset.id}" carries no path on this release`)
+    }
     const dir = join(userRoot, variantId)
     const staging = `${dir}.staging`
     rmSync(staging, { recursive: true, force: true })
@@ -524,15 +696,20 @@ async function materializeVariants(
     publishVariant(staging, dir)
     generated.add(variantId)
   }
-  for (const entry of readdirSync(userRoot, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue
-    if (entry.name === 'wsl') {
-      // The legacy standalone WSL mode: folded into the variants above.
+  // Clean up the retired directory mechanism. `generated` holds the
+  // directories the directory path wrote on THIS boot; from 0.1.7-alpha.1 on it is
+  // always empty, because a variant is a declaration row and the roster no
+  // longer scans this root at all — so every `wsl*` entry left here (the legacy
+  // standalone `wsl` mode included) is inert leftover, and a `wsl-<mode>/`
+  // beside a registered `wsl-<mode>` declaration would only mislead. An absent
+  // root (a fresh install that never used the old mechanism) is not a failure.
+  if (existsSync(userRoot)) {
+    for (const entry of readdirSync(userRoot, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue
+      if (!/^wsl(-[a-z0-9-]+)?$/.test(entry.name)) continue
+      if (generated.has(entry.name)) continue
       rmSync(join(userRoot, entry.name), { recursive: true, force: true })
-      continue
     }
-    if (!/^wsl-[a-z0-9-]+$/.test(entry.name)) continue
-    if (!generated.has(entry.name)) rmSync(join(userRoot, entry.name), { recursive: true, force: true })
   }
 }
 
@@ -576,6 +753,21 @@ export function apply(ctx: Context, config: Config): void {
   const agentPresets = ctx.get('agentPresets') as unknown as AgentPresetsService | undefined
   if (agentPresets !== undefined) {
     ctx.effect(() => {
+      // On 0.1.7-alpha.1+ the variants are declaration rows in Host state rather
+      // than files, so the effect owns their disposers: a plugin unload or hot
+      // reload retires them instead of leaving orphans the next apply could not
+      // replace (`Duplicate agent preset: wsl-<mode>`).
+      let stopped = false
+      const disposers: (() => Promise<void>)[] = []
+      const track = (dispose: unknown): void => {
+        if (typeof dispose !== 'function') return
+        const retire = dispose as () => Promise<void>
+        if (stopped) {
+          void Promise.resolve(retire()).catch(() => {})
+          return
+        }
+        disposers.push(retire)
+      }
       void (async () => {
         const persistentShell = await supportsPersistentShell(ctx)
         await materializeVariants(agentPresets, dshHome, {
@@ -586,14 +778,19 @@ export function apply(ctx: Context, config: Config): void {
           sandbox: sandboxPath,
           search: searchPath,
           jobs: jobsPath,
-        }, persistentShell)
+        }, persistentShell, track)
       })().catch((error) => {
         // Variant generation is best-effort over a live roster: a missing or
         // unreadable source preset must not take the whole plugin down, but
         // the failure is surfaced loudly rather than hidden.
         console.error(`dsh-wsl-workspace: WSL preset-variant generation failed: ${messageOf(error)}`)
       })
-      return () => {}
+      return () => {
+        stopped = true
+        for (const retire of disposers.splice(0, disposers.length)) {
+          void Promise.resolve(retire()).catch(() => {})
+        }
+      }
     }, 'dsh-wsl-workspace: WSL preset variants')
   }
 

package/src/shared/links.ts

@@ -18,12 +18,9 @@
  * @module dsh-wsl-workspace/shared/links
  */
 
-import { execFile } from 'node:child_process'
-import { promisify } from 'node:util'
+import { execFileResult, textOf, wslExecutableCandidates } from './wsl.ts'
 import { isAbsoluteLinuxPath, joinUnc, parseWslUnc } from './paths.ts'
 
-const execFileAsync = promisify(execFile)
-
 /** How many `readlink` calls may be in flight at once. */
 export const LINK_RESOLVE_CONCURRENCY = 4
 /** How long the distribution may take to answer one `readlink` call. */
@@ -75,13 +72,25 @@ export async function resolveLinuxSymlink(
   // the path itself would come back mangled by that trim.
   if (unc === null || /[\r\n]/.test(unc.linuxPath)) return undefined
   try {
-    const output = await execFileAsync(
-      wslPath,
-      ['-d', unc.distro, '--', 'readlink', '-f', unc.linuxPath],
-      { encoding: 'utf8', timeout: LINK_RESOLVE_TIMEOUT_MS, windowsHide: true },
-    )
-    const target = String(output.stdout).trim()
-    return isAbsoluteLinuxPath(target) ? joinUnc(unc.distro, target) : undefined
+    // `execFileResult` is the callback form on purpose: a host that replaces
+    // `child_process.execFile` with a plain wrapper (DSH Desktop's
+    // `windowsHide` injection) strips the metadata `promisify` needs, and the
+    // promisified call would hand back stdout instead of `{ stdout, stderr }`
+    // — making this silently return `undefined` for every link (issue #35).
+    for (const candidate of wslExecutableCandidates(wslPath)) {
+      try {
+        const output = await execFileResult(
+          candidate,
+          ['-d', unc.distro, '--', 'readlink', '-f', unc.linuxPath],
+          { encoding: 'utf8', timeout: LINK_RESOLVE_TIMEOUT_MS, windowsHide: true },
+        )
+        const target = textOf(output.stdout).trim()
+        return isAbsoluteLinuxPath(target) ? joinUnc(unc.distro, target) : undefined
+      } catch {
+        // try the next spelling of wsl.exe
+      }
+    }
+    return undefined
   } catch {
     // Missing intermediate components, an unreadable link, a stopped
     // distribution or a missing `readlink` all land here.

package/src/shared/wsl.ts

@@ -7,9 +7,7 @@
  */
 
 import { execFile, execFileSync } from 'node:child_process'
-import { promisify } from 'node:util'
-
-const execFileAsync = promisify(execFile)
+import type { ExecFileOptions } from 'node:child_process'
 
 /** Executable timeout for the short discovery calls. */
 const DISCOVERY_TIMEOUT_MS = 10_000
@@ -21,13 +19,86 @@ function messageOf(value: unknown): string {
   return value instanceof Error ? value.message : String(value)
 }
 
+/** One `execFile` outcome: the two streams, as `encoding` asked for them. */
+export interface ExecFileResult {
+  stdout: Buffer | string
+  stderr: Buffer | string
+}
+
+/**
+ * Run `execFile` through its callback API and resolve `{ stdout, stderr }`.
+ *
+ * `util.promisify(execFile)` only resolves that object because `execFile`
+ * carries `util.promisify.custom`. A host that replaces
+ * `child_process.execFile` with a plain wrapper loses that metadata, and
+ * `promisify` then falls back to "resolve the first callback value" — which is
+ * stdout itself, so `result.stdout` is `undefined` (issue #35: DSH Desktop
+ * injects `windowsHide: true` that way, and `listDistros()` died with
+ * `Cannot read properties of undefined (reading 'includes')`).
+ *
+ * The callback form is what every such wrapper preserves, so this does not
+ * depend on how the host patched the module.
+ * @param file - the executable.
+ * @param args - its arguments.
+ * @param options - `execFile` options, including the requested encoding.
+ * @returns both streams; the caller narrows them by the encoding it asked for.
+ */
+export function execFileResult(
+  file: string,
+  args: readonly string[],
+  options: ExecFileOptions,
+): Promise<ExecFileResult> {
+  // `settle`/`fail` rather than `resolve`/`reject`, matching
+  // `src/host/wsl-search.ts`; `scripts/verify-lib.mjs` reads a bare
+  // `resolve(` call as an unbound `node:path` export.
+  return new Promise<ExecFileResult>((settle, fail) => {
+    execFile(file, [...args], options, (error, stdout, stderr) => {
+      if (error !== null && error !== undefined) {
+        fail(error)
+        return
+      }
+      settle({ stdout, stderr })
+    })
+  })
+}
+
+/** Read a captured stream as text, whichever way the encoding arrived. */
+export function textOf(stream: Buffer | string): string {
+  return typeof stream === 'string' ? stream : stream.toString('utf8')
+}
+
+/**
+ * The `wsl.exe` spellings to try, in order.
+ *
+ * The bare name relies on `PATH`. A host whose `PATH` omits `System32` can run
+ * every other part of this plugin — `listDir`/`check` go through the
+ * `\\wsl.localhost\…` share and never spawn anything — while `listDistros`
+ * reports that WSL is missing, which is what issue #36 describes. The
+ * absolute fallback removes that failure mode.
+ * @param wslPath - the configured executable.
+ * @returns the candidates, without duplicates.
+ */
+export function wslExecutableCandidates(wslPath: string): string[] {
+  if (wslPath !== 'wsl.exe') return [wslPath]
+  const root = process.env.SystemRoot ?? process.env.windir
+  if (root === undefined || root === '') return [wslPath]
+  const absolute = `${root.replace(/[\\/]+$/, '')}\\System32\\wsl.exe`
+  return [wslPath, absolute]
+}
+
 /**
  * Decode `wsl.exe -l -q` output. Newer builds emit UTF-8; most emit UTF-16LE
- * with NUL bytes interleaved — the NUL probe picks the right one.
+ * with NUL bytes interleaved — the NUL probe picks the right one. A host that
+ * handed back something other than the captured stream is reported as such
+ * instead of throwing `Cannot read properties of undefined`.
  * @param buffer - the raw captured output.
  * @returns the decoded text.
  */
-export function decodeWslOutput(buffer: Buffer): string {
+export function decodeWslOutput(buffer: Buffer | string): string {
+  if (typeof buffer === 'string') return buffer
+  if (!(buffer instanceof Uint8Array)) {
+    throw new Error(`wsl-workspace: expected captured output, got ${typeof buffer}`)
+  }
   return buffer.includes(0) ? buffer.toString('utf16le') : buffer.toString('utf8')
 }
 
@@ -37,12 +108,25 @@ export function decodeWslOutput(buffer: Buffer): string {
  * @returns distribution names, blank lines dropped.
  */
 export async function listDistros(wslPath = 'wsl.exe'): Promise<string[]> {
-  let stdout: Buffer
-  try {
-    const result = await execFileAsync(wslPath, ['-l', '-q'], { encoding: 'buffer', timeout: DISCOVERY_TIMEOUT_MS })
-    stdout = result.stdout as Buffer
-  } catch (error) {
-    throw new Error(`wsl-workspace: cannot list WSL distributions (${messageOf(error)}); is WSL installed?`)
+  const candidates = wslExecutableCandidates(wslPath)
+  let stdout: Buffer | string | undefined
+  let lastError: unknown
+  for (const candidate of candidates) {
+    try {
+      const result = await execFileResult(candidate, ['-l', '-q'], {
+        encoding: 'buffer',
+        timeout: DISCOVERY_TIMEOUT_MS,
+      })
+      stdout = result.stdout
+      break
+    } catch (error) {
+      lastError = error
+    }
+  }
+  if (stdout === undefined) {
+    throw new Error(
+      `wsl-workspace: cannot list WSL distributions (tried ${candidates.join(' and ')}: ${messageOf(lastError)}); is WSL installed?`,
+    )
   }
   return decodeWslOutput(stdout)
     .split(/\r?\n/)
@@ -58,15 +142,15 @@ export async function listDistros(wslPath = 'wsl.exe'): Promise<string[]> {
  */
 export async function defaultDistro(): Promise<string | undefined> {
   try {
-    const value = await execFileAsync('reg.exe', ['query', LXSS_KEY, '/v', 'DefaultDistribution'], {
+    const value = await execFileResult('reg.exe', ['query', LXSS_KEY, '/v', 'DefaultDistribution'], {
       timeout: DISCOVERY_TIMEOUT_MS,
     })
-    const guid = /DefaultDistribution\s+REG_SZ\s+(\{[0-9a-fA-F-]+\})/i.exec(value.stdout)?.[1]
+    const guid = /DefaultDistribution\s+REG_SZ\s+(\{[0-9a-fA-F-]+\})/i.exec(textOf(value.stdout))?.[1]
     if (guid === undefined) return undefined
-    const name = await execFileAsync('reg.exe', ['query', `${LXSS_KEY}\\${guid}`, '/v', 'DistributionName'], {
+    const name = await execFileResult('reg.exe', ['query', `${LXSS_KEY}\\${guid}`, '/v', 'DistributionName'], {
       timeout: DISCOVERY_TIMEOUT_MS,
     })
-    const distro = /DistributionName\s+REG_SZ\s+(.+)/i.exec(name.stdout)?.[1]?.trim()
+    const distro = /DistributionName\s+REG_SZ\s+(.+)/i.exec(textOf(name.stdout))?.[1]?.trim()
     return distro === undefined || distro === '' ? undefined : distro
   } catch {
     return undefined

package/lib/links-BQxdJOMy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"links-BQxdJOMy.js","names":["resolved: (string | undefined)[]"],"sources":["../src/shared/links.ts"],"sourcesContent":["/**\n * Linux symlink resolution through the owning distribution.\n *\n * The `\\\\wsl.localhost\\<distro>\\…` 9P share lists a Linux symlink entry but\n * cannot resolve its target: `readdir` reports it, and every Windows-side\n * `stat` on it fails (`ENOENT`/`EISDIR`). The distribution resolves the same\n * path trivially, so both halves of this plugin — the skill walk and the\n * filesystem backend — ask it with one short `wsl.exe … readlink -f` call per\n * link.\n *\n * Each link gets its own call on purpose: `wsl.exe` drops the arguments that\n * follow a command (`sh -c 'echo ARGC:$#' sh a b c` answers 0) and its\n * command-line parser truncates an argument containing a double quote, while a\n * bare multi-argument `readlink -f a b c` stops at the first path it cannot\n * resolve and still exits non-zero. A process argument carries any path\n * without quoting, which is what keeps this correct.\n *\n * @module dsh-wsl-workspace/shared/links\n */\n\nimport { execFile } from 'node:child_process'\nimport { promisify } from 'node:util'\nimport { isAbsoluteLinuxPath, joinUnc, parseWslUnc } from './paths.ts'\n\nconst execFileAsync = promisify(execFile)\n\n/** How many `readlink` calls may be in flight at once. */\nexport const LINK_RESOLVE_CONCURRENCY = 4\n/** How long the distribution may take to answer one `readlink` call. */\nexport const LINK_RESOLVE_TIMEOUT_MS = 10_000\n\n/**\n * Resolve Linux symlinks through the distribution that owns them.\n *\n * Never throws: a link the distribution cannot resolve (a missing component, a\n * stopped distribution, a `readlink` that fails) stays unresolved, and callers\n * keep whatever behaviour they had before this fallback existed.\n *\n * @param uncPaths - the links to resolve, in UNC spelling.\n * @param wslPath - the `wsl.exe` executable (absolute or PATH name).\n * @returns one entry per input, in order: the resolved real path as a UNC\n *   path, or `undefined` when the link or the distribution could not answer.\n */\nexport async function resolveLinuxSymlinks(\n  uncPaths: readonly string[],\n  wslPath = 'wsl.exe',\n): Promise<(string | undefined)[]> {\n  const resolved: (string | undefined)[] = uncPaths.map(() => undefined)\n  let next = 0\n  const workers = Array.from(\n    { length: Math.min(LINK_RESOLVE_CONCURRENCY, uncPaths.length) },\n    async () => {\n      for (let index = next; index < uncPaths.length; index = next) {\n        next += 1\n        resolved[index] = await resolveLinuxSymlink(uncPaths[index] ?? '', wslPath)\n      }\n    },\n  )\n  await Promise.all(workers)\n  return resolved\n}\n\n/**\n * Resolve one Linux symlink the share cannot follow.\n * @param uncPath - the link, in UNC spelling.\n * @param wslPath - the `wsl.exe` executable (absolute or PATH name).\n * @returns the real path as a UNC path, or `undefined` when it does not resolve.\n */\nexport async function resolveLinuxSymlink(\n  uncPath: string,\n  wslPath = 'wsl.exe',\n): Promise<string | undefined> {\n  const unc = parseWslUnc(uncPath)\n  // `readlink` answers one line, which the caller trims: a line break inside\n  // the path itself would come back mangled by that trim.\n  if (unc === null || /[\\r\\n]/.test(unc.linuxPath)) return undefined\n  try {\n    const output = await execFileAsync(\n      wslPath,\n      ['-d', unc.distro, '--', 'readlink', '-f', unc.linuxPath],\n      { encoding: 'utf8', timeout: LINK_RESOLVE_TIMEOUT_MS, windowsHide: true },\n    )\n    const target = String(output.stdout).trim()\n    return isAbsoluteLinuxPath(target) ? joinUnc(unc.distro, target) : undefined\n  } catch {\n    // Missing intermediate components, an unreadable link, a stopped\n    // distribution or a missing `readlink` all land here.\n    return undefined\n  }\n}\n"],"mappings":";;;;;AAwBA,MAAM,gBAAgB,UAAU;;AAGhC,MAAa,2BAA2B;;AAExC,MAAa,0BAA0B;;;;;;;;;;;;;AAcvC,eAAsB,qBACpB,UACA,UAAU,WACuB;CACjC,MAAMA,WAAmC,SAAS,UAAU;CAC5D,IAAI,OAAO;CACX,MAAM,UAAU,MAAM,KACpB,EAAE,QAAQ,KAAK,IAAI,0BAA0B,SAAS,WACtD,YAAY;AACV,OAAK,IAAI,QAAQ,MAAM,QAAQ,SAAS,QAAQ,QAAQ,MAAM;AAC5D,WAAQ;AACR,YAAS,SAAS,MAAM,oBAAoB,SAAS,UAAU,IAAI;;;AAIzE,OAAM,QAAQ,IAAI;AAClB,QAAO;;;;;;;;AAST,eAAsB,oBACpB,SACA,UAAU,WACmB;CAC7B,MAAM,MAAM,YAAY;AAGxB,KAAI,QAAQ,QAAQ,SAAS,KAAK,IAAI,WAAY,QAAO;AACzD,KAAI;EACF,MAAM,SAAS,MAAM,cACnB,SACA;GAAC;GAAM,IAAI;GAAQ;GAAM;GAAY;GAAM,IAAI;KAC/C;GAAE,UAAU;GAAQ,SAAS;GAAyB,aAAa;;EAErE,MAAM,SAAS,OAAO,OAAO,QAAQ;AACrC,SAAO,oBAAoB,UAAU,QAAQ,IAAI,QAAQ,UAAU;SAC7D;AAGN,SAAO"}

package/lib/wsl-CECXiGZH.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"wsl-CECXiGZH.js","names":["stdout: Buffer","syncDefault: string | undefined"],"sources":["../src/shared/paths.ts","../src/shared/wsl.ts"],"sourcesContent":["/**\n * WSL path helpers shared by the client and host halves. Pure and\n * dependency-free so both planes can import them without a runtime edge.\n */\n\n/** WSL2 default loopback bridge host: `\\\\wsl.localhost\\<distro>\\...`. */\nconst WSL_LOCALHOST_HOST = 'wsl.localhost'\n/** Legacy WSL interop host: `\\\\wsl$\\<distro>\\...`. */\nconst WSL_LEGACY_HOST = 'wsl$'\n\n/** The two UNC hosts WSL exposes a distribution's filesystem under. */\nconst UNC_HOSTS = [WSL_LOCALHOST_HOST, WSL_LEGACY_HOST]\n\n/** One WSL workspace coordinate parsed out of a UNC path. */\nexport interface WslUncTarget {\n  /** Distro name (e.g. `Ubuntu`) as `wsl -l -q` reports it. */\n  readonly distro: string\n  /** Normalized absolute Linux path (leading `/`; no trailing slash except root). */\n  readonly linuxPath: string\n}\n\n/**\n * Parse a WSL UNC path into its distro and Linux path. Accepts the WSL2\n * `\\\\wsl.localhost\\<distro>\\<linux>` form, the legacy `\\\\wsl$\\<distro>\\<linux>`\n * interop form, and forward-slash spellings of either.\n * @param raw - candidate absolute path.\n * @returns the parsed target, or null when the path is not a WSL UNC.\n */\nexport function parseWslUnc(raw: string): WslUncTarget | null {\n  const normalized = raw.replace(/\\\\/g, '/').replace(/\\/\\/+/g, '//')\n  if (!normalized.startsWith('//')) return null\n  const segments = normalized.slice(2).split('/')\n  const host = (segments[0] ?? '').toLowerCase()\n  if (!UNC_HOSTS.includes(host)) return null\n  const distro = segments[1] ?? ''\n  if (distro === '') return null\n  const rest = segments.slice(2).filter(segment => segment.length > 0)\n  return { distro, linuxPath: `/${rest.join('/')}` }\n}\n\n/**\n * Whether a path resolves into a WSL distro through either UNC form.\n * @param raw - candidate absolute path.\n * @returns whether the path parses as a WSL UNC.\n */\nexport function isWslUnc(raw: string): boolean {\n  return parseWslUnc(raw) !== null\n}\n\n/**\n * Translate a WSL UNC path to the absolute Linux path a process inside the\n * distribution can open. Throws on non-WSL input: callers rely on this\n * conversion to hand paths to the Linux world, so a silent pass-through\n * would hand a Windows path to bash.\n * @param uncPath - a path {@link parseWslUnc} accepts.\n * @returns the absolute Linux path.\n */\nexport function uncToLinux(uncPath: string): string {\n  const parts = parseWslUnc(uncPath)\n  if (parts === null) {\n    throw new Error(`wsl-workspace: \"${uncPath}\" is not a WSL UNC path`)\n  }\n  return parts.linuxPath\n}\n\n/**\n * Normalize a Linux absolute path for the Host: collapse repeated slashes and\n * strip a trailing slash (root becomes `/`).\n * @param path - absolute Linux path.\n * @returns the normalized path.\n */\nexport function normalizeLinuxPath(path: string): string {\n  const collapsed = path.replace(/\\/+/g, '/')\n  return collapsed === '/' ? '/' : collapsed.replace(/\\/$/, '')\n}\n\n/**\n * Whether a path is an absolute, non-empty Linux path.\n * @param path - candidate.\n * @returns whether it starts with `/` and contains no NUL.\n */\nexport function isAbsoluteLinuxPath(path: string): boolean {\n  return path.startsWith('/') && !path.includes('\\0')\n}\n\n/**\n * Join a distro and a Linux absolute path into the WSL2 UNC form used as the\n * workspace identity (`\\\\wsl.localhost\\<distro>\\<linux>`, backslash segments).\n * @param distro - distro name.\n * @param linuxPath - absolute Linux path (leading `/`).\n * @returns the UNC path.\n */\nexport function joinUnc(distro: string, linuxPath: string): string {\n  if (!isAbsoluteLinuxPath(linuxPath)) {\n    throw new Error(`wsl-workspace: cannot map a non-absolute Linux path \"${linuxPath}\" to UNC`)\n  }\n  // Defense in depth: a distribution name with separators or dot-dirs would\n  // escape the `\\\\wsl.localhost\\` share structure (the host route validates\n  // wire-supplied names too; every other caller passes through here).\n  if (distro === '' || distro === '.' || distro === '..' || /[\\\\/]/.test(distro)) {\n    throw new Error(`wsl-workspace: invalid distribution name \"${distro}\"`)\n  }\n  const normalized = linuxPath.replace(/\\/+/g, '/').replace(/\\/$/, '')\n  const withoutLeading = normalized.startsWith('/') ? normalized.slice(1) : normalized\n  const windowsSegments = withoutLeading.replace(/\\//g, '\\\\')\n  const suffix = windowsSegments === '' ? '' : `\\\\${windowsSegments}`\n  return `\\\\\\\\wsl.localhost\\\\${distro}${suffix}`\n}\n\n/**\n * Translate a Windows drive path to the drvfs mount path WSL distributions\n * conventionally expose it at (`C:\\foo` → `/mnt/c/foo`). Only single-letter\n * drives under `/mnt` are mapped; custom mount points are out of scope.\n * @param path - the candidate Windows path.\n * @returns the `/mnt/<drive>/…` path, or `null` for non-drive paths.\n */\nexport function windowsToMntPath(path: string): string | null {\n  const match = /^([A-Za-z]):[\\\\/](.*)$/.exec(path)\n  if (match === null) return null\n  const rest = (match[2] ?? '').replace(/\\\\/g, '/').replace(/\\/+/g, '/').replace(/\\/$/, '')\n  return `/mnt/${(match[1] ?? '').toLowerCase()}${rest === '' ? '' : `/${rest}`}`\n}\n\n/**\n * Translate a `/mnt/<drive>/…` path back to its Windows drive path.\n * @param linuxPath - the candidate Linux path.\n * @returns the `X:\\…` drive path, or `null` when the path is not a drvfs mount.\n */\nexport function mntToWindowsPath(linuxPath: string): string | null {\n  const match = /^\\/mnt\\/([a-zA-Z])(?:\\/(.*))?$/.exec(linuxPath)\n  if (match === null) return null\n  const rest = (match[2] ?? '').replace(/\\//g, '\\\\')\n  return `${(match[1] ?? '').toUpperCase()}:\\\\${rest}`\n}\n\n/**\n * Canonical Windows drive path for store keys and cross-realm identity:\n * separators unified to `\\`, trailing separator stripped, and the WHOLE path\n * lowercased — Windows paths compare case-insensitively, and the workspace\n * registry may realpath a different casing than the caller spelled (8.3 or\n * on-disk casing), so the store key must collide across casings.\n * @param path - candidate Windows drive path.\n * @returns the canonical form, or `null` when not drive-shaped.\n */\nexport function canonicalWindowsPath(path: string): string | null {\n  const match = /^([A-Za-z]):[\\\\/](.*)$/.exec(path)\n  if (match === null) return null\n  const rest = (match[2] ?? '').replace(/[\\\\/]+/g, '\\\\').replace(/\\\\$/, '').toLowerCase()\n  return `${(match[1] ?? '').toLowerCase()}:\\\\${rest}`\n}\n\n/**\n * True when a value is a Windows-shaped path (drive or UNC), which is how\n * the shell executor decides the WSLENV `/p` translation flag: only Windows\n * path values need translation when they cross into the Linux process.\n * @param value - the environment value to classify.\n * @returns whether the value looks like a Windows path.\n */\nexport function isWindowsPathShaped(value: string): boolean {\n  return /^[A-Za-z]:[\\\\/]/.test(value) || value.startsWith('\\\\\\\\')\n}\n\n/** Linux username shape for `wsl.exe -u`: starts with a letter or underscore, then letters/digits/`_`/`.`/`-` (max 64). */\nconst WSL_USERNAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_.-]{0,63}$/\n\n/**\n * Whether a value is a safe Linux username for `wsl.exe -u`. The check is\n * strict on purpose: a value starting with `-` could be parsed as a wsl.exe\n * option instead of a username.\n * @param value - candidate username.\n * @returns whether it matches the Linux username shape.\n */\nexport function isValidWslUsername(value: string): boolean {\n  return WSL_USERNAME_PATTERN.test(value)\n}\n","/**\n * WSL discovery helpers (host side): enumerate installed distributions\n * through `wsl.exe -l -q` and read the default distribution from the Lxss\n * registry key. `wsl.exe` output is UTF-16LE on most builds, so decoding\n * sniffs for NUL bytes before choosing an encoding.\n * @module dsh-wsl-workspace/shared/wsl\n */\n\nimport { execFile, execFileSync } from 'node:child_process'\nimport { promisify } from 'node:util'\n\nconst execFileAsync = promisify(execFile)\n\n/** Executable timeout for the short discovery calls. */\nconst DISCOVERY_TIMEOUT_MS = 10_000\n\nconst LXSS_KEY = 'HKCU\\\\Software\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Lxss'\n\n/** Human text for an unknown rejection. */\nfunction messageOf(value: unknown): string {\n  return value instanceof Error ? value.message : String(value)\n}\n\n/**\n * Decode `wsl.exe -l -q` output. Newer builds emit UTF-8; most emit UTF-16LE\n * with NUL bytes interleaved — the NUL probe picks the right one.\n * @param buffer - the raw captured output.\n * @returns the decoded text.\n */\nexport function decodeWslOutput(buffer: Buffer): string {\n  return buffer.includes(0) ? buffer.toString('utf16le') : buffer.toString('utf8')\n}\n\n/**\n * List installed WSL distributions in `wsl.exe` order.\n * @param wslPath - the `wsl.exe` executable (absolute or PATH name).\n * @returns distribution names, blank lines dropped.\n */\nexport async function listDistros(wslPath = 'wsl.exe'): Promise<string[]> {\n  let stdout: Buffer\n  try {\n    const result = await execFileAsync(wslPath, ['-l', '-q'], { encoding: 'buffer', timeout: DISCOVERY_TIMEOUT_MS })\n    stdout = result.stdout as Buffer\n  } catch (error) {\n    throw new Error(`wsl-workspace: cannot list WSL distributions (${messageOf(error)}); is WSL installed?`)\n  }\n  return decodeWslOutput(stdout)\n    .split(/\\r?\\n/)\n    .map(line => line.trim())\n    .filter(line => line.length > 0)\n}\n\n/**\n * Read the user's default distribution from the Lxss registry. Non-fatal:\n * returns `undefined` when the value is absent or unreadable (the caller\n * falls back to list order).\n * @returns the default distribution name, or `undefined`.\n */\nexport async function defaultDistro(): Promise<string | undefined> {\n  try {\n    const value = await execFileAsync('reg.exe', ['query', LXSS_KEY, '/v', 'DefaultDistribution'], {\n      timeout: DISCOVERY_TIMEOUT_MS,\n    })\n    const guid = /DefaultDistribution\\s+REG_SZ\\s+(\\{[0-9a-fA-F-]+\\})/i.exec(value.stdout)?.[1]\n    if (guid === undefined) return undefined\n    const name = await execFileAsync('reg.exe', ['query', `${LXSS_KEY}\\\\${guid}`, '/v', 'DistributionName'], {\n      timeout: DISCOVERY_TIMEOUT_MS,\n    })\n    const distro = /DistributionName\\s+REG_SZ\\s+(.+)/i.exec(name.stdout)?.[1]?.trim()\n    return distro === undefined || distro === '' ? undefined : distro\n  } catch {\n    return undefined\n  }\n}\n\n/** Module-level cache for {@link defaultDistroSync} (one registry read per process). */\nlet syncDefaultResolved = false\nlet syncDefault: string | undefined\n\n/**\n * Synchronous variant of {@link defaultDistro} for executors that must\n * resolve a distribution inside a synchronous plan step. Cached after the\n * first read; non-fatal (returns `undefined` when the registry is\n * unreadable, letting the caller fail loud with its own message).\n * @returns the default distribution name, or `undefined`.\n */\nexport function defaultDistroSync(): string | undefined {\n  if (syncDefaultResolved) return syncDefault\n  syncDefaultResolved = true\n  try {\n    const value = execFileSync('reg.exe', ['query', LXSS_KEY, '/v', 'DefaultDistribution'], {\n      timeout: DISCOVERY_TIMEOUT_MS,\n    })\n    const guid = /DefaultDistribution\\s+REG_SZ\\s+(\\{[0-9a-fA-F-]+\\})/i.exec(String(value))?.[1]\n    if (guid === undefined) return undefined\n    const name = execFileSync('reg.exe', ['query', `${LXSS_KEY}\\\\${guid}`, '/v', 'DistributionName'], {\n      timeout: DISCOVERY_TIMEOUT_MS,\n    })\n    const distro = /DistributionName\\s+REG_SZ\\s+(.+)/i.exec(String(name))?.[1]?.trim()\n    syncDefault = distro === undefined || distro === '' ? undefined : distro\n  } catch {\n    syncDefault = undefined\n  }\n  return syncDefault\n}\n"],"mappings":"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"}