dsh-tui-theme 0.7.0 → 0.7.2

package/scripts/runtime-themes-headless.mjs

@@ -240,3 +240,78 @@ assert.ok(followToast.text.includes('pink-day') && followToast.text.includes('re
 assert.equal(JSON.parse(readFileSync(join(dataDir3, 'theme.json'), 'utf8')).theme, 'pink-day', 'the follow pref write still happened')
 await mount3.fiber.dispose()
 console.log('OK toast phase 3: apply-time self-heal and boot-follow toasts delivered on the real host')
+
+// ── Phase 4: settings namespace registers against the REAL service, late ────
+// The stub suites cover the namespace registration with fakes, and phase 3
+// stands in a minimal fake at apply time; this phase mounts a real
+// @deepseek-ai/dsh-settings SettingsProvider AFTER the plugin (and after the
+// extensions row), so the plugin's parked ['settings'] inject fires against
+// the genuine register()/scope/watch machinery. The end-to-end signal: a
+// user-layer followSystem write through the real service flips theme.json.
+const sandbox4 = mkdtempSync(join(tmpdir(), 'pink-settings-late-'))
+process.env.USERPROFILE = sandbox4
+process.env.HOME = sandbox4
+const dataDir4 = join(sandbox4, '.dsh-tui')
+mkdirSync(dataDir4, { recursive: true })
+writeFileSync(join(dataDir4, 'theme-follow.json'), JSON.stringify({ light: true, at: 1 }, null, 2))
+
+const { SettingsProvider } = await import(pathToFileURL(hostRequire.resolve('@deepseek-ai/dsh-settings')).href)
+
+/** Minimal concrete provider: in-memory storage, no file, no background IO. */
+class MemorySettingsProvider extends SettingsProvider {
+  static provide = 'settings'
+  writable = true
+  stored = {}
+  async load() {
+    return { ...this.stored }
+  }
+
+  async persist(ns, section) {
+    this.stored[ns] = { ...section }
+  }
+}
+
+const app4 = new Context()
+await app4.plugin(pluginHost.default ?? pluginHost)
+const mount4 = await mountPlugin(app4)
+await mount4.context.plugin(pink)
+await app4.plugin(extensions.default ?? extensions)
+// Deliberately last: the namespace registration can only be "late" when the
+// service arrives after everything the plugin injects at apply time.
+await app4.plugin(MemorySettingsProvider)
+
+const provider = app4.get('settings')
+assert.ok(provider, 'the real dsh-settings provider must be mounted')
+const settingsDeadline = Date.now() + 5_000
+while (provider.get(SETTINGS_NAMESPACE) === undefined && Date.now() < settingsDeadline) {
+  await sleep(25)
+}
+assert.ok(
+  provider.get(SETTINGS_NAMESPACE),
+  `the plugin namespace must register with the real service within ${5_000}ms of its late arrival`,
+)
+await provider.update(SETTINGS_NAMESPACE, { followSystem: true })
+assert.equal(
+  provider.get(SETTINGS_NAMESPACE)?.followSystem,
+  true,
+  'the real service must resolve the committed user layer for the namespace',
+)
+
+const prefPath4 = join(dataDir4, 'theme.json')
+const followDeadline = Date.now() + 5_000
+let followed = false
+while (!followed && Date.now() < followDeadline) {
+  try {
+    followed = JSON.parse(readFileSync(prefPath4, 'utf8')).theme === 'pink-day'
+  } catch {
+    // Pref not written yet.
+  }
+  if (!followed) await sleep(25)
+}
+assert.equal(
+  followed,
+  true,
+  'the user-layer follow toggle must apply the cached light background through the real service',
+)
+await mount4.fiber.dispose()
+console.log('OK settings: namespace registers late on the real dsh-settings service and drives the follow pref')

package/scripts/validate-themes-against-host.mjs

@@ -105,6 +105,13 @@ assert.deepEqual(
 // guarantee, so the count is reported instead of pinned to a hardcoded floor.
 console.log(`* host Theme key count: ${allKeys.length} (coverage asserted per key)`)
 
+// The color keys the host's /settings screen paints with (screens/Settings.tsx
+// at the pinned baseline: promptBorder card frame, permission card title,
+// selectionBg focused row, suggestion/error/success/inactive/subtle row text
+// and checkbox chips, warning badges). Maintained by hand because the screen
+// has no exported key manifest; revisit this list whenever a dsh-TUI release
+// adds a Theme key to that screen — the per-key coverage assertion below then
+// fails loudly instead of shipping an unreadable settings card.
 const settingsKeys = [
   'promptBorder',
   'selectionBg',

package/scripts/verify-package.mjs

@@ -7,9 +7,14 @@ import { existsSync, readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import assert from 'node:assert/strict'
 
+// This repo deliberately ships no package-lock.json: the pinned host tarball
+// bundles @dsh-std/* packages whose manifests still declare workspace:*, and
+// npm replays a committed lockfile faithfully — every install (npm ci too)
+// dies with EUNSUPPORTEDPROTOCOL. Removing the lockfile makes npm skip the
+// bundled directories instead. The peer/dev consistency checks below therefore
+// read package.json only; CI's contract job guards the deletion (REVIEW.md G1).
 const pluginRoot = fileURLToPath(new URL('..', import.meta.url))
 const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'))
-const lockfile = JSON.parse(readFileSync(new URL('../package-lock.json', import.meta.url), 'utf8'))
 const packCommand = process.platform === 'win32'
   ? { file: 'cmd.exe', args: ['/d', '/s', '/c', 'npm pack --dry-run --json --ignore-scripts'] }
   : { file: 'npm', args: ['pack', '--dry-run', '--json', '--ignore-scripts'] }
@@ -36,6 +41,8 @@ for (const required of [
   'lib/types/pluginId.d.ts',
   'lib/types/settingsSection.js',
   'lib/types/settingsSection.d.ts',
+  'lib/types/liveConfig.js',
+  'lib/types/liveConfig.d.ts',
   'lib/types/statusLine.js',
   'lib/types/statusLine.d.ts',
   'lib/types/themeAssets.js',
@@ -58,6 +65,7 @@ for (const required of [
   'docs/screenshots/settings.png',
   'scripts/verify.mjs',
   'scripts/verify-package.mjs',
+  'scripts/verify-settings-generation.mjs',
   'scripts/headless-order-test.mjs',
   'scripts/runtime-themes-headless.mjs',
   'scripts/validate-themes-against-host.mjs',
@@ -90,12 +98,10 @@ for (const name of Object.keys(packageJson.peerDependencies)) {
   assert.equal(devAccepted, true, `${name} dev pin must be accepted by its peer range`)
 }
 assert.equal(packageJson.dependencies?.['@deepseek-ai/schemastery'], undefined)
-const rootLock = lockfile.packages?.['']
-assert.ok(rootLock, 'lockfile must have root metadata')
-assert.equal(lockfile.version, packageJson.version)
-assert.deepEqual(rootLock.devDependencies, packageJson.devDependencies)
-assert.deepEqual(rootLock.peerDependencies, packageJson.peerDependencies)
-assert.equal(rootLock.dependencies, undefined)
+// The lockfile's root metadata is deliberately not compared here: this script
+// also ships inside the published tarball (package.json `files`), and npm never
+// packs a lockfile, so the check could not hold for a consumer. The repo-level
+// lockfile invariant lives in the CI contract job instead (REVIEW.md G1).
 assert.equal(existsSync(new URL('../lib/types/index.js', import.meta.url)), true)
 
 console.log(`✓ package manifest: ${packed.name}@${packed.version}, ${files.size} files`)

package/scripts/verify-settings-generation.mjs

@@ -0,0 +1,306 @@
+/**
+ * Verify the plugin against a real `@deepseek-ai/dsh-settings` install of the
+ * ≥0.1.7 generation — the Config-derived forms the `/settings` screen reads.
+ *
+ * Why this exists: 0.1.7 removed the namespace-registration API entirely and
+ * projects each profile entry's Cordis Config instead. A plugin that misses the
+ * transition still boots, still registers its card, and simply renders
+ * `命名空间未注册`; a card field whose Config key is not marked volatile renders
+ * `（未设置）` forever. Both are silent, so they get a gate — the reference
+ * record is docs/decisions/2026-09-24-settings-generation-adaptation.md (in the
+ * dsh-tui-find repo), whose migration checklist this script implements for
+ * dsh-tui-theme.
+ *
+ * What it checks (against the built `lib/types/`, not the sources):
+ *   1. `volatileForm(Config)` is non-empty and holds exactly the live keys
+ *      (the entry is listed by `describe()` only when it is);
+ *   2. every live key is writable through the `isVolatilePath` gate;
+ *   3. the card's field paths equal the live keys — the parity that keeps a
+ *      field from rendering editable while nothing serves it;
+ *   4. `projectForm` over a resolved row config yields a value for every live
+ *      knob (all of them carry defaults, so nothing may read `（未设置）`);
+ *   5. the wiring against a real-shaped service (no `register`, has
+ *      `configure`): page policy opts out of the auto page on the plugin's own
+ *      fiber, the initial value comes from the live config, and a
+ *      `loader/volatile-update` re-read sees edited values.
+ *
+ * Usage:
+ *   npm run build && node scripts/verify-settings-generation.mjs
+ *   node scripts/verify-settings-generation.mjs --settings <dir>
+ *   DSH_SETTINGS_DIR=<dir> node scripts/verify-settings-generation.mjs
+ *
+ * `<dir>` is a `@deepseek-ai/dsh-settings` package directory, e.g. the one a
+ * real profile resolves:
+ *   %USERPROFILE%\.dsh\profiles\node_modules\@deepseek-ai\dsh-settings
+ *
+ * Generation detection is behavioural, never a version parse: a legacy
+ * install (≤0.1.6) is reported as "nothing to verify here" and exits 0 — its
+ * path is covered by scripts/verify.mjs. So a green run with the repo's own
+ * (legacy) dependency means "the new-generation path was not exercised", not
+ * "verified"; point DSH_SETTINGS_DIR at a real 0.1.7+ install to gate it.
+ * Exit code 1 on any failed check.
+ *
+ * The probe runs from a scratch directory inside the settings tree's own
+ * `node_modules`, so the plugin's bare import (`@deepseek-ai/schemastery`)
+ * resolves exactly as it does at runtime there — the marking only happens on a
+ * schemastery that knows `.volatile()` (3.18.3+), and that is the host's copy,
+ * not this repo's. The directory is removed on the way out.
+ */
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const repoRoot = dirname(dirname(fileURLToPath(import.meta.url)))
+
+function parseArgs(argv) {
+  let settings
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--settings') {
+      if (argv[i + 1] === undefined) throw new Error('--settings needs a directory argument')
+      settings = argv[++i]
+    } else {
+      throw new Error(`unknown option: ${argv[i]}`)
+    }
+  }
+  return { settings }
+}
+
+/** Where the settings package lives: --settings, then DSH_SETTINGS_DIR, then
+ *  this repo's own tree. */
+function resolveSettingsDir(explicit) {
+  const candidate =
+    explicit ?? process.env['DSH_SETTINGS_DIR'] ?? join(repoRoot, 'node_modules', '@deepseek-ai', 'dsh-settings')
+  if (!existsSync(join(candidate, 'package.json'))) {
+    throw new Error(
+      `no @deepseek-ai/dsh-settings at ${candidate}\n` +
+        'pass --settings <dir> or set DSH_SETTINGS_DIR (a real profile resolves it under ' +
+        '<DSH_HOME>/profiles/node_modules/@deepseek-ai/dsh-settings)',
+    )
+  }
+  return candidate
+}
+
+const failures = []
+function check(label, ok, detail = '') {
+  console.log(`${ok ? 'ok  ' : 'FAIL'} ${label}${detail === '' ? '' : ` — ${detail}`}`)
+  if (!ok) failures.push(label)
+}
+function note(text) {
+  console.log(`  · ${text}`)
+}
+
+const { settings: explicitSettings } = parseArgs(process.argv.slice(2))
+const settingsDir = resolveSettingsDir(explicitSettings)
+const version = JSON.parse(readFileSync(join(settingsDir, 'package.json'), 'utf8')).version
+console.log(`* @deepseek-ai/dsh-settings ${version} (${settingsDir})`)
+
+// Generation detection: the Config-derived surface needs `lib/types/schema.js`
+// (volatileForm/projectForm/isVolatilePath) and there must be no
+// namespace-registration class to fall back on.
+const schemaModule = join(settingsDir, 'lib', 'types', 'schema.js')
+const lib = await import(pathToFileURL(join(settingsDir, 'lib', 'index.js')).href)
+const provider =
+  lib.SettingsForms ??
+  lib.default ??
+  Object.values(lib).find(value => typeof value === 'function' && value.prototype !== undefined)
+const legacyRegister = typeof provider?.prototype?.register === 'function'
+if (!existsSync(schemaModule) || legacyRegister) {
+  console.log('* ≤0.1.6 generation (namespace registration): nothing to verify here.')
+  console.log('  The plugin\'s legacy path is covered by scripts/verify.mjs.')
+  console.log('  Point DSH_SETTINGS_DIR at a real ≥0.1.7 install to exercise the Config-derived path.')
+  process.exit(0)
+}
+console.log('* ≥0.1.7 generation (Config-derived forms): verifying the plugin card against it.')
+
+const buildDir = join(repoRoot, 'lib', 'types')
+for (const file of ['index.js', 'liveConfig.js', 'settingsSection.js']) {
+  if (!existsSync(join(buildDir, file))) {
+    throw new Error(`lib/types/${file} is missing — run \`npm run build\` first`)
+  }
+}
+
+// Scratch dir inside the settings tree's node_modules: bare specifiers resolve
+// from there exactly as the plugin's own copy would at runtime.
+const probeRoot = join(dirname(dirname(settingsDir)), `.dsh-tui-theme-settings-probe-${process.pid}`)
+try {
+  rmSync(probeRoot, { recursive: true, force: true })
+  mkdirSync(probeRoot, { recursive: true })
+  cpSync(buildDir, join(probeRoot, 'types'), { recursive: true })
+
+  const plugin = name => import(pathToFileURL(join(probeRoot, 'types', name)).href)
+  const helper = name => import(pathToFileURL(join(settingsDir, 'lib', 'types', name)).href)
+
+  const { Config } = await plugin('index.js')
+  const { LIVE_CONFIG_KEYS, hasLiveConfigFields, readConfigValues } = await plugin('liveConfig.js')
+  const { registerPinkSettings, resolveSettingsNamespace, SETTINGS_NS } = await plugin('settingsSection.js')
+  const { volatileForm, projectForm, plainConfig, isVolatilePath } = await helper('schema.js')
+
+  // The host's own schemastery: 3.18.3+ parses marked fields into live refs.
+  const hostRequire = createRequire(join(settingsDir, 'lib', 'index.js'))
+  const z = (await import(pathToFileURL(hostRequire.resolve('@deepseek-ai/schemastery')).href)).default
+  const volatileCapable = typeof z?.string?.().volatile === 'function'
+
+  const liveKeys = [...LIVE_CONFIG_KEYS].sort()
+  const form = volatileForm(Config)
+  check('a live marker exists on the shipped Config', hasLiveConfigFields(Config))
+  check('volatileForm(Config) is non-empty (describe() lists the entry)', form !== undefined)
+  const formKeys = Object.keys(form?.dict ?? {}).sort()
+  check(
+    'live keys == form-projected keys',
+    JSON.stringify(formKeys) === JSON.stringify(liveKeys),
+    formKeys.join(', '),
+  )
+  check('every live key passes the write gate', LIVE_CONFIG_KEYS.every(key => isVolatilePath(Config, [key])))
+
+  // The namespace follows the Loader entry id on this generation (dsh-TUI
+  // #990's fragility: the host keys by entry id, so a renamed row must move
+  // the card with it) and falls back to the constant for an unusable id.
+  const withEntry = id => ({ fiber: { entry: { options: { id } } } })
+  check(
+    'namespace follows the Loader entry id',
+    resolveSettingsNamespace(withEntry('custom-theme')) === 'custom-theme',
+    resolveSettingsNamespace(withEntry('custom-theme')),
+  )
+  check(
+    'namespace falls back for an unusable entry id',
+    resolveSettingsNamespace(withEntry('Custom.TUI')) === SETTINGS_NS,
+  )
+  check('namespace defaults to the constant without a Loader entry', resolveSettingsNamespace({}) === SETTINGS_NS)
+
+  // Every live knob carries a schema default here, so the projection must
+  // serve a value for each one (the `（未设置）` symptom is a defaulted field
+  // missing from the form).
+  const unset = projectForm(form, plainConfig(Config({})))
+  const unsetMissing = LIVE_CONFIG_KEYS.filter(key => unset[key] === undefined)
+  check('every live knob is served (no （未设置）)', unsetMissing.length === 0, unsetMissing.join(', '))
+
+  const rowConfig = Config({
+    followSystem: true,
+    statusGlyph: '❀',
+    statusSeparator: '✦',
+    showGlyph: true,
+    showClock: false,
+    showTurns: true,
+    statusScope: 'all-themes',
+  })
+  const view = projectForm(form, plainConfig(rowConfig))
+  check(
+    'user values survive the projection',
+    view.statusGlyph === '❀' &&
+      view.statusSeparator === '✦' &&
+      view.showClock === false &&
+      view.statusScope === 'all-themes' &&
+      view.followSystem === true,
+    JSON.stringify(view),
+  )
+
+  if (volatileCapable) {
+    check(
+      'the host sends marked fields as live refs',
+      typeof rowConfig.statusGlyph === 'object' && rowConfig.statusGlyph !== null,
+    )
+    check('apply-time config resolves through live refs', readConfigValues(rowConfig).statusGlyph === '❀')
+  } else {
+    note('this host schemastery has no .volatile(): values stay plain; meta marking still projects')
+  }
+
+  // The wiring, against a service shaped like the real one: no `register`, a
+  // per-instance page policy, and the values coming from the live Config.
+  const warns = []
+  const cards = []
+  const configured = []
+  const applied = []
+  let refresh
+  const service = {
+    configure: (presentation, owner) => {
+      configured.push({ presentation, owner })
+      return () => {}
+    },
+    describe: () => [],
+    update: async () => {},
+    mutate: async () => {},
+  }
+  const sections = {
+    register: section => {
+      cards.push(section)
+      return () => {}
+    },
+  }
+  const logger = { warn: message => warns.push(String(message)), info: () => {}, error: () => {} }
+  const child = dep => ({
+    [dep]: dep === 'settings' ? service : sections,
+    effect: factory => factory(),
+    logger,
+  })
+  const ctx = {
+    get: key => (key === 'tuiSettingsSections' ? sections : undefined),
+    effect: factory => factory(),
+    inject: (deps, callback) => {
+      for (const dep of deps) callback(child(dep))
+    },
+    on: (event, listener) => {
+      check('listens on loader/volatile-update', event === 'loader/volatile-update', event)
+      refresh = listener
+      return () => {}
+    },
+    // The plugin's own fiber, as the Loader reports it: the namespace source
+    // and the owner the page policy must attach to.
+    fiber: { entry: { options: { id: SETTINGS_NS } } },
+    logger,
+  }
+
+  const live = { current: rowConfig }
+  registerPinkSettings(
+    ctx,
+    {
+      cordis: { statusGlyph: '✿', statusSeparator: '·', showGlyph: true, showClock: true, showTurns: true, statusScope: 'pink-only', statusEnabled: true, followSystem: false },
+      readLive: () => readConfigValues(live.current),
+      hasLiveFields: hasLiveConfigFields(Config),
+      onDoc: doc => applied.push(doc),
+    },
+    join(probeRoot, 'data'),
+  )
+
+  check('the card takes the Loader entry id as its namespace', cards[0]?.ns === SETTINGS_NS, String(cards[0]?.ns))
+  check('no namespace registration is attempted', typeof service.register === 'undefined')
+  check(
+    'page policy opts out of the auto page on the plugin fiber',
+    configured.length === 1 &&
+      configured[0].presentation.auto === false &&
+      configured[0].owner === ctx.fiber,
+  )
+  const cardPaths = (cards[0]?.fields ?? []).map(field => field.path.join('.')).sort()
+  check('card fields == live keys', JSON.stringify(cardPaths) === JSON.stringify(liveKeys), cardPaths.join(', '))
+  check('initial value comes from the live config', applied.at(-1)?.statusGlyph === '❀')
+  check('a healthy ≥0.1.7 host logs no warning', warns.length === 0, warns.join(' | '))
+
+  const edited = Config({
+    followSystem: false,
+    statusGlyph: '🌸',
+    statusSeparator: '·',
+    showGlyph: false,
+    showClock: true,
+    showTurns: false,
+    statusScope: 'pink-only',
+  })
+  // Model the loader's in-place rewrite: the plugin re-reads the same object.
+  for (const key of Object.keys(edited)) live.current[key] = edited[key]
+  refresh?.()
+  check(
+    'a volatile update re-reads the edited config',
+    applied.at(-1)?.statusGlyph === '🌸' &&
+      applied.at(-1)?.showGlyph === false &&
+      applied.at(-1)?.showClock === true &&
+      applied.at(-1)?.followSystem === false,
+    JSON.stringify(applied.at(-1)),
+  )
+} finally {
+  rmSync(probeRoot, { recursive: true, force: true })
+}
+
+if (failures.length > 0) {
+  console.error(`\n${failures.length} check(s) failed`)
+  process.exit(1)
+}
+console.log('\nall checks passed')