dsh-chat-manager-wide 1.4.0

package/scripts/smoke-ui.mjs

@@ -0,0 +1,221 @@
+import { chromium } from 'playwright'
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+const HELP = `Usage:
+  pnpm smoke:ui -- --session "Exact session title" [options]
+
+Options:
+  --url <url>          Running DSH URL (default: http://127.0.0.1:14171)
+  --session <title>    Exact existing session title (required)
+  --channel <name>     Browser channel such as chrome (optional)
+  --executable <path>  Existing Chromium-family executable (optional)
+  --headed             Show the browser window
+  --screenshot <path>  Save the opened confirmation dialog
+  --simulate-delete-success
+                       On a ?fixture page only, intercept the delete request,
+                       click the final button, and verify no page reload
+  --help               Show this help
+
+By default this check opens Delete session, verifies the confirmation dialog,
+and clicks Cancel. The simulation mode never reaches the Host deletion route or
+controls DSH's process lifecycle.
+`
+
+export function parseArgs(argv) {
+  const result = { url: 'http://127.0.0.1:14171', headed: false }
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index]
+    if (arg === '--') continue
+    if (arg === '--help') return { help: true }
+    if (arg === '--headed') {
+      result.headed = true
+      continue
+    }
+    if (arg === '--simulate-delete-success') {
+      result.simulateDeleteSuccess = true
+      continue
+    }
+    if (['--url', '--session', '--channel', '--executable', '--screenshot'].includes(arg)) {
+      const value = argv[index + 1]
+      if (value === undefined || value.startsWith('--')) throw new Error(`${arg} requires a value`)
+      result[arg.slice(2)] = value
+      index += 1
+      continue
+    }
+    throw new Error(`unknown argument: ${arg}`)
+  }
+  if (typeof result.session !== 'string' || result.session.length === 0) {
+    throw new Error('--session is required so the smoke test never chooses a user session implicitly')
+  }
+  if (result.channel !== undefined && result.executable !== undefined) {
+    throw new Error('use either --channel or --executable, not both')
+  }
+  if (result.simulateDeleteSuccess === true) {
+    if (!isFixtureUrl(result.url)) {
+      throw new Error('--simulate-delete-success requires a DSH fixture URL so it cannot target user sessions')
+    }
+  }
+  return result
+}
+
+export function isFixtureUrl(url) {
+  return new URL(url).searchParams.has('fixture')
+}
+
+export function isIgnorableFixtureConsoleError(message) {
+  return (
+    message.includes('[cordis-client-runner] syncing inspect providers failed:')
+      && message.includes('fixture connection RPC endpoint "dynamicCordisRunner/syncInspectManifest" is unavailable')
+  ) || (
+    message.includes('[ui-cordis] reading the Cordis inventory failed:')
+      && message.includes('fixture connection RPC endpoint "dynamicCordisRunner/inventory" is unavailable')
+  )
+}
+
+export async function runSmoke(options) {
+  const deleteRequests = []
+  const consoleErrors = []
+  const fixture = isFixtureUrl(options.url)
+  const browser = await chromium.launch({
+    headless: !options.headed,
+    ...(options.channel === undefined ? {} : { channel: options.channel }),
+    ...(options.executable === undefined ? {} : { executablePath: options.executable }),
+  })
+  try {
+    const page = await browser.newPage({ viewport: { width: 1440, height: 960 } })
+    let navigationArmed = false
+    let mainFrameNavigations = 0
+    if (options.simulateDeleteSuccess === true) {
+      await page.addInitScript(() => {
+        globalThis.__dshDeleteSmokeDocumentToken = crypto.randomUUID()
+      })
+      await page.route('**/plugins/dsh-session-delete/delete', async (route) => {
+        await route.fulfill({
+          status: 200,
+          contentType: 'application/json',
+          body: JSON.stringify({ ok: true, value: { deleted: true } }),
+        })
+      })
+      page.on('framenavigated', (frame) => {
+        if (navigationArmed && frame === page.mainFrame()) mainFrameNavigations += 1
+      })
+    }
+    page.on('request', (request) => {
+      if (new URL(request.url()).pathname === '/plugins/dsh-session-delete/delete') {
+        deleteRequests.push(request.method())
+      }
+    })
+    page.on('console', (message) => {
+      if (message.type() === 'error') consoleErrors.push(message.text())
+    })
+
+    await page.goto(options.url, { waitUntil: 'domcontentloaded' })
+    const documentToken = options.simulateDeleteSuccess === true
+      ? await page.evaluate(() => globalThis.__dshDeleteSmokeDocumentToken)
+      : undefined
+    if (fixture) {
+      // Fixture mode cannot persist DSH's product-wide onboarding acknowledgement,
+      // so clicking Continue immediately reopens the unrelated notice. Remove only
+      // that exact fixture-only overlay; never mutate real settings or user pages.
+      const onboarding = page.getByRole('dialog', { name: /^(内测声明|Internal Testing Notice)$/ })
+      const onboardingVisible = await onboarding
+        .waitFor({ state: 'visible', timeout: 3000 })
+        .then(() => true, () => false)
+      if (onboardingVisible) {
+        await onboarding.evaluate((element) => {
+          const overlay = element.parentElement
+          if (overlay !== null) overlay.remove()
+          else element.remove()
+          for (const inertElement of document.querySelectorAll('[inert]')) {
+            inertElement.removeAttribute('inert')
+          }
+        })
+      }
+    }
+    await page.locator('#archived-sessions').click()
+    const archiveDialog = page.getByRole('dialog', { name: /^(Archived sessions|归档会话)$/ })
+    await archiveDialog.getByRole('searchbox').waitFor()
+    await archiveDialog.getByRole('button', { name: /^(Close|关闭)$/ }).filter({ hasText: /^(Close|关闭)$/ }).click()
+    await archiveDialog.waitFor({ state: 'hidden' })
+    const matchingTitles = page.getByText(options.session, { exact: true })
+    await matchingTitles.first().waitFor()
+    const rowCount = await matchingTitles.count()
+    if (rowCount !== 1) {
+      throw new Error(`expected exactly one visible session row named ${JSON.stringify(options.session)}, found ${rowCount}`)
+    }
+
+    const row = matchingTitles.first().locator('xpath=ancestor::*[@role="treeitem"][1]')
+    await row.hover()
+    const actions = row.getByRole('button')
+    if (await actions.count() !== 1) throw new Error('session action button was not uniquely identifiable')
+    await actions.click()
+
+    const archiveItem = page.getByRole('menuitem', { name: /^(Archive session|归档会话)$/ })
+    await archiveItem.waitFor()
+    const deleteItem = page.getByRole('menuitem', { name: /^(Delete session|删除会话)$/ })
+    await deleteItem.waitFor()
+    const [archiveColor, deleteColor] = await Promise.all([
+      archiveItem.evaluate((element) => getComputedStyle(element).color),
+      deleteItem.evaluate((element) => getComputedStyle(element).color),
+    ])
+    if (archiveColor === deleteColor) {
+      throw new Error(`delete menu item is not using a distinct danger color (${deleteColor})`)
+    }
+    await deleteItem.click()
+
+    const dialog = page.getByRole('dialog')
+    await dialog.getByText(/^(Permanently delete session\?|永久删除会话？)$/).waitFor()
+    await dialog.getByRole('button', { name: /^(Delete permanently|永久删除)$/ }).waitFor()
+    const cancel = dialog.getByRole('button', { name: /^(Cancel|取消)$/ })
+    await cancel.waitFor()
+    if (options.screenshot !== undefined) await dialog.screenshot({ path: options.screenshot })
+    if (options.simulateDeleteSuccess === true) {
+      navigationArmed = true
+      await dialog.getByRole('button', { name: /^(Delete permanently|永久删除)$/ }).click()
+      await page.waitForTimeout(750)
+      const settledToken = await page.evaluate(() => globalThis.__dshDeleteSmokeDocumentToken)
+      if (deleteRequests.length !== 1) {
+        throw new Error(`simulated success expected one delete request, observed ${deleteRequests.length}`)
+      }
+      if (mainFrameNavigations !== 0 || settledToken !== documentToken) {
+        throw new Error(`successful deletion reloaded the WebView (${mainFrameNavigations} main-frame navigation(s))`)
+      }
+      await dialog.getByText(/^(Permanently delete session\?|永久删除会话？)$/).waitFor({ state: 'hidden' })
+    } else {
+      await cancel.click()
+      await dialog.waitFor({ state: 'hidden' })
+      if (deleteRequests.length > 0) {
+        throw new Error(`cancel path unexpectedly sent ${deleteRequests.length} delete request(s)`)
+      }
+    }
+    const blockingConsoleErrors = fixture
+      ? consoleErrors.filter((message) => !isIgnorableFixtureConsoleError(message))
+      : consoleErrors
+    if (blockingConsoleErrors.length > 0) {
+      throw new Error(`browser console errors: ${blockingConsoleErrors.join(' | ')}`)
+    }
+    return {
+      ok: true,
+      checks: options.simulateDeleteSuccess === true
+        ? ['archive manager', 'Archive session', 'red Delete session', 'confirmation dialog', 'successful delete without reload']
+        : ['archive manager', 'Archive session', 'red Delete session', 'confirmation dialog', 'cancel without request'],
+    }
+  } finally {
+    await browser.close()
+  }
+}
+
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  try {
+    const options = parseArgs(process.argv.slice(2))
+    if (options.help) {
+      process.stdout.write(HELP)
+    } else {
+      process.stdout.write(`${JSON.stringify(await runSmoke(options))}\n`)
+    }
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`)
+    process.exitCode = 1
+  }
+}

package/src/host/archive-manager.mjs

@@ -0,0 +1,329 @@
+const SEARCH_LIMIT = 20
+const MESSAGE_TYPES = new Set(['user/message', 'assistant/message'])
+const MAX_REQUEST_BYTES = 8 * 1024
+
+const assertSessionId = sessionId => {
+  if (typeof sessionId !== 'string' || sessionId.length === 0 || sessionId.length > 512 || sessionId.includes('\0')) {
+    throw new TypeError('invalid archived session id')
+  }
+  return sessionId
+}
+
+const archiveIds = workspaceRegistry => {
+  const ids = workspaceRegistry?.archivedSessionIds
+  if (!Array.isArray(ids) || ids.some(id => typeof id !== 'string')) {
+    throw new Error('unsupported workspace registry archive snapshot')
+  }
+  return [...ids]
+}
+
+const plainSnippet = (text, query) => {
+  const compact = text.replace(/\s+/g, ' ').trim()
+  if (compact.length <= 240) return compact
+  const matchAt = compact.toLowerCase().indexOf(query.toLowerCase())
+  const start = Math.max(0, (matchAt === -1 ? 0 : matchAt) - 80)
+  const end = Math.min(compact.length, start + 240)
+  return `${start > 0 ? '…' : ''}${compact.slice(start, end)}${end < compact.length ? '…' : ''}`
+}
+
+const scanArchivedEvents = async (sessionQuery, archivedSessionIds, query, signal) => {
+  if (typeof sessionQuery?.filterEvents !== 'function') {
+    throw new Error('archived history scan is unavailable')
+  }
+  const filters = [
+    { kind: 'type', values: ['user/message', 'assistant/message'] },
+    { kind: 'surface', values: ['current'] },
+    { kind: 'text', text: query },
+  ]
+  const items = []
+  for (let offset = 0; offset < archivedSessionIds.length && items.length <= SEARCH_LIMIT; offset += 4) {
+    signal?.throwIfAborted()
+    const batch = archivedSessionIds.slice(offset, offset + 4)
+    const matches = await Promise.all(batch.map(sessionId => sessionQuery.filterEvents(sessionId, filters)))
+    signal?.throwIfAborted()
+    for (let index = 0; index < batch.length; index += 1) {
+      const match = Array.isArray(matches[index])
+        ? matches[index].find(event => typeof event?.text === 'string' && event.text.trim().length > 0)
+        : undefined
+      if (match !== undefined) items.push({ sessionId: batch[index], snippet: plainSnippet(match.text, query) })
+      if (items.length > SEARCH_LIMIT) break
+    }
+  }
+  return { items: items.slice(0, SEARCH_LIMIT), hasMore: items.length > SEARCH_LIMIT }
+}
+
+/**
+ * Remove one id from DSH's registry-global archive set without touching the
+ * session log or its workspace accounting position. Prefer the public DSH
+ * unarchive operation; older cores retain the validated registry fallback.
+ */
+export async function restoreArchivedSession(workspaceRegistry, sessionId) {
+  const id = assertSessionId(sessionId)
+  if (typeof workspaceRegistry?.unarchiveSession === 'function') {
+    const wasArchived = archiveIds(workspaceRegistry).includes(id)
+    await workspaceRegistry.unarchiveSession(id)
+    return { restored: wasArchived, archivedSessionIds: [...archiveIds(workspaceRegistry)] }
+  }
+  if (
+    typeof workspaceRegistry?.enqueueOperation !== 'function'
+    || typeof workspaceRegistry?.requireState !== 'function'
+    || typeof workspaceRegistry?.setState !== 'function'
+  ) {
+    throw new Error('unsupported workspace registry restore seam')
+  }
+
+  return workspaceRegistry.enqueueOperation(async () => {
+    const state = workspaceRegistry.requireState()
+    if (!Array.isArray(state?.archivedSessionIds)) {
+      throw new Error('unsupported workspace registry restore state')
+    }
+    if (!state.archivedSessionIds.includes(id)) {
+      return { restored: false, archivedSessionIds: [...state.archivedSessionIds] }
+    }
+    const archivedSessionIds = state.archivedSessionIds.filter(candidate => candidate !== id)
+    await workspaceRegistry.setState({ ...state, archivedSessionIds })
+    return { restored: true, archivedSessionIds }
+  })
+}
+
+/** Keep DSH's archive registry free of ids whose storage was permanently removed. */
+export async function deleteSessionAndReconcileArchive({ workspaceRegistry, deleteSession, warn = console.warn }, sessionId) {
+  const result = await deleteSession(sessionId)
+  if (result?.ok !== true) return result
+  try {
+    await restoreArchivedSession(workspaceRegistry, sessionId)
+    return { ok: true, value: { ...result.value, archiveReconciled: true } }
+  } catch (error) {
+    warn('session storage was deleted but its archive marker could not be reconciled:', error)
+    return { ok: true, value: { ...result.value, archiveReconciled: false } }
+  }
+}
+
+/** Search current user/assistant message history inside the archive set only. */
+export async function searchArchivedSessions({ workspaceRegistry, sessionQuery }, query, signal) {
+  signal?.throwIfAborted()
+  const normalized = typeof query === 'string' ? query.trim() : ''
+  if (normalized.length === 0 || normalized.length > 500 || normalized.includes('\0')) {
+    throw new TypeError('invalid archive search query')
+  }
+  if (typeof sessionQuery?.searchSessions !== 'function') {
+    throw new Error('archived history search is unavailable')
+  }
+
+  const archivedSessionIds = archiveIds(workspaceRegistry)
+  if (archivedSessionIds.length === 0) return { items: [], hasMore: false }
+
+  let page
+  try {
+    page = await sessionQuery.searchSessions({
+      query: normalized,
+      sessionFilters: [{ kind: 'id', values: archivedSessionIds }],
+      eventFilters: [
+        { kind: 'type', values: ['user/message', 'assistant/message'] },
+        { kind: 'surface', values: ['current'] },
+      ],
+      limit: SEARCH_LIMIT,
+    }, { signal })
+    signal?.throwIfAborted()
+  } catch (error) {
+    if (error?.code !== 'SESSION_QUERY_SEARCH_DISABLED') throw error
+    return scanArchivedEvents(sessionQuery, archivedSessionIds, normalized, signal)
+  }
+
+  const archived = new Set(archivedSessionIds)
+  const items = []
+  const included = new Set()
+  for (const hit of Array.isArray(page?.items) ? page.items : []) {
+    const sessionId = hit?.header?.id
+    const match = hit?.bestMatch
+    if (
+      typeof sessionId !== 'string'
+      || !archived.has(sessionId)
+      || included.has(sessionId)
+      || match?.sessionId !== sessionId
+      || match?.surface !== 'current'
+      || !MESSAGE_TYPES.has(match?.type)
+      || typeof match?.snippet !== 'string'
+    ) continue
+    included.add(sessionId)
+    items.push({ sessionId, snippet: match.snippet })
+    if (items.length >= SEARCH_LIMIT) break
+  }
+
+  return { items, hasMore: page?.nextCursor !== undefined }
+}
+
+const DETAIL_MESSAGE_LIMIT = 4000
+const DETAIL_TEXT_LIMIT = 40000
+const DETAIL_TOTAL_TEXT_LIMIT = 4 * 1024 * 1024
+
+/**
+ * Read the current user/assistant transcript of one archived session.
+ * Archive membership is re-checked here so this read stays inside the archive set.
+ */
+export async function readArchivedSessionDetail({ workspaceRegistry, sessionQuery }, sessionId) {
+  const id = assertSessionId(sessionId)
+  if (!archiveIds(workspaceRegistry).includes(id)) {
+    throw new TypeError('session is not archived')
+  }
+  if (typeof sessionQuery?.filterEvents !== 'function') {
+    throw new Error('archived history read is unavailable')
+  }
+
+  const documents = await sessionQuery.filterEvents(id, [
+    { kind: 'type', values: ['user/message', 'assistant/message'] },
+    { kind: 'surface', values: ['current'] },
+  ])
+  const found = Array.isArray(documents) ? documents : []
+  const items = []
+  let textBudget = 0
+  let truncated = false
+  for (const document of found) {
+    if (items.length >= DETAIL_MESSAGE_LIMIT) {
+      truncated = true
+      break
+    }
+    const text = typeof document?.text === 'string' ? document.text : ''
+    if (text.trim().length === 0) continue
+    let body = text
+    if (body.length > DETAIL_TEXT_LIMIT) {
+      body = `${body.slice(0, DETAIL_TEXT_LIMIT)}…`
+      truncated = true
+    }
+    if (textBudget + body.length > DETAIL_TOTAL_TEXT_LIMIT) {
+      truncated = true
+      break
+    }
+    textBudget += body.length
+    items.push({
+      seq: Number.isInteger(document?.seq) ? document.seq : items.length,
+      role: document?.type === 'user/message' ? 'user' : 'assistant',
+      time: typeof document?.time === 'number' ? document.time : null,
+      text: body,
+    })
+  }
+
+  return { items, total: found.length, shown: items.length, truncated: truncated || items.length < found.length }
+}
+
+const sendJson = (res, status, payload) => {
+  res.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+    'x-content-type-options': 'nosniff',
+  })
+  res.end(JSON.stringify(payload))
+}
+
+const failure = (code, message) => ({ ok: false, error: { code, message } })
+
+const readJsonBody = async req => {
+  const chunks = []
+  let size = 0
+  for await (const chunk of req) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+    size += buffer.length
+    if (size > MAX_REQUEST_BYTES) throw new Error('request-too-large')
+    chunks.push(buffer)
+  }
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'))
+}
+
+const acceptJsonPost = (req, res) => {
+  if (req.method !== 'POST') {
+    sendJson(res, 405, failure('method-not-allowed', '只允许使用 POST 管理归档会话。'))
+    return false
+  }
+  const host = req.headers.host
+  if (typeof host !== 'string' || req.headers.origin !== `http://${host}`) {
+    sendJson(res, 403, failure('forbidden', '归档管理请求未通过同源校验。'))
+    return false
+  }
+  const contentType = req.headers['content-type']
+  if (typeof contentType !== 'string' || !contentType.toLowerCase().startsWith('application/json')) {
+    sendJson(res, 415, failure('unsupported-media-type', '归档管理请求必须使用 JSON。'))
+    return false
+  }
+  return true
+}
+
+const parseBody = async (req, res) => {
+  try {
+    return await readJsonBody(req)
+  } catch (error) {
+    const tooLarge = error instanceof Error && error.message === 'request-too-large'
+    sendJson(
+      res,
+      tooLarge ? 413 : 400,
+      failure(tooLarge ? 'request-too-large' : 'invalid-json', tooLarge ? '归档管理请求过大。' : '归档管理请求不是有效 JSON。'),
+    )
+    return undefined
+  }
+}
+
+/** Same-origin HTTP boundary consumed by the native archive manager UI. */
+export function createArchiveRequestHandlers({ restore, search, detail, warn = console.warn }) {
+  return {
+    restore: async (req, res) => {
+      if (!acceptJsonPost(req, res)) return
+      if (req.headers['x-dsh-session-manager-action'] !== 'restore-session') {
+        sendJson(res, 403, failure('forbidden', '恢复请求缺少明确的操作标记。'))
+        return
+      }
+      const body = await parseBody(req, res)
+      if (body === undefined) return
+      try {
+        const sessionId = assertSessionId(body?.sessionId)
+        sendJson(res, 200, { ok: true, value: await restore(sessionId) })
+      } catch (error) {
+        if (error instanceof TypeError) {
+          sendJson(res, 400, failure('invalid-session-id', '会话 ID 无效。'))
+        } else {
+          sendJson(res, 500, failure('restore-failed', '取消归档失败，归档状态未确认改变。'))
+        }
+      }
+    },
+    detail: async (req, res) => {
+      if (!acceptJsonPost(req, res)) return
+      const body = await parseBody(req, res)
+      if (body === undefined) return
+      try {
+        const sessionId = assertSessionId(body?.sessionId)
+        sendJson(res, 200, { ok: true, value: await detail(sessionId) })
+      } catch (error) {
+        if (error instanceof TypeError) {
+          sendJson(res, 400, failure('invalid-session-id', '会话 ID 无效或不在归档集合中。'))
+        } else {
+          warn('archived history read failed:', error)
+          sendJson(res, 503, failure('detail-unavailable', '归档对话内容暂不可用。'))
+        }
+      }
+    },
+    search: async (req, res) => {
+      if (!acceptJsonPost(req, res)) return
+      const body = await parseBody(req, res)
+      if (body === undefined) return
+      const query = typeof body?.query === 'string' ? body.query.trim() : ''
+      if (query.length === 0 || query.length > 500 || query.includes('\0')) {
+        sendJson(res, 400, failure('invalid-query', '搜索内容无效。'))
+        return
+      }
+      const controller = new AbortController()
+      const abort = () => controller.abort(new Error('archive search request closed'))
+      req.once('aborted', abort)
+      if (typeof res.once === 'function') res.once('close', abort)
+      try {
+        const value = await search(query, controller.signal)
+        if (controller.signal.aborted) return
+        sendJson(res, 200, { ok: true, value })
+      } catch (error) {
+        if (controller.signal.aborted) return
+        warn('archived history search failed:', error)
+        sendJson(res, 503, failure('search-unavailable', '归档内容搜索暂不可用。'))
+      } finally {
+        req.off('aborted', abort)
+        if (typeof res.off === 'function') res.off('close', abort)
+      }
+    },
+  }
+}