dsh-native-session-delete 1.0.7 → 1.1.1

package/src/host/archive-manager.mjs

@@ -0,0 +1,251 @@
+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)))
+    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. DSH does not expose a
+ * public unarchive method yet, so every private seam is checked before use.
+ */
+export async function restoreArchivedSession(workspaceRegistry, sessionId) {
+  const id = assertSessionId(sessionId)
+  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) {
+  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 })
+  } 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 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, 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', '取消归档失败，归档状态未确认改变。'))
+        }
+      }
+    },
+    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)
+        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)
+      }
+    },
+  }
+}

package/src/index.js

@@ -3,9 +3,15 @@ import {
   deleteSessionSafely,
   installAgentHandleTracker,
 } from './host/delete-session.mjs'
+import {
+  createArchiveRequestHandlers,
+  deleteSessionAndReconcileArchive,
+  restoreArchivedSession,
+  searchArchivedSessions,
+} from './host/archive-manager.mjs'
 
 export const name = 'dsh-session-delete'
-export const inject = ['webServer', 'sessionPersistence', 'sessions', 'agents']
+export const inject = ['webServer', 'sessionPersistence', 'sessions', 'agents', 'workspaceRegistry']
 
 export function apply(ctx) {
   const sessionRoot = ctx.sessionPersistence?.root
@@ -16,13 +22,24 @@ export function apply(ctx) {
   const agentHandles = installAgentHandleTracker(ctx.agents, ctx.sessions)
   ctx.effect(() => () => agentHandles.release(), 'dsh-session-delete: agent lifecycle tracking')
 
+  const deleteSession = sessionId => deleteSessionSafely({
+    sessions: ctx.sessions,
+    agents: ctx.agents,
+    agentHandles,
+    sessionPersistence: ctx.sessionPersistence,
+  }, { sessionRoot, sessionId })
   const handler = createDeleteRequestHandler({
-    deleteSession: sessionId => deleteSessionSafely({
-      sessions: ctx.sessions,
-      agents: ctx.agents,
-      agentHandles,
-      sessionPersistence: ctx.sessionPersistence,
-    }, { sessionRoot, sessionId }),
+    deleteSession: sessionId => deleteSessionAndReconcileArchive({
+      workspaceRegistry: ctx.workspaceRegistry,
+      deleteSession,
+    }, sessionId),
+  })
+  const archiveHandlers = createArchiveRequestHandlers({
+    restore: sessionId => restoreArchivedSession(ctx.workspaceRegistry, sessionId),
+    search: (query, signal) => searchArchivedSessions({
+      workspaceRegistry: ctx.workspaceRegistry,
+      sessionQuery: ctx.get('sessionQuery'),
+    }, query, signal),
   })
 
   ctx.effect(
@@ -33,6 +50,22 @@ export function apply(ctx) {
     }),
     'dsh-session-delete: confirmed permanent deletion route',
   )
+  ctx.effect(
+    () => ctx.webServer.register({
+      kind: 'exact',
+      path: '/plugins/dsh-session-delete/restore',
+      handler: archiveHandlers.restore,
+    }),
+    'dsh-session-delete: archived session restore route',
+  )
+  ctx.effect(
+    () => ctx.webServer.register({
+      kind: 'exact',
+      path: '/plugins/dsh-session-delete/archive-search',
+      handler: archiveHandlers.search,
+    }),
+    'dsh-session-delete: archived history search route',
+  )
 }
 
 export {
@@ -41,3 +74,10 @@ export {
   deleteSessionSafely,
   installAgentHandleTracker,
 } from './host/delete-session.mjs'
+
+export {
+  createArchiveRequestHandlers,
+  deleteSessionAndReconcileArchive,
+  restoreArchivedSession,
+  searchArchivedSessions,
+} from './host/archive-manager.mjs'

package/README.en.md

@@ -1,134 +0,0 @@
-<div align="center">
-
-# DSH Native Session Delete
-
-**Bring permanent session deletion to the native DeepSeek Harness menu.**
-
-Native dark menu · Second confirmation · Permanent delete · In-place list update
-
-[![Release](https://img.shields.io/github/v/release/WSL043/dsh-native-session-delete?display_name=tag&style=flat-square)](https://github.com/WSL043/dsh-native-session-delete/releases/latest)
-[![Checks](https://img.shields.io/github/actions/workflow/status/WSL043/dsh-native-session-delete/ci.yml?branch=main&label=checks&style=flat-square)](https://github.com/WSL043/dsh-native-session-delete/actions/workflows/ci.yml)
-[![npm](https://img.shields.io/npm/v/dsh-native-session-delete?style=flat-square)](https://www.npmjs.com/package/dsh-native-session-delete)
-[![DSH](https://img.shields.io/badge/DSH-compatible-2f81f7?style=flat-square)](#compatibility)
-[![License](https://img.shields.io/github/license/WSL043/dsh-native-session-delete?style=flat-square)](LICENSE)
-
-[中文](README.md) · [Install](#install) · [Use](#use) · [Safety boundary](#safety-boundary)
-
-</div>
-
-<p align="center">
-  <img src="https://raw.githubusercontent.com/WSL043/dsh-native-session-delete/v1.0.7/docs/assets/hero.en.png" alt="Red Delete session action in the native DeepSeek Harness dark-mode session menu">
-</p>
-
-| Native | Direct | Smooth |
-| --- | --- | --- |
-| The action lives in the native session menu and keeps Archive available | A second confirmation permanently deletes the target; running work is stopped first | The list updates in place without reloading the whole DSH page |
-
-## Install
-
-### Windows quick install (recommended)
-
-Open PowerShell and paste one line:
-
-```powershell
-irm 'https://github.com/WSL043/dsh-native-session-delete/releases/download/v1.0.7/install.ps1' | iex
-```
-
-The helper checks the current directory, PATH, `DSH_PORTABLE_ROOT`, Downloads/Desktop/Documents, and up to
-three nested levels below those folders and `LocalAppData\Temp`, then calls the official DSH `plugin add`
-command once. It does not recursively scan disks, install a package manager, snapshot profiles, create a
-resident command, or download the plugin twice. It supports regular DSH and both the portable edition and
-Windows installer edition of [DSH-Portable](https://github.com/WSL043/DSH-Portable) as targets. If it finds one durable installation plus disposable
-copies under Temp, it chooses the durable installation automatically. If several durable installations exist,
-the helper displays their real paths and asks for a number; no command editing or placeholder path is needed.
-If it still finds nothing, enter the actual DSH-Portable folder and rerun the same one-line command.
-
-### Official CLI (macOS, Linux, or direct review)
-
-```sh
-dsh plugin --profile web add dsh-native-session-delete@1.0.7
-```
-
-The helper and direct command use the same standard bundle mechanism. The helper is only a Windows entry
-point; DSH still owns the installation transaction.
-
-When the command finishes, save your work and restart DSH once through its normal workflow so the new
-bundle configuration becomes active.
-
-### Agent installation
-
-Use the fixed-version [AGENTS.md](https://raw.githubusercontent.com/WSL043/dsh-native-session-delete/v1.0.7/AGENTS.md).
-It defines installation, update, acceptance, uninstall, and safety boundaries. Do not use the `main`
-branch document as an installation contract.
-
-## Use
-
-1. Open the native actions menu beside the target session in the sidebar.
-2. Choose the red **Delete session…** action.
-3. Check the session name and select **Delete permanently** in the confirmation dialog, or select
-   **Cancel** to leave it unchanged.
-
-<p align="center">
-  <img src="https://raw.githubusercontent.com/WSL043/dsh-native-session-delete/v1.0.7/docs/assets/confirm-delete.en.png" width="560" alt="English dark-mode permanent deletion confirmation dialog">
-  <br><sub>Permanent deletion cannot be undone; the dialog identifies the target session.</sub>
-</p>
-
-Once active, the plugin reuses DSH lifecycle and session-storage capabilities. If work is still running,
-it is stopped and allowed to settle before the target session is deleted. The session list then
-updates in place without reloading the whole DSH page.
-
-## Safety boundary
-
-> [!WARNING]
-> Permanent deletion cannot be undone. Check the session name before confirming and make a separate backup when needed.
-
-The plugin is responsible for validating and removing only the explicitly confirmed session's dedicated
-directory within DSH's default per-session JSONL store and host lifecycle boundary. DSH currently exposes
-no public session-deletion API. The second confirmation is mandatory; cancelling sends no deletion request.
-
-The following are outside the plugin's deletion scope and are not guaranteed to be removed:
-
-- Other sessions, other plugin data, external attachments, caches, indexes, logs, backups, or cloud/sync copies;
-- Non-JSONL storage or hosts without a safe stop capability; these are refused instead of force-deleted;
-- Additional copies created by the operating system, filesystem, host updates, or third-party sync services.
-
-If the operating system refuses cleanup, the plugin reports that deletion could not be confirmed rather
-than misreporting partial completion as success. You are responsible for having authority to delete the
-target data and for meeting applicable retention, audit, and privacy requirements. This is an unofficial
-community plugin, not affiliated with or endorsed by DeepSeek. It is provided under the [MIT License](LICENSE),
-without warranty.
-
-## Compatibility
-
-<!-- dsh-compatibility -->
-Supports DeepSeek Harness: `0.1.0-rc.6`, `0.1.0-rc.7`, `0.1.0-rc.8`, `0.1.1-rc.1`, `0.1.1-rc.2`.
-<!-- /dsh-compatibility -->
-
-The plugin supports DSH's default per-session JSONL storage. It adds deletion to the native session menu;
-uninstalling restores the original DSH menu.
-
-## Update and uninstall
-
-Update by rerunning the quick installer or installing the new npm version. For v1.0.7:
-
-```sh
-dsh plugin --profile web add dsh-native-session-delete@1.0.7
-```
-
-Uninstall removes only this plugin's bundle layer and never deletes sessions:
-
-```sh
-dsh plugin --profile web remove dsh-native-session-delete
-```
-
-For DSH-Portable, use the corresponding `.\dsh.exe plugin --profile web add ...` or
-`.\dsh.exe plugin --profile web remove dsh-native-session-delete`. Restart DSH through its normal
-workflow after installing, updating, or uninstalling so the configuration is recomposed.
-
-## Support and license
-
-Open a [GitHub Issue](https://github.com/WSL043/dsh-native-session-delete/issues) for ordinary problems. Report
-security issues privately as described in [SECURITY.md](SECURITY.md).
-
-MIT. See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for the modified upstream client and its license
-notice.