dsh-delete-conversation 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jiuling
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,58 @@
-# Temporary Holding Version
+# dsh-delete-conversation
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> DeepSeek Harness 插件：在侧边栏会话的「⋯」菜单里加一项 **删除会话**。
+
+DSH 原生只提供「归档会话」（会话仍留在磁盘上，可随时取消归档）。装上这个插件后，
+菜单里会多出一行 **删除会话**：经二次确认，**永久删除**该会话的日志、工作区归属与投影缓存。
+
+## 安装
+
+```bash
+dsh plugin add dsh-delete-conversation
+```
+
+安装后重启 DSH 宿主（Web 端刷新页面即可加载浏览器半边；宿主半边需要重启进程）。
+
+## 使用
+
+1. 在左侧边栏把鼠标移到任意会话行上，点右侧的「⋯」；
+2. 菜单底部选择 **删除会话**；
+3. 弹窗里确认 **永久删除**。
+
+删完这一行就从列表里消失了。
+
+## 它到底删了什么
+
+一次删除会清掉这个会话的全部落地痕迹：
+
+| 位置 | 内容 |
+|---|---|
+| `$DSH_HOME/sessions/<项目>/<会话 id>/` | 会话事件日志（`session.v4.jsonl.zstd`） |
+| `$DSH_HOME/storages/workspace.json` → `archivedSessionIds` | 该会话的归档记录 |
+| `$DSH_HOME/storages/workspace.json` → `tables.workspaces.*.sessionIds` | 该会话的工作区归属 |
+| `$DSH_HOME/storages/session_projcache/sessions/<会话 id>.json` | 会话投影缓存 |
+
+工作区那部分走的是宿主自己的 `workspaceRegistry`（`detachSession` / `unarchiveSession`），
+不是绕开它直接改文件——所以内存里的投影和磁盘上的表始终一致。
+
+## 安全边界
+
+- **正在运行的会话不能删。** 它有活跃的 Agent 持有写锁，且界面还指着它。
+  这种情况接口返回 `409`，弹窗里会提示你先结束它或改为归档。
+- **只在同源、回环地址上的请求会被受理。** 带了 `forwarded` / `x-forwarded-for` /
+  `x-real-ip` 的转发请求一律 `403`，所以把这个端口暴露到公网也不会被人隔着隧道删会话。
+- **每个会话 id 都按格式校验**（`session-<uuid>`），不合法直接拒。
+- 删除是物理不可逆的，没有回收站。想要可恢复，请用原生「归档会话」。
+
+## 兼容性
+
+- 依赖官方菜单插槽 `sidebar.workspaces.session.menu.item`（DSH 桌面端 / Web 端自带）。
+  插件不碰 DOM，不劫持样式，官方改版菜单不会让它散架。
+- 菜单行的样式优先复用 `@deepseek-ai/dsh-client-ui-primitives` 的 `MenuItemButton`
+  与 `IconTrashOutlineRegular`；万一取不到，会退化成一个仍能加入菜单键盘遍历的
+  `role="menuitem"` 按钮。
+- 中英文界面文案都已内置，跟随 DSH 的语言设置。
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# dsh-delete-conversation bundle patch layer: installable via `dsh plugin add`.
+# This declares the plugin's own loader entry, inserted into the profile tree.
+# `name` MUST equal the package name.
+- insert:
+    - id: dsh-delete-conversation
+      name: 'dsh-delete-conversation'

package/lib/client.js

@@ -0,0 +1,273 @@
+/**
+ * dsh-delete-conversation — browser half.
+ *
+ * Contributes one destructive row, "删除会话", to the Session "..." menu
+ * (the official `sidebar.workspaces.session.menu.item` list slot, after the
+ * shipped archive row) and one confirmation dialog in the frame-wide
+ * `shell.overlay` layer. The menu row only raises the request; the dialog
+ * performs it, so the destructive call never rides a menu that is closing.
+ */
+window.__ModuleLoader__.load({
+  id: 'dsh-delete-conversation',
+  factory: (require) => {
+    const React = require('react');
+
+    /** This package's locale namespace, slot-id prefix, and host route. */
+    const NS = 'dsh-delete-conversation';
+    const DELETE_PATH = '/dsh-delete-conversation/delete';
+
+    /**
+     * ui-primitives supplies the shipped menu row's chrome. A plugin resolved
+     * from disk may not see it, so the row degrades to a plain `menuitem`
+     * button that still joins the menu's keyboard walk.
+     */
+    let primitives = null;
+    try {
+      primitives = require('@deepseek-ai/dsh-client-ui-primitives');
+    } catch {
+      primitives = null;
+    }
+    const MenuItemButton = primitives !== null && typeof primitives.MenuItemButton === 'function' ? primitives.MenuItemButton : null;
+    const TrashIcon = primitives !== null && typeof primitives.IconTrashOutlineRegular === 'function' ? primitives.IconTrashOutlineRegular : null;
+
+    const DICT = {
+      zh: {
+        'menu.deleteSession': '删除会话',
+        'dialog.title': '删除会话',
+        'dialog.body': '将永久删除「{title}」及其全部消息记录，且无法撤销。',
+        'dialog.cancel': '取消',
+        'dialog.confirm': '永久删除',
+        'dialog.deleting': '正在删除…'
+      },
+      en: {
+        'menu.deleteSession': 'Delete session',
+        'dialog.title': 'Delete session',
+        'dialog.body': 'This permanently deletes "{title}" and its entire message history. It cannot be undone.',
+        'dialog.cancel': 'Cancel',
+        'dialog.confirm': 'Delete permanently',
+        'dialog.deleting': 'Deleting…'
+      }
+    };
+
+    /**
+     * Minimal observable: the overlay entry lives outside the menu row that
+     * raises the request, so both read one shared value.
+     * @param initial - starting value.
+     * @returns get/set/subscribe accessors.
+     */
+    function createSignal(initial) {
+      let value = initial;
+      const listeners = new Set();
+      return {
+        get: () => value,
+        set(next) {
+          value = next;
+          for (const listener of [...listeners]) listener();
+        },
+        subscribe(listener) {
+          listeners.add(listener);
+          return () => {
+            listeners.delete(listener);
+          };
+        }
+      };
+    }
+
+    /**
+     * Subscribe a component to one signal.
+     * @param signal - signal to read.
+     * @returns the current value, re-rendering its reader on change.
+     */
+    function useSignal(signal) {
+      const [value, setValue] = React.useState(signal.get);
+      React.useEffect(() => signal.subscribe(() => { setValue(signal.get()); }), [signal]);
+      return value;
+    }
+
+    /**
+     * Ask the host to delete one stored Session.
+     * @param sessionId - stored Session id.
+     * @returns the host result.
+     * @throws {Error} carrying the host's own message.
+     */
+    async function requestDeletion(sessionId) {
+      const response = await fetch(DELETE_PATH, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ sessionId })
+      });
+      let body = null;
+      try {
+        body = await response.json();
+      } catch {
+        body = null;
+      }
+      if (!response.ok || body === null || body.ok !== true) {
+        throw new Error(body !== null && typeof body.error === 'string' ? body.error : `HTTP ${response.status}`);
+      }
+      return body;
+    }
+
+    /**
+     * Rebuild the sidebar list after a deletion, releasing the selection when
+     * the deleted Session was the one on stage.
+     * @param ctx - client context.
+     * @param sessionId - the deleted Session id.
+     */
+    function refreshAfterDeletion(ctx, sessionId) {
+      const sessions = ctx.get('sessions');
+      if (sessions === undefined) return;
+      try {
+        if (String(sessions.list.getSnapshot().current) === sessionId) ctx.sessions.clearSelection();
+      } catch {}
+      Promise.resolve(sessions.refresh()).catch(() => {});
+    }
+
+    /**
+     * The Session "..." menu row (order 500, after the shipped archive row at 400).
+     * @param props - owner share, the shared request signal, and the translator.
+     * @returns the menu row.
+     */
+    function DeleteSessionMenuItem({ sessionId, displayTitle, useMenuOpenState, requestDelete, t }) {
+      const [, setMenuOpen] = useMenuOpenState();
+      const label = t('menu.deleteSession');
+      const select = () => {
+        setMenuOpen(false);
+        requestDelete({ sessionId, displayTitle });
+      };
+      if (MenuItemButton !== null) {
+        return React.createElement(MenuItemButton, {
+          icon: TrashIcon === null ? undefined : React.createElement(TrashIcon, {}),
+          onSelect: select,
+          children: label
+        });
+      }
+      return React.createElement('button', {
+        type: 'button',
+        role: 'menuitem',
+        onClick: select,
+        style: {
+          display: 'flex',
+          alignItems: 'center',
+          gap: 8,
+          width: '100%',
+          padding: '6px 10px',
+          border: 'none',
+          background: 'transparent',
+          color: 'inherit',
+          font: 'inherit',
+          textAlign: 'left',
+          cursor: 'pointer'
+        }
+      }, label);
+    }
+
+    /**
+     * Confirmation dialog; the destructive call runs here, not in the menu row.
+     * @param props - the client context, the shared request signal, and the translator.
+     * @returns the dialog, or null while no request is open.
+     */
+    function DeleteSessionDialog({ ctx, signal, t }) {
+      const request = useSignal(signal);
+      const [pending, setPending] = React.useState(false);
+      const [error, setError] = React.useState('');
+      const openId = request === null ? null : request.sessionId;
+      React.useEffect(() => {
+        setPending(false);
+        setError('');
+      }, [openId]);
+      if (request === null) return null;
+      const confirm = () => {
+        setPending(true);
+        setError('');
+        requestDeletion(request.sessionId).then(() => {
+          signal.set(null);
+          refreshAfterDeletion(ctx, request.sessionId);
+        }).catch((failure) => {
+          setPending(false);
+          setError(failure instanceof Error ? failure.message : String(failure));
+        });
+      };
+      const cancel = () => {
+        if (pending) return;
+        signal.set(null);
+      };
+      const buttonStyle = {
+        padding: '6px 14px',
+        borderRadius: 6,
+        border: '1px solid var(--dsw-alias-border-divider, rgba(0, 0, 0, 0.12))',
+        background: 'transparent',
+        color: 'var(--dsw-alias-label-primary, #1a1a1a)',
+        font: 'inherit',
+        cursor: pending ? 'default' : 'pointer'
+      };
+      return React.createElement('div', {
+        style: {
+          position: 'fixed',
+          inset: 0,
+          display: 'flex',
+          alignItems: 'center',
+          justifyContent: 'center',
+          background: 'rgba(0, 0, 0, 0.35)',
+          pointerEvents: 'auto',
+          zIndex: 40
+        },
+        onClick: cancel
+      }, React.createElement('div', {
+        role: 'dialog',
+        'aria-modal': 'true',
+        'aria-label': t('dialog.title'),
+        onClick: (event) => { event.stopPropagation(); },
+        style: {
+          width: 'min(420px, calc(100vw - 48px))',
+          padding: '18px 20px 16px',
+          borderRadius: 12,
+          background: 'var(--dsw-alias-bg-elevated, #ffffff)',
+          boxShadow: '0 12px 32px rgba(0, 0, 0, 0.24)'
+        }
+      },
+      React.createElement('div', { style: { color: 'var(--dsw-alias-label-primary, #1a1a1a)', fontSize: 15, lineHeight: '22px', fontWeight: 500 } }, t('dialog.title')),
+      React.createElement('div', { style: { marginTop: 8, color: 'var(--dsw-alias-label-secondary, #666666)', fontSize: 13, lineHeight: '20px', wordBreak: 'break-word' } }, t('dialog.body', { title: request.displayTitle })),
+      error === '' ? null : React.createElement('div', { style: { marginTop: 10, color: 'var(--dsw-alias-label-danger, #d93025)', fontSize: 13, lineHeight: '20px' } }, error),
+      React.createElement('div', { style: { marginTop: 16, display: 'flex', justifyContent: 'flex-end', gap: 8 } },
+        React.createElement('button', { type: 'button', onClick: cancel, disabled: pending, style: buttonStyle }, t('dialog.cancel')),
+        React.createElement('button', {
+          type: 'button',
+          onClick: confirm,
+          disabled: pending,
+          style: { ...buttonStyle, borderColor: 'transparent', background: 'var(--dsw-alias-label-danger, #d93025)', color: '#ffffff', opacity: pending ? 0.6 : 1 }
+        }, pending ? t('dialog.deleting') : t('dialog.confirm'))
+      )));
+    }
+
+    const exports = {};
+    exports.inject = ['slots', 'locale'];
+    exports.apply = function apply(ctx) {
+      ctx.effect(() => ctx.locale.register(NS, DICT), 'dsh-delete-conversation: dictionaries');
+      const t = ctx.locale.bind(NS);
+      const deleteRequest = createSignal(null);
+
+      ctx.slots.inject('sidebar.workspaces.session.menu.item', () => ctx.slots.register({
+        name: 'sidebar.workspaces.session.menu.item',
+        id: NS,
+        order: 500,
+        locale: NS,
+        inject: () => ({
+          requestDelete: (request) => { deleteRequest.set(request); }
+        })
+      }, function DeleteSessionMenuRow(props) {
+        return React.createElement(DeleteSessionMenuItem, { ...props, t });
+      }));
+
+      ctx.slots.inject('shell.overlay', () => ctx.slots.register({
+        name: 'shell.overlay',
+        id: `${NS}.confirm`,
+        locale: NS,
+        inject: () => ({})
+      }, function DeleteSessionConfirm() {
+        return React.createElement(DeleteSessionDialog, { ctx, signal: deleteRequest, t });
+      }));
+    };
+    return exports;
+  }
+});

package/lib/index.js

@@ -0,0 +1,257 @@
+/**
+ * dsh-delete-conversation — host half.
+ *
+ * Permanently deletes one stored Session:
+ *   1. its log directory under `$DSH_HOME/sessions/<project>/<sessionId>`,
+ *   2. its archive / workspace membership in `workspace.json` — through the
+ *      live `WorkspaceRegistry`, so the in-memory projection and the durable
+ *      table stay consistent (never by rewriting the file behind its back),
+ *   3. its entry in the Session projection cache.
+ *
+ * A Session whose Agent is live is refused: the running Session owns its log
+ * and the UI still points at it; archive it or end it first.
+ *
+ * @module dsh-delete-conversation
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+/** Route the browser half calls. */
+const DELETE_PATH = '/dsh-delete-conversation/delete';
+/** Stored Session identity, exactly as the persistence layer spells it. */
+const SESSION_ID_PATTERN = /^session-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
+const DSH_HOME = process.env.DSH_HOME || join(homedir(), '.dsh');
+const SESSIONS_DIR = join(DSH_HOME, 'sessions');
+const PROJCACHE_DIR = join(DSH_HOME, 'storages', 'session_projcache', 'sessions');
+const WORKSPACE_FILE = join(DSH_HOME, 'storages', 'workspace.json');
+const LOG_PATH = join(DSH_HOME, 'dsh-delete-conversation.log');
+
+/**
+ * Append one line to the plugin log; logging never breaks the deletion.
+ * @param message - short event name.
+ * @param data - optional structured detail.
+ */
+function log(message, data) {
+  try {
+    mkdirSync(dirname(LOG_PATH), { recursive: true });
+    appendFileSync(LOG_PATH, `[${new Date().toISOString()}] ${message}${data === undefined ? '' : ` ${JSON.stringify(data)}`}\n`, 'utf8');
+  } catch {}
+}
+
+/**
+ * Whether the request came from this machine's own browser tab: loopback peer,
+ * no forwarding headers, and an Origin matching the Host it was served from.
+ * @param request - incoming node request.
+ * @returns true when the request may mutate stored Sessions.
+ */
+function trustedRequest(request) {
+  const address = request.socket.remoteAddress;
+  if (address !== '127.0.0.1' && address !== '::1' && address !== '::ffff:127.0.0.1') return false;
+  if (request.headers.forwarded !== undefined || request.headers['x-forwarded-for'] !== undefined || request.headers['x-real-ip'] !== undefined) return false;
+  const host = request.headers.host;
+  const origin = request.headers.origin;
+  if (typeof host !== 'string' || typeof origin !== 'string') return false;
+  try {
+    const parsed = new URL(origin);
+    return (parsed.protocol === 'http:' || parsed.protocol === 'https:') && parsed.host === host;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Send one JSON response.
+ * @param response - node response.
+ * @param status - HTTP status.
+ * @param value - JSON-serializable body.
+ */
+function writeJson(response, status, value) {
+  response.writeHead(status, { 'cache-control': 'no-store', 'content-type': 'application/json; charset=utf-8' });
+  response.end(JSON.stringify(value));
+}
+
+/**
+ * Read one JSON request body with a size bound; a Session id is all that crosses.
+ * @param request - incoming node request.
+ * @returns the parsed body.
+ */
+async function readJsonBody(request) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    size += chunk.length;
+    if (size > 8192) throw new Error('request body too large');
+    chunks.push(chunk);
+  }
+  if (chunks.length === 0) return {};
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+
+/**
+ * Every stored directory holding this Session's log. The directory name is the
+ * stored id verbatim, so no project-key re-encoding is needed here.
+ * @param sessionId - stored Session id.
+ * @returns absolute log-directory paths, possibly empty.
+ */
+function sessionDirectories(sessionId) {
+  const found = [];
+  let entries;
+  try {
+    entries = readdirSync(SESSIONS_DIR, { withFileTypes: true });
+  } catch {
+    return found;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const candidate = join(SESSIONS_DIR, entry.name, sessionId);
+    if (existsSync(candidate)) found.push(candidate);
+  }
+  return found;
+}
+
+/**
+ * Workspace ids whose durable candidate account still names this Session.
+ * Read from the domain file because the registry's own projection filters out
+ * sessions whose header is already gone — exactly the residue worth clearing.
+ * @param sessionId - stored Session id.
+ * @returns workspace ids to detach from.
+ */
+function workspaceIdsOwning(sessionId) {
+  let state;
+  try {
+    state = JSON.parse(readFileSync(WORKSPACE_FILE, 'utf8'));
+  } catch {
+    return [];
+  }
+  const tables = state?.tables?.workspaces;
+  if (tables === null || typeof tables !== 'object') return [];
+  return Object.entries(tables)
+    .filter(([, record]) => Array.isArray(record?.sessionIds) && record.sessionIds.includes(sessionId))
+    .map(([id]) => id);
+}
+
+/**
+ * Drop the Session from the workspace domain through the live registry, so the
+ * durable table, the display order and the in-memory entity all move together.
+ * @param ctx - host context.
+ * @param sessionId - stored Session id.
+ * @returns per-store outcome report.
+ */
+async function detachFromWorkspaces(ctx, sessionId) {
+  const report = { detached: [], unarchived: false, errors: [] };
+  const registry = ctx.get('workspaceRegistry');
+  if (registry === undefined) {
+    report.errors.push('workspaceRegistry unavailable');
+    return report;
+  }
+  for (const workspaceId of workspaceIdsOwning(sessionId)) {
+    try {
+      const workspace = registry.get(workspaceId);
+      if (workspace === undefined) continue;
+      await workspace.detachSession(sessionId);
+      report.detached.push(workspaceId);
+    } catch (error) {
+      report.errors.push(`detach ${workspaceId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  try {
+    await registry.unarchiveSession(sessionId);
+    report.unarchived = true;
+  } catch (error) {
+    report.errors.push(`unarchive: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return report;
+}
+
+/**
+ * Whether an Agent currently owns this Session in this process.
+ * @param ctx - host context.
+ * @param sessionId - stored Session id.
+ * @returns true when the Session is live and must not be deleted.
+ */
+function sessionIsLive(ctx, sessionId) {
+  const agents = ctx.get('agents');
+  if (agents === undefined) return false;
+  try {
+    return agents.get(sessionId) !== undefined;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Permanently delete one stored Session.
+ * @param ctx - host context.
+ * @param sessionId - stored Session id.
+ * @returns a result describing what was removed.
+ * @throws {Error} when the id is malformed, the Session is live, or the log cannot be removed.
+ */
+async function deleteSession(ctx, sessionId) {
+  if (!SESSION_ID_PATTERN.test(sessionId)) throw new Error('invalid session id');
+  if (sessionIsLive(ctx, sessionId)) {
+    const error = new Error('该会话正在运行，无法删除；请先归档或结束它。');
+    error.code = 'session-active';
+    throw error;
+  }
+  const directories = sessionDirectories(sessionId);
+  const cacheFile = join(PROJCACHE_DIR, `${sessionId}.json`);
+  const hadCache = existsSync(cacheFile);
+  if (directories.length === 0 && !hadCache) {
+    const residue = await detachFromWorkspaces(ctx, sessionId);
+    return { sessionId, directories: [], cacheRemoved: false, workspace: residue, existed: false };
+  }
+  // Physical removal first: when the log cannot go, the registry must not move either.
+  for (const directory of directories) {
+    rmSync(directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  }
+  let cacheRemoved = false;
+  if (hadCache) {
+    try {
+      unlinkSync(cacheFile);
+      cacheRemoved = true;
+    } catch (error) {
+      log('projection cache removal failed', { sessionId, message: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  const workspace = await detachFromWorkspaces(ctx, sessionId);
+  log('session deleted', { sessionId, directories, cacheRemoved, workspace });
+  return { sessionId, directories, cacheRemoved, workspace, existed: true };
+}
+
+export const name = 'dsh-delete-conversation';
+export const inject = ['webServer'];
+
+/**
+ * Host plugin body: expose one guarded route that permanently deletes a stored Session.
+ * @param ctx - host root context.
+ */
+export function apply(ctx) {
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: DELETE_PATH,
+    handler(request, response) {
+      if (request.method !== 'POST') {
+        writeJson(response, 405, { ok: false, error: 'method not allowed' });
+        return;
+      }
+      if (!trustedRequest(request)) {
+        writeJson(response, 403, { ok: false, error: 'deletion is limited to same-origin loopback requests' });
+        return;
+      }
+      void (async () => {
+        try {
+          const body = await readJsonBody(request);
+          const sessionId = typeof body.sessionId === 'string' ? body.sessionId : '';
+          const result = await deleteSession(ctx, sessionId);
+          writeJson(response, 200, { ok: true, ...result });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          const status = error?.code === 'session-active' ? 409 : 400;
+          log('deletion failed', { message });
+          writeJson(response, status, { ok: false, error: message });
+        }
+      })();
+    }
+  }), 'dsh-delete-conversation: delete route');
+}

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "dsh-delete-conversation",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "DSH 插件：在侧边栏会话的「…」菜单里加一项「删除会话」，彻底删除该会话的日志、工作区归属与投影缓存。Adds a \"Delete session\" action to the DeepSeek Harness sidebar session menu that permanently removes the stored session.",
+  "type": "module",
+  "main": "./lib/index.js",
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": []
+    }
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "dsh-bundle",
+    "deepseek-harness",
+    "session",
+    "conversation",
+    "delete",
+    "sidebar",
+    "menu"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    }
+  }
+}