dsh-ws-recency 0.8.0 → 0.9.0

package/README.md

@@ -1,6 +1,6 @@
 # dsh-ws-recency
 
-DSH 侧栏的四件事：**工作区分组按最近活跃排序**、**过期历史自动折叠**、**运行中/未读/需跟进三色标记**、**所有置顶会话汇总到顶部一个区**。单独装上就有效，不依赖其它插件。
+DSH 侧栏的五件事：**工作区分组按最近活跃排序**、**过期历史自动折叠**、**运行中/未读/需跟进三色标记**、**所有置顶会话汇总到顶部一个区**、**删除会话到可恢复的回收站**。单独装上就有效，不依赖其它插件。
 
 ## 一、分组排序
 
@@ -47,6 +47,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 +97,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.0/dsh-ws-recency-0.9.0.tgz
 ```
 
 装完把 `dsh-ws-recency` 加进 `~/.hypers-work/profiles/<profile>/package.json` 的 `dsh.profile.bundles`，重启应用。

package/client.js

@@ -135,6 +135,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 +155,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" };
@@ -810,6 +816,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; });
@@ -1044,6 +1086,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.0",
+  "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": {