dsh-vscode-mode 0.1.10 → 0.1.11

package/src/model.ts

@@ -4,6 +4,7 @@
  * 作者 ddj 2026-08-20
  */
 import type { Decision, DiffRecord, Hunk, RecordSummary } from './shared/types.js'
+import { applyLocations, fingerprint, isNoopHunk, locateHunks, preciseHunk } from './shared/diff.js'
 
 /** 工作区记录桶上限（超过后按 at 最旧剔除）。 */
 export const MAX_RECORDS = 200
@@ -19,22 +20,46 @@ export function normalizeRecord(raw: unknown): DiffRecord | null {
   const r = raw as Record<string, unknown>
   if (typeof r.callId !== 'string' || typeof r.path !== 'string') return null
   const hunks: Hunk[] = Array.isArray(r.hunks)
-    ? (r.hunks as unknown[]).filter((h) => h && typeof (h as { newText?: unknown }).newText === 'string') as Hunk[]
+    ? (r.hunks as unknown[]).filter((h) => h && typeof (h as { newText?: unknown }).newText === 'string').map((h) => {
+      const item = h as Record<string, unknown>
+      return {
+        oldText: typeof item.oldText === 'string' ? item.oldText : null,
+        newText: item.newText as string,
+        ...(Number.isInteger(item.afterStart) ? { afterStart: item.afterStart as number } : {}),
+        ...(Number.isInteger(item.afterEnd) ? { afterEnd: item.afterEnd as number } : {}),
+        ...(Number.isInteger(item.beforeStart) ? { beforeStart: item.beforeStart as number } : {}),
+        ...(Number.isInteger(item.beforeEnd) ? { beforeEnd: item.beforeEnd as number } : {}),
+      }
+    })
     : []
   const toolName: DiffRecord['toolName'] = r.toolName === 'write' ? 'write' : 'edit'
+  const rawDecisions = r.decisions && typeof r.decisions === 'object' ? r.decisions as Record<string, unknown> : {}
+  const call = rawDecisions.call === 'accepted' || rawDecisions.call === 'rejected' ? rawDecisions.call : 'pending'
+  const rawPerHunk = Array.isArray(rawDecisions.perHunk) ? rawDecisions.perHunk : []
+  const perHunk = hunks.map((_, i) => {
+    const value = rawPerHunk[i]
+    if (value === 'accepted' || value === 'rejected') return value
+    return call === 'accepted' || call === 'rejected' ? call : 'pending'
+  })
+  const before = typeof r.before === 'string' ? r.before : null
+  const hasAfter = Object.prototype.hasOwnProperty.call(r, 'after')
+  const after = typeof r.after === 'string' ? r.after : null
   return {
     callId: r.callId,
     toolName,
     path: r.path,
-    before: typeof r.before === 'string' ? r.before : null,
+    before,
+    after,
+    baseFingerprint: typeof r.baseFingerprint === 'string' ? r.baseFingerprint : fingerprint(before),
+    afterFingerprint: typeof r.afterFingerprint === 'string' ? r.afterFingerprint : fingerprint(after),
+    legacy: !hasAfter,
+    conflict: r.conflict === true,
     create: r.create === true,
-    callHunk: r.callHunk && typeof (r.callHunk as { oldText?: unknown }).oldText === 'string'
+    callHunk: r.callHunk && typeof (r.callHunk as { oldText?: unknown }).oldText === 'string' && typeof (r.callHunk as { newText?: unknown }).newText === 'string'
       ? { oldText: (r.callHunk as { oldText: string }).oldText, newText: (r.callHunk as { newText: string }).newText }
       : null,
-    hunks: hunks.map((h) => ({ oldText: typeof h.oldText === 'string' ? h.oldText : null, newText: h.newText })),
-    decisions: r.decisions && typeof r.decisions === 'object'
-      ? r.decisions as DiffRecord['decisions']
-      : { call: 'pending', perHunk: hunks.map(() => 'pending' as Decision) },
+    hunks,
+    decisions: { call: call as Decision, perHunk },
     note: typeof r.note === 'string' ? r.note : null,
     superseded: r.superseded === true,
     archived: r.archived === true,
@@ -68,9 +93,17 @@ export function markDecision(record: DiffRecord, scope: string, idx: number | un
 /** 记录是否已无任何待决策差异（superseded 或全部已决策）。 */
 export function recordResolved(record: DiffRecord): boolean {
   if (record.superseded === true) return true
+  const hunks = Array.isArray(record.hunks) ? record.hunks : []
   const perHunk = Array.isArray(record.decisions.perHunk) ? record.decisions.perHunk : []
-  if (perHunk.length) return perHunk.every((v) => v === 'accepted' || v === 'rejected')
-  return record.decisions.call === 'accepted' || record.decisions.call === 'rejected'
+  const count = Math.max(hunks.length, perHunk.length)
+  if (!count) return record.decisions.call === 'accepted' || record.decisions.call === 'rejected'
+  for (let idx = 0; idx < count; idx++) {
+    const precise = preciseHunk(record, idx)
+    const value = perHunk[idx] ?? record.decisions.call
+    if (isNoopHunk(precise) && value === 'pending') return false
+    if (value !== 'accepted' && value !== 'rejected') return false
+  }
+  return true
 }
 
 /**
@@ -80,20 +113,20 @@ export function recordResolved(record: DiffRecord): boolean {
  * @returns 摘要
  */
 export function recSummary(record: DiffRecord): RecordSummary {
+  const hunks = Array.isArray(record.hunks) ? record.hunks : []
   const perHunk = Array.isArray(record.decisions.perHunk) ? record.decisions.perHunk : []
-  const n = Math.max(1, Array.isArray(record.hunks) ? record.hunks.length : 1)
+  const n = Math.max(1, hunks.length, perHunk.length)
   let accepted = 0
   let rejected = 0
   let pending = 0
-  if (perHunk.length) {
-    for (const v of perHunk) {
-      if (v === 'accepted') accepted++
-      else if (v === 'rejected') rejected++
-      else pending++
-    }
-  } else if (record.decisions.call === 'accepted') accepted = n
-  else if (record.decisions.call === 'rejected') rejected = n
-  else pending = n
+  for (let i = 0; i < n; i++) {
+    const hunk = preciseHunk(record, i)
+    const value = perHunk[i] ?? record.decisions.call
+    if (i < hunks.length && isNoopHunk(hunk) && value === 'pending') continue
+    if (value === 'accepted') accepted++
+    else if (value === 'rejected') rejected++
+    else pending++
+  }
   return { accepted, rejected, pending, superseded: record.superseded === true }
 }
 
@@ -106,27 +139,21 @@ export function recSummary(record: DiffRecord): RecordSummary {
  * @returns 重建内容与 stale 定位
  */
 export function reconstructOriginal(records: DiffRecord[], content: string): { content: string; stale: Array<{ callId: string; idx: number }> } {
-  const pending: Array<{ rec: DiffRecord; idx: number }> = []
+  const pending: Array<{ rec: DiffRecord; idx: number; hunk: Hunk }> = []
   for (const rec of records) {
-    const perHunk = Array.isArray(rec.decisions.perHunk) ? rec.decisions.perHunk : []
     for (let i = 0; i < rec.hunks.length; i++) {
-      const st = perHunk.length ? perHunk[i] : rec.decisions.call
-      if (st === 'pending') pending.push({ rec, idx: i })
+      const st = rec.decisions.perHunk[i] ?? rec.decisions.call
+      const hunk = preciseHunk(rec, i)
+      if (st === 'pending' && hunk && !isNoopHunk(hunk)) pending.push({ rec, idx: i, hunk })
     }
   }
   pending.sort((a, b) => (a.rec.at < b.rec.at ? 1 : a.rec.at > b.rec.at ? -1 : 0))
-  let out = content
-  const stale: Array<{ callId: string; idx: number }> = []
-  for (const p of pending) {
-    const h = p.rec.hunks[p.idx]
-    const precise = p.rec.toolName === 'edit' && p.rec.hunks.length <= 1 && p.rec.callHunk ? p.rec.callHunk : h
-    const newText = precise.newText ?? ''
-    const at = out.indexOf(newText)
-    if (at < 0) { stale.push({ callId: p.rec.callId, idx: p.idx }); continue }
-    const oldText = precise.oldText === null ? '' : precise.oldText
-    out = out.slice(0, at) + oldText + out.slice(at + newText.length)
+  const locations = locateHunks(content, pending.map((item) => item.hunk))
+  const rebuilt = applyLocations(content, locations, true)
+  return {
+    content: rebuilt.content,
+    stale: rebuilt.stale.map((idx) => ({ callId: pending[idx].rec.callId, idx: pending[idx].idx })),
   }
-  return { content: out, stale }
 }
 
 /** 文件当前最大批次号（无记录为 0）。 */
@@ -188,6 +215,11 @@ export function archiveEntryFor(recs: DiffRecord[], cwd: string, reason: string)
       decisions: r.decisions,
       note: r.note ?? null,
       before: typeof r.before === 'string' ? r.before : null,
+      after: typeof r.after === 'string' ? r.after : null,
+      baseFingerprint: r.baseFingerprint ?? null,
+      afterFingerprint: r.afterFingerprint ?? null,
+      conflict: r.conflict === true,
+      legacy: r.legacy === true,
       superseded: r.superseded === true,
       batch: Number.isInteger(r.batch) ? r.batch : null,
       at: r.at,

package/src/revert.ts

@@ -6,6 +6,7 @@
 import type { DiffRecord } from './shared/types.js'
 import type { Ctx, Session } from './store.js'
 import { policyOf, resolveTarget } from './store.js'
+import { applyLocations, locateHunks, preciseHunk } from './shared/diff.js'
 
 export type Result = { ok: true } | { ok: false; error: string }
 
@@ -71,12 +72,18 @@ export async function revertCall(ctx: Ctx, session: Session, record: DiffRecord)
 export async function revertHunk(ctx: Ctx, session: Session, record: DiffRecord, idx: number): Promise<Result> {
   const fs = ctx.get('fs')
   if (!fs) return { ok: false, error: '回滚不可用：缺少 fs' }
-  const hunk = record.hunks[idx]
-  const precise = record.toolName === 'edit' && record.hunks.length <= 1 && record.callHunk ? record.callHunk : hunk
+  const precise = preciseHunk(record, idx)
   if (!precise) return { ok: false, error: '找不到该差异块' }
   try {
     const target = await resolveTarget(ctx, session, record.path)
-    await fs.editText(target, { oldString: precise.newText, newString: precise.oldText === null ? '' : precise.oldText }, void 0, void 0, policyOf(ctx, session))
+    const info = await fs.stat(target)
+    if (!info || info.type !== 'file') return { ok: false, error: '回滚失败：文件不存在' }
+    if ((info.size ?? 0) > 8 * 1024 * 1024) return { ok: false, error: '回滚失败：文件过大，无法安全定位' }
+    const content = await fs.readText(target)
+    const location = locateHunks(content, [precise])[0]
+    if (!location?.matched) return { ok: false, error: '回滚失败：该区域可能已被后续修改影响' }
+    const result = applyLocations(content, [location], true)
+    await fs.writeText(target, result.content, void 0, void 0, policyOf(ctx, session))
     return { ok: true }
   } catch (error) {
     return { ok: false, error: '回滚失败：该区域可能已被后续修改影响（' + String(error) + '）' }

package/src/rpc.ts

@@ -23,6 +23,8 @@ import type { Registry } from './registry.js'
 import { bucketOf, cwdOf, sessionOf } from './registry.js'
 import { listWorkspaceFiles } from './workspace.js'
 import { restoreFile, revertCall, revertHunk } from './revert.js'
+import { listMcp, refreshMcp, removeMcp, saveMcp, toggleMcp } from './mcp.js'
+import { listProjects, projectRefresh, projectRemove, projectSave, projectToggle } from './mcpProject.js'
 
 /** cwd → Promise 链：串行化 debug 日志追加（fs read+write 非原子，避免并发丢行）。 */
 const debugWriteQueues = new Map<string, Promise<void>>()
@@ -40,6 +42,11 @@ function recView(record: DiffRecord): RecordView {
     decisions: record.decisions,
     note: record.note ?? null,
     superseded: record.superseded === true,
+    after: record.after ?? null,
+    baseFingerprint: record.baseFingerprint ?? null,
+    afterFingerprint: record.afterFingerprint ?? null,
+    conflict: record.conflict === true,
+    legacy: record.legacy === true,
     at: record.at,
   }
 }
@@ -275,6 +282,43 @@ export function buildHandlers(ctx: Ctx, registry: Registry): RpcHandlerMap {
       }
       return { ok: true, files, truncated: files.length >= 50 }
     },
+    'mcp.list': async () => ({ ok: true, ...listMcp(ctx) }),
+    'mcp.save': async (args) => {
+      try { return { ok: true, server: await saveMcp(ctx, args.config) } }
+      catch (error) { return { ok: false, error: String(error) } }
+    },
+    'mcp.remove': async (args) => {
+      try { await removeMcp(ctx, args.id); return { ok: true } }
+      catch (error) { return { ok: false, error: String(error) } }
+    },
+    'mcp.toggle': async (args) => {
+      try { return { ok: true, server: await toggleMcp(ctx, args.id, args.enabled) } }
+      catch (error) { return { ok: false, error: String(error) } }
+    },
+    'mcp.refresh': async (args) => {
+      try { return { ok: true, server: await refreshMcp(ctx, args.id) } }
+      catch (error) { return { ok: false, error: String(error) } }
+    },
+    'mcp.projects': async () => {
+      try { return { ok: true, ...await listProjects(ctx) } }
+      catch (error) { return { ok: false, error: String(error) } }
+    },
+    'mcp.projectSave': async (args) => {
+      try { return { ok: true, project: await projectSave(ctx, args.workspacePath, args.serverName, args.config) } }
+      catch (error) { return { ok: false, error: String(error) } }
+    },
+    'mcp.projectRemove': async (args) => {
+      try { return { ok: true, project: await projectRemove(ctx, args.workspacePath, args.serverName) } }
+      catch (error) { return { ok: false, error: String(error) } }
+    },
+    'mcp.projectToggle': async (args) => {
+      try { return { ok: true, project: await projectToggle(ctx, args.workspacePath, args.serverName, args.enabled) } }
+      catch (error) { return { ok: false, error: String(error) } }
+    },
+    'mcp.projectRefresh': async (args) => {
+      try { return { ok: true, project: await projectRefresh(ctx, args.workspacePath, args.serverName) } }
+      catch (error) { return { ok: false, error: String(error) } }
+    },
   }
 }
 

package/src/shared/diff.ts

@@ -0,0 +1,201 @@
+/**
+ * dsh-vscode-mode shared diff primitives — 快照指纹、hunk 规范化与安全定位。
+ * 不依赖 Node/React，host 与 browser 共用，避免各层用不同 indexOf 语义。
+ * 作者 ddj 2026-08-24
+ */
+import type { Hunk, RecordBase } from './types.js'
+
+/** 文件读取状态，区分真实空文件与无法读取/过大的文件。 */
+export type ReadState =
+  | { kind: 'content'; content: string }
+  | { kind: 'missing' }
+  | { kind: 'unavailable' }
+
+/** 文本中的一个半开区间 [start,end)。 */
+export interface TextRange {
+  start: number
+  end: number
+}
+
+/** 一条 hunk 在当前内容中的定位结果。 */
+export interface HunkLocation extends TextRange {
+  idx: number
+  hunk: Hunk
+  matched: boolean
+}
+
+/** 统一取对应 hunk；callHunk 只用于旧记录缺失 hunks 时兼容。 */
+export function preciseHunk(record: Pick<RecordBase, 'hunks' | 'callHunk'>, idx: number): Hunk | null {
+  return hunkOf(record, idx)
+}
+
+/** 轻量、确定性的字符串指纹；不引入 Node crypto。 */
+export function fingerprint(text: string | null | undefined): string | null {
+  if (typeof text !== 'string') return null
+  let hash = 2166136261
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i)
+    hash = Math.imul(hash, 16777619)
+  }
+  return 'fnv1a:' + (hash >>> 0).toString(16) + ':' + text.length
+}
+
+/** 取记录第 idx 个有效 hunk；只有记录缺 hunk 时才回退 callHunk。 */
+export function hunkOf(record: Pick<RecordBase, 'hunks' | 'callHunk'>, idx: number): Hunk | null {
+  const hunk = Array.isArray(record.hunks) ? record.hunks[idx] : undefined
+  if (hunk && typeof hunk.newText === 'string') return hunk
+  if (idx === 0 && record.callHunk && typeof record.callHunk.newText === 'string') return record.callHunk
+  return null
+}
+
+/** hunk 是否表示没有实际内容变化。 */
+export function isNoopHunk(hunk: Hunk | null | undefined): boolean {
+  return !!hunk && hunk.oldText !== null && hunk.oldText === hunk.newText
+}
+
+/** splitLines 的空文本语义：真实空文件没有一行变更内容。 */
+export function splitLines(text: string): string[] {
+  return text.length ? text.split('\n') : []
+}
+
+/** 为执行后 hunk 写入快照坐标；空 newText 通过 before/after 公共边界定位删除点。 */
+export function annotateHunk(hunk: Hunk, before: string | null, after: string | null): Hunk {
+  return annotateHunks([hunk], before, after)[0]
+}
+
+/** 按文件顺序为多 hunk 写入不重复的 after 坐标。 */
+export function annotateHunks(hunks: Hunk[], before: string | null, after: string | null): Hunk[] {
+  if (typeof after !== 'string') return hunks
+  let cursor = 0
+  return hunks.map((hunk) => {
+    if (hunk.newText.length > 0) {
+      const start = after.indexOf(hunk.newText, cursor)
+      if (start >= 0) {
+        cursor = start + hunk.newText.length
+        return { ...hunk, afterStart: start, afterEnd: cursor }
+      }
+      return hunk
+    }
+    if (hunks.length !== 1 || typeof before !== 'string' || before === after || hunk.oldText === null) return hunk
+    const prefix = commonPrefix(before, after)
+    const suffix = commonSuffix(before, after, prefix)
+    const removedStart = prefix
+    const removedEnd = Math.max(removedStart, before.length - suffix)
+    return { ...hunk, afterStart: removedStart, afterEnd: removedStart, beforeStart: removedStart, beforeEnd: removedEnd }
+  })
+}
+
+/** 计算两个文本的最长公共前缀长度。 */
+function commonPrefix(left: string, right: string): number {
+  const limit = Math.min(left.length, right.length)
+  let i = 0
+  while (i < limit && left.charCodeAt(i) === right.charCodeAt(i)) i++
+  return i
+}
+
+/** 计算不与 prefix 重叠的最长公共后缀长度。 */
+function commonSuffix(left: string, right: string, prefix: number): number {
+  const limit = Math.min(left.length, right.length) - prefix
+  let i = 0
+  while (i < limit && left.charCodeAt(left.length - 1 - i) === right.charCodeAt(right.length - 1 - i)) i++
+  return i
+}
+
+/** 计算 index 前的 0 基行数。 */
+export function lineBefore(text: string, index: number): number {
+  let n = 0
+  const end = Math.max(0, Math.min(index, text.length))
+  for (let i = 0; i < end; i++) if (text.charCodeAt(i) === 10) n++
+  return n
+}
+
+/** 找出文本的全部非重叠出现位置。 */
+function allMatches(content: string, needle: string): TextRange[] {
+  if (!needle.length) return []
+  const out: TextRange[] = []
+  let from = 0
+  while (from <= content.length - needle.length) {
+    const at = content.indexOf(needle, from)
+    if (at < 0) break
+    out.push({ start: at, end: at + needle.length })
+    from = at + Math.max(1, needle.length)
+  }
+  return out
+}
+
+/**
+ * 从 after 快照定位所有 hunk，按 hunk 顺序优先选未占用且靠近前一块的候选。
+ * 若 hunk 带 afterStart/afterEnd，则优先验证快照坐标，避免重复文本错配。
+ * @author ddj 2026年08月24号
+ * @param content 当前文件内容
+ * @param hunks 待定位 hunk
+ * @returns 每个 hunk 一个结果，matched=false 表示冲突/stale
+ */
+export function locateHunks(content: string, hunks: Hunk[]): HunkLocation[] {
+  const locations: HunkLocation[] = []
+  let cursor = 0
+  const occupied: TextRange[] = []
+  for (let idx = 0; idx < hunks.length; idx++) {
+    const hunk = hunks[idx]
+    const newText = hunk.newText
+    const snapshot = Number.isInteger(hunk.afterStart) && Number.isInteger(hunk.afterEnd)
+      ? { start: hunk.afterStart as number, end: hunk.afterEnd as number }
+      : null
+    const snapshotMatches = snapshot && snapshot.start >= 0 && snapshot.end >= snapshot.start
+      && (newText.length === 0 || content.slice(snapshot.start, snapshot.end) === newText)
+      ? snapshot
+      : null
+    const candidates = snapshotMatches ? [snapshotMatches] : allMatches(content, newText)
+    const candidate = candidates.find((range) => range.start >= cursor && !occupied.some((used) => overlaps(range, used)))
+      ?? candidates.find((range) => !occupied.some((used) => overlaps(range, used)))
+    if (candidate) {
+      locations.push({ idx, hunk, ...candidate, matched: true })
+      occupied.push(candidate)
+      cursor = Math.max(cursor, candidate.end)
+      continue
+    }
+    if (newText.length === 0 && hunk.afterStart === undefined && hunk.afterEnd === undefined && content.length === 0) {
+      const point = { start: 0, end: 0 }
+      locations.push({ idx, hunk, ...point, matched: true })
+      continue
+    }
+    if (newText.length === 0 && hunk.afterStart !== undefined && hunk.afterEnd !== undefined
+      && hunk.afterStart === hunk.afterEnd && hunk.afterStart >= 0 && hunk.afterStart <= content.length) {
+      const point = { start: hunk.afterStart, end: hunk.afterEnd }
+      if (!occupied.some((used) => overlaps(point, used))) {
+        locations.push({ idx, hunk, ...point, matched: true })
+        occupied.push(point)
+        cursor = Math.max(cursor, point.end)
+        continue
+      }
+    }
+    locations.push({ idx, hunk, start: -1, end: -1, matched: false })
+  }
+  return locations
+}
+
+/** 判断两个半开区间是否重叠。零长度区间只与同一位置的零长度区间重叠。 */
+function overlaps(left: TextRange, right: TextRange): boolean {
+  if (left.start === left.end || right.start === right.end) return left.start === right.start && left.end === right.end
+  return left.start < right.end && right.start < left.end
+}
+
+/** 在可定位区间上执行一次 hunk 反向替换。 */
+export function replaceRange(content: string, location: HunkLocation, reverse = false): string | null {
+  if (!location.matched || location.start < 0) return null
+  const replacement = reverse ? (location.hunk.oldText ?? '') : location.hunk.newText
+  return content.slice(0, location.start) + replacement + content.slice(location.end)
+}
+
+/** 按当前内容中出现的位置从后向前应用 hunk，避免前块长度变化影响后块。 */
+export function applyLocations(content: string, locations: HunkLocation[], reverse = false): { content: string; stale: number[] } {
+  const stale = locations.filter((location) => !location.matched).map((location) => location.idx)
+  let out = content
+  const matched = locations.filter((location) => location.matched).sort((a, b) => b.start - a.start)
+  for (const location of matched) {
+    const next = replaceRange(out, location, reverse)
+    if (next === null) stale.push(location.idx)
+    else out = next
+  }
+  return { content: out, stale: stale.sort((a, b) => a - b) }
+}

package/src/shared/mcp.ts

@@ -0,0 +1,53 @@
+/** dsh-vscode-mode MCP 管理共享数据契约。作者 ddj 2026年08月22号 */
+
+export type MpcTransport = 'stdio' | 'streamable-http'
+export type MpcStatus = 'connected' | 'connecting' | 'error' | 'disabled'
+
+export interface MpcTool {
+  name: string
+  description?: string
+}
+
+export interface MpcConfig {
+  serverName: string
+  transport: MpcTransport
+  command?: string
+  args?: string[]
+  cwd?: string
+  env?: Record<string, string>
+  url?: string
+  headers?: Record<string, string>
+  toolCallTimeoutMs?: number
+  failOnStartupError?: boolean
+  reconnect?: Record<string, unknown>
+}
+
+export interface MpcServer {
+  id: string
+  serverName: string
+  enabled: boolean
+  transport: MpcTransport
+  config: MpcConfig
+  status: MpcStatus
+  toolCount: number
+  tools: MpcTool[]
+  error?: string
+}
+
+/** 项目级 MCP：绑定到一个 workspace 路径，配置存于该项目根 .mcp.json。 */
+export interface MpcProject {
+  workspacePath: string
+  title: string
+  servers: MpcServer[]
+  source: 'project'
+  missingDir?: boolean
+  /** .mcp.json 解析失败时携带错误文案（不覆盖文件）。 */
+  fileError?: string
+}
+
+/** 项目级 MCP 保存入参：config 为该 serverName 的传输配置（不含归属信息）。 */
+export interface MpcProjectSaveInput {
+  workspacePath: string
+  serverName: string
+  config: MpcConfig
+}

package/src/shared/rpc.ts

@@ -12,6 +12,7 @@ import type {
   RecordView,
   StaleHunk,
 } from './types.js'
+import type { MpcConfig, MpcProject, MpcProjectSaveInput, MpcServer } from './mcp.js'
 
 /** webServer 精确路由。 */
 export const RPC_PATH = '/edrv/rpc'
@@ -32,6 +33,16 @@ export interface RpcRequestMap {
   'edrv.rollback': { sessionId?: string; path: string; batch?: number }
   'edrv.debug': { sessionId?: string; text: string }
   'edrv.searchFiles': { sessionId?: string; query: string }
+  'mcp.list': {}
+  'mcp.save': { config: MpcConfig }
+  'mcp.remove': { id: string }
+  'mcp.toggle': { id: string; enabled: boolean }
+  'mcp.refresh': { id: string }
+  'mcp.projects': {}
+  'mcp.projectSave': MpcProjectSaveInput
+  'mcp.projectRemove': { workspacePath: string; serverName: string }
+  'mcp.projectToggle': { workspacePath: string; serverName: string; enabled: boolean }
+  'mcp.projectRefresh': { workspacePath: string; serverName: string }
 }
 
 export type RpcMethod = keyof RpcRequestMap
@@ -49,6 +60,16 @@ export interface RpcOkMap {
   'edrv.rollback': { path: string; batch: number | null }
   'edrv.debug': object
   'edrv.searchFiles': { files: string[]; truncated: boolean }
+  'mcp.list': { servers: MpcServer[] }
+  'mcp.save': { server: MpcServer }
+  'mcp.remove': object
+  'mcp.toggle': { server: MpcServer }
+  'mcp.refresh': { server: MpcServer }
+  'mcp.projects': { projects: MpcProject[] }
+  'mcp.projectSave': { project: MpcProject }
+  'mcp.projectRemove': { project: MpcProject }
+  'mcp.projectToggle': { project: MpcProject }
+  'mcp.projectRefresh': { project: MpcProject }
 }
 
 /** 统一响应：{ok:true, ...payload} 或 {ok:false, error}。 */

package/src/shared/types.ts

@@ -15,6 +15,12 @@ export type Decision = 'pending' | 'accepted' | 'rejected'
 export interface Hunk {
   oldText: string | null
   newText: string
+  /** 执行后快照中的精确范围（可选，旧记录没有）。 */
+  afterStart?: number
+  afterEnd?: number
+  /** 执行前快照中的精确范围（可选，旧记录没有）。 */
+  beforeStart?: number
+  beforeEnd?: number
 }
 
 /** 单条 edit 调用的精确 old/new 串（edit 工具参数原样）。 */
@@ -41,6 +47,15 @@ export interface RecordBase {
   note: string | null
   superseded: boolean
   at: string
+  /** 完整执行后快照；旧 sidecar 缺失时为 undefined。 */
+  after?: string | null
+  /** 执行前/后快照指纹，用于保守冲突判断。 */
+  baseFingerprint?: string | null
+  afterFingerprint?: string | null
+  /** 当前磁盘内容无法安全匹配时保留记录并标记冲突。 */
+  conflict?: boolean
+  /** 记录来自没有快照字段的旧 sidecar。 */
+  legacy?: boolean
 }
 
 /** host 内部完整记录（含持久化专用字段）。 */