dsh-plugin-wsl-env 0.1.0

package/lib/subprocess.js

@@ -0,0 +1,230 @@
+/**
+ * `ctx.subprocess` entrypoint — the WSL execution world behind the GUI's
+ * terminal window.
+ *
+ * ## Why this seam, and not `ctx.terminals`
+ *
+ * `ctx.terminals` (`@deepseek-ai/dsh-terminal` + `dsh-terminal-bash`) is the
+ * *model-facing* persistent-terminal service. The right-hand terminal window is
+ * a different subsystem: its host half is
+ * `@deepseek-ai/dsh-api-terminal-controller`, mounted once by the Web bundle,
+ * and it resolves the execution environment of the Session it serves with
+ *
+ *     execution(agent) {
+ *       const subprocess = agent.ctx.get("subprocess");
+ *       const sandboxPolicy = agent.ctx.get("sandboxPolicy");
+ *       ...
+ *     }
+ *
+ * ## Why a preset-scoped provider cannot serve it
+ *
+ * The obvious design — mount this provider in the `wsl` preset's isolate realm
+ * next to `shell` and `fs` — does not work, and the reason is worth recording
+ * because it is invisible from the profile YAML:
+ *
+ *   - A preset's isolate realms are created by `dsh-agent-preset-registry`
+ *     under the registry's **own** context:
+ *     `createScope(this.owner, key)` → `mountPreset(scope.ctx…)`.
+ *   - An Agent's context is a **parallel branch** created by the agent loop:
+ *     `this.scope = createScope(loopCtx, this); this.ctx = this.scope.ctx`,
+ *     where `loopCtx` is the root-mounted `ctx.agents` service context.
+ *     `createScope` only wraps a Cordis plugin and tags a scope key; it neither
+ *     touches `Context.isolate` nor passes through a loader entry, so the
+ *     agent's isolate map still resolves every service to the root realm.
+ *
+ * So `agent.ctx.get("subprocess")` always finds the **composition-level**
+ * provider, whatever the agent's preset isolates. The shipped registry provides
+ * `agentPresets.serviceFor(agent, name)` for exactly this gap, and the terminal
+ * controller does not use it. (`shell` and `fs` are unaffected: the model-facing
+ * tools live *inside* the preset tree, so their own contexts do resolve the
+ * realm.)
+ *
+ * ## What this provider therefore changes
+ *
+ * It replaces the shipped `subprocess` row at the composition level and
+ * overrides one method: `spawnTerminal`. A `wsl.exe` launch is rewritten into a
+ * launch that actually names the distro and the Session workspace's Linux
+ * directory; every other request — including every ordinary `spawn()`, which the
+ * command path uses for `wsl.exe -lc <command>` — reaches the shipped
+ * implementation untouched.
+ *
+ * The interpreter, the PTY, output handling and process-tree teardown stay the
+ * shipped implementation's, so the blast radius of replacing a root service
+ * stays at the one thing that was wrong: the directory and distro a terminal
+ * starts in.
+ *
+ * ## What the operator must pair it with
+ *
+ * `terminalEnvironment()` and `resolveExecutable()` are also resolved from the
+ * root realm, and neither receives a Session or a directory, so this provider
+ * deliberately leaves them alone: rewriting them would change executable lookup
+ * for every other root consumer (the pwsh executor, the LSP host, the file
+ * search) to make the *shell menu* of one window prettier. The profile instead
+ * configures the terminal controller with the single shell profile that matters:
+ * `shell: { path: wsl.exe, name: WSL }` and `shellCandidates: []`.
+ *
+ * Consequence worth stating plainly: the terminal is a property of the
+ * composition, not of the Session. A Session whose workspace is a Windows folder
+ * gets the same terminal, with that folder mounted at `/mnt/<drive>/…`.
+ *
+ * @module dsh-plugin-wsl/subprocess
+ */
+
+import z from "@deepseek-ai/schemastery";
+import { LocalSubprocessRuntime } from "@deepseek-ai/dsh-subprocess-local";
+import { isPosixAbsolute, toLinuxPath, uncToPosix, windowsToLinuxMount } from "./paths.js";
+import { DEFAULT_WSL_PATH, defaultDistro, wslEnvValue, wslTerminalArgv } from "./wsl.js";
+
+/**
+ * Env names a terminal launch keeps for the distro. `TERM` rides along because
+ * the PTY consumer sets it for the host process, and WSL imports no name that
+ * `WSLENV` does not list.
+ */
+const SAFE_FORWARD = ["TERM", "NO_COLOR", "PAGER", "GIT_PAGER", "LANG", "LC_ALL"];
+
+/** Namespace of the managed facts; every `DSH_*` name in a terminal request is forwarded. */
+const DSH_ENV_PREFIX = "DSH_";
+
+/** The one program a launch of this provider's does not pass through. */
+const WSL_PROGRAM = "wsl";
+
+/**
+ * Subprocess provider that serves a WSL distro as the composition's terminal
+ * execution world.
+ *
+ * Mount it at the profile root in place of the shipped local provider (the
+ * profile patch disables the `subprocess` row and inserts this one). It is a
+ * subclass rather than a wrapper, so every method it does not override is
+ * literally the shipped implementation.
+ */
+export class WslSubprocessRuntime extends LocalSubprocessRuntime {
+  static Config = z.object({
+    /** Distro name; empty means WSL's own default distro. */
+    distro: z.string().default(""),
+    /** Path to `wsl.exe`; overridable for a non-standard install. */
+    wslPath: z.string().default(DEFAULT_WSL_PATH),
+    /**
+     * A shell to pin inside the distro, as an absolute Linux path. Empty — the
+     * default — leaves the choice to `wsl.exe`, which starts the distro user's
+     * login shell exactly as an interactive `wsl.exe` does.
+     */
+    shell: z.string().default(""),
+    /**
+     * Login-shell semantics for a pinned shell. Ignored when no shell is pinned,
+     * because then the login shell is the shell.
+     */
+    loginShell: z.boolean().default(true),
+    /** Fallback directory when a launch names none; accepts any coordinate system. */
+    cwd: z.string().default(""),
+    /** Windows directory the `wsl.exe` process itself starts in. */
+    hostCwd: z.string().volatile(),
+    /** Extra env names to forward into the distro through WSLENV. */
+    forwardEnv: z.array(z.string()).default([]),
+  });
+
+  constructor(ctx, config) {
+    super(ctx);
+    this.config = config;
+    /** Cached default distro, resolved once from `wsl.exe -l -q`. */
+    this.resolvedDistro = config.distro;
+  }
+
+  /**
+   * The distro a launch uses when the request's directory does not name one,
+   * resolving WSL's default on first use.
+   * @returns the distro name.
+   */
+  async distro() {
+    if (this.resolvedDistro.length === 0) this.resolvedDistro = await defaultDistro({ wslPath: this.config.wslPath });
+    return this.resolvedDistro;
+  }
+
+  /** Windows directory the `wsl.exe` process is started from. */
+  hostCwd() {
+    return this.config.hostCwd.get() ?? process.env.SystemRoot ?? process.cwd();
+  }
+
+  /**
+   * The distro and Linux directory one terminal request names.
+   *
+   * The Session workspace the terminal controller passes in is the coordinate
+   * the harness already speaks, and it is also the strongest evidence of the
+   * intended distro: a UNC path names one outright. Anything else — a Windows
+   * drive path or a directory-less request — may legitimately be served by the
+   * configured distro.
+   *
+   * @param cwd - the request's working directory, in any coordinate system.
+   * @returns the distro name and its absolute Linux directory.
+   */
+  async terminalTarget(cwd) {
+    const text = String(cwd ?? "").trim();
+    const named = uncToPosix(text);
+    if (named !== undefined) return { distro: named.distro, linuxCwd: named.linuxPath };
+    const distro = await this.distro();
+    if (isPosixAbsolute(text)) return { distro, linuxCwd: text };
+    const mounted = windowsToLinuxMount(text);
+    if (mounted !== undefined) return { distro, linuxCwd: mounted };
+    return { distro, linuxCwd: toLinuxPath(this.config.cwd, { distro }) };
+  }
+
+  /**
+   * Open one interactive shell inside the distro over the host's PTY.
+   *
+   * Only a `wsl.exe` launch is rewritten. Everything else — a shipped host
+   * shell, the PTY backend's `bash -i`, any other consumer's terminal — is the
+   * shipped implementation's, which is what keeps replacing a root provider
+   * safe.
+   *
+   * The request's remaining arguments are intentionally not forwarded: the
+   * controller's shell profile carries only the program, and a second set of
+   * `wsl.exe` arguments would fight the distro and `--cd` this method derives
+   * from the Session.
+   *
+   * @param spec - the terminal request from the PTY consumer.
+   * @returns the live terminal handle.
+   */
+  async spawnTerminal(spec) {
+    if (!this.launchesDistro(spec.argv)) return super.spawnTerminal(spec);
+    const target = await this.terminalTarget(spec.cwd);
+    const argv = wslTerminalArgv({
+      wslPath: this.config.wslPath,
+      distro: target.distro,
+      shellPath: this.config.shell,
+      linuxCwd: target.linuxCwd,
+      login: this.config.loginShell,
+    });
+    const forward = new Set([...SAFE_FORWARD, ...this.config.forwardEnv]);
+    const imported = Object.keys(spec.env ?? {}).filter(
+      (name) => forward.has(name) || name.startsWith(DSH_ENV_PREFIX),
+    );
+    return super.spawnTerminal({
+      ...spec,
+      argv,
+      // A Windows CreateProcess cannot use a Linux path as its working
+      // directory; the Linux directory rides on `--cd` instead.
+      cwd: this.hostCwd(),
+      env: {
+        ...spec.env,
+        ...(imported.length > 0 ? { WSLENV: wslEnvValue(imported) } : {}),
+      },
+    });
+  }
+
+  /**
+   * Whether a terminal request is a `wsl.exe` launch.
+   *
+   * A bare `argv[0]` is judged by its own name, so the shipped program name and
+   * an operator-pinned absolute path both match.
+   *
+   * @param argv - the request's program and arguments.
+   * @returns true when this provider owns the launch.
+   */
+  launchesDistro(argv) {
+    const program = argv?.[0];
+    if (typeof program !== "string" || program.length === 0) return false;
+    const base = program.slice(Math.max(program.lastIndexOf("/"), program.lastIndexOf("\\")) + 1);
+    return base.toLowerCase().replace(/\.exe$/u, "") === WSL_PROGRAM;
+  }
+}
+
+export default WslSubprocessRuntime;

package/lib/wsl.js

@@ -0,0 +1,320 @@
+/**
+ * `wsl.exe` interop primitives shared by the shell executor, the filesystem
+ * backend and the directory picker.
+ *
+ * This module is deliberately separate from `index.js`: the picker runs as its
+ * own Loader entry and must not drag the shell executor's and filesystem
+ * backend's peer dependencies into that row.
+ *
+ * @module dsh-plugin-wsl/wsl
+ */
+
+import { execFile } from "node:child_process";
+import { posixToUnc } from "./paths.js";
+
+/** Default executable name; resolution is left to PATH. */
+export const DEFAULT_WSL_PATH = "wsl.exe";
+
+/**
+ * Run one host command and capture UTF-8 output.
+ *
+ * `wsl.exe` writes UTF-16LE by default, which would arrive as interleaved NUL
+ * bytes on every non-ASCII distro name or path, so `WSL_UTF8=1` is set for
+ * every call.
+ *
+ * @param argv - executable plus arguments, spawned without a shell.
+ * @param signal - optional cancellation.
+ * @returns captured stdout.
+ * @throws the execFile error, with a hint attached when the cause is the sandbox.
+ */
+export function runCapture(argv, signal) {
+  const [file, ...args] = argv;
+  return new Promise((resolve, reject) => {
+    execFile(
+      file,
+      args,
+      { env: { ...process.env, WSL_UTF8: "1" }, windowsHide: true, signal, encoding: "utf8" },
+      (error, stdout, stderr) => {
+        if (error) {
+          // A denied WSL call is the likeliest failure here and its own message
+          // is unhelpful, so name the cause when it is recognisable.
+          const detail = `${stdout ?? ""}${stderr ?? ""}`.replace(/\u0000/g, "").trim();
+          const denied = /E_ACCESSDENIED/i.test(detail) || error.code === "EACCES";
+          error.message = `${file} failed: ${detail || error.message}${
+            denied
+              ? " (WSL is unreachable from a sandboxed process: DSH's Windows ACL sandbox runs commands under a restricted low-integrity token. Compose the non-sandboxing providers.)"
+              : ""
+          }`;
+          reject(error);
+          return;
+        }
+        resolve(String(stdout ?? "").replace(/\u0000/g, ""));
+      },
+    );
+  });
+}
+
+/**
+ * List installed distros with `wsl.exe -l -q`.
+ * @param options - the `wsl.exe` path and optional cancellation.
+ * @returns distro names in WSL's own order, default distro first.
+ */
+export async function listDistros(options = {}) {
+  const stdout = await runCapture([options.wslPath ?? DEFAULT_WSL_PATH, "-l", "-q"], options.signal);
+  return stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+}
+
+/**
+ * Resolve the distro to use when none is configured: WSL's own default.
+ * @param options - the `wsl.exe` path and optional cancellation.
+ * @returns the first entry of {@link listDistros}.
+ * @throws when no distro is installed.
+ */
+export async function defaultDistro(options = {}) {
+  const [first] = await listDistros(options);
+  if (first === undefined) throw new Error("dsh-plugin-wsl: no WSL distro is installed (`wsl.exe -l -q` returned nothing)");
+  return first;
+}
+
+/**
+ * The Linux home directory of a distro's default user, as a Linux path. `$HOME`
+ * is set by `wsl.exe` itself from the distro's default user, so this needs no
+ * passwd parsing.
+ *
+ * @param distro - distro name.
+ * @param options - the `wsl.exe` path and optional cancellation.
+ * @returns e.g. `/home/andy`.
+ * @throws when the distro cannot be queried or reports no home.
+ */
+export async function linuxHomePath(distro, options = {}) {
+  const stdout = await runCapture(
+    [options.wslPath ?? DEFAULT_WSL_PATH, "-d", distro, "--exec", "sh", "-c", 'printf %s "$HOME"'],
+    options.signal,
+  );
+  const home = stdout.trim();
+  if (home.length === 0 || !home.startsWith("/")) {
+    throw new Error(`dsh-plugin-wsl: distro "${distro}" reported no usable $HOME (got "${home}")`);
+  }
+  return home;
+}
+
+/**
+ * The same home in the world coordinate system, which is what a host-side
+ * consumer needs.
+ *
+ * @param distro - distro name.
+ * @param options - the `wsl.exe` path and optional cancellation.
+ * @returns e.g. `\\wsl.localhost\ubuntu\home\andy`.
+ * @throws when the distro cannot be queried or reports no home.
+ */
+export async function linuxHome(distro, options = {}) {
+  return posixToUnc(distro, await linuxHomePath(distro, options));
+}
+
+/**
+ * Resolve a Linux path to its canonical form INSIDE the distro with
+ * `readlink -f`.
+ *
+ * This exists because the UNC share cannot traverse Linux symlinks: the share
+ * exposes one as a Windows reparse point whose relative POSIX target has no
+ * meaning to Windows path resolution, so `stat`/`realpath`/`read` on a path such
+ * as `/etc/os-release` (-> ../usr/lib/os-release) or `/lib` (-> usr/lib) fail
+ * with `ENOENT`, even though `lstat` reaches the link. Asking the distro for the
+ * real path is the only reliable answer, at one process per distinct path.
+ *
+ * @param distro - distro name.
+ * @param linuxPath - the Linux path to canonicalize.
+ * @param options - the `wsl.exe` path and optional cancellation.
+ * @returns the canonical absolute Linux path, or undefined when it cannot be
+ *   determined (missing file, broken link, or a failed query).
+ */
+export async function canonicalLinuxPath(distro, linuxPath, options = {}) {
+  try {
+    const stdout = await runCapture(
+      [options.wslPath ?? DEFAULT_WSL_PATH, "-d", distro, "--exec", "readlink", "-f", linuxPath],
+      options.signal,
+    );
+    const resolved = stdout.trim();
+    return resolved.startsWith("/") ? resolved : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Give `targetLinux` the same POSIX mode `sourceLinux` has, inside the distro.
+ *
+ * The UNC share does not carry POSIX modes to the host: a host-side `chmod` on a
+ * share path is silently ignored, and a host-side `stat` reports 0666 no matter
+ * what the distro sees. The distro itself has the real mode, so the mode has to
+ * be applied there — and because a rename preserves the inode's mode, applying
+ * it to a staged temp file *before* publication is enough for the published file
+ * to come out with the right bits.
+ *
+ * `stat` + `chmod` rather than `chmod --reference` keeps this working on distros
+ * whose chmod is busybox's.
+ *
+ * @param distro - distro name.
+ * @param sourceLinux - absolute Linux path whose mode is copied.
+ * @param targetLinux - absolute Linux path that receives the mode.
+ * @param options - the `wsl.exe` path and optional cancellation.
+ * @throws when the mode cannot be applied.
+ */
+export async function copyModeInDistro(distro, sourceLinux, targetLinux, options = {}) {
+  const script = 'if [ -e "$1" ]; then mode=$(stat -c %a "$1") && chmod "$mode" "$2"; fi';
+  await runCapture(
+    [options.wslPath ?? DEFAULT_WSL_PATH, "-d", distro, "--exec", "sh", "-c", script, "sh", sourceLinux, targetLinux],
+    options.signal,
+  );
+}
+
+/**
+ * Shells known to accept the combined POSIX `-lc` login-plus-command form.
+ *
+ * `-l` is not universal: csh/tcsh signal login through argv[0] instead, and
+ * fish/nushell/xonsh take different flags. Anything outside this set therefore
+ * gets a bare `-c`, so a distro whose user runs one of those shells still works
+ * — it just does not get login-shell semantics.
+ */
+const POSIX_LOGIN_SHELLS = new Set(["sh", "bash", "dash", "zsh", "ksh", "ksh93", "mksh", "ash", "busybox"]);
+
+/**
+ * The argv flags that make `shell` run `command`, with login semantics when the
+ * shell supports them.
+ *
+ * @param shellPath - absolute path to the shell inside the distro.
+ * @param login - whether login-shell semantics were requested.
+ * @returns the flags to place before the command string.
+ */
+export function shellArgs(shellPath, login) {
+  const name = String(shellPath).slice(String(shellPath).lastIndexOf("/") + 1).toLowerCase();
+  if (!POSIX_LOGIN_SHELLS.has(name)) return ["-c"];
+  return login ? ["-lc"] : ["-c"];
+}
+
+/**
+ * Shells whose `-l` flag means a login shell.
+ *
+ * Fish is included although it is absent from {@link POSIX_LOGIN_SHELLS}: fish
+ * rejects the combined `-lc` form that set guards, but it does accept `-l` for
+ * an interactive login shell. csh/tcsh signal login through argv[0] and
+ * nushell/xonsh use long flags, so they deliberately get nothing.
+ */
+const LOGIN_FLAG_SHELLS = new Set([...POSIX_LOGIN_SHELLS, "fish"]);
+
+/**
+ * The flags that make an interactive shell a login shell.
+ *
+ * Separate from {@link shellArgs} because an interactive terminal passes no
+ * command: `-lc` has no meaning there, and the login flag has to sit beside the
+ * caller's own `-i` (or its dialect equivalent) rather than replace it.
+ *
+ * @param shellPath - absolute path to the shell inside the distro.
+ * @param login - whether login-shell semantics were requested.
+ * @returns `["-l"]`, or an empty array for a shell whose login flag differs.
+ */
+export function interactiveShellArgs(shellPath, login) {
+  const name = String(shellPath).slice(String(shellPath).lastIndexOf("/") + 1).toLowerCase();
+  return login && LOGIN_FLAG_SHELLS.has(name) ? ["-l"] : [];
+}
+
+/**
+ * The `wsl.exe` argv that opens one interactive shell inside a distro.
+ *
+ * This is the terminal twin of the command form built in `lib/index.js`, with
+ * three deliberate differences:
+ *
+ *   - There is no command string. With no pinned shell the launch ends here and
+ *     `wsl.exe` itself starts the distro user's login shell, which is the same
+ *     shell an interactive `wsl.exe` gives a person — no shell has to be
+ *     guessed, and the distro's own passwd entry decides.
+ *   - A pinned `shellPath` is passed after `--exec`, which is as load-bearing
+ *     here as it is for commands: without it `wsl.exe` routes the launch through
+ *     the distro's default shell, which would expand and re-split the arguments
+ *     before the requested interactive shell ever sees them.
+ *   - `--cd` is omitted when no working directory is known, because `wsl.exe`
+ *     rejects an empty `--cd` argument whereas its own default starts in the
+ *     distro user's home.
+ *
+ * @param options - the `wsl.exe` path, distro, optional shell, its args, cwd and login mode.
+ * @returns the argv to spawn on the host.
+ */
+export function wslTerminalArgv(options) {
+  const { wslPath = DEFAULT_WSL_PATH, distro = "", shellPath, args = [], linuxCwd, login = true } = options;
+  const directory = typeof linuxCwd === "string" && linuxCwd.length > 0 ? ["--cd", linuxCwd] : [];
+  const shell =
+    typeof shellPath === "string" && shellPath.length > 0
+      ? ["--exec", shellPath, ...interactiveShellArgs(shellPath, login), ...args]
+      : [];
+  return [wslPath, ...(distro.length > 0 ? ["-d", distro] : []), ...directory, ...shell];
+}
+
+/**
+ * Managed facts of the `DSH_*` namespace that carry a Windows path. WSL's
+ * `WSLENV` `/p` flag translates them on the way into the distro, so a command
+ * there sees `/mnt/c/...` instead of `C:\...`. `DSH_WSL_HOME` is deliberately
+ * absent: it is already a POSIX path, and translating it would corrupt it.
+ */
+const PATH_TRANSLATED_ENV = new Set(["DSH_HOME", "DSH_PROFILE_DIR"]);
+
+/**
+ * Render WSLENV's value from the env names a call wants the distro to import.
+ *
+ * `wsl.exe` imports only the names listed here; everything else in the Windows
+ * process environment stops at the distro boundary.
+ *
+ * @param names - env names to reveal to the distro.
+ * @returns the `:`-joined WSLENV value.
+ */
+export function wslEnvValue(names) {
+  return names.map((name) => (PATH_TRANSLATED_ENV.has(name) ? `${name}/p` : name)).join(":");
+}
+
+/**
+ * Resolve the shell a distro's user actually gets, rather than assuming bash.
+ *
+ * The authoritative source is the login shell field of the user's passwd entry;
+ * `$SHELL` (which `wsl.exe` derives from it) is the fallback for distros without
+ * `getent`, and bash is the last resort. The passwd field is preferred because a
+ * user can export a different `SHELL` without changing their login shell.
+ *
+ * @param distro - distro name.
+ * @param options - the `wsl.exe` path and optional cancellation.
+ * @returns an absolute path to the shell inside the distro.
+ */
+export async function defaultShell(distro, options = {}) {
+  const wslPath = options.wslPath ?? DEFAULT_WSL_PATH;
+  const ask = async (script) => {
+    try {
+      const value = (await runCapture([wslPath, "-d", distro, "--exec", "sh", "-c", script], options.signal)).trim();
+      return value.startsWith("/") ? value : undefined;
+    } catch {
+      return undefined;
+    }
+  };
+  return (
+    (await ask('getent passwd "$(id -u)" | cut -d: -f7')) ??
+    (await ask('printf %s "$SHELL"')) ??
+    "bash"
+  );
+}
+
+/**
+ * Run one command inside a distro and return raw stdout. Used by callers that
+ * want Linux semantics instead of the UNC share's.
+ *
+ * @param distro - distro name.
+ * @param command - a shell command string.
+ * @param options - the `wsl.exe` path, an explicit `shell`, and optional cancellation.
+ * @returns captured stdout.
+ */
+export async function runInDistro(distro, command, options = {}) {
+  const shell = options.shell ?? (await defaultShell(distro, options));
+  return runCapture(
+    [options.wslPath ?? DEFAULT_WSL_PATH, "-d", distro, "--exec", shell, ...shellArgs(shell, options.loginShell !== false), command],
+    options.signal,
+  );
+}

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "dsh-plugin-wsl-env",
+  "version": "0.1.0",
+  "description": "Run a DeepSeek Harness session against a WSL distro: a ctx.shell executor that runs commands inside the distro and a ctx.fs backend over its UNC share",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "cordis",
+    "wsl",
+    "windows"
+  ],
+  "type": "module",
+  "main": "lib/shell.js",
+  "exports": {
+    ".": "./lib/shell.js",
+    "./shell": "./lib/shell.js",
+    "./fs": "./lib/fs.js",
+    "./subprocess": "./lib/subprocess.js",
+    "./picker": "./lib/picker.js",
+    "./auto-preset": "./lib/auto-preset.js",
+    "./shell-env": "./lib/shell-env.js",
+    "./wsl": "./lib/wsl.js",
+    "./paths": "./lib/paths.js",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "files": [
+    "lib/**/*.js",
+    "cordis.patch.yml",
+    "examples/**/*.yml",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "npm run test:syntax && npm run test:unit",
+    "test:syntax": "node test/syntax.mjs",
+    "test:unit": "node --test test/paths.test.mjs test/listing.test.mjs test/shell.test.mjs test/terminal.test.mjs",
+    "probe": "bash test/probe/run.sh",
+    "probe:terminal": "bash test/probe/terminal.sh",
+    "probe:sandbox": "bash test/probe/sandbox.sh",
+    "probe:sandbox-shell": "bash test/probe/sandbox-shell.sh",
+    "sync:windows": "bash test/probe/sync-to-windows.sh"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@11.7.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Big-Dao/dsh-plugin-wsl-env.git"
+  },
+  "homepage": "https://github.com/Big-Dao/dsh-plugin-wsl-env#readme",
+  "bugs": {
+    "url": "https://github.com/Big-Dao/dsh-plugin-wsl-env/issues"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "~4.0.4",
+    "@deepseek-ai/dsh-bash-local": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-fs": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-fs-local": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-host-directory-picker": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-sandbox": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-subprocess": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-subprocess-local": "0.2.0-rc.2",
+    "@deepseek-ai/schemastery": "~3.18.4"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-bash-local": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-fs": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-fs-local": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-host-directory-picker": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-sandbox": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-subprocess": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-subprocess-local": {
+      "optional": true
+    },
+    "@deepseek-ai/schemastery": {
+      "optional": true
+    }
+  }
+}