dsh-vscode-mode 0.21.0 → 0.21.2

package/src/missingReview.ts

@@ -0,0 +1,127 @@
+/** Missing historical files: frozen, whole-file deletion reviews. */
+import { createHash, randomUUID } from 'node:crypto'
+import { resolve } from 'node:path'
+import type { DiffRecord, MissingReview } from './shared/types.js'
+import type { Ctx, Session } from './store.js'
+import { archiveRecords, policyOf, READ_CAP, resolveTargetIn } from './store.js'
+import { hasOfficial } from './reviewDb.js'
+import { recordResolved } from './model.js'
+
+interface FrozenReview {
+  view: MissingReview
+  cwd: string
+  session: Session
+  revision: string
+  expires: number
+  operation?: { id: string; undo: boolean; restored: boolean; done: boolean }
+}
+const frozen = new Map<string, FrozenReview>()
+const locks = new Set<string>()
+
+/** @private @author ddj 2026年10月28号 @param target Resolved absolute path. @returns Platform file identity. */
+function fileKey(target: string): string {
+  const normalized = resolve(target).replace(/\\/g, '/')
+  return process.platform === 'win32' ? normalized.toLowerCase() : normalized
+}
+
+/** @private @author ddj 2026年10月28号 @param records Ordered records. @returns Full evidence and decision revision, excluding transient conflict flags. */
+function revisionOf(records: DiffRecord[]): string {
+  const evidence = records.map(({ callId, path, at, after, hunks, decisions, archived, superseded }) =>
+    ({ callId, path, at, after, hunks, decisions, archived, superseded }))
+  return createHash('sha256').update(JSON.stringify(evidence)).digest('hex')
+}
+
+/** @private @author ddj 2026年10月28号 @param ctx Host capability. @param cwd Workspace. @param bucket Records. @param target Resolved file. @returns Records for the same physical path spelling, oldest first. */
+async function fileRecords(ctx: Ctx, cwd: string, bucket: Map<string, DiffRecord>, target: string): Promise<DiffRecord[]> {
+  const matches: DiffRecord[] = []
+  const identity = fileKey(target)
+  for (const record of bucket.values()) {
+    if (record.superseded) continue
+    if (fileKey(await resolveTargetIn(ctx, cwd, record.path)) === identity) matches.push(record)
+  }
+  return matches.sort((left, right) => left.at.localeCompare(right.at))
+}
+
+/** @public @author ddj 2026年10月28号 @param ctx Host. @param cwd Workspace. @param path Requested file. @returns True only for confirmed absence; directories and IO failures are not missing files. */
+export async function fileAbsent(ctx: Ctx, cwd: string, path: string): Promise<boolean> {
+  const fs = ctx.get('fs')
+  if (!fs) throw new Error('缺少 fs')
+  const target = await resolveTargetIn(ctx, cwd, path)
+  try { return !(await fs.stat(target)) }
+  catch (error) {
+    if (['ENOENT', 'FS_NOT_FOUND'].includes(String((error as { code?: string }).code))) return true
+    throw error
+  }
+}
+
+/** @public @author ddj 2026年10月28号 @param ctx Host. @param session Live session. @param cwd Workspace. @param bucket Records. @param path Requested file. @returns Frozen complete snapshot; never constructs text from hunks or writes files. @throws Missing evidence or nonmissing target. */
+export async function missingReview(ctx: Ctx, session: Session, cwd: string, bucket: Map<string, DiffRecord>, path: string): Promise<MissingReview> {
+  const target = await resolveTargetIn(ctx, cwd, path)
+  if (hasOfficial(cwd, path) || hasOfficial(cwd, target)) throw new Error('该文件已有官方审查记录，请使用官方审查入口')
+  if (!await fileAbsent(ctx, cwd, target)) throw new Error('文件已重新出现，请刷新')
+  const records = await fileRecords(ctx, cwd, bucket, target)
+  const latest = records.at(-1)
+  if (!records.some((record) => !record.archived && !recordResolved(record))) throw new Error('没有待审历史记录')
+  if (!latest || typeof latest.after !== 'string') throw new Error('缺少可靠的完整历史快照，无法展示或恢复；不会用局部差异拼接文件')
+  if (Buffer.byteLength(latest.after, 'utf8') > READ_CAP) throw new Error('历史快照过大，无法整文件预览')
+
+  for (const [token, item] of frozen) if (item.expires < Date.now()) frozen.delete(token)
+  if (frozen.size >= 256) throw new Error('缺失文件预览过多，请稍后重试')
+  const view: MissingReview = { token: randomUUID(), path, content: latest.after, callIds: records.filter((record) => !record.archived && !recordResolved(record)).map((record) => record.callId), at: latest.at }
+  frozen.set(view.token, { view, cwd, session, revision: revisionOf(records), expires: Date.now() + 30 * 60_000 })
+  return view
+}
+
+/** @private @author ddj 2026年10月28号 @param ctx Host. @param item Frozen evidence. @param target Resolved path. @param undo Restore instead of keeping absence. @sideEffects Atomically creates absent file, verifies exact bytes; retries never overwrite an existing file. */
+async function applyDisk(ctx: Ctx, item: FrozenReview, target: string, undo: boolean): Promise<void> {
+  const fs = ctx.get('fs')
+  const absent = await fileAbsent(ctx, item.cwd, target)
+  if (!undo) { if (!absent) throw new Error('文件已重新出现，未执行 Keep'); return }
+  const operation = item.operation!
+  if (!absent && !operation.restored) throw new Error('文件已重新出现，未执行 Undo')
+  if (absent && !operation.restored) {
+    // Publish through the official capability and session sandbox, never unconditional overwrite.
+    await fs.writeText(target, item.view.content, { kind: 'createIfAbsent' }, undefined, policyOf(ctx, item.session))
+    operation.restored = true
+  }
+  if (absent && operation.restored && !await fs.stat(target)) throw new Error('恢复后的文件再次缺失，未结清记录')
+  if (await fs.readText(target) !== item.view.content) throw new Error('恢复内容校验失败，未结清记录')
+}
+
+/** @public @author ddj 2026年10月28号 @param ctx Host. @param session Requesting session. @param cwd Workspace. @param bucket Records. @param token Frozen preview token. @param operationId Stable retry ID. @param undo True restores shown snapshot; false keeps deletion. @returns Covered call IDs. @throws Changed evidence, concurrent action or sandbox/IO failure. */
+export async function missingDecide(ctx: Ctx, session: Session, cwd: string, bucket: Map<string, DiffRecord>, token: string, operationId: string, undo: boolean): Promise<string[]> {
+  const item = frozen.get(token)
+  if (!item || item.expires < Date.now() || item.cwd !== cwd || item.session.id !== session.id) throw new Error('删除预览已过期，请刷新后重试')
+  if (!operationId || operationId.length > 128) throw new Error('缺少有效操作 ID')
+  const target = await resolveTargetIn(ctx, cwd, item.view.path)
+  const key = JSON.stringify([cwd, fileKey(target)])
+  if (locks.has(key)) throw new Error('该文件正在处理，请稍后重试')
+  locks.add(key)
+  item.session = session
+  try { return await commitMissing(ctx, item, bucket, target, operationId, undo) }
+  finally { locks.delete(key) }
+}
+
+/** @private @author ddj 2026年10月28号 @param ctx Host. @param item Frozen preview. @param bucket Live records. @param target Resolved target. @param operationId Retry identity. @param undo Restore action. @returns Archived pending call IDs; disk success survives bookkeeping failure in the same Host lifetime. */
+async function commitMissing(ctx: Ctx, item: FrozenReview, bucket: Map<string, DiffRecord>, target: string, operationId: string, undo: boolean): Promise<string[]> {
+  const previous = item.operation
+  if (previous && (previous.id !== operationId || previous.undo !== undo)) throw new Error('已有不同操作，请刷新后重试')
+  if (previous?.done) return item.view.callIds
+  if (hasOfficial(item.cwd, target) || hasOfficial(item.cwd, item.view.path)) throw new Error('该文件已有官方审查记录，请刷新')
+  const records = await fileRecords(ctx, item.cwd, bucket, target)
+  if (revisionOf(records) !== item.revision) throw new Error('历史记录已变化，请刷新删除预览')
+  item.operation ??= { id: operationId, undo, restored: false, done: false }
+  await applyDisk(ctx, item, target, undo)
+
+  // Recheck after awaited IO: capture/another review must not silently join this decision.
+  const current = await fileRecords(ctx, item.cwd, bucket, target)
+  if (revisionOf(current) !== item.revision) throw new Error('历史记录已变化，未结清记录，请刷新')
+  const pending = current.filter((record) => item.view.callIds.includes(record.callId))
+  const decisions = pending.map((record) => record.decisions)
+  const decision = undo ? 'rejected' : 'accepted'
+  for (const record of pending) record.decisions = { call: decision, perHunk: record.hunks.map(() => decision) }
+  try { await archiveRecords(ctx, item.session, item.cwd, bucket, pending, undo ? '已恢复删除文件快照' : '已保留文件删除') }
+  catch (error) { pending.forEach((record, index) => { record.decisions = decisions[index] }); throw error }
+  item.operation.done = true
+  return item.view.callIds
+}

package/src/rpc.ts

@@ -60,6 +60,7 @@ import type { FileVersions } from './fileVersions.js'
 import { settingsDocPath } from './settingsDocPath.js'
 import { createTextPages } from './textPages.js'
 import { reviewHandlers } from './reviewRpc.js'
+import { fileAbsent, missingReview, missingDecide } from './missingReview.js'
 
 /** Process-local cursor signer; reads must stay on the Host filesystem capability. */
 const readTextPage = createTextPages()
@@ -169,20 +170,19 @@ async function readTargetOf(
   ctx: Ctx,
   sc: SessionScope,
   path: string,
-): Promise<ReadTargetOk | { err: string; resolvedPath?: string; code?: 'file-too-large' }> {
+): Promise<ReadTargetOk | { err: string; resolvedPath?: string; code?: 'file-too-large' | 'file-missing' }> {
   const fs = ctx.get('fs')
   if (!fs) return { err: '缺少 fs' }
   try {
     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') {
-      // 带上解析后的真实路径：跳转失败时可直接看出是路径解析错还是目标本身不存在
-      return { err: '文件不存在', resolvedPath: fs.processPath(target) }
-    }
+    if (!info) return { err: '文件不存在', resolvedPath: fs.processPath(target), code: 'file-missing' }
+    if (info.type !== 'file') return { err: '目标不是文件', resolvedPath: fs.processPath(target) }
     if ((info.size ?? 0) > BINARY_READ_CAP) return { err: '文件过大（>32MB），不支持整文件预览', code: 'file-too-large' }
     return { target, fs, info }
   } catch (error) {
+    if (['ENOENT', 'FS_NOT_FOUND'].includes(String((error as { code?: string }).code))) return { err: '文件不存在', code: 'file-missing' }
     return { err: '读取失败：' + String(error) }
   }
 }
@@ -193,7 +193,7 @@ async function readTargetOf(
  * @param prep readTargetOf 的失败分支
  * @returns { ok:false } 形态载荷
  */
-function targetErrOf(prep: { err: string; resolvedPath?: string; code?: 'file-too-large' }): { ok: false; error: string; resolvedPath?: string; code?: 'file-too-large' } {
+function targetErrOf(prep: { err: string; resolvedPath?: string; code?: 'file-too-large' | 'file-missing' }): { ok: false; error: string; resolvedPath?: string; code?: 'file-too-large' | 'file-missing' } {
   return { ok: false, error: prep.err,
     ...(prep.resolvedPath !== undefined ? { resolvedPath: prep.resolvedPath } : {}),
     ...(prep.code ? { code: prep.code } : {}) }
@@ -290,6 +290,15 @@ async function applyDecisions(
       results.push({ callId: item.callId, ok: false, error: '记录已归档，无法重复决策' })
       continue
     }
+    try {
+      if (await fileAbsent(ctx, cwd, record.path)) {
+        results.push({ callId: item.callId, ok: false, error: '文件已删除，请刷新后按整文件删除预览执行 Keep / Undo' })
+        continue
+      }
+    } catch (error) {
+      results.push({ callId: item.callId, ok: false, error: '无法确认文件状态：' + String(error) })
+      continue
+    }
     // 重试已执行的决定只补持久化，不能再次修改磁盘上的同一个 hunk。
     const previous = item.scope === 'hunk'
       ? record.decisions.perHunk[item.hunkIndex ?? -1] : record.decisions.call
@@ -693,6 +702,23 @@ export function buildHandlers(
       if (!item?.ok) return { ok: false, error: item?.error ?? '操作失败' }
       return { ok: true, record: item.record! }
     },
+    'edrv.missingReview': async (args) => {
+      const sc = await requireSession(ctx, args.sessionId)
+      if ('err' in sc) return { ok: false, error: sc.err }
+      try {
+        const bucket = await bucketOf(registry, ctx, sc.cwd)
+        if (!await fileAbsent(ctx, sc.cwd, args.path)) return { ok: true, review: null }
+        return { ok: true, review: await missingReview(ctx, sc.session, sc.cwd, bucket, args.path) }
+      } catch (error) { return { ok: false, error: String(error) } }
+    },
+    'edrv.missingDecide': async (args) => {
+      const sc = await requireSession(ctx, args.sessionId)
+      if ('err' in sc) return { ok: false, error: sc.err }
+      try {
+        const bucket = await bucketOf(registry, ctx, sc.cwd)
+        return { ok: true, callIds: await missingDecide(ctx, sc.session, sc.cwd, bucket, args.token, args.operationId, args.undo === true) }
+      } catch (error) { return { ok: false, error: String(error) } }
+    },
     'edrv.decideBatch': async (args) => {
       const sc = await requireSession(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }

package/src/shared/rpc.ts

@@ -377,6 +377,8 @@ export interface RpcRequestMap {
   'edrv.reject': { sessionId?: string; callId: string; scope?: RpcScope; hunkIndex?: number }
   'edrv.decideBatch': { sessionId?: string; items: DecideItem[] }
   'edrv.textPage': import('./textPages.js').TextPageArgs
+  'edrv.missingReview': { sessionId?: string; path: string }
+  'edrv.missingDecide': { sessionId?: string; token: string; operationId: string; undo: boolean }
   'edrv.read': { sessionId?: string; path: string; encoding?: 'base64' }
   'edrv.readBinary': { sessionId?: string; path: string }
   'edrv.versions': { sessionId?: string; paths: string[] }
@@ -549,6 +551,8 @@ export interface RpcOkMap {
   'edrv.reject': { record: RecordView }
   'edrv.decideBatch': { results: DecideResult[] }
   'edrv.textPage': Extract<import('./textPages.js').TextPageResult, { ok: true }>
+  'edrv.missingReview': { review: import('./types.js').MissingReview | null }
+  'edrv.missingDecide': { callIds: string[] }
   'edrv.read': { content: string; size: number; encoding?: 'base64'; mime?: string; version?: string }
   'edrv.readBinary': { binary: BinaryReadPayload }
   'edrv.versions': { items: FileVersionItem[] }
@@ -707,7 +711,7 @@ export interface RpcOkMap {
 /** 统一响应：{ok:true, ...payload} 或 {ok:false, error}。 */
 export type RpcResult<M extends RpcMethod> =
   | ({ ok: true } & RpcOkMap[M])
-  | { ok: false; error: string; code?: 'file-too-large'; reason?: Extract<import('./textPages.js').TextPageResult, { ok: false }>['reason'] }
+  | { ok: false; error: string; code?: 'file-too-large' | 'file-missing'; reason?: Extract<import('./textPages.js').TextPageResult, { ok: false }>['reason'] }
 
 /** 每个方法的 handler 签名（host 分发表与 client 类型检查共用）。 */
 export type RpcHandler<M extends RpcMethod> = (

package/src/shared/types.ts

@@ -8,6 +8,15 @@
  * 作者 ddj 2026-08-20
  */
 
+/** Frozen whole-file deletion preview, backed by a complete Host snapshot. */
+export interface MissingReview {
+  token: string
+  path: string
+  content: string
+  callIds: string[]
+  at: string
+}
+
 /** 单条差异块的决策状态。 */
 export type Decision = 'pending' | 'accepted' | 'rejected'