@chronosun/dsh-wsl 0.0.0-stage → 1.5.1

package/src/preset-default.mjs

@@ -0,0 +1,277 @@
+// Host-side default Agent preset for WSL workspaces.
+//
+// The Workspace UI's New Session path never names a preset (`startSession` /
+// `openWorkspace` / `connectWorkspace` all omit it), so every session created
+// in a `\\wsl.localhost\...` workspace used to fall back to the Host default
+// (`ptc`/`standard`) and silently ran its tools on Windows. This patch rewrites
+// the one request every Client creation path funnels through:
+// `sessionController.create`.
+//
+// Cordis exposes a Service through a tracing Proxy; the original instance is
+// reachable through the global `cordis.original` symbol. Patching the instance
+// (not the Proxy) is what the Typert gateway resolves for each call, so it
+// applies to every Client and every UI entry point, including a browser that
+// was loaded before this plugin. An explicit `agentPreset` always wins.
+//
+// The patch is deliberately scoped by path: a Windows Workspace keeps the Host
+// default. `agentPresets.resolve('wsl')` is checked once per process so a
+// profile where the preset row failed to activate falls back instead of making
+// every session creation fail.
+
+export const WSL_PRESET = 'wsl'
+
+const ORIGINAL = Symbol.for('cordis.original')
+const PATCHED = Symbol.for('dsh-wsl/preset-default')
+const CWD_PATCHED = Symbol.for('dsh-wsl/model-cwd')
+
+// `\\wsl.localhost\<distro>\...`, `//wsl.localhost/...`, `\\wsl$\...`.
+const WSL_UNC = /^[\\/]{2}\??(?:wsl\.localhost|wsl\$)[\\/]/i
+// Extended-length form: `\\?\UNC\wsl.localhost\...`.
+const WSL_EXTENDED_UNC = /^\\\\\?\\UNC\\(?:wsl\.localhost|wsl\$)[\\/]/i
+
+/** True for a Windows UNC path that addresses a WSL distribution. */
+export function isWslPath(value) {
+  if (typeof value !== 'string' || value.length === 0) return false
+  return WSL_UNC.test(value) || WSL_EXTENDED_UNC.test(value)
+}
+
+/**
+ * Translate a WSL UNC path to the Linux path the tools actually use.
+ * `\\\\wsl.localhost\\Ubuntu\\home\\me` -> `/home/me`; anything else -> undefined.
+ */
+export function linuxPathFromUnc(value) {
+  const raw = String(value ?? '')
+  if (raw.length === 0) return undefined
+  const extended = /^\\\\\?\\UNC\\(?:wsl\.localhost|wsl\$)\\([^\\]+)\\(.*)$/i.exec(raw)
+  if (extended) return '/' + extended[2].replace(/\\/g, '/')
+  const normal = /^[\\/]{2}\??(?:wsl\.localhost|wsl\$)[\\/]([^\\/]+)(?:[\\/](.*))?$/i.exec(raw)
+  if (!normal) return undefined
+  return '/' + (normal[2] ?? '').replace(/\\/g, '/')
+}
+
+/** Resolve the Workspace path through the Host registry, tolerating absence. */
+export function workspacePathOf(workspaceRegistry, workspaceId) {
+  if (workspaceId === undefined || workspaceId === null || workspaceId === '') return ''
+  try {
+    const workspace = workspaceRegistry?.get?.(workspaceId)
+    return typeof workspace?.path === 'string' ? workspace.path : ''
+  } catch {
+    return ''
+  }
+}
+
+/** The preset a create request should use, or undefined to leave it to the Host. */
+export function presetForRequest(ctx, request) {
+  if (!request || typeof request !== 'object') return undefined
+  if (request.agentPreset !== undefined) return undefined
+  const cwd = typeof request.cwd === 'string' ? request.cwd : ''
+  if (cwd !== '') return isWslPath(cwd) ? WSL_PRESET : undefined
+  let registry
+  try {
+    registry = ctx.get('workspaceRegistry')
+  } catch {
+    return undefined
+  }
+  return isWslPath(workspacePathOf(registry, request.workspaceId)) ? WSL_PRESET : undefined
+}
+
+function unwrap(value) {
+  if (!value || (typeof value !== 'object' && typeof value !== 'function')) return value
+  try {
+    return value[ORIGINAL] ?? value
+  } catch {
+    return value
+  }
+}
+
+/**
+ * Install the request-rewriting patch on the Host `sessionController`.
+ *
+ * The service may not exist yet when the plugin applies; the `internal/service`
+ * event covers that without making the whole plugin row depend on it.
+ *
+ * @returns `{ installed, dispose }`; `installed` is a live getter.
+ */
+export function installSessionPresetDefault(ctx) {
+  const disposers = []
+  let installed = false
+  let wslPresetReady = false
+  let checking = null
+
+  async function presetAvailable() {
+    if (wslPresetReady) return true
+    if (checking === null) {
+      checking = (async () => {
+        let presets
+        try {
+          presets = ctx.get('agentPresets')
+        } catch {
+          return false
+        }
+        if (typeof presets?.resolve !== 'function') return false
+        try {
+          await presets.resolve(WSL_PRESET)
+          return true
+        } catch {
+          return false
+        }
+      })().finally(() => { checking = null })
+    }
+    const ok = await checking
+    // A failed probe may mean the preset row is still mounting, so only the
+    // positive answer is cached for the life of the process.
+    if (ok) wslPresetReady = true
+    return ok
+  }
+
+  const install = (service) => {
+    if (installed) return true
+    const raw = unwrap(service)
+    if (!raw || typeof raw.create !== 'function') return false
+    if (raw[PATCHED]) {
+      installed = true
+      return true
+    }
+
+    const original = raw.create
+    const patched = async function create(request) {
+      const preset = presetForRequest(ctx, request)
+      const next = preset === undefined || !(await presetAvailable())
+        ? request
+        : { ...request, agentPreset: preset }
+      return original.call(raw, next)
+    }
+
+    try {
+      Object.defineProperty(raw, 'create', {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: patched,
+      })
+    } catch {
+      return false
+    }
+
+    const dispose = () => {
+      try { delete raw.create } catch {}
+      try { delete raw[PATCHED] } catch {}
+    }
+    Object.defineProperty(raw, PATCHED, {
+      configurable: true,
+      enumerable: false,
+      writable: true,
+      value: dispose,
+    })
+    disposers.push(dispose)
+    installed = true
+    return true
+  }
+
+  const current = ctx.get('sessionController')
+  if (current) install(current)
+  else ctx.on('internal/service', (name, value) => {
+    if (name === 'sessionController') install(value)
+  })
+
+  return {
+    get installed() { return installed },
+    dispose() {
+      for (const dispose of disposers.splice(0)) dispose()
+      installed = false
+    },
+  }
+}
+
+/**
+ * Present a Linux working directory to the model in WSL-preset sessions.
+ *
+ * The session's durable `cwd` stays the UNC path on purpose: Host features
+ * (diff view, `@` references, open-in-app, workspace grouping) resolve it
+ * through the Windows filesystem. But the Agent's tools all run in WSL and
+ * every path it writes is Linux, so showing `\\\\wsl.localhost\\...` as its
+ * `Current working directory` is the one remaining Windows-shaped input that
+ * makes the model emit Windows paths.
+ *
+ * Patch only `WorkingDirectoryService.contextText`, the model-facing string:
+ * `get`/`set`/the durable projection keep the UNC value, so no Host feature
+ * breaks. Only sessions whose recorded preset is `wsl` are rewritten.
+ *
+ * @returns `{ installed, dispose }`; `installed` is a live getter.
+ */
+export function installModelCwdTranslation(ctx) {
+  const disposers = []
+  let installed = false
+  let presetsService
+
+  const presetOf = (session) => {
+    try {
+      presetsService ??= ctx.get('agentPresets')
+      return presetsService?.presetForSession?.(session)
+    } catch {
+      return undefined
+    }
+  }
+
+  const install = (service) => {
+    if (installed) return true
+    const raw = unwrap(service)
+    if (!raw || typeof raw.contextText !== 'function' || typeof raw.get !== 'function') return false
+    if (raw[CWD_PATCHED]) {
+      installed = true
+      return true
+    }
+
+    const original = raw.contextText
+    const patched = function contextText(session) {
+      const text = original.call(raw, session)
+      try {
+        if (presetOf(session) !== WSL_PRESET) return text
+        const linux = linuxPathFromUnc(raw.get(session))
+        if (linux === undefined) return text
+        return `Current working directory: ${JSON.stringify(linux)}.`
+      } catch {
+        return text
+      }
+    }
+
+    try {
+      Object.defineProperty(raw, 'contextText', {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: patched,
+      })
+    } catch {
+      return false
+    }
+
+    const dispose = () => {
+      try { delete raw.contextText } catch {}
+      try { delete raw[CWD_PATCHED] } catch {}
+    }
+    Object.defineProperty(raw, CWD_PATCHED, {
+      configurable: true,
+      enumerable: false,
+      writable: true,
+      value: dispose,
+    })
+    disposers.push(dispose)
+    installed = true
+    return true
+  }
+
+  const current = ctx.get('workingDirectory')
+  if (current) install(current)
+  else ctx.on('internal/service', (name, value) => {
+    if (name === 'workingDirectory') install(value)
+  })
+
+  return {
+    get installed() { return installed },
+    dispose() {
+      for (const dispose of disposers.splice(0)) dispose()
+      installed = false
+    },
+  }
+}

package/src/registry.mjs

@@ -0,0 +1,56 @@
+// One broker per (distro, user), shared by the world and the panel.
+// ESM module cache makes this a process-wide singleton for every row of this
+// package, so the panel observes the very connections sessions use.
+import { readFileSync } from 'node:fs'
+import { WslBroker } from './broker.mjs'
+
+const helperSource = readFileSync(new URL('./helper.mjs', import.meta.url), 'utf8')
+
+class WslRegistry {
+  #brokers = new Map()
+  #idleMinutes = 15
+
+  set idleMinutes(minutes) {
+    const n = Number(minutes)
+    if (!Number.isFinite(n) || n < 0) return
+    this.#idleMinutes = n
+    for (const broker of this.#brokers.values()) broker.setIdleMs(n * 60_000)
+  }
+
+  get idleMinutes() { return this.#idleMinutes }
+
+  key(distro, user) { return `${distro}|${user}` }
+
+  get(distro = '', user = '') {
+    const key = this.key(distro, user)
+    let broker = this.#brokers.get(key)
+    if (!broker) {
+      broker = new WslBroker({ distro, user, idleMs: this.#idleMinutes * 60_000, helperSource })
+      broker.on('state', (s) => this.#log(`[${key}] ${s.state}`))
+      this.#brokers.set(key, broker)
+    }
+    return broker
+  }
+
+  peek(distro, user) { return this.#brokers.get(this.key(distro, user)) }
+
+  list() {
+    return [...this.#brokers.entries()].map(([key, broker]) => ({
+      key,
+      ...broker.info,
+      hello: broker.hello
+        ? { user: broker.hello.user, home: broker.hello.home, node: broker.hello.node, cwd: broker.hello.cwd }
+        : undefined,
+    }))
+  }
+
+  async disconnectAll() {
+    for (const broker of this.#brokers.values()) await broker.disconnect('shutdown').catch(() => {})
+  }
+
+  #log(message) {
+    try { process.stdout.write(`[dsh-wsl] ${message}\n`) } catch {}
+  }
+}
+
+export const registry = new WslRegistry()

package/src/settings.mjs

@@ -0,0 +1,51 @@
+// Small user settings store for the panel/doctor: per-distro login user and a
+// default distro. Deliberately separate from the profile patch (the user owns
+// that file); the plugin only reads/writes its own JSON under ~/.dsh.
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+export const settingsFile = join(homedir(), '.dsh', 'remote-wsl-settings.json')
+
+function normalize(raw) {
+  const idle = Number(raw?.idleDays)
+  return {
+    users: { ...(raw && typeof raw.users === 'object' && raw.users !== null ? raw.users : {}) },
+    defaultDistro: typeof raw?.defaultDistro === 'string' ? raw.defaultDistro : '',
+    idleDays: Number.isFinite(idle) && idle >= 0 ? idle : 5,
+  }
+}
+
+export function readSettings() {
+  try {
+    return normalize(JSON.parse(readFileSync(settingsFile, 'utf8')))
+  } catch {
+    return normalize({})
+  }
+}
+
+export function writeSettings(patch = {}) {
+  const current = readSettings()
+  const next = normalize({
+    ...current,
+    ...patch,
+    users: { ...current.users, ...(patch.users ?? {}) },
+  })
+  try {
+    mkdirSync(dirname(settingsFile), { recursive: true })
+    const tmp = `${settingsFile}.tmp`
+    writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`, 'utf8')
+    renameSync(tmp, settingsFile)
+  } catch {}
+  return next
+}
+
+/** Per-distro login user; empty means the distribution default. */
+export function userFor(distro) {
+  const settings = readSettings()
+  return settings.users[distro ?? ''] ?? settings.users[''] ?? ''
+}
+
+export function defaultDistro() {
+  return readSettings().defaultDistro
+}

package/src/subprocess.mjs

@@ -0,0 +1,180 @@
+// WSL execution world for the ctx.subprocess seam.
+// Written as a factory so it can be tested without DSH; the plugin wraps it in
+// a `SubprocessRuntime` subclass (see index.js).
+import { spawn as nodeSpawn, execFile } from 'node:child_process'
+import { appendFileSync } from 'node:fs'
+import { Collector } from './collector.mjs'
+import { parseWslUnc } from './broker.mjs'
+import { buildArgv } from './launch.mjs'
+
+const LOG = 'C:\\Users\\Yunson\\dsh-wsl-plugin\\wsl-world.log'
+const DEBUG = process.env.DSH_WSL_DEBUG === '1'
+const trace = (line) => { if (DEBUG) try { appendFileSync(LOG, `${new Date().toISOString()} sub: ${line}\n`) } catch {} }
+
+const WSL_EXE = `${process.env.SystemRoot ?? 'C:\\Windows'}\\System32\\wsl.exe`
+
+/** Accept a Linux path, a `\\wsl.localhost\...` path, or a `C:\...` path. */
+export function toLinuxCwd(cwd, distro) {
+  if (!cwd) return undefined
+  if (cwd.startsWith('/')) return cwd
+  const unc = parseWslUnc(cwd)
+  if (unc) {
+    if (unc.distro.toLowerCase() !== distro.toLowerCase()) {
+      throw Object.assign(new Error(`cwd 属于另一个发行版：${unc.distro}`), { code: 'FS_BAD_PATH' })
+    }
+    return unc.linuxPath
+  }
+  const drive = /^([A-Za-z]):[\\/](.*)$/.exec(cwd)
+  if (drive) return `/mnt/${drive[1].toLowerCase()}/${drive[2].replace(/\\/g, '/')}`
+  return cwd
+}
+
+function collect(mode) {
+  if (mode === 'pipe' || mode === 'inherit') return { kind: mode, collector: null }
+  if (mode && typeof mode.maxBytes === 'number') return { kind: 'collect', collector: new Collector(mode.maxBytes) }
+  throw Object.assign(new Error('subprocess-wsl: invalid stdio mode'), { code: 'SUBPROCESS_INVALID_SPEC' })
+}
+
+export function createWslSubprocess({ broker, distro, user = '', ptyDelegate, onExit } = {}) {
+  const live = new Set()
+
+  /**
+   * Everything travels inside ONE base64-encoded `-c` script (see launch.mjs):
+   * wsl.exe drops trailing arguments and pre-expands `$VAR` against the dirty
+   * target environment, so nothing else survives intact.
+   */
+  function argvFor(spec, cwd) {
+    const args = buildArgv(spec, { distro, user, cwd, path: broker?.cleanPath })
+    trace(`spawn ${JSON.stringify(args)}`)
+    return args
+  }
+
+  function validate(spec) {
+    if (!spec || !Array.isArray(spec.argv) || spec.argv.length === 0) {
+      throw Object.assign(new Error('subprocess-wsl: argv must name a program'), { code: 'SUBPROCESS_INVALID_SPEC' })
+    }
+    if (spec.signal?.aborted) throw Object.assign(new Error('subprocess-wsl: aborted'), { code: 'SUBPROCESS_ABORTED' })
+  }
+
+  return {
+    /** @inheritdoc */
+    async resolveExecutable(command, env, signal) {
+      signal?.throwIfAborted()
+      if (!command) throw Object.assign(new Error('subprocess-wsl: empty command'), { code: 'SUBPROCESS_INVALID_SPEC' })
+      if (command.includes('/') && !command.startsWith('/')) {
+        throw Object.assign(new Error(`subprocess-wsl: relative path is ambiguous: ${command}`), { code: 'SUBPROCESS_INVALID_SPEC' })
+      }
+      const found = await broker.call('which', { command, env }, { signal })
+      if (!found?.path) {
+        throw Object.assign(new Error(`subprocess-wsl: command not found in ${distro}: ${command}`), { code: 'SUBPROCESS_EXECUTABLE_NOT_FOUND' })
+      }
+      return found.path
+    },
+
+    /** @inheritdoc */
+    async terminalEnvironment(signal) {
+      signal?.throwIfAborted()
+      const shell = broker.hello?.shell ?? '/bin/bash'
+      return { platform: 'posix', defaultShell: shell }
+    },
+
+    /** @inheritdoc */
+    spawn(spec) {
+      validate(spec)
+      const cwd = toLinuxCwd(spec.cwd, distro)
+      const stdinMode = spec.stdio.stdin
+      const out = collect(spec.stdio.stdout)
+      const err = collect(spec.stdio.stderr)
+      const stdio = [
+        stdinMode === 'pipe' ? 'pipe' : stdinMode === 'ignore' ? 'ignore' : 'pipe',
+        out.kind === 'inherit' ? 'inherit' : 'pipe',
+        err.kind === 'inherit' ? 'inherit' : 'pipe',
+      ]
+      const child = nodeSpawn(WSL_EXE, argvFor(spec, cwd), { windowsHide: true, stdio })
+      if (out.kind === 'pipe' || err.kind === 'pipe') {
+        // Raw streams belong to the caller; nothing is buffered here.
+      }
+      if (out.collector) child.stdout.on('data', (d) => out.collector.write(d))
+      if (err.collector) child.stderr.on('data', (d) => err.collector.write(d))
+      if (typeof stdinMode === 'object' && stdinMode && typeof stdinMode.data === 'string') {
+        child.stdin.end(stdinMode.data)
+      }
+      if (spec.signal) {
+        const onAbort = () => { try { terminate() } catch {} }
+        spec.signal.addEventListener('abort', onAbort, { once: true })
+        child.once('close', () => spec.signal.removeEventListener('abort', onAbort))
+      }
+
+      let settled = false
+      let terminated = false
+      const done = new Promise((resolve, reject) => {
+        child.on('error', (error) => { if (!settled) { settled = true; reject(error) } })
+        child.on('close', (code, signal) => {
+          if (settled) return
+          settled = true
+          live.delete(handle)
+          onExit?.(handle)
+          resolve({ exitCode: code, signal: signal ?? null })
+        })
+      })
+
+      function terminate() {
+        if (terminated || settled) return
+        terminated = true
+        if (process.platform === 'win32' && child.pid) {
+          // Kill the whole tree: wsl.exe plus the Windows-side relay.
+          execFile('taskkill', ['/T', '/F', '/PID', String(child.pid)], () => {})
+        } else {
+          try { child.kill('SIGKILL') } catch {}
+        }
+      }
+
+      const handle = {
+        stdin: child.stdin ?? undefined,
+        stdout: out.kind === 'pipe' ? child.stdout : undefined,
+        stderr: err.kind === 'pipe' ? child.stderr : undefined,
+        control: undefined,
+        collected: {
+          stdout: out.collector ? { readFrom: (o) => out.collector.readFrom(o) } : undefined,
+          stderr: err.collector ? { readFrom: (o) => err.collector.readFrom(o) } : undefined,
+        },
+        done,
+        terminate,
+        async waitForExit() { await done.catch(() => {}); return true },
+      }
+      live.add(handle)
+      done.catch(() => {}).finally(() => live.delete(handle))
+      return handle
+    },
+
+    /** @inheritdoc */
+    async spawnTerminal(spec, delegate = ptyDelegate) {
+      if (!delegate) {
+        throw Object.assign(new Error('subprocess-wsl: no PTY delegate mounted; the sidebar terminal is unavailable'), { code: 'SUBPROCESS_UNSUPPORTED' })
+      }
+      const cwd = toLinuxCwd(spec.cwd, distro)
+      const args = ['-d', distro]
+      if (user) args.push('-u', user)
+      if (cwd) args.push('--cd', cwd)
+      args.push('--', ...spec.argv)
+      // Delegate to the host's real PTY: wsl.exe allocates the tty, the
+      // Linux-side bash inherits it. This is why the world needs the local
+      // provider captured before it is shadowed.
+      return delegate.spawnTerminal({
+        ...spec,
+        argv: [WSL_EXE, ...args],
+        cwd: process.env.SystemRoot ?? 'C:\\Windows',
+        env: { ...(spec.env ?? {}) },
+      })
+    },
+
+    /** Terminate everything this provider still manages (service disposal). */
+    async dispose() {
+      for (const handle of [...live]) {
+        try { handle.terminate() } catch {}
+      }
+      for (const handle of [...live]) await handle.waitForExit().catch(() => {})
+      live.clear()
+    },
+  }
+}