dsh-vscode-mode 0.22.0 → 0.23.1

package/src/pending/capture.ts

@@ -29,93 +29,122 @@ export interface PendingCapture {
   dispose(): void
 }
 
+/** 采集器的进程内状态：同一目标并发写入时只采信最外层那一次。 */
+interface CaptureState {
+  busy: Set<string>
+  stopped: boolean
+}
+
+/** 工具的写工具参数形状；只取本采集关心的字段。 */
+interface WriteExec {
+  name?: string
+  arguments?: { file_path?: unknown; path?: unknown }
+  agent?: { session?: { id?: string; cwd?: string } }
+}
+
 /**
- * @author ddj 2026年10月29号
+ * @author ddj 2026年10月30号
  * @description: 安装写文件采集；读写失败只影响待审来源，绝不影响用户工具本身。
  * @param ctx Host 生命周期
  * @param sink 已确认写入的接收方
  * @returns 可释放的采集器
  */
-export function installPendingCapture(ctx: Ctx, sink: (write: PendingWrite) => void): PendingCapture {
-  const busy = new Set<string>()
-  let stopped = false
-  ctx.on('tools/execute', aroundTool)
-  return { dispose }
+export function installPending(ctx: Ctx, sink: (write: PendingWrite) => void): PendingCapture {
+  const state: CaptureState = { busy: new Set<string>(), stopped: false }
+  ctx.on('tools/execute', (exec: WriteExec, next: () => Promise<unknown>) => aroundTool(ctx, state, sink, exec, next))
+  return {
+    dispose(): void {
+      state.stopped = true
+      state.busy.clear()
+    },
+  }
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 判定本次调用是否值得采集；不值得时返回 null，调用方直接透传原始分发。
+ * @param ctx Host 生命周期
+ * @param state 采集状态
+ * @param exec 工具分发上下文
+ * @returns 采集计划或 null
+ */
+async function planOf(ctx: Ctx, state: CaptureState, exec: WriteExec): Promise<CapturePlan | null> {
+  const session = exec.agent?.session
+  const requested = exec.arguments?.file_path ?? exec.arguments?.path
+  if (state.stopped || !session?.id || typeof requested !== 'string') return null
+  if (!WRITE_TOOLS.includes(String(exec.name))) return null
+  const cwd = cwdOf(session as never)
+  if (!cwd) return null
+  const fs = ctx.get('fs')
+  const target = await resolveTarget(ctx, session as never, requested)
+  const identity = fs.processPath(target)
+  if (typeof identity !== 'string' || !identity || state.busy.has(identity)) return null
+  const before = await readText(fs, target)
+  if (before !== null && before.length > MAX_TEXT) return null
+  return { cwd: String(cwd), sessionId: String(session.id), path: requested, identity, before, session: session as never }
+}
+
+/** 一次采集所需的固定信息。 */
+interface CapturePlan {
+  cwd: string
+  sessionId: string
+  path: string
+  identity: string
+  before: string | null
+  session: never
+}
 
-  /**
-   * @author ddj 2026年10月29号
-   * @description: 写工具执行前后各读一次，内容变化才上报。
-   * @param exec 工具分发上下文
-   * @param next 原始分发
-   * @returns 原始工具结果，永不因采集失败而改变
-   */
-  async function aroundTool(exec: any, next: () => Promise<any>): Promise<any> {
-    const session = exec.agent?.session
-    const path = exec.arguments?.file_path ?? exec.arguments?.path
-    if (stopped || !session?.id || typeof path !== 'string' || !WRITE_TOOLS.includes(exec.name)) return next()
-    const cwd = cwdOf(session)
-    if (!cwd) return next()
-    let before: string | null = null
-    let identity: string | null = null
+/**
+ * @author ddj 2026年10月30号
+ * @description: 写工具执行前后各读一次，内容变化才上报；任何采集异常都不改变工具结果。
+ * @param ctx Host 生命周期
+ * @param state 采集状态
+ * @param sink 已确认写入的接收方
+ * @param exec 工具分发上下文
+ * @param next 原始分发
+ * @returns 原始工具结果
+ */
+async function aroundTool(
+  ctx: Ctx, state: CaptureState, sink: (write: PendingWrite) => void,
+  exec: WriteExec, next: () => Promise<unknown>,
+): Promise<unknown> {
+  let plan: CapturePlan | null = null
+  try {
+    plan = await planOf(ctx, state, exec)
+  } catch (error) {
+    log.debug('待审采集跳过：' + String(error))
+  }
+  if (!plan) return next()
+
+  state.busy.add(plan.identity)
+  try {
+    return await next()
+  } finally {
+    state.busy.delete(plan.identity)
     try {
-      const fs = ctx.get('fs')
-      const target = await resolveTarget(ctx, session, path)
-      const key = fs.processPath(target)
-      if (typeof key !== 'string' || !key) return next()
-      if (busy.has(key)) return next()
-      before = await readText(fs, target)
-      if (before !== null && before.length > MAX_TEXT) return next()
-      identity = key
-      busy.add(key)
+      reportWrite(ctx, sink, plan)
     } catch (error) {
-      log.debug('待审采集跳过：' + String(error))
-      return next()
-    }
-    try {
-      return await next()
-    } finally {
-      if (identity !== null) {
-        const key: string = identity
-        try { report(String(cwd), String(session.id), String(path), key, before, exec) } catch (error) {
-          log.debug('待审上报失败：' + String(error))
-        }
-        busy.delete(key)
-      }
+      log.debug('待审上报失败：' + String(error))
     }
   }
+}
 
-  /**
-   * @author ddj 2026年10月29号
-   * @description: 写后读回并比较，内容一致视为无净变化不产生条目。
-   * @param cwd 工作区
-   * @param sessionId 会话
-   * @param path 展示路径
-   * @param identity 目标身份
-   * @param before 写前内容
-   * @param exec 工具分发上下文
-   * @returns 无
-   */
-  function report(
-    cwd: string, sessionId: string, path: string, identity: string, before: string | null, exec: any,
-  ): void {
-    const fs = ctx.get('fs')
-    void resolveTarget(ctx, exec.agent.session, path).then(async (target: any) => {
-      const after = await readText(fs, target)
-      if (after !== null && after.length > MAX_TEXT) return
-      if (before === after) return
-      sink({ cwd, sessionId, path, identity, before, after, now: Date.now() })
-    }).catch((error: unknown) => log.debug('待审读回失败：' + String(error)))
-  }
-
-  /**
-   * @author ddj 2026年10月29号
-   * @description: 释放监听。
-   * @returns 无
-   */
-  function dispose(): void {
-    stopped = true
-    busy.clear()
-  }
+/**
+ * @author ddj 2026年10月29号
+ * @description: 写后读回并比较，内容一致视为无净变化不产生条目。
+ * @param ctx Host 生命周期
+ * @param sink 已确认写入的接收方
+ * @param plan 采集计划
+ * @returns 无；读回失败只记日志
+ */
+function reportWrite(ctx: Ctx, sink: (write: PendingWrite) => void, plan: CapturePlan): void {
+  const fs = ctx.get('fs')
+  void resolveTarget(ctx, plan.session, plan.path).then(async (target: unknown) => {
+    const after = await readText(fs, target)
+    if (after !== null && after.length > MAX_TEXT) return
+    if (plan.before === after) return
+    sink({ cwd: plan.cwd, sessionId: plan.sessionId, path: plan.path, identity: plan.identity, before: plan.before, after, now: Date.now() })
+  }).catch((error: unknown) => log.debug('待审读回失败：' + String(error)))
 }
 
 /**

package/src/pending/persist.ts

@@ -76,7 +76,12 @@ CREATE TABLE IF NOT EXISTS pending_history (
   state TEXT NOT NULL DEFAULT 'applied');
 `
 
-/** v1 历史表补 state 列（rebuild 成本高于一次 ALTER）。 */
+/**
+ * @author ddj 2026年10月29号
+ * @description: v1 历史表补 state 列（rebuild 成本高于一次 ALTER）。
+ * @param db 已打开的工作区库
+ * @returns 无
+ */
 function migrateHistory(db: DatabaseSync): void {
   const columns = db.prepare('PRAGMA table_info(pending_history)').all() as Row[]
   if (columns.some((column) => column.name === 'state')) return

package/src/pending/store.ts

@@ -21,7 +21,12 @@ import {
   readOp, saveBlocks, saveEntry, setHistoryState, writeOp,
 } from './persist.js'
 
-/** 统计一次差异的增删行数。 */
+/**
+ * @author ddj 2026年10月29号
+ * @description: 统计一次差异的增删行数；非文本差异统一记 0/0。
+ * @param entry 待审条目
+ * @returns 增删行数
+ */
 function countsOf(entry: PendingEntry): { added: number; deleted: number } {
   const diff = diffOf(entry)
   if (diff.kind !== 'text') return { added: 0, deleted: 0 }
@@ -225,11 +230,11 @@ export function writerFor(
     // 撤销「Revert 删除新建文件」时文件已不存在，只有显式允许重建才放行
     const recreate = allowCreate && current === null
     if (!recreate && current !== expected) return { ok: false, reason: 'diverged' }
-    const info = await fs.stat(target, signal).catch(() => undefined)
+    const currentStat = await fs.stat(target, signal).catch(() => undefined)
     try {
       // 第五个实参是沙箱策略；缺它时 provider 会以 FS_SANDBOX_DENIED 拒绝写入
       const written = await fs.writeText(
-        target, content ?? '', info ? { kind: 'replaceIfVersion', version: info.version } : undefined, signal, policy,
+        target, content ?? '', currentStat ? { kind: 'replaceIfVersion', version: currentStat.version } : undefined, signal, policy,
       )
       const readBack = await readText(fs, target)
       if ((content ?? '') !== (readBack ?? '')) return { ok: false, reason: 'read-back-mismatch' }
@@ -412,8 +417,8 @@ async function deleteTarget(fs: any, cwd: string, identity: string, signal?: Abo
   } catch {
     return { ok: false, reason: 'resolve-failed' }
   }
-  const info = await fs.stat(target, signal).catch(() => undefined)
-  if (!info) return { ok: true, content: null }
+  const currentStat = await fs.stat(target, signal).catch(() => undefined)
+  if (!currentStat) return { ok: true, content: null }
   const absolute = String(fs.processPath(target))
   if (!insideWorkspace(cwd, absolute)) return { ok: false, reason: 'outside-workspace' }
   try {

package/src/pending/vcs.ts

@@ -373,8 +373,8 @@ async function runCommand(
  */
 async function readTextOf(path: string): Promise<string | null> {
   try {
-    const info = await stat(path)
-    if (!info.isFile()) return null
+    const fileStat = await stat(path)
+    if (!fileStat.isFile()) return null
     return await readFile(path, 'utf8')
   } catch {
     return null

package/src/pendingCompat.ts

@@ -5,6 +5,7 @@
  */
 import type { ReviewDetail, ReviewItem, ReviewPage } from './shared/review.js'
 import type { PendingDetail, PendingItem, PendingPage } from './shared/pendingReview.js'
+import { pathKeyFor } from './shared/pathKey.js'
 
 /** 进程内"已被待审接管"的路径集合；旧写入口守卫只读它，绝不碰数据库。 */
 const coveredPaths = new Set<string>()
@@ -30,18 +31,12 @@ function stableSeq(id: string): number {
 
 /**
  * @author ddj 2026年10月29号
- * @description: 统一路径比较口径，消除分隔符与 Windows 大小写差异；远端身份保留原大小写。
+ * @description: Host 侧的路径比较口径：远端身份保留大小写，其余按运行平台折叠。
  * @param path 路径
  * @returns 比较键
  */
 function pathKey(path: string): string {
-  const unified = path.replace(/\\/g, '/')
-  // 远端仓库身份区分大小写，折叠成小写会把 Host/Repo 与 host/repo 混成同一个文件。
-  if (/^[a-z]+:\/\//i.test(unified)) return unified
-  // 盘符路径天生大小写不敏感（与宿主平台无关，客户端 diffPathKey 同口径）；
-  // POSIX 路径在 POSIX 上区分大小写，不能折叠。
-  if (/^[a-z]:\//i.test(unified)) return unified.toLowerCase()
-  return process.platform === 'win32' ? unified.toLowerCase() : unified
+  return pathKeyFor(path, process.platform === 'win32')
 }
 
 /**

package/src/pendingRpc.ts

@@ -12,111 +12,172 @@ import type { ShellLike } from './pending/vcs.js'
 import type { Ctx } from './store.js'
 import { policyOf } from './store.js'
 
+/** 处理器共享的作用域能力：读允许跨实例冷读，写必须本端 live 会话。 */
+interface ScopeKit {
+  ctx: Ctx
+  read(sessionId: string): Promise<string>
+  write(sessionId: string): Promise<string>
+}
+
 /**
- * @author ddj 2026年10月29号
- * @description: 待审投影处理器。读路径允许跨实例冷读，写路径必须本端 live 会话。
+ * @author ddj 2026年10月30号
+ * @description: 解析会话工作区并预热记录桶；读路径也走它，避免冷读时桶未就绪。
  * @param ctx Host 上下文
  * @param registry 工作区记录桶缓存
- * @returns 待审相关处理器表
+ * @param sessionId 请求作用域
+ * @returns 工作区路径
  */
-export function pendingHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandlerMap> {
-  /** @private @author ddj 2026年10月29号 @param sessionId 请求作用域 @returns 工作区 */
-  async function workspace(sessionId: string): Promise<string> {
-    const scope = await resolveScope(ctx, sessionId)
-    if ('err' in scope) throw new Error('会话不存在或没有工作区')
-    await bucketOf(registry, ctx, scope.cwd)
-    return scope.cwd
-  }
+async function workspaceOf(ctx: Ctx, registry: Registry, sessionId: string): Promise<string> {
+  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月29号 @param sessionId 请求作用域 @returns 本端 live 会话的工作区 */
-  async function liveWorkspace(sessionId: string): Promise<string> {
-    const cwd = await workspace(sessionId)
-    if (!sessionOf(ctx, sessionId)) throw new Error('写入要求本端活跃会话')
-    return cwd
-  }
+/**
+ * @author ddj 2026年10月30号
+ * @description: 写路径专用的工作区解析：本端没有该会话就直接拒绝，不做跨实例写。
+ * @param ctx Host 上下文
+ * @param registry 工作区记录桶缓存
+ * @param sessionId 请求作用域
+ * @returns 工作区路径
+ */
+async function writeWorkspaceOf(ctx: Ctx, registry: Registry, sessionId: string): Promise<string> {
+  const cwd = await workspaceOf(ctx, registry, sessionId)
+  if (!sessionOf(ctx, sessionId)) throw new Error('写入要求本端活跃会话')
+  return cwd
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 把异常归一成可播报文案，避免处理器各自重复三元表达式。
+ * @param error 捕获到的异常
+ * @returns 错误文案
+ */
+function failureOf(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
 
-  /**
-   * @private
-   * @author ddj 2026年10月30号
-   * @description: 面板列表里的条目 id 带待审前缀（用于和官方条目区分），
-   * 而待审内核按原始身份存取；各处理器统一走 pendingRawId 剥掉前缀。
-   * @param id 请求里的条目 id
-   * @returns 待审内核使用的原始 id
-   */
-  const rawId = pendingRawId
+/**
+ * @author ddj 2026年10月30号
+ * @description: 按会话策略包装 shell：执行器默认按 workspace-write 跑，本机无可用沙箱后端会直接拒绝。
+ * @param raw 原始 shell 能力
+ * @param policy 会话沙箱策略
+ * @returns 带策略的 shell 视图
+ */
+function shellOf(raw: ShellLike, policy: unknown): ShellLike {
+  return {
+    resolve: (request) => raw.resolve(policy ? { ...request, sandboxPolicy: policy } : request),
+    execute: (spec) => raw.execute(spec),
+  }
+}
 
+/**
+ * @author ddj 2026年10月30号
+ * @description: 读路径处理器：列表与详情，允许跨实例冷读。
+ * @param kit 作用域能力
+ * @returns 处理器表
+ */
+function readHandlers(kit: ScopeKit): Partial<RpcHandlerMap> {
   return {
     'edrv.pending.list': async (args: PendingRequest) => {
-      const cwd = await workspace(args.sessionId)
+      const cwd = await kit.read(args.sessionId)
       const page = loadPage(cwd, args.sessionId)
       // 列表即登记接管关系；旧写入口守卫之后只读内存集合，不再产生数据库读
       for (const item of page.items) trackPendingCover(cwd, item.path, true)
       return { ok: true, page }
     },
     'edrv.pending.detail': async (args: PendingRequest & { id: string }) => {
-      const cwd = await workspace(args.sessionId)
-      const detail = loadDetail(cwd, rawId(args.id))
+      const cwd = await kit.read(args.sessionId)
+      const detail = loadDetail(cwd, pendingRawId(args.id))
       return detail ? { ok: true, detail } : { ok: false, error: '待审条目不存在' }
     },
+  }
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 判定处理器：Keep/Revert 与已解决条目移除，都会改变待审状态。
+ * @param kit 作用域能力
+ * @returns 处理器表
+ */
+function decideHandlers(kit: ScopeKit): Partial<RpcHandlerMap> {
+  return {
     'edrv.pending.decide': async (args) => {
-      const cwd = await liveWorkspace(args.sessionId)
+      const cwd = await kit.write(args.sessionId)
+      const id = pendingRawId(args.id)
       try {
-        const id = rawId(args.id)
-        const result = await applyDecide(ctx.get('fs'), cwd, { ...args, id }, undefined, policyOf(ctx, sessionOf(ctx, args.sessionId)))
+        const policy = policyOf(kit.ctx, sessionOf(kit.ctx, args.sessionId))
+        const result = await applyDecide(kit.ctx.get('fs'), cwd, { ...args, id }, undefined, policy)
         if (!result.ok) return { ok: false, error: result.reason }
         const detail = loadDetail(cwd, id)
-        if (!detail) return { ok: false, error: '待审条目不存在' }
-        return { ok: true, item: detail.item, wrote: result.wrote }
+        return detail ? { ok: true, item: detail.item, wrote: result.wrote } : { ok: false, error: '待审条目不存在' }
       } catch (error) {
-        return { ok: false, error: error instanceof Error ? error.message : String(error) }
+        return { ok: false, error: failureOf(error) }
       }
     },
     'edrv.pending.remove': async (args) => {
-      const cwd = await liveWorkspace(args.sessionId)
-      const id = rawId(args.id)
+      const cwd = await kit.write(args.sessionId)
+      const id = pendingRawId(args.id)
       const path = loadEntries(cwd).find((stored) => stored.entry.id === id)?.entry.path
       const removed = removeEntry(cwd, id, args.revision)
       // 移除后该路径不再由待审投影接管，旧入口守卫随之放行
       if (removed && path) trackPendingCover(cwd, path, false)
       return { ok: true, removed }
     },
+  }
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 历史处理器：撤销/重做一次决定。
+ * @param kit 作用域能力
+ * @returns 处理器表
+ */
+function historyHandlers(kit: ScopeKit): Partial<RpcHandlerMap> {
+  return {
     'edrv.pending.history': async (args) => {
-      const cwd = await liveWorkspace(args.sessionId)
+      const cwd = await kit.write(args.sessionId)
+      const policy = policyOf(kit.ctx, sessionOf(kit.ctx, args.sessionId))
       try {
-        const result = await undoDecide(ctx.get('fs'), cwd, args, undefined, policyOf(ctx, sessionOf(ctx, args.sessionId)))
-        if (!result.ok) return { ok: false, error: result.reason }
-        return { ok: true, item: result.item, wrote: result.wrote }
+        const result = await undoDecide(kit.ctx.get('fs'), cwd, args, undefined, policy)
+        return result.ok ? { ok: true, item: result.item, wrote: result.wrote } : { ok: false, error: result.reason }
       } catch (error) {
-        return { ok: false, error: error instanceof Error ? error.message : String(error) }
+        return { ok: false, error: failureOf(error) }
       }
     },
+  }
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 投影维护处理器：从版本库导入、按磁盘现状刷新单条。
+ * @param kit 作用域能力
+ * @returns 处理器表
+ */
+function refreshHandlers(kit: ScopeKit): Partial<RpcHandlerMap> {
+  return {
     'edrv.pending.import': async (args) => {
-      const cwd = await liveWorkspace(args.sessionId)
-      const raw = ctx.get('shell') as unknown as ShellLike | undefined
+      const cwd = await kit.write(args.sessionId)
+      const raw = kit.ctx.get('shell') as unknown as ShellLike | undefined
       if (!raw) return { ok: false, error: '当前环境没有 shell 能力，无法读取版本库基线' }
-      // shell 执行器默认按 workspace-write 跑；本机没有可用沙箱后端时会直接拒绝，
-      // 所以按会话策略显式下发（会话已放宽时命令才能跑起来）。
-      const policy = policyOf(ctx, sessionOf(ctx, args.sessionId))
-      const shell: ShellLike = {
-        resolve: (request) => raw.resolve(policy ? { ...request, sandboxPolicy: policy } : request),
-        execute: (spec) => raw.execute(spec),
-      }
+      const policy = policyOf(kit.ctx, sessionOf(kit.ctx, args.sessionId))
       try {
+        const shell = shellOf(raw, policy)
         const result = await importFromVcs(shell, cwd, args.sessionId, { includeUntracked: args.includeUntracked, path: args.path })
-        const page = loadPage(cwd, args.sessionId)
-        for (const item of page.items) trackPendingCover(cwd, item.path, true)
+        for (const item of loadPage(cwd, args.sessionId).items) trackPendingCover(cwd, item.path, true)
         return { ok: true, imported: result.imported, changes: result.changes }
       } catch (error) {
-        return { ok: false, error: error instanceof Error ? error.message : String(error) }
+        return { ok: false, error: failureOf(error) }
       }
     },
     'edrv.pending.refresh': async (args: PendingRequest & { id: string }) => {
-      const cwd = await liveWorkspace(args.sessionId)
-      const id = rawId(args.id)
+      const cwd = await kit.write(args.sessionId)
+      const id = pendingRawId(args.id)
       const stored = loadEntries(cwd).find((entry) => entry.entry.id === id)
       if (!stored) return { ok: false, error: '待审条目不存在' }
-      const session = sessionOf(ctx, args.sessionId)
-      const fs = ctx.get('fs')
+      const fs = kit.ctx.get('fs')
+      const session = sessionOf(kit.ctx, args.sessionId)
       const target = await fs.resolve(id, { cwd, agent: session })
       const content = await readText(fs, target).catch(() => undefined)
       if (content === undefined) return { ok: false, error: '读取失败' }
@@ -126,3 +187,24 @@ export function pendingHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandle
     },
   }
 }
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: 待审投影处理器表：按用途拆成读/判定/历史/维护四组，便于分别收敛权限。
+ * @param ctx Host 上下文
+ * @param registry 工作区记录桶缓存
+ * @returns 待审相关处理器表
+ */
+export function pendingHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandlerMap> {
+  const kit: ScopeKit = {
+    ctx,
+    read: (sessionId) => workspaceOf(ctx, registry, sessionId),
+    write: (sessionId) => writeWorkspaceOf(ctx, registry, sessionId),
+  }
+  return {
+    ...readHandlers(kit),
+    ...decideHandlers(kit),
+    ...historyHandlers(kit),
+    ...refreshHandlers(kit),
+  }
+}