dsh-ris-yds 0.0.0-stage → 1.0.0

package/test/cli.test.mjs

@@ -0,0 +1,246 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import {
+  browserCookieHint,
+  expectedRdbga,
+  healBrowserCookie,
+  noDevtoolsHint,
+  run,
+} from '../lib/cli.js'
+import { rdbgaValue } from '../lib/yms.js'
+
+// The suite runs in its own process but inherits the developer's shell: strip every
+// YDS_* override so each case sees only the fixture workspace below.
+for (const key of Object.keys(process.env)) {
+  if (key.startsWith('YDS_')) delete process.env[key]
+}
+
+const WORKBENCH = 'https://srmdev.hanslaser.com'
+const WORKBENCH_HOST = 'srmdev.hanslaser.com'
+const CFG = {
+  module: 'c-ass-kk-hans',
+  context: '/',
+  serverBindAddress: '172.20.63.131',
+  serverPort: 31010,
+  workbenchUrl: WORKBENCH,
+}
+const EXPECTED = rdbgaValue(CFG)
+const TARGETS = [{ type: 'page', url: `${WORKBENCH}/`, webSocketDebuggerUrl: 'ws://a' }]
+const NO_PORT = { port: 0, targets: [], hosts: [], error: '没有开着工作台页签的 DevTools 端口（浏览器未启动或未打开工作台）' }
+const FOUND = { port: 9222, targets: TARGETS, hosts: [WORKBENCH_HOST], error: '' }
+const NO_LIVE = async () => ({ ok: false, values: [], error: 'no powershell' })
+
+/**
+ * A throwaway workspace with no project config. A remembered yms port keeps config
+ * resolution from spawning a child to find a free one.
+ */
+function emptyWorkspace() {
+  const dir = mkdtempSync(join(tmpdir(), 'yds-cli-'))
+  mkdirSync(join(dir, '.dsh-ris-yds'), { recursive: true })
+  writeFileSync(join(dir, '.dsh-ris-yds', 'yms-port'), '65000')
+  return dir
+}
+
+async function runInEmptyWorkspace(argv) {
+  const dir = emptyWorkspace()
+  try {
+    return await run(argv, { cwd: dir })
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+}
+
+test('an unknown browser action is rejected before any port is probed', async () => {
+  const result = await runInEmptyWorkspace(['browser', 'frobnicate'])
+  assert.equal(result.exitCode, 1)
+  assert.match(result.text, /未知动作: frobnicate/)
+  assert.match(result.text, /用法: yds browser/)
+})
+
+test('extra positional arguments are reported, not silently ignored', async () => {
+  const result = await runInEmptyWorkspace(['browser', 'status', 'extra'])
+  assert.equal(result.exitCode, 1)
+  assert.match(result.text, /多余参数: extra/)
+})
+
+test('an unknown option is reported, not silently ignored', async () => {
+  const result = await runInEmptyWorkspace(['browser', 'status', '--bogus'])
+  assert.equal(result.exitCode, 1)
+  assert.match(result.text, /未知选项: --bogus/)
+})
+
+test('an empty --rdbga is rejected instead of silently falling back', async () => {
+  const result = await runInEmptyWorkspace(['browser', 'status', '--rdbga='])
+  assert.equal(result.exitCode, 1)
+  assert.match(result.text, /--rdbga 需要一个 base64 值/)
+})
+
+test('--dry-run is refused for the read-only action', async () => {
+  const result = await runInEmptyWorkspace(['browser', 'status', '--dry-run'])
+  assert.equal(result.exitCode, 1)
+  assert.match(result.text, /--dry-run 只用于 fix/)
+})
+
+test('an unknown command exits non-zero and prints the usage', async () => {
+  const result = await runInEmptyWorkspace(['frobnicate'])
+  assert.equal(result.exitCode, 1)
+  assert.match(result.text, /用法: node yds\.js <command>/)
+})
+
+test('unknown actions of the other commands are rejected as well', async () => {
+  for (const argv of [['fe', 'bogus'], ['yoncode', 'bogus'], ['proxy', 'bogus'], ['ide', 'bogus']]) {
+    const result = await runInEmptyWorkspace(argv)
+    assert.equal(result.exitCode, 1, argv.join(' '))
+    assert.match(result.text, /未知动作/)
+  }
+})
+
+test('a missing workbench URL is named, and no sentence gets a double space', async () => {
+  const result = await runInEmptyWorkspace(['browser', 'status'])
+  assert.equal(result.exitCode, 1)
+  assert.match(result.text, /workbenchUrl 未配置/)
+  assert.match(result.text, /无法从 workbenchUrl 推断工作台域名/)
+  assert.doesNotMatch(result.text, /在\s{2,}域/)
+  assert.doesNotMatch(result.text, /手工在 {2,}/)
+})
+
+test('cookie hints degrade gracefully without a workbench URL', () => {
+  assert.match(browserCookieHint({ workbenchUrl: '' }, EXPECTED), /workbenchUrl 未配置/)
+  assert.ok(browserCookieHint({ workbenchUrl: '' }, EXPECTED).includes(`rdbga=${EXPECTED}`))
+  assert.ok(browserCookieHint({ workbenchUrl: WORKBENCH }, EXPECTED).includes(`在 ${WORKBENCH} 域下种 cookie`))
+  assert.doesNotMatch(browserCookieHint({}, EXPECTED), /在 {2,}域/)
+
+  assert.match(noDevtoolsHint({ workbenchUrl: '' }), /workbenchUrl 未配置/)
+  assert.doesNotMatch(noDevtoolsHint({}), /在\s{2,}域/)
+  assert.ok(noDevtoolsHint({ workbenchUrl: WORKBENCH }).includes(`在 ${WORKBENCH} 域下`))
+})
+
+test('the expected value comes only from what can be verified', async () => {
+  const own = rdbgaValue(CFG)
+  assert.deepEqual(
+    await expectedRdbga(CFG, '', { liveQuery: NO_LIVE }),
+    { ok: true, value: own, source: '本机配置', hint: 'no powershell' },
+  )
+  const agree = await expectedRdbga(CFG, '', { liveQuery: async () => ({ ok: true, values: [own], error: '' }) })
+  assert.equal(agree.source, '运行中的 JVM')
+  assert.equal(agree.value, own)
+
+  const other = Buffer.from('other,/@1.2.3.4:1').toString('base64')
+  const disagree = await expectedRdbga(CFG, '', {
+    liveQuery: async () => ({ ok: true, values: [other, 'Zm9v'], error: '' }),
+  })
+  assert.equal(disagree.ok, false)
+  // The rule must be explainable: how many JVMs were seen, which values, and that none
+  // matches the configured one.
+  assert.match(disagree.reason, /2 个实例/)
+  assert.ok(disagree.reason.includes(`${other.slice(0, 10)}…`))
+  assert.match(disagree.reason, /都不一致/)
+  assert.match(disagree.reason, /--rdbga/)
+
+  const override = await expectedRdbga(CFG, own, { liveQuery: async () => ({ ok: true, values: ['x'], error: '' }) })
+  assert.deepEqual({ ok: override.ok, value: override.value, source: override.source }, { ok: true, value: own, source: '命令行指定' })
+
+  const bad = await expectedRdbga(CFG, 'not base64 !!', { liveQuery: NO_LIVE })
+  assert.equal(bad.ok, false)
+  assert.match(bad.reason, /base64|解码/)
+
+  const noModule = await expectedRdbga({ ...CFG, module: null }, '', { liveQuery: NO_LIVE })
+  assert.match(noModule.reason, /模块名/)
+  const badBind = await expectedRdbga({ ...CFG, serverBindAddress: 'localhost' }, '', { liveQuery: NO_LIVE })
+  assert.match(badBind.reason, /serverBindAddress/)
+  const badPort = await expectedRdbga({ ...CFG, serverPort: 70000 }, '', { liveQuery: NO_LIVE })
+  assert.match(badPort.reason, /serverPort/)
+})
+
+test('a dry run plans the repair but never reads back or writes', async () => {
+  const logged = []
+  let reads = 0
+  const result = await healBrowserCookie(CFG, {
+    log: (line) => logged.push(line),
+    dryRun: true,
+    findPort: async () => FOUND,
+    liveQuery: NO_LIVE,
+    repair: async ({ dryRun }) => ({ ok: true, tabs: 1, removed: 2, wrote: 1, set: EXPECTED, dryRun }),
+    read: async () => { reads += 1; return { ok: true, cookies: [] } },
+  })
+  assert.deepEqual(
+    { ok: result.ok, dryRun: result.dryRun, removed: result.removed, wrote: result.wrote, source: result.source },
+    { ok: true, dryRun: true, removed: 2, wrote: 1, source: '本机配置' },
+  )
+  assert.equal(reads, 0)
+  assert.match(logged.join('\n'), /预览/)
+})
+
+test('the port is probed before the PowerShell query: no port, no cost', async () => {
+  const order = []
+  const noPort = await healBrowserCookie(CFG, {
+    findPort: async () => { order.push('find'); return NO_PORT },
+    liveQuery: async () => { order.push('live'); return { ok: false, values: [], error: '' } },
+  })
+  assert.equal(noPort.ok, false)
+  assert.match(noPort.reason, /没有开着工作台页签/)
+  assert.deepEqual(order, ['find'])
+
+  order.length = 0
+  const healed = await healBrowserCookie(CFG, {
+    findPort: async () => { order.push('find'); return FOUND },
+    liveQuery: async () => { order.push('live'); return { ok: false, values: [], error: 'no powershell' } },
+    repair: async () => ({ ok: true, tabs: 1, removed: 0, wrote: 0, set: EXPECTED }),
+    read: async () => ({
+      ok: true,
+      cookies: [{ name: 'rdbga', value: EXPECTED, domain: `.${WORKBENCH_HOST}`, path: '/' }],
+    }),
+  })
+  assert.deepEqual(order, ['find', 'live'])
+  assert.deepEqual({ ok: healed.ok, port: healed.port, source: healed.source }, { ok: true, port: 9222, source: '本机配置' })
+})
+
+test('a repair that leaves a wrong cookie behind is a failure, not a success', async () => {
+  const result = await healBrowserCookie(CFG, {
+    findPort: async () => FOUND,
+    liveQuery: NO_LIVE,
+    repair: async () => ({ ok: true, tabs: 1, removed: 1, wrote: 1, set: EXPECTED }),
+    read: async () => ({
+      ok: true,
+      cookies: [
+        { name: 'rdbga', value: EXPECTED, domain: `.${WORKBENCH_HOST}`, path: '/' },
+        { name: 'rdbga', value: '', domain: WORKBENCH_HOST, path: '/' },
+      ],
+    }),
+  })
+  assert.equal(result.ok, false)
+  assert.match(result.reason, /写入后仍有多个/)
+})
+
+test('an unreadable cookie store after the repair is a failure, not a fake success', async () => {
+  const result = await healBrowserCookie(CFG, {
+    findPort: async () => FOUND,
+    liveQuery: NO_LIVE,
+    repair: async () => ({ ok: true, tabs: 1, removed: 1, wrote: 1, set: EXPECTED }),
+    read: async () => ({ ok: false, cookies: [], error: 'CDP 断开' }),
+  })
+  assert.equal(result.ok, false)
+  assert.match(result.reason, /回读 cookie 失败: CDP 断开/)
+})
+
+test('a failed repair is reported with the browser error text', async () => {
+  const result = await healBrowserCookie(CFG, {
+    findPort: async () => FOUND,
+    liveQuery: NO_LIVE,
+    repair: async () => ({ ok: false, error: '所有页签都失败' }),
+  })
+  assert.equal(result.ok, false)
+  assert.match(result.reason, /所有页签都失败/)
+})
+
+test('the budget cuts off a browser that keeps the repair hanging', async () => {
+  const started = Date.now()
+  const result = await healBrowserCookie(CFG, { budgetMs: 30, findPort: () => new Promise(() => {}) })
+  assert.equal(result.ok, false)
+  assert.match(result.reason, /超时/)
+  assert.ok(Date.now() - started < 1000)
+})

package/test/config.test.mjs

@@ -0,0 +1,106 @@
+// Config resolution without any .env: the local listen port is discovered, the
+// front-end port comes from the project (yds.webConfig, else the front end's own
+// override file), and nothing machine-specific has to be configured by hand.
+import assert from 'node:assert/strict'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import test from 'node:test'
+
+import {
+  DEFAULT_FE_PORT,
+  discoverFrontend,
+  findFreePort,
+  isPortFree,
+  pickFrontend,
+  portOfUrl,
+  readRememberedPort,
+} from '../lib/config.js'
+
+/** A throwaway project directory; callers remove it in a finally block. */
+function tempProject() {
+  return mkdtempSync(join(tmpdir(), 'yds-config-'))
+}
+
+test('yds.webConfig picks the entry whose domainKey is the module', () => {
+  const webConfig = {
+    'some-other-fe': { 'yds.domainKey': 'other', 'yds.localDevUrl': 'http://127.0.0.1:9999' },
+    'c-ass-kk-hans-fe': { 'yds.domainKey': 'c-ass-kk-hans', 'yds.localDevUrl': 'http://127.0.0.1:3004', 'yds.debugScript': 'debug' },
+  }
+  const frontend = pickFrontend(webConfig, 'c-ass-kk-hans')
+  assert.equal(frontend.code, 'c-ass-kk-hans-fe')
+  assert.equal(frontend.port, 3004)
+  assert.equal(frontend.debugScript, 'debug')
+})
+
+test('a single entry wins even when the domainKey differs', () => {
+  const frontend = pickFrontend({ 'x-fe': { 'yds.localDevUrl': 'http://127.0.0.1:4100' } }, 'must-not-matter')
+  assert.equal(frontend.port, 4100)
+})
+
+test('no webConfig at all still yields the historical default', () => {
+  const frontend = pickFrontend(undefined, 'c-ass-kk-hans')
+  assert.equal(frontend.port, DEFAULT_FE_PORT)
+})
+
+test('discoverFrontend reads the port from the front end own override file', () => {
+  const dir = tempProject()
+  try {
+    mkdirSync(join(dir, 'c-ass-kk-hans-fe'))
+    writeFileSync(join(dir, 'c-ass-kk-hans-fe', 'resource_override_rules.json'), JSON.stringify({
+      v: 2,
+      ruleGroups: [{ rules: [{ replace: 'https://127.0.0.1:4567/static/javascripts/index.js' }] }],
+    }))
+    const frontend = discoverFrontend(dir, 'c-ass-kk-hans')
+    assert.equal(frontend.port, 4567)
+    assert.equal(frontend.devUrl, 'http://127.0.0.1:4567')
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+test('discoverFrontend falls back when the project has no front end', () => {
+  const dir = tempProject()
+  try {
+    assert.equal(discoverFrontend(dir, 'mod').port, DEFAULT_FE_PORT)
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+test('portOfUrl understands dev URLs and gives up quietly', () => {
+  assert.equal(portOfUrl('http://127.0.0.1:3004'), 3004)
+  assert.equal(portOfUrl('https://127.0.0.1:3004/some/path'), 3004)
+  assert.equal(portOfUrl('http://127.0.0.1'), 0)
+  assert.equal(portOfUrl(''), 0)
+})
+
+test('findFreePort skips a port that is already bound', async () => {
+  const { createServer } = await import('node:net')
+  const busy = await new Promise((resolve) => {
+    const server = createServer()
+    server.listen(0, '127.0.0.1', () => resolve(server))
+  })
+  const busyPort = busy.address().port
+  try {
+    assert.equal(isPortFree(busyPort), false)
+    const picked = findFreePort(busyPort)
+    assert.equal(picked > busyPort, true, `expected a port above ${busyPort}, got ${picked}`)
+    assert.equal(isPortFree(picked), true)
+  } finally {
+    await new Promise((resolve) => busy.close(resolve))
+  }
+})
+
+test('the remembered port survives a restart and absent state is null', () => {
+  const dir = tempProject()
+  try {
+    assert.equal(readRememberedPort(dir), null)
+    writeFileSync(join(dir, 'yms-port'), '31012\n')
+    assert.equal(readRememberedPort(dir), 31012)
+    writeFileSync(join(dir, 'yms-port'), 'not-a-port\n')
+    assert.equal(readRememberedPort(dir), null)
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})

package/test/fe-dev.test.mjs

@@ -0,0 +1,93 @@
+// Front-end dev-server wiring: the override rules are generated from the project
+// config, and the same rules are exposed as regex+substitution pairs so an agent
+// can redirect requests through CDP instead of installing the extension.
+import assert from 'node:assert/strict'
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import test from 'node:test'
+
+import {
+  DEFAULT_FE_PORT,
+  globToDnrRegex,
+  overrideRules,
+  pageUrlWithScriptUrl,
+  requestRedirects,
+  writeOverrideRules,
+} from '../lib/fe-dev.js'
+
+const cfg = {
+  workspace: '',
+  module: 'c-ass-kk-hans',
+  workbenchUrl: 'https://srmdev.hanslaser.com',
+  fePort: 3004,
+}
+
+test('the rules follow the project, not the copy that was hand-edited', () => {
+  const rules = overrideRules(cfg)
+  const list = rules.ruleGroups[0].rules
+  assert.equal(rules.v, 2)
+  assert.equal(list.length, 7)
+  // The three dynamic values: module, workbench host, dev port.
+  assert.match(list[0].match, /c-ass-kk-hans/)
+  assert.match(list[6].match, /^https:\/\/srmdev\.hanslaser\.com\/c-ass-kk-hans-festatic\/\*$/)
+  assert.match(list[0].replace, /^http:\/\/127\.0\.0\.1:3004\/static\/javascripts\/extend\.js$/)
+  // A different project/port produces different rules with no other edits.
+  const other = overrideRules({ module: 'st-storein', workbenchUrl: 'https://tj.example.com', fePort: 4321 })
+  assert.match(other.ruleGroups[0].rules[0].match, /st-storein/)
+  assert.match(other.ruleGroups[0].rules[0].replace, /127\.0\.0\.1:4321/)
+  assert.match(other.ruleGroups[0].rules[6].match, /tj\.example\.com/)
+})
+
+test('glob → regex keeps the extension’s capture semantics', () => {
+  // Last star becomes a capture group (used by \1), the second-to-last becomes
+  // [^/]+ so a trailing segment is not swallowed, the rest are .*
+  const withSuffix = globToDnrRegex('https://*/mod/*/js/extend*.min.js*', 'http://127.0.0.1:3004/static/js/extend.js')
+  assert.equal(withSuffix.regex, '^https://.*/mod/.*/js/extend[^/]+\\.min\\.js(.*)$')
+  const filePrefix = globToDnrRegex('https://host/mod-festatic/*', 'http://127.0.0.1:3004/static/*')
+  assert.equal(filePrefix.regex, '^https://host/mod-festatic/(.*)$')
+  assert.equal(filePrefix.substitution, 'http://127.0.0.1:3004/static/\\1')
+  // Anchored, because the browser's DNR match is anchored too.
+  assert.ok(filePrefix.regex.startsWith('^') && filePrefix.regex.endsWith('$'))
+})
+
+test('the plan is the same seven rules as redirects an agent can apply', () => {
+  const redirects = requestRedirects(cfg)
+  assert.equal(redirects.length, 7)
+  for (const item of redirects) {
+    assert.equal(typeof item.regex, 'string')
+    assert.ok(item.regex.length > 2)
+    assert.equal(typeof item.substitution, 'string')
+    // The regex must actually match the glob's own URL shape.
+    const sample = item.match.replace('*', 'srmdev.hanslaser.com')
+    const probe = sample.replace(/\*/g, 'x')
+    assert.match(probe, new RegExp(item.regex), item.regex)
+  }
+})
+
+test('the rule file is written where the extension can import it', () => {
+  const workspace = mkdtempSync(join(tmpdir(), 'yds-fe-'))
+  try {
+    const written = writeOverrideRules({ ...cfg, workspace })
+    assert.equal(written.path, join(workspace, '.dsh-ris-yds', 'resource-override-rules.json'))
+    assert.equal(written.rules, 7)
+    assert.equal(written.module, 'c-ass-kk-hans')
+    assert.equal(written.fePort, DEFAULT_FE_PORT)
+    assert.ok(existsSync(written.path))
+    const parsed = JSON.parse(readFileSync(written.path, 'utf8'))
+    assert.equal(parsed.ruleGroups[0].rules.length, 7)
+    assert.equal(parsed.ruleGroups[0].rules[0].type, 'normalOverride')
+  } finally {
+    rmSync(workspace, { recursive: true, force: true })
+  }
+})
+
+test('scriptUrl is appended to a page without any extension', () => {
+  const url = pageUrlWithScriptUrl(cfg, '/mdf-node/meta/voucherlist/st_purchaseorderlist?domainKey=upu')
+  const parsed = new URL(url)
+  assert.equal(parsed.host, 'srmdev.hanslaser.com')
+  assert.equal(parsed.searchParams.get('scriptUrl'), 'http://127.0.0.1:3004/static')
+  // The page's own parameters survive.
+  assert.equal(parsed.searchParams.get('domainKey'), 'upu')
+  assert.equal(pageUrlWithScriptUrl(cfg, ''), '')
+})

package/test/ide-config.test.mjs

@@ -0,0 +1,151 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, relative } from 'node:path'
+import {
+  applyIdeConfig, belongsToYdsProject, emptyIdeConfigDocument, frontendProjectName, initializeIdeConfig,
+  isOurs, javaProjectName, removeIdeConfig, repairFrontendNames, repairYdsRows,
+} from '../lib/ide.js'
+
+/** A yds project root: aggregator pom + bootstrap pom with a parent block. */
+function makeProject() {
+  const root = mkdtempSync(join(tmpdir(), 'yds-ide-'))
+  mkdirSync(join(root, 'c-ass-kk-hans-be', 'dev-c-ass-kk-hans-bootstrap'), { recursive: true })
+  writeFileSync(join(root, 'c-ass-kk-hans-be', 'pom.xml'), '<project><artifactId>c-ass-kk-hans</artifactId></project>')
+  writeFileSync(join(root, 'c-ass-kk-hans-be', 'dev-c-ass-kk-hans-bootstrap', 'pom.xml'), `<project>
+  <parent>
+    <artifactId>c-ass-kk-hans</artifactId>
+    <groupId>com.yonyou.ucf</groupId>
+  </parent>
+  <artifactId>c-ass-kk-hans-bootstrap</artifactId>
+</project>`)
+  // The yds marker: an ancestor .vscode/settings.json carrying `yds.` settings.
+  mkdirSync(join(root, '.vscode'), { recursive: true })
+  writeFileSync(join(root, '.vscode', 'settings.json'),
+    '{\n  // yds project\n  "yds.accessKey": "k",\n  "yds.webConfig": {}\n}')
+  mkdirSync(join(root, 'c-ass-kk-hans-fe'))
+  writeFileSync(join(root, 'c-ass-kk-hans-fe', 'package.json'), '{"name":"fe"}')
+  writeFileSync(join(root, 'c-ass-kk-hans-fe', 'module.xml'), '<module name="c-ass-kk-hans-fe" description="前端"/>')
+  return root
+}
+
+test('names come from the project files, not our own bookkeeping', () => {
+  const root = makeProject()
+  const cfg = { projectDir: root, module: 'c-ass-kk-hans' }
+  // java = bootstrap pom's parent.artifactId
+  assert.equal(javaProjectName(cfg), 'c-ass-kk-hans')
+  // frontend = module.xml beside package.json
+  assert.equal(frontendProjectName(cfg), 'c-ass-kk-hans-fe')
+  // no files: fall back to the YMS module name
+  assert.equal(javaProjectName({ projectDir: '/nonexistent', module: 'm1' }), 'm1')
+  rmSync(root, { recursive: true, force: true })
+})
+
+test('apply initialises the config file before writing our row', () => {
+  const root = makeProject()
+  const cfg = { workspace: root, projectDir: root, module: 'c-ass-kk-hans' }
+  const first = applyIdeConfig(cfg)
+  assert.equal(first.action, 'created')
+  assert.equal(first.initialized, true)
+  const doc = JSON.parse(readFileSync(first.path, 'utf8').replace(/^\/\/.*$/gm, ''))
+  // Same shape ris-ide itself generates, plus our row named after the project.
+  assert.deepEqual(doc.defaults, emptyIdeConfigDocument().defaults)
+  assert.equal(doc.version, 1)
+  assert.equal(doc.programs.length, 1)
+  assert.equal(doc.programs[0].name, 'c-ass-kk-hans')
+  // Idempotent second pass.
+  const second = applyIdeConfig(cfg)
+  assert.equal(second.action, 'unchanged')
+  assert.equal(second.initialized, false)
+  // Removal finds it by identity, not by a hardcoded name.
+  assert.equal(removeIdeConfig(cfg).action, 'removed')
+  rmSync(root, { recursive: true, force: true })
+})
+
+test('our rows are recognised across renames', () => {
+  const cfg = { module: 'c-ass-kk-hans', projectDir: '/nonexistent' }
+  assert.equal(isOurs({ name: 'yds-yms-c-ass-kk-hans' }, cfg), true)
+  assert.equal(isOurs({ name: 'other', startCommand: 'node "/x/bin/yds.js" start' }, cfg), true)
+  assert.equal(isOurs({ name: 'other', startCommand: 'npm run dev' }, cfg), false)
+  // A frontend row with the same name is NOT ours — deleting it would be data loss.
+  assert.equal(isOurs({ name: 'c-ass-kk-hans', kind: 'frontend' }, cfg), false)
+  assert.equal(isOurs({ name: 'c-ass-kk-hans', kind: 'spring' }, cfg), true)
+})
+
+test('initialise keeps an existing file untouched', () => {
+  const root = mkdtempSync(join(tmpdir(), 'yds-ide2-'))
+  mkdirSync(join(root, '.dsh-ris-ide'), { recursive: true })
+  const path = join(root, '.dsh-ris-ide', 'config.json')
+  writeFileSync(path, '{ "programs": [{ "name": "user-row" }] }\n')
+  assert.deepEqual(initializeIdeConfig(root), { created: false, path })
+  assert.match(readFileSync(path, 'utf8'), /user-row/)
+  rmSync(root, { recursive: true, force: true })
+})
+
+test('a frontend row of this project is renamed after its module.xml', () => {
+  const root = makeProject()
+  const cfg = { workspace: root, projectDir: root, module: 'c-ass-kk-hans' }
+  const programs = [
+    // generated before the rule existed: package.json's name == the java project name
+    { id: 'frontend:c-ass-kk-hans-fe#start', kind: 'frontend', name: 'c-ass-kk-hans', dir: 'c-ass-kk-hans-fe' },
+    // outside the project: never touched
+    { id: 'frontend:other/ui#dev', kind: 'frontend', name: 'other-ui', dir: '/tmp/other/ui' },
+  ]
+  const result = repairFrontendNames(cfg, programs)
+  assert.equal(result.programs[0].name, 'c-ass-kk-hans-fe')
+  assert.deepEqual(result.renamed, [{ from: 'c-ass-kk-hans', to: 'c-ass-kk-hans-fe' }])
+  assert.equal(result.programs[1].name, 'other-ui')
+  // Membership is decided by `dir` (walking up to .vscode/settings.json), never by name or kind.
+  assert.equal(belongsToYdsProject(cfg, { name: 'x', kind: 'spring', dir: 'c-ass-kk-hans-fe' }), true)
+  assert.equal(belongsToYdsProject(cfg, { name: 'x', dir: '../outside' }), false)
+  // A row whose directory has no yds ancestor is left alone even if it has a module.xml.
+  const outside = join(root, '..', 'plain-npm')
+  mkdirSync(outside, { recursive: true })
+  writeFileSync(join(outside, 'module.xml'), '<module name="renamed-by-accident"/>')
+  const guarded = repairFrontendNames(cfg, [{ name: 'plain', dir: relative(cfg.workspace, outside) }])
+  assert.deepEqual(guarded.renamed, [])
+  rmSync(outside, { recursive: true, force: true })
+  rmSync(root, { recursive: true, force: true })
+})
+
+test('a java row is renamed to its parent artifactId unless the name is taken', () => {
+  const root = makeProject()
+  const cfg = { workspace: root, projectDir: root, module: 'c-ass-kk-hans' }
+  const programs = [
+    // ours: keeps the java project name
+    { name: 'c-ass-kk-hans', kind: 'spring', dir: '.', startCommand: 'node x/bin/yds.js start' },
+    // discovered bootstrap module: would now want the same name -> skipped, not merged
+    { name: 'dev-c-ass-kk-hans-bootstrap', kind: 'spring', dir: 'c-ass-kk-hans-be/dev-c-ass-kk-hans-bootstrap' },
+  ]
+  const result = repairFrontendNames(cfg, programs)
+  assert.equal(result.programs[0].name, 'c-ass-kk-hans')
+  assert.equal(result.programs[1].name, 'dev-c-ass-kk-hans-bootstrap')
+  assert.deepEqual(result.renamed, [])
+  assert.deepEqual(result.skipped.map((item) => item.to), ['c-ass-kk-hans'])
+  rmSync(root, { recursive: true, force: true })
+})
+
+test('the discovered backend row is disabled and a hijacked startCommand is removed', () => {
+  const root = makeProject()
+  const cfg = { workspace: root, projectDir: root, module: 'c-ass-kk-hans' }
+  const ours = { id: `yds:c-ass-kk-hans`, name: 'c-ass-kk-hans', kind: 'spring', dir: '.',
+    startCommand: 'node x/bin/yds.js start --foreground' }
+  const programs = [
+    ours,
+    // the row the panel generates for the same backend — must not compete with ours
+    { id: 'spring:be/bootstrap#Main', name: 'dev-c-ass-kk-hans-bootstrap', kind: 'spring', dir: 'c-ass-kk-hans-be/dev-c-ass-kk-hans-bootstrap' },
+    // a frontend row an older update copied our command onto
+    { id: 'frontend:c-ass-kk-hans-fe#start', name: 'c-ass-kk-hans', kind: 'frontend', dir: 'c-ass-kk-hans-fe',
+      startCommand: 'node x/bin/yds.js start --foreground' },
+  ]
+  const result = repairYdsRows(cfg, programs)
+  assert.deepEqual(result.renamed.map((item) => item.to), ['c-ass-kk-hans-fe'])
+  assert.deepEqual(result.disabled.map((item) => item.name), ['dev-c-ass-kk-hans-bootstrap'])
+  assert.deepEqual(result.cleaned.map((item) => item.name), ['c-ass-kk-hans-fe'])
+  assert.equal(result.programs[0].disabled, undefined, 'our row stays enabled')
+  assert.equal(result.programs[1].disabled, true)
+  assert.equal(result.programs[2].startCommand, undefined)
+  assert.equal(result.programs[2].name, 'c-ass-kk-hans-fe')
+  rmSync(root, { recursive: true, force: true })
+})