dsh-vscode-mode 0.23.1 → 0.23.3

package/lib/index.js

@@ -7649,6 +7649,25 @@ function reviewPage(cwd, cursor = 0, history = false, path) {
 		}))]
 	};
 }
+/**
+* @public
+* @author ddj 2026年10月31号
+* @description: 该文件是否还有未处理的官方待审改动。缺失文件预览据此区分「需要去差异栏 Keep 结案」
+* 与「记录都已处理、可直接关闭标签页」，避免已结案的删除文件继续提示待审。
+* @param cwd Migrated workspace
+* @param path Host path of the file
+* @returns 存在未决官方记录时为 true
+*/
+function officialPending(cwd, path) {
+	if (typeof path !== "string") return false;
+	const db = dbFor(cwd);
+	if (!db.prepare("SELECT 1 FROM sqlite_master WHERE name='review_files' AND type='table'").get()) return false;
+	if (path.length > 1 && path[1] === ":") {
+		const folded = path.split(String.fromCharCode(92)).join("/").toLowerCase();
+		return !!db.prepare("SELECT 1 FROM review_files WHERE current=1 AND decision='pending' AND lower(replace(identity,char(92),'/'))=? LIMIT 1").get(folded);
+	}
+	return !!db.prepare("SELECT 1 FROM review_files WHERE current=1 AND decision='pending' AND identity=? LIMIT 1").get(path);
+}
 /** @public @author ddj 2026年10月26号 @param cwd Migrated workspace. @param path Legacy write target. @returns Whether any official version owns the file, including decided history. */
 function hasOfficial(cwd, path) {
 	if (typeof path !== "string") return false;
@@ -7926,20 +7945,31 @@ function installCapture(ctx, onSnapshot) {
 			log.warn("官方历史补采不可用：缺少 sessionQuery；后续实时事件仍会采集");
 			return;
 		}
+		const source = ctx.get("workspaceChanges");
+		if (!source?.summary) {
+			log.warn("官方历史补采不可用：缺少 workspaceChanges；后续实时事件仍会采集");
+			return;
+		}
 		try {
 			if (session.header?.cwd) {
 				await loadBucket(ctx, session.header.cwd);
 				await repairPaths(session.header.cwd, resolvePath);
 			}
 			const events = await query.listEvents(session.id);
+			let expired = 0;
 			for (const event of events) {
 				if (event.type !== "workspace/changes" || event.seq < (session.inheritedEventCount ?? 0)) continue;
+				if (!source.summary(session.id, event.seq)) {
+					expired += 1;
+					continue;
+				}
 				const window = await query.readEvent({
 					sessionId: session.id,
 					seq: event.seq
 				});
 				collector.enqueue(session, window.target);
 			}
+			if (expired) log.info(`官方历史补采跳过 ${expired} 轮已失效事件：官方 summary 不跨宿主重启保留，实时事件照常采集`);
 		} catch (error) {
 			log.warn("官方历史补采失败：" + String(error));
 		}
@@ -15971,6 +16001,10 @@ function finishUndo(cwd, request) {
 //#region src/reviewRpc.ts
 /** 批量写入快照的硬上限：待审积压超过它说明状态异常，宁可拒绝也不做无界写循环。 */
 const BATCH_LIMIT = 2e3;
+/** 冷端 Undo 说明：Undo 会校验证据并写回源文件，只能在持有该会话的那一端执行。 */
+const UNDO_NEEDS_LIVE = "Undo 需要在本端活跃的会话上执行：该会话当前在另一端（Web / 桌面）激活。Keep 不受影响，可在任一端执行；或在本端打开该会话后重试。";
+/** 冷端待审判定说明：待审库是按工作区的本地存储，判定需要与正在编辑的那一端保持一致。 */
+const PENDING_NEEDS_LIVE = "待审条目的判定需要在本端活跃的会话上执行：该会话当前在另一端激活，请在那一端处理，或在本端打开该会话后重试。";
 /**
 * @private
 * @author ddj 2026年10月31号
@@ -16011,6 +16045,39 @@ function batchSnapshot(cwd, pending) {
 	};
 }
 /**
+* @private
+* @author ddj 2026年10月31号
+* @description: 文件已在磁盘删除时修正官方记录的能力说明。Keep 只写审查库、仍可结案，
+* Undo 需要读写源文件、必然不可用：把「缺少原始字节」这种误导性原因换成可执行说明。
+* 只改文案与 undo 位，不参与判定写入。
+* @param ctx Host 能力
+* @param cwd 工作区
+* @param detail 官方记录详情
+* @param capability 已按冷/热端调整过的能力
+* @returns 修正后的能力；无法确认删除时原样返回
+*/
+async function absenceCapability(ctx, cwd, detail, capability) {
+	if (!capability.keep) return capability;
+	if (detail.diff.kind === "text" && !detail.diff.after) return {
+		...capability,
+		undo: false,
+		reason: "该记录删除了这个文件：Keep 按删除结案；Undo 需要完整文件内容，官方差异只有片段，不可用。"
+	};
+	const fs = ctx.get("fs");
+	if (!fs) return capability;
+	try {
+		const target = await resolveTargetIn(ctx, cwd, detail.item.currentPath);
+		if (await fs.stat(target)) return capability;
+	} catch {
+		return capability;
+	}
+	return {
+		...capability,
+		undo: false,
+		reason: "文件已在磁盘删除：Keep 按删除结案；Undo 需要读写该文件，当前不可用。"
+	};
+}
+/**
 * @public
 * @author ddj 2026年10月26号 / 2026年10月28号
 * @description: 审查 RPC 处理器。工作区一律由 host 解析，绝不采信调用方 cwd：
@@ -16020,19 +16087,61 @@ function batchSnapshot(cwd, pending) {
 * @returns 审查相关处理器表
 */
 function reviewHandlers(ctx, registry) {
-	/** @private @author ddj 2026年10月28号 @param sessionId 请求作用域 @returns 已迁移工作区（允许跨实例冷读） */
-	async function workspace(sessionId) {
+	/**
+	* @private
+	* @author ddj 2026年10月31号
+	* @description: 解析会话作用域，并标明本端是否持有该会话的活跃实例。
+	* 工作区一律由 host 解析，绝不采信调用方 cwd；冷读作用域只带 cwd，不带会话实例。
+	* @param sessionId 请求作用域
+	* @returns 已迁移工作区与活跃标记
+	* @throws 会话不存在、会话无工作区或活跃库迁移未完成
+	*/
+	async function scopeOf(sessionId) {
 		const scope = await resolveScope(ctx, sessionId);
 		if ("err" in scope) throw new Error("会话不存在或没有工作区");
 		await bucketOf(registry, ctx, scope.cwd);
-		return scope.cwd;
+		return {
+			cwd: scope.cwd,
+			live: !!scope.session
+		};
 	}
-	/** @private @author ddj 2026年10月28号 @param sessionId 请求作用域 @returns 本端 live 会话的工作区；冷读作用域一律拒绝写入 */
-	async function liveWorkspace(sessionId) {
-		const scope = await resolveScope(ctx, sessionId);
-		if ("err" in scope || !scope.session) throw new Error("会话不存在或没有工作区");
-		await bucketOf(registry, ctx, scope.cwd);
-		return scope.cwd;
+	/**
+	* @private
+	* @author ddj 2026年10月31号
+	* @description: 本端是否持有该会话的活跃实例（纯诊断用，不解析工作区）。
+	* @param sessionId 请求作用域
+	* @returns 本端加载了该会话时为 true
+	*/
+	function liveOf(sessionId) {
+		return !!sessionOf(ctx, sessionId);
+	}
+	/**
+	* @private
+	* @author ddj 2026年10月31号
+	* @description: 按本端是否活跃覆写面板能力位。活跃端保持数据库结论；
+	* 冷端关闭依赖会话的操作（Undo、待审判定）并给出跨端原因，Keep 仍按数据库结论放行。
+	* @param capability 数据库推导的能力位
+	* @param live 本端是否持有活跃会话
+	* @param pending 是否为待审投影条目
+	* @returns 面板可用的能力位
+	*/
+	function liveCapabilityOf(capability, live, pending) {
+		if (live) return {
+			...capability,
+			live: true
+		};
+		if (pending) return {
+			keep: false,
+			undo: false,
+			reason: PENDING_NEEDS_LIVE,
+			live: false
+		};
+		return {
+			...capability,
+			undo: false,
+			live: false,
+			reason: capability.undo ? UNDO_NEEDS_LIVE : capability.reason
+		};
 	}
 	/**
 	* @private
@@ -16045,7 +16154,11 @@ function reviewHandlers(ctx, registry) {
 	*/
 	function pendingPageOf(cwd, sessionId) {
 		try {
-			return loadPage(cwd, sessionId);
+			const page = loadPage(cwd, sessionId);
+			return page.items.some((item) => item.settled === true) ? {
+				...page,
+				items: page.items.filter((item) => item.settled !== true)
+			} : page;
 		} catch {
 			return {
 				items: [],
@@ -16057,7 +16170,7 @@ function reviewHandlers(ctx, registry) {
 	}
 	return {
 		"edrv.review.list": async (args) => {
-			const cwd = await workspace(args.sessionId);
+			const { cwd } = await scopeOf(args.sessionId);
 			if (args.all && !args.history && args.path === void 0) return batchSnapshot(cwd, pendingPageOf(cwd, args.sessionId));
 			const official = reviewPage(cwd, args.cursor, args.history, args.path);
 			const pending = pendingPageOf(cwd, args.sessionId);
@@ -16077,63 +16190,97 @@ function reviewHandlers(ctx, registry) {
 					}
 				};
 			}
+			const merged = mergedPage(official, pending, cwd);
+			log.debug(`[review] list live=${liveOf(args.sessionId) ? 1 : 0} path=${args.path ?? "(all)"} items=${merged.items.length} pending=${merged.pending} covered=${merged.overview?.coveredPaths.length ?? -1}`);
 			return {
 				ok: true,
-				page: mergedPage(official, pending, cwd)
+				page: merged
 			};
 		},
 		"edrv.review.detail": async (args) => {
-			const cwd = await workspace(args.sessionId);
+			const scope = await scopeOf(args.sessionId);
+			const cwd = scope.cwd;
 			if (args.id.startsWith("pending:")) {
 				const detail = loadDetail(cwd, args.id.slice(8));
 				if (!detail) return {
 					ok: false,
 					error: "待审条目不存在"
 				};
+				const mapped = pendingDetailOf(detail, new Date(detail.item.updatedAt).toISOString(), cwd);
 				return {
 					ok: true,
-					detail: pendingDetailOf(detail, new Date(detail.item.updatedAt).toISOString(), cwd)
+					detail: {
+						...mapped,
+						capability: liveCapabilityOf(mapped.capability, scope.live, true)
+					}
 				};
 			}
 			const detail = reviewDetail(cwd, args.id);
-			return detail ? {
+			if (!detail) {
+				log.debug(`[review] detail live=${scope.live ? 1 : 0} id=${args.id} found=0`);
+				return {
+					ok: false,
+					error: "官方审查记录不存在"
+				};
+			}
+			const capability = await absenceCapability(ctx, cwd, detail, liveCapabilityOf(detail.capability, scope.live, false));
+			log.debug(`[review] detail live=${scope.live ? 1 : 0} id=${args.id} found=1 keep=${capability.keep ? 1 : 0} undo=${capability.undo ? 1 : 0}`);
+			return {
 				ok: true,
-				detail
-			} : {
-				ok: false,
-				error: "官方审查记录不存在"
+				detail: {
+					...detail,
+					capability
+				}
 			};
 		},
 		"edrv.review.decide": async (args) => {
-			const cwd = await liveWorkspace(args.sessionId);
-			if (args.id.startsWith("pending:")) {
-				const result = await applyDecide(ctx.get("fs"), cwd, {
-					sessionId: args.sessionId,
-					id: args.id.slice(8),
-					revision: args.revision,
-					operationId: args.operationId,
-					decision: args.decision,
-					scope: args.scope === "hunk" ? "block" : "file",
-					...args.blockId === void 0 ? {} : { blockId: args.blockId }
-				});
-				if (!result.ok) return {
-					ok: false,
-					error: result.reason
-				};
-				return {
-					ok: true,
-					revision: result.flags.revision
-				};
-			}
 			try {
+				const scope = await scopeOf(args.sessionId);
+				if (args.id.startsWith("pending:")) {
+					if (!scope.live) return {
+						ok: false,
+						error: PENDING_NEEDS_LIVE
+					};
+					const result = await applyDecide(ctx.get("fs"), scope.cwd, {
+						sessionId: args.sessionId,
+						id: args.id.slice(8),
+						revision: args.revision,
+						operationId: args.operationId,
+						decision: args.decision,
+						scope: args.scope === "hunk" ? "block" : "file",
+						...args.blockId === void 0 ? {} : { blockId: args.blockId }
+					});
+					if (!result.ok) return {
+						ok: false,
+						error: result.reason
+					};
+					return {
+						ok: true,
+						revision: result.flags.revision
+					};
+				}
+				if (args.decision === "rejected") {
+					if (!scope.live) return {
+						ok: false,
+						error: UNDO_NEEDS_LIVE
+					};
+					return {
+						ok: true,
+						...await undoReview(ctx, sessionOf(ctx, args.sessionId), scope.cwd, args)
+					};
+				}
+				const result = decideReview(scope.cwd, args);
+				if (!scope.live) log.info(`[review] 冷端 Keep 官方记录 ${args.id}`);
 				return {
 					ok: true,
-					...args.decision === "rejected" ? await undoReview(ctx, sessionOf(ctx, args.sessionId), cwd, args) : decideReview(cwd, args)
+					...result
 				};
 			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				log.warn(`[review] decide 失败 id=${args.id} decision=${args.decision}: ${message}`);
 				return {
 					ok: false,
-					error: error instanceof Error ? error.message : String(error)
+					error: message
 				};
 			}
 		}
@@ -16386,6 +16533,29 @@ function pendingHandlers(ctx, registry) {
 /** Missing historical files: frozen, whole-file deletion reviews. */
 const frozen = /* @__PURE__ */ new Map();
 const locks = /* @__PURE__ */ new Set();
+/**
+* @public
+* @author ddj 2026年10月31号
+* @description: 给缺失文件预览的可预期拒绝挂稳定错误码。客户端据此显示终态说明，
+* 而不是把内部错误原文当「加载失败」反复重试；也不让上游把 SQLite 报错原文透给编辑器。
+* @param code 稳定错误码（official-covered / no-records / no-evidence / too-large）
+* @param message 可读原因
+* @returns 带 code 的 Error
+*/
+function refusal(code, message) {
+	return Object.assign(new Error(message), { code });
+}
+/**
+* @public
+* @author ddj 2026年10月31号
+* @description: 从任意错误里取回缺失文件预览的稳定拒绝码；不是本模块抛出的错误一律返回 undefined。
+* @param error 捕获到的错误
+* @returns 稳定拒绝码或 undefined
+*/
+function refusalCodeOf(error) {
+	const code = error?.code;
+	return code === "official-covered" || code === "official-decided" || code === "no-records" || code === "no-evidence" || code === "too-large" ? code : void 0;
+}
 /** @private @author ddj 2026年10月28号 @param target Resolved absolute path. @returns Platform file identity. */
 function fileKey(target) {
 	const normalized = resolve(target).replace(/\\/g, "/");
@@ -16436,13 +16606,16 @@ async function fileAbsent(ctx, cwd, path) {
 async function missingReview(ctx, session, cwd, bucket, path) {
 	const abs = targetPathOf(ctx, await resolveTargetIn(ctx, cwd, path));
 	if (!abs) throw new Error("无法解析目标文件路径");
-	if (hasOfficial(cwd, path) || hasOfficial(cwd, abs)) throw new Error("该文件已有官方审查记录，请使用官方审查入口");
+	if (hasOfficial(cwd, path) || hasOfficial(cwd, abs)) {
+		if (!officialPending(cwd, abs) && !officialPending(cwd, path)) throw refusal("official-decided", "该文件已在磁盘删除，官方审查记录均已处理：可直接关闭该标签页");
+		throw refusal("official-covered", "该文件已有官方审查记录（磁盘上已删除）：请在差异栏对该待审条目执行 Keep 结案；整文件删除预览只适用于待审历史记录");
+	}
 	if (!await fileAbsent(ctx, cwd, abs)) throw new Error("文件已重新出现，请刷新");
 	const records = await fileRecords(ctx, cwd, bucket, abs);
 	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") > 8388608) throw new Error("历史快照过大，无法整文件预览");
+	if (!records.some((record) => !record.archived && !recordResolved(record))) throw refusal("no-records", "磁盘上已没有该文件，且没有待审历史记录：可直接关闭该标签页");
+	if (!latest || typeof latest.after !== "string") throw refusal("no-evidence", "磁盘上已没有该文件，且缺少可靠的完整历史快照，无法展示或恢复；不会用局部差异拼接文件");
+	if (Buffer.byteLength(latest.after, "utf8") > 8388608) throw refusal("too-large", "磁盘上已没有该文件，且历史快照过大，无法整文件预览");
 	for (const [token, item] of frozen) if (item.expires < Date.now()) frozen.delete(token);
 	if (frozen.size >= 256) throw new Error("缺失文件预览过多，请稍后重试");
 	const view = {
@@ -17232,9 +17405,11 @@ function buildHandlers(ctx, registry, searcher = newSearcher(ctx), contentSearch
 					review: await missingReview(ctx, sc.session, sc.cwd, bucket, args.path)
 				};
 			} catch (error) {
+				const code = refusalCodeOf(error);
 				return {
 					ok: false,
-					error: String(error)
+					error: String(error),
+					...code ? { code } : {}
 				};
 			}
 		},