dsh-vscode-mode 0.20.3 → 0.20.5

package/src/registry.ts

@@ -6,10 +6,29 @@
 import type { DiffRecord } from './shared/types.js'
 import type { Ctx, Session } from './store.js'
 import { cwdOfSession, loadBucket } from './store.js'
+import { SESSION_MISSING_ERROR, SESSION_NO_WORKSPACE_ERROR } from './shared/rpc.js'
 
 /** cwd → 记录桶（内存缓存；随会话销毁清理）。 */
 export type Registry = Map<string, Map<string, DiffRecord>>
 
+/** 会话作用域：本进程 live 会话可带 session；跨实例冷读只有已确认的 cwd。 */
+export interface SessionScope {
+  /** 本进程 live 会话；冷读持久化会话时为 undefined。 */
+  session?: Session
+  /** 已确认的绝对工作区路径。 */
+  cwd: string
+}
+
+/** sessionQuery 会话记录的最小读取面：只取 header.cwd，不依赖 DSH 类型包。 */
+interface ColdSessionRecord {
+  header?: { id?: string; cwd?: string }
+}
+
+/** sessionId → cwd 冷读缓存：header.cwd 建会话后不可变，故只增不改。 */
+const coldCwdCache = new Map<string, string>()
+/** 冷读缓存上限：超出后整表清空，避免长跑实例无限累积。 */
+const COLD_CWD_CACHE_MAX = 2048
+
 /** 按 sessionId 取会话；缺省时仅当唯一活跃会话才返回。 */
 export function sessionOf(ctx: Ctx, sessionId?: string): Session | undefined {
   const sessions = ctx.get('sessions')
@@ -46,3 +65,82 @@ export function bucketOf(registry: Registry, ctx: Ctx, cwd: string): Promise<Map
     return map
   })
 }
+
+/**
+ * 解析会话作用域：优先本进程 live 会话；未命中时冷读持久化会话头取 cwd。
+ * 仅供只读 RPC 使用——桌面端与 Web 端各有独立宿主，会话只在创建端 live，
+ * 但审查数据按 cwd 落盘、跨实例可读；写类 RPC 必须另行要求 live 会话。
+ * @author ddj 2026年10月28号
+ * @param ctx DSH 上下文（可选探测 sessions 与 sessionQuery）
+ * @param sessionId 目标会话 id（冷读必需；缺省时只认唯一活跃会话）
+ * @returns 会话作用域，或与 requireSession 同源的错误文案
+ */
+export async function resolveScope(ctx: Ctx, sessionId: string | undefined): Promise<SessionScope | { err: string }> {
+  const session = sessionOf(ctx, sessionId)
+  if (session) {
+    const cwd = cwdOfSession(ctx, session)
+    return cwd ? { session, cwd } : { err: SESSION_NO_WORKSPACE_ERROR }
+  }
+
+  const cwd = await coldCwdOf(ctx, sessionId)
+  return cwd ? { cwd } : { err: SESSION_MISSING_ERROR }
+}
+
+/**
+ * 冷读持久化会话头的 cwd：走 DSH sessionQuery 的持久化视图，不读事件日志、不碰写句柄。
+ * @author ddj 2026年10月28号
+ * @param ctx DSH 上下文
+ * @param sessionId 目标会话 id
+ * @returns 绝对路径；服务缺失、查无此会话或读取失败时 null（失败语义等同 live 未命中）
+ */
+export async function coldCwdOf(ctx: Ctx, sessionId: string | undefined): Promise<string | null> {
+  if (!sessionId) return null
+  const cached = coldCwdCache.get(sessionId)
+  if (cached) return cached
+
+  const query = ctx?.get?.('sessionQuery')
+  if (!query) return null
+
+  try {
+    const record = await findColdRecord(query, sessionId)
+    const cwd = record?.header?.cwd
+    if (typeof cwd !== 'string' || !cwd) return null
+    rememberColdCwd(sessionId, cwd)
+    return cwd
+  } catch {
+    // 冷读故障不改语义：仍按「会话不存在」上报，避免把存储异常说成权限问题
+    return null
+  }
+}
+
+/**
+ * 在 sessionQuery 的持久化会话视图里定位一条记录（优先精确过滤，其次整表列举）。
+ * 两种能力都缺失时返回 null，调用方回落原有「会话不存在」。
+ * @author ddj 2026年10月28号
+ * @param query ctx.sessionQuery 服务（不同 DSH 版本能力不同）
+ * @param sessionId 目标会话 id
+ * @returns 会话记录；无此会话或能力缺失时 null
+ */
+async function findColdRecord(query: Ctx, sessionId: string): Promise<ColdSessionRecord | null> {
+  const filterable = typeof query.filterSessions === 'function'
+  const listable = typeof query.listSessions === 'function'
+  if (!filterable && !listable) return null
+
+  const records = filterable
+    ? await query.filterSessions([{ kind: 'id', values: [sessionId] }])
+    : await query.listSessions()
+  if (!Array.isArray(records)) return null
+
+  return records.find((item: ColdSessionRecord) => item?.header?.id === sessionId) ?? null
+}
+
+/**
+ * 记录冷读结果（header.cwd 不可变，可长期复用）。
+ * @author ddj 2026年10月28号
+ * @param sessionId 目标会话 id
+ * @param cwd 已确认的绝对工作区路径
+ */
+function rememberColdCwd(sessionId: string, cwd: string): void {
+  if (coldCwdCache.size >= COLD_CWD_CACHE_MAX) coldCwdCache.clear()
+  coldCwdCache.set(sessionId, cwd)
+}

package/src/reviewRpc.ts

@@ -2,19 +2,34 @@
 import type { RpcHandlerMap } from './shared/rpc.js'
 import { decideReview, reviewDetail, reviewPage } from './reviewDb.js'
 import { undoReview } from './reviewUndo.js'
-import { bucketOf, cwdOfSession, sessionOf } from './registry.js'
+import { bucketOf, resolveScope, sessionOf } from './registry.js'
 import type { Registry } from './registry.js'
 import type { Ctx } from './store.js'
 
-/** @public @author ddj 2026年10月26号 @param ctx Host. @param registry Workspace cache. @returns Handlers resolving workspace from the live authenticated session, never caller cwd. */
+/**
+ * @public
+ * @author ddj 2026年10月26号 / 2026年10月28号
+ * @description: 审查 RPC 处理器。工作区一律由 host 解析，绝不采信调用方 cwd：
+ * 读路径优先 live 会话、其次冷读持久化会话头（跨实例只读）；写路径仍须 live 会话。
+ * @param ctx Host 上下文
+ * @param registry 工作区记录桶缓存
+ * @returns 审查相关处理器表
+ */
 export function reviewHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandlerMap> {
-  /** @private @author ddj 2026年10月26号 @param sessionId Request scope. @returns Migrated workspace, or explicit failure without fallback. */
+  /** @private @author ddj 2026年10月28号 @param sessionId 请求作用域 @returns 已迁移工作区（允许跨实例冷读） */
   async function workspace(sessionId: string): Promise<string> {
-    const session = sessionOf(ctx, sessionId)
-    const cwd = cwdOfSession(ctx, session)
-    if (!session || !cwd) throw new Error('会话不存在或没有工作区')
-    await bucketOf(registry, ctx, cwd)
-    return cwd
+    const scope = await resolveScope(ctx, sessionId)
+    if ('err' in scope) throw new Error('会话不存在或没有工作区')
+    await bucketOf(registry, ctx, scope.cwd)
+    return scope.cwd
+  }
+
+  /** @private @author ddj 2026年10月28号 @param sessionId 请求作用域 @returns 本端 live 会话的工作区；冷读作用域一律拒绝写入 */
+  async function liveWorkspace(sessionId: string): Promise<string> {
+    const scope = await resolveScope(ctx, sessionId)
+    if ('err' in scope || !scope.session) throw new Error('会话不存在或没有工作区')
+    await bucketOf(registry, ctx, scope.cwd)
+    return scope.cwd
   }
   return {
     'edrv.review.list': async (args) => {
@@ -27,7 +42,8 @@ export function reviewHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandler
       return detail ? { ok: true, detail } : { ok: false, error: '官方审查记录不存在' }
     },
     'edrv.review.decide': async (args) => {
-      const cwd = await workspace(args.sessionId)
+      // 写类操作要求 live 会话：避免两端并发写同一工作区审查库，回滚也依赖本端会话内容
+      const cwd = await liveWorkspace(args.sessionId)
       try {
         const result = args.decision === 'rejected'
           ? await undoReview(ctx, sessionOf(ctx, args.sessionId), cwd, args)

package/src/rpc.ts

@@ -17,6 +17,7 @@ import {
   autoArchiveStale,
   policyOf,
   resolveTarget,
+  resolveTargetIn,
   saveBucket,
 } from './store.js'
 import { cp, mkdir, readFile, rename, rm, stat, writeFile, readdir } from 'node:fs/promises'
@@ -25,8 +26,8 @@ import { archiveEntryFor, markDecision, recordResolved, reconstructOriginal } fr
 import { clearRevertState, listArchives, pageArchives, readArchives, revertState, setRevertState, startReverts } from './archiveDb.js'
 import { hasOfficial } from './reviewDb.js'
 import { log } from './log.js'
-import type { Registry } from './registry.js'
-import { bucketOf, cwdOfSession, sessionOf } from './registry.js'
+import type { Registry, SessionScope } from './registry.js'
+import { bucketOf, cwdOfSession, resolveScope, sessionOf } from './registry.js'
 import type { SearchOrchestrator } from './search/orchestrator.js'
 import { newSearcher } from './search/orchestrator.js'
 import type { ContentSearcher } from './search/content.js'
@@ -166,13 +167,13 @@ interface ReadTargetOk {
  */
 async function readTargetOf(
   ctx: Ctx,
-  sc: { session: Session; cwd: string },
+  sc: SessionScope,
   path: string,
 ): Promise<ReadTargetOk | { err: string; resolvedPath?: string; code?: 'file-too-large' }> {
   const fs = ctx.get('fs')
   if (!fs) return { err: '缺少 fs' }
   try {
-    const target = await resolveTarget(ctx, sc.session, path)
+    const target = await resolveTargetIn(ctx, sc.cwd, path)
     debugRecord(ctx, sc.cwd, '[DEBUG path.resolve] input=' + String(path ?? '') + ' resolved=' + fs.processPath(target), 'debug')
     const info = await fs.stat(target)
     if (!info || info.type !== 'file') {
@@ -596,7 +597,7 @@ export function buildHandlers(
       let staleMs = 0
       let staleChecked = false
       // #endregion
-      const sc = await requireSession(ctx, args.sessionId)
+      const sc = await resolveScope(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       const bucket = await bucketOf(registry, ctx, sc.cwd)
       // #region debug log
@@ -606,7 +607,8 @@ export function buildHandlers(
       // 全量轮询时自动清理 stale 幽灵差异（批量决策后的即时刷新可 skipStale 跳过）；
       // 三个组件各自 5s 全量 list，stale 检查节流到 STALE_CHECK_MIN_MS 一次，
       // 避免每轮都对全部记录读文件 + 算指纹（keepall 期间多组件同时刷新的主要 host 开销）。
-      if (!want && args.skipStale !== true) {
+      // 跨实例冷读没有 live 会话：stale 清理要写侧车与归档，一律跳过（只读语义）。
+      if (sc.session && !want && args.skipStale !== true) {
         const now = Date.now()
         if (now - (staleCheckedAt.get(sc.cwd) ?? 0) > STALE_CHECK_MIN_MS) {
           staleCheckedAt.set(sc.cwd, now)
@@ -645,7 +647,7 @@ export function buildHandlers(
      * @author ddj 2026年09月28号
      */
     'edrv.uiState.get': async (args) => {
-      const sc = await requireSession(ctx, args.sessionId)
+      const sc = await resolveScope(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       const keys = await readUiState(uiStateFile(sc.cwd))
       const globals = await readUiState(uiGlobalsFile())
@@ -657,7 +659,7 @@ export function buildHandlers(
      * @author ddj 2026年09月28号 / 2026年09月29号
      */
     'edrv.uiState.set': async (args) => {
-      const sc = await requireSession(ctx, args.sessionId)
+      const sc = await resolveScope(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       const tasks: Array<Promise<{ ok: true } | { ok: false; error: string }>> = []
       if (args.keys && Object.keys(args.keys).length) tasks.push(writeUiState(uiStateFile(sc.cwd), args.keys))
@@ -700,10 +702,10 @@ export function buildHandlers(
     },
     /** @author ddj 2026年10月22号 @param args Read-only request. @returns Bounded official range read, or unsupported on older providers; never bypasses Host IO. */
     'edrv.textPage': async (args) => {
-      const sc = await requireSession(ctx, args.sessionId)
+      const sc = await resolveScope(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err, reason: 'read-failed' }
       try {
-        const target = await resolveTarget(ctx, sc.session, args.path)
+        const target = await resolveTargetIn(ctx, sc.cwd, args.path)
         const fs = ctx.get('fs')
         if (typeof fs?.readByteRange !== 'function' || typeof fs.stat !== 'function') return readTextPage(undefined, args)
         // Keys are opaque identities, never decoded into physical paths. Both legacy string and official FsTarget are supported.
@@ -741,7 +743,7 @@ export function buildHandlers(
           return { ok: false, error: '读取片段文件失败：' + String(error), resolvedPath: snippetTarget }
         }
       }
-      const sc = await requireSession(ctx, args.sessionId)
+      const sc = await resolveScope(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       const prep = await readTargetOf(ctx, sc, args.path)
       if ('err' in prep) return targetErrOf(prep)
@@ -763,7 +765,7 @@ export function buildHandlers(
       // 二进制直读通道（图片/PDF 预览）：与 edrv.read base64 分支共用 readTargetOf 前置，
       // 返回 Uint8Array 信封；routes 接线后以 octet-stream + x-edrv-* 头直出，
       // 未接线时信封被 JSON 化，由 client 探测到后自动回退 base64 路径（见 shared/rpc readBinaryPreview）。
-      const sc = await requireSession(ctx, args.sessionId)
+      const sc = await resolveScope(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       const prep = await readTargetOf(ctx, sc, args.path)
       if ('err' in prep) return targetErrOf(prep)
@@ -802,12 +804,12 @@ export function buildHandlers(
     'edrv.original': async (args) => {
       // 重建"本批次修改前"内容：DiffEditor 原始侧。仅反解 pending 块；
       // 全部反解失败时回退到最早记录的整体 before（若存在）。
-      const sc = await requireSession(ctx, args.sessionId)
+      const sc = await resolveScope(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       const fs = ctx.get('fs')
       if (!fs) return { ok: false, error: '缺少 fs' }
       try {
-        const target = await resolveTarget(ctx, sc.session, args.path)
+        const target = await resolveTargetIn(ctx, sc.cwd, args.path)
          debugRecord(ctx, sc.cwd, '[DEBUG path.resolve] input=' + String(args.path ?? '') + ' resolved=' + fs.processPath(target), 'debug')
         const info = await fs.stat(target)
         if (!info || info.type !== 'file') return { ok: false, error: '文件不存在' }
@@ -898,7 +900,7 @@ export function buildHandlers(
       }
     },
     'edrv.archiveList': async (args) => {
-      const sc = await requireSession(ctx, args.sessionId)
+      const sc = await resolveScope(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       try {
         const ws = findRemoteWs(sc.cwd)
@@ -911,7 +913,7 @@ export function buildHandlers(
       }
     },
     'edrv.archivePage': async (args) => {
-      const sc = await requireSession(ctx, args.sessionId)
+      const sc = await resolveScope(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       try {
         const ws = findRemoteWs(sc.cwd)
@@ -924,7 +926,7 @@ export function buildHandlers(
       }
     },
     'edrv.archiveRead': async (args) => {
-      const sc = await requireSession(ctx, args.sessionId)
+      const sc = await resolveScope(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       try {
         if (args.batch !== undefined && (!args.path || (args.batch !== null && !Number.isInteger(args.batch)))) return { ok: false, error: '归档批次参数无效' }
@@ -1064,7 +1066,7 @@ export function buildHandlers(
     'edrv.listDir': async (args) => {
       // 目录树（侧边栏文件管理用）：树索引命中直出（内存，0 IO）；失效/force 时
       // 走快路径（resolve + listDirCheap + putIndex）；同路径在途请求去重复用。
-      const sc = await requireSession(ctx, args.sessionId)
+      const sc = await resolveScope(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       const rel = normalizeRel(args.path)
       if (rel === null) return { ok: false, error: '路径不合法' }

package/src/store.ts

@@ -65,6 +65,19 @@ export async function resolveTarget(ctx: Ctx, session: Session | undefined, path
   return fs.resolve(path, cwd ? { cwd } : {})
 }
 
+/**
+ * 按已知工作区目录解析目标路径：跨实例只读路径在无 live 会话时使用。
+ * @author ddj 2026年10月28号
+ * @param ctx DSH 上下文
+ * @param cwd 工作区绝对路径（live 投影或持久化 header）
+ * @param path 客户端请求路径
+ * @returns 解析后的目标
+ */
+export async function resolveTargetIn(ctx: Ctx, cwd: string, path: string): Promise<string> {
+  const fs = ctx.get('fs')
+  return fs.resolve(path, cwd ? { cwd } : {})
+}
+
 /** 读取工作区主 sidecar 文本（缺失/失败 → null）。 */
 async function readSidecarText(ctx: Ctx, cwd: string | null): Promise<string | null> {
   const fs = ctx.get('fs')