dsh-ws-recency 0.8.0 → 0.9.1

package/README.md

@@ -1,6 +1,6 @@
 # dsh-ws-recency
 
-DSH 侧栏的四件事：**工作区分组按最近活跃排序**、**过期历史自动折叠**、**运行中/未读/需跟进三色标记**、**所有置顶会话汇总到顶部一个区**。单独装上就有效，不依赖其它插件。
+DSH 侧栏的五件事：**工作区分组按最近活跃排序**、**过期历史自动折叠**、**运行中/未读/需跟进三色标记**、**所有置顶会话汇总到顶部一个区**、**删除会话到可恢复的回收站**。单独装上就有效，不依赖其它插件。
 
 ## 一、分组排序
 
@@ -12,8 +12,7 @@ DSH 已经把**组内**会话按 `updatedAt` 倒序排好了（排序方式 =
 
 会话超过 `foldDays`（默认 **3 天**）没有更新就折叠起来；整个工作区都过期时，它只剩一行工作区标题——需要翻历史时点开就行。
 
-- **每组只有一个控件**：宿主自己还有没渲染的行时，用它的「展开其余 N 条会话」（N 已含被折叠的行）；宿主把该组渲染完了时，才出现插件的 `展开历史 N` / `收起历史`；
-- 点宿主的「展开其余」会同时放出被折叠的行；它变成「收起」时，折叠也一并复原；
+- **两个控件各管一件事**：宿主的「展开其余 N 条会话」负责让**宿主渲染**更多行（数字由宿主自己报，插件不再改写它）；插件的 `展开历史 N` / `收起历史` 只负责把**已渲染但过期**的行折叠起来，点两次就是展开、收起一对；
 - 选中 / 运行中 / 等待处理的会话**永不折叠**（可在设置里关掉这个豁免）；
 - 空白草稿行（新会话）不参与折叠判断；
 - 每 5 分钟自动重算一次，所以跨过 3 天边界的会话会自己折叠，不用刷新。
@@ -47,6 +46,21 @@ DSH 原生的置顶只把会话顶到**它所属工作区分组的第一行**，
 - 工作区分组、组内顺序、折叠、颜色全部照旧；
 - 只在按工作区分组时出现；搜索、扁平视图、侧栏收起时自动隐藏。
 
+## 五、归档与删除
+
+**归档**用宿主原生的：「…」菜单 →「归档会话」；看归档的内容用侧栏「视图选项」→ 显示已归档 / 仅显示已归档。本插件不改这套。
+
+**删除**是宿主没有的，本插件补上（「…」菜单 →「删除会话（移入回收站）」）：
+
+1. 先停掉它正在跑的工作；
+2. 摘掉归档标记与置顶；
+3. 从每个工作区的 `sessionIds` 记账里 detach；
+4. 删掉投影缓存记录；
+5. 把日志目录移动到 `~/.hypers-work/.trash/ws-recency/<sessionId>-<时间戳>/`；
+6. 广播 `api-session/removed`，浏览器立即移除该行。
+
+**不是物理删除**：目录只是被改名搬走，恢复就是把 `.trash/ws-recency/<id>-<时间>/` 移回 `sessions/<project>/<id>/`。这条删除走的是宿主侧路由（`POST /ws-recency/session-trash`，仅接受回环来源），因为浏览器侧碰不到文件系统。
+
 ## 设置
 
 **设置 → 通用**：
@@ -82,7 +96,7 @@ dsh plugin --profile <profile> add github:chyxhtc/dsh-ws-recency
 或固定版本的预构建包：
 
 ```powershell
-dsh plugin --profile <profile> add https://github.com/chyxhtc/dsh-ws-recency/releases/download/v0.8.0/dsh-ws-recency-0.8.0.tgz
+dsh plugin --profile <profile> add https://github.com/chyxhtc/dsh-ws-recency/releases/download/v0.9.1/dsh-ws-recency-0.9.1.tgz
 ```
 
 装完把 `dsh-ws-recency` 加进 `~/.hypers-work/profiles/<profile>/package.json` 的 `dsh.profile.bundles`，重启应用。

package/client.js

@@ -78,13 +78,11 @@
         var written = new Set();
         var roots = new Set();
         var hidden = new Set();
-        var labelled = new Set();
         var toggles = new Set();
         var dots = new Set();
         var pinHidden = new Set();
         var pinHost = null;
         var expandedSections = new Set();
-        var clickMarked = new WeakSet();
         var headerMarked = new WeakSet();
         var disposed = false;
 
@@ -135,6 +133,9 @@
           "pin.unpin": "\u53d6\u6d88\u7f6e\u9876",
           "menu.flag": "\u6807\u8bb0\u9700\u8981\u8ddf\u8fdb",
           "menu.unflag": "\u53d6\u6d88\u8ddf\u8fdb\u6807\u8bb0",
+          "menu.trash": "\u5220\u9664\u4f1a\u8bdd\uff08\u79fb\u5165\u56de\u6536\u7ad9\uff09",
+          "trash.confirm": "\u5220\u9664\u8fd9\u4e2a\u4f1a\u8bdd\uff1f\n\n\u4f1a\u5148\u505c\u6b62\u5b83\u6b63\u5728\u8fdb\u884c\u7684\u5de5\u4f5c\uff0c\u518d\u628a\u65e5\u5fd7\u76ee\u5f55\u79fb\u5165\u56de\u6536\u7ad9\uff08\u4e0d\u662f\u7269\u7406\u5220\u9664\uff0c\u53ef\u4ee5\u624b\u52a8\u6062\u590d\uff09\u3002",
+          "trash.failed": "\u5220\u9664\u5931\u8d25\uff1a",
         };
         var EN = {
           "settings.title": "Fold history after (days)",
@@ -152,6 +153,9 @@
           "pin.unpin": "Unpin",
           "menu.flag": "Mark as needs follow-up",
           "menu.unflag": "Clear follow-up mark",
+          "menu.trash": "Delete session (move to trash)",
+          "trash.confirm": "Delete this session?\n\nIt stops whatever the session is running, then moves the log directory into the trash folder (a move, not an erase: you can restore it by hand).",
+          "trash.failed": "Delete failed: ",
         };
 
         var FALLBACK = { "fold.show": "Show history ({n})", "fold.hide": "Hide history" };
@@ -319,11 +323,6 @@
           return out;
         }
 
-        function overflowButtonOf(section) {
-          if (typeof section.querySelector !== "function") return null;
-          return section.querySelector('button[class*="' + OVERFLOW_TOKEN + '"]');
-        }
-
         function isActiveRow(row) {
           if (typeof row.querySelector !== "function") return false;
           return row.querySelector('[data-state="ongoing"], [data-state="warning"]') !== null;
@@ -365,55 +364,7 @@
           return session !== undefined && session !== null && session.blank === true;
         }
 
-        /**
-         * Rewrite the host button's count so it reports what is really hidden: the
-         * host counts only the rows it did not render, and the fold hides a few more.
-         */
-        function rewriteLabel(button, extraHidden) {
-          if (button === null || button === undefined) return;
-          if (typeof button.textContent !== "string" || button.dataset === undefined) return;
-          var base = button.dataset.wsrBase;
-          if (typeof base !== "string") {
-            base = button.textContent;
-            button.dataset.wsrBase = base;
-            labelled.add(button);
-          }
-          var match = /\d+/.exec(base);
-          if (match === null) return;
-          var hostCount = Number(match[0]);
-          if (!Number.isFinite(hostCount)) return;
-          var total = hostCount + extraHidden;
-          var text = total <= 0 ? base : base.slice(0, match.index) + String(total) + base.slice(match.index + match[0].length);
-          if (button.textContent !== text) button.textContent = text;
-        }
-
-        function releaseLabel(button) {
-          if (button === null || button === undefined || button.dataset === undefined) return;
-          var base = button.dataset.wsrBase;
-          if (typeof base === "string") {
-            if (button.textContent !== base) button.textContent = base;
-            delete button.dataset.wsrBase;
-          }
-          labelled.delete(button);
-        }
-
-        function markButton(button, key) {
-          if (typeof button.addEventListener !== "function" || clickMarked.has(button)) return;
-          clickMarked.add(button);
-          button.addEventListener("click", function () {
-            if (disposed) return;
-            /* The host's own control is the only one while it exists, so it has to
-               carry the fold too: `aria-expanded` still reads the pre-click state
-               (React delegates at the root, this listener runs first), which is
-               exactly what decides whether the click reveals or hides. */
-            var expanded = typeof button.getAttribute === "function"
-              && button.getAttribute("aria-expanded") === "true";
-            if (expanded) expandedSections.delete(key);
-            else expandedSections.add(key);
-            schedule();
-          });
-        }
-
+        /** Collapsing a group resets its fold state, so the click is observed. */
         function markHeader(header, key) {
           if (typeof header.addEventListener !== "function" || headerMarked.has(header)) return;
           headerMarked.add(header);
@@ -435,11 +386,15 @@
             button.addEventListener("click", function (event) {
               if (disposed) return;
               if (event !== undefined && typeof event.stopPropagation === "function") event.stopPropagation();
-              onClick();
+              var current = button.wsrOnClick;
+              if (typeof current === "function") current();
             });
             section.appendChild(button);
             toggles.add(button);
           }
+          /* The handler is refreshed every pass: the button toggles between "show"
+             and "hide", and a captured first callback would only ever show. */
+          button.wsrOnClick = onClick;
           if (button.textContent !== label) button.textContent = label;
           return button;
         }
@@ -463,10 +418,7 @@
             var entry = entries[i];
             var section = entry.section;
             var rows = rowElements(section);
-            var hostButton = overflowButtonOf(section);
             markHeader(entry.header, entry.key);
-            if (hostButton !== null) markButton(hostButton, entry.key);
-            releaseLabel(hostButton);
 
             var expanded = expandedSections.has(entry.key);
             var folded = 0;
@@ -487,14 +439,13 @@
               }
             }
 
-            /* ONE control per group: while the host offers its own "show more"
-               button, that button is the control (its count already carries the
-               folded rows below). Only a group the host finished rendering gets
-               this plugin's own toggle. */
-            if (hostButton !== null) {
-              dropToggle(section);
-              rewriteLabel(hostButton, expanded ? 0 : folded);
-            } else if (expanded) {
+            /* The host's own "show more" button and this fold are two different
+               things: the host decides which rows it RENDERS, this plugin decides
+               which rendered rows stay VISIBLE. Touching the host's label or its
+               click made the two fight (a count nobody could trust, and a collapse
+               that never came back), so they stay separate: the group gets its own
+               "show history" control whenever something is folded. */
+            if (expanded) {
               (function (entryKey) {
                 ensureToggle(section, entryKey, t("fold.hide"), function () {
                   expandedSections.delete(entryKey);
@@ -810,6 +761,42 @@
           });
         }
 
+        /**
+         * Session "..." menu row: move the session into the trash folder.
+         *
+         * DSH itself only archives; the host half of this plugin stops the work,
+         * detaches the bookkeeping and renames the log directory into
+         * `<home>/.trash/ws-recency/`. The browser half only asks for confirmation
+         * and posts the id.
+         */
+        function TrashMenuItem(props) {
+          var Item = ui.MenuItemButton;
+          if (typeof Item !== "function") return null;
+          var Icon = ui.IconTrashOutlineRegular;
+          return h(Item, {
+            icon: typeof Icon === "function" ? h(Icon, {}) : undefined,
+            onSelect: function () {
+              var question = t("trash.confirm");
+              var confirmed = typeof window.confirm === "function" ? window.confirm(question) : false;
+              if (!confirmed) return;
+              fetch("/ws-recency/session-trash", {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ sessionId: props.sessionId }),
+              })
+                .then(function (response) { return response.json(); })
+                .then(function (result) {
+                  if (result !== null && result.ok !== true && typeof window.alert === "function") {
+                    window.alert(t("trash.failed") + (result.error || "unknown"));
+                  }
+                })
+                .catch(function (error) {
+                  if (typeof window.alert === "function") window.alert(t("trash.failed") + (error && error.message ? error.message : error));
+                });
+            },
+          }, props.t("menu.trash"));
+        }
+
         /** Settings -> General row: how old a session must be before it is folded. */
         function SettingsRow(props) {
           var settings = props.useStore(function (state) { return state; });
@@ -916,8 +903,6 @@
             if (element.removeAttribute !== undefined) element.removeAttribute(HIDDEN_ATTR);
           });
           hidden.clear();
-          labelled.forEach(function (button) { releaseLabel(button); });
-          labelled.clear();
           toggles.forEach(function (button) { button.remove(); });
           toggles.clear();
           dots.forEach(function (dot) { dot.remove(); });
@@ -1044,6 +1029,16 @@
             }, FollowUpDot);
           });
 
+          ctx.slots.inject("sidebar.workspaces.session.menu.item", function () {
+            return ctx.slots.register({
+              name: "sidebar.workspaces.session.menu.item",
+              id: "ws-recency-trash",
+              order: 700,
+              store: prefs,
+              locale: NS,
+            }, TrashMenuItem);
+          });
+
           ctx.effect(function () {
             return function () { shutdown(); };
           }, "dsh-ws-recency: list observer");

package/index.js

@@ -1,14 +1,226 @@
 /**
- * Host half of dsh-ws-recency.
+ * Host half of dsh-ws-recency: the one part that needs the file system.
  *
- * The whole feature is client-side: it reads Session and Workspace state through
- * the Client's root-standard hooks and writes a flex `order` onto the sidebar's
- * workspace groups. This row only carries the package into the plugin graph so
- * the Client registry can serve ./client.js beside it.
+ * Deleting a conversation is the only sidebar operation the Client cannot do on
+ * its own: DSH only offers "archive" (a flag in `archivedSessionIds`), while the
+ * log directory and the projection cache stay on disk forever. This module moves
+ * a session into a trash folder instead of erasing it:
+ *
+ *   1. stop whatever the session is running (`workspace/session-stop`)
+ *   2. drop the archive flag and the pin
+ *   3. detach it from every workspace that lists it
+ *   4. delete its projection-cache row
+ *   5. move `<home>/sessions/<project>/<sessionId>` to
+ *      `<home>/.trash/ws-recency/<sessionId>-<timestamp>`
+ *   6. broadcast `api-session/removed` so the browser drops the row
+ *
+ * Nothing is erased irreversibly: the log directory is renamed, so restoring is
+ * a move back. The route only answers loopback origins and only accepts POST.
+ *
+ * @module dsh-ws-recency
  */
+import { mkdir, readdir, rename } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+/** Cordis plugin name shown by the loader. */
+export const name = "ws-recency";
+
+/** Host services this module asks for; `webServer` is injected separately. */
+export const inject = ["sessionPersistence", "workspaceRegistry", "sessions"];
+
+/** Exact route the client half calls. */
+export const TRASH_SESSION_PATH = "/ws-recency/session-trash";
+
+const STOP_SETTLE_MS = 500;
+const MAX_BODY_BYTES = 16 * 1024;
+const RENAME_RETRY = 4;
+const RENAME_GAP_MS = 150;
+
+function loopbackOrigin(req) {
+  const origin = req.headers.origin;
+  if (origin === undefined) return true;
+  try {
+    const { hostname } = new URL(origin);
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+
+async function readJsonBody(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > MAX_BODY_BYTES) throw new Error("request body too large");
+    chunks.push(chunk);
+  }
+  if (chunks.length === 0) return {};
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+
+function sendJson(res, status, value) {
+  const body = JSON.stringify(value);
+  res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+  res.end(body);
+}
+
+async function dshHome() {
+  try {
+    const module = await import("@deepseek-ai/dsh-home-paths");
+    if (typeof module.resolveDshHome === "function") return module.resolveDshHome();
+  } catch {
+    /* fall through to the environment */
+  }
+  const fromEnv = process.env.DSH_HOME;
+  if (typeof fromEnv === "string" && fromEnv !== "") return fromEnv;
+  return join(process.env.USERPROFILE ?? process.env.HOME ?? ".", ".dsh");
+}
+
+/** Absolute path of a session's log file, or undefined when it cannot be located. */
+function locateLog(ctx, meta) {
+  const persistence = ctx.sessionPersistence;
+  if (persistence !== undefined && typeof persistence.locate === "function") {
+    try {
+      const located = persistence.locate(meta);
+      if (located !== undefined && located !== null && typeof located.path === "string" && located.path !== "") return located.path;
+    } catch {
+      /* fall back to the scan below */
+    }
+  }
+  return undefined;
+}
+
+/** Rename with a short retry: Windows can hold a handle for a moment. */
+async function moveWithRetry(source, target) {
+  for (let attempt = 0; attempt < RENAME_RETRY; attempt += 1) {
+    try {
+      await rename(source, target);
+      return true;
+    } catch (error) {
+      if (attempt === RENAME_RETRY - 1) throw error;
+      await new Promise((resolve) => setTimeout(resolve, RENAME_GAP_MS));
+    }
+  }
+  return false;
+}
+
+/** Move the session log directory into the trash; returns the new path. */
+async function trashSessionLog(ctx, meta, trashRoot) {
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const target = join(trashRoot, `${meta.id}-${stamp}`);
+  await mkdir(trashRoot, { recursive: true });
+
+  const located = locateLog(ctx, meta);
+  if (located !== undefined) {
+    if (await moveWithRetry(dirname(located), target)) return target;
+  }
+
+  /* No `locate()` (older host): scan `<home>/sessions/<project>/<sessionId>`. */
+  const home = await dshHome();
+  const root = join(home, "sessions");
+  let projects;
+  try {
+    projects = await readdir(root, { withFileTypes: true });
+  } catch {
+    return undefined;
+  }
+  for (const project of projects) {
+    if (!project.isDirectory()) continue;
+    try {
+      if (await moveWithRetry(join(root, project.name, meta.id), target)) return target;
+    } catch {
+      /* not in this project directory */
+    }
+  }
+  return undefined;
+}
+
+/** Stop the session, drop its bookkeeping, trash its logs, tell the browser. */
+export async function trashSession(ctx, sessionId) {
+  const live = typeof ctx.sessions?.get === "function" ? ctx.sessions.get(sessionId) : undefined;
+  let meta;
+  if (live !== undefined) {
+    meta = live.header;
+  } else {
+    const stat = await ctx.sessionPersistence.stat(sessionId);
+    if (stat === undefined) return { ok: false, error: "session not found" };
+    meta = stat.header;
+  }
+
+  try {
+    await ctx.parallel("workspace/session-stop", { sessionId });
+  } catch {
+    /* stopping is best effort, exactly like "stop and archive" */
+  }
+  await new Promise((resolve) => setTimeout(resolve, STOP_SETTLE_MS));
+
+  try { await ctx.workspaceRegistry.unarchiveSession(sessionId); } catch { /* not archived */ }
+  try { await ctx.workspaceRegistry.unpinSession(sessionId); } catch { /* not pinned */ }
+
+  for (const workspace of ctx.workspaceRegistry.list()) {
+    if (!Array.isArray(workspace.sessionIds) || !workspace.sessionIds.includes(sessionId)) continue;
+    try { await workspace.detachSession(sessionId); } catch { /* keep going */ }
+  }
+
+  try {
+    const domain = ctx.get("storageDomain");
+    const projcache = typeof domain?.get === "function" ? domain.get("session_projcache") : undefined;
+    if (projcache !== undefined) await projcache.table("sessions").delete(sessionId);
+  } catch {
+    /* the cache is derived data: a miss only costs a cold read */
+  }
+
+  const home = await dshHome();
+  const trashRoot = join(home, ".trash", "ws-recency");
+  let moved;
+  try {
+    moved = await trashSessionLog(ctx, meta, trashRoot);
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+
+  ctx.emit("api-session/removed", sessionId);
+  return { ok: true, trash: moved };
+}
 
-/** Plugin name shown by the loader. */
-export const name = 'ws-recency'
+/** POST { sessionId } -> move that session into the trash folder. */
+export async function handleTrashRequest(ctx, req, res) {
+  if ((req.method ?? "POST").toUpperCase() !== "POST") {
+    sendJson(res, 405, { ok: false, error: "method not allowed" });
+    return;
+  }
+  if (!loopbackOrigin(req)) {
+    sendJson(res, 403, { ok: false, error: "origin not trusted" });
+    return;
+  }
+  try {
+    const body = await readJsonBody(req);
+    const sessionId = body !== null && typeof body.sessionId === "string" ? body.sessionId.trim() : "";
+    if (sessionId === "") {
+      sendJson(res, 400, { ok: false, error: "sessionId required" });
+      return;
+    }
+    const result = await trashSession(ctx, sessionId);
+    sendJson(res, result.ok ? 200 : 500, result);
+  } catch (error) {
+    sendJson(res, 500, { ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+}
 
-/** Host-plane entry point; this plugin owns no Host behavior. */
-export function apply() {}
+/** Cordis entry point: mount the route when the host has a web server. */
+export function apply(ctx) {
+  try {
+    if (typeof ctx.inject === "function") {
+      ctx.inject(["webServer"], (webCtx) => {
+        webCtx.effect(() => webCtx.webServer.register({
+          kind: "exact",
+          path: TRASH_SESSION_PATH,
+          handler: (req, res) => handleTrashRequest(ctx, req, res),
+        }), "ws-recency: trash route");
+      });
+    }
+  } catch {
+    /* a headless profile simply gets no route */
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-ws-recency",
-  "version": "0.8.0",
-  "description": "Sidebar session management for DeepSeek Harness: workspace groups sorted by latest activity, stale history folded, a global pinned section, and manual follow-up marks.",
+  "version": "0.9.1",
+  "description": "Sidebar session management for DeepSeek Harness: workspace groups sorted by latest activity, stale history folded, a global pinned section, follow-up marks, and session delete into a recoverable trash.",
   "license": "MIT",
   "author": "chyxhtc",
   "repository": {