dsh-wsl-workspace 0.1.0

package/src/fs.ts

@@ -0,0 +1,228 @@
+/**
+ * WSL Service Provider for the `ctx.fs` capability seam. Backed by the host
+ * filesystem over the `\\wsl.localhost\<distro>\…` 9P share — zero install
+ * inside the distribution — while every model/UI-facing path is the Linux
+ * path a WSL process would open (`processPath`, `displayPath`, `fileUrl`).
+ * Reuses `LocalFileSystem`'s mechanics (realpath identity, atomic writes,
+ * per-target locks, version guards) unchanged, because those operate on the
+ * UNC path Node can open directly.
+ *
+ * Both UNC paths and Linux absolute paths resolve; Windows drive paths
+ * resolve through their `/mnt/<drive>` form, so a WSL-composed session can
+ * still touch the Windows filesystem coherently.
+ * @module dsh-wsl-workspace/fs
+ */
+
+import { Context } from '@deepseek-ai/cordis'
+import z from '@deepseek-ai/schemastery'
+import { link, lstat, rename } from 'node:fs/promises'
+import { FsError } from '@deepseek-ai/dsh-fs'
+import type { FsPathInfo, FsTarget } from '@deepseek-ai/dsh-fs'
+import { LocalFileSystem } from '@deepseek-ai/dsh-fs-local'
+import {
+  isAbsoluteLinuxPath,
+  joinUnc,
+  mntToWindowsPath,
+  parseWslUnc,
+  windowsToMntPath,
+} from './shared/paths.ts'
+
+/** Plugin config. `cwd`/`distro` are optional because UNC workdirs carry both. */
+export interface Config {
+  /** Base directory for relative paths without a per-call cwd (UNC or Linux). */
+  cwd?: string
+  /** Default distribution for Linux-absolute paths without a UNC cwd. */
+  distro?: string
+  /** Exclusive UTF-8 byte limit on each overwrite-diff side (see fs-local). */
+  diffBasisMaxBytes?: number
+}
+
+/** One translated coordinate: the input the local backend opens plus its cwd. */
+interface Translated {
+  /** Absolute path to hand to the local backend (UNC or Windows drive). */
+  input: string
+  /** Absolute Windows-side base for relative inputs (UNC or Windows drive). */
+  cwd: string
+}
+
+/**
+ * The WSL filesystem backend. Identity keys are canonical UNC paths; the
+ * Linux form is derived on demand, so both worlds stay in sync across
+ * aliases and symlinks.
+ */
+export class WslFileSystem extends LocalFileSystem {
+  static override Config: z<Config> = z.object({
+    cwd: z.string(),
+    distro: z.string(),
+    diffBasisMaxBytes: z.number().default(10 * 1024 * 1024),
+  })
+
+  private readonly distro: string | undefined
+
+  constructor(ctx: Context, config: Config) {
+    // schemastery fills the defaults before construction; the parent validates
+    // `diffBasisMaxBytes` and stores the resolved shape.
+    super(ctx, config)
+    this.distro = config.distro
+    // The 9P/drvfs substrate has no hard links and no Win32 security semantics:
+    // replace the atomic-publication boundaries the parent's fsio defaults to.
+    this.internals = {
+      linkFile: WslFileSystem.publishNoReplace,
+      replaceFile: WslFileSystem.replaceOverWrite,
+      copyFileDacl: WslFileSystem.skipDaclCopy,
+    }
+  }
+
+  /**
+   * No-replace publication for filesystems without hard links. A real
+   * collision (a concurrent external creator won) must still surface as the
+   * original EEXIST so the guarded-create failure path classifies it; an
+   * absent target falls back to rename, which on Windows publishes without
+   * replacing anything. Safe against this backend's own writers because the
+   * per-target lock serializes them.
+   * @param tempPath - the staged file.
+   * @param destPath - the destination to create.
+   */
+  private static async publishNoReplace(tempPath: string, destPath: string): Promise<void> {
+    try {
+      await link(tempPath, destPath)
+      return
+    } catch (error) {
+      let exists = false
+      try {
+        await lstat(destPath)
+        exists = true
+      } catch {
+        // Absent destination: rename publishes the staged file.
+      }
+      if (exists) throw error
+      await rename(tempPath, destPath)
+    }
+  }
+
+  /**
+   * Security-preserving replacement boundary: Windows rename replaces an
+   * existing destination atomically; no DACL preservation is needed over 9P.
+   * @param destPath - the file being replaced.
+   * @param tempPath - the staged replacement.
+   */
+  private static async replaceOverWrite(destPath: string, tempPath: string): Promise<void> {
+    await rename(tempPath, destPath)
+  }
+
+  /** 9P files inherit their directory's DACL; nothing to preserve. */
+  private static async skipDaclCopy(): Promise<void> {}
+
+  /** Translate a model/plugin path into Windows-side coordinates. */
+  private translate(path: string, cwd?: string): Translated {
+    const unc = parseWslUnc(path)
+    if (unc !== null) {
+      return { input: joinUnc(unc.distro, unc.linuxPath), cwd: this.cwdOr(cwd) }
+    }
+    if (isAbsoluteLinuxPath(path)) {
+      // /mnt/<drive>/… names the Windows filesystem inside the Linux world
+      // (the dual-access path for migration): open the drive path directly so
+      // both worlds stay coherent — the display stays the /mnt form.
+      const win = mntToWindowsPath(path)
+      if (win !== null) return { input: win, cwd: this.cwdOr(cwd) }
+      return { input: joinUnc(this.distroFor(cwd), path), cwd: this.cwdOr(cwd) }
+    }
+    if (windowsToMntPath(path) !== null) {
+      // Windows drive paths open directly; the Linux world reaches them via /mnt.
+      return { input: path, cwd: this.cwdOr(cwd) }
+    }
+    // Relative: resolve against the caller cwd (or the configured base).
+    const base = this.uncCwd(cwd)
+    return { input: path, cwd: base }
+  }
+
+  /** A base for absolute inputs (unused by resolution, but the parent needs one). */
+  private cwdOr(cwd?: string): string {
+    return cwd ?? this.config.cwd ?? process.cwd()
+  }
+
+  private uncCwd(cwd?: string): string {
+    const base = cwd ?? this.config.cwd
+    if (base === undefined || base === '') {
+      throw new FsError('wsl-fs: no cwd and no configured base for relative resolution', 'FS_IO_ERROR')
+    }
+    const unc = parseWslUnc(base)
+    if (unc !== null) return joinUnc(unc.distro, unc.linuxPath)
+    if (isAbsoluteLinuxPath(base)) return joinUnc(this.distroFor(base), base)
+    if (windowsToMntPath(base) !== null) return base
+    throw new FsError(`wsl-fs: cwd "${base}" is not in the WSL execution world`, 'FS_IO_ERROR')
+  }
+
+  private distroFor(cwd?: string): string {
+    const fromCwd = parseWslUnc(cwd ?? '')
+    if (fromCwd !== null) return fromCwd.distro
+    const distro = this.distro
+    if (distro === undefined || distro === '') {
+      throw new FsError('wsl-fs: Linux path carries no distribution and none is configured', 'FS_IO_ERROR')
+    }
+    return distro
+  }
+
+  /** The Linux display path for a resolved Windows-side path. */
+  private linuxDisplay(raw: string): string {
+    const unc = parseWslUnc(raw)
+    if (unc !== null) return unc.linuxPath
+    const mnt = windowsToMntPath(raw)
+    if (mnt !== null) return mnt
+    throw new FsError(`wsl-fs: resolved path "${raw}" is outside the WSL execution world`, 'FS_IO_ERROR')
+  }
+
+  override async resolve(path: string, opts?: { cwd?: string; signal?: AbortSignal }): Promise<FsTarget> {
+    if (opts?.signal?.aborted) throw new FsError('resolve aborted', 'FS_ABORTED')
+    const { input, cwd } = this.translate(path, opts?.cwd)
+    const local = await super.resolve(input, {
+      cwd,
+      ...opts?.signal !== undefined ? { signal: opts.signal } : {},
+    })
+    return { targetKey: local.targetKey, displayPath: this.linuxDisplay(String(local.displayPath)) }
+  }
+
+  override processPath(target: FsTarget): string {
+    const key = String(target.targetKey)
+    const unc = parseWslUnc(key)
+    if (unc !== null) return unc.linuxPath
+    const mnt = windowsToMntPath(key)
+    if (mnt !== null) return mnt
+    throw new FsError(`wsl-fs: target "${target.displayPath}" is outside the WSL execution world`, 'FS_IO_ERROR')
+  }
+
+  override fileUrl(target: FsTarget): string {
+    const linux = this.processPath(target)
+    const encoded = linux.split('/').map(encodeURIComponent).join('/')
+    return `file://${encoded}`
+  }
+
+  override contains(parent: FsTarget, child: FsTarget): boolean {
+    const parentWorld = this.worldPath(parent)
+    const childWorld = this.worldPath(child)
+    if (parentWorld.distro !== childWorld.distro) return false
+    const parentPath = parentWorld.linuxPath
+    const childPath = childWorld.linuxPath
+    if (childPath === parentPath) return true
+    return parentPath === '/' ? true : childPath.startsWith(`${parentPath}/`)
+  }
+
+  /** One target's (distro, linuxPath) pair for containment; `undefined` distro = Windows world. */
+  private worldPath(target: FsTarget): { distro: string | undefined; linuxPath: string } {
+    const key = String(target.targetKey)
+    const unc = parseWslUnc(key)
+    if (unc !== null) return { distro: unc.distro, linuxPath: unc.linuxPath }
+    const mnt = windowsToMntPath(key)
+    if (mnt !== null) return { distro: undefined, linuxPath: mnt }
+    throw new FsError(`wsl-fs: target "${target.displayPath}" is outside the WSL execution world`, 'FS_IO_ERROR')
+  }
+
+  override async lstat(path: string, opts?: { cwd?: string }, signal?: AbortSignal): Promise<FsPathInfo | undefined> {
+    if (signal?.aborted) throw new FsError('lstat aborted', 'FS_ABORTED')
+    if (path.trim().length === 0) throw new FsError('file_path must be a non-empty string', 'FS_NOT_FOUND')
+    const { input, cwd } = this.translate(path, opts?.cwd)
+    return super.lstat(input, { cwd }, signal)
+  }
+}
+
+export default WslFileSystem

package/src/host/variants.ts

@@ -0,0 +1,199 @@
+/**
+ * WSL preset-variant generator. For every healthy source preset the roster
+ * supplies, a `wsl-<id>` variant is materialized under the roster's user
+ * root: the source composition with its shell/filesystem world replaced by
+ * the WSL providers, so any mode (standard, minimal, code, cordis, user
+ * presets) can run on top of a WSL execution world. The execution world is
+ * therefore orthogonal to the mode instead of a mode itself.
+ *
+ * The transformation is text-level on the top-level rows of the composition
+ * (the shape all shipped presets share), with surgical edits for the known
+ * special groups; unknown shapes are kept verbatim where possible.
+ * @module dsh-wsl-workspace/host/variants
+ */
+
+/** Top-level rows that name the execution world and are replaced by the variant's own. */
+const WORLD_ROWS = new Set(['tool-bash', 'tool-pwsh', 'tool-fs', 'tool-fs-search', 'filesystem', 'persistent-shell'])
+
+/** The injected WSL world group: providers + the bash/fs consumers, entry-local. */
+function wslWorldGroup(shellPath: string, fsPath: string, includeEditor: boolean): string {
+  return [
+    '# ── WSL execution world (dsh-wsl-workspace variant) ─────────────────────',
+    '# The shell and fs services are provided entry-locally (the isolate',
+    '# realm); host services (tools registry, shell-env, jobs) fall through.',
+    '# tool-fs-search is intentionally absent: the packaged ripgrep runs on',
+    '# the Windows host and cannot open Linux paths; WSL sessions search with',
+    '# shell tools instead.',
+    '- id: wsl-world',
+    "  name: cordis:group",
+    '  group: true',
+    '  isolate:',
+    '    shell: true',
+    '    fs: true',
+    '  config:',
+    `    - id: shell-wsl`,
+    `      name: '${shellPath.replace(/'/g, "''")}'`,
+    '    - id: fs-wsl',
+    `      name: '${fsPath.replace(/'/g, "''")}'`,
+    '    - id: tool-bash',
+    "      name: '@deepseek-ai/dsh-tool-bash'",
+    '    - id: tool-fs',
+    "      name: '@deepseek-ai/dsh-tool-fs'",
+    ...(includeEditor
+      ? [
+          '    - id: str-replace-editor',
+          "      name: '@deepseek-ai/dsh-tool-str-replace-editor'",
+          '      config:',
+          '        maxOutputChars: 16000',
+        ]
+      : []),
+    '',
+  ].join('\n')
+}
+
+/**
+ * The persistent-shell group re-pointed at WSL: the PTY spawns wsl.exe's
+ * bash instead of a host `bash` (which does not exist on Windows).
+ */
+function persistentShellGroup(): string {
+  return [
+    '# ── persistent shell over WSL (variant) ─────────────────────────────────',
+    '- id: persistent-shell',
+    '  name: cordis:group',
+    '  group: true',
+    '  isolate:',
+    '    terminals: true',
+    '  config:',
+    '    - id: pty',
+    "      name: '@deepseek-ai/dsh-terminal'",
+    '',
+    '    - id: terminal-bash',
+    "      name: '@deepseek-ai/dsh-terminal-bash'",
+    '      config:',
+    '        timeoutMs: 300000',
+    "        shellPath: 'wsl.exe'",
+    "        shellArgs: ['-e', 'bash', '-l']",
+    '',
+    '    - id: persistent-bash',
+    "      name: '@deepseek-ai/dsh-tool-bash-persistent'",
+    '      config:',
+    '        timeoutMs: 300000',
+    '        description: |-',
+    '          Run commands in a bash shell inside the WSL distribution',
+    '          * When invoking this tool, the contents of the "command" parameter does NOT need to be XML-escaped.',
+    "          * You don't have access to the internet via this tool.",
+    '          * You do have access to a mirror of common linux and python packages via apt and pip.',
+    '          * State is persistent across command calls and discussions with the user.',
+    "          * To inspect a particular line range of a file, e.g. lines 10-25, try 'sed -n 10,25p /path/to/the/file'.",
+    '          * Please avoid commands that may produce a very large amount of output.',
+    "          * Please run long lived commands in the background, e.g. 'sleep 10 &' or start a server in the background.",
+    '',
+  ].join('\n')
+}
+
+/** The sentence appended to a standard-like persona when the variant runs in WSL. */
+const PERSONA_APPEND = ' Your working directory {{cwd}} is inside a WSL (Windows Subsystem for Linux) distribution: the bash tool and the file read/write/edit tools use Linux paths, and the Windows filesystem is reachable as /mnt/<drive> for file migration.'
+
+/** The top-level rows of one composition, as (startLine, endLineExclusive) spans. */
+function topLevelSpans(lines: readonly string[]): { start: number; end: number }[] {
+  const spans: { start: number; end: number }[] = []
+  let start = -1
+  for (let index = 0; index < lines.length; index++) {
+    if (lines[index]?.startsWith('- id: ') === true) {
+      if (start >= 0) spans.push({ start, end: index })
+      start = index
+    }
+  }
+  if (start >= 0) spans.push({ start, end: lines.length })
+  return spans
+}
+
+/** The row id of a top-level span, or undefined when the first line is malformed. */
+function spanId(lines: readonly string[], span: { start: number; end: number }): string | undefined {
+  return /^- id: ([A-Za-z0-9_.-]+)/.exec(lines[span.start] ?? '')?.[1]
+}
+
+/** Whether a top-level span is a `persona` row with an appendable folded text. */
+function appendablePersona(lines: readonly string[], span: { start: number; end: number }): boolean {
+  const block = lines.slice(span.start, span.end).join('\n')
+  if (!block.includes('complete: true') && /text: [>|-]/.test(block)) {
+    // Append only when the folded text actually has content lines.
+    const textLine = block.split('\n').find(line => /^(\s*)text: [>|-]/.test(line))
+    if (textLine !== undefined) {
+      const indent = /^(\s*)/.exec(textLine)?.[1]?.length ?? 0
+      return block.split('\n').some(line => line.length > indent && /^\s+/.test(line) && !line.includes(':'))
+    }
+  }
+  return false
+}
+
+/** Append the WSL sentence to a persona row's folded text (in place of its last text line). */
+function appendPersona(lines: readonly string[], span: { start: number; end: number }): string[] {
+  const block = lines.slice(span.start, span.end)
+  const textIndex = block.findIndex(line => /^(\s*)text: [>|-]/.test(line))
+  if (textIndex < 0) return [...block]
+  const indent = /^(\s*)/.exec(block[textIndex] ?? '')?.[1]?.length ?? 0
+  let lastText = -1
+  for (let index = textIndex + 1; index < block.length; index++) {
+    const line = block[index] ?? ''
+    if (line.trim() === '') continue
+    if (line.length > indent && /^\s+/.test(line)) lastText = index
+  }
+  if (lastText < 0) return [...block]
+  const updated = [...block]
+  const textIndent = /^(\s*)/.exec(block[lastText] ?? '')?.[1] ?? '  '
+  updated.splice(lastText + 1, 0, `${textIndent}${PERSONA_APPEND}`)
+  return updated
+}
+
+/**
+ * Transform one source preset composition into its WSL variant: drop the
+ * execution-world rows, keep everything else verbatim, and append the WSL
+ * world group (plus the persistent-shell group when the source had one).
+ * @param source - the source composition text.
+ * @param shellPath - absolute path of the plugin's built WSL shell provider.
+ * @param fsPath - absolute path of the plugin's built WSL fs provider.
+ * @returns the variant composition text.
+ */
+export function transformPresetForWsl(source: string, shellPath: string, fsPath: string): string {
+  const lines = source.split('\n')
+  const spans = topLevelSpans(lines)
+  const kept: string[] = []
+  let sawEditor = false
+  let sawPersistent = false
+  let personaAppended = false
+  for (const span of spans) {
+    const id = spanId(lines, span)
+    if (id === undefined) {
+      kept.push(...lines.slice(span.start, span.end))
+      continue
+    }
+    if (WORLD_ROWS.has(id)) {
+      if (id === 'persistent-shell') sawPersistent = true
+      continue
+    }
+    if (id === 'persona' && !personaAppended && appendablePersona(lines, span)) {
+      kept.push(...appendPersona(lines, span))
+      personaAppended = true
+      continue
+    }
+    kept.push(...lines.slice(span.start, span.end))
+    if (id === 'str-replace-editor') sawEditor = true
+  }
+  if (source.includes('str-replace-editor')) sawEditor = true
+  const result = [...kept]
+  if (result.length > 0 && result[result.length - 1] !== '') result.push('')
+  result.push(wslWorldGroup(shellPath, fsPath, sawEditor))
+  if (sawPersistent) result.push(persistentShellGroup())
+  return result.join('\n').replace(/\n{3,}/g, '\n\n').replace(/\n+$/, '\n')
+}
+
+/** Whether an id is one of this plugin's own preset directories. */
+export function isWslVariantId(id: string): boolean {
+  return id === 'wsl' || /^wsl-[a-z0-9-]+$/.test(id)
+}
+
+/** The variant id for one source preset id. */
+export function variantIdFor(sourceId: string): string {
+  return `wsl-${sourceId.toLowerCase()}`
+}