@objectivex666/dsh-settings-search 1.12.0 → 1.13.0

package/scripts/ai.test.mjs

@@ -13,6 +13,8 @@ const instrumented = source.replace(hook, `
       requestUserAi, requestAiKeywords, testAiService, LOGS,
       modelsUrl, fetchAiModels,
       readIndexCache, serializeHarvest,
+      readDshModelConfig, otherPluginFingerprint, DEEP_SLOTS,
+      log, flushLogs, discardPendingLogs, sessionLogText, logTarget, readLogCount,
     })
 ${hook}`)
 const storage = () => {
@@ -321,13 +323,17 @@ for (const cfg of [ollama, openai, anthropic]) {
     const { api, sandbox, calls } = load(abortedFetch)
     let expire
     let cleared = false
+    const deadline = cfg.provider === 'ollama' ? 120000 : 12000
+    const delays = []
     sandbox.setTimeout = (callback, ms) => {
-      assert.equal(ms, cfg.provider === 'ollama' ? 120000 : 12000)
-      expire = callback
+      delays.push(ms)
+      // The log batch timer shares this seam, so select the request deadline.
+      if (ms === deadline) expire = callback
       return 1
     }
     sandbox.clearTimeout = () => { cleared = true }
     const result = api.testAiService(cfg)
+    assert.ok(delays.includes(deadline), `the request must use a ${deadline}ms deadline, saw ${delays.join('/')}`)
     expire()
     assert.equal((await result).code, 'timeout')
     assert.equal(calls[0].signal.aborted, true)
@@ -377,3 +383,268 @@ test('cache respects settings labels and is invalidated when provider configurat
   assert.equal(calls.length, 4)
   assert.equal(calls[3].headers.authorization, `Bearer ${openai.apiKey}`)
 })
+
+// --- DSH default-model import: 0.2 Remote namespaces, the legacy unary client, and failures ---
+
+const dshNamespaces = (provider, model, providerProfiles) => ([
+  { ns: 'agent-default-model', value: { provider, model, reasoningEffort: 'high' } },
+  { ns: 'llm-pi-ai', value: { providers: providerProfiles } },
+])
+const describeReply = (namespaces) => ({ ok: true, value: { writable: true, hasDocument: true, namespaces } })
+
+test('DSH 0.2 remote namespaces supply the default model config without touching credentials', async () => {
+  const { api } = load()
+  const requested = []
+  const ctx = {
+    get: (name) => {
+      requested.push(name)
+      if (name === 'remote.settings') {
+        return {
+          describe: async () => describeReply(dshNamespaces('openai', 'gpt-x', {
+            openai: { api: 'openai-completions', baseURL: 'https://example.test/v1', models: [{ id: 'gpt-x' }] },
+          })),
+        }
+      }
+      if (name === 'remote.llm') {
+        return {
+          listConfigurableProviders: async () => ({
+            ok: true,
+            value: [{ provider: 'openai', settingsNs: 'llm-pi-ai', settingsPath: ['providers', 'openai'] }],
+          }),
+        }
+      }
+      return undefined
+    },
+  }
+  assert.deepEqual(plain(await api.readDshModelConfig(ctx, (key) => key)), {
+    provider: 'openai',
+    baseUrl: 'https://example.test/v1',
+    model: 'gpt-x',
+  })
+  assert.deepEqual(requested, ['remote.settings', 'remote.llm'])
+})
+
+test('the legacy connection.api unary client still supplies the default model config', async () => {
+  const { api } = load()
+  const ctx = {
+    get: (name) => name === 'connection'
+      ? {
+          api: {
+            settings: {
+              describe: async (payload) => {
+                assert.deepEqual(plain(payload), {})
+                return {
+                  result: {
+                    ok: true,
+                    value: {
+                      namespaces: dshNamespaces('anthropic', 'claude-x', {
+                        anthropic: { baseURL: 'https://anthropic.test', models: [{ id: 'claude-x', api: 'anthropic-messages' }] },
+                      }),
+                    },
+                  },
+                }
+              },
+            },
+            llm: {
+              providers: async () => ({
+                result: {
+                  ok: true,
+                  value: { providers: [{ provider: 'anthropic', settingsNs: 'llm-pi-ai', settingsPath: ['providers', 'anthropic'] }] },
+                },
+              }),
+            },
+          },
+        }
+      : undefined,
+  }
+  assert.deepEqual(plain(await api.readDshModelConfig(ctx, (key) => key)), {
+    provider: 'anthropic',
+    baseUrl: 'https://anthropic.test',
+    model: 'claude-x',
+  })
+})
+
+test('a missing llm namespace falls back to the provider profile inside the settings namespace', async () => {
+  const { api } = load()
+  const ctx = {
+    get: (name) => name === 'remote.settings'
+      ? {
+          describe: async () => describeReply(dshNamespaces('ollama', 'qwen3:8b', {
+            ollama: { baseURL: 'http://127.0.0.1:11434/v1', models: [{ id: 'qwen3:8b' }] },
+          })),
+        }
+      : undefined,
+  }
+  assert.deepEqual(plain(await api.readDshModelConfig(ctx, (key) => key)), {
+    provider: 'ollama',
+    baseUrl: 'http://127.0.0.1:11434/v1',
+    model: 'qwen3:8b',
+  })
+})
+
+test('a failed describe is reported instead of being mistaken for a missing model', async () => {
+  const { api } = load()
+  const ctx = {
+    get: (name) => name === 'remote.settings'
+      ? { describe: async () => ({ ok: false, error: { message: 'settings are read-only' } }) }
+      : undefined,
+  }
+  await assert.rejects(api.readDshModelConfig(ctx, (key) => key), { message: 'settings are read-only' })
+})
+
+test('a DSH build with no settings API fails with a readable reason instead of a TypeError', async () => {
+  const { api } = load()
+  await assert.rejects(api.readDshModelConfig({ get: () => undefined }, (key) => key), { message: 'aiDshImportApi' })
+})
+
+test('a default model without an importable Base URL names the model, and no default model imports nothing', async () => {
+  const { api } = load()
+  const account = {
+    get: (name) => name === 'remote.settings'
+      ? {
+          describe: async () => describeReply([
+            { ns: 'agent-default-model', value: { provider: 'deepseek-account', model: 'deepseek-flash' } },
+          ]),
+        }
+      : name === 'remote.llm'
+        ? {
+            listConfigurableProviders: async () => ({
+              ok: true,
+              value: [{ provider: 'deepseek-account', settingsNs: 'llm-deepseek-account', settingsPath: [] }],
+            }),
+          }
+        : undefined,
+  }
+  await assert.rejects(api.readDshModelConfig(account, (key) => key), { message: 'aiDshImportNoBaseUrl' })
+
+  const idle = {
+    get: (name) => name === 'remote.settings'
+      ? { describe: async () => describeReply([{ ns: 'agent-default-model', value: {} }]) }
+      : undefined,
+  }
+  assert.equal(await api.readDshModelConfig(idle, (key) => key), null)
+})
+
+// --- DSH 0.2 adaptation: plugin-inventory fingerprint and in-page seats ---
+
+test('the plugin-inventory fingerprint drops this plugin and follows 0.2 bundle/plugin rows', () => {
+  const { api } = load()
+  const own = { id: '@objectivex666/dsh-settings-search', npm: '@objectivex666/dsh-settings-search', version: '1.13.0' }
+  const shell = { id: '@deepseek-ai/dsh-client-ui-shell', npm: '@deepseek-ai/dsh-client-ui-shell', version: '0.2.0-rc.2', enabled: true }
+  const baseline = api.otherPluginFingerprint([own, shell])
+  assert.equal(api.otherPluginFingerprint([shell]), baseline, 'this plugin must not affect its own index fingerprint')
+  assert.notEqual(api.otherPluginFingerprint([own, { ...shell, version: '0.2.1' }]), baseline, 'a plugin update must invalidate')
+  assert.notEqual(api.otherPluginFingerprint([own, { ...shell, enabled: false }]), baseline, 'a plugin toggle must invalidate')
+  assert.notEqual(api.otherPluginFingerprint([own]), baseline, 'a plugin removal must invalidate')
+  assert.equal(api.otherPluginFingerprint([]), api.otherPluginFingerprint([own]))
+  // 0.2 plugin rows carry entryId/moduleName rather than id/name.
+  assert.notEqual(
+    api.otherPluginFingerprint([own, { id: 'ui-theme', npm: '@deepseek-ai/dsh-client-ui-theme', enabled: true }]),
+    baseline,
+  )
+})
+
+test('legacy plugin-card seats stay indexed for pre-0.2 builds only', () => {
+  const { api } = load()
+  const seats = Object.fromEntries(api.DEEP_SLOTS.map((config) => [config.slot, config.parent]))
+  assert.equal(seats['settings.plugins.tab'], 'plugins', 'the Settings to Plugins tab seat is inside the panel and indexed')
+  assert.equal(seats['settings.general.item'], 'general')
+  assert.equal(seats['settings.plugin.item'], 'plugins', 'legacy seat stays indexed')
+  assert.equal(seats['web-ui.plugin.item'], 'web-ui-plugins', 'legacy seat stays indexed')
+  // 0.2 moves the plugin cards to its standalone Plugins panel, which the
+  // settings-panel navigation cannot reach: indexing it would dead-end.
+  assert.equal(seats['plugins.item'], undefined, 'the standalone panel seat must not be indexed')
+})
+
+test('the seat fingerprint stays meaningful on DSH 0.2, where the legacy card seats are empty', () => {  const { api } = load()
+  const pages = [{ options: { id: 'general', order: 0, label: 'General' } }]
+  const ctx = {
+    effect: (fn) => fn(),
+    get: () => null,
+    inject: () => {},
+    locale: { register: () => {}, bind: () => () => '', subscribe: () => () => {} },
+    slots: {
+      register: (name, id, options) => ({ name, id, options }),
+      inject: (_slot, registrar) => registrar(),
+      entries: (slot) => (slot === 'settings.section' ? pages : []),
+      subscribe: () => () => {},
+    },
+  }
+  api.apply(ctx)
+  const model = api.__indexTestModel
+  const before = model.slotsFingerprint()
+  assert.notEqual(before, '[]', 'an empty fingerprint would disable every rebuild signal on 0.2')
+  pages.push({ options: { id: 'plugins', order: 15, label: 'Plugins' } })
+  assert.notEqual(model.slotsFingerprint(), before, 'a settings page appearing must invalidate a stored index')
+})
+
+// --- Log recording: the in-memory ring, the batched host write-through, and the viewer fallback ---
+
+const logRouteCalls = (calls) => calls.filter((call) => String(call.url).includes('api/settings-search-log'))
+
+test('log entries are batched to the host log route as one formatted line each', () => {
+  const { api, calls } = load()
+  api.log('info', '应用装载', { version: '1.13.0' })
+  api.log('error', '导入失败')
+  api.flushLogs()
+  const [call] = logRouteCalls(calls)
+  assert.ok(call, 'the host log route must be posted to')
+  assert.equal(call.method, 'POST')
+  assert.deepEqual(plain(call.headers), { 'content-type': 'application/json' })
+  assert.equal(call.body.action, 'append')
+  assert.equal(call.body.lines.length, 2)
+  assert.match(call.body.lines[0], /^\d{4}-\d{2}-\d{2}T[\d:.]+Z \[info\] \[[0-9a-f]{8}:1\] 应用装载 \{"version":"1\.13\.0"\}$/)
+  assert.match(call.body.lines[1], /\[error\] \[[0-9a-f]{8}:2\] 导入失败$/)
+})
+
+test('the debounce timer ships queued lines, and clearing drops them instead', () => {
+  const { api, calls, sandbox } = load()
+  let fire = null
+  let delay = 0
+  sandbox.setTimeout = (callback, ms) => { fire = callback; delay = ms; return 1 }
+  sandbox.clearTimeout = () => {}
+  api.log('info', 'a')
+  assert.equal(delay, 1200, 'the batch must be debounced instead of posting per line')
+  assert.equal(logRouteCalls(calls).length, 0)
+  fire()
+  assert.equal(logRouteCalls(calls).length, 1, 'the debounce must ship the queued line')
+
+  api.log('info', 'b')
+  api.discardPendingLogs()
+  api.flushLogs()
+  assert.equal(logRouteCalls(calls).length, 1, 'a cleared queue must not be shipped')
+})
+
+test('the session log text mirrors the on-disk line format for the viewer fallback', () => {
+  const { api } = load()
+  assert.deepEqual(plain(api.logTarget()), { dir: '', file: '', state: 'idle', detail: '', count: null })
+  api.log('info', 'only line')
+  assert.match(api.sessionLogText(), /^\d{4}-\d{2}-\d{2}T[\d:.]+Z \[info\] \[[0-9a-f]{8}:1\] only line$/)
+})
+
+test('a failing host log channel never throws and never logs about itself', async () => {
+  const { api, calls } = load(async () => { throw new TypeError('Failed to fetch') })
+  api.log('info', 'first')
+  api.flushLogs()
+  await new Promise((resolve) => setTimeout(resolve, 0))
+  assert.equal(logRouteCalls(calls).length, 1)
+  assert.equal(api.logTarget().state, 'fail')
+  // The failed transport must not have queued a log line of its own.
+  api.flushLogs()
+  assert.equal(logRouteCalls(calls).length, 1)
+})
+
+test('the badge count follows the host file, not just this session', async () => {
+  // The host reports the entries that exist on disk, including earlier runs.
+  const { api, calls } = load(async () => json({ ok: true, count: 7, dir: 'D', file: 'F' }))
+  assert.equal(await api.readLogCount(), 7)
+  const [call] = logRouteCalls(calls)
+  assert.equal(call.method, 'GET')
+  assert.match(String(call.url), /api\/settings-search-log\?count=1$/)
+  assert.deepEqual(plain(api.logTarget()), { dir: 'D', file: 'F', state: 'ok', detail: '', count: 7 })
+
+  // A count that fails to arrive leaves the badge on the session fallback.
+  const { api: offline } = load(async () => { throw new TypeError('Failed to fetch') })
+  assert.equal(await offline.readLogCount(), null)
+  assert.equal(offline.logTarget().count, null)
+})

package/scripts/check.mjs

@@ -60,6 +60,34 @@ check(versionMatch !== null, 'lib/client.js must define const PKG_VERSION')
 check(versionMatch?.[1] === pkg.version,
   `PKG_VERSION (${versionMatch?.[1]}) must equal package.json version (${pkg.version})`)
 
+// 5. theme variables: every token the bundle styles with must exist in the DSH
+//    0.2 theme registry (verified against @deepseek-ai/dsh-client-ui-theme).
+//    A token that 0.2 never defines silently falls back to the inherited value.
+const VERIFIED_THEME_TOKENS = new Set([
+  '--dsw-alias-bg-layer-1',
+  '--dsw-alias-bg-layer-2',
+  '--dsw-alias-bg-layer-3',
+  '--dsw-alias-bg-mask-1',
+  '--dsw-alias-bg-module-platform',
+  '--dsw-alias-bg-overlay',
+  '--dsw-alias-border-l1',
+  '--dsw-alias-border-l2',
+  '--dsw-alias-brand-primary',
+  '--dsw-alias-interactive-bg-hover',
+  '--dsw-alias-label-dimmed',
+  '--dsw-alias-label-primary',
+  '--dsw-alias-label-secondary',
+  '--dsw-alias-label-tertiary',
+  '--dsw-alias-state-error-primary',
+  '--dsw-alias-state-success-primary',
+  '--dsw-shadow-lv2',
+  '--dsw-shadow-lv3',
+])
+for (const token of new Set([...source.matchAll(/--dsw-[a-z0-9-]+/g)].map((match) => match[0]))) {
+  check(VERIFIED_THEME_TOKENS.has(token),
+    `lib/client.js uses ${token}, which the DSH 0.2 theme does not define`)
+}
+
 if (failed > 0) {
   console.error(`${failed} check(s) failed`)
   process.exit(1)

package/scripts/log.test.mjs

@@ -0,0 +1,345 @@
+/**
+ * Host-half log store regression tests (`npm test`).
+ *
+ * The store owns the daily files behind the panel's 「查看日志 / 打开日志文件夹」
+ * actions, so the invariants under test are the ones a reader depends on: one
+ * file per local day with the date in its name, one line per entry, no forged
+ * entries, a per-file cap that continues in a numbered part, a folder budget
+ * that never deletes the active file, and a tail that never starts mid-line.
+ */
+import assert from 'node:assert/strict'
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { basename, join } from 'node:path'
+import { tmpdir } from 'node:os'
+import test from 'node:test'
+import { apply, createLogRoute, createLogStore, folderLaunchCommand, inject } from '../lib/index.js'
+
+const withStore = (options = {}) => {
+  const dir = mkdtempSync(join(tmpdir(), 'sss-log-'))
+  return {
+    dir,
+    store: createLogStore({ dir, ...options }),
+    cleanup: () => rmSync(dir, { recursive: true, force: true }),
+  }
+}
+
+/** A day whose local stamp the store will write into the filename. */
+const day = (iso, hour = '09:00:00') => new Date(`${iso}T${hour}`)
+
+test('one file per local day, named with that date', () => {
+  const { dir, store, cleanup } = withStore({ now: () => day('2026-10-06', '23:30:00') })
+  try {
+    store.append(['entry'])
+    assert.equal(basename(store.file), 'settings-search-2026-10-06.log')
+    assert.equal(store.dir, dir)
+  } finally {
+    cleanup()
+  }
+})
+
+test('a new day starts a new file while the previous day is kept', () => {
+  const { store, cleanup } = withStore({ now: () => day('2026-10-05') })
+  try {
+    store.append(['yesterday'])
+    const yesterday = store.file
+    assert.equal(basename(yesterday), 'settings-search-2026-10-05.log')
+    // Roll the clock over by rebuilding the store against the same folder.
+    const next = createLogStore({ dir: store.dir, now: () => day('2026-10-06') })
+    next.append(['today'])
+    assert.equal(basename(next.file), 'settings-search-2026-10-06.log')
+    assert.equal(readFileSync(yesterday, 'utf8'), 'yesterday\n')
+    assert.equal(next.count(), 1, 'the count follows the new day')
+  } finally {
+    cleanup()
+  }
+})
+
+test('the log store appends one line per entry and reads them back', () => {
+  const { store, cleanup } = withStore({ now: () => day('2026-10-06') })
+  try {
+    assert.equal(store.append(['first', 'second']), 2)
+    assert.equal(store.append([]), 0)
+    assert.equal(store.append('not-an-array'), 0)
+    const read = store.read()
+    assert.equal(read.text, 'first\nsecond\n')
+    assert.equal(read.truncated, false)
+    assert.equal(read.size, 13)
+  } finally {
+    cleanup()
+  }
+})
+
+test('embedded newlines cannot forge entries and one line stays capped', () => {
+  const { store, cleanup } = withStore({ now: () => day('2026-10-06') })
+  try {
+    assert.equal(store.append(['one\ntwo']), 1)
+    assert.equal(store.append([`x${'y'.repeat(4000)}`]), 1)
+    const lines = store.read().text.split('\n').filter((line) => line !== '')
+    assert.equal(lines.length, 2)
+    assert.equal(lines[0], 'one two')
+    assert.equal(lines[1].length, 1000)
+  } finally {
+    cleanup()
+  }
+})
+
+test('a day that passes its per-file cap continues in a numbered part', () => {
+  const { store, cleanup } = withStore({ now: () => day('2026-10-06'), maxBytes: 40 })
+  try {
+    store.append(['x'.repeat(20)])
+    const base = store.file
+    assert.match(basename(base), /^settings-search-2026-10-06\.log$/)
+    store.append(['y'.repeat(20)])
+    const part = store.file
+    assert.match(basename(part), /^settings-search-2026-10-06\.1\.log$/)
+    store.append(['z'])
+    assert.equal(readFileSync(base, 'utf8'), `${'x'.repeat(20)}\n${'y'.repeat(20)}\n`)
+    assert.equal(readFileSync(part, 'utf8'), 'z\n')
+  } finally {
+    cleanup()
+  }
+})
+
+test('the folder is pruned to its budget, never deleting the active file', () => {
+  const { dir, store, cleanup } = withStore({ now: () => day('2026-10-04'), maxTotalBytes: 40 })
+  try {
+    store.append(['a'.repeat(20)])
+    const first = store.file
+    const second = createLogStore({ dir, now: () => day('2026-10-05'), maxTotalBytes: 40 })
+    second.append(['b'.repeat(20)])
+    assert.equal(existsSync(first), false, 'the oldest file goes once the folder passes its budget')
+    assert.equal(existsSync(second.file), true)
+
+    const third = createLogStore({ dir, now: () => day('2026-10-06'), maxTotalBytes: 40 })
+    third.append(['c'])
+    assert.equal(existsSync(second.file), true, 'a file inside the budget survives')
+    assert.equal(existsSync(third.file), true, 'the active file is never pruned')
+  } finally {
+    cleanup()
+  }
+})
+
+test('the pre-daily file is folded into today the first time the store runs', () => {
+  const { dir, store, cleanup } = withStore({ now: () => day('2026-10-06') })
+  try {
+    writeFileSync(join(dir, 'settings-search.log'), 'old\nline\n', 'utf8')
+    assert.equal(store.read().text, 'old\nline\n')
+    assert.equal(existsSync(join(dir, 'settings-search.log')), false)
+    assert.equal(basename(store.file), 'settings-search-2026-10-06.log')
+    assert.equal(store.count(), 2)
+  } finally {
+    cleanup()
+  }
+})
+
+test('a pre-daily leftover file counts as an old file and is pruned first', () => {
+  const { dir, store, cleanup } = withStore({ now: () => day('2026-10-06'), maxTotalBytes: 30 })
+  try {
+    const leftover = join(dir, 'settings-search.log.1')
+    writeFileSync(leftover, `${'legacy'.repeat(6)}\n`, 'utf8')
+    store.append(['fresh'])
+    assert.equal(existsSync(leftover), false)
+    assert.equal(existsSync(store.file), true)
+  } finally {
+    cleanup()
+  }
+})
+
+test('the tail read drops the partial first line and reports truncation', () => {
+  const { store, cleanup } = withStore({ now: () => day('2026-10-06'), tailBytes: 12 })
+  try {
+    store.append(['aaaa', 'bbbb', 'cccc', 'dddd'])
+    const read = store.read()
+    assert.equal(read.truncated, true)
+    assert.equal(read.text, 'cccc\ndddd\n')
+  } finally {
+    cleanup()
+  }
+})
+
+test('a short tail read never returns stale buffer contents', () => {
+  const sentinel = 'LEAKED-HEAP-BYTES'
+  const io = {
+    openSync: () => 1,
+    closeSync: () => {},
+    readSync: (_fd, buffer, offset, length) => {
+      // Simulate an uninitialized buffer whose read reports fewer bytes than requested.
+      for (let at = 0; at < length; at += sentinel.length) {
+        buffer.write(sentinel, at, Math.min(sentinel.length, length - at), 'utf8')
+      }
+      buffer.write('fresh\n', offset, 'utf8')
+      return 'fresh\n'.length
+    },
+  }
+  const { store, cleanup } = withStore({ now: () => day('2026-10-06'), tailBytes: 64, io })
+  try {
+    writeFileSync(store.file, `${'a'.repeat(200)}\n`, 'utf8')
+    const read = store.read()
+    assert.equal(read.truncated, true)
+    assert.equal(read.text, '', 'a short read must not decode the untouched buffer')
+  } finally {
+    cleanup()
+  }
+})
+
+test('clear truncates the active file and removes the older daily files', () => {
+  const { dir, store, cleanup } = withStore({ now: () => day('2026-10-05') })
+  try {
+    store.append(['yesterday'])
+    const yesterday = store.file
+    const today = createLogStore({ dir, now: () => day('2026-10-06') })
+    today.append(['today'])
+    assert.equal(today.clear(), true)
+    assert.equal(statSync(today.file).size, 0)
+    assert.equal(existsSync(yesterday), false)
+    assert.equal(today.count(), 0)
+    assert.deepEqual(readdirSync(dir).filter((name) => name.startsWith('settings-search-')), ['settings-search-2026-10-06.log'])
+  } finally {
+    cleanup()
+  }
+})
+
+test('count reports the entries of the active day', () => {
+  const { dir, store, cleanup } = withStore({ now: () => day('2026-10-05') })
+  try {
+    assert.equal(store.count(), 0, 'a missing file counts zero')
+    store.append(['a', 'b'])
+    assert.equal(store.count(), 2)
+    const next = createLogStore({ dir, now: () => day('2026-10-06') })
+    assert.equal(next.count(), 0, 'a new day counts from zero')
+    next.append(['c'])
+    assert.equal(next.count(), 1)
+    next.clear()
+    assert.equal(next.count(), 0)
+  } finally {
+    cleanup()
+  }
+})
+
+test('a fresh store reads the count of a file written by an earlier run', () => {
+  const { store, cleanup } = withStore({ now: () => day('2026-10-06') })
+  try {
+    store.append(['one', 'two', 'three'])
+    const reopened = createLogStore({ dir: store.dir, now: () => day('2026-10-06') })
+    assert.equal(reopened.count(), 3)
+    assert.equal(reopened.count(), 3, 'the count is cached after the first read')
+  } finally {
+    cleanup()
+  }
+})
+
+const send = async (route, method, body, query = '') => {
+  const request = new Request(`http://dsh.internal${route.path}${query}`, {
+    method,
+    ...(body === undefined
+      ? {}
+      : { headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) }),
+  })
+  const response = await route.fetch(request)
+  return { status: response.status, body: await response.json() }
+}
+
+test('the log route answers the entry count with and without the file tail', async () => {
+  const { store, cleanup } = withStore({ now: () => day('2026-10-06') })
+  const route = createLogRoute(store)
+  try {
+    await send(route, 'POST', { action: 'append', lines: ['a', 'b'] })
+    const appended = await send(route, 'POST', { action: 'append', lines: ['c'] })
+    assert.equal(appended.body.count, 3)
+
+    const full = await send(route, 'GET')
+    assert.equal(full.body.count, 3)
+    assert.equal(full.body.text, 'a\nb\nc\n')
+
+    const countOnly = await send(route, 'GET', undefined, '?count=1')
+    assert.equal(countOnly.body.count, 3)
+    assert.equal(countOnly.body.text, undefined, 'the count-only read must not transfer the tail')
+
+    const cleared = await send(route, 'POST', { action: 'clear' })
+    assert.equal(cleared.body.count, 0)
+  } finally {
+    cleanup()
+  }
+})
+
+test('the log route serves the tail and accepts append/clear only', async () => {
+  const { store, cleanup } = withStore({ now: () => day('2026-10-06') })
+  const route = createLogRoute(store)
+  try {
+    assert.equal(route.path, '/api/settings-search-log')
+    assert.deepEqual(route.methods, ['GET', 'POST'])
+    assert.equal(route.requestBody, 'buffered')
+
+    const appended = await send(route, 'POST', { action: 'append', lines: ['hello'] })
+    assert.equal(appended.status, 200)
+    assert.equal(appended.body.ok, true)
+    assert.equal(appended.body.written, 1)
+
+    const read = await send(route, 'GET')
+    assert.equal(read.body.ok, true)
+    assert.equal(read.body.text, 'hello\n')
+    assert.equal(read.body.file.endsWith('settings-search-2026-10-06.log'), true)
+    assert.equal(read.body.dir, store.dir)
+
+    assert.equal((await send(route, 'POST', { action: 'nope' })).status, 400)
+    assert.equal((await send(route, 'POST')).status, 400)
+    assert.equal((await send(route, 'POST', { action: 'clear' })).body.ok, true)
+    assert.equal((await send(route, 'GET')).body.text, '')
+  } finally {
+    cleanup()
+  }
+})
+
+test('the folder launcher uses the OS shell open verb, never a hidden file manager', () => {
+  const win = folderLaunchCommand('win32', 'C:\\logs\\dsh-settings-search')
+  assert.equal(win.command, 'cmd.exe')
+  assert.deepEqual(win.args, ['/c', 'start', '', 'C:\\logs\\dsh-settings-search'])
+  // Only cmd's own console may hide: starting explorer.exe with CREATE_NO_WINDOW
+  // produces a window that never becomes visible.
+  assert.equal(win.hideWindow, true)
+  assert.deepEqual(folderLaunchCommand('darwin', '/tmp/dsh'), { command: 'open', args: ['/tmp/dsh'], hideWindow: false })
+  assert.deepEqual(folderLaunchCommand('linux', '/tmp/dsh'), { command: 'xdg-open', args: ['/tmp/dsh'], hideWindow: false })
+})
+
+test('the open action reports the launcher outcome and records the attempt', async () => {
+  const { store, cleanup } = withStore({ now: () => day('2026-10-06') })
+  try {
+    const failing = createLogRoute({ ...store, open: async () => ({ failure: 'boom', command: 'cmd.exe' }) })
+    const failed = await send(failing, 'POST', { action: 'open' })
+    assert.equal(failed.status, 500)
+    assert.equal(failed.body.reason, 'open-failed')
+    assert.equal(failed.body.detail, 'boom')
+    assert.match(store.read().text, /\[host\] 打开日志文件夹 failed \(cmd\.exe\): boom/)
+
+    const succeeding = createLogRoute({ ...store, open: async () => ({ failure: undefined, command: 'cmd.exe' }) })
+    const opened = await send(succeeding, 'POST', { action: 'open' })
+    assert.equal(opened.body.ok, true)
+    assert.equal(opened.body.opened, true)
+    assert.equal(opened.body.command, 'cmd.exe')
+    assert.match(store.read().text, /\[host\] 打开日志文件夹 ok \(cmd\.exe\)/)
+  } finally {
+    cleanup()
+  }
+})
+
+test('the host half registers the route on the connection fetch registry', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'sss-log-apply-'))
+  const previous = process.env.DSH_SETTINGS_SEARCH_LOG_DIR
+  process.env.DSH_SETTINGS_SEARCH_LOG_DIR = dir
+  let registered = null
+  let disposed = false
+  try {
+    apply({
+      connection: { fetch: { register: (route) => { registered = route; return () => { disposed = true } } } },
+      effect: (callback) => { const dispose = callback(); return () => { dispose?.(); disposed = true } },
+    })
+    assert.deepEqual(inject, ['connection'])
+    assert.equal(registered.path, '/api/settings-search-log')
+    assert.equal(typeof registered.fetch, 'function')
+    assert.equal(disposed, false)
+  } finally {
+    if (previous === undefined) delete process.env.DSH_SETTINGS_SEARCH_LOG_DIR
+    else process.env.DSH_SETTINGS_SEARCH_LOG_DIR = previous
+    rmSync(dir, { recursive: true, force: true })
+  }
+})