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

package/test/configure-options.test.mjs

@@ -0,0 +1,244 @@
+// dbhub_configure's options-only path, the §7.5 decision table and the D7
+// security asymmetry (lib/tools.mjs runOptionsOnly / pendingOptionsOf):
+//
+//   * the model may TIGHTEN an environment (readOnly:true) and may NEVER RELAX
+//     it — readOnly:false is refused before anything is read or written, and it
+//     must not open a dialog either (that would be a social-engineering channel);
+//   * an options-only call needs a home for the option: a persisted row, or an
+//     auto-discovered row that gets PROMOTED in the same explicit action (D10);
+//     with neither, the plugin says so and persists nothing;
+//   * options that accompany connection facts ride the SAME store write as the
+//     connection, so a same-endpoint call must leave the DSN byte-identical.
+
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const home = mkdtempSync(join(tmpdir(), 'dsh-dbhub-opts-'))
+process.env.DSH_HOME = home
+
+// Plain imports = the very singletons lib/tools.mjs uses (see copy-from.test.mjs).
+const cfg = await import('../lib/config.mjs')
+const mcp = await import('../lib/mcp.mjs')
+const state = await import('../lib/state.mjs')
+const { currentT } = await import('../lib/i18n.mjs')
+const { registerCoreTools } = await import('../lib/tools.mjs?opts=' + Date.now())
+
+// One workspace per case: distinct store keys, so no case can leak into another.
+const WS_A = 'D:/work/a' // readOnly:true on an existing row
+const WS_B = 'D:/work/b' // readOnly:false — the security red line
+const WS_C = 'D:/work/c' // options with no row and no auto-discovery
+const WS_D = 'D:/work/d' // auto-discovered -> promoted on an explicit options write
+const WS_E = 'D:/work/e' // SSH facts + connection facts keep the original DSN
+
+const REGISTRY = [
+  { path: WS_A, title: 'a' },
+  { path: WS_B, title: 'b' },
+  { path: WS_C, title: 'c' },
+  { path: WS_D, title: 'd' },
+  { path: WS_E, title: 'e' },
+]
+
+const AUTO_ENV = WS_D + '/.env'
+const AUTO_DSN = 'mysql://127.0.0.1:3306/auto'
+
+// `mise env` fails IMMEDIATELY (a failed handle settles at once, so no case
+// burns the 2.5 s discovery budget), while a dbhub probe completes the MCP
+// handshake: the probe-first loop's SUCCESS branches are what cases 1 and 5
+// assert (option applied without rebuilding the DSN / without a dialog).
+function failHandle() {
+  return {
+    stdin: { write() {} },
+    stdout: { on() {} },
+    stderr: { on() {} },
+    done: Promise.resolve({ exitCode: 1 }),
+    terminate() {},
+    waitForExit: async () => ({ exitCode: 1 }),
+  }
+}
+function okHandle() {
+  let onData = null
+  return {
+    stdin: {
+      write(chunk) {
+        let req
+        try {
+          req = JSON.parse(String(chunk))
+        } catch (e) {
+          return
+        }
+        const result =
+          req.method === 'tools/call'
+            ? { content: [{ type: 'text', text: 'ok' }] }
+            : {
+                protocolVersion: '2025-03-26',
+                capabilities: {},
+                serverInfo: { name: 'fake-dbhub', version: '1.4.0' },
+              }
+        queueMicrotask(() => {
+          if (onData) onData(JSON.stringify({ jsonrpc: '2.0', id: req.id, result }) + '\n')
+        })
+      },
+    },
+    stdout: {
+      on(event, handler) {
+        if (event === 'data') onData = handler
+      },
+    },
+    stderr: { on() {} },
+    done: new Promise(() => {}), // stays alive: no early settle for a live probe
+    terminate() {},
+    waitForExit: async () => ({ exitCode: 0 }),
+  }
+}
+const subprocess = {
+  resolveExecutable: async (name) => '/nonexistent/' + name,
+  spawn: ({ argv }) => (String((argv && argv[0]) || '').includes('dbhub') ? okHandle() : failHandle()),
+}
+
+const dialogs = []
+const fakeQuestions = {
+  ask: async (params) => {
+    dialogs.push(params)
+    return { answers: [] } // reached at all = an unexpected dialog
+  },
+}
+const fakeFs = {
+  resolve: async (name, opts) => {
+    if (name === '.env' && opts && opts.cwd === WS_D) return AUTO_ENV
+    throw new Error('no .env')
+  },
+  readText: async (target) => (target === AUTO_ENV ? 'DSN=' + AUTO_DSN + '\n' : ''),
+}
+
+const captured = {}
+const ctx = {
+  tools: {
+    register: (def) => {
+      captured[def.name] = def
+      return () => {}
+    },
+  },
+  get: (name) => {
+    if (name === 'userQuestions') return fakeQuestions
+    if (name === 'fs') return fakeFs
+    if (name === 'workspaceRegistry') return { list: async () => REGISTRY }
+    return undefined
+  },
+  inject: () => {},
+}
+registerCoreTools(ctx, subprocess)
+
+const execFor = (wsPath) => ({ agent: { session: { header: { cwd: wsPath } } }, signal: undefined })
+const configure = (args, wsPath) => captured.dbhub_configure.execute(args, execFor(wsPath))
+const rowOf = (wsPath, env) =>
+  cfg.listWorkspaceEnvironments(cfg.store).find((r) => r.wsPath === wsPath && r.env === env)
+
+test.before(() => {
+  if (!state.isEnabled()) state.setEnabled(true)
+  cfg.resetAutoDsnCache()
+})
+
+test.after(() => {
+  rmSync(home, { recursive: true, force: true })
+})
+
+test('readOnly:true on an existing row tightens the switch with zero dialogs', async () => {
+  const dsn = 'mysql://127.0.0.1:3306/a'
+  cfg.setWorkspaceEnv(WS_A, 'default', dsn, 'user')
+  dialogs.length = 0
+
+  const res = await configure({ readOnly: true }, WS_A)
+
+  assert.equal(res.ok, true, res.text)
+  const row = rowOf(WS_A, 'default')
+  assert.equal(row.ro, true, 'the read-only flag is persisted')
+  assert.equal(row.dsn, dsn, 'an options-only write never touches the DSN')
+  assert.equal(row.source, 'user')
+  assert.equal(dialogs.length, 0, 'tightening a safety switch needs no user input')
+  assert.ok(res.text.includes(currentT('result.readOnlyOn', { env: 'default' })), res.text)
+  // The option write still runs the host-side check of the EFFECTIVE connection.
+  assert.ok(res.text.includes(currentT('result.savedProbeOk')), res.text)
+})
+
+test('readOnly:false is refused and writes nothing (user-only action)', async () => {
+  cfg.setWorkspaceEnv(WS_B, 'default', 'mysql://127.0.0.1:3306/b', 'user')
+  const snapshot = JSON.stringify(cfg.store[WS_B])
+  dialogs.length = 0
+
+  const res = await configure({ readOnly: false }, WS_B)
+
+  assert.equal(res.ok, false)
+  assert.equal(res.text, currentT('result.readOnlyUserOnly'))
+  assert.equal(
+    JSON.stringify(cfg.store[WS_B]),
+    snapshot,
+    'the store must be byte-identical after a refused relax',
+  )
+  assert.equal(dialogs.length, 0, 'a refused relax must not even prompt the user')
+})
+
+test('options with no row and no auto-discovery are refused with guidance', async () => {
+  dialogs.length = 0
+
+  const res = await configure({ readOnly: true }, WS_C)
+
+  assert.equal(res.ok, false)
+  assert.equal(res.text, currentT('result.needConnFirst'))
+  assert.equal(cfg.store[WS_C], undefined, 'nothing may be persisted without a connection')
+  assert.equal(dialogs.length, 0)
+})
+
+test('options on an auto-discovered environment promote it to a persisted row', async () => {
+  assert.equal(cfg.store[WS_D], undefined, 'precondition: the connection is not persisted')
+
+  const res = await configure({ readOnly: true }, WS_D)
+
+  assert.equal(res.ok, true, res.text)
+  const row = rowOf(WS_D, 'default')
+  assert.ok(row, 'the promotion must persist the auto-discovered connection')
+  assert.equal(row.dsn, AUTO_DSN)
+  assert.equal(row.source, 'promoted')
+  assert.equal(row.ro, true)
+  assert.ok(res.text.includes(currentT('result.promotedNotice')), res.text)
+})
+
+test('SSH facts on an existing row keep the original DSN when the endpoint is unchanged', async () => {
+  const dsn = 'mysql://u:p@127.0.0.1:3306/e'
+  cfg.setWorkspaceEnv(WS_E, 'default', dsn, 'user')
+  dialogs.length = 0
+
+  const res = await configure(
+    {
+      sshHost: 'bastion.example.com',
+      sshUser: 'deploy',
+      sshAuthKind: 'key',
+      sshKeyPath: '~/.ssh/id_ed25519',
+      host: '127.0.0.1',
+      database: 'e',
+    },
+    WS_E,
+  )
+
+  assert.equal(res.ok, true, res.text)
+  const row = rowOf(WS_E, 'default')
+  assert.equal(row.dsn, dsn, 'a same-endpoint call must not rebuild the DSN')
+  assert.ok(row.ssh, 'the tunnel is persisted with the connection facts')
+  assert.equal(row.ssh.host, 'bastion.example.com')
+  assert.equal(row.ssh.auth, 'key')
+  assert.equal(dialogs.length, 0, 'a model-supplied key path needs no dialog')
+  // The unchanged endpoint means the EXISTING row (with its stored password) was
+  // verified in place — no re-entry, no rebuilt DSN.
+  assert.ok(
+    res.text.includes(
+      currentT('result.existingOk', {
+        env: 'default',
+        conn: 'mysql://127.0.0.1:3306/e',
+        srcId: mcp.sourceIdOf({ title: 'e', wsPath: WS_E, env: 'default' }),
+      }),
+    ),
+    res.text,
+  )
+})

package/test/configure-ssh.test.mjs

@@ -0,0 +1,232 @@
+// dbhub_configure's SSH tunnel surface (lib/tools.mjs resolveSshRequest and the
+// options-only write it feeds). §7.5's last rows:
+//
+//   * the model may NAME a tunnel (host/port/user/auth kind/key path) but never
+//     CARRY its secret: a password is collected in a UI dialog, stored host-side,
+//     and must not appear in the tool result either;
+//   * a model-argument mistake (no user, multi-hop ProxyJump) is refused without
+//     a dialog and without a write;
+//   * a dismissed dialog cancels the whole call;
+//   * sshOff clears ONLY the tunnel: the connection and the safety switch stay.
+
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const home = mkdtempSync(join(tmpdir(), 'dsh-dbhub-ssh-'))
+process.env.DSH_HOME = home
+
+// Plain imports = the very singletons lib/tools.mjs uses (see copy-from.test.mjs).
+const cfg = await import('../lib/config.mjs')
+const state = await import('../lib/state.mjs')
+const { currentT } = await import('../lib/i18n.mjs')
+const { registerCoreTools } = await import('../lib/tools.mjs?ssh=' + Date.now())
+
+// One workspace per case, so a leaked write can never masquerade as a pass.
+const WS_P = 'D:/work/p' // password auth -> dialog -> stored secret
+const WS_M = 'D:/work/m' // missing sshUser
+const WS_X = 'D:/work/x' // user cancels the dialog
+const WS_O = 'D:/work/o' // sshOff keeps DSN + read-only
+const WS_J = 'D:/work/j' // multi-hop ProxyJump
+const WS_K = 'D:/work/k' // key auth with a model-supplied key path
+
+const REGISTRY = [WS_P, WS_M, WS_X, WS_O, WS_J, WS_K].map((path) => ({
+  path,
+  title: path.slice(-1),
+}))
+
+// Failed probe (exit 1): the option write happens before the probe and its
+// outcome is only appended to the reply, so every case asserts store state.
+const subprocess = {
+  resolveExecutable: async (name) => '/nonexistent/' + name,
+  spawn: () => ({
+    stdin: { write() {} },
+    stdout: { on() {} },
+    stderr: { on() {} },
+    done: Promise.resolve({ exitCode: 1 }),
+    terminate() {},
+    waitForExit: async () => ({ exitCode: 1 }),
+  }),
+}
+
+const dialogs = []
+let responder = async () => undefined
+const fakeQuestions = {
+  ask: async (params) => {
+    dialogs.push(params)
+    return responder(params)
+  },
+}
+const fakeFs = {
+  resolve: async () => {
+    throw new Error('no .env')
+  },
+  readText: async () => '',
+}
+
+const captured = {}
+const ctx = {
+  tools: {
+    register: (def) => {
+      captured[def.name] = def
+      return () => {}
+    },
+  },
+  get: (name) => {
+    if (name === 'userQuestions') return fakeQuestions
+    if (name === 'fs') return fakeFs
+    if (name === 'workspaceRegistry') return { list: async () => REGISTRY }
+    return undefined
+  },
+  inject: () => {},
+}
+registerCoreTools(ctx, subprocess)
+
+const execFor = (wsPath) => ({ agent: { session: { header: { cwd: wsPath } } }, signal: undefined })
+const configure = (args, wsPath) => captured.dbhub_configure.execute(args, execFor(wsPath))
+const rowOf = (wsPath, env) =>
+  cfg.listWorkspaceEnvironments(cfg.store).find((r) => r.wsPath === wsPath && r.env === env)
+
+const HOST = 'bastion.example.com'
+
+test.before(() => {
+  if (!state.isEnabled()) state.setEnabled(true)
+})
+
+test.after(() => {
+  rmSync(home, { recursive: true, force: true })
+})
+
+test('a password-auth tunnel stores the user-entered password and never echoes it', async () => {
+  cfg.setWorkspaceEnv(WS_P, 'default', 'mysql://u:p@127.0.0.1:3306/p', 'user')
+  dialogs.length = 0
+  responder = async () => ({ answers: [{ id: 'sshPassword', custom: 'CHANGE_ME' }] })
+
+  const res = await configure(
+    { sshHost: HOST, sshUser: 'deploy', sshAuthKind: 'password' },
+    WS_P,
+  )
+
+  assert.equal(res.ok, true, res.text)
+  const row = rowOf(WS_P, 'default')
+  assert.ok(row.ssh, 'the tunnel is persisted')
+  assert.equal(row.ssh.auth, 'password')
+  assert.equal(row.ssh.password, 'CHANGE_ME', 'the dialog secret is stored host-side')
+  assert.equal(row.ssh.host, HOST)
+
+  assert.equal(dialogs.length, 1, 'exactly one password dialog')
+  assert.equal(dialogs[0].questions[0].id, 'sshPassword')
+
+  // Zero-knowledge surface: the reply may describe the tunnel, never its secret.
+  assert.ok(!res.text.includes('CHANGE_ME'), 'the stored password must not be echoed to the model')
+  assert.ok(res.text.includes(HOST), res.text)
+  assert.ok(res.text.includes('deploy'), res.text)
+})
+
+test('an SSH request without a user is refused before anything is written', async () => {
+  cfg.setWorkspaceEnv(WS_M, 'default', 'mysql://127.0.0.1:3306/m', 'user')
+  const snapshot = JSON.stringify(cfg.store[WS_M])
+  dialogs.length = 0
+  responder = async () => undefined
+
+  const res = await configure(
+    { sshHost: HOST, sshAuthKind: 'key', sshKeyPath: '~/.ssh/id_ed25519' },
+    WS_M,
+  )
+
+  assert.equal(res.ok, false)
+  assert.equal(res.text, currentT('result.sshMissingUser'))
+  assert.equal(JSON.stringify(cfg.store[WS_M]), snapshot, 'nothing may be written')
+  assert.equal(dialogs.length, 0, 'a missing host/user is a model-argument error, not a dialog')
+})
+
+test('a dismissed SSH dialog cancels the call and writes nothing', async () => {
+  cfg.setWorkspaceEnv(WS_X, 'default', 'mysql://127.0.0.1:3306/x', 'user')
+  const snapshot = JSON.stringify(cfg.store[WS_X])
+  dialogs.length = 0
+  responder = async () => undefined // the user closed/cancelled the ask
+
+  const res = await configure(
+    { sshHost: HOST, sshUser: 'deploy', sshAuthKind: 'password' },
+    WS_X,
+  )
+
+  assert.equal(res.ok, false)
+  assert.equal(res.text, currentT('result.modeCanceled'))
+  assert.equal(dialogs.length, 1)
+  assert.equal(JSON.stringify(cfg.store[WS_X]), snapshot, 'a cancel writes nothing')
+})
+
+test('sshOff removes the tunnel while the DSN and read-only flag survive', async () => {
+  const dsn = 'mysql://u:p@127.0.0.1:3306/o'
+  cfg.setWorkspaceEnv(WS_O, 'default', dsn, 'user', {
+    readOnly: true,
+    ssh: {
+      host: HOST,
+      port: 22,
+      user: 'deploy',
+      auth: 'key',
+      keyPath: '~/.ssh/id_ed25519',
+    },
+  })
+
+  const res = await configure({ sshOff: true }, WS_O)
+
+  assert.equal(res.ok, true, res.text)
+  const entry = cfg.store[WS_O].environments.default
+  assert.equal('ssh' in entry, false, 'the ssh field must be DELETED, not blanked')
+  assert.equal(entry.dsn, dsn, 'the connection string is untouched')
+  assert.equal(entry.readOnly, true, 'the safety switch survives sshOff')
+
+  const row = rowOf(WS_O, 'default')
+  assert.equal(row.ssh, null)
+  assert.equal(row.ro, true)
+  assert.ok(res.text.includes(currentT('result.sshCleared', { env: 'default' })), res.text)
+})
+
+test('a multi-hop ProxyJump is refused and nothing is written', async () => {
+  cfg.setWorkspaceEnv(WS_J, 'default', 'mysql://127.0.0.1:3306/j', 'user')
+  const snapshot = JSON.stringify(cfg.store[WS_J])
+  dialogs.length = 0
+
+  const res = await configure(
+    {
+      sshHost: HOST,
+      sshUser: 'deploy',
+      sshAuthKind: 'key',
+      sshKeyPath: '~/.ssh/id_ed25519',
+      sshProxyJump: 'a:22,b:22',
+    },
+    WS_J,
+  )
+
+  assert.equal(res.ok, false)
+  assert.equal(res.text, currentT('result.sshMultiHopUnsupported'))
+  assert.equal(JSON.stringify(cfg.store[WS_J]), snapshot, 'a refused tunnel writes nothing')
+  assert.equal(dialogs.length, 0)
+})
+
+test('key auth with a model-supplied key path needs no dialog and stores no secret', async () => {
+  cfg.setWorkspaceEnv(WS_K, 'default', 'mysql://u:p@127.0.0.1:3306/k', 'user')
+  dialogs.length = 0
+  responder = async () => undefined
+
+  const res = await configure(
+    { sshHost: HOST, sshUser: 'deploy', sshAuthKind: 'key', sshKeyPath: '~/.ssh/id_ed25519' },
+    WS_K,
+  )
+
+  assert.equal(res.ok, true, res.text)
+  assert.equal(dialogs.length, 0, 'a key path is not a secret: no dialog')
+  const row = rowOf(WS_K, 'default')
+  assert.equal(row.ssh.auth, 'key')
+  assert.equal(row.ssh.keyPath, '~/.ssh/id_ed25519')
+  assert.equal(row.ssh.password, undefined)
+  assert.equal(row.ssh.passphrase, undefined, 'no passphrase was given, none is stored')
+
+  assert.ok(res.text.includes(HOST), res.text)
+  assert.ok(res.text.includes('deploy'), res.text)
+  assert.ok(!res.text.includes('CHANGE_ME'), 'no secret may surface in the reply')
+})

package/test/copy-from.test.mjs

@@ -0,0 +1,155 @@
+// dbhub_configure's `copyFrom` path (lib/tools.mjs runCopyFrom): reusing another
+// workspace's connection must create a REAL row in THIS workspace, and the model
+// must never be told "source not found" for a handle the plugin itself published.
+//
+// Regression this file locks down: `runCopyFrom` was called with the executing
+// context in the `target` position, so `target.path` was undefined and EVERY copy
+// failed (or wrote under an undefined workspace key). The copy is done host-side
+// only: the DSN is read from the source row and written to the target row, and
+// the model sees neither the DSN nor the password.
+
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const home = mkdtempSync(join(tmpdir(), 'dsh-dbhub-copy-'))
+process.env.DSH_HOME = home
+
+// Plain imports on purpose: lib/tools.mjs (imported below with a cache-busting
+// query) resolves './config.mjs' / './mcp.mjs' / './state.mjs' / './i18n.mjs'
+// WITHOUT a query, so these are the very singletons the plugin uses.
+const cfg = await import('../lib/config.mjs')
+const mcp = await import('../lib/mcp.mjs')
+const state = await import('../lib/state.mjs')
+const { currentT } = await import('../lib/i18n.mjs')
+const { registerCoreTools } = await import('../lib/tools.mjs?copy=' + Date.now())
+
+const APP = 'D:/work/app'
+const OTHER = 'D:/work/other'
+const SRC_DSN = 'mysql://127.0.0.1:3306/app'
+
+// A probe that always fails (exit 1) is all these cases need: nothing real may
+// run, and the copy itself is the regression under test. The probe outcome is
+// only appended to the reply.
+const subprocess = {
+  resolveExecutable: async (name) => '/nonexistent/' + name,
+  spawn: () => ({
+    stdin: { write() {} },
+    stdout: { on() {} },
+    stderr: { on() {} },
+    done: Promise.resolve({ exitCode: 1 }),
+    terminate() {},
+    waitForExit: async () => ({ exitCode: 1 }),
+  }),
+}
+
+const REGISTRY = [
+  { path: APP, title: 'app' },
+  { path: OTHER, title: 'other' },
+]
+
+const dialogs = []
+const fakeQuestions = {
+  ask: async (params) => {
+    dialogs.push(params)
+    return undefined // a copy must never need a dialog anyway
+  },
+}
+const fakeFs = {
+  resolve: async () => {
+    throw new Error('no .env')
+  },
+  readText: async () => '',
+}
+
+const captured = {}
+const ctx = {
+  tools: {
+    register: (def) => {
+      captured[def.name] = def
+      return () => {}
+    },
+  },
+  get: (name) => {
+    if (name === 'userQuestions') return fakeQuestions
+    if (name === 'fs') return fakeFs
+    if (name === 'workspaceRegistry') return { list: async () => REGISTRY }
+    return undefined
+  },
+  inject: () => {},
+}
+registerCoreTools(ctx, subprocess)
+
+const exec = { agent: { session: { header: { cwd: APP } } }, signal: undefined }
+
+test.before(() => {
+  if (!state.isEnabled()) state.setEnabled(true)
+})
+
+test.after(() => {
+  rmSync(home, { recursive: true, force: true })
+})
+
+test('copyFrom brings another workspace connection into THIS workspace', async () => {
+  cfg.setWorkspaceEnv(OTHER, 'default', SRC_DSN, 'user')
+
+  // The handle the model would have read out of dbhub_list_sources — the copy
+  // must accept exactly that.
+  const listed = await captured.dbhub_list_sources.execute({}, exec)
+  assert.equal(listed.ok, true, listed.text)
+  const otherId = mcp.sourceIdOf({ title: 'other', wsPath: OTHER, env: 'default' })
+  assert.ok(listed.text.includes(otherId), 'the source handle must be listed')
+
+  dialogs.length = 0
+  const res = await captured.dbhub_configure.execute({ copyFrom: otherId, env: 'prod' }, exec)
+
+  assert.equal(res.ok, true, res.text)
+  assert.notEqual(res.text, currentT('result.noSource', { src: otherId }))
+  assert.ok(!res.text.includes(currentT('result.noSource', { src: otherId })), res.text)
+
+  const row = cfg
+    .listWorkspaceEnvironments(cfg.store)
+    .find((r) => r.wsPath === APP && r.env === 'prod')
+  assert.ok(row, 'the copied row must live in the CURRENT workspace')
+  assert.equal(row.dsn, SRC_DSN, 'the source DSN is copied host-side, verbatim')
+  assert.equal(row.source, 'copied')
+  assert.equal(dialogs.length, 0, 'a host-side copy needs no user input')
+
+  // The source row is untouched.
+  const source = cfg
+    .listWorkspaceEnvironments(cfg.store)
+    .find((r) => r.wsPath === OTHER && r.env === 'default')
+  assert.equal(source.dsn, SRC_DSN)
+})
+
+test('copying a row onto itself is refused without rewriting the row', async () => {
+  const selfDsn = 'mysql://127.0.0.1:3306/self'
+  cfg.setWorkspaceEnv(APP, 'self', selfDsn, 'user')
+  const selfId = mcp.sourceIdOf({ title: 'app', wsPath: APP, env: 'self' })
+
+  const res = await captured.dbhub_configure.execute({ copyFrom: selfId, env: 'self' }, exec)
+
+  assert.equal(res.ok, false)
+  assert.equal(res.text, currentT('result.copySelf', { title: 'app', env: 'self' }))
+
+  const row = cfg
+    .listWorkspaceEnvironments(cfg.store)
+    .find((r) => r.wsPath === APP && r.env === 'self')
+  assert.equal(row.dsn, selfDsn)
+  assert.equal(row.source, 'user', 'a refused self-copy must not rewrite the row')
+})
+
+test('renameFrom combined with copyFrom is refused as an argument conflict', async () => {
+  const before = JSON.stringify(cfg.store[APP] || {})
+
+  const res = await captured.dbhub_configure.execute(
+    { renameFrom: 'default', copyFrom: 'other', env: 'prod2' },
+    exec,
+  )
+
+  assert.equal(res.ok, false)
+  assert.equal(res.text, currentT('result.argConflict'))
+  assert.equal(JSON.stringify(cfg.store[APP] || {}), before, 'a refused call writes nothing')
+})