dsh-session-groups 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## 0.2.1 — 2026-11-12
+
+### Added
+
+- 工作区右键 **新建会话**：在当前工作区创建并打开新会话。
+- 分组右键 **在此分组新建会话**：新会话创建后直接归入该分组，并自动展开分组和上级。
+
+### Fixed
+
+- 桌面端分组数据未落盘：宿主侧改为通过 `webServer` 注册已认证的 `/session-tree` 路由（`load` / `save`），使用 Connection 的 `requestRejection` 校验浏览器凭证；保留结构校验、原子写入和 `.bak` 备份。
+- 宿主路由失败时客户端继续使用 `localStorage` 缓存，不阻塞侧边栏。
+
+## 0.2.0 — 2026-11-11
+
+- 首个公开版本：工作区内的可嵌套会话分组树、分组/会话排序、移动、导入导出和本地落盘。

package/README.md

@@ -26,6 +26,8 @@ DSH 原生的层级是：
 
 - 每个工作区独立维护自己的分组树
 - 新建根分组、新建子分组
+- 工作区右键 **新建会话**：在该工作区直接创建并打开新会话
+- 分组右键 **在此分组新建会话**：新会话创建后直接归入该分组，无需再移动
 - 行内重命名（Enter 提交，Esc 取消）
 - 折叠 / 展开分组，分组标题显示会话数量
 - 通过右键菜单“移动会话”归类会话，也可直接拖拽会话到分组标题
@@ -37,26 +39,29 @@ DSH 原生的层级是：
 - 分组和归类关系自动落盘到 DSH 主目录（原子写入并保留 `.bak` 备份），浏览器 `localStorage` 只作为缓存和降级
 - 支持导出 / 导入分组数据，方便备份、迁移和分享
 - 同一浏览器的多个标签页通过 `localStorage` 事件自动同步
-- 工作区右键菜单增加：新建分组、显示全部会话、展开全部分组、折叠全部分组、导出分组数据、导入分组数据
+- 工作区右键菜单增加：新建会话、新建分组、显示全部会话、展开全部分组、折叠全部分组、导出分组数据、导入分组数据
 - 打开有分组的工作区时自动展开被原生“显示更多”隐藏的会话，保证分组树完整
 
 ## 使用
 
 1. 右键工作区标题 → **新建分组**（或右键已有分组 → **新建子分组**）。
 2. 输入分组名，按 Enter。
-3. 归类会话：
+3. 新建会话：
+   - 右键工作区 → **新建会话**：在该工作区创建并打开；
+   - 右键分组 → **在此分组新建会话**：创建后直接归入该分组。
+4. 归类会话：
    - 右键会话 → **移动会话** → 选择目标分组，或选择 **新建分组并移入…**；或
    - 把会话行拖到分组标题上。
-4. 在分组标题上：
+5. 在分组标题上：
    - 点击箭头 / 标题：折叠或展开
    - `+`：新建子分组
    - 铅笔：重命名
    - 垃圾桶：删除分组（有确认）；会话和子分组会移到上一级并自动展开
-   - 右键：新建子分组 / 重命名 / 折叠 / 移到顶层 / 分组排序 / 删除
-5. 会话排序：右键组内会话 → **排序** → 移到最前 / 上移 / 下移 / 移到最后；需要回到原生顺序时选 **恢复默认顺序**。
-6. 分组排序：右键分组 → **分组排序** → 移到最前 / 上移 / 下移 / 移到最后；同级分组也可按名称重排。
-7. 要取消归类：右键会话 → **移动会话** → **移出分组**，或把会话拖到“未分组”。
-8. 备份或迁移：右键任意工作区 → **导出分组数据**，会下载一个 JSON 文件；在新机器或重装后右键工作区 → **导入分组数据** 选择该文件即可。导入会替换当前全部分组，不会删除任何会话。
+   - 右键：新建会话 / 新建子分组 / 重命名 / 折叠 / 移到顶层 / 分组排序 / 删除
+6. 会话排序：右键组内会话 → **排序** → 移到最前 / 上移 / 下移 / 移到最后；需要回到原生顺序时选 **恢复默认顺序**。
+7. 分组排序：右键分组 → **分组排序** → 移到最前 / 上移 / 下移 / 移到最后；同级分组也可按名称重排。
+8. 要取消归类：右键会话 → **移动会话** → **移出分组**，或把会话拖到“未分组”。
+9. 备份或迁移：右键任意工作区 → **导出分组数据**，会下载一个 JSON 文件；在新机器或重装后右键工作区 → **导入分组数据** 选择该文件即可。导入会替换当前全部分组，不会删除任何会话。
 
 > 分组树只出现在原生“分组方式 = 工作区 / 工作区树”的列表中。搜索结果是临时平铺列表，不显示分组；切回工作区列表后分组会恢复。
 
@@ -133,16 +138,16 @@ window.__DSH_SESSION_TREE__.importJson(text)  // 弹出确认后整份替换
 - `MutationObserver` 监听行增减，重新计算分组布局。
 - 分组右键菜单通过 `ctx.contextMenus` 注册一个插件私有 target；会话/工作区菜单通过官方 API 追加动作。
 - 归类关系按 `workspaceId → sessionId → groupId` 保存；不修改会话数据。
-- 宿主半侧在 `ctx.connection.rpc` 上注册插件私有通道 `/session-tree`（`load` / `save`），走官方已认证的 Connection RPC，不额外开放 HTTP 路由。
+- 宿主半侧通过 `ctx.webServer` 注册已认证的 `/session-tree` 前缀路由（`load` / `save`），用官方 Connection 的 `requestRejection` 校验浏览器凭证；不依赖浏览器端 `connection.rpc` 的 HTTP 转发。
 - 宿主只做结构校验、大小上限和原子文件写入；名称、父链、归类关系仍由客户端 `sanitizeState` 修正。
-- 连接服务不可用时（例如非 Web combo）客户端自动退回 `localStorage`，侧边栏照常工作。
+- Connection 服务不可用（例如非 Web combo）时只允许回环地址访问；客户端仍照常退回 `localStorage`。
 
 ## 兼容性
 
 - 目标版本：DSH `0.2.2-rc.1`（桌面端 Web GUI）。
 - 依赖官方行上的 `data-row-key` 约定和 `sidebar.workspaces` 区域的 DOM 结构。DSH 大版本升级后如果行结构变化，需要同步调整 `sectionForElement` / `wrapperOf`。
-- 宿主落盘依赖 Web combo 中的 `@deepseek-ai/dsh-client-connection`；缺失时自动退回 localStorage。
-- 不使用构建步骤：直接编辑 `lib/client.js`，刷新页面即可生效；修改 `lib/index.js` 后必须重启 DSH 才能重新加载宿主半侧（Node 会缓存已导入的模块，插件管理里的关闭/启用不会重新读取文件）。
+- 宿主落盘依赖 Web combo 的 `webServer` 与 `connection` 服务；`connection` 缺失时只允许回环地址读写，不退回 localStorage。
+- 不使用构建步骤：直接编辑 `lib/client.js`，刷新页面即可生效；修改 `lib/index.js` 后建议重启 DSH。插件管理的关闭/启用可能触发 HMR 重载宿主，但已打开的页面可能仍持有旧客户端 bundle，需要重新加载甚至重启才能恢复。
 
 ## 已知限制
 
@@ -152,5 +157,5 @@ window.__DSH_SESSION_TREE__.importJson(text)  // 弹出确认后整份替换
 - 分组数据落在 `$DSH_HOME` 下；同一台机器、同一个 DSH 主目录的多个 profile 共用一份文件，不同主目录不共享，也不会跨设备同步。
 - 导入是“整份替换”，不是合并；导入前建议先导出一份当前数据。
 - 不支持跨工作区移动会话：DSH 的会话归属由会话工作目录/工作区记录决定，插件只保存显示分组；把会话显示到另一个工作区会与原生归属、权限和工作目录语义冲突。跨区需求应通过“在目标工作区新建会话”完成，而不是移动。
-- 落盘依赖 `dsh-client-connection` 的认证 RPC。该服务缺失或连接失败时，数据只保留在浏览器 `localStorage`，并会在 Console 给出警告。
+- 落盘依赖 `webServer` 路由和 Connection 认证；`connection` 缺失时只允许回环地址访问。客户端 RPC 失败或宿主不可用时，数据保留在浏览器 `localStorage`，并在 Console 给出警告。
 - 插件通过 DOM 增强官方列表，不提供官方 API 级别的替换；如果 DSH 改变侧边栏 DOM 结构，需要适配。

package/lib/client.js

@@ -51,6 +51,9 @@ window.__ModuleLoader__.load({
     const STRINGS = {
       zh: {
         newGroup: "新建分组",
+        newSession: "新建会话",
+        newSessionInGroup: "在此分组新建会话",
+        sessionCreateFailed: "新建会话失败",
         newSubgroup: "新建子分组",
         rename: "重命名",
         deleteGroup: "删除分组",
@@ -101,6 +104,9 @@ window.__ModuleLoader__.load({
       },
       en: {
         newGroup: "New group",
+        newSession: "New session",
+        newSessionInGroup: "New session in this group",
+        sessionCreateFailed: "Could not create a session",
         newSubgroup: "New subgroup",
         rename: "Rename",
         deleteGroup: "Delete group",
@@ -1426,6 +1432,51 @@ window.__ModuleLoader__.load({
       return group;
     }
 
+    async function createSession(wsId, groupId) {
+      const sessions = getService("sessions");
+      if (!sessions || typeof sessions.create !== "function") {
+        toast(t("sessionCreateFailed"));
+        return;
+      }
+      try {
+        ensureWorkspaceExpanded(wsId);
+        const sessionId = await sessions.create({ workspaceId: wsId });
+        if (!sessionId) throw new Error("session create returned no id");
+
+        if (groupId) {
+          const ws = getWorkspace(wsId, true);
+          const group = findGroup(ws, groupId);
+          if (ws && group) {
+            const previous = ws.assignments[sessionId];
+            if (previous !== groupId) {
+              normalizeGroupOrder(wsId, groupId);
+              ws.assignments[sessionId] = groupId;
+              ws.sessionOrder = ws.sessionOrder || {};
+              ws.sessionOrder[sessionId] = nextSessionOrder(ws, groupId);
+            }
+            group.collapsed = false;
+            let parentId = group.parentId;
+            while (parentId) {
+              const parent = findGroup(ws, parentId);
+              if (!parent) break;
+              parent.collapsed = false;
+              parentId = parent.parentId;
+            }
+            saveState();
+            scheduleApply();
+          }
+        }
+
+        const uiWorkspace = getService("uiWorkspace");
+        if (uiWorkspace && typeof uiWorkspace.openSession === "function") {
+          uiWorkspace.openSession(sessionId);
+        }
+      } catch (error) {
+        console.warn("[" + MARK + "] could not create a session", error);
+        toast(t("sessionCreateFailed"));
+      }
+    }
+
     function beginRename(wsId, groupId, isNew) {
       const ws = getWorkspace(wsId, false);
       const group = findGroup(ws, groupId);
@@ -1839,6 +1890,7 @@ window.__ModuleLoader__.load({
             resolve: ({ workspaceId }) => {
               if (!workspaceId) return [];
               return [
+                { id: "new-session", label: t("newSession"), run: () => createSession(workspaceId) },
                 { id: "new-group", label: t("newGroup") + "…", run: () => createGroup(workspaceId, null) },
                 { id: "show-all", label: t("showAll"), run: () => expandAllSessions(workspaceId, false) },
                 { id: "expand-groups", label: t("expandAllGroups"), run: () => setAllGroupsCollapsed(workspaceId, false) },
@@ -1865,6 +1917,11 @@ window.__ModuleLoader__.load({
               const orderIndex = siblings.findIndex((candidate) => candidate.id === groupId);
               const orderLast = siblings.length - 1;
               return [
+                {
+                  id: "new-session",
+                  label: t("newSessionInGroup"),
+                  run: () => createSession(workspaceId, groupId),
+                },
                 { id: "subgroup", label: t("newSubgroup") + "…", run: () => createGroup(workspaceId, groupId) },
                 { id: "rename", label: t("rename") + "…", run: () => beginRename(workspaceId, groupId, false) },
                 {

package/lib/index.js

@@ -20,8 +20,8 @@ import { dirname, join } from 'node:path'
 /** Stable Cordis plugin name. */
 export const name = 'session-tree'
 
-/** No required host services; `connection` is injected opportunistically. */
-export const inject = []
+/** The shared HTTP server supplies the persistence route. */
+export const inject = ['webServer']
 
 const CHANNEL = '/session-tree'
 const FORMAT = 'dsh-session-tree'
@@ -160,52 +160,180 @@ function failure(code, message) {
   return { ok: false, error: { code, message, details: {} } }
 }
 
-function installRpc(scope) {
-  const connection = scope.connection || (typeof scope.get === 'function' ? scope.get('connection') : undefined)
-  const rpc = connection && connection.rpc
-  if (!rpc || typeof rpc.handle !== 'function') {
-    console.warn('[dsh-session-tree] connection RPC is unavailable; host persistence is off')
-    return
+const MAX_REQUEST_BYTES = MAX_STATE_BYTES + 64 * 1024
+
+/** Whether the Host connection service accepts this request as authenticated. */
+function authorized(req, connection) {
+  if (connection && typeof connection.requestRejection === 'function') {
+    try {
+      return connection.requestRejection(req) === undefined
+    } catch {
+      return false
+    }
   }
+  // No Connection service (for example a non-Web combo): only loopback may
+  // read or replace local group data.
+  const address = (req.socket && req.socket.remoteAddress) || ''
+  return address === '127.0.0.1' || address === '::1' || address === '::ffff:127.0.0.1'
+}
 
-  rpc.handle(CHANNEL, async (endpoint, payload) => {
-    if (endpoint === 'load') {
-      try {
-        const stored = await serialize(loadStored)
-        return { ok: true, value: stored }
-      } catch (error) {
-        console.warn('[dsh-session-tree] host load failed', error)
-        return failure('session-tree/load-failed', 'could not read saved groups')
+/** Read a bounded request body as UTF-8. */
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    let total = 0
+    let settled = false
+    const fail = (error) => {
+      if (settled) return
+      settled = true
+      reject(error)
+    }
+    req.on('data', (chunk) => {
+      if (settled) return
+      total += chunk.length
+      if (total > MAX_REQUEST_BYTES) {
+        fail(Object.assign(new Error('request is too large'), { code: 'request-too-large' }))
+        return
       }
+      chunks.push(chunk)
+    })
+    req.on('end', () => {
+      if (settled) return
+      settled = true
+      resolve(Buffer.concat(chunks).toString('utf8'))
+    })
+    req.on('error', fail)
+    req.on('aborted', () => fail(new Error('request aborted')))
+  })
+}
+
+/** Write one JSON response without leaking connection-level details. */
+function sendJson(res, status, value) {
+  const body = JSON.stringify(value)
+  res.writeHead(status, {
+    'cache-control': 'no-store',
+    'content-type': 'application/json; charset=utf-8',
+    'content-length': Buffer.byteLength(body, 'utf8'),
+  })
+  res.end(body)
+}
+
+async function handleRpc(req, res, connection) {
+  if (req.method !== 'POST') {
+    res.writeHead(405, { allow: 'POST', 'cache-control': 'no-store' })
+    res.end()
+    return
+  }
+  if (!authorized(req, connection)) {
+    res.writeHead(401, { 'cache-control': 'no-store' })
+    res.end('unauthorized')
+    return
+  }
+  const contentType = String(req.headers['content-type'] || '')
+    .split(';', 1)[0]
+    .trim()
+    .toLowerCase()
+  if (contentType !== 'application/json') {
+    res.writeHead(415, { 'cache-control': 'no-store' })
+    res.end('content type must be application/json')
+    return
+  }
+
+  let envelope
+  try {
+    envelope = JSON.parse(await readBody(req))
+  } catch (error) {
+    if (error && error.code === 'request-too-large') {
+      res.writeHead(413, { 'cache-control': 'no-store' })
+      res.end('request is too large')
+      return
     }
+    res.writeHead(400, { 'cache-control': 'no-store' })
+    res.end('body is not JSON')
+    return
+  }
+  if (
+    !envelope ||
+    typeof envelope !== 'object' ||
+    envelope.type !== 'client-request' ||
+    typeof envelope.rpcId !== 'string' ||
+    typeof envelope.method !== 'string'
+  ) {
+    res.writeHead(400, { 'cache-control': 'no-store' })
+    res.end('invalid request envelope')
+    return
+  }
 
-    if (endpoint === 'save') {
-      const state = payload && typeof payload === 'object' ? payload.state : undefined
-      try {
-        assertState(state)
-        const savedAt = await serialize(() => saveStored(state))
-        return { ok: true, value: { savedAt } }
-      } catch (error) {
-        console.warn('[dsh-session-tree] host save failed', error)
-        return failure('session-tree/save-failed', 'could not save groups')
-      }
+  let result
+  if (envelope.method === 'load') {
+    try {
+      const stored = await serialize(loadStored)
+      result = { ok: true, value: stored }
+    } catch (error) {
+      console.warn('[dsh-session-tree] host load failed', error)
+      result = failure('session-tree/load-failed', 'could not read saved groups')
     }
+  } else if (envelope.method === 'save') {
+    const state = envelope.payload && typeof envelope.payload === 'object' ? envelope.payload.state : undefined
+    try {
+      assertState(state)
+      const savedAt = await serialize(() => saveStored(state))
+      result = { ok: true, value: { savedAt } }
+    } catch (error) {
+      console.warn('[dsh-session-tree] host save failed', error)
+      result = failure('session-tree/save-failed', 'could not save groups')
+    }
+  } else {
+    result = failure('session-tree/not-found', 'unknown endpoint ' + JSON.stringify(String(envelope.method)))
+  }
+  sendJson(res, 200, { type: 'server-response', rpcId: envelope.rpcId, result })
+}
 
-    return failure('session-tree/not-found', 'unknown endpoint ' + JSON.stringify(String(endpoint)))
+function installRoute(scope, webServer) {
+  const dispose = webServer.register({
+    kind: 'prefix',
+    path: CHANNEL,
+    handler: (req, res) => {
+      let connection
+      try {
+        connection = typeof scope.get === 'function' ? scope.get('connection') : scope.connection
+      } catch {
+        connection = undefined
+      }
+      void handleRpc(req, res, connection).catch((error) => {
+        console.warn('[dsh-session-tree] host route failed', error)
+        if (!res.headersSent) {
+          res.writeHead(500, { 'cache-control': 'no-store' })
+          res.end('internal error')
+        } else {
+          res.end()
+        }
+      })
+    },
   })
+  return dispose
 }
 
 /** Mount the host half. */
 export function apply(ctx) {
   try {
-    ctx.inject(['connection'], (scope) => {
-      try {
-        installRpc(scope)
-      } catch (error) {
-        console.warn('[dsh-session-tree] could not register host RPC', error)
-      }
-    })
+    const webServer = ctx.webServer || (typeof ctx.get === 'function' ? ctx.get('webServer') : undefined)
+    if (!webServer || typeof webServer.register !== 'function') {
+      console.warn('[dsh-session-tree] web server is unavailable; host persistence is off')
+      return
+    }
+    const dispose = installRoute(ctx, webServer)
+    ctx.effect(
+      () => () => {
+        try {
+          if (typeof dispose === 'function') dispose()
+        } catch {
+          /* ignore */
+        }
+      },
+      'session-tree: host persistence route',
+    )
   } catch (error) {
-    console.warn('[dsh-session-tree] could not inject connection', error)
+    console.warn('[dsh-session-tree] could not register host route', error)
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-groups",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "DSH Web GUI sidebar session tree: group sessions inside each workspace into folders, persisted to disk with import/export.",
   "author": "westformula1",
   "license": "MIT",
@@ -24,6 +24,7 @@
     "README.md",
     "LICENSE",
     "PUBLISHING.md",
+    "CHANGELOG.md",
     "assets",
     "cordis.patch.yml"
   ],