dsh-dbhub-live 3.0.0 → 3.1.2

package/lib/mcp.mjs

@@ -9,13 +9,16 @@
 // disposers (the source of truth for the registered-tool count).
 
 import { statSync } from 'node:fs'
-import { join } from 'node:path'
+import { join, basename } from 'node:path'
 import {
-  DATA_DIR, dshHomeDir, STORE_PATH, TOML_PATH, IDLE_MS,
-  store, listWorkspaces, resolveWorkspaceDsn, slugify, shortHash,
+  DATA_DIR, dshHomeDir, STORE_PATH, TOML_PATH,
+  store, listWorkspaces, listWorkspaceEnvironments, resolveWorkspaceEnvs,
+  slugify, envSlug, shortHash,
   fingerprintOf, generateToml, maskDsn, writeToml,
 } from './config.mjs'
 import { buildSpawnArgv, resolveDbhubExe } from './runtime.mjs'
+import { currentT } from './i18n.mjs'
+import * as options from './options.mjs'
 import * as state from './state.mjs'
 
 // ── MCP client (JSON-RPC 2.0 over stdio) ─────────────────────────────────
@@ -188,120 +191,48 @@ async function spawnServer(subprocess, signal) {
   return {}
 }
 
-// ── per-workspace tool sync ───────────────────────────────────────────────
-
-// Tools sync: register one ctx.tools def per dbhub tool, keyed by raw name.
-const toolDisposers = new Map() // modelName -> disposer (server-synced tools)
-const coreDisposers = new Map() // modelName -> disposer (plugin-owned tools, never synced away)
+// ── tool registry (single-slot) ────────────────────────────────────────────
+//
+// Context budget: there is exactly ONE set of dbhub tools, period. Work
+// workspaces × environments are NOT expanded into per-source tools (that
+// would inject 2N tool declarations into every model turn); instead the
+// source-parameterized tools dbhub_execute_sql / dbhub_search_objects resolve
+// their `source` argument at call time against the live source list.
+const toolDisposers = new Map() // modelName -> disposer (plugin-owned tools)
+const coreDisposers = toolDisposers
 
-/** Total registered dbhub tools (core + per-workspace). */
+/** Total registered dbhub tools (constant set: configure/list/execute/search/query/query_objects). */
 export function activeToolCount() {
-  return coreDisposers.size + toolDisposers.size
+  return coreDisposers.size
 }
 
 function refreshToolCount() {
   state.setToolCount(activeToolCount())
 }
 
-// Per-source tool naming + connection labeling.
-// Each generated source gets its own suffixed tool set (`dbhub_<base>_<slug>`)
-// even when dbhub reports single-source bare names, so a workspace's tools are
-// never ambiguous. Every tool's description and result carry the masked
-// connection target (host:port/database, password hidden), so a user can see
-// exactly which environment (test/dev/prod) it points at before querying.
-function syncToolsNow(ctx, subprocess, sources) {
-  if (!server.client) return Promise.resolve()
-  const sourceById = new Map()
-  for (const s of sources) sourceById.set(s.id, s)
-  return server.client.request('tools/list').then((res) => {
-    const tools = Array.isArray(res && res.tools) ? res.tools : []
-    // raw base name -> list of {slug, dbhubRawName, maskedDsn}
-    const bases = new Map() // base -> Map<slug, {rawName, dsnMasked}>
-    for (const t of tools) {
-      const raw = t && t.name
-      if (!raw || typeof raw !== 'string') continue
-      // split off a per-source slug suffix (dbhub suffix = our source id)
-      let base = raw
-      let slug
-      for (const id of sourceById.keys()) {
-        if (raw === id) { slug = id } else if (raw.endsWith('_' + id)) {
-          base = raw.slice(0, raw.length - id.length - 1)
-          slug = id
-        }
-      }
-      if (slug === undefined && sources.length === 1) {
-        // single source: dbhub emits bare names -> attribute to the only source
-        slug = sources[0].id
-      }
-      if (slug === undefined) continue
-      const src = sourceById.get(slug)
-      const dsnMasked = src ? maskDsn(src.dsn) : slug
-      if (!bases.has(base)) bases.set(base, new Map())
-      bases.get(base).set(slug, { rawName: raw, dsnMasked })
-    }
-    const seen = new Set()
-    const jobs = []
-    const inputByRaw = new Map(tools.map((t) => [t.name, t.inputSchema]))
-    const descByRaw = new Map(tools.map((t) => [t.name, t.description]))
-    for (const [base, bySlug] of bases) {
-      for (const [slug, info] of bySlug) {
-        const modelName = 'dbhub_' + base + '_' + slug
-        seen.add(modelName)
-        if (toolDisposers.has(modelName)) continue
-        const rawName = info.rawName
-        const dsnMasked = info.dsnMasked
-        const inputSchema = inputByRaw.get(rawName)
-        const desc = descByRaw.get(rawName)
-        jobs.push(
-          (async () => {
-            try {
-              const def = {
-                name: modelName,
-                description: (desc ? desc + ' ' : '') +
-                  '（连接源：' + slug + ' → ' + dsnMasked + '；注意：这是该工作区配置的数据库环境，请确认是你要查的那套）',
-                parameters: (inputSchema && typeof inputSchema === 'object' && inputSchema.type === 'object')
-                  ? inputSchema
-                  : { type: 'object', properties: {}, required: [] },
-                timeoutMs: 60000,
-                output: {
-                  schema: {},
-                  render: (_args, value) => [
-                    {
-                      type: 'text',
-                      text: String(value && value.text !== undefined ? value.text : JSON.stringify(value)),
-                    },
-                  ],
-                },
-                async execute(args, exec) {
-                  return runOnServer(ctx, subprocess, rawName, args, exec, '{连接: ' + slug + ' → ' + dsnMasked + '}')
-                },
-              }
-              const disposer = ctx.tools.register(def)
-              toolDisposers.set(modelName, disposer)
-            } catch (e) {
-              console.error('[dsh-dbhub-live] register failed for ' + modelName + ': ' + String((e && e.message) || e))
-            }
-          })(),
-        )
-      }
-    }
-    // unregister tools whose source vanished
-    for (const [modelName, disposer] of [...toolDisposers]) {
-      if (!seen.has(modelName)) {
-        try {
-          disposer()
-        } catch (e) {
-          /* ignore */
-        }
-        toolDisposers.delete(modelName)
-      }
-    }
-    return Promise.all(jobs).then(() => {
-      refreshToolCount()
-    })
-  }).catch((e) => {
-    console.error('[dsh-dbhub-live] tools/list failed: ' + String((e && e.message) || e))
+/**
+ * Resolve a `source` reference (from dbhub_list_sources) to a live source row.
+ * Accepts: the exact source id (`<title>_<hash>[_<env>]`), the display titles
+ * `<title>` / `<title> <env>` / `<title>_<env>` / `<title>.<env>`.
+ * @returns the matched {@link collectSources} row + its source id, or
+ *   `undefined` when nothing matches.
+ */
+export async function resolveSource(ctx, subprocess, sourceRef) {
+  const wanted = String(sourceRef || '').trim().toLowerCase()
+  if (!wanted) return undefined
+  const { rows } = await collectSources(ctx, subprocess)
+  const keyed = rows.map((r, i) => {
+    const title = slugify(r.title)
+    const env = r.env === 'default' ? '' : envSlug(r.env)
+    const id = title + '_' + shortHash(r.wsPath) + (env ? '_' + env : '')
+    return { row: r, id, keys: new Set([id, title, env ? title + '_' + env : title, env ? title + ' ' + r.env : title, env ? title + '.' + r.env : title, String(i)]) }
   })
+  return keyed.find((k) => k.keys.has(wanted) || k.id === wanted || (wanted.includes(k.id)))
+}
+
+/** Human label for a source row ({连接: <title> → masked dsn}). */
+export function sourceLabel(row) {
+  return row ? '{连接: ' + row.title + ' → ' + maskDsn(row.dsn) + '}' : ''
 }
 
 // ── warm-call fast path & lazy ensure ─────────────────────────────────────
@@ -317,11 +248,12 @@ function resetIdle(ctx) {
     idleDispose = undefined
   }
   if (!server.handle) return
+  const idleMs = (options.get('idleMinutes') || 10) * 60 * 1000
   idleDispose = ctx.timeout(() => {
     idleDispose = undefined
     console.log('[dsh-dbhub-live] idle — recycling dbhub process')
     terminateServer()
-  }, IDLE_MS)
+  }, idleMs)
 }
 
 // Re-resolve configs only when the durable inputs change (workspace registry
@@ -329,7 +261,33 @@ function resetIdle(ctx) {
 // Keeps repeated tool calls at ~0 overhead.
 let lastInputMtime = 0
 
-function configInputsMtime() {
+// Live connection-row cache: refreshed by every collectSources run so the
+// settings publish path can mirror the card without an extra walk.
+let lastRowCache = []
+
+/** Masked connection rows for the card (never leaks passwords over the wire). */
+export function summarizeRows(rows) {
+  return rows.map((r) => {
+    const srcId = slugify(r.title) + '_' + shortHash(r.wsPath) + (r.env === 'default' ? '' : '_' + envSlug(r.env))
+    return {
+      title: r.title,
+      path: r.wsPath,
+      env: r.env,
+      dsn: maskDsn(r.dsn),
+      source: r.source,
+      persisted: !!r.persisted,
+      srcId,
+    }
+  })
+}
+
+/** The last collected summary set (empty until the first walk). */
+export function latestSummaries() {
+  return summarizeRows(lastRowCache)
+}
+
+/** mtime of the durable config inputs (workspace registry + credentials). */
+export function configInputsMtime() {
   let max = 0
   for (const p of [join(dshHomeDir(), 'storages', 'workspace.json'), STORE_PATH]) {
     try {
@@ -342,6 +300,46 @@ function configInputsMtime() {
   return max
 }
 
+/**
+ * Walk every workspace × environment and produce the live connection rows
+ * (for the card's masked summaries) and the dbhub source list (for the toml
+ * and per-workspace tool names). Shared by `ensureRunning` and the settings
+ * publish path so the card always mirrors what the server would load.
+ * Environment naming: the 'default' env keeps the legacy bare source id
+ * (`<title>_<hash>`); extra environments append `_<envSlug>`.
+ * @returns `{ rows, sources }` — rows: [{ wsPath, title, env, dsn, source,
+ *   persisted }]; sources: [{ id, dsn }].
+ */
+export async function collectSources(ctx, subprocess) {
+  const rows = []
+  const sources = []
+  try {
+    const workspaces = await listWorkspaces(ctx)
+    const persisted = listWorkspaceEnvironments(store)
+    const byPath = new Map()
+    for (const p of persisted) {
+      if (!byPath.has(p.wsPath)) byPath.set(p.wsPath, [])
+      byPath.get(p.wsPath).push(p)
+    }
+    for (const ws of workspaces) {
+      const title = ws.title || basename(ws.path)
+      const baseId = slugify(title) + '_' + shortHash(ws.path)
+      const resolved = await resolveWorkspaceEnvs(subprocess, ctx.get('fs'), ws.path, undefined)
+      const persistedEnvs = new Set((byPath.get(ws.path) || []).map((p) => p.env))
+      for (const r of resolved) {
+        const slug = envSlug(r.env)
+        const id = baseId + (slug ? '_' + slug : '')
+        rows.push({ wsPath: ws.path, title, env: r.env, dsn: r.dsn, source: r.source, persisted: persistedEnvs.has(r.env) })
+        sources.push({ id, dsn: r.dsn })
+      }
+    }
+  } catch (e) {
+    console.error('[dsh-dbhub-live] config generation failed: ' + String((e && e.message) || e))
+  }
+  lastRowCache = rows
+  return { rows, sources }
+}
+
 /**
  * Make sure the persistent server is up and synced, initializing lazily on
  * first use. Concurrent callers share one in-flight start. Regenerates the
@@ -357,18 +355,7 @@ export async function ensureRunning(ctx, subprocess) {
     resetIdle(ctx)
     return
   }
-  let sources = []
-  try {
-    const workspaces = await listWorkspaces(ctx)
-    for (const ws of workspaces) {
-      const resolved = await resolveWorkspaceDsn(subprocess, ctx.get('fs'), ws.path, undefined)
-      if (resolved && resolved.dsn) {
-        sources.push({ id: slugify(ws.title) + '_' + shortHash(ws.path), dsn: resolved.dsn })
-      }
-    }
-  } catch (e) {
-    console.error('[dsh-dbhub-live] config generation failed: ' + String((e && e.message) || e))
-  }
+  const { sources } = await collectSources(ctx, subprocess)
   lastInputMtime = inputMtime
   const fp = fingerprintOf(sources)
   // Never spawn with zero sources: dbhub treats an empty [[sources]] toml as
@@ -410,7 +397,6 @@ export async function ensureRunning(ctx, subprocess) {
       state.setPhase('initializing')
       const r = await spawnServer(subprocess, undefined)
       if (r.error) throw new Error(r.error)
-      await syncToolsNow(ctx, subprocess, sources)
       state.clearError()
       state.setPhase('running')
       refreshToolCount()
@@ -438,9 +424,9 @@ export async function runOnServer(ctx, subprocess, rawName, args, exec, label) {
   try {
     await ensureRunning(ctx, subprocess)
   } catch (e) {
-    return { ok: false, text: 'dbhub 服务启动失败: ' + String((e && e.message) || e) }
+    return { ok: false, text: currentT('result.serverStartFail', { msg: String((e && e.message) || e) }) }
   }
-  if (!server.client) return { ok: false, text: 'dbhub 服务不可用' }
+  if (!server.client) return { ok: false, text: currentT('result.serverUnavailable') }
   try {
     const res = await server.client.request('tools/call', { name: rawName, arguments: args || {} })
     const textOf = (r) => {
@@ -453,7 +439,7 @@ export async function runOnServer(ctx, subprocess, rawName, args, exec, label) {
     }
     resetIdle(ctx)
     const prefix = label ? label + '\n' : ''
-    if (res && res.isError) return { ok: false, text: 'dbhub 执行错误: ' + textOf(res) }
+    if (res && res.isError) return { ok: false, text: textOf(res) }
     if (res && res.structuredContent !== undefined) {
       return { ok: true, text: prefix + JSON.stringify(res.structuredContent, null, 2) }
     }
@@ -463,9 +449,9 @@ export async function runOnServer(ctx, subprocess, rawName, args, exec, label) {
   }
 }
 
-// Shared "plugin disabled" copy for every dbhub tool.
+// Shared "plugin disabled" copy for every dbhub tool (locale-aware).
 export function disabledMessage() {
-  return 'dsh-dbhub-live 已禁用：所有 dbhub 工具暂不可用。请在 设置 → 插件 → dsh-dbhub-live 中重新开启。'
+  return currentT('result.disabled')
 }
 
 /** Whether the persistent server currently answers calls. */

package/lib/options.mjs

@@ -0,0 +1,94 @@
+// dsh-dbhub-live: deployment-tunable options.
+//
+// Editable through the Settings -> Plugins -> dsh-dbhub-live card. Precedence:
+//   user settings (settings document) > process environment > built-in default
+// Environment variables only seed the boot values; once the settings document
+// claims a field (first publish writes the section), that field is owned by
+// the settings UI until it is unset — so an env change no longer applies to a
+// claimed field. This mirrors how the dsh settings system treats user layers.
+
+const BUILTIN_DEFAULTS = {
+  dbhubPackage: '@bytebase/dbhub',
+  updateIntervalDays: 7,
+  idleMinutes: 10,
+}
+
+function envNumber(name, fallback) {
+  const raw = process.env[name]
+  if (raw === undefined || raw === '') return fallback
+  const n = Number(raw)
+  return Number.isFinite(n) && n >= 0 ? n : fallback
+}
+
+const options = {
+  dbhubPackage: process.env.DSH_DBHUB_PACKAGE || BUILTIN_DEFAULTS.dbhubPackage,
+  updateIntervalDays: envNumber('DSH_DBHUB_UPDATE_DAYS', BUILTIN_DEFAULTS.updateIntervalDays),
+  idleMinutes: BUILTIN_DEFAULTS.idleMinutes,
+}
+
+const listeners = new Set()
+
+function emit() {
+  for (const fn of [...listeners]) {
+    try {
+      fn()
+    } catch (e) {
+      /* contain listener failures */
+    }
+  }
+}
+
+/** Subscribe to option changes; returns the disposer. */
+export function subscribe(fn) {
+  listeners.add(fn)
+  return () => listeners.delete(fn)
+}
+
+/**
+ * Detached JSON snapshot of the settings-exposed options. `dbhubPackage` is
+ * deliberately excluded: the auto-install package stays an environment-seeded
+ * internal knob (DSH_DBHUB_PACKAGE / built-in default), not a settings field.
+ */
+export function snapshot() {
+  return {
+    updateIntervalDays: options.updateIntervalDays,
+    idleMinutes: options.idleMinutes,
+  }
+}
+
+/**
+ * Read one option by id ('dbhubPackage' is internal-only).
+ * @param id - 'dbhubPackage' | 'updateIntervalDays' | 'idleMinutes'.
+ * @returns the current value.
+ */
+export function get(id) {
+  return options[id]
+}
+
+// Per-field validators for the settings-exposed options; 'dbhubPackage' is
+// deliberately not patchable (it stays an env/internal knob).
+const VALIDATORS = {
+  updateIntervalDays: (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0,
+  idleMinutes: (v) => typeof v === 'number' && Number.isFinite(v) && v > 0,
+}
+
+/**
+ * Apply a validated patch onto the options.
+ * @param patch - partial option values (prefixes the env seed at boot).
+ * @returns whether any option actually changed.
+ */
+export function applyPatch(patch) {
+  if (!patch || typeof patch !== 'object' || Array.isArray(patch)) return false
+  let changed = false
+  for (const [key, validator] of Object.entries(VALIDATORS)) {
+    const value = patch[key]
+    if (value === undefined) continue
+    if (!validator(value)) continue
+    const next = key === 'dbhubPackage' ? String(value).trim() : value
+    if (next === options[key]) continue
+    options[key] = next
+    changed = true
+  }
+  if (changed) emit()
+  return changed
+}

package/lib/runtime.mjs

@@ -11,17 +11,12 @@
 import { existsSync, statSync, readdirSync, mkdirSync } from 'node:fs'
 import { join } from 'node:path'
 import { DATA_DIR, RUNTIME_DIR, runtime, saveRuntime, ensureStorageDir } from './config.mjs'
+import * as options from './options.mjs'
 
-// How often the AUTO-INSTALLED copy is refreshed to the latest version.
-// Only our own managed install is refreshed — a dbhub the user installed
-// himself (PATH / mise) is never touched. Override via DSH_DBHUB_UPDATE_DAYS
-// (e.g. "0" disables auto-update; any positive number sets the day interval).
-const DBHUB_PACKAGE = process.env.DSH_DBHUB_PACKAGE || '@bytebase/dbhub'
-const DBHUB_UPDATE_MS = (() => {
-  const raw = process.env.DSH_DBHUB_UPDATE_DAYS
-  const n = raw !== undefined && raw !== '' && Number(raw) >= 0 ? Number(raw) : 7
-  return n * 24 * 60 * 60 * 1000
-})()
+// Auto-update interval and install package are deployment-tunable options
+// (Settings -> Plugins -> dsh-dbhub-live); only our own managed install is
+// ever refreshed — a dbhub the user installed himself (PATH / mise) is never
+// touched.
 
 // ── executable lookup ─────────────────────────────────────────────────────
 
@@ -97,8 +92,8 @@ let installingDbhub // single in-flight install guard
 
 // Install the dbhub MCP server once, into a private prefix under the storage
 // dir. Uses `npm install --prefix <RUNTIME_DIR>` (deterministic, offline-safe
-// afterwards) rather than `npx <pkg>` per call. Package and version can be
-// overridden via DSH_DBHUB_PACKAGE; by default installs the latest.
+// afterwards) rather than `npx <pkg>` per call. The package/version is a
+// configurable option (default installs the latest).
 async function installDbhub(subprocess, signal) {
   if (installingDbhub) return installingDbhub
   if (!subprocess) {
@@ -115,9 +110,10 @@ async function installDbhub(subprocess, signal) {
     if (!ensureStorageDir()) {
       throw new Error('无法创建 dbhub 运行时目录 ' + DATA_DIR + '（写入被拦截）')
     }
+    const dbhubPackage = options.get('dbhubPackage') || '@bytebase/dbhub'
     const args = [
       'install',
-      DBHUB_PACKAGE,
+      dbhubPackage,
       '--prefix', RUNTIME_DIR,
       '--no-save', '--no-fund', '--no-audit',
       '--loglevel=error',
@@ -159,7 +155,7 @@ async function installDbhub(subprocess, signal) {
       throw new Error('npm 安装完成，但未在 ' + RUNTIME_DIR + ' 下找到 dbhub 可执行文件')
     }
     runtime.dbhubInstallAt = Date.now()
-    console.log('[dsh-dbhub-live] 已自动安装 dbhub (' + DBHUB_PACKAGE + ') → ' + exe)
+    console.log('[dsh-dbhub-live] 已自动安装 dbhub (' + dbhubPackage + ') → ' + exe)
     return exe
   })()
   try {
@@ -209,8 +205,10 @@ export function isAutoManagedExe() {
 export async function maybeRefreshDbhub(subprocess) {
   if (!isAutoManagedExe()) return
   if (!(runtime.dbhubInstallAt > 0)) return
-  if (DBHUB_UPDATE_MS <= 0) return // auto-update disabled
-  if (Date.now() - runtime.dbhubInstallAt < DBHUB_UPDATE_MS) return
+  const intervalDays = options.get('updateIntervalDays')
+  if (!(intervalDays > 0)) return // auto-update disabled
+  const intervalMs = intervalDays * 24 * 60 * 60 * 1000
+  if (Date.now() - runtime.dbhubInstallAt < intervalMs) return
   try {
     await installDbhub(subprocess, undefined)
     console.log('[dsh-dbhub-live] dbhub 已自动更新到最新版')