@objectivex666/dsh-settings-search 1.13.1 → 1.14.1

package/scripts/compat.mjs

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+/**
+ * Harness compatibility audit.
+ *
+ * This plugin talks to DSH through surfaces that are not part of any public npm
+ * API — client service names, Typert Remote descriptors, slot keys, theme
+ * tokens, the host Fetch route registry, and the DeepSeek adapter constants.
+ * `npm test` cannot see any of those, so run this against the Harness install
+ * you are actually targeting:
+ *
+ *   node scripts/compat.mjs                       # auto-detect the install
+ *   node scripts/compat.mjs --asar <app.asar>     # explicit archive
+ *   DSH_ASAR=<app.asar> node scripts/compat.mjs   # or through the environment
+ *
+ * The archive is read read-only and nothing is written. The script exits
+ * non-zero as soon as an assumption breaks — that moment is exactly when a
+ * Harness upgrade needs this plugin adapted.
+ */
+import { closeSync, existsSync, openSync, readFileSync, readSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
+
+/** Candidate install locations, most specific first. */
+const DEFAULT_ASAR_CANDIDATES = [
+  'E:\\Program Files\\dsh\\resources\\app.asar',
+  'C:\\Program Files\\dsh\\resources\\app.asar',
+  '/Applications/DeepSeek Harness.app/Contents/Resources/app.asar',
+]
+
+const argOf = (name) => {
+  const at = process.argv.indexOf(name)
+  return at >= 0 ? process.argv[at + 1] : undefined
+}
+
+/**
+ * A minimal read-only Electron asar reader: a pickle-framed JSON header with
+ * `{ size, offset }` per entry, the payload starting right after the header.
+ * @param archive - absolute path to `app.asar`.
+ */
+const openAsar = (archive) => {
+  const fd = openSync(archive, 'r')
+  const sizeBuf = Buffer.alloc(8)
+  readSync(fd, sizeBuf, 0, 8, 0)
+  const headerSize = sizeBuf.readUInt32LE(4)
+  const headerBuf = Buffer.alloc(headerSize)
+  readSync(fd, headerBuf, 0, headerSize, 8)
+  const jsonLength = headerBuf.readUInt32LE(4)
+  const header = JSON.parse(headerBuf.toString('utf8', 8, 8 + jsonLength))
+  const dataStart = 8 + headerSize
+  const files = new Map()
+  const walk = (node, prefix) => {
+    for (const [name, entry] of Object.entries(node.files ?? {})) {
+      const path = prefix === '' ? name : `${prefix}/${name}`
+      if (entry.files !== undefined) walk(entry, path)
+      else files.set(path, { size: entry.size, offset: Number(entry.offset) })
+    }
+  }
+  walk(header, '')
+  const reader = {
+    archive,
+    files,
+    has: (path) => files.has(path),
+    read(path) {
+      const entry = files.get(path)
+      if (entry === undefined) throw new Error(`no entry ${JSON.stringify(path)}`)
+      const buffer = Buffer.alloc(entry.size)
+      readSync(fd, buffer, 0, entry.size, dataStart + entry.offset)
+      return buffer.toString('utf8')
+    },
+    close: () => closeSync(fd),
+  }
+  return reader
+}
+
+/** Locate the archive to audit. */
+const resolveAsar = () => {
+  const explicit = argOf('--asar') ?? process.env.DSH_ASAR
+  if (explicit !== undefined && explicit !== '') {
+    if (!existsSync(explicit)) throw new Error(`archive not found at ${explicit}`)
+    return explicit
+  }
+  const found = DEFAULT_ASAR_CANDIDATES.find((candidate) => existsSync(candidate))
+  if (found === undefined) {
+    throw new Error('could not locate a Harness install — pass --asar <app.asar> or set DSH_ASAR')
+  }
+  return found
+}
+
+const checks = []
+/**
+ * Run one compatibility check. A check returns a short detail string, `true`,
+ * or `undefined` when it passes, and throws (or returns `false`) when the
+ * Harness no longer matches an assumption this plugin makes.
+ */
+const check = (label, run) => {
+  try {
+    const detail = run()
+    checks.push({ label, ok: detail !== false, detail: detail === true || detail === undefined ? '' : String(detail) })
+  } catch (error) {
+    checks.push({ label, ok: false, detail: String(error?.message ?? error) })
+  }
+}
+
+/** The client-half source of one package, whatever the platform file is named. */
+const clientSourceOf = (archive, name, cache) => {
+  if (cache.has(name)) return cache.get(name)
+  const candidates = [
+    `dsh/node_modules/@deepseek-ai/${name}/lib/client.js`,
+    `dsh/node_modules/@deepseek-ai/${name}/lib/client.browser.js`,
+  ]
+  const found = candidates.find((path) => archive.has(path))
+  if (found === undefined) throw new Error(`${name} ships no client bundle`)
+  const text = archive.read(found)
+  cache.set(name, text)
+  return text
+}
+
+/** Assert one substring, reporting the missing needle. */
+const mustInclude = (text, needle, message) => {
+  if (!text.includes(needle)) throw new Error(message ?? `missing ${JSON.stringify(needle)}`)
+}
+
+/**
+ * Assert one pattern. Bundled client code is minified and re-emitted by every
+ * release, so it may quote a string with `"`, `'`, or a template literal
+ * without any behavioural change — match the code, not the quoting.
+ */
+const mustMatch = (text, pattern, message) => {
+  if (!pattern.test(text)) throw new Error(message ?? `missing ${pattern}`)
+}
+
+const main = () => {
+  const archivePath = resolveAsar()
+  const archive = openAsar(archivePath)
+  const cache = new Map()
+  try {
+    const connectionManifest = JSON.parse(archive.read('dsh/node_modules/@deepseek-ai/dsh-client-connection/package.json'))
+    const source = readFileSync(join(ROOT, 'lib/client.js'), 'utf8')
+    console.log(`Harness: ${archivePath}`)
+    console.log(`Version: ${connectionManifest.version}\n`)
+
+    check('client connection service is provided', () => {
+      mustMatch(
+        clientSourceOf(archive, 'dsh-client-connection', cache),
+        /provide\(\s*(['"`])connection\1/,
+        'the connection handle is gone',
+      )
+      return 'ctx.connection'
+    })
+
+    check('Remote namespaces live at remote.<namespace>', () => {
+      const gateway = clientSourceOf(archive, 'dsh-api-gateway', cache)
+      mustMatch(gateway, /super\(\s*ctx\s*,\s*(['"`])remote\1\s*\)/, 'the `remote` service is gone')
+      mustInclude(gateway, 'remote.${namespace}', 'namespace service keys changed')
+      return 'remote.<ns>'
+    })
+
+    check('settings/describe answers { namespaces: [{ ns, value }] }', () => {
+      const settings = archive.read('dsh/node_modules/@deepseek-ai/dsh-api-settings-controller/lib/typert.remote-client.js')
+      mustInclude(settings, "'namespaces'", 'describe value lost `namespaces`')
+      mustInclude(settings, "'ns': z.string()", 'namespace view lost `ns`')
+      mustInclude(settings, "'value': z.json()", 'namespace view lost `value`')
+      return 'ok'
+    })
+
+    check('settings/describe takes no arguments', () => {
+      const settings = archive.read('dsh/node_modules/@deepseek-ai/dsh-api-settings-controller/lib/typert.remote-client.js')
+      const at = settings.indexOf("'settings/describe':")
+      if (at === -1) throw new Error('the settings/describe descriptor is gone')
+      if (!/parameters:\s*\[\s*\]/.test(settings.slice(at, at + 900))) throw new Error('settings/describe now takes parameters')
+      return 'ok'
+    })
+
+    check('llm/listConfigurableProviders keeps settingsNs/settingsPath', () => {
+      const llm = archive.read('dsh/node_modules/@deepseek-ai/dsh-llm/lib/typert.remote-client.js')
+      mustInclude(llm, "'settingsNs'", 'rows lost settingsNs')
+      mustInclude(llm, "'settingsPath'", 'rows lost settingsPath')
+      return 'ok'
+    })
+
+    check('pluginManager inventories keep the fields the fingerprint reads', () => {
+      const manager = archive.read('dsh/node_modules/@deepseek-ai/dsh-plugin-manager/lib/typert.remote-client.js')
+      for (const field of ["'name'", "'version'", "'enabled'"]) {
+        mustInclude(manager, field, `a bundle row lost ${field}`)
+      }
+      for (const field of ["'entryId'", "'moduleName'"]) {
+        mustInclude(manager, field, `a plugin row lost ${field}`)
+      }
+      return 'name/version/enabled + entryId/moduleName'
+    })
+
+    check('host connection still owns the exact-Fetch route registry', () => {
+      const host = archive.read('dsh/node_modules/@deepseek-ai/dsh-client-connection/lib/index.js')
+      mustInclude(host, 'registerFetchRoute', 'the host fetch registry is gone')
+      mustInclude(host, 'bodyMode === "streaming"', 'streaming exact routes are no longer supported')
+      const segment = /const ENDPOINT_SEGMENT_PATTERN = \/\^\[([^\]]+)\]/.exec(host)
+      if (segment === null) throw new Error('endpoint validation pattern not found')
+      const sample = 'settings-search-log'
+      if (!new RegExp(`^[${segment[1]}]+$`).test(sample)) throw new Error(`route segment ${sample} is no longer valid`)
+      return `/api/${sample}`
+    })
+
+    check('every theme token this plugin uses exists in the Harness theme', () => {
+      const theme = clientSourceOf(archive, 'dsh-client-ui-theme', cache)
+      const defined = new Set([...theme.matchAll(/--dsw-[a-z0-9-]+/g)].map((match) => match[0]))
+      const used = new Set([...source.matchAll(/--dsw-[a-z0-9-]+/g)].map((match) => match[0]))
+      const missing = [...used].filter((token) => !defined.has(token))
+      if (missing.length > 0) throw new Error(`missing: ${missing.join(', ')}`)
+      return `${used.size} tokens`
+    })
+
+    check('the settings seats this plugin indexes still exist', () => {
+      const seats = ['settings.header', 'settings.section', 'settings.plugins.tab', 'settings.general.item']
+      const bundles = [...archive.files.keys()]
+        .filter((path) => /^dsh\/node_modules\/@deepseek-ai\/dsh-client-ui-[^/]+\/lib\/client(\.browser)?\.js$/.test(path))
+      const text = bundles.map((path) => archive.read(path)).join('\n')
+      const missing = seats.filter((seat) => !text.includes(`"${seat}"`))
+      if (missing.length > 0) throw new Error(`undeclared: ${missing.join(', ')}`)
+      return `${seats.length} seats`
+    })
+
+    check('the Plugins inventory still renders the 会话/全局 groups this plugin mines', () => {
+      const inventory = clientSourceOf(archive, 'dsh-client-ui-settings-plugin-inventory', cache)
+      mustInclude(inventory, '"groupTitle"', 'the group title class hook is gone')
+      mustInclude(inventory, '"data-plugin-scope"', 'the group scope attribute is gone')
+      return 'groupTitle + data-plugin-scope'
+    })
+
+    check('the DeepSeek adapter constants the import fallback mirrors', () => {
+      const deepseek = archive.read('dsh/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/index.js')
+      mustInclude(deepseek, '"https://api.deepseek.com/anthropic"', 'PUBLIC_BASE_URL changed')
+      mustInclude(deepseek, '"DEEPSEEK_BASE_URL"', 'BASE_URL_ENV changed')
+      mustInclude(
+        archive.read('dsh/node_modules/@deepseek-ai/dsh-llm-deepseek-api-key/lib/index.js'),
+        '"deepseek-official"',
+        'the deepseek-official provider id changed',
+      )
+      mustInclude(
+        archive.read('dsh/node_modules/@deepseek-ai/dsh-llm-deepseek-account/lib/index.js'),
+        '"deepseek-account"',
+        'the deepseek-account provider id changed',
+      )
+      return 'endpoint + two provider ids'
+    })
+
+    check('the client module loader still accepts this plugin\u2019s bundle format', () => {
+      mustInclude(clientSourceOf(archive, 'dsh-client-modules', cache), '__ModuleLoader__', 'the __ModuleLoader__ facade is gone')
+      mustInclude(source, 'window.__ModuleLoader__.load(', 'this plugin no longer uses the facade')
+      return 'window.__ModuleLoader__.load({ id, factory })'
+    })
+
+    const failed = checks.filter((entry) => !entry.ok)
+    const width = Math.max(...checks.map((entry) => entry.label.length))
+    for (const entry of checks) {
+      console.log(`${entry.ok ? 'PASS' : 'FAIL'}  ${entry.label.padEnd(width)}  ${entry.detail}`)
+    }
+    console.log(`\n${checks.length - failed.length}/${checks.length} compatibility checks passed`)
+    if (failed.length > 0) {
+      console.error('\nThis Harness needs the plugin adapted before it can be trusted here.')
+      process.exitCode = 1
+    }
+  } finally {
+    archive.close()
+  }
+}
+
+main()

package/scripts/log.test.mjs

@@ -8,7 +8,10 @@
  * 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 {
+  closeSync, existsSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync,
+  rmSync, statSync, writeFileSync,
+} from 'node:fs'
 import { basename, join } from 'node:path'
 import { tmpdir } from 'node:os'
 import test from 'node:test'
@@ -228,6 +231,31 @@ test('a fresh store reads the count of a file written by an earlier run', () =>
   }
 })
 
+test('a persisted log is counted in bounded chunks instead of one large allocation', () => {
+  const { dir, cleanup } = withStore({ now: () => day('2026-10-06') })
+  try {
+    const file = join(dir, 'settings-search-2026-10-06.log')
+    writeFileSync(file, 'entry\n'.repeat(20000), 'utf8')
+    let largestRequest = 0
+    let reads = 0
+    const io = {
+      openSync,
+      closeSync,
+      readSync(fd, buffer, offset, length, position) {
+        largestRequest = Math.max(largestRequest, length)
+        reads += 1
+        return readSync(fd, buffer, offset, length, position)
+      },
+    }
+    const reopened = createLogStore({ dir, now: () => day('2026-10-06'), io })
+    assert.equal(reopened.count(), 20000)
+    assert.ok(largestRequest <= 64 * 1024, `requested ${largestRequest} bytes`)
+    assert.ok(reads > 1, 'the file must be streamed across multiple reads')
+  } finally {
+    cleanup()
+  }
+})
+
 const send = async (route, method, body, query = '') => {
   const request = new Request(`http://dsh.internal${route.path}${query}`, {
     method,
@@ -268,7 +296,7 @@ test('the log route serves the tail and accepts append/clear only', async () =>
   try {
     assert.equal(route.path, '/api/settings-search-log')
     assert.deepEqual(route.methods, ['GET', 'POST'])
-    assert.equal(route.requestBody, 'buffered')
+    assert.equal(route.requestBody, 'streaming')
 
     const appended = await send(route, 'POST', { action: 'append', lines: ['hello'] })
     assert.equal(appended.status, 200)
@@ -290,6 +318,28 @@ test('the log route serves the tail and accepts append/clear only', async () =>
   }
 })
 
+test('an over-budget request body is rejected before any action runs', async () => {
+  let actions = 0
+  const route = createLogRoute({
+    dir: 'unused',
+    file: 'unused',
+    ensure() {},
+    append() { actions += 1; return 0 },
+    count() { actions += 1; return 0 },
+    clear() { actions += 1; return true },
+    open() { actions += 1; return { failure: undefined, command: 'test' } },
+    read() { actions += 1; return { text: '', size: 0, truncated: false } },
+  })
+  const request = new Request('http://dsh.internal/api/settings-search-log', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ action: 'append', lines: ['x'.repeat(257 * 1024)] }),
+  })
+  const response = await route.fetch(request)
+  assert.equal(response.status, 400)
+  assert.equal(actions, 0)
+})
+
 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')