@objectivex666/dsh-settings-search 1.11.0 → 1.13.0

package/scripts/ai.test.mjs

@@ -11,6 +11,10 @@ const instrumented = source.replace(hook, `
     Object.assign(exports, {
       aiConfig, setAiConfig, aiConfigReady, ollamaChatUrl,
       requestUserAi, requestAiKeywords, testAiService, LOGS,
+      modelsUrl, fetchAiModels,
+      readIndexCache, serializeHarvest,
+      readDshModelConfig, otherPluginFingerprint, DEEP_SLOTS,
+      log, flushLogs, discardPendingLogs, sessionLogText, logTarget, readLogCount,
     })
 ${hook}`)
 const storage = () => {
@@ -30,6 +34,8 @@ const plain = (value) => JSON.parse(JSON.stringify(value))
 const ollama = { provider: 'ollama', baseUrl: '', model: 'local-model:7b', apiKey: '' }
 const openai = { provider: 'openai', baseUrl: 'https://example.test/v1', model: 'cloud-model', apiKey: 'test-secret' }
 const anthropic = { ...openai, provider: 'anthropic', baseUrl: 'https://example.test' }
+const modelHook = '      const model = createModel(ctx)'
+
 const reply = (provider, content = '{"keywords":["Language"]}') => provider === 'ollama'
   ? { message: { role: 'assistant', content }, done: true }
   : provider === 'anthropic'
@@ -49,16 +55,73 @@ function load(fetchImpl = async () => json(reply('ollama'))) {
     setTimeout,
     clearTimeout,
     fetch: async (url, options) => {
-      const call = { url, ...options, body: JSON.parse(options.body) }
+      const call = { url, ...options, body: options.body ? JSON.parse(options.body) : undefined }
       calls.push(call)
       return fetchImpl(call)
     },
   }
-  vm.runInNewContext(instrumented, sandbox, { filename: 'lib/client.js' })
-  const api = handoff.factory(() => ({}))
+  const instrumentedModel = instrumented.replace(modelHook, modelHook + '\n    exports.__indexTestModel = model')
+  vm.runInNewContext(instrumentedModel, sandbox, { filename: 'lib/client.js' })
+  const api = handoff.factory(() => ({ createElement: () => null }))
   return { api, calls, sandbox }
 }
 
+test('persistent settings index reuses matching fingerprints and drops invalid rows', () => {
+  const { api, sandbox } = load()
+  const records = {
+    'settings.general.item': {
+      row1: { title: 'Enable Workshop card', idx: 1, text: 'Enable Workshop card and save.', inner: [] },
+      broken: { idx: 2 },
+    },
+  }
+  assert.equal(Object.keys(api.serializeHarvest(new Map())).length, 0)
+  sandbox.localStorage.setItem('dsh-settings-search:index:v1', JSON.stringify({
+    version: 1,
+    fingerprint: 'manager:test',
+    updatedAt: 1,
+    harvest: records,
+  }))
+  const cached = api.readIndexCache()
+  assert.equal(cached.fingerprint, 'manager:test')
+  assert.equal(cached.harvest.get('settings.general.item')?.get('row1')?.title, 'Enable Workshop card')
+  assert.equal(cached.harvest.get('settings.general.item')?.has('broken'), false)
+
+  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.general.item'
+        ? [{ options: { id: 'row1', order: 1 } }]
+        : [],
+      subscribe: () => () => {},
+    },
+  }
+  api.apply(ctx)
+  const model = api.__indexTestModel
+  assert.equal(model.indexFingerprintReady(), true)
+  assert.equal(model.applyIndexFingerprint('manager:test'), false)
+  assert.ok(model.readDeep().some((item) => item.label === 'Enable Workshop card'))
+  assert.equal(model.applyIndexFingerprint('manager:changed'), true)
+  assert.equal(model.readDeep().some((item) => item.label === 'Enable Workshop card'), false)
+  assert.equal(model.persistIndex('manager:changed'), false)
+})
+
+test('readIndexCache rejects malformed persisted index payloads', () => {
+  const { api, sandbox } = load()
+  for (const value of ['{', '{"version":1}', 'null']) {
+    sandbox.localStorage.setItem('dsh-settings-search:index:v1', value)
+    assert.equal(api.readIndexCache(), null)
+  }
+})
+
 test('Ollama configuration persists and requires a model but no key', () => {
   const { api, sandbox } = load()
   api.setAiConfig({ ...ollama, model: ' local-model:7b ' })
@@ -88,6 +151,59 @@ test('Ollama accepts root, native, compatibility, proxy and IPv6 base URLs', ()
   assert.equal(api.ollamaChatUrl('https://example.test/ollama/v1/'), 'https://example.test/ollama/api/chat')
 })
 
+test('users discover selectable models from each supported API type', async () => {
+  const cases = [
+    {
+      cfg: ollama,
+      payload: { models: [{ name: 'qwen3:8b' }, { name: 'llama3.1:8b' }, { name: 'qwen3:8b' }] },
+      url: 'http://127.0.0.1:11434/api/tags',
+      headers: {},
+      models: ['qwen3:8b', 'llama3.1:8b'],
+    },
+    {
+      cfg: openai,
+      payload: { data: [{ id: 'gpt-4o-mini' }, { id: 'gpt-4.1-mini' }] },
+      url: 'https://example.test/v1/models',
+      headers: { authorization: `Bearer ${openai.apiKey}` },
+      models: ['gpt-4o-mini', 'gpt-4.1-mini'],
+    },
+    {
+      cfg: anthropic,
+      payload: { data: [{ id: 'claude-sonnet-4-20250514' }] },
+      url: 'https://example.test/v1/models',
+      headers: {
+        'x-api-key': anthropic.apiKey,
+        'anthropic-version': '2023-06-01',
+        'anthropic-dangerous-direct-browser-access': 'true',
+      },
+      models: ['claude-sonnet-4-20250514'],
+    },
+  ]
+  for (const expected of cases) {
+    const { api, calls } = load(async () => json(expected.payload))
+    assert.deepEqual(plain(await api.fetchAiModels(expected.cfg)), { ok: true, models: expected.models, code: 'ok', detail: '' })
+    const [call] = calls
+    assert.equal(call.url, expected.url)
+    assert.equal(call.method, 'GET')
+    assert.equal(call.redirect, 'error')
+    assert.deepEqual(plain(call.headers), expected.headers)
+  }
+})
+
+test('model discovery rejects unsafe or incomplete sources before fetching', async () => {
+  const { api, calls } = load(async () => json({ data: [{ id: 'should-not-load' }] }))
+  assert.equal(api.modelsUrl('ollama', 'javascript:alert(1)'), '')
+  assert.deepEqual(plain(await api.fetchAiModels({ ...ollama, baseUrl: 'file:///models' })), { ok: false, code: 'unsafe-url', models: [], detail: '' })
+  assert.deepEqual(plain(await api.fetchAiModels({ ...openai, apiKey: '' })), { ok: false, code: 'need-config', models: [], detail: '' })
+  assert.equal(calls.length, 0)
+})
+
+test('model discovery reports provider failures without inventing choices', async () => {
+  const { api, calls } = load(async () => json({ error: 'denied' }, 401))
+  assert.deepEqual(plain(await api.fetchAiModels(ollama)), { ok: false, code: 'auth', models: [], detail: 'HTTP 401' })
+  assert.equal(calls.length, 1)
+})
+
 test('Ollama search uses native non-streaming JSON and never sends a stored cloud key', async () => {
   const { api, calls, sandbox } = load(async () => json(reply('ollama', '{"keywords":["Language","Language"," Theme ",42]}')))
   api.setAiConfig({ ...ollama, apiKey: 'test-secret' })
@@ -207,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)
@@ -263,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)