@tobycaimf/dsh-archived-sessions 1.0.0

package/src/index.js

@@ -0,0 +1,277 @@
+// dsh-archived-sessions — host half.
+//
+// Serves /archived-sessions/* JSON routes (list / restore / restore-many /
+// delete / delete-many) over the host `webServer`. The browser Settings
+// section ("归档会话") talks to these. Reads/writes the durable workspace
+// archive set (workspaceRegistry + storageDomain), folds titles/dates/workspace
+// tags from session persistence, and physically removes a session's log file
+// on delete.
+import { unlink } from 'node:fs/promises'
+
+export const name = 'dsh-archived-sessions'
+export const inject = ['webServer', 'workspaceRegistry', 'sessionPersistence', 'sessionQuery', 'storageDomain']
+
+const MAX_TITLE = 80
+
+function json(res, value, status = 200) {
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
+  res.end(JSON.stringify(value))
+}
+
+async function readJsonBody(req) {
+  const chunks = []
+  let total = 0
+  for await (const chunk of req) {
+    chunks.push(chunk)
+    total += chunk.length
+    if (total > 1 << 20) return null
+  }
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'))
+  } catch {
+    return null
+  }
+}
+
+function parseIds(body) {
+  const raw = body && body.sessionIds
+  if (!Array.isArray(raw)) return null
+  const ids = []
+  for (const v of raw) if (typeof v === 'string' && v) ids.push(v)
+  return ids
+}
+
+function foldTitle(events) {
+  let found = null
+  let firstUser = null
+  for (const ev of events) {
+    if (ev.type === 'session/title' && ev.data && typeof ev.data.title === 'string' && ev.data.title.length) {
+      found = ev.data.title
+    }
+    if (firstUser === null && ev.type === 'user/message' && ev.data && Array.isArray(ev.data.content)) {
+      const txt = ev.data.content.filter((b) => b && b.type === 'text').map((b) => b.text).filter(Boolean).join(' ').trim()
+      if (txt) firstUser = txt
+    }
+  }
+  return found || firstUser || null
+}
+
+export function apply(ctx) {
+  const w = ctx.workspaceRegistry
+  const sp = ctx.sessionPersistence
+  const sq = ctx.sessionQuery
+  const dom = () => ctx.storageDomain.get('workspace')
+
+  async function archivedState() {
+    const d = dom()
+    if (!d) throw new Error('workspace domain is not open')
+    return d.global.get()
+  }
+
+  async function writeArchived(nextIds) {
+    const d = dom()
+    if (!d) throw new Error('workspace domain is not open')
+    const cur = d.global.get()
+    const next = Object.assign({}, cur, { archivedSessionIds: nextIds })
+    await d.global.set(next)
+    // Keep the registry's in-memory cache in sync so the live sidebar refreshes.
+    if (w && 'state' in w) { try { w.state = next } catch (e) { /* best-effort */ } }
+    return next
+  }
+
+  let wsByPath = {}
+
+  async function resolveOne(id) {
+    let title = null, createdAt = null, cwd = null
+    try {
+      const o = await sq.readTitleSnapshot(id)
+      if (o) {
+        if (o.title && o.title.title) title = String(o.title.title)
+        if (o.session) { cwd = o.session.cwd || null; createdAt = o.session.createdAt || null }
+      }
+    } catch (e) { /* fall back to raw log */ }
+    if (!title || !cwd) {
+      try {
+        const r = await sp.readFrom(id, 0)
+        if (r.meta) {
+          if (!cwd) cwd = r.meta.cwd || null
+          if (!createdAt) createdAt = r.meta.createdAt || null
+        }
+        if (!title && Array.isArray(r.events)) title = foldTitle(r.events)
+      } catch (e2) { /* keep what we have */ }
+    }
+    const ws = cwd ? wsByPath[cwd] : undefined
+    const workspaceGone = !!(cwd && !ws)
+    const display = title ? (String(title).length > MAX_TITLE ? String(title).slice(0, MAX_TITLE) + '…' : String(title)) : null
+    return {
+      sessionId: id,
+      title: display,
+      createdAt: createdAt || null,
+      workspacePath: cwd || null,
+      workspaceTitle: (ws && ws.title) ? ws.title : null,
+      workspaceGone: workspaceGone ? true : false,
+      hasWorkspace: !!cwd,
+    }
+  }
+
+  // Restore (unarchive) one session; throws on failure.
+  async function restoreOne(sid) {
+    const state = await archivedState()
+    const list = state.archivedSessionIds.map(String)
+    if (!list.includes(sid)) return { ok: true, restored: false }
+    await writeArchived(list.filter((x) => x !== sid))
+    return { ok: true, restored: true }
+  }
+
+  // Physically delete one session log + clear archive/workspace accounting;
+  // throws on failure (live sessions are rejected).
+  async function deleteOne(sid) {
+    const sessions = ctx.get('sessions')
+    if (sessions && sessions.get(sid)) {
+      throw new Error('该会话当前处于打开状态，请先切换到别的会话再删除。')
+    }
+    let removedPath = null
+    try {
+      const headers = await sp.list()
+      const header = headers.find((h) => String(h.id) === sid)
+      if (header) {
+        const loc = sp.locate(header)
+        if (loc && typeof loc.path === 'string') removedPath = loc.path
+      } else {
+        // Session not in the materialized list — use its header cwd to locate the log anyway.
+        const r = await sp.readFrom(sid, 0)
+        if (r && r.meta && r.meta.cwd) {
+          const loc = sp.locate({ id: sid, cwd: r.meta.cwd })
+          if (loc && typeof loc.path === 'string') removedPath = loc.path
+        }
+      }
+    } catch (e) { /* best-effort */ }
+    if (removedPath) {
+      try {
+        await unlink(removedPath)
+      } catch (e) {
+        if (e && e.code !== 'ENOENT') throw new Error('删除日志文件失败：' + String((e && e.message) || e))
+      }
+    }
+    try {
+      for (const ent of w.list()) {
+        if (ent.sessionIds.includes(sid)) { try { await ent.detachSession(sid) } catch (e) { /* ignore */ } }
+      }
+    } catch (e) { /* ignore */ }
+    try { if (w.sessionPaths && w.sessionPaths.delete) w.sessionPaths.delete(sid) } catch (e) {}
+    try { if (w.headers && w.headers.delete) w.headers.delete(sid) } catch (e) {}
+    // NOTE: intentionally do NOT unarchive (keep the id in the archive set).
+    // Removing it from the archive set would make DSH re-show the session in the
+    // sidebar; with its workspace gone it would land in 未分组 until the index
+    // rebuilds. Keeping it hidden keeps the deleted session out of every list
+    // immediately. The stale hidden id is inert (no log -> no session resolves).
+    return { ok: true, deleted: true, removedPath }
+  }
+
+  ctx.effect(() => {
+    const disposers = []
+
+    disposers.push(ctx.webServer.register({
+      kind: 'exact',
+      path: '/archived-sessions/list',
+      handler: async (req, res) => {
+        try {
+          const state = await archivedState()
+          const ids = state.archivedSessionIds || []
+          // Only surface archived ids that still exist (materialized log or live).
+          // Deleted sessions keep a hidden archive id but no log, so they drop out here.
+          let materialized = new Set()
+          let live = ctx.get('sessions')
+          try {
+            const headers = await sp.list()
+            materialized = new Set(headers.map((h) => String(h.id)))
+          } catch (e) { /* best-effort */ }
+          const idStrs = ids.map(String).filter((id) => materialized.has(id) || (live && live.get(id)))
+          wsByPath = {}
+          try { for (const ent of w.list()) wsByPath[ent.path] = ent } catch (e) { wsByPath = {} }
+          const items = []
+          const CHUNK = 6
+          for (let i = 0; i < idStrs.length; i += CHUNK) {
+            const res2 = await Promise.all(idStrs.slice(i, i + CHUNK).map(resolveOne))
+            items.push.apply(items, res2)
+          }
+          json(res, { items })
+        } catch (e) {
+          json(res, { error: String((e && e.message) || e) }, 500)
+        }
+      },
+    }))
+
+    disposers.push(ctx.webServer.register({
+      kind: 'exact',
+      path: '/archived-sessions/restore',
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req)
+          const sid = body && typeof body.sessionId === 'string' ? body.sessionId : null
+          if (!sid) return json(res, { ok: false, error: 'missing sessionId' }, 400)
+          json(res, await restoreOne(sid))
+        } catch (e) {
+          json(res, { ok: false, error: String((e && e.message) || e) }, 500)
+        }
+      },
+    }))
+
+    disposers.push(ctx.webServer.register({
+      kind: 'exact',
+      path: '/archived-sessions/restore-many',
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req)
+          const ids = parseIds(body)
+          if (!ids || ids.length === 0) return json(res, { ok: false, error: 'missing sessionIds' }, 400)
+          const results = []
+          for (const sid of ids) {
+            try { results.push({ sessionId: sid, ok: true, ...(await restoreOne(sid)) }) }
+            catch (e) { results.push({ sessionId: sid, ok: false, error: String((e && e.message) || e) }) }
+          }
+          json(res, { ok: true, restored: results.filter((r) => r.ok).length, results })
+        } catch (e) {
+          json(res, { ok: false, error: String((e && e.message) || e) }, 500)
+        }
+      },
+    }))
+
+    disposers.push(ctx.webServer.register({
+      kind: 'exact',
+      path: '/archived-sessions/delete',
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req)
+          const sid = body && typeof body.sessionId === 'string' ? body.sessionId : null
+          if (!sid) return json(res, { ok: false, error: 'missing sessionId' }, 400)
+          json(res, await deleteOne(sid))
+        } catch (e) {
+          json(res, { ok: false, error: String((e && e.message) || e) }, 500)
+        }
+      },
+    }))
+
+    disposers.push(ctx.webServer.register({
+      kind: 'exact',
+      path: '/archived-sessions/delete-many',
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req)
+          const ids = parseIds(body)
+          if (!ids || ids.length === 0) return json(res, { ok: false, error: 'missing sessionIds' }, 400)
+          const results = []
+          for (const sid of ids) {
+            try { results.push({ sessionId: sid, ok: true, ...(await deleteOne(sid)) }) }
+            catch (e) { results.push({ sessionId: sid, ok: false, error: String((e && e.message) || e) }) }
+          }
+          json(res, { ok: true, deleted: results.filter((r) => r.ok).length, results })
+        } catch (e) {
+          json(res, { ok: false, error: String((e && e.message) || e) }, 500)
+        }
+      },
+    }))
+
+    return () => { for (const d of disposers) d() }
+  }, 'dsh-archived-sessions: routes')
+}

package/src/zstd-frame.js

@@ -0,0 +1,137 @@
+// dsh-sessions-manager — zstd frame helpers.
+//
+// DSH persists session logs as a sequence of concatenated zstd frames. The
+// FIRST frame must be exactly one line: the session header JSON (type
+// 'session'). The persistence layer enforces this on startup
+// (assertZstdHeaderFrame), so any corruption of frame0 takes down the whole
+// web profile.
+//
+// Moving a session between workspaces requires rewriting frame0's `cwd`
+// without re-encoding the rest of the log. That rewrite is where a bad frame
+// boundary can silently destroy a session — hence the defensive checks here.
+
+import zlib from 'node:zlib'
+import { readFileSync, writeFileSync } from 'node:fs'
+
+// zstd magic bytes are 28 B5 2F FD; read as a little-endian uint32 that is
+// 0xFD2FB528 (4247762216).
+export const ZSTD_MAGIC = 0xFD2FB528
+
+const CHECKSUM_OPTS = { params: { [zlib.constants.ZSTD_c_checksumFlag]: 1 } }
+
+/**
+ * Locate real zstd frame boundaries in a concatenated-frame buffer.
+ *
+ * Scanning for the 4-byte magic alone produces FALSE POSITIVES: the same byte
+ * sequence can occur inside compressed data. Every candidate is therefore
+ * validated by attempting decompression; only offsets that decode are kept.
+ *
+ * @param {Buffer} buf
+ * @returns {number[]} ascending offsets of real frame starts
+ */
+export function findZstdFrameStarts(buf) {
+  const starts = []
+  for (let i = 0; i + 4 <= buf.length; i++) {
+    if (buf.readUInt32LE(i) !== ZSTD_MAGIC) continue
+    try {
+      // Two checks are needed, not just one:
+      //  - a magic inside compressed data fails to decode and throws
+      //  - a BARE 4-byte magic at the very end of the buffer decodes to an
+      //    EMPTY result without throwing, so non-empty output is required too
+      // Every real frame carries at least one JSON line, so neither case can
+      // be a genuine frame start.
+      const out = zlib.zstdDecompressSync(buf.subarray(i, i + Math.min(buf.length - i, 1000000)))
+      if (out.length > 0) starts.push(i)
+    } catch (_) {
+      // Not a real frame boundary — the magic bytes occurred inside compressed data.
+    }
+  }
+  return starts
+}
+
+/**
+ * Rewrite the `cwd` field of a session log's first frame, leaving all
+ * subsequent frames byte-identical.
+ *
+ * Refuses to write anything unless frame0 is a session header. A corrupted
+ * frame0 (e.g. an `agent/inbox/spliced` event) is reported as an error rather
+ * than being re-serialized back to disk — rewriting it would bake the
+ * corruption in permanently and make the file unrecoverable.
+ *
+ * @param {string} filePath path to session.jsonl.zstd
+ * @param {string} newCwd   workspace path to write into frame0
+ * @throws {Error} when the log has no zstd frame or frame0 is not a session header
+ */
+export function rewriteFrame0Cwd(filePath, newCwd) {
+  const buf = readFileSync(filePath)
+  const starts = findZstdFrameStarts(buf)
+  if (starts.length === 0) throw new Error('会话日志格式异常（无 zstd 帧）')
+  const end0 = starts.length > 1 ? starts[1] : buf.length
+  const frame0 = buf.subarray(starts[0], end0)
+  const text = zlib.zstdDecompressSync(frame0).toString('utf8')
+  const nl = text.indexOf('\n')
+  const line = nl >= 0 ? text.slice(0, nl) : text
+  const obj = JSON.parse(line)
+  if (obj.type !== 'session') {
+    throw new Error(`会话日志格式异常（帧0 不是 session header，实际 type=${obj.type}）`)
+  }
+  if (obj.cwd === newCwd) return // already correct, no rewrite needed
+  obj.cwd = newCwd
+  const newFrame0 = zlib.zstdCompressSync(JSON.stringify(obj) + '\n', CHECKSUM_OPTS)
+  const rest = buf.subarray(end0)
+  writeFileSync(filePath, Buffer.concat([newFrame0, rest]))
+}
+
+/**
+ * Non-destructive variant of rewriteFrame0Cwd: returns the rewritten buffer
+ * instead of touching the file on disk. Used by tests.
+ *
+ * @param {Buffer} buf
+ * @param {string} newCwd
+ * @returns {Buffer} rewritten log
+ */
+export function rewriteFrame0CwdInMemory(buf, newCwd) {
+  const starts = findZstdFrameStarts(buf)
+  if (starts.length === 0) throw new Error('会话日志格式异常（无 zstd 帧）')
+  const end0 = starts.length > 1 ? starts[1] : buf.length
+  const frame0 = buf.subarray(starts[0], end0)
+  const text = zlib.zstdDecompressSync(frame0).toString('utf8')
+  const nl = text.indexOf('\n')
+  const line = nl >= 0 ? text.slice(0, nl) : text
+  const obj = JSON.parse(line)
+  if (obj.type !== 'session') {
+    throw new Error(`会话日志格式异常（帧0 不是 session header，实际 type=${obj.type}）`)
+  }
+  obj.cwd = newCwd
+  const newFrame0 = zlib.zstdCompressSync(JSON.stringify(obj) + '\n', CHECKSUM_OPTS)
+  const rest = buf.subarray(end0)
+  return Buffer.concat([newFrame0, rest])
+}
+
+/**
+ * Build a multi-frame session log buffer (header frame + event frames),
+ * matching the layout DSH's persistence layer writes. Used by tests.
+ *
+ * @param {object} header  session header (must have type: 'session')
+ * @param {object[]} events subsequent records, one zstd frame each
+ * @returns {Buffer}
+ */
+export function buildSessionLog(header, events = []) {
+  const frames = [JSON.stringify(header) + '\n', ...events.map((e) => JSON.stringify(e) + '\n')]
+  return Buffer.concat(frames.map((f) => zlib.zstdCompressSync(Buffer.from(f, 'utf8'), CHECKSUM_OPTS)))
+}
+
+/**
+ * Read frame0 of a session log and return the parsed header line.
+ *
+ * @param {Buffer} buf
+ * @returns {{obj: object, lineCount: number}}
+ */
+export function readFrame0(buf) {
+  const starts = findZstdFrameStarts(buf)
+  if (starts.length === 0) throw new Error('会话日志格式异常（无 zstd 帧）')
+  const end0 = starts.length > 1 ? starts[1] : buf.length
+  const text = zlib.zstdDecompressSync(buf.subarray(starts[0], end0)).toString('utf8')
+  const lines = text.split('\n').filter((l) => l.length > 0)
+  return { obj: JSON.parse(lines[0]), lineCount: lines.length }
+}

package/tests/host.test.js

@@ -0,0 +1,145 @@
+import assert from 'node:assert/strict'
+import { after, before, test } from 'node:test'
+import { Readable } from 'node:stream'
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+let root
+let routes
+let domainState
+let sessionPath
+let liveSessions
+
+before(async () => {
+  root = await mkdtemp(join(tmpdir(), 'dsm-test-'))
+  process.env.DSH_SESSIONS_MANAGER_TRASH_DIR = join(root, 'trash')
+  await mkdir(process.env.DSH_SESSIONS_MANAGER_TRASH_DIR, { recursive: true })
+  await writeFile(join(process.env.DSH_SESSIONS_MANAGER_TRASH_DIR, 'index.json'), JSON.stringify([{ sessionId: 'legacy-1', title: 'Legacy', deletedAt: 1 }]))
+  const { apply } = await import(`../src/index.js?test=${Date.now()}`)
+  routes = new Map()
+  domainState = { archivedSessionIds: [] }
+  // Match DSH's real persistence layout: the session id owns a directory,
+  // while the log filename itself is the generic session.jsonl.zstd.
+  sessionPath = join(root, 'known-1', 'session.jsonl.zstd')
+  await mkdir(dirname(sessionPath), { recursive: true })
+  await writeFile(sessionPath, 'test')
+  const header = { id: 'known-1', cwd: root, title: 'Known session', createdAt: Date.now() }
+  const live = { id: 'known-1', header, events: [{ type: 'session/title', data: { title: 'Latest renamed title' } }] }
+  liveSessions = new Map([['known-1', live]])
+  const sessions = {
+    get: (id) => liveSessions.get(id), list: () => [...liveSessions.values()], flush: async () => true,
+    store: new Map([['known-1', { detach: () => liveSessions.delete('known-1') }]]),
+  }
+  const ctx = {
+    workspaceRegistry: {
+      list: () => [], state: domainState,
+      archiveSession: async (sid) => { if (!domainState.archivedSessionIds.includes(sid)) domainState.archivedSessionIds.push(sid) },
+    },
+    sessionPersistence: {
+      list: async () => [header], locate: (item) => item.id === 'known-1' ? { path: sessionPath } : null,
+      readFrom: async (sid) => sid === 'known-1' ? { meta: header, events: [] } : Promise.reject(new Error('missing')),
+    },
+    sessionQuery: {
+      readTitleSnapshot: async () => ({ session: header, title: { title: 'Latest renamed title' } }),
+      readTitleSnapshots: async (ids) => ids.map(() => ({ status: 'fulfilled', value: { session: header, title: { title: 'Latest renamed title' } } })),
+    },
+    storageDomain: { get: () => ({ global: { get: () => domainState, set: async (next) => Object.assign(domainState, next) } }) },
+    webServer: { register: (route) => { routes.set(route.path, route.handler); return () => {} } },
+    get: (name) => name === 'sessions' ? sessions : null,
+    effect: (fn) => fn(),
+  }
+  apply(ctx)
+})
+
+after(async () => { await rm(root, { recursive: true, force: true }) })
+
+async function call(path, body = {}) {
+  const req = Readable.from([Buffer.from(JSON.stringify(body))])
+  let status = 200
+  let text = ''
+  const res = { writeHead: (value) => { status = value }, end: (value) => { text += value || '' } }
+  await routes.get(path)(req, res)
+  return { status, body: JSON.parse(text) }
+}
+
+test('reads a legacy trash array through schema v2 API', async () => {
+  const result = await call('/archived-sessions/trash/list')
+  assert.equal(result.status, 200)
+  assert.equal(result.body.schemaVersion, 2)
+  assert.equal(result.body.items[0].sessionId, 'legacy-1')
+  assert.deepEqual(result.body.settings, { retentionDays: 0 })
+})
+
+test('persists a supported retention policy atomically', async () => {
+  const result = await call('/archived-sessions/trash/settings', { retentionDays: 30 })
+  assert.equal(result.status, 200)
+  assert.equal(result.body.settings.retentionDays, 30)
+  const stored = JSON.parse(await readFile(join(process.env.DSH_SESSIONS_MANAGER_TRASH_DIR, 'index.json'), 'utf8'))
+  assert.equal(stored.schemaVersion, 2)
+  assert.equal(stored.settings.retentionDays, 30)
+})
+
+test('rejects unsafe session ids', async () => {
+  const result = await call('/archived-sessions/delete', { sessionId: '../escape' })
+  assert.equal(result.status, 400)
+  assert.match(result.body.error, /sessionId/)
+})
+
+test('keeps activity, archive and trash transitions consistent', async () => {
+  let result = await call('/archived-sessions/archive', { sessionId: 'known-1' })
+  assert.equal(result.body.archived, true)
+  assert.deepEqual(domainState.archivedSessionIds, ['known-1'])
+
+  result = await call('/archived-sessions/restore', { sessionId: 'known-1' })
+  assert.equal(result.body.restored, true)
+  assert.deepEqual(domainState.archivedSessionIds, [])
+
+  result = await call('/archived-sessions/delete', { sessionId: 'known-1' })
+  assert.equal(result.body.trashed, true)
+  result = await call('/archived-sessions/trash/restore', { sessionId: 'known-1' })
+  assert.equal(result.body.restored, true)
+  const trash = await call('/archived-sessions/trash/list')
+  assert.equal(trash.body.items.some((item) => item.sessionId === 'known-1'), false)
+  assert.deepEqual(domainState.archivedSessionIds, [])
+})
+
+test('serializes concurrent archive and restore operations without duplicate ids', async () => {
+  await Promise.all([
+    call('/archived-sessions/archive', { sessionId: 'known-1' }),
+    call('/archived-sessions/archive', { sessionId: 'known-1' }),
+  ])
+  assert.deepEqual(domainState.archivedSessionIds, ['known-1'])
+  await Promise.all([
+    call('/archived-sessions/restore', { sessionId: 'known-1' }),
+    call('/archived-sessions/restore', { sessionId: 'known-1' }),
+  ])
+  assert.deepEqual(domainState.archivedSessionIds, [])
+})
+
+test('restores an archived trashed session to its pre-delete archived state', async () => {
+  await call('/archived-sessions/archive', { sessionId: 'known-1' })
+  await call('/archived-sessions/delete', { sessionId: 'known-1' })
+  const restored = await call('/archived-sessions/trash/restore', { sessionId: 'known-1' })
+  assert.equal(restored.body.restored, true)
+  assert.deepEqual(domainState.archivedSessionIds, ['known-1'])
+
+  await call('/archived-sessions/restore', { sessionId: 'known-1' })
+  assert.deepEqual(domainState.archivedSessionIds, [])
+})
+
+test('serves latest log-folded titles to the cold sidebar', async () => {
+  const state = await call('/archived-sessions/sidebar-state')
+  assert.equal(state.body.titles['known-1'], 'Latest renamed title')
+})
+
+test('hard purge detaches a live session and persists an authoritative tombstone', async () => {
+  await call('/archived-sessions/delete', { sessionId: 'known-1' })
+  const purged = await call('/archived-sessions/trash/purge', { sessionId: 'known-1' })
+  assert.equal(purged.body.purged, true)
+  assert.equal(liveSessions.has('known-1'), false)
+  await assert.rejects(readFile(sessionPath))
+  const state = await call('/archived-sessions/sidebar-state')
+  assert.equal(state.body.purgedSessionIds.includes('known-1'), true)
+  assert.equal(state.body.trashedSessionIds.includes('known-1'), false)
+})