dsh-wsl-workspace 0.2.2 → 0.2.3

package/src/shared/paths.ts

@@ -1,159 +1,175 @@
-/**
- * WSL path helpers shared by the client and host halves. Pure and
- * dependency-free so both planes can import them without a runtime edge.
- */
-
-/** WSL2 default loopback bridge host: `\\wsl.localhost\<distro>\...`. */
-const WSL_LOCALHOST_HOST = 'wsl.localhost'
-/** Legacy WSL interop host: `\\wsl$\<distro>\...`. */
-const WSL_LEGACY_HOST = 'wsl$'
-
-/** The two UNC hosts WSL exposes a distribution's filesystem under. */
-const UNC_HOSTS = [WSL_LOCALHOST_HOST, WSL_LEGACY_HOST]
-
-/** One WSL workspace coordinate parsed out of a UNC path. */
-export interface WslUncTarget {
-  /** Distro name (e.g. `Ubuntu`) as `wsl -l -q` reports it. */
-  readonly distro: string
-  /** Normalized absolute Linux path (leading `/`; no trailing slash except root). */
-  readonly linuxPath: string
-}
-
-/**
- * Parse a WSL UNC path into its distro and Linux path. Accepts the WSL2
- * `\\wsl.localhost\<distro>\<linux>` form, the legacy `\\wsl$\<distro>\<linux>`
- * interop form, and forward-slash spellings of either.
- * @param raw - candidate absolute path.
- * @returns the parsed target, or null when the path is not a WSL UNC.
- */
-export function parseWslUnc(raw: string): WslUncTarget | null {
-  const normalized = raw.replace(/\\/g, '/').replace(/\/\/+/g, '//')
-  if (!normalized.startsWith('//')) return null
-  const segments = normalized.slice(2).split('/')
-  const host = (segments[0] ?? '').toLowerCase()
-  if (!UNC_HOSTS.includes(host)) return null
-  const distro = segments[1] ?? ''
-  if (distro === '') return null
-  const rest = segments.slice(2).filter(segment => segment.length > 0)
-  return { distro, linuxPath: `/${rest.join('/')}` }
-}
-
-/**
- * Whether a path resolves into a WSL distro through either UNC form.
- * @param raw - candidate absolute path.
- * @returns whether the path parses as a WSL UNC.
- */
-export function isWslUnc(raw: string): boolean {
-  return parseWslUnc(raw) !== null
-}
-
-/**
- * Translate a WSL UNC path to the absolute Linux path a process inside the
- * distribution can open. Throws on non-WSL input: callers rely on this
- * conversion to hand paths to the Linux world, so a silent pass-through
- * would hand a Windows path to bash.
- * @param uncPath - a path {@link parseWslUnc} accepts.
- * @returns the absolute Linux path.
- */
-export function uncToLinux(uncPath: string): string {
-  const parts = parseWslUnc(uncPath)
-  if (parts === null) {
-    throw new Error(`wsl-workspace: "${uncPath}" is not a WSL UNC path`)
-  }
-  return parts.linuxPath
-}
-
-/**
- * Normalize a Linux absolute path for the Host: collapse repeated slashes and
- * strip a trailing slash (root becomes `/`).
- * @param path - absolute Linux path.
- * @returns the normalized path.
- */
-export function normalizeLinuxPath(path: string): string {
-  const collapsed = path.replace(/\/+/g, '/')
-  return collapsed === '/' ? '/' : collapsed.replace(/\/$/, '')
-}
-
-/**
- * Whether a path is an absolute, non-empty Linux path.
- * @param path - candidate.
- * @returns whether it starts with `/` and contains no NUL.
- */
-export function isAbsoluteLinuxPath(path: string): boolean {
-  return path.startsWith('/') && !path.includes('\0')
-}
-
-/**
- * Join a distro and a Linux absolute path into the WSL2 UNC form used as the
- * workspace identity (`\\wsl.localhost\<distro>\<linux>`, backslash segments).
- * @param distro - distro name.
- * @param linuxPath - absolute Linux path (leading `/`).
- * @returns the UNC path.
- */
-export function joinUnc(distro: string, linuxPath: string): string {
-  if (!isAbsoluteLinuxPath(linuxPath)) {
-    throw new Error(`wsl-workspace: cannot map a non-absolute Linux path "${linuxPath}" to UNC`)
-  }
-  // Defense in depth: a distribution name with separators or dot-dirs would
-  // escape the `\\wsl.localhost\` share structure (the host route validates
-  // wire-supplied names too; every other caller passes through here).
-  if (distro === '' || distro === '.' || distro === '..' || /[\\/]/.test(distro)) {
-    throw new Error(`wsl-workspace: invalid distribution name "${distro}"`)
-  }
-  const normalized = linuxPath.replace(/\/+/g, '/').replace(/\/$/, '')
-  const withoutLeading = normalized.startsWith('/') ? normalized.slice(1) : normalized
-  const windowsSegments = withoutLeading.replace(/\//g, '\\')
-  const suffix = windowsSegments === '' ? '' : `\\${windowsSegments}`
-  return `\\\\wsl.localhost\\${distro}${suffix}`
-}
-
-/**
- * Translate a Windows drive path to the drvfs mount path WSL distributions
- * conventionally expose it at (`C:\foo` → `/mnt/c/foo`). Only single-letter
- * drives under `/mnt` are mapped; custom mount points are out of scope.
- * @param path - the candidate Windows path.
- * @returns the `/mnt/<drive>/…` path, or `null` for non-drive paths.
- */
-export function windowsToMntPath(path: string): string | null {
-  const match = /^([A-Za-z]):[\\/](.*)$/.exec(path)
-  if (match === null) return null
-  const rest = (match[2] ?? '').replace(/\\/g, '/').replace(/\/+/g, '/').replace(/\/$/, '')
-  return `/mnt/${(match[1] ?? '').toLowerCase()}${rest === '' ? '' : `/${rest}`}`
-}
-
-/**
- * Translate a `/mnt/<drive>/…` path back to its Windows drive path.
- * @param linuxPath - the candidate Linux path.
- * @returns the `X:\…` drive path, or `null` when the path is not a drvfs mount.
- */
-export function mntToWindowsPath(linuxPath: string): string | null {
-  const match = /^\/mnt\/([a-zA-Z])(?:\/(.*))?$/.exec(linuxPath)
-  if (match === null) return null
-  const rest = (match[2] ?? '').replace(/\//g, '\\')
-  return `${(match[1] ?? '').toUpperCase()}:\\${rest}`
-}
-
-/**
- * True when a value is a Windows-shaped path (drive or UNC), which is how
- * the shell executor decides the WSLENV `/p` translation flag: only Windows
- * path values need translation when they cross into the Linux process.
- * @param value - the environment value to classify.
- * @returns whether the value looks like a Windows path.
- */
-export function isWindowsPathShaped(value: string): boolean {
-  return /^[A-Za-z]:[\\/]/.test(value) || value.startsWith('\\\\')
-}
-
-/** Linux username shape for `wsl.exe -u`: starts with a letter or underscore, then letters/digits/`_`/`.`/`-` (max 64). */
-const WSL_USERNAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_.-]{0,63}$/
-
-/**
- * Whether a value is a safe Linux username for `wsl.exe -u`. The check is
- * strict on purpose: a value starting with `-` could be parsed as a wsl.exe
- * option instead of a username.
- * @param value - candidate username.
- * @returns whether it matches the Linux username shape.
- */
-export function isValidWslUsername(value: string): boolean {
-  return WSL_USERNAME_PATTERN.test(value)
-}
+/**
+ * WSL path helpers shared by the client and host halves. Pure and
+ * dependency-free so both planes can import them without a runtime edge.
+ */
+
+/** WSL2 default loopback bridge host: `\\wsl.localhost\<distro>\...`. */
+const WSL_LOCALHOST_HOST = 'wsl.localhost'
+/** Legacy WSL interop host: `\\wsl$\<distro>\...`. */
+const WSL_LEGACY_HOST = 'wsl$'
+
+/** The two UNC hosts WSL exposes a distribution's filesystem under. */
+const UNC_HOSTS = [WSL_LOCALHOST_HOST, WSL_LEGACY_HOST]
+
+/** One WSL workspace coordinate parsed out of a UNC path. */
+export interface WslUncTarget {
+  /** Distro name (e.g. `Ubuntu`) as `wsl -l -q` reports it. */
+  readonly distro: string
+  /** Normalized absolute Linux path (leading `/`; no trailing slash except root). */
+  readonly linuxPath: string
+}
+
+/**
+ * Parse a WSL UNC path into its distro and Linux path. Accepts the WSL2
+ * `\\wsl.localhost\<distro>\<linux>` form, the legacy `\\wsl$\<distro>\<linux>`
+ * interop form, and forward-slash spellings of either.
+ * @param raw - candidate absolute path.
+ * @returns the parsed target, or null when the path is not a WSL UNC.
+ */
+export function parseWslUnc(raw: string): WslUncTarget | null {
+  const normalized = raw.replace(/\\/g, '/').replace(/\/\/+/g, '//')
+  if (!normalized.startsWith('//')) return null
+  const segments = normalized.slice(2).split('/')
+  const host = (segments[0] ?? '').toLowerCase()
+  if (!UNC_HOSTS.includes(host)) return null
+  const distro = segments[1] ?? ''
+  if (distro === '') return null
+  const rest = segments.slice(2).filter(segment => segment.length > 0)
+  return { distro, linuxPath: `/${rest.join('/')}` }
+}
+
+/**
+ * Whether a path resolves into a WSL distro through either UNC form.
+ * @param raw - candidate absolute path.
+ * @returns whether the path parses as a WSL UNC.
+ */
+export function isWslUnc(raw: string): boolean {
+  return parseWslUnc(raw) !== null
+}
+
+/**
+ * Translate a WSL UNC path to the absolute Linux path a process inside the
+ * distribution can open. Throws on non-WSL input: callers rely on this
+ * conversion to hand paths to the Linux world, so a silent pass-through
+ * would hand a Windows path to bash.
+ * @param uncPath - a path {@link parseWslUnc} accepts.
+ * @returns the absolute Linux path.
+ */
+export function uncToLinux(uncPath: string): string {
+  const parts = parseWslUnc(uncPath)
+  if (parts === null) {
+    throw new Error(`wsl-workspace: "${uncPath}" is not a WSL UNC path`)
+  }
+  return parts.linuxPath
+}
+
+/**
+ * Normalize a Linux absolute path for the Host: collapse repeated slashes and
+ * strip a trailing slash (root becomes `/`).
+ * @param path - absolute Linux path.
+ * @returns the normalized path.
+ */
+export function normalizeLinuxPath(path: string): string {
+  const collapsed = path.replace(/\/+/g, '/')
+  return collapsed === '/' ? '/' : collapsed.replace(/\/$/, '')
+}
+
+/**
+ * Whether a path is an absolute, non-empty Linux path.
+ * @param path - candidate.
+ * @returns whether it starts with `/` and contains no NUL.
+ */
+export function isAbsoluteLinuxPath(path: string): boolean {
+  return path.startsWith('/') && !path.includes('\0')
+}
+
+/**
+ * Join a distro and a Linux absolute path into the WSL2 UNC form used as the
+ * workspace identity (`\\wsl.localhost\<distro>\<linux>`, backslash segments).
+ * @param distro - distro name.
+ * @param linuxPath - absolute Linux path (leading `/`).
+ * @returns the UNC path.
+ */
+export function joinUnc(distro: string, linuxPath: string): string {
+  if (!isAbsoluteLinuxPath(linuxPath)) {
+    throw new Error(`wsl-workspace: cannot map a non-absolute Linux path "${linuxPath}" to UNC`)
+  }
+  // Defense in depth: a distribution name with separators or dot-dirs would
+  // escape the `\\wsl.localhost\` share structure (the host route validates
+  // wire-supplied names too; every other caller passes through here).
+  if (distro === '' || distro === '.' || distro === '..' || /[\\/]/.test(distro)) {
+    throw new Error(`wsl-workspace: invalid distribution name "${distro}"`)
+  }
+  const normalized = linuxPath.replace(/\/+/g, '/').replace(/\/$/, '')
+  const withoutLeading = normalized.startsWith('/') ? normalized.slice(1) : normalized
+  const windowsSegments = withoutLeading.replace(/\//g, '\\')
+  const suffix = windowsSegments === '' ? '' : `\\${windowsSegments}`
+  return `\\\\wsl.localhost\\${distro}${suffix}`
+}
+
+/**
+ * Translate a Windows drive path to the drvfs mount path WSL distributions
+ * conventionally expose it at (`C:\foo` → `/mnt/c/foo`). Only single-letter
+ * drives under `/mnt` are mapped; custom mount points are out of scope.
+ * @param path - the candidate Windows path.
+ * @returns the `/mnt/<drive>/…` path, or `null` for non-drive paths.
+ */
+export function windowsToMntPath(path: string): string | null {
+  const match = /^([A-Za-z]):[\\/](.*)$/.exec(path)
+  if (match === null) return null
+  const rest = (match[2] ?? '').replace(/\\/g, '/').replace(/\/+/g, '/').replace(/\/$/, '')
+  return `/mnt/${(match[1] ?? '').toLowerCase()}${rest === '' ? '' : `/${rest}`}`
+}
+
+/**
+ * Translate a `/mnt/<drive>/…` path back to its Windows drive path.
+ * @param linuxPath - the candidate Linux path.
+ * @returns the `X:\…` drive path, or `null` when the path is not a drvfs mount.
+ */
+export function mntToWindowsPath(linuxPath: string): string | null {
+  const match = /^\/mnt\/([a-zA-Z])(?:\/(.*))?$/.exec(linuxPath)
+  if (match === null) return null
+  const rest = (match[2] ?? '').replace(/\//g, '\\')
+  return `${(match[1] ?? '').toUpperCase()}:\\${rest}`
+}
+
+/**
+ * Canonical Windows drive path for store keys and cross-realm identity:
+ * separators unified to `\`, trailing separator stripped, and the WHOLE path
+ * lowercased — Windows paths compare case-insensitively, and the workspace
+ * registry may realpath a different casing than the caller spelled (8.3 or
+ * on-disk casing), so the store key must collide across casings.
+ * @param path - candidate Windows drive path.
+ * @returns the canonical form, or `null` when not drive-shaped.
+ */
+export function canonicalWindowsPath(path: string): string | null {
+  const match = /^([A-Za-z]):[\\/](.*)$/.exec(path)
+  if (match === null) return null
+  const rest = (match[2] ?? '').replace(/[\\/]+/g, '\\').replace(/\\$/, '').toLowerCase()
+  return `${(match[1] ?? '').toLowerCase()}:\\${rest}`
+}
+
+/**
+ * True when a value is a Windows-shaped path (drive or UNC), which is how
+ * the shell executor decides the WSLENV `/p` translation flag: only Windows
+ * path values need translation when they cross into the Linux process.
+ * @param value - the environment value to classify.
+ * @returns whether the value looks like a Windows path.
+ */
+export function isWindowsPathShaped(value: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(value) || value.startsWith('\\\\')
+}
+
+/** Linux username shape for `wsl.exe -u`: starts with a letter or underscore, then letters/digits/`_`/`.`/`-` (max 64). */
+const WSL_USERNAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_.-]{0,63}$/
+
+/**
+ * Whether a value is a safe Linux username for `wsl.exe -u`. The check is
+ * strict on purpose: a value starting with `-` could be parsed as a wsl.exe
+ * option instead of a username.
+ * @param value - candidate username.
+ * @returns whether it matches the Linux username shape.
+ */
+export function isValidWslUsername(value: string): boolean {
+  return WSL_USERNAME_PATTERN.test(value)
+}

package/src/shared/wsl-credentials.ts

@@ -1,85 +1,135 @@
-/**
- * Per-workspace WSL credentials (host side only). The dialog stores the
- * optional Linux username of a WSL workspace under the harness home; the
- * per-session env contributor and the WSL shell executor read it back so
- * `wsl.exe -u <username>` can run commands as that user. Keys are canonical
- * UNC workspace paths. This module touches node builtins, so the browser
- * half never imports it.
- * @module dsh-wsl-workspace/shared/wsl-credentials
- */
-
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { isValidWslUsername, joinUnc, parseWslUnc } from './paths.ts'
-
-/** One workspace's stored credentials. */
-interface WorkspaceEntry {
-  /** The Linux user bash runs as inside the distribution (absent = distro default). */
-  username?: string
-}
-
-/** The stored form: canonical UNC workspace path → credentials. */
-type WorkspaceStore = Record<string, WorkspaceEntry>
-
-/** The store file lives under the harness home so both host halves share it. */
-function storePath(): string {
-  const dshHome = process.env.DSH_HOME ?? join(homedir(), '.dsh')
-  return join(dshHome, 'wsl-workspaces.json')
-}
-
-/** Read the store; a missing or corrupt file reads as empty (never throws). */
-function readStore(): WorkspaceStore {
-  try {
-    const parsed: unknown = JSON.parse(readFileSync(storePath(), 'utf8'))
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return {}
-    return parsed as WorkspaceStore
-  } catch {
-    return {}
-  }
-}
-
-/**
- * Canonicalize any accepted WSL UNC spelling into the store's key form.
- * @param path - candidate workspace path (either UNC host form).
- * @returns the canonical UNC path, or null when the path is not a WSL UNC.
- */
-export function canonicalWslUnc(path: string): string | null {
-  const parsed = parseWslUnc(path)
-  return parsed === null ? null : joinUnc(parsed.distro, parsed.linuxPath)
-}
-
-/**
- * Read the stored username for a WSL workspace.
- * @param uncPath - the workspace path (any accepted WSL UNC spelling).
- * @returns the username, or undefined when none is stored.
- */
-export function getWorkspaceUsername(uncPath: string): string | undefined {
-  const key = canonicalWslUnc(uncPath)
-  if (key === null) return undefined
-  const username = readStore()[key]?.username
-  return username === undefined || username === '' ? undefined : username
-}
-
-/**
- * Store (or clear) the username of a WSL workspace.
- * @param uncPath - the workspace path (any accepted WSL UNC spelling).
- * @param username - the username; empty or undefined clears the stored value.
- */
-export function setWorkspaceUsername(uncPath: string, username: string | undefined): void {
-  const key = canonicalWslUnc(uncPath)
-  if (key === null) throw new Error('wsl-workspace: workspace path is not a WSL UNC path')
-  const store = readStore()
-  if (username === undefined || username.trim() === '') {
-    delete store[key]
-  } else {
-    const trimmed = username.trim()
-    if (!isValidWslUsername(trimmed)) {
-      throw new Error('wsl-workspace: username must match the Linux username pattern [A-Za-z_][A-Za-z0-9_.-]*')
-    }
-    store[key] = { username: trimmed }
-  }
-  const path = storePath()
-  mkdirSync(dirname(path), { recursive: true })
-  writeFileSync(path, JSON.stringify(store, null, 2) + '\n', 'utf8')
-}
+/**
+ * Per-workspace WSL credentials (host side only). The dialog stores the
+ * optional Linux username of a WSL workspace under the harness home; the
+ * per-session env contributor and the WSL shell executor read it back so
+ * `wsl.exe -u <username>` can run commands as that user. Keys are canonical
+ * UNC workspace paths. This module touches node builtins, so the browser
+ * half never imports it.
+ * @module dsh-wsl-workspace/shared/wsl-credentials
+ */
+
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { canonicalWindowsPath, isValidWslUsername, joinUnc, parseWslUnc } from './paths.ts'
+
+/** One workspace's stored credentials. */
+interface WorkspaceEntry {
+  /** The Linux user bash runs as inside the distribution (absent = distro default). */
+  username?: string
+  /**
+   * The WSL distribution of a Windows-drive workspace (`/mnt/<drive>` path).
+   * 9P cannot serve drvfs mounts, so such workspaces register under their
+   * Windows drive path; this entry is what the per-session env contributor
+   * uses to hand a distro to the shell executor.
+   */
+  distro?: string
+}
+
+/** The stored form: canonical UNC or Windows drive workspace path → credentials. */
+type WorkspaceStore = Record<string, WorkspaceEntry>
+
+/** The store file lives under the harness home so both host halves share it. */
+function storePath(): string {
+  const dshHome = process.env.DSH_HOME ?? join(homedir(), '.dsh')
+  return join(dshHome, 'wsl-workspaces.json')
+}
+
+/** Read the store; a missing or corrupt file reads as empty (never throws). */
+function readStore(): WorkspaceStore {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(storePath(), 'utf8'))
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return {}
+    return parsed as WorkspaceStore
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Canonicalize any accepted WSL UNC spelling into the store's key form.
+ * @param path - candidate workspace path (either UNC host form).
+ * @returns the canonical UNC path, or null when the path is not a WSL UNC.
+ */
+export function canonicalWslUnc(path: string): string | null {
+  const parsed = parseWslUnc(path)
+  return parsed === null ? null : joinUnc(parsed.distro, parsed.linuxPath)
+}
+
+/**
+ * Read the stored username for a WSL workspace.
+ * @param uncPath - the workspace path (any accepted WSL UNC spelling).
+ * @returns the username, or undefined when none is stored.
+ */
+export function getWorkspaceUsername(uncPath: string): string | undefined {
+  const key = canonicalWslUnc(uncPath)
+  if (key === null) return undefined
+  const username = readStore()[key]?.username
+  return username === undefined || username === '' ? undefined : username
+}
+
+/**
+ * Store (or clear) the username of a WSL workspace.
+ * @param uncPath - the workspace path (any accepted WSL UNC spelling).
+ * @param username - the username; empty or undefined clears the stored value.
+ */
+export function setWorkspaceUsername(uncPath: string, username: string | undefined): void {
+  const key = canonicalWslUnc(uncPath)
+  if (key === null) throw new Error('wsl-workspace: workspace path is not a WSL UNC path')
+  const store = readStore()
+  if (username === undefined || username.trim() === '') {
+    delete store[key]
+  } else {
+    const trimmed = username.trim()
+    if (!isValidWslUsername(trimmed)) {
+      throw new Error('wsl-workspace: username must match the Linux username pattern [A-Za-z_][A-Za-z0-9_.-]*')
+    }
+    store[key] = { username: trimmed }
+  }
+  const path = storePath()
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, JSON.stringify(store, null, 2) + '\n', 'utf8')
+}
+
+/**
+ * Register the WSL distribution (and optional Linux username) of a
+ * Windows-drive workspace (`/mnt/<drive>` path). Keys are canonical Windows
+ * drive paths; the per-session env contributor reads the entry back so
+ * `wsl.exe -d <distro>` can run when the session cwd is a drive path.
+ * @param winPath - the Windows drive path (any spelling).
+ * @param distro - the WSL distribution the workspace belongs to.
+ * @param username - optional Linux username (distro default when absent).
+ */
+export function registerWindowsWorkspace(winPath: string, distro: string, username: string | undefined): void {
+  const key = canonicalWindowsPath(winPath)
+  if (key === null) throw new Error('wsl-workspace: workspace path is not a Windows drive path')
+  const entry: WorkspaceEntry = { distro }
+  if (username !== undefined && username.trim() !== '') {
+    const trimmed = username.trim()
+    if (!isValidWslUsername(trimmed)) {
+      throw new Error('wsl-workspace: username must match the Linux username pattern [A-Za-z_][A-Za-z0-9_.-]*')
+    }
+    entry.username = trimmed
+  }
+  const store = readStore()
+  store[key] = entry
+  const path = storePath()
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, JSON.stringify(store, null, 2) + '\n', 'utf8')
+}
+
+/**
+ * Read the stored credentials of a Windows-drive workspace.
+ * @param winPath - the Windows drive path (any spelling).
+ * @returns the stored entry, or undefined when none is registered.
+ */
+export function getWindowsWorkspace(winPath: string): WorkspaceEntry | undefined {
+  const key = canonicalWindowsPath(winPath)
+  if (key === null) return undefined
+  return readStore()[key]
+}
+
+/** Every stored workspace key (canonical UNC and Windows drive paths). */
+export function listWorkspaceKeys(): string[] {
+  return Object.keys(readStore())
+}

package/lib/paths-DBaSmi7x.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"paths-DBaSmi7x.js","names":[],"sources":["../src/shared/paths.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 * 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"],"mappings":";;AAWA,MAAM,YAAY,CAAC,iBAAoB,MAAe;;;;;;;;AAiBtD,SAAgB,YAAY,KAAkC;CAC5D,MAAM,aAAa,IAAI,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,UAAU,IAAI;CACjE,IAAI,CAAC,WAAW,WAAW,IAAI,GAAG,OAAO;CACzC,MAAM,WAAW,WAAW,MAAM,CAAC,CAAC,CAAC,MAAM,GAAG;CAC9C,MAAM,QAAQ,SAAS,MAAM,GAAA,CAAI,YAAY;CAC7C,IAAI,CAAC,UAAU,SAAS,IAAI,GAAG,OAAO;CACtC,MAAM,SAAS,SAAS,MAAM;CAC9B,IAAI,WAAW,IAAI,OAAO;CAE1B,OAAO;EAAE;EAAQ,WAAW,IADf,SAAS,MAAM,CAAC,CAAC,CAAC,QAAO,YAAW,QAAQ,SAAS,CAC/B,CAAC,CAAC,KAAK,GAAG;CAAI;AACnD;;;;;;;AAiCA,SAAgB,mBAAmB,MAAsB;CACvD,MAAM,YAAY,KAAK,QAAQ,QAAQ,GAAG;CAC1C,OAAO,cAAc,MAAM,MAAM,UAAU,QAAQ,OAAO,EAAE;AAC9D;;;;;;AAOA,SAAgB,oBAAoB,MAAuB;CACzD,OAAO,KAAK,WAAW,GAAG,KAAK,CAAC,KAAK,SAAS,IAAI;AACpD;;;;;;;;AASA,SAAgB,QAAQ,QAAgB,WAA2B;CACjE,IAAI,CAAC,oBAAoB,SAAS,GAChC,MAAM,IAAI,MAAM,wDAAwD,UAAU,SAAS;CAK7F,IAAI,WAAW,MAAM,WAAW,OAAO,WAAW,QAAQ,QAAQ,KAAK,MAAM,GAC3E,MAAM,IAAI,MAAM,6CAA6C,OAAO,EAAE;CAExE,MAAM,aAAa,UAAU,QAAQ,QAAQ,GAAG,CAAC,CAAC,QAAQ,OAAO,EAAE;CAEnE,MAAM,mBADiB,WAAW,WAAW,GAAG,IAAI,WAAW,MAAM,CAAC,IAAI,WAAA,CACnC,QAAQ,OAAO,IAAI;CAE1D,OAAO,sBAAsB,SADd,oBAAoB,KAAK,KAAK,KAAK;AAEpD;;;;;;;;AASA,SAAgB,iBAAiB,MAA6B;CAC5D,MAAM,QAAQ,yBAAyB,KAAK,IAAI;CAChD,IAAI,UAAU,MAAM,OAAO;CAC3B,MAAM,QAAQ,MAAM,MAAM,GAAA,CAAI,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,QAAQ,GAAG,CAAC,CAAC,QAAQ,OAAO,EAAE;CACxF,OAAO,SAAS,MAAM,MAAM,GAAA,CAAI,YAAY,IAAI,SAAS,KAAK,KAAK,IAAI;AACzE;;;;;;AAOA,SAAgB,iBAAiB,WAAkC;CACjE,MAAM,QAAQ,iCAAiC,KAAK,SAAS;CAC7D,IAAI,UAAU,MAAM,OAAO;CAC3B,MAAM,QAAQ,MAAM,MAAM,GAAA,CAAI,QAAQ,OAAO,IAAI;CACjD,OAAO,IAAI,MAAM,MAAM,GAAA,CAAI,YAAY,EAAE,KAAK;AAChD;;;;;;;;AASA,SAAgB,oBAAoB,OAAwB;CAC1D,OAAO,kBAAkB,KAAK,KAAK,KAAK,MAAM,WAAW,MAAM;AACjE;;AAGA,MAAM,uBAAuB;;;;;;;;AAS7B,SAAgB,mBAAmB,OAAwB;CACzD,OAAO,qBAAqB,KAAK,KAAK;AACxC"}

package/lib/wsl-GjkUifnx.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"wsl-GjkUifnx.js","names":[],"sources":["../src/shared/wsl-credentials.ts","../src/shared/wsl.ts"],"sourcesContent":["/**\n * Per-workspace WSL credentials (host side only). The dialog stores the\n * optional Linux username of a WSL workspace under the harness home; the\n * per-session env contributor and the WSL shell executor read it back so\n * `wsl.exe -u <username>` can run commands as that user. Keys are canonical\n * UNC workspace paths. This module touches node builtins, so the browser\n * half never imports it.\n * @module dsh-wsl-workspace/shared/wsl-credentials\n */\n\nimport { mkdirSync, readFileSync, writeFileSync } from 'node:fs'\nimport { homedir } from 'node:os'\nimport { dirname, join } from 'node:path'\nimport { isValidWslUsername, joinUnc, parseWslUnc } from './paths.ts'\n\n/** One workspace's stored credentials. */\ninterface WorkspaceEntry {\n  /** The Linux user bash runs as inside the distribution (absent = distro default). */\n  username?: string\n}\n\n/** The stored form: canonical UNC workspace path → credentials. */\ntype WorkspaceStore = Record<string, WorkspaceEntry>\n\n/** The store file lives under the harness home so both host halves share it. */\nfunction storePath(): string {\n  const dshHome = process.env.DSH_HOME ?? join(homedir(), '.dsh')\n  return join(dshHome, 'wsl-workspaces.json')\n}\n\n/** Read the store; a missing or corrupt file reads as empty (never throws). */\nfunction readStore(): WorkspaceStore {\n  try {\n    const parsed: unknown = JSON.parse(readFileSync(storePath(), 'utf8'))\n    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return {}\n    return parsed as WorkspaceStore\n  } catch {\n    return {}\n  }\n}\n\n/**\n * Canonicalize any accepted WSL UNC spelling into the store's key form.\n * @param path - candidate workspace path (either UNC host form).\n * @returns the canonical UNC path, or null when the path is not a WSL UNC.\n */\nexport function canonicalWslUnc(path: string): string | null {\n  const parsed = parseWslUnc(path)\n  return parsed === null ? null : joinUnc(parsed.distro, parsed.linuxPath)\n}\n\n/**\n * Read the stored username for a WSL workspace.\n * @param uncPath - the workspace path (any accepted WSL UNC spelling).\n * @returns the username, or undefined when none is stored.\n */\nexport function getWorkspaceUsername(uncPath: string): string | undefined {\n  const key = canonicalWslUnc(uncPath)\n  if (key === null) return undefined\n  const username = readStore()[key]?.username\n  return username === undefined || username === '' ? undefined : username\n}\n\n/**\n * Store (or clear) the username of a WSL workspace.\n * @param uncPath - the workspace path (any accepted WSL UNC spelling).\n * @param username - the username; empty or undefined clears the stored value.\n */\nexport function setWorkspaceUsername(uncPath: string, username: string | undefined): void {\n  const key = canonicalWslUnc(uncPath)\n  if (key === null) throw new Error('wsl-workspace: workspace path is not a WSL UNC path')\n  const store = readStore()\n  if (username === undefined || username.trim() === '') {\n    delete store[key]\n  } else {\n    const trimmed = username.trim()\n    if (!isValidWslUsername(trimmed)) {\n      throw new Error('wsl-workspace: username must match the Linux username pattern [A-Za-z_][A-Za-z0-9_.-]*')\n    }\n    store[key] = { username: trimmed }\n  }\n  const path = storePath()\n  mkdirSync(dirname(path), { recursive: true })\n  writeFileSync(path, JSON.stringify(store, null, 2) + '\\n', 'utf8')\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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"}