dsh-dbhub-live 5.0.1 → 5.2.0-dev.3

package/lib/config.mjs

@@ -2,8 +2,10 @@
 // resolution. Pure module — every function takes the services it needs as
 // arguments, so this file never imports a Cordis service.
 
-import { readFileSync, writeFileSync, renameSync, mkdirSync } from 'node:fs'
+import { readFileSync, writeFileSync, renameSync, mkdirSync, existsSync } from 'node:fs'
 import { join, basename, dirname } from 'node:path'
+// i18n.mjs imports nothing (a leaf), so this cannot create a cycle.
+import { currentT } from './i18n.mjs'
 
 export function dshHomeDir() {
   if (process.env.DSH_HOME) return process.env.DSH_HOME
@@ -14,7 +16,7 @@ export const DATA_DIR = join(dshHomeDir(), 'storages', 'dsh-dbhub-live')
 export const STORE_PATH = join(DATA_DIR, 'credentials.json')
 export const RUNTIME_DIR = join(DATA_DIR, 'dbhub-runtime')
 export const RUNTIME_PATH = join(DATA_DIR, 'runtime.json')
-// UI preferences owned by the card (`updateIntervalDays`, `showSidebarEntry`).
+// UI preferences owned by the card (`updateIntervalDays`).
 // On dsh >= 0.1.7 there is no settings namespace to keep them in, and the
 // profile entry id needed to write the plugin's Config form is deployment
 // owned, so the plugin persists them itself; on 0.1.x the settings document
@@ -116,8 +118,11 @@ export function normalizeStore(raw) {
 
 /**
  * List every persisted workspace environment as flat rows for the card.
+ * Each row also carries the environment's options: `ro` (read-only) and `ssh`
+ * (the normalized tunnel config, SECRETS INCLUDED — this is host-side data and
+ * every model/UI-facing copy goes through `describeEnvOptions`).
  * @param store - the (normalized) credentials store.
- * @returns rows [{ wsPath, env, dsn, source?, updatedAt?, persisted: true }].
+ * @returns rows [{ wsPath, env, dsn, source?, updatedAt?, ro, ssh, persisted: true }].
  */
 export function listWorkspaceEnvironments(store) {
   const rows = []
@@ -132,6 +137,8 @@ export function listWorkspaceEnvironments(store) {
         dsn: envEntry.dsn.trim(),
         ...(typeof envEntry.source === 'string' && envEntry.source ? { source: envEntry.source } : {}),
         ...(typeof envEntry.updatedAt === 'number' && Number.isFinite(envEntry.updatedAt) ? { updatedAt: envEntry.updatedAt } : {}),
+        ro: readOnlyOf(envEntry),
+        ssh: sshOf(envEntry),
         persisted: true,
       })
     }
@@ -139,12 +146,253 @@ export function listWorkspaceEnvironments(store) {
   return rows
 }
 
+// ── environment options: read-only + SSH tunnel (store model v3) ──────────
+//
+// v3 keeps the exact v2 layout and merely adds two optional fields to an
+// environment entry:
+//   { dsn, source, updatedAt, readOnly?: true, ssh?: {…} }
+// Compatibility is structural, not versioned: `normalizeStore` already
+// preserves unknown env fields (so an older build reading a v3 file keeps the
+// new keys instead of stripping them), and a v2 file simply reads back as
+// "not read-only, no tunnel".
+//
+// SSH secrets (`password`, `passphrase`) sit next to `dsn` and share its trust
+// model (same file, same 0600-by-user-directory guarantee).
+
+/** Longest accepted values (a hand-edited file cannot inject a huge blob). */
+const SSH_LIMITS = { host: 255, user: 128, keyPath: 1024, secret: 512, proxyJump: 1024 }
+
+function sshText(value, max) {
+  const raw = String(value === undefined || value === null ? '' : value)
+    .replace(/[\u0000-\u001f\u007f]/g, '')
+    .trim()
+  if (!raw) return ''
+  return raw.slice(0, max)
+}
+
+/** Integer port in 1..65535, or the default. */
+function sshPort(value, fallback) {
+  const n = Number(String(value === undefined || value === null ? '' : value).trim())
+  if (!Number.isInteger(n) || n < 1 || n > 65535) return fallback
+  return n
+}
+
+/**
+ * Number of hops a ProxyJump list names. dbhub's `ssh_proxy_jump` is a
+ * comma-separated ProxyJump list that SHARES one credential set across every
+ * hop, so a real multi-hop route (different credentials per jump host) cannot
+ * be expressed — this plugin supports single-hop only and says so.
+ */
+export function sshProxyJumpHops(value) {
+  const raw = sshText(value, SSH_LIMITS.proxyJump)
+  if (!raw) return 0
+  return raw.split(',').map((s) => s.trim()).filter(Boolean).length
+}
+
+/**
+ * Normalize one SSH tunnel block. Returns `null` for anything that cannot be
+ * used (missing host/user, unknown auth kind, a missing credential for the
+ * chosen kind, a multi-hop ProxyJump, …) — the caller turns that into a
+ * localized, actionable message.
+ *
+ * Secrets are carried verbatim: they were either typed in the UI dialog or are
+ * being preserved from the stored entry.
+ *
+ * @param raw - `{ host, port?, user, auth, keyPath?, password?, passphrase?, proxyJump? }`.
+ * @returns the normalized block, or `null`.
+ */
+export function normalizeSshOptions(raw) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null
+  const host = sshText(raw.host, SSH_LIMITS.host)
+  const user = sshText(raw.user, SSH_LIMITS.user)
+  if (!host || !user) return null
+  const auth = raw.auth === 'password' ? 'password' : raw.auth === 'key' ? 'key' : ''
+  if (!auth) return null
+  const out = { host, port: sshPort(raw.port, 22), user, auth }
+  const proxyJump = sshText(raw.proxyJump, SSH_LIMITS.proxyJump)
+  if (sshProxyJumpHops(proxyJump) > 1) return null
+  if (proxyJump) out.proxyJump = proxyJump
+  if (auth === 'key') {
+    const keyPath = sshText(raw.keyPath, SSH_LIMITS.keyPath)
+    if (!keyPath) return null
+    out.keyPath = keyPath
+    const passphrase = String(raw.passphrase === undefined || raw.passphrase === null ? '' : raw.passphrase)
+    if (passphrase) out.passphrase = passphrase.slice(0, SSH_LIMITS.secret)
+  } else {
+    const password = String(raw.password === undefined || raw.password === null ? '' : raw.password)
+    if (!password) return null
+    out.password = password.slice(0, SSH_LIMITS.secret)
+  }
+  return out
+}
+
+/** The stored read-only flag of one environment entry (`false` when unset). */
+export function readOnlyOf(envEntry) {
+  return !!(envEntry && typeof envEntry === 'object' && envEntry.readOnly === true)
+}
+
+/** The stored, normalized SSH block of one environment entry (or null). */
+export function sshOf(envEntry) {
+  if (!envEntry || typeof envEntry !== 'object') return null
+  return normalizeSshOptions(envEntry.ssh)
+}
+
+/**
+ * The identity file an SSH client falls back to when none is given — the same
+ * value the UI shows as the key-path placeholder.
+ */
+export const DEFAULT_SSH_KEY_PATH = '~/.ssh/id_ed25519'
+
+/**
+ * Fill the conventional identity path into a key-auth block that names none.
+ *
+ * Without this a key-auth tunnel with a blank path is simply UNUSABLE
+ * (`normalizeSshOptions` rejects it), so the placeholder the field shows would be
+ * a promise the plugin never keeps. Applied at the last step of a merge and right
+ * before an SSH-layer test, never to a block that already names a path.
+ * @returns the same object when nothing was filled (identity check is meaningful).
+ */
+export function withDefaultSshKey(block) {
+  if (!block || typeof block !== 'object' || Array.isArray(block)) return block
+  if (block.auth !== 'key') return block
+  const named = block.keyPath !== undefined && block.keyPath !== null && String(block.keyPath).trim() !== ''
+  if (named) return block
+  return Object.assign({}, block, { keyPath: DEFAULT_SSH_KEY_PATH })
+}
+
+/**
+ * Merge an incoming tunnel block with the stored one, implementing the
+ * "blank secret = keep the stored value" rule for the BROWSER path.
+ *
+ * The UI can never echo a secret back (the mirror only carries
+ * `hasPassword`/`hasPassphrase`/`keyReady`), so a user who edits only the host —
+ * or presses "test the tunnel" on a saved row — sends a block without a
+ * password. Normalizing that directly would reject it, which is why the COMMAND
+ * layer merges first (the model path does the same in `tools.mjs`).
+ *
+ * Non-secret fields overwrite (a blank one falls back to the stored value so the
+ * merge cannot produce an unusable block); switching the auth kind drops the
+ * other kind's secret.
+ *
+ * @param incoming - the block from the card (secrets possibly blank/omitted).
+ * @param storedRaw - the stored raw block (or null).
+ * @returns the merged raw block (still to be normalized/validated).
+ */
+export function mergeSshOptions(incoming, storedRaw) {
+  if (!incoming || typeof incoming !== 'object' || Array.isArray(incoming)) return incoming
+  const prev = normalizeSshOptions(storedRaw)
+  const filled = (v) => v !== undefined && v !== null && String(v).trim() !== ''
+  const auth = incoming.auth === 'password' || incoming.auth === 'key'
+    ? incoming.auth
+    : (prev ? prev.auth : '')
+  const merged = {
+    host: filled(incoming.host) ? incoming.host : (prev ? prev.host : ''),
+    port: filled(incoming.port) ? incoming.port : (prev ? prev.port : 22),
+    user: filled(incoming.user) ? incoming.user : (prev ? prev.user : ''),
+    auth,
+    proxyJump: incoming.proxyJump !== undefined && incoming.proxyJump !== null
+      ? incoming.proxyJump
+      : (prev ? prev.proxyJump || '' : ''),
+  }
+  if (auth === 'key') {
+    const sameKind = !!(prev && prev.auth === 'key')
+    const keyPath = filled(incoming.keyPath) ? incoming.keyPath : (sameKind ? prev.keyPath : '')
+    if (keyPath) merged.keyPath = keyPath
+    const passphrase = filled(incoming.passphrase) ? incoming.passphrase : (sameKind ? prev.passphrase : '')
+    if (passphrase) merged.passphrase = passphrase
+  } else if (auth === 'password') {
+    const sameKind = !!(prev && prev.auth === 'password')
+    const password = filled(incoming.password) ? incoming.password : (sameKind ? prev.password : '')
+    if (password) merged.password = password
+  }
+  return withDefaultSshKey(merged)
+}
+
+/** Expand a leading `~/` the way dbhub does, for local key-existence checks. */
+export function expandHome(p) {
+  const raw = String(p || '')
+  if (!raw.startsWith('~/') && !raw.startsWith('~\\')) return raw
+  const home = process.env.HOME || process.env.USERPROFILE || ''
+  if (!home) return raw
+  return join(home, raw.slice(2))
+}
+
+/**
+ * Secret-free description of an environment's options. This is the ONLY shape
+ * the browser mirror and the model-facing surface may see: booleans for "does a
+ * secret exist" and never the secret itself, and never the key PATH either
+ * (only whether it resolves to a readable file).
+ */
+export function describeEnvOptions(envEntry) {
+  const ro = readOnlyOf(envEntry)
+  const ssh = sshOf(envEntry)
+  if (!ssh) return { ro, ssh: null }
+  let keyReady = false
+  if (ssh.auth === 'key') {
+    try {
+      keyReady = !!ssh.keyPath && existsSync(expandHome(ssh.keyPath))
+    } catch (e) {
+      keyReady = false
+    }
+  }
+  return {
+    ro,
+    ssh: {
+      host: ssh.host,
+      port: ssh.port,
+      user: ssh.user,
+      authKind: ssh.auth,
+      hasPassword: !!ssh.password,
+      hasPassphrase: !!ssh.passphrase,
+      keyReady,
+      proxyJump: ssh.proxyJump || '',
+    },
+  }
+}
+
+/**
+ * Copy the previous entry's option fields onto a freshly built entry, applying
+ * an explicit patch when one is given.
+ *
+ * Semantics (D4): an OMITTED patch preserves whatever the entry had — a plain
+ * `dbhub_configure` DSN update must never silently drop the read-only flag or
+ * the tunnel. An explicit `false` / `null` DELETES the field.
+ */
+function applyEnvOptions(target, previous, opts) {
+  if (!opts || typeof opts !== 'object') {
+    if (previous && previous.readOnly === true) target.readOnly = true
+    const ssh = sshOf(previous)
+    if (ssh) target.ssh = ssh
+    return target
+  }
+  if (opts.readOnly === true) target.readOnly = true
+  else if (opts.readOnly === undefined && previous && previous.readOnly === true) target.readOnly = true
+  if (opts.ssh !== undefined) {
+    // `withDefaultSshKey` first: a key-auth block with a blank path means the
+    // conventional identity file (what the field's placeholder shows), and it must
+    // SAVE the same way it TESTS — otherwise a successful tunnel test is followed
+    // by a silent save that drops the tunnel.
+    const ssh = opts.ssh === null ? null : normalizeSshOptions(withDefaultSshKey(opts.ssh))
+    if (ssh) target.ssh = ssh
+  } else {
+    const ssh = sshOf(previous)
+    if (ssh) target.ssh = ssh
+  }
+  return target
+}
+
 /**
  * Persist one workspace environment (creates or overwrites). The workspace
- * entry becomes `{ environments: { <env>: { dsn, source, updatedAt } } }`.
+ * entry becomes `{ environments: { <env>: { dsn, source, updatedAt, … } } }`.
+ *
+ * `opts` = `{ readOnly?: boolean|null, ssh?: object|null }`. When it is
+ * OMITTED the entry's existing read-only / tunnel options are PRESERVED (a
+ * DSN-only update must not clear a user's safety switch); `readOnly: false` and
+ * `ssh: null` delete the field.
+ *
  * @returns the stored environment name ('default' when blank).
  */
-export function setWorkspaceEnv(wsPath, env, dsn, source) {
+export function setWorkspaceEnv(wsPath, env, dsn, source, opts) {
   const entry = store[wsPath] && typeof store[wsPath] === 'object' && !Array.isArray(store[wsPath])
     ? store[wsPath]
     : {}
@@ -154,12 +402,53 @@ export function setWorkspaceEnv(wsPath, env, dsn, source) {
   const name = normalizeEnvName(env)
   const cleanDsn = String(dsn).trim()
   if (!cleanDsn) throw new TypeError('DSN 不能为空')
-  environments[name] = { dsn: cleanDsn, source: String(source || 'user'), updatedAt: Date.now() }
+  const previous = environments[name]
+  const next = { dsn: cleanDsn, source: String(source || 'user'), updatedAt: Date.now() }
+  applyEnvOptions(next, previous, opts)
+  environments[name] = next
+  store[wsPath] = { environments }
+  saveStore(store)
+  return name
+}
+
+/**
+ * Change ONLY the options of an existing environment — the DSN, its source and
+ * its updatedAt are left exactly as they were (the UI's "toggle read-only" and
+ * "configure the tunnel" writes have no connection data to offer, and requiring
+ * one would make the user re-type a password to flip a checkbox).
+ *
+ * @param patch - `{ readOnly?: boolean, ssh?: object|null }` (only the keys
+ *   present are touched).
+ * @returns the environment name, or `undefined` when no such persisted row
+ *   exists (the caller decides whether to promote an auto-discovered row).
+ */
+export function setWorkspaceEnvOptions(wsPath, env, patch) {
+  const entry = store[wsPath]
+  if (!entry || typeof entry !== 'object' || !entry.environments || typeof entry.environments !== 'object') return undefined
+  const name = normalizeEnvName(env)
+  const current = entry.environments[name]
+  if (!current || typeof current.dsn !== 'string' || !current.dsn.trim()) return undefined
+  const environments = { ...entry.environments }
+  const next = { ...current, updatedAt: Date.now() }
+  if (patch && typeof patch === 'object') {
+    if (patch.readOnly === true) next.readOnly = true
+    else if (patch.readOnly === false) delete next.readOnly
+    if (patch.ssh !== undefined) {
+      if (patch.ssh === null) delete next.ssh
+      else {
+        const ssh = normalizeSshOptions(withDefaultSshKey(patch.ssh))
+        if (!ssh) return undefined
+        next.ssh = ssh
+      }
+    }
+  }
+  environments[name] = next
   store[wsPath] = { environments }
   saveStore(store)
   return name
 }
 
+
 /**
  * Rename one persisted environment IN PLACE: the DSN, its source provenance
  * and the connection itself move with the name, so no credential is ever
@@ -293,13 +582,26 @@ export function normalizePrefs(raw) {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return out
   const days = raw.updateIntervalDays
   if (typeof days === 'number' && Number.isFinite(days) && days >= 0) defineOwn(out, 'updateIntervalDays', days)
+  // The user's own "hide the sidebar entry" preference. It is INDEPENDENT of the
+  // plugin's enabled state: hiding the shortcut does not turn the plugin off,
+  // and the client ANDs the two (a disabled plugin contributes no entry at all).
   if (typeof raw.showSidebarEntry === 'boolean') defineOwn(out, 'showSidebarEntry', raw.showSidebarEntry)
+  // The user's own "announce the database-access policy to the model" preference.
+  // Turning it off removes one system-prompt section; no tool changes behavior.
+  if (typeof raw.announceAccessPolicy === 'boolean') defineOwn(out, 'announceAccessPolicy', raw.announceAccessPolicy)
   return out
 }
 
 /** Load the persisted UI options; a missing or unreadable file is `{}`. */
 export function loadPrefs() {
-  return normalizePrefs(readJsonFile(PREFS_PATH, {}))
+  const raw = readJsonFile(PREFS_PATH, {})
+  const normalized = normalizePrefs(raw)
+  // One-time migration, mirroring loadStore/loadRuntime: a legacy key (or a
+  // hand-edited value that fails its validator) is dropped from DISK on the
+  // first boot, so the file never keeps advertising an option this build does
+  // not have — a removed `showSidebarEntry` must not look configurable again.
+  if (JSON.stringify(raw) !== JSON.stringify(normalized)) writeJsonFile(PREFS_PATH, normalized)
+  return normalized
 }
 
 /** Persist the UI options atomically; returns whether it succeeded. */
@@ -405,7 +707,7 @@ export function describeConn(dsn) {
  */
 export function connLabel(dsn) {
   const c = describeConn(dsn)
-  if (!c.type) return String(dsn || '').trim() || '(未知连接)'
+  if (!c.type) return String(dsn || '').trim() || currentT('result.unknownConn')
   if (c.type === 'sqlite' && c.database) {
     return 'sqlite:///' + c.database.replace(/\\/g, '/')
   }
@@ -448,19 +750,35 @@ export function dsnUser(dsn) {
 
 /**
  * Defense-in-depth scrubber for text that originates from dbhub (results,
- * stderr tails, error messages): replaces the known DSN's password and full
- * DSN occurrences, plus generic `password=` / `passwd=` tokens, so a leak from
- * the MCP server can never reach the model. Passwords and usernames never
- * cross.
+ * stderr tails, error messages): replaces the known DSN's password and the
+ * userinfo of every URL-shaped DSN occurrence, plus generic `password=` /
+ * `passwd=` tokens, so a leak from the MCP server can never reach the model.
+ * Passwords AND usernames never cross.
+ *
+ * dbhub's own startup banner prints the DSN with only the password masked
+ * (`mysql://root:****@host:3306/db`), which is exactly the text that lands in a
+ * connection-test diagnostic — hence the userinfo is collapsed as a whole, not
+ * just the password.
+ *
+ * `extraSecrets` carries the secrets a generated TOML put in the child
+ * environment (the SSH login password / key passphrase): dbhub may echo them in
+ * its own diagnostics, so they are replaced like the DSN password.
  */
-export function scrubSecrets(text, dsn) {
+export function scrubSecrets(text, dsn, extraSecrets) {
   let out = String(text || '')
   const pass = dsnPassword(dsn)
-  if (pass && pass !== '****') {
-    out = out.split(pass).join('****')
-    out = out.replace(/(:\/\/[^:/@]+:)[^@]+(@)/g, '$1****$2')
+  if (pass && pass !== '****') out = out.split(pass).join('****')
+  const extras = Array.isArray(extraSecrets) ? extraSecrets : []
+  for (const secret of extras) {
+    const s = String(secret === undefined || secret === null ? '' : secret)
+    if (!s) continue
+    out = out.split(s).join('****')
   }
   out = out.replace(/(password|passwd|pwd)\s*(:|=)\s*["']?[^"'\s,;]+/gi, '$1$2****')
+  // Userinfo of a URL-shaped connection string: `://user:pass@` and `://user@`.
+  // Runs LAST so it also covers a DSN that arrived through an `extraSecrets`
+  // replacement, and it is unconditional because the username is a secret too.
+  out = out.replace(/(:\/\/)[^/@\s]+@/g, '$1****:****@')
   return out
 }
 
@@ -640,17 +958,39 @@ export async function runMiseEnv(subprocess, cwd, signal, timeoutMs) {
 // `mise env` — which may be slow, or need the timeout above — for the same
 // directory over and over was the dominant cost of both. A config file edited by
 // hand is picked up again after at most AUTO_DSN_TTL_MS.
+//
+// The cache stores RESULTS, so an in-flight probe must ALSO be de-duplicated:
+// the card's publish, the model's list and a connection test can all request the
+// same directory within the same second, and each one used to spawn its own
+// `mise env`. A rejection is deliberately NOT cached — the next caller must be
+// able to really retry.
+const autoDsnInFlight = new Map()
+
 async function resolveAutoDsn(subprocess, fs, wsPath, signal) {
   const cached = autoDsnCache.get(wsPath)
   if (cached && Date.now() - cached.at < AUTO_DSN_TTL_MS) return cached.value
-  const value = await probeAutoDsn(subprocess, fs, wsPath, signal)
-  autoDsnCache.set(wsPath, { at: Date.now(), value })
-  return value
+  const inFlight = autoDsnInFlight.get(wsPath)
+  if (inFlight) return inFlight
+  const run = probeAutoDsn(subprocess, fs, wsPath, signal).then(
+    (value) => {
+      autoDsnCache.set(wsPath, { at: Date.now(), value })
+      return value
+    },
+  )
+  autoDsnInFlight.set(wsPath, run)
+  try {
+    return await run
+  } finally {
+    // Clear the in-flight handle on BOTH paths: a cached rejection would turn
+    // every later call into "the connection was never discovered".
+    if (autoDsnInFlight.get(wsPath) === run) autoDsnInFlight.delete(wsPath)
+  }
 }
 
 /** Forget every cached auto-discovery result (tests, and explicit rescans). */
 export function resetAutoDsnCache() {
   autoDsnCache.clear()
+  autoDsnInFlight.clear()
 }
 
 async function probeAutoDsn(subprocess, fs, wsPath, signal) {
@@ -686,12 +1026,21 @@ export async function resolveWorkspaceEnvs(subprocess, fs, wsPath, signal) {
   const out = []
   for (const [env, envEntry] of Object.entries(persisted)) {
     if (envEntry && typeof envEntry.dsn === 'string' && envEntry.dsn.trim()) {
-      out.push({ env, dsn: envEntry.dsn.trim(), source: 'persisted(' + (envEntry.source || 'user') + ')' })
+      out.push({
+        env,
+        dsn: envEntry.dsn.trim(),
+        source: 'persisted(' + (envEntry.source || 'user') + ')',
+        ro: readOnlyOf(envEntry),
+        ssh: sshOf(envEntry),
+      })
     }
   }
   if (!Object.prototype.hasOwnProperty.call(persisted, 'default')) {
     const auto = await resolveAutoDsn(subprocess, fs, wsPath, signal)
-    if (auto) out.push({ env: 'default', dsn: auto.dsn, source: auto.source })
+    // An auto-discovered row has no store entry, therefore no options: it is
+    // never read-only and never tunnelled until the user (or the model) sets an
+    // option, which promotes it to a persisted row (D10).
+    if (auto) out.push({ env: 'default', dsn: auto.dsn, source: auto.source, ro: false, ssh: null })
   }
   return out
 }