@mzzsfy/dsh-bug-perf 0.1.0 → 0.2.0

package/src/list-slim.mjs

@@ -0,0 +1,207 @@
+// 会话列表瘦身:session/list 为每个会话下发完整投影快照,列表行只消费其中少数几项。
+// 本模块在 remote 方法返回前按白名单裁剪并缓存结果。任何失败路径都降级为原行为:
+// 未装载、形状不符、原方法抛错一律透传,不影响本插件的其它补丁。
+// sessionController 经 ctx.inject 可选依赖取得,宿主缺该服务时静默等待。
+// 缓存只服务 owner/本地调用:非 owner Remote 主体直接透传原方法,避免跨主体命中共享缓存。
+
+// 列表行消费的投影;其余键不下发。被裁掉的投影仍由会话详情接口完整返回。
+export const KEEP_PROJECTIONS = ['title', 'sessionListMetadata', 'inbox', 'modelSelection', 'tokenUsage']
+
+// 缓存有效期:会话增删立即失效,TTL 只兜底标题与运行时状态的漂移。
+export const TTL_MS = 15 * 1000
+
+// 启动后预热延迟:让宿主先完成装载,再让出一次列表重建。
+export const WARMUP_DELAY_MS = 10 * 1000
+
+// 预热等待上限:宿主列表长期不返回时不无限占用共享构建。
+export const WARMUP_TIMEOUT_MS = 2 * 60 * 1000
+
+const LOG_PREFIX = '[dsh-bug-perf] 列表瘦身'
+const INSTALL_MARKER = Symbol.for('@mzzsfy/dsh-bug-perf/list-slim')
+const WRAPPED_MARKER = Symbol.for('@mzzsfy/dsh-bug-perf/list-slim/wrapped')
+
+/**
+ * 当前 receiver 是否来自非 owner Remote 主体。
+ * 与宿主 remoteAccess.allows 的判定同源:owner 或非 Remote 调用没有 principal。
+ * @param receiver - 列表方法调用时的 this。
+ * @returns 非 owner 主体返回 true。
+ */
+function isNonOwner(receiver) {
+  const principal = receiver?.ctx?.invocation?.peer?.principal
+  return principal !== undefined && principal.kind !== 'owner'
+}
+
+/**
+ * 让一个调用者按自己的 signal 等待共享构建,取消只影响本次等待。
+ * @param promise - 共享的列表构建。
+ * @param signal - 调用者的取消信号。
+ * @returns 本调用者的等待结果。
+ */
+function raceWithSignal(promise, signal) {
+  if (signal === undefined) return promise
+  if (signal.aborted) return Promise.reject(signal.reason ?? new Error('aborted'))
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason ?? new Error('aborted'))
+    signal.addEventListener('abort', onAbort, { once: true })
+    promise.then(
+      (value) => {
+        signal.removeEventListener('abort', onAbort)
+        resolve(value)
+      },
+      (error) => {
+        signal.removeEventListener('abort', onAbort)
+        reject(error)
+      },
+    )
+  })
+}
+
+/**
+ * 裁剪一条列表项的投影,只保留白名单里的键。
+ * @param item - 宿主返回的列表项。
+ * @param keep - 保留的投影键。
+ * @returns 投影已裁剪的列表项;形状不符时原样返回。
+ */
+export function slimItem(item, keep = KEEP_PROJECTIONS) {
+  const values = item?.projections?.values
+  if (values === null || typeof values !== 'object' || Array.isArray(values)) return item
+  const picked = {}
+  for (const key of keep) if (key in values) picked[key] = values[key]
+  return { ...item, projections: { ...item.projections, values: picked } }
+}
+
+/**
+ * 给 sessionController.list 装上裁剪与缓存。
+ * @param ctx - 宿主上下文。
+ * @param options - 开关、白名单、缓存有效期与预热延迟。
+ * @returns 是否提交了装载回调;sessionController 缺席时回调不执行,宿主行为不变。
+ */
+export function installListSlim(ctx, options = {}) {
+  const {
+    isEnabled,
+    keep = KEEP_PROJECTIONS,
+    ttlMs = TTL_MS,
+    warmupDelayMs = WARMUP_DELAY_MS,
+  } = options
+  const warn = (message) => ctx.logger?.warn?.(LOG_PREFIX + ' ' + message)
+  try {
+    ctx.inject(['sessionController'], (scope) => {
+      try {
+        const controller = scope.sessionController
+        const original = controller?.list
+        if (typeof original !== 'function') {
+          warn('sessionController.list 不可用,跳过')
+          return
+        }
+        if (controller[INSTALL_MARKER] !== undefined && controller.list?.[WRAPPED_MARKER] === true) return
+        let cache
+        let cachedAt = 0
+        let inflight
+        let generation = 0
+        let active = true
+
+        const fresh = () => cache !== undefined && Date.now() - cachedAt < ttlMs
+        const invalidate = () => {
+          generation += 1
+          cachedAt = 0
+        }
+        scope.on('api-session/added', invalidate)
+        scope.on('api-session/removed', invalidate)
+
+        // 每个调用者独立等待共享构建;所有等待者都取消时中止构建,避免挂起被后续调用复用
+        const awaitBuild = (entry, signal) => {
+          const waiter = {}
+          entry.waiters.add(waiter)
+          const result = raceWithSignal(entry.promise, signal)
+          const settle = () => {
+            entry.waiters.delete(waiter)
+            if (entry.waiters.size === 0 && inflight === entry) {
+              entry.controller.abort()
+              inflight = undefined
+            }
+          }
+          result.then(settle, settle)
+          return result
+        }
+
+        // 缓存跨调用共享,按 TTL 与会话增删事件失效;非 owner 不读写缓存。
+        // 普通函数保留调用方 receiver:宿主在 list 内按 invocation 做逐项鉴权。
+        const wrapped = function list(request, signal) {
+          const receiver = this
+          // 卸载、关闭、已取消或非 owner:不裁剪、不缓存,原样交给宿主
+          if (!active || signal?.aborted || (isEnabled !== undefined && !isEnabled()) || isNonOwner(receiver)) {
+            return original.call(receiver, request, signal)
+          }
+          if (fresh()) return cache
+          // 共享构建不绑定任何调用者的 signal;调用者取消只结束自己的等待
+          if (inflight !== undefined && inflight.generation === generation) return awaitBuild(inflight, signal)
+          const current = generation
+          const buildController = new AbortController()
+          const entry = { promise: undefined, generation: current, controller: buildController, waiters: new Set() }
+          const created = Promise.resolve(original.call(receiver, request, buildController.signal))
+            .then((value) => {
+              if (!Array.isArray(value?.items)) return value
+              const slimmed = { items: value.items.map((item) => slimItem(item, keep)) }
+              // 在途期间发生增删失效时只返回本次结果,不把旧快照写回缓存
+              if (generation === current && inflight === entry) {
+                cache = slimmed
+                cachedAt = Date.now()
+              }
+              return slimmed
+            })
+            .finally(() => {
+              if (inflight === entry) inflight = undefined
+            })
+          entry.promise = created
+          inflight = entry
+          return awaitBuild(entry, signal)
+        }
+        Object.defineProperty(controller, INSTALL_MARKER, { value: wrapped, configurable: true })
+        Object.defineProperty(wrapped, WRAPPED_MARKER, { value: true })
+        try {
+          controller.list = wrapped
+        } catch (error) {
+          if (controller[INSTALL_MARKER] === wrapped) delete controller[INSTALL_MARKER]
+          throw error
+        }
+        let timer
+        if (warmupDelayMs >= 0) {
+          timer = setTimeout(() => {
+            if (isEnabled !== undefined && !isEnabled()) return
+            if (fresh() || inflight !== undefined) return
+            const timeout = AbortSignal.timeout?.(WARMUP_TIMEOUT_MS)
+            void wrapped.call(controller, {}, timeout).catch(() => {})
+          }, warmupDelayMs)
+          timer.unref?.()
+        }
+
+        // 卸载恢复原方法:按包装标记与归属判断,不摘掉后装或其它实例的包装;
+        // 已被后装引用时由 active 失活,链上继续透传;在途构建一并中止
+        const dispose = () => {
+          active = false
+          if (timer !== undefined) clearTimeout(timer)
+          if (inflight !== undefined) {
+            inflight.controller.abort()
+            inflight = undefined
+          }
+          if (controller[INSTALL_MARKER] === wrapped && controller.list?.[WRAPPED_MARKER] === true) controller.list = original
+          if (controller[INSTALL_MARKER] === wrapped) delete controller[INSTALL_MARKER]
+        }
+        try {
+          scope.effect(() => dispose)
+        } catch (error) {
+          // effect 注册失败时回滚包装与标记,避免留下无法卸载的包装
+          dispose()
+          throw error
+        }
+        ctx.logger?.info?.(`${LOG_PREFIX} 已装载 (keep=${keep.join(',')} ttl=${ttlMs}ms)`)
+      } catch (error) {
+        warn('装载失败,保持原行为: ' + String(error?.message ?? error))
+      }
+    })
+    return true
+  } catch (error) {
+    warn('未启用: ' + String(error?.message ?? error))
+    return false
+  }
+}

package/test/client-diag.test.mjs

@@ -0,0 +1,165 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+
+const source = readFileSync(new URL('../src/client.js', import.meta.url), 'utf8')
+
+function loadPlugin() {
+  let registered
+  const window = { __ModuleLoader__: { load: (entry) => { registered = entry } } }
+  new Function('window', source)(window)
+  return registered.factory(() => { throw new Error('no modules') })
+}
+
+function fakeClock() {
+  let now = 0
+  let nextId = 0
+  const intervals = new Map()
+  return {
+    now: () => now,
+    setInterval: (fn, ms) => { const id = ++nextId; intervals.set(id, { fn, every: ms, at: now + ms }); return id },
+    clearInterval: (id) => { intervals.delete(id) },
+    advance(ms) {
+      const target = now + ms
+      while (true) {
+        const due = [...intervals.values()].map((timer) => timer.at).filter((at) => at <= target)
+        if (due.length === 0) break
+        now = Math.min(...due)
+        for (const timer of intervals.values()) {
+          if (timer.at <= now) {
+            timer.at = now + timer.every
+            timer.fn()
+          }
+        }
+      }
+      now = target
+    },
+    intervalCount: () => intervals.size,
+  }
+}
+
+function fakeWindow(clock) {
+  const fetchCalls = []
+  const pendingProbes = []
+  const win = {
+    location: { pathname: '/chat' },
+    performance: { memory: { usedJSHeapSize: 64 * 1024 * 1024 } },
+    document: { querySelectorAll: () => ({ length: 42 }) },
+    fetch: (url, options) => {
+      fetchCalls.push({ url, options })
+      return Promise.resolve({ ok: true })
+    },
+    setTimeout: (fn) => { pendingProbes.push({ fn, startedAt: clock.now() }); return pendingProbes.length },
+    addEventListener: () => {},
+  }
+  return { win, fetchCalls, pendingProbes }
+}
+
+// Given 默认关闭, When 采样运行五分钟, Then 不发任何请求, 采样与阻塞探测仍工作
+test('诊断_默认关闭_只采样不上报', () => {
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  const { win, fetchCalls, pendingProbes } = fakeWindow(clock)
+  const diag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win, clock, diag, doc: win.document })
+  const reporting = plugin.__test.startDiagReporting({
+    win,
+    clock,
+    diag,
+    options: { enabled: false, reportEvery: 12 },
+  })
+  clock.advance(5 * 60 * 1000)
+  assert.equal(reporting.enabled, false)
+  assert.equal(diag.enabled, false)
+  assert.equal(fetchCalls.length, 0)
+  assert.ok(diag.samples.length >= 60)
+  clock.advance(plugin.__test.DIAG_PROBE_MS)
+  const probe = pendingProbes.shift()
+  assert.equal(typeof probe?.fn, 'function')
+  clock.advance(plugin.__test.DIAG_BLOCK_MS + 1)
+  probe.fn()
+  assert.equal(typeof diag.blockedAt, 'number')
+  assert.ok(diag.blockedMs >= plugin.__test.DIAG_BLOCK_MS)
+})
+
+// Given 开启, When 推进一个上报周期, Then 恰好一次请求且 payload 字段完整
+test('诊断_开启_按周期上报', () => {
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  const { win, fetchCalls } = fakeWindow(clock)
+  const diag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win, clock, diag, doc: win.document })
+  const reporting = plugin.__test.startDiagReporting({ win, clock, diag, options: { enabled: true, reportEvery: 12 } })
+  assert.equal(reporting.enabled, true)
+  assert.equal(diag.enabled, true)
+  clock.advance(12 * plugin.__test.DIAG_SAMPLE_MS - 1)
+  assert.equal(fetchCalls.length, 0)
+  clock.advance(1)
+  assert.equal(fetchCalls.length, 1)
+  const { url, options } = fetchCalls[0]
+  assert.ok(url.startsWith('/api/dsh-bug-perf/diag?d='))
+  assert.equal(options.keepalive, true)
+  const payload = JSON.parse(decodeURIComponent(url.slice(url.indexOf('?d=') + 3)))
+  assert.equal(typeof payload.at, 'number')
+  assert.equal(payload.path, '/chat')
+  assert.equal(typeof payload.totals.opened, 'number')
+  assert.ok(Array.isArray(payload.last))
+  assert.ok(Array.isArray(payload.longTasks))
+  assert.ok(Array.isArray(payload.errors))
+  assert.equal('blockedMs' in payload, true)
+  assert.ok(payload.last.length > 0)
+})
+
+// Given reportEvery 改小, When 推进两个周期, Then 上报次数随周期增加
+test('诊断_上报间隔_随配置变化', () => {
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  const { win, fetchCalls } = fakeWindow(clock)
+  const diag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win, clock, diag, doc: win.document })
+  plugin.__test.startDiagReporting({ win, clock, diag, options: { enabled: true, reportEvery: 2 } })
+  clock.advance(2 * plugin.__test.DIAG_SAMPLE_MS)
+  assert.equal(fetchCalls.length, 1)
+  clock.advance(2 * plugin.__test.DIAG_SAMPLE_MS)
+  assert.equal(fetchCalls.length, 2)
+})
+
+// Given fetch 缺失或抛错, When 到达上报点, Then 静默跳过且不抛
+test('诊断_上报失败_静默', () => {
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  const missing = fakeWindow(clock)
+  delete missing.win.fetch
+  const missingDiag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win: missing.win, clock, diag: missingDiag, doc: missing.win.document })
+  plugin.__test.startDiagReporting({ win: missing.win, clock, diag: missingDiag, options: { enabled: true, reportEvery: 1 } })
+  assert.doesNotThrow(() => clock.advance(plugin.__test.DIAG_SAMPLE_MS))
+
+  const throwing = fakeWindow(clock)
+  throwing.win.fetch = () => { throw new Error('fetch boom') }
+  const throwingDiag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win: throwing.win, clock, diag: throwingDiag, doc: throwing.win.document })
+  plugin.__test.startDiagReporting({ win: throwing.win, clock, diag: throwingDiag, options: { enabled: true, reportEvery: 1 } })
+  assert.doesNotThrow(() => clock.advance(plugin.__test.DIAG_SAMPLE_MS))
+})
+
+// Given fetch 返回拒绝或非 2xx, When 到达上报点, Then 不产生未处理异常
+test('诊断_上报异步失败_静默', async () => {
+  const plugin = loadPlugin()
+  const clock = fakeClock()
+  const rejecting = fakeWindow(clock)
+  rejecting.win.fetch = () => Promise.reject(new Error('fetch rejected'))
+  const rejectingDiag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win: rejecting.win, clock, diag: rejectingDiag, doc: rejecting.win.document })
+  plugin.__test.startDiagReporting({ win: rejecting.win, clock, diag: rejectingDiag, options: { enabled: true, reportEvery: 1 } })
+  assert.doesNotThrow(() => clock.advance(plugin.__test.DIAG_SAMPLE_MS))
+  await Promise.resolve()
+
+  const notOk = fakeWindow(clock)
+  notOk.win.fetch = () => Promise.resolve({ ok: false })
+  const notOkDiag = plugin.__test.createDiag(clock)
+  plugin.__test.startDiagSampling({ win: notOk.win, clock, diag: notOkDiag, doc: notOk.win.document })
+  plugin.__test.startDiagReporting({ win: notOk.win, clock, diag: notOkDiag, options: { enabled: true, reportEvery: 1 } })
+  assert.doesNotThrow(() => clock.advance(plugin.__test.DIAG_SAMPLE_MS))
+  await Promise.resolve()
+})

package/test/client-restart.test.mjs

@@ -127,7 +127,14 @@ test('配置_客户端内联_与宿主同源', async () => {
   const plugin = loadPlugin()
   const host = await import('../src/config.mjs')
   assert.deepEqual(plugin.__test.DEFAULT_CONFIG, host.DEFAULT_CONFIG)
+  assert.deepEqual(plugin.__test.LIMITS, host.LIMITS)
   assert.deepEqual(plugin.__test.normalizeConfig({}), host.normalizeConfig({}))
+  const raw = { diag: { enabled: true, reportEvery: 0 } }
+  assert.deepEqual(plugin.__test.normalizeConfig(raw), host.normalizeConfig(raw))
+  assert.deepEqual(
+    plugin.__test.normalizeConfig({ diag: { reportEvery: 99999 } }),
+    host.normalizeConfig({ diag: { reportEvery: 99999 } }),
+  )
 })
 
 // Given 远程配置缺失, When 客户端归一化, Then 落在与宿主一致的默认值上

package/test/client-settings.test.mjs

@@ -0,0 +1,76 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+
+const source = readFileSync(new URL('../src/client.js', import.meta.url), 'utf8')
+
+function loadPlugin({ modules = {} } = {}) {
+  let registered
+  const window = { __ModuleLoader__: { load: (entry) => { registered = entry } } }
+  new Function('window', source)(window)
+  const requireImpl = (id) => {
+    if (Object.hasOwn(modules, id)) return modules[id]
+    throw new Error(`module not registered: ${id}`)
+  }
+  return registered.factory(requireImpl)
+}
+
+const reactStub = {
+  createElement: (type, props, ...children) => ({ type, props, children }),
+  useState: () => [undefined, () => {}],
+  useEffect: () => {},
+}
+
+// Given React 与 slots 就绪, When 注册设置 UI, Then 两个官方插槽都登记且 key 正确
+test('设置UI_注册官方插槽', () => {
+  const plugin = loadPlugin({ modules: { react: reactStub } })
+  const registrations = []
+  const injected = []
+  const styleEffects = []
+  const scope = {
+    slots: {
+      inject: (name, callback) => { injected.push(name); callback() },
+      register: (options, component) => registrations.push({ options, component }),
+    },
+    effect: (factory) => { styleEffects.push(factory) },
+  }
+  const ctx = { inject: (services, callback) => { if (services.includes('slots')) callback(scope) } }
+  plugin.__test.registerSettingsUi(ctx)
+  assert.deepEqual(injected.sort(), ['plugins.bundle.config', 'settings.plugin.item'])
+  const byName = Object.fromEntries(registrations.map((entry) => [entry.options.name, entry.options]))
+  assert.equal(byName['settings.plugin.item'].key, 'bug-perf')
+  assert.equal(byName['plugins.bundle.config'].key, '@mzzsfy/dsh-bug-perf')
+  assert.equal(styleEffects.length, 1)
+})
+
+// Given 无 React 或 slots, When 注册, Then 静默跳过,不影响其它补丁
+test('设置UI_缺依赖_静默跳过', () => {
+  const noReact = loadPlugin()
+  let called = false
+  noReact.__test.registerSettingsUi({ inject: () => { called = true } })
+  assert.equal(called, false)
+  const plugin = loadPlugin({ modules: { react: reactStub } })
+  assert.doesNotThrow(() => plugin.__test.registerSettingsUi({}))
+})
+
+// Given 设置节定义, When 检查字段, Then 各节与共享配置的键一致
+test('设置UI_节字段与配置同源', () => {
+  const plugin = loadPlugin({ modules: { react: reactStub } })
+  const keys = plugin.__test.UI_SECTIONS.map((section) => section.key)
+  assert.deepEqual(keys, Object.keys(plugin.__test.DEFAULT_CONFIG))
+  for (const section of plugin.__test.UI_SECTIONS) {
+    for (const field of section.fields) {
+      assert.equal(typeof plugin.__test.DEFAULT_CONFIG[section.key][field.name], 'number')
+    }
+  }
+})
+
+// Given 客户端注入设置样式, When 检查注入契约, Then data-plugin 与样式创建点数一致且开关选择器锚定 checkbox
+test('设置UI_样式注入契约', () => {
+  const creates = (source.match(/createElement\('style'\)/g) ?? []).length
+  const markers = (source.match(/style\.setAttribute\('data-plugin'/g) ?? []).length
+  assert.equal(creates, 2)
+  assert.equal(markers, creates)
+  assert.match(source, /input\[type="checkbox"\]:checked \+ \.bp-switch__track/)
+  assert.match(source, /input\[type="checkbox"\]:focus-visible \+ \.bp-switch__track/)
+})

package/test/config.test.mjs

@@ -2,8 +2,8 @@ import test from 'node:test'
 import assert from 'node:assert/strict'
 import { DEFAULT_CONFIG, normalizeConfig } from '../src/config.mjs'
 
-// Given 无配置, When 归一化, Then 两个功能默认开启且阈值取默认
-test('配置_缺省_默认全开', () => {
+// Given 无配置, When 归一化, Then 各补丁默认开启(诊断上报默认关闭)且阈值取默认
+test('配置_缺省_功能默认值与阈值', () => {
   const config = normalizeConfig(undefined)
   assert.deepEqual(config, DEFAULT_CONFIG)
   assert.equal(config.restartCoalesce.enabled, true)
@@ -116,3 +116,30 @@ test('配置_任务流上限_开关与回退', () => {
   const inverted = normalizeConfig({ jobStreamLimit: { base: 200, max: 10 } })
   assert.equal(inverted.jobStreamLimit.base, 10)
 })
+
+// Given 列表瘦身缺省或关闭, When 归一化, Then 默认开启、显式关闭保留、非法类型回退默认
+test('配置_列表瘦身_开关与回退', () => {
+  assert.deepEqual(normalizeConfig(undefined).listSlim, { enabled: true })
+  assert.equal(normalizeConfig({ listSlim: { enabled: false } }).listSlim.enabled, false)
+  assert.equal(normalizeConfig({ listSlim: { enabled: 'off' } }).listSlim.enabled, true)
+})
+
+// Given 诊断上报缺省, When 归一化, Then 默认关闭且上报间隔取默认
+test('配置_诊断上报_默认关闭', () => {
+  assert.deepEqual(normalizeConfig(undefined).diag, { enabled: false, reportEvery: 12 })
+})
+
+// Given 诊断上报显式开关与非法值, When 归一化, Then 开关保留、非法类型回退、间隔越界收敛、未知字段丢弃
+test('配置_诊断上报_开关边界', () => {
+  const off = normalizeConfig({ diag: { enabled: false, reportEvery: 5 } })
+  assert.equal(off.diag.enabled, false)
+  assert.equal(off.diag.reportEvery, 5)
+  const on = normalizeConfig({ diag: { enabled: true } })
+  assert.equal(on.diag.enabled, true)
+  const bad = normalizeConfig({ diag: { enabled: 'yes', reportEvery: 'often' } })
+  assert.equal(bad.diag.enabled, false)
+  assert.equal(bad.diag.reportEvery, 12)
+  assert.equal(normalizeConfig({ diag: { reportEvery: 0 } }).diag.reportEvery, 1)
+  assert.equal(normalizeConfig({ diag: { reportEvery: 99999 } }).diag.reportEvery, 720)
+  assert.deepEqual(normalizeConfig({ diag: { reportEvery: 3, unknown: 1 } }).diag, { enabled: false, reportEvery: 3 })
+})