dsh-dbhub-live 3.0.0 → 3.1.2

package/lib/config.mjs

@@ -15,7 +15,6 @@ export const STORE_PATH = join(DATA_DIR, 'credentials.json')
 export const TOML_PATH = join(DATA_DIR, 'dbhub.toml')
 export const RUNTIME_DIR = join(DATA_DIR, 'dbhub-runtime')
 export const RUNTIME_PATH = join(DATA_DIR, 'runtime.json')
-export const IDLE_MS = 10 * 60 * 1000
 
 // Ensure the storage directory exists once at load; every writer below
 // (store, runtime, toml, managed dbhub prefix) assumes it is present.
@@ -55,11 +54,14 @@ function defineOwn(target, key, value) {
 
 /**
  * Normalize a credentials document (per-workspace entries + the enabled
- * toggle) so legacy or hand-edited files cannot poison initialization:
- * non-boolean `enabled`, non-object entries and empty-DSN entries are
- * dropped; the authoritative `dsn` is trimmed. Unknown entry fields are
- * preserved so a newer version's writes are never stripped by an older
- * loader (forward compatibility).
+ * toggle) so legacy or hand-edited files cannot poison initialization.
+ * Store model (v2): each workspace entry is `{ environments: { <env>: {
+ * dsn, source?, updatedAt? } } }`; a v1 entry `{ dsn, source?, updatedAt? }`
+ * is migrated into `environments.default` automatically. Non-boolean
+ * `enabled`, non-object entries, empty-DSN entries and empty environment maps
+ * are dropped; DSNs are trimmed. Unknown fields are preserved so a newer
+ * version's writes are never stripped by an older loader (forward
+ * compatibility).
  * @param raw - parsed JSON document (any shape).
  * @returns the normalized plain object.
  */
@@ -67,16 +69,113 @@ export function normalizeStore(raw) {
   const out = {}
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return out
   if (typeof raw.enabled === 'boolean') defineOwn(out, 'enabled', raw.enabled)
+
+  const normalizeEnv = (env) => {
+    const clean = {}
+    if (!env || typeof env !== 'object' || Array.isArray(env)) return
+    const dsn = typeof env.dsn === 'string' ? env.dsn.trim() : ''
+    if (!dsn) return
+    defineOwn(clean, 'dsn', dsn)
+    if (typeof env.source === 'string' && env.source) defineOwn(clean, 'source', env.source)
+    if (typeof env.updatedAt === 'number' && Number.isFinite(env.updatedAt)) {
+      defineOwn(clean, 'updatedAt', env.updatedAt)
+    }
+    for (const [k, v] of Object.entries(env)) {
+      if (k === 'dsn' || k === 'source' || k === 'updatedAt') continue
+      defineOwn(clean, k, v) // forward-compatible unknown env fields
+    }
+    return clean
+  }
+
   for (const [key, entry] of Object.entries(raw)) {
     if (key === 'enabled') continue
     if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue
-    const dsn = typeof entry.dsn === 'string' ? entry.dsn.trim() : ''
-    if (!dsn) continue
-    defineOwn(out, key, { ...entry, dsn })
+    if (Object.prototype.hasOwnProperty.call(entry, 'environments')) {
+      // v2: per-environment map
+      const environments = {}
+      if (entry.environments && typeof entry.environments === 'object' && !Array.isArray(entry.environments)) {
+        for (const [env, envEntry] of Object.entries(entry.environments)) {
+          const clean = normalizeEnv(envEntry)
+          if (clean) defineOwn(environments, env, clean)
+        }
+      }
+      if (Object.keys(environments).length > 0) defineOwn(out, key, { environments })
+    } else {
+      // v1 migration: a bare dsn entry becomes the 'default' environment
+      const clean = normalizeEnv(entry)
+      if (clean) defineOwn(out, key, { environments: { default: clean } })
+    }
   }
   return out
 }
 
+/**
+ * List every persisted workspace environment as flat rows for the card.
+ * @param store - the (normalized) credentials store.
+ * @returns rows [{ wsPath, env, dsn, source?, updatedAt?, persisted: true }].
+ */
+export function listWorkspaceEnvironments(store) {
+  const rows = []
+  for (const [wsPath, entry] of Object.entries(store || {})) {
+    if (wsPath === 'enabled') continue
+    if (!entry || typeof entry !== 'object' || !entry.environments || typeof entry.environments !== 'object') continue
+    for (const [env, envEntry] of Object.entries(entry.environments)) {
+      if (!envEntry || typeof envEntry.dsn !== 'string' || !envEntry.dsn.trim()) continue
+      rows.push({
+        wsPath,
+        env,
+        dsn: envEntry.dsn.trim(),
+        ...(typeof envEntry.source === 'string' && envEntry.source ? { source: envEntry.source } : {}),
+        ...(typeof envEntry.updatedAt === 'number' && Number.isFinite(envEntry.updatedAt) ? { updatedAt: envEntry.updatedAt } : {}),
+        persisted: true,
+      })
+    }
+  }
+  return rows
+}
+
+/**
+ * Persist one workspace environment (creates or overwrites). The workspace
+ * entry becomes `{ environments: { <env>: { dsn, source, updatedAt } } }`.
+ * @returns the stored environment name ('default' when blank).
+ */
+export function setWorkspaceEnv(wsPath, env, dsn, source) {
+  const entry = store[wsPath] && typeof store[wsPath] === 'object' && !Array.isArray(store[wsPath])
+    ? store[wsPath]
+    : {}
+  const environments = entry.environments && typeof entry.environments === 'object' && !Array.isArray(entry.environments)
+    ? { ...entry.environments }
+    : {}
+  const name = env === undefined || env === null || String(env).trim() === ''
+    ? 'default'
+    : String(env).trim()
+  const cleanDsn = String(dsn).trim()
+  if (!cleanDsn) throw new TypeError('DSN 不能为空')
+  environments[name] = { dsn: cleanDsn, source: String(source || 'user'), updatedAt: Date.now() }
+  store[wsPath] = { environments }
+  saveStore(store)
+  return name
+}
+
+/**
+ * Remove one persisted workspace environment; when it was the last one the
+ * whole workspace entry is dropped. Removing an auto-derived 'default' (which
+ * is never persisted) is a no-op.
+ * @returns whether anything was removed.
+ */
+export function removeWorkspaceEnv(wsPath, env) {
+  const entry = store[wsPath]
+  if (!entry || typeof entry !== 'object' || !entry.environments || typeof entry.environments !== 'object') return false
+  const name = env === undefined || env === null || String(env).trim() === '' ? 'default' : String(env).trim()
+  if (!Object.prototype.hasOwnProperty.call(entry.environments, name)) return false
+  const environments = { ...entry.environments }
+  delete environments[name]
+  if (Object.keys(environments).length === 0) delete store[wsPath]
+  else store[wsPath] = { environments }
+  saveStore(store)
+  return true
+}
+
 /** Normalize the runtime document (dbhubExe / dbhubInstallAt) the same way. */
 export function normalizeRuntime(raw) {
   const out = {}
@@ -342,13 +441,9 @@ export async function runMiseEnv(subprocess, cwd, signal) {
   }
 }
 
-// Resolve one workspace's DSN: persisted explicit entry first, then
-// auto-discovery (mise env -> .env). Never consults the process environment.
-export async function resolveWorkspaceDsn(subprocess, fs, wsPath, signal) {
-  const entry = store[wsPath]
-  if (entry && entry.dsn && typeof entry.dsn === 'string' && entry.dsn.trim()) {
-    return { dsn: entry.dsn.trim(), source: 'persisted(' + (entry.source || 'user') + ')' }
-  }
+// Auto-discovery (mise env -> .env) supplies the workspace's 'default'
+// environment only. Never consults the process environment.
+async function resolveAutoDsn(subprocess, fs, wsPath, signal) {
   const miseMap = await runMiseEnv(subprocess, wsPath, signal)
   if (miseMap) {
     const dsn = dsnFromMap(miseMap)
@@ -363,4 +458,35 @@ export async function resolveWorkspaceDsn(subprocess, fs, wsPath, signal) {
     /* no .env */
   }
   return undefined
+}
+
+/**
+ * Resolve one workspace's connection rows, one per environment: every
+ * persisted environment (v2 `environments.<env>`) plus, when no persisted
+ * `default` overrides it, the auto-discovered 'default'. Auto-discovery is
+ * never persisted — it is re-evaluated at every resolve (the card marks it
+ * as such).
+ * @returns rows [{ env, dsn, source }].
+ */
+export async function resolveWorkspaceEnvs(subprocess, fs, wsPath, signal) {
+  const entry = store[wsPath]
+  const persisted = entry && entry.environments && typeof entry.environments === 'object'
+    ? entry.environments
+    : {}
+  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') + ')' })
+    }
+  }
+  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 })
+  }
+  return out
+}
+
+/** Environment slug for tool/source naming; 'default' stays bare. */
+export function envSlug(env) {
+  return env === 'default' ? '' : slugify(env) || 'env'
 }

package/lib/i18n.mjs

@@ -0,0 +1,139 @@
+// dsh-dbhub-live: host-side locale support.
+//
+// The dsh UI language preference lives in the user settings document under
+// the 'locale' namespace ('preference': 'zh' | 'en'; absence delegates to the
+// browser and defaults to zh here). Every user/model-facing string the Host
+// produces — tool results, error feedback, milestone logs, the status-card
+// error source — runs through `currentT` so reports match the dsh UI
+// language. Tool SCHEMA descriptions stay pinned Chinese (model-facing
+// product copy; they are static per registration).
+
+const ZH = {
+  'log.hostApply': 'host apply',
+  'log.nsRegistered': '状态命名空间已注册: dsh-dbhub-live',
+  'log.loaded': 'dbhub 服务已加载（{n} 个工具）',
+  'log.readyNoSources': '插件就绪（暂无工作区数据源，可用 dbhub_configure 配置后自动启动服务）',
+  'log.initFailed': '初始化失败（状态卡片可见最近错误），下次调用自动重试',
+  'log.disabledBoot': '插件处于禁用状态，未自动初始化（可在 设置 → 插件 → dsh-dbhub-live 开启）',
+  'log.opSaved': '卡片配置：{title} 环境 {env} 已保存',
+  'log.opRemoved': '卡片配置：{title} 环境 {env} 已删除',
+  'log.opNothing': '卡片配置：{title} 无可删除的环境记录（自动发现项不会持久化）',
+  'log.opNoWs': '配置操作失败：找不到工作区 "{ws}"',
+  'log.opBad': '忽略非法的配置操作: {raw}',
+  'log.opUnknown': '忽略未知配置操作: {op}',
+  'log.syncApplied': '配置操作已生效：dbhub 工具已重新同步（{n} 个）',
+  'log.syncLater': '配置操作后工具重同步失败（下次调用自动重试）: {msg}',
+  'log.stateSyncFail': '状态同步失败: {msg}',
+  'log.updateCheckFailed': 'dbhub 自动更新检查失败: {msg}',
+  'result.disabled': 'dsh-dbhub-live 已禁用：所有 dbhub 工具暂不可用。请在 设置 → 插件 → dsh-dbhub-live 中重新开启。',
+  'result.dsnMissing': '缺少 dsn 参数（如 mysql://user:pass@host:3306/db）',
+  'result.masked': '检测到脱敏密码 `****`：dbhub_query / dbhub_query_objects 需要真实凭据，打码连接串不能直连。要查询已注册的环境，请改用对应的常驻工具（先用 dbhub_list_sources 查 source 值）；若确需临时直连，请提供真实密码的完整 DSN。',
+  'result.noSource': '找不到数据源 "{src}"：请先调用 dbhub_list_sources 查看可用 source 值（如 <工作区> 或 <工作区>_<环境>）。',
+  'result.sourcesIntro': '⚠️ 下面每个连接串都是脱敏显示（密码 ****），仅供识别，不要把它们拷进 dbhub_query 直连；查询某环境请用 dbhub_execute_sql / dbhub_search_objects，source 参数取该行的「source 值」。\n已注册连接源 {n} 个：',
+  'result.srcRow': '- {title}（{badge}）｜环境 {env}｜连接 {dsn}（打码，仅显示）｜来源 {src}｜source 值 {srcId}',
+  'result.sourcesEmpty': '暂无已注册的连接源（可用 dbhub_configure 或 设置 → 插件 → dsh-dbhub-live → 工作区连接 添加）。',
+  'result.badgeSaved': '已保存',
+  'result.badgeAuto': '自动',
+  'result.savedOk': '已持久化连接并注册工具（{slug}，环境 {env}）。下次可直接使用 dbhub_execute_sql_{tool}。',
+  'result.sevSaveFail': '连接已持久化，但 dbhub 服务启动失败（下次调用会自动重试并注册工具）。见 dsh web 日志。',
+  'result.serverStartFail': 'dbhub 服务启动失败: {msg}',
+  'result.serverUnavailable': 'dbhub 服务不可用',
+  'result.noWslabel': '没有可用的工作区',
+  'result.modeCanceled': '已取消，未做任何修改',
+  'result.noDsn': '未提供 DSN，已取消',
+  'result.scanDenied': '未授权扫描，已取消（可改用“输入 DSN”或“填写分项”）',
+  'result.scanEmpty': '未找到可扫描的数据库配置文件（已跳过 node_modules/.git/target 等）。可改用“输入 DSN”或“填写分项”。',
+  'result.scanNone': '扫描了 {n} 个文件，但未提取到数据库连接。可改用“输入 DSN”或“填写分项”。',
+  'result.scanPicked': '已按你的确认持久化连接（来源: 项目文件扫描，环境 {env}）并注册工具（{slug}）。',
+  'label.conn': '{连接: {src} → {dsn}}',
+  'label.adhocConn': '{临时连接: {dsn}}',
+}
+
+const EN = {
+  'log.hostApply': 'host apply',
+  'log.nsRegistered': 'settings namespace registered: dsh-dbhub-live',
+  'log.loaded': 'dbhub server loaded ({n} tools)',
+  'log.readyNoSources': 'ready (no workspace sources yet — configure one with dbhub_configure)',
+  'log.initFailed': 'init failed (see the recent error on the status card); retried on next call',
+  'log.disabledBoot': 'plugin disabled — not initialized (enable it in Settings → Plugins → dsh-dbhub-live)',
+  'log.opSaved': 'card config: {title} environment {env} saved',
+  'log.opRemoved': 'card config: {title} environment {env} removed',
+  'log.opNothing': 'card config: {title} has no persisted environment to remove (auto-discovered rows are not persisted)',
+  'log.opNoWs': 'config operation failed: workspace "{ws}" not found',
+  'log.opBad': 'ignoring invalid config operation: {raw}',
+  'log.opUnknown': 'ignoring unknown config operation: {op}',
+  'log.syncApplied': 'config applied: dbhub tools re-synced ({n})',
+  'log.syncLater': 'tool re-sync failed after config (auto-retried on next call): {msg}',
+  'log.stateSyncFail': 'status sync failed: {msg}',
+  'log.updateCheckFailed': 'dbhub auto-update check failed: {msg}',
+  'result.disabled': 'dsh-dbhub-live is disabled: dbhub tools are unavailable. Re-enable it in Settings → Plugins → dsh-dbhub-live.',
+  'result.dsnMissing': 'missing dsn argument (e.g. mysql://user:pass@host:3306/db)',
+  'result.masked': 'masked password `****` detected: dbhub_query / dbhub_query_objects need real credentials. To query a registered environment use the persistent tools (run dbhub_list_sources for the source value); for a one-off connection pass a full DSN with the real password.',
+  'result.noSource': 'source "{src}" not found: run dbhub_list_sources first to see the available source values (e.g. <workspace> or <workspace>_<env>).',
+  'result.sourcesIntro': '⚠️ Every DSN below is masked (password ****) and only for identification — do not copy one into dbhub_query. To query an environment use dbhub_execute_sql / dbhub_search_objects with the row\u2019s source value.\n{n} registered source(s):',
+  'result.srcRow': '- {title} ({badge}) | env {env} | dsn {dsn} (masked) | source {src} | source value {srcId}',
+  'result.sourcesEmpty': 'no registered sources yet (add one with dbhub_configure or Settings → Plugins → dsh-dbhub-live → Workspace connections).',
+  'result.badgeSaved': 'saved',
+  'result.badgeAuto': 'auto',
+  'result.savedOk': 'connection persisted and tools registered ({slug}, env {env}). Next time use dbhub_execute_sql_{tool}.',
+  'result.sevSaveFail': 'connection persisted but the dbhub server failed to start (auto-retried and re-registered on next call). See the dsh web log.',
+  'result.serverStartFail': 'dbhub server failed to start: {msg}',
+  'result.serverUnavailable': 'dbhub server unavailable',
+  'result.noWslabel': 'no workspace available',
+  'result.modeCanceled': 'cancelled — nothing changed',
+  'result.noDsn': 'no DSN provided — cancelled',
+  'result.scanDenied': 'scan not authorized — cancelled (use "enter DSN" or "fill in fields" instead)',
+  'result.scanEmpty': 'no database config files found (node_modules/.git/target etc. are skipped). Use "enter DSN" or "fill in fields" instead.',
+  'result.scanNone': 'scanned {n} files but extracted no database connection. Use "enter DSN" or "fill in fields" instead.',
+  'result.scanPicked': 'connection persisted from your selection (source: project file scan, env {env}) and tools registered ({slug}).',
+  'label.conn': '{connection: {src} → {dsn}}',
+  'label.adhocConn': '{adhoc: {dsn}}',
+}
+
+let localeProvider = () => 'zh'
+let cached = { at: 0, value: 'zh' }
+
+/** Install the locale provider (set from apply with the settings service). */
+export function setLocaleProvider(fn) {
+  localeProvider = fn
+  cached = { at: 0, value: 'zh' } // invalidate so the next read refreshes
+}
+
+/** Current locale (cached up to 1s; provider errors fall back to zh). */
+export function currentLocale() {
+  const now = Date.now()
+  if (now - cached.at >= 1000) {
+    let value = 'zh'
+    try {
+      value = localeProvider() === 'en' ? 'en' : 'zh'
+    } catch (e) {
+      value = 'zh'
+    }
+    cached = { at: now, value }
+  }
+  return cached.value
+}
+
+/** Translate a key for the CURRENT locale; falls back to zh then the key. */
+export function currentT(key, params) {
+  const dict = currentLocale() === 'en' ? EN : ZH
+  let s = dict[key] ?? ZH[key] ?? key
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      s = s.split('{' + k + '}').join(String(v))
+    }
+  }
+  return s
+}
+
+/** Translate for an explicit locale (pure — unit-testable). */
+export function tFor(locale, key, params) {
+  const dict = locale === 'en' ? EN : ZH
+  let s = dict[key] ?? ZH[key] ?? key
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      s = s.split('{' + k + '}').join(String(v))
+    }
+  }
+  return s
+}

package/lib/index.mjs

@@ -31,22 +31,28 @@ import {
 } from './runtime.mjs'
 import {
   ensureRunning, terminateServer, isServerUp, activeToolCount, refreshToolCount,
+  collectSources, latestSummaries, configInputsMtime,
 } from './mcp.mjs'
 import { registerCoreTools } from './tools.mjs'
+import {
+  listWorkspaces, setWorkspaceEnv, removeWorkspaceEnv,
+} from './config.mjs'
+import { setLocaleProvider, currentT } from './i18n.mjs'
 import * as state from './state.mjs'
+import * as options from './options.mjs'
 
 export const name = 'dsh-dbhub-live'
 // Real-module Guard requires declared injection before touching `ctx.tools`;
 // the timer mixin powers idle recycling.
 export const inject = ['tools', 'timer']
 
-// ── settings namespace: live status mirror for the browser card ───────────
+// ── settings namespace: live status mirror + configurable options ─────────
 
 // The namespace must match the settings-namespace pattern
 // (^[a-z][a-z0-9-]*$) — derived from @deepseek-ai/dsh-settings'
 // `settingsNamespace()` brand without importing it, so a plugin installed as a
 // local-directory link (whose bare imports resolve from the source tree) can
-// never fail to boot over a status accessory.
+// never fail to boot over a settings accessory.
 const STATUS_NS = 'dsh-dbhub-live'
 
 const STATUS_DEFAULTS = {
@@ -55,6 +61,13 @@ const STATUS_DEFAULTS = {
   toolCount: 0,
   lastError: '',
   mode: 'lazy',
+  updateIntervalDays: 7,
+  idleMinutes: 10,
+  // Workspace-connection summaries ride as a JSON string so the schema never
+  // has to validate their arbitrary shape; `configOp` is the one-way command
+  // channel from the card (host consumes it and republishes without it).
+  workspaces: '[]',
+  configOp: '',
 }
 
 // Prefer the real schemastery schema (standard path, present in every dsh
@@ -71,6 +84,10 @@ try {
     toolCount: z.number().min(0).default(STATUS_DEFAULTS.toolCount),
     lastError: z.string().default(STATUS_DEFAULTS.lastError),
     mode: z.string().default(STATUS_DEFAULTS.mode),
+    updateIntervalDays: z.number().min(0).default(STATUS_DEFAULTS.updateIntervalDays),
+    idleMinutes: z.number().min(0).default(STATUS_DEFAULTS.idleMinutes),
+    workspaces: z.string().default(STATUS_DEFAULTS.workspaces),
+    configOp: z.string().default(STATUS_DEFAULTS.configOp),
   })
 } catch (e) {
   const fallbackSchema = (value) => {
@@ -85,40 +102,138 @@ try {
   console.warn('[dsh-dbhub-live] @deepseek-ai/schemastery 不可解析，使用内置最小状态 schema（状态卡片功能不受影响）')
 }
 
-// Mirrors the state machine into the settings namespace when a settings
-// provider is mounted (the Plugins tab dispatches our card from this
-// namespace). The namespace's `enabled` field is how the card's toggle writes
-// back; the host store remains the authoritative source and converges the
-// document at boot. Everything is wired on the injected settings fiber so it
-// rolls back with this plugin.
+// Resolve a workspace selector (path or title) from the card ops.
+async function resolveWorkspaceRef(ref) {
+  const workspaces = await listWorkspaces(undefined)
+  const wanted = String(ref || '').trim()
+  if (wanted) {
+    const byPath = workspaces.find((w) => w.path === wanted)
+    if (byPath) return byPath
+    const byTitle = workspaces.find((w) => w.title === wanted)
+    if (byTitle) return byTitle
+  }
+  return undefined
+}
+
+// One card command: { op: 'add'|'remove', workspace, env, dsn? }
+async function handleConfigOp(rawOp, ctx, subprocess) {
+  let op
+  try {
+    op = JSON.parse(String(rawOp || ''))
+  } catch (e) {
+    console.warn('[dsh-dbhub-live] ' + currentT('log.opBad', { raw: String(rawOp) }))
+    return
+  }
+  if (!op || typeof op !== 'object') return
+  const ws = await resolveWorkspaceRef(op.workspace)
+  if (!ws) {
+    console.warn('[dsh-dbhub-live] ' + currentT('log.opNoWs', { ws: String(op.workspace || '') }))
+    return
+  }
+  try {
+    if (op.op === 'add' || op.op === 'set') {
+      const dsn = typeof op.dsn === 'string' ? op.dsn.trim() : ''
+      if (!dsn) throw new TypeError('DSN 不能为空')
+      const envName = setWorkspaceEnv(ws.path, op.env, dsn, op.source === 'collected' ? 'collected' : 'user')
+      console.log('[dsh-dbhub-live] ' + currentT('log.opSaved', { title: ws.title, env: envName }))
+    } else if (op.op === 'remove') {
+      const removed = removeWorkspaceEnv(ws.path, op.env)
+      if (!removed) console.log('[dsh-dbhub-live] ' + currentT('log.opNothing', { title: ws.title }))
+      else console.log('[dsh-dbhub-live] ' + currentT('log.opRemoved', { title: ws.title, env: String(op.env || 'default') }))
+    } else {
+      console.warn('[dsh-dbhub-live] ' + currentT('log.opUnknown', { op: String(op.op) }))
+    }
+  } catch (e) {
+    console.warn('[dsh-dbhub-live] ' + currentT('log.opNoWs', { ws: String((e && e.message) || e) }))
+  }
+  // Refresh the summaries cache AND make the running server re-sync its tool
+  // registrations NOW (the credentials mtime changed, the toml regenerates,
+  // the server restarts and every per-environment tool — including a newly
+  // added `_<env>` name — registers immediately). Without this, a card edit
+  // would only surface as a tool on the next unrelated call.
+  await collectSources(ctx, subprocess)
+  try {
+    await ensureRunning(ctx, subprocess)
+    console.log('[dsh-dbhub-live] ' + currentT('log.syncApplied', { n: activeToolCount() }))
+  } catch (e) {
+    console.warn('[dsh-dbhub-live] ' + currentT('log.syncLater', { msg: String((e && e.message) || e) }))
+  }
+  refreshToolCount()
+}
+
+// Mirrors the state machine + configurable options into the settings
+// namespace when a settings provider is mounted (the Plugins tab dispatches
+// our card from this namespace). The namespace's `enabled` field is how the
+// card's toggle writes back, and the config fields (`dbhubPackage`,
+// `updateIntervalDays`, `idleMinutes`) are how the card edits options. The
+// host store remains the authoritative source and converges the document at
+// boot. Everything is wired on the injected settings fiber so it rolls back
+// with this plugin.
 function wireStatusNamespace(ctx) {
   ctx.inject(['settings'], (sctx) => {
-    let scope
-    try {
-      scope = sctx.settings.register(STATUS_NS, STATUS_SCHEMA, { base: {} })
-    } catch (e) {
-      console.error('[dsh-dbhub-live] 状态命名空间注册失败: ' + String((e && e.message) || e))
-      return
-    }
-    const publish = () => {
-      scope.replace(state.snapshot()).catch((e) => {
-        console.warn('[dsh-dbhub-live] 状态同步失败: ' + String((e && e.message) || e))
-      })
+    // The whole callback runs inside one guard: a wiring failure must surface
+    // in the log instead of silently killing the status surface (bootstrap
+    // publishes, configOp commands and live summaries all live here).
+    const wrap = (fn) => {
+      try {
+        return fn()
+      } catch (e) {
+        console.error('[dsh-dbhub-live] 状态接线异常: ' + String((e && e.stack) || e))
+        return undefined
+      }
     }
-    const stopWatch = scope.watch((next) => {
-      const nextEnabled = next && typeof next === 'object' && typeof next.enabled === 'boolean'
-        ? next.enabled
-        : undefined
-      if (nextEnabled !== undefined && nextEnabled !== state.isEnabled()) {
-        state.setEnabled(nextEnabled)
+    wrap(() => {
+      const subprocess = ctx.get('subprocess')
+      const scope = sctx.settings.register(STATUS_NS, STATUS_SCHEMA, { base: {} })
+      console.log('[dsh-dbhub-live] ' + currentT('log.nsRegistered'))
+      // Precedence: user settings > process environment > built-in defaults.
+      // Capture the user layer BEFORE our first publish, so env-seeded options
+      // are only overridden by fields the user actually saved.
+      const preBootUser = (() => {
+        try {
+          const found = sctx.settings.describe().find((d) => d && d.ns === STATUS_NS)
+          return found && found.user && typeof found.user === 'object' ? found.user : {}
+        } catch (e) {
+          return {}
+        }
+      })()
+      options.applyPatch(preBootUser)
+      const publish = () => {
+        const merged = {
+          ...state.snapshot(),
+          ...options.snapshot(),
+          serverUp: isServerUp(),
+          workspaces: JSON.stringify(latestSummaries()),
+        }
+        scope.replace(merged).catch((e) => {
+          console.warn('[dsh-dbhub-live] 状态同步失败: ' + String((e && e.message) || e))
+        })
       }
+      // Fresh summaries at attach, then mirror every state change.
+      collectSources(ctx, subprocess).then(publish, () => publish())
+      const stopWatch = scope.watch((next) => {
+        const value = next && typeof next === 'object' ? next : {}
+        if (typeof value.enabled === 'boolean' && value.enabled !== state.isEnabled()) {
+          state.setEnabled(value.enabled)
+        }
+        // Config edits from the card land here; applying them republishes the
+        // merged snapshot (the republish is a no-op for unchanged fields).
+        if (options.applyPatch(value)) publish()
+        // One-way workspace-config command.
+        if (typeof value.configOp === 'string' && value.configOp.trim() !== '' && value.configOp !== '{}') {
+          const op = value.configOp
+          handleConfigOp(op, ctx, subprocess).then(publish, () => publish())
+        }
+      })
+      const stopStatus = state.subscribe(publish)
+      const stopOptions = options.subscribe(publish)
+      sctx.effect(() => () => {
+        stopWatch()
+        stopStatus()
+        stopOptions()
+      })
+      publish()
     })
-    const unsubscribe = state.subscribe(publish)
-    sctx.effect(() => () => {
-      stopWatch()
-      unsubscribe()
-    })
-    publish()
   })
 }
 
@@ -144,27 +259,27 @@ function startLazyInit(ctx, subprocess) {
         state.clearError()
         state.setPhase('running')
         refreshToolCount()
-        console.log('[dsh-dbhub-live] dbhub 服务已加载（' + activeToolCount() + ' 个工具）')
+        console.log('[dsh-dbhub-live] ' + currentT('log.loaded', { n: activeToolCount() }))
         // Background, non-blocking: refresh the auto-installed dbhub if its
         // update interval has elapsed. Fails silently — the current binary
         // stays in use.
         maybeRefreshDbhub(subprocess).catch((e) => {
-          console.error('[dsh-dbhub-live] dbhub 自动更新检查失败: ' + String((e && e.message) || e))
+          console.error('[dsh-dbhub-live] ' + currentT('log.updateCheckFailed', { msg: String((e && e.message) || e) }))
         })
       } else if (state.getState().phase !== 'error') {
         // No workspace data source yet (or the server was recycled): the
         // plugin is healthy and waiting — mark it running, not initializing.
         state.clearError()
         state.setPhase('running')
-        console.log('[dsh-dbhub-live] 插件就绪（暂无工作区数据源，可用 dbhub_configure 配置后自动启动服务）')
+        console.log('[dsh-dbhub-live] ' + currentT('log.readyNoSources'))
       } else {
         // A real start failure was already recorded into the state machine;
         // the next tool call retries automatically.
-        console.error('[dsh-dbhub-live] 初始化失败（状态卡片可见最近错误），下次调用自动重试')
+        console.error('[dsh-dbhub-live] ' + currentT('log.initFailed'))
       }
     } catch (e) {
       state.recordError(String((e && e.message) || e))
-      console.error('[dsh-dbhub-live] 初始化失败: ' + String((e && e.message) || e))
+      console.error('[dsh-dbhub-live] ' + currentT('log.initFailed') + ': ' + String((e && e.message) || e))
     } finally {
       initInFlight = undefined
     }
@@ -175,6 +290,19 @@ function startLazyInit(ctx, subprocess) {
 // ── apply ─────────────────────────────────────────────────────────────────
 
 export async function apply(ctx) {
+  console.log('[dsh-dbhub-live] ' + currentT('log.hostApply'))
+  // Host-side feedback follows the dsh UI language (settings.locale.preference).
+  setLocaleProvider(() => {
+    try {
+      const settings = ctx.get('settings')
+      if (!settings) return 'zh'
+      const entry = settings.describe().find((d) => d && d.ns === 'locale')
+      const preference = entry && entry.value && entry.value.preference
+      return preference === 'en' ? 'en' : 'zh'
+    } catch (e) {
+      return 'zh'
+    }
+  })
   const subprocess = ctx.get('subprocess')
   registerCoreTools(ctx, subprocess)
   refreshToolCount()
@@ -212,6 +340,6 @@ export async function apply(ctx) {
       /* recorded in state */
     })
   } else {
-    console.log('[dsh-dbhub-live] 插件处于禁用状态，未自动初始化（可在 设置 → 插件 → dsh-dbhub-live 开启）')
+    console.log('[dsh-dbhub-live] ' + currentT('log.disabledBoot'))
   }
 }