dsh-remote-workspaces 0.1.0

package/src/local-backend.js

@@ -0,0 +1,224 @@
+/**
+ * Local filesystem backend (the "local path" half of the routing provider).
+ *
+ * Self-contained over `node:fs` so the plugin does not depend on the
+ * `deepseek-harness` local backend (which would register `ctx.fs` and conflict
+ * with the routing provider). Implements the same 12 operations as the
+ * `@deepseek-ai/dsh-fs` `FileSystem` seam, on plain `{ targetKey, displayPath }`
+ * targets and plain version strings.
+ */
+
+import { readFile, readdir, rename, rm, stat, lstat, realpath, writeFile } from 'node:fs/promises'
+import { isAbsolute, join, relative, resolve, dirname, basename, sep } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { fsError } from './errors.js'
+import { writableRoots, isPathUnder } from './containment.js'
+
+function versionOf(st) {
+  return `mtime:${Math.round(st.mtimeMs)}:size:${st.size}`
+}
+
+function typeOf(st) {
+  if (st.isDirectory()) return 'directory'
+  if (st.isFile()) return 'file'
+  return 'other'
+}
+
+export class LocalBackend {
+  constructor({ cwd = process.cwd(), getPolicy } = {}) {
+    this.cwd = cwd
+    this.getPolicy = getPolicy
+  }
+
+  async resolve(path, opts = {}) {
+    const base = opts.cwd ?? this.cwd
+    const displayPath = isAbsolute(path) ? resolve(path) : resolve(base, path)
+    let targetKey = displayPath
+    try {
+      targetKey = await realpath(displayPath)
+    } catch {
+      // A path about to be created has no canonical form yet; keep the resolved path.
+    }
+    return { targetKey, displayPath }
+  }
+
+  processPath(target) {
+    return target.targetKey
+  }
+
+  fileUrl(target) {
+    return pathToFileURL(target.targetKey).href
+  }
+
+  contains(parent, child) {
+    const rel = relative(parent.targetKey, child.targetKey)
+    return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel))
+  }
+
+  async stat(target) {
+    try {
+      const st = await stat(target.targetKey)
+      return { version: versionOf(st), type: typeOf(st), ...(st.isFile() ? { size: st.size } : {}) }
+    } catch (error) {
+      if (error && error.code === 'ENOENT') return undefined
+      throw fsError('FS_IO_ERROR', `cannot stat "${target.displayPath}": ${error.message}`, error)
+    }
+  }
+
+  async lstat(path, opts = {}) {
+    const base = opts.cwd ?? this.cwd
+    const full = isAbsolute(path) ? path : resolve(base, path)
+    try {
+      const st = await lstat(full)
+      const type = st.isSymbolicLink() ? 'symlink' : typeOf(st)
+      return { version: versionOf(st), type, ...(st.isFile() ? { size: st.size } : {}) }
+    } catch (error) {
+      if (error && error.code === 'ENOENT') return undefined
+      throw fsError('FS_IO_ERROR', `cannot lstat "${full}": ${error.message}`, error)
+    }
+  }
+
+  async readText(target) {
+    try {
+      const text = await readFile(target.targetKey, 'utf8')
+      if (text.includes('\0')) throw fsError('FS_NOT_TEXT', `cannot read "${target.displayPath}": binary file`)
+      return text
+    } catch (error) {
+      if (error && error.code) throw error
+      throw fsError('FS_IO_ERROR', `cannot read "${target.displayPath}": ${error.message}`, error)
+    }
+  }
+
+  async streamText(target) {
+    const text = await this.readText(target)
+    return {
+      async *[Symbol.asyncIterator]() {
+        yield text
+      },
+    }
+  }
+
+  async readBytes(target, signal, maxBytes) {
+    const info = await this.stat(target)
+    if (info === undefined) throw fsError('FS_NOT_FOUND', `cannot read "${target.displayPath}": not found`)
+    if (info.type !== 'file') throw fsError('FS_NOT_REGULAR_FILE', `cannot read "${target.displayPath}": not a regular file`)
+    if (info.size !== undefined && info.size > maxBytes) {
+      throw fsError('FS_TOO_LARGE', `cannot read "${target.displayPath}": ${info.size} bytes exceeds the ${maxBytes}-byte limit`)
+    }
+    try {
+      return await readFile(target.targetKey)
+    } catch (error) {
+      throw fsError('FS_IO_ERROR', `cannot read "${target.displayPath}": ${error.message}`, error)
+    }
+  }
+
+  async listDir(target) {
+    try {
+      const entries = await readdir(target.targetKey, { withFileTypes: true })
+      return entries
+        .map((entry) => ({
+          name: entry.name,
+          type: entry.isDirectory() ? 'directory' : entry.isFile() ? 'file' : 'other',
+          target: {
+            targetKey: join(target.targetKey, entry.name),
+            displayPath: join(target.displayPath, entry.name),
+          },
+        }))
+        .sort((a, b) => a.name.localeCompare(b.name))
+    } catch (error) {
+      if (error && error.code === 'ENOENT') throw fsError('FS_NOT_FOUND', `cannot list "${target.displayPath}": not found`, error)
+      throw fsError('FS_IO_ERROR', `cannot list "${target.displayPath}": ${error.message}`, error)
+    }
+  }
+
+  async writeText(target, content, expected, signal, sandboxPolicy) {
+    const t = await this.checkedTarget(target, sandboxPolicy)
+    const existing = await this.stat(t)
+    if (existing !== undefined && existing.type !== 'file') {
+      throw fsError('FS_NOT_REGULAR_FILE', `cannot write "${t.displayPath}": not a regular file`)
+    }
+    if (expected && expected.kind === 'createIfAbsent' && existing !== undefined) {
+      throw fsError('FS_NOT_OBSERVED', `cannot overwrite existing "${t.displayPath}" without reading it first`)
+    }
+    if (expected && expected.kind === 'replaceIfVersion') {
+      if (existing === undefined || existing.version !== expected.version) {
+        throw fsError('FS_STALE_VERSION', `cannot write "${t.displayPath}": file changed since it was read`)
+      }
+    }
+    let before = null
+    if (existing !== undefined && existing.type === 'file') {
+      try { before = await this.readText(t) } catch { before = null }
+    }
+    await this.atomicWrite(t.targetKey, content)
+    const after = await this.stat(t)
+    return { operation: existing === undefined ? 'create' : 'update', version: after.version, before, after: content }
+  }
+
+  async editText(target, edit, expected, signal, sandboxPolicy) {
+    const t = await this.checkedTarget(target, sandboxPolicy)
+    const existing = await this.stat(t)
+    if (existing === undefined) throw fsError('FS_STALE_VERSION', `cannot edit "${t.displayPath}": file changed since it was read`)
+    if (existing.type !== 'file') throw fsError('FS_NOT_REGULAR_FILE', `cannot edit "${t.displayPath}": not a regular file`)
+    if (expected && existing.version !== expected.version) {
+      throw fsError('FS_STALE_VERSION', `cannot edit "${t.displayPath}": file changed since it was read`)
+    }
+    const content = await this.readText(t)
+    const oldString = edit.oldString
+    if (!oldString) throw fsError('FS_EDIT_NOT_FOUND', `cannot edit "${t.displayPath}": old_string must be non-empty`)
+    let matches = 0
+    let offset = 0
+    while (true) {
+      const found = content.indexOf(oldString, offset)
+      if (found < 0) break
+      matches += 1
+      offset = found + oldString.length
+    }
+    if (matches === 0) throw fsError('FS_EDIT_NOT_FOUND', `cannot edit "${t.displayPath}": old_string was not found`)
+    if (!edit.replaceAll && matches !== 1) {
+      throw fsError('FS_AMBIGUOUS_EDIT', `cannot edit "${t.displayPath}": old_string matched ${matches} times`)
+    }
+    const next = edit.replaceAll ? content.split(oldString).join(edit.newString) : content.replace(oldString, edit.newString)
+    await this.atomicWrite(t.targetKey, next)
+    const after = await this.stat(t)
+    return { version: after.version, before: content, after: next }
+  }
+
+  /**
+   * Enforce the per-call sandbox policy against `target` (mirrors the harness's
+   * `@deepseek-ai/dsh-fs-sandbox` fence). No policy service or
+   * `danger-full-access` → target unchanged; `read-only` → deny;
+   * `workspace-write` → re-canonicalize and require containment under a
+   * writable root.
+   */
+  async checkedTarget(target, sandboxPolicy) {
+    const policy = sandboxPolicy ?? this.getPolicy?.()?.resolve?.()
+    if (policy === undefined) return target
+    const { mode } = policy
+    if (mode === 'danger-full-access') return target
+    if (mode === 'read-only') {
+      throw fsError('FS_SANDBOX_DENIED', `cannot write "${target.displayPath}": file access denied under read-only mode`)
+    }
+    const fresh = await this.resolve(target.displayPath)
+    let contained = false
+    for (const root of writableRoots(policy)) {
+      if (await isPathUnder(fresh.targetKey, root)) { contained = true; break }
+    }
+    if (!contained) {
+      throw fsError('FS_SANDBOX_DENIED', `cannot write "${target.displayPath}": file access denied under workspace-write mode`)
+    }
+    return fresh
+  }
+
+  async atomicWrite(targetKey, content) {
+    const tmp = join(dirname(targetKey), `.dsh-${basename(targetKey)}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+    try {
+      await writeFile(tmp, content, 'utf8')
+      await rename(tmp, targetKey)
+    } catch (error) {
+      await rm(tmp, { force: true }).catch(() => {})
+      throw fsError('FS_IO_ERROR', `cannot write "${targetKey}": ${error.message}`, error)
+    }
+  }
+}
+
+export default LocalBackend

package/src/machine-store.js

@@ -0,0 +1,238 @@
+import { randomUUID, randomBytes, createCipheriv, createDecipheriv } from 'node:crypto'
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+
+/**
+ * Persistent multi-machine SSH registry, stored as a local JSON file under
+ * the DSH home (matching the harness's own data location):
+ *
+ *   <dsh-home>/remote-workspaces/machines.json
+ *
+ * Secrets (`password`, `passphrase`) are AES-256-GCM encrypted at rest with a
+ * key kept in a separate file (`<dsh-home>/remote-workspaces/.secret-key`), so
+ * a plaintext dump of machines.json never exposes them. They are decrypted only
+ * in memory and never sent back to the browser — `sanitizeMachine` strips them,
+ * exposing only a `hasPassword`/`hasPassphrase` flag. On POSIX both files are
+ * chmod'd 0600; on Windows the OS ACL applies (the encrypted form still stops
+ * casual/grep-style disclosure). Legacy plaintext secrets are read transparently
+ * and re-encrypted on the next write (see `ensureSecretsEncrypted`).
+ */
+
+const SECRET_PREFIX = 'enc:v1:'
+const KEY_NAME = '.secret-key'
+
+function expandHomePath(value) {
+  if (value === '~') return homedir()
+  if (value.startsWith('~/') || value.startsWith('~\\')) return join(homedir(), value.slice(2))
+  return value
+}
+
+/** Mirror of the harness's `resolveDshHome()`: `$DSH_HOME` (non-blank) else `~/.dsh`. */
+export function machinesRoot() {
+  const fromEnv = process.env.DSH_HOME
+  const selected = fromEnv !== undefined && String(fromEnv).trim().length > 0
+    ? fromEnv
+    : join(homedir(), '.dsh')
+  return resolve(expandHomePath(selected))
+}
+
+export function machinesPath() {
+  return join(machinesRoot(), 'remote-workspaces', 'machines.json')
+}
+
+function keyPath() {
+  return join(machinesRoot(), 'remote-workspaces', KEY_NAME)
+}
+
+/**
+ * Load (or create) the local 32-byte encryption key. Creating it on first use
+ * keeps it out of the registry file itself; a machine that loses the key file
+ * simply cannot decrypt old secrets (a fresh key is created and the user
+ * re-enters the credentials).
+ */
+function loadKey() {
+  const path = keyPath()
+  try {
+    const hex = readFileSync(path, 'utf8').trim()
+    const buf = Buffer.from(hex, 'hex')
+    if (buf.length === 32) return buf
+  } catch {}
+  const key = randomBytes(32)
+  try {
+    mkdirSync(dirname(path), { recursive: true })
+    writeFileSync(path, key.toString('hex') + '\n', { encoding: 'utf8', mode: 0o600 })
+    try { chmodSync(path, 0o600) } catch {}
+  } catch {}
+  return key
+}
+
+/** `enc:v1:<iv><tag><ciphertext>` (base64) for a non-empty, not-yet-encrypted secret. */
+function encryptSecret(value) {
+  if (value === undefined || value === null) return value
+  const s = String(value)
+  if (s === '' || s.startsWith(SECRET_PREFIX)) return s
+  const key = loadKey()
+  const iv = randomBytes(12)
+  const cipher = createCipheriv('aes-256-gcm', key, iv)
+  const enc = Buffer.concat([cipher.update(s, 'utf8'), cipher.final()])
+  const tag = cipher.getAuthTag()
+  return SECRET_PREFIX + Buffer.concat([iv, tag, enc]).toString('base64')
+}
+
+/** Decrypt an `enc:` secret; pass legacy plaintext through; `undefined` on failure. */
+function decryptSecret(value) {
+  if (typeof value !== 'string' || !value.startsWith(SECRET_PREFIX)) return value
+  try {
+    const key = loadKey()
+    const raw = Buffer.from(value.slice(SECRET_PREFIX.length), 'base64')
+    if (raw.length < 28) return undefined
+    const iv = raw.subarray(0, 12)
+    const tag = raw.subarray(12, 28)
+    const enc = raw.subarray(28)
+    const decipher = createDecipheriv('aes-256-gcm', key, iv)
+    decipher.setAuthTag(tag)
+    return Buffer.concat([decipher.update(enc), decipher.final()]).toString('utf8')
+  } catch {
+    return undefined
+  }
+}
+
+function encryptMachineSecrets(machine) {
+  const out = { ...machine }
+  for (const field of ['password', 'passphrase']) {
+    if (out[field] === undefined) continue
+    out[field] = encryptSecret(out[field])
+  }
+  return out
+}
+
+function decryptMachineSecrets(machine) {
+  const out = { ...machine }
+  for (const field of ['password', 'passphrase']) {
+    if (out[field] === undefined || out[field] === null) continue
+    const plain = decryptSecret(out[field])
+    if (plain === undefined) delete out[field]
+    else out[field] = plain
+  }
+  return out
+}
+
+function isPlainSecret(value) {
+  return typeof value === 'string' && value.length > 0 && !value.startsWith(SECRET_PREFIX)
+}
+
+export function loadMachines() {
+  const path = machinesPath()
+  if (!existsSync(path)) return []
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'))
+    const machines = parsed && typeof parsed === 'object' ? parsed.machines : undefined
+    return Array.isArray(machines)
+      ? machines.filter((m) => m && typeof m === 'object').map(decryptMachineSecrets)
+      : []
+  } catch {
+    return []
+  }
+}
+
+function persistMachines(machines) {
+  const path = machinesPath()
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, JSON.stringify({ machines: machines.map(encryptMachineSecrets) }, null, 2) + '\n', 'utf8')
+  try { chmodSync(path, 0o600) } catch {}
+}
+
+/**
+ * One-time migration: if the on-disk registry still holds plaintext secrets,
+ * re-persist it (which encrypts them). Called once at plugin startup so an
+ * existing install becomes secure without the user having to edit a host.
+ * Returns true when a rewrite happened.
+ */
+export function ensureSecretsEncrypted() {
+  const path = machinesPath()
+  if (!existsSync(path)) return false
+  try {
+    const raw = JSON.parse(readFileSync(path, 'utf8'))
+    const machines = raw && typeof raw === 'object' ? raw.machines : undefined
+    if (!Array.isArray(machines)) return false
+    const hasPlain = machines.some((m) => m && typeof m === 'object' && (
+      isPlainSecret(m.password) || isPlainSecret(m.passphrase)
+    ))
+    if (!hasPlain) return false
+    persistMachines(machines)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** Projection safe to cross the Remote boundary (no password, no passphrase). */
+export function sanitizeMachine(machine) {
+  return {
+    id: machine.id,
+    alias: machine.alias ?? '',
+    host: machine.host ?? '',
+    port: machine.port ?? null,
+    user: machine.user ?? null,
+    identityFile: machine.identityFile ?? null,
+    hasPassword: Boolean(machine.password),
+    hasPassphrase: Boolean(machine.passphrase),
+  }
+}
+
+/**
+ * Insert or update one machine by id. A missing id creates a new machine.
+ * `password`/`passphrase` are one-way writes: an empty string clears the stored
+ * secret, and `undefined`/absent leaves the existing value untouched.
+ */
+export function upsertMachine(input) {
+  const machines = loadMachines()
+  let machine = input.id === undefined ? undefined : machines.find((m) => m.id === input.id)
+  if (machine === undefined) {
+    machine = { id: randomUUID() }
+    machines.push(machine)
+  }
+  if (input.alias !== undefined) machine.alias = String(input.alias ?? '')
+  if (input.host !== undefined) machine.host = String(input.host ?? '')
+  if (input.port !== undefined) machine.port = input.port === null || input.port === '' ? null : Number(input.port) || null
+  if (input.user !== undefined) machine.user = input.user === null || input.user === '' ? null : String(input.user)
+  if (input.identityFile !== undefined) {
+    machine.identityFile = input.identityFile === null || input.identityFile === '' ? null : String(input.identityFile)
+  }
+  if (input.password === '') delete machine.password
+  else if (input.password !== undefined) machine.password = String(input.password)
+  if (input.passphrase === '') delete machine.passphrase
+  else if (input.passphrase !== undefined) machine.passphrase = String(input.passphrase)
+  persistMachines(machines)
+  return sanitizeMachine(machine)
+}
+
+export function removeMachine(id) {
+  const machines = loadMachines()
+  const next = machines.filter((m) => m.id !== id)
+  persistMachines(next)
+  return next.length !== machines.length
+}
+
+/** The raw record (with secrets) used to build an SSH connection. */
+export function machineById(id) {
+  return loadMachines().find((m) => m.id === id)
+}
+
+/**
+ * Find a saved machine by its connection identity (host + user + effective
+ * port). Mirrors record only these fields in their `.dsh-remote-meta.json`,
+ * so reconnecting for sync matches them back to a stored machine (and its
+ * secret) this way, surviving machine id churn.
+ */
+export function machineForRemote({ host, port, user }) {
+  const h = String(host ?? '')
+  const u = String(user ?? '')
+  const p = Number(port) || 22
+  return loadMachines().find((m) => {
+    return String(m.host ?? '') === h
+      && String(m.user ?? '') === u
+      && (Number(m.port) || 22) === p
+  })
+}

package/src/registry.js

@@ -0,0 +1,76 @@
+/**
+ * Remote-workspace registry: the durable map from a LOCAL anchor directory to
+ * its remote origin (machine + remote path). This is the routing key the
+ * `RoutingFileSystem` and `SshShellExecutor` consult per session cwd.
+ *
+ * An anchor is an EMPTY local directory adopted by the harness as the
+ * workspace identity (`fs.realpath` must resolve it); all file/command I/O is
+ * routed to the remote, never through the anchor's contents.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join, sep } from 'node:path'
+import { remoteWorkspacesRoot } from './anchor.js'
+
+function anchorsPath() {
+  return join(remoteWorkspacesRoot(), 'anchors.json')
+}
+
+/** Load the anchor map (anchorPath → record). Returns {} when absent. */
+export function loadAnchors() {
+  const file = anchorsPath()
+  if (!existsSync(file)) return {}
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8'))
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {}
+  } catch {
+    return {}
+  }
+}
+
+function saveAnchors(anchors) {
+  const root = remoteWorkspacesRoot()
+  try { mkdirSync(root, { recursive: true }) } catch {}
+  writeFileSync(anchorsPath(), JSON.stringify(anchors, null, 2) + '\n', 'utf8')
+}
+
+/** Record an anchor (idempotent by anchorPath). Returns the stored record. */
+export function registerAnchor({ anchorPath, machineId, host, port, user, remotePath }) {
+  const anchors = loadAnchors()
+  anchors[anchorPath] = { machineId, host, port, user, remotePath, registeredAt: new Date().toISOString() }
+  saveAnchors(anchors)
+  return anchors[anchorPath]
+}
+
+/** Remove one anchor by its local path. */
+export function unregisterAnchor(anchorPath) {
+  const anchors = loadAnchors()
+  delete anchors[anchorPath]
+  saveAnchors(anchors)
+}
+
+/**
+ * Resolve a session cwd (the anchor path, or any descendant) to its remote
+ * origin. Returns `{ anchorPath, remotePath, remoteSubpath, host, port, user, machineId }`
+ * or `undefined` when the cwd is not under any registered anchor.
+ */
+export function findByCwd(cwd) {
+  if (typeof cwd !== 'string' || cwd === '') return undefined
+  const anchors = loadAnchors()
+  let best
+  let bestLen = -1
+  for (const [anchorPath, rec] of Object.entries(anchors)) {
+    const base = anchorPath.endsWith(sep) ? anchorPath : anchorPath + sep
+    if (cwd === anchorPath || cwd.startsWith(base)) {
+      if (anchorPath.length > bestLen) {
+        bestLen = anchorPath.length
+        best = { anchorPath, ...rec }
+      }
+    }
+  }
+  if (best === undefined) return undefined
+  const rel = cwd === best.anchorPath ? '' : cwd.slice(best.anchorPath.length + sep.length)
+  return { ...best, remoteSubpath: rel === '' ? '' : rel.split(sep).join('/') }
+}
+
+export default { loadAnchors, registerAnchor, unregisterAnchor, findByCwd, remoteWorkspacesRoot }