code-server-sync 0.0.0-stage → 0.1.0

package/cs_sync/git.py

@@ -0,0 +1,683 @@
+from __future__ import annotations
+
+import base64
+import os
+import subprocess
+import tempfile
+import urllib.error
+from typing import Dict, Optional, Tuple
+
+from cs_sync.files import file_mode, sha256_bytes
+from cs_sync.ignore import IGNORE_PREFIXES, PathIgnore, load_path_ignore, should_skip
+from cs_sync.protocol import MAX_BYTES, eprint
+
+class StageError(Exception):
+    pass
+
+
+def is_git_repo(path: str) -> bool:
+    git_path = os.path.join(path, ".git")
+    return os.path.isdir(git_path) or os.path.isfile(git_path)
+
+
+def git_repos(root: str, ignored: set, path_ignore: PathIgnore = None) -> list:
+    root = os.path.abspath(root)
+    if path_ignore is None:
+        path_ignore = load_path_ignore(root)
+    if is_git_repo(root):
+        return [root]
+    found = []
+    if not os.path.isdir(root):
+        return found
+    for dirpath, dirnames, _filenames in os.walk(root):
+        kept = []
+        for name in dirnames:
+            if name in ignored or name == ".git" or name.startswith(IGNORE_PREFIXES):
+                continue
+            rel_dir = os.path.relpath(os.path.join(dirpath, name), root).replace(os.sep, "/")
+            if should_skip(rel_dir, ignored, path_ignore, is_dir=True):
+                continue
+            full = os.path.join(dirpath, name)
+            if is_git_repo(full):
+                found.append(full)
+                continue
+            kept.append(name)
+        dirnames[:] = kept
+    return found
+
+
+def git_run(repo: str, args: list) -> subprocess.CompletedProcess:
+    env = dict(os.environ)
+    env["GIT_TERMINAL_PROMPT"] = "0"
+    try:
+        return subprocess.run(
+            ["git", "-C", repo] + args,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=False,
+            env=env,
+        )
+    except OSError as exc:
+        raise StageError("找不到 git 命令：%s" % exc)
+
+
+def stage_changes(root: str, ignored: set) -> Tuple[list, int]:
+    repos = git_repos(root, ignored, load_path_ignore(root))
+    if not repos:
+        print("项目里没有 git 仓库，跳过暂存。", flush=True)
+        return [], 0
+    staged = []
+    for repo in repos:
+        rel = os.path.relpath(repo, os.path.abspath(root)).replace(os.sep, "/")
+        status = git_run(repo, ["status", "--porcelain", "--untracked-files=all"])
+        if status.returncode != 0:
+            detail = status.stderr.decode("utf-8", errors="replace").strip()
+            raise StageError("暂存失败 %s ：%s" % (rel, detail or "git status 失败"))
+        if not status.stdout.strip():
+            continue
+        added = git_run(repo, ["add", "-A"])
+        if added.returncode != 0:
+            detail = added.stderr.decode("utf-8", errors="replace").strip()
+            raise StageError("暂存失败 %s ：%s" % (rel, detail or "git add -A 失败"))
+        print("暂存 %s" % rel, flush=True)
+        staged.append(rel)
+    if not staged:
+        print("没有需要暂存的修改。", flush=True)
+    return staged, len(repos)
+
+
+def git_bytes(repo: str, args: list) -> bytes:
+    result = git_run(repo, ["-c", "core.quotepath=false"] + args)
+    if result.returncode != 0:
+        detail = result.stderr.decode("utf-8", errors="replace").strip()
+        raise StageError(detail or "git 命令失败")
+    return result.stdout
+
+
+def parse_name_status(raw: bytes) -> list:
+    parts = raw.split(b"\0")
+    found = []
+    index = 0
+    while index + 1 < len(parts) and parts[index]:
+        status = parts[index].decode("utf-8", errors="strict")
+        path = parts[index + 1].decode("utf-8", errors="strict")
+        found.append((status[:1], path.replace("\\", "/")))
+        index += 2
+    return found
+
+
+def project_rel(prefix: str, path: str) -> str:
+    path = path.replace("\\", "/")
+    if prefix in ("", "."):
+        return path
+    return prefix + "/" + path
+
+
+def encode_bytes(payload: bytes) -> str:
+    return base64.b64encode(payload).decode("ascii")
+
+
+def decode_bytes(value: str) -> bytes:
+    return base64.b64decode(value.encode("ascii"))
+
+
+def collect_changes(root: str, ignored: set) -> Tuple[list, int]:
+    path_ignore = load_path_ignore(root)
+    repos = git_repos(root, ignored, path_ignore)
+    changes = []
+    seen = set()
+    for repo in repos:
+        prefix = os.path.relpath(repo, os.path.abspath(root)).replace(os.sep, "/")
+        has_head = git_run(repo, ["rev-parse", "--verify", "HEAD"]).returncode == 0
+        diff_base = ["diff", "HEAD", "--no-renames"] if has_head else ["diff", "--cached", "--no-renames"]
+        listed = parse_name_status(git_bytes(repo, diff_base + ["--name-status", "-z"]))
+        for status, path in listed:
+            rel = project_rel(prefix, path)
+            if should_skip(rel, ignored, path_ignore) or rel in seen:
+                continue
+            full = os.path.join(repo, *path.split("/"))
+            if status == "D":
+                patch = git_bytes(repo, diff_base + ["-U3", "--", path])
+                changes.append({"path": rel, "repoPath": path, "kind": "delete", "patch": encode_bytes(patch)})
+                seen.add(rel)
+                continue
+            if os.path.islink(full) or not os.path.isfile(full):
+                continue
+            if os.path.getsize(full) > MAX_BYTES:
+                changes.append({"path": rel, "repoPath": path, "kind": "binary"})
+                seen.add(rel)
+                continue
+            numstat = git_bytes(repo, diff_base + ["--numstat", "-z", "--", path])
+            if numstat.startswith(b"-\t-\t"):
+                if status == "A":
+                    with open(full, "rb") as handle:
+                        payload = handle.read()
+                    changes.append({
+                        "path": rel,
+                        "repoPath": path,
+                        "kind": "add",
+                        "mode": file_mode(full),
+                        "content": encode_bytes(payload),
+                    })
+                else:
+                    changes.append({"path": rel, "repoPath": path, "kind": "binary"})
+                seen.add(rel)
+                continue
+            if status == "A":
+                with open(full, "rb") as handle:
+                    payload = handle.read()
+                changes.append({
+                    "path": rel,
+                    "repoPath": path,
+                    "kind": "add",
+                    "mode": file_mode(full),
+                    "content": encode_bytes(payload),
+                })
+                seen.add(rel)
+                continue
+            patch = git_bytes(repo, diff_base + ["-U3", "--", path])
+            with open(full, "rb") as handle:
+                payload = handle.read()
+            changes.append({
+                "path": rel,
+                "repoPath": path,
+                "kind": "modify",
+                "mode": file_mode(full),
+                "patch": encode_bytes(patch),
+                "content": encode_bytes(payload),
+            })
+            seen.add(rel)
+        others = git_bytes(repo, ["ls-files", "--others", "--exclude-standard", "-z"])
+        for raw in others.split(b"\0"):
+            if not raw:
+                continue
+            path = raw.decode("utf-8").replace("\\", "/")
+            rel = project_rel(prefix, path)
+            full = os.path.join(repo, *path.split("/"))
+            if should_skip(rel, ignored, path_ignore) or rel in seen or os.path.islink(full) or not os.path.isfile(full):
+                continue
+            if os.path.getsize(full) > MAX_BYTES:
+                continue
+            with open(full, "rb") as handle:
+                payload = handle.read()
+            changes.append({
+                "path": rel,
+                "repoPath": path,
+                "kind": "add",
+                "mode": file_mode(full),
+                "content": encode_bytes(payload),
+            })
+            seen.add(rel)
+    return changes, len(repos)
+
+
+def find_repo_for_rel(root: str, rel: str) -> Tuple[Optional[str], str, str]:
+    """返回 (repo绝对路径, 项目内repo前缀, repo内相对路径)。找不到则 (None, '', '')."""
+    root = os.path.abspath(root)
+    full = os.path.join(root, *rel.split("/"))
+    start = full if os.path.isdir(full) else os.path.dirname(full)
+    cur = start
+    while True:
+        if is_git_repo(cur):
+            prefix = os.path.relpath(cur, root).replace(os.sep, "/")
+            if prefix == ".":
+                return cur, "", rel
+            if rel == prefix:
+                return cur, prefix, ""
+            if rel.startswith(prefix + "/"):
+                return cur, prefix, rel[len(prefix) + 1 :]
+            return None, "", ""
+        if cur == root:
+            break
+        parent = os.path.dirname(cur)
+        if parent == cur:
+            break
+        cur = parent
+    if is_git_repo(root):
+        return root, "", rel
+    return None, "", ""
+
+
+def collect_path_change(root: str, ignored: set, rel: str) -> Optional[dict]:
+    """只收集某一个项目相对路径相对 HEAD（或无 HEAD 时相对 index）的行级变更。"""
+    path_ignore = load_path_ignore(root)
+    if should_skip(rel, ignored, path_ignore):
+        return None
+    repo, prefix, repo_path = find_repo_for_rel(root, rel)
+    if not repo or not repo_path:
+        return None
+    has_head = git_run(repo, ["rev-parse", "--verify", "HEAD"]).returncode == 0
+    diff_base = ["diff", "HEAD", "--no-renames"] if has_head else ["diff", "--cached", "--no-renames"]
+    full = os.path.join(repo, *repo_path.split("/"))
+    listed = parse_name_status(git_bytes(repo, diff_base + ["--name-status", "-z", "--", repo_path]))
+    status = None
+    for item_status, item_path in listed:
+        if item_path.replace("\\", "/") == repo_path:
+            status = item_status
+            break
+    if status == "D" or (status is None and not os.path.exists(full)):
+        # 可能是已跟踪删除
+        if status == "D":
+            patch = git_bytes(repo, diff_base + ["-U3", "--", repo_path])
+            return {"path": rel, "repoPath": repo_path, "kind": "delete", "patch": encode_bytes(patch)}
+        # 未跟踪且文件不在，不算变更
+        tracked = git_run(repo, ["ls-files", "--", repo_path])
+        if tracked.returncode == 0 and tracked.stdout.strip():
+            patch = git_bytes(repo, diff_base + ["-U3", "--", repo_path])
+            return {"path": rel, "repoPath": repo_path, "kind": "delete", "patch": encode_bytes(patch)}
+        return None
+    if status is None:
+        # 未跟踪新文件
+        others = git_run(repo, ["ls-files", "--others", "--exclude-standard", "-z", "--", repo_path])
+        if others.returncode != 0 or repo_path.encode("utf-8") not in others.stdout.split(b"\0"):
+            # 也可能路径恰好匹配
+            found = False
+            for raw in others.stdout.split(b"\0"):
+                if raw.decode("utf-8", errors="replace").replace("\\", "/") == repo_path:
+                    found = True
+                    break
+            if not found:
+                return None
+        if os.path.islink(full) or not os.path.isfile(full):
+            return None
+        if os.path.getsize(full) > MAX_BYTES:
+            return None
+        with open(full, "rb") as handle:
+            payload = handle.read()
+        return {
+            "path": rel,
+            "repoPath": repo_path,
+            "kind": "add",
+            "mode": file_mode(full),
+            "content": encode_bytes(payload),
+        }
+    if os.path.islink(full) or not os.path.isfile(full):
+        return None
+    if os.path.getsize(full) > MAX_BYTES:
+        return {"path": rel, "repoPath": repo_path, "kind": "binary"}
+    numstat = git_bytes(repo, diff_base + ["--numstat", "-z", "--", repo_path])
+    if numstat.startswith(b"-\t-\t"):
+        if status == "A":
+            with open(full, "rb") as handle:
+                payload = handle.read()
+            return {
+                "path": rel,
+                "repoPath": repo_path,
+                "kind": "add",
+                "mode": file_mode(full),
+                "content": encode_bytes(payload),
+            }
+        return {"path": rel, "repoPath": repo_path, "kind": "binary"}
+    if status == "A":
+        with open(full, "rb") as handle:
+            payload = handle.read()
+        return {
+            "path": rel,
+            "repoPath": repo_path,
+            "kind": "add",
+            "mode": file_mode(full),
+            "content": encode_bytes(payload),
+        }
+    patch = git_bytes(repo, diff_base + ["-U3", "--", repo_path])
+    with open(full, "rb") as handle:
+        payload = handle.read()
+    return {
+        "path": rel,
+        "repoPath": repo_path,
+        "kind": "modify",
+        "mode": file_mode(full),
+        "patch": encode_bytes(patch),
+        "content": encode_bytes(payload),
+    }
+
+
+def unified_diff_patch(old: bytes, new: bytes, repo_path: str) -> bytes:
+    """生成可被 git apply 的 unified diff（保留原始换行；正确处理无结尾换行）。"""
+    import difflib
+    import re
+    old_text = old.decode("utf-8")
+    new_text = new.decode("utf-8")
+
+    def split_keep(text: str):
+        if text == "":
+            return []
+        return text.splitlines(keepends=True)
+
+    def missing_final_nl(lines) -> bool:
+        return bool(lines) and not (lines[-1].endswith("\n") or lines[-1].endswith("\r"))
+
+    old_lines = split_keep(old_text)
+    new_lines = split_keep(new_text)
+    old_missing = missing_final_nl(old_lines)
+    new_missing = missing_final_nl(new_lines)
+    # 行已带原始换行（含 CRLF）；lineterm 必须为空，避免重复追加
+    parts = list(
+        difflib.unified_diff(
+            old_lines,
+            new_lines,
+            fromfile="a/" + repo_path,
+            tofile="b/" + repo_path,
+            lineterm="",
+        )
+    )
+    if not parts:
+        return b""
+    # 无换行标记只能跟在「真正对应文件最后一行」的补丁行后。
+    # 用 @@ 行号判断；末行未出现在 hunk 中时不要输出标记，否则 git apply
+    # 会把标记误贴到仍带换行的上下文行上，吃掉换行并把下一行拼上。
+    # 文件头 / hunk 头只在进入正文前识别；hunk 内以 -- / ++ 开头的正文不得当头
+    def is_diff_header(line: str, in_hunk: bool) -> bool:
+        if not line:
+            return not in_hunk
+        if line.startswith("@@"):
+            return True
+        if not in_hunk and (line.startswith("--- ") or line.startswith("+++ ")):
+            return True
+        return False
+
+    hunk_re = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+    out = []
+    in_hunk = False
+    old_lineno = 0  # 1-based：下一条旧侧行号
+    new_lineno = 0
+    old_n = len(old_lines)
+    new_n = len(new_lines)
+    for line in parts:
+        if is_diff_header(line, in_hunk):
+            if line.startswith("@@"):
+                in_hunk = True
+                match = hunk_re.match(line)
+                if match:
+                    old_lineno = int(match.group(1))
+                    new_lineno = int(match.group(3))
+            out.append(line if line.endswith("\n") else line + "\n")
+            continue
+        tag = line[0]
+        body = line[1:]
+        if body.endswith("\n"):
+            out.append(line)
+        else:
+            out.append(line + "\n")
+        hit_old_last = False
+        hit_new_last = False
+        if tag in (" ", "-"):
+            # lineno 为 0 表示空文件侧，不应当成「最后一行」
+            if old_lineno >= 1 and old_lineno == old_n:
+                hit_old_last = True
+            if old_lineno > 0:
+                old_lineno += 1
+        if tag in (" ", "+"):
+            if new_lineno >= 1 and new_lineno == new_n:
+                hit_new_last = True
+            if new_lineno > 0:
+                new_lineno += 1
+        # 同一上下文行同时是两侧最后一行时只写一条标记
+        if (old_missing and hit_old_last) or (new_missing and hit_new_last):
+            out.append("\\n")
+    return "".join(out).encode("utf-8")
+
+
+def empty_file_delete_patch(repo_path: str) -> bytes:
+    """空文件删除：difflib 无法生成有效补丁，用 git 风格 deleted 头。"""
+    return (
+        "diff --git a/%(p)s b/%(p)s\n"
+        "deleted file mode 100644\n"
+        "index e69de29..0000000\n"
+        "--- a/%(p)s\n"
+        "+++ /dev/null\n"
+    ) % {"p": repo_path}
+
+
+def change_from_contents(
+    rel: str,
+    repo_path: str,
+    old: bytes,
+    new: bytes,
+    mode: str,
+    deleted: bool = False,
+) -> Optional[dict]:
+    """把两次内容做成与 transfer_line_changes 兼容的变更（相对上次已同步内容）。
+
+    空字节表示空文件内容，不是删除；只有 deleted=True 才生成 delete。
+    """
+    if not deleted and old == new:
+        return None
+    if not repo_path:
+        repo_path = rel
+    try:
+        old.decode("utf-8")
+        new.decode("utf-8")
+    except UnicodeDecodeError:
+        return {"path": rel, "repoPath": repo_path, "kind": "binary"}
+    if deleted:
+        if old == b"":
+            patch = empty_file_delete_patch(repo_path)
+        else:
+            patch = unified_diff_patch(old, b"", repo_path)
+            if not patch.strip():
+                patch = empty_file_delete_patch(repo_path)
+        return {"path": rel, "repoPath": repo_path, "kind": "delete", "patch": encode_bytes(patch)}
+    # 空↔有内容一律按 modify（对端已有空文件时不能标成 add）
+    patch = unified_diff_patch(old, new, repo_path)
+    if not patch.strip():
+        return None
+    return {
+        "path": rel,
+        "repoPath": repo_path,
+        "kind": "modify",
+        "mode": mode,
+        "patch": encode_bytes(patch),
+        "content": encode_bytes(new),
+    }
+
+
+def build_watch_change(root: str, ignored: set, rel: str, new_payload: Optional[bytes], last_synced: Dict[str, bytes], deleted: bool = False) -> Optional[dict]:
+    """为 sync 监视生成单文件行级变更：优先相对上次已同步内容，否则相对 git HEAD。"""
+    repo, _prefix, repo_path = find_repo_for_rel(root, rel)
+    if not repo_path:
+        repo_path = rel
+    if deleted:
+        old = last_synced.get(rel)
+        if old is not None:
+            # 有基线即可打删除补丁；无 git 仓库时也不能整份强删云端分叉内容
+            return change_from_contents(rel, repo_path, old, b"", "644", deleted=True)
+        if not repo:
+            return None
+        return collect_path_change(root, ignored, rel)
+    if not repo:
+        return None
+    if new_payload is None:
+        return None
+    mode = "644"
+    full = os.path.join(root, *rel.split("/"))
+    if os.path.isfile(full):
+        mode = file_mode(full)
+    if rel in last_synced:
+        return change_from_contents(rel, repo_path, last_synced[rel], new_payload, mode)
+    return collect_path_change(root, ignored, rel)
+
+
+def apply_saved_patch(
+    repo_path: str,
+    dest: Optional[bytes],
+    patch: bytes,
+    reverse: bool = False,
+) -> Tuple[str, Optional[bytes]]:
+    with tempfile.TemporaryDirectory(prefix="cs-sync-patch-") as tmp:
+        patch_path = os.path.join(tmp, "change.diff")
+        with open(patch_path, "wb") as handle:
+            handle.write(patch)
+        if dest is not None:
+            dest_path = os.path.join(tmp, *repo_path.split("/"))
+            parent = os.path.dirname(dest_path)
+            if parent:
+                os.makedirs(parent, exist_ok=True)
+            with open(dest_path, "wb") as handle:
+                handle.write(dest)
+        env = dict(os.environ)
+        env["GIT_TERMINAL_PROMPT"] = "0"
+        cmd = ["git", "apply", "--unsafe-paths", "--whitespace=nowarn"]
+        if reverse:
+            cmd.append("--reverse")
+        cmd.append(patch_path)
+        result = subprocess.run(
+            cmd,
+            cwd=tmp,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=False,
+            env=env,
+        )
+        if result.returncode != 0:
+            return "failed", None
+        dest_path = os.path.join(tmp, *repo_path.split("/"))
+        if not os.path.exists(dest_path):
+            return "deleted", None
+        with open(dest_path, "rb") as handle:
+            return "ok", handle.read()
+
+
+def change_target_bytes(change: dict) -> Optional[bytes]:
+    """变更目标内容（工作区新内容）；没有 content 字段时返回 None。"""
+    raw = change.get("content")
+    if not raw:
+        return None
+    try:
+        return decode_bytes(str(raw))
+    except ValueError:
+        return None
+
+
+def patch_already_applied(repo_path: str, dest: Optional[bytes], patch: bytes) -> bool:
+    """对端是否已含本补丁结果（反向 git apply 能打上）。"""
+    if dest is None:
+        return False
+    outcome, _payload = apply_saved_patch(repo_path, dest, patch, reverse=True)
+    return outcome in ("ok", "deleted")
+
+
+def transfer_line_changes(
+    changes: list,
+    read_dest,
+    write_dest,
+    delete_dest,
+    success_verb: Optional[str] = None,
+    quiet: bool = False,
+) -> Tuple[int, int]:
+    """按行把变更写到对面。
+
+    success_verb 为「本地改动」或「本地写入」时按方向打成功日志；
+    兼容旧值「上传」「下载」。否则沿用新增/同步行/删除。
+    quiet=True 时只静默失败日志（用于三路合并前的试探，避免假警报）；成功日志仍打印。
+    """
+    applied = failed = 0
+    verb = {"上传": "本地改动", "下载": "本地写入"}.get(success_verb or "", success_verb)
+    if verb in ("本地改动", "本地写入"):
+        add_verb = verb
+        modify_verb = verb
+        delete_verb = verb + "（删除）"
+        fail_prefix = "未同步到云端" if verb == "本地改动" else "未写入本地"
+    else:
+        add_verb = "新增"
+        modify_verb = "同步行"
+        delete_verb = "删除"
+        fail_prefix = "未应用"
+
+    def fail(rel: str, reason: str) -> None:
+        nonlocal failed
+        failed += 1
+        if not quiet:
+            eprint("%s %s ：%s" % (fail_prefix, rel, reason))
+
+    def already_synced(rel: str) -> None:
+        nonlocal applied
+        applied += 1
+        if not quiet:
+            print("已同步（跳过） %s" % rel, flush=True)
+
+    for change in changes:
+        rel = str(change.get("path") or "")
+        kind = str(change.get("kind") or "")
+        repo_path = str(change.get("repoPath") or rel)
+        mode = str(change.get("mode") or "644")
+        try:
+            exists, dest, dest_mode = read_dest(rel)
+        except urllib.error.URLError:
+            raise
+        except OSError as exc:
+            fail(rel, str(exc))
+            continue
+        if kind == "binary":
+            fail(rel, "二进制文件不能按行同步。")
+            continue
+        if kind == "add":
+            try:
+                payload = decode_bytes(str(change.get("content") or ""))
+            except ValueError:
+                fail(rel, "新增内容无法读取。")
+                continue
+            if exists:
+                if dest == payload:
+                    already_synced(rel)
+                else:
+                    fail(rel, "对方已有这个文件，已跳过（没有覆盖）。")
+                continue
+            if write_dest(rel, payload, mode):
+                print("%s %s" % (add_verb, rel), flush=True)
+                applied += 1
+            else:
+                failed += 1
+            continue
+        patch_raw = change.get("patch")
+        if not patch_raw:
+            fail(rel, "没有 git diff。")
+            continue
+        try:
+            patch = decode_bytes(str(patch_raw))
+        except ValueError:
+            fail(rel, "git diff 无法读取。")
+            continue
+        if kind == "delete":
+            if not exists:
+                # 对端已无此文件：视为删除已同步，避免调用方误判失败
+                already_synced(rel)
+                continue
+            outcome, payload = apply_saved_patch(repo_path, dest, patch)
+            removed = outcome == "deleted" or (outcome == "ok" and payload == b"")
+            if removed and delete_dest(rel):
+                print("%s %s" % (delete_verb, rel), flush=True)
+                applied += 1
+            else:
+                fail(rel, "补丁对不上，已跳过（没有删除）。")
+            continue
+        if not exists:
+            fail(rel, "对方没有这个文件，无法按行补上。")
+            continue
+        target = change_target_bytes(change)
+        # 对端已是目标态：绝不再打补丁（避免插入类 hunk 重复写入）
+        if (target is not None and dest == target) or patch_already_applied(repo_path, dest, patch):
+            already_synced(rel)
+            continue
+        outcome, payload = apply_saved_patch(repo_path, dest, patch)
+        if outcome == "ok" and payload is not None:
+            if payload == dest:
+                already_synced(rel)
+                continue
+            # 错误的 \ No newline 标记可能让 git apply 返回 0 却写坏内容。
+            # 若结果不等于目标，且同一补丁无法反向还原 dest，则视为写坏并跳过。
+            # 对端另有 hunk 外改动时，反向仍能还原 dest，结果可以不等于目标。
+            if target is not None and payload != target:
+                back_ok, back = apply_saved_patch(repo_path, payload, patch, reverse=True)
+                if not (back_ok == "ok" and back == dest):
+                    fail(rel, "补丁对不上，已跳过（没有覆盖）。")
+                    continue
+            if write_dest(rel, payload, dest_mode or mode):
+                print("%s %s" % (modify_verb, rel), flush=True)
+                applied += 1
+            else:
+                failed += 1
+        elif target is not None and dest == target:
+            already_synced(rel)
+        else:
+            fail(rel, "补丁对不上，已跳过（没有覆盖）。")
+    return applied, failed