code-server-sync 0.0.0-stage → 0.1.0

package/cs_sync/sync.py

@@ -0,0 +1,812 @@
+from __future__ import annotations
+
+import os
+import time
+import urllib.error
+from typing import Dict, Optional, Tuple
+
+from cs_sync.client import Client, check_ready, explain_http
+from cs_sync.files import file_mode, remove_file, scan, sha256_bytes, sha256_file, write_file
+from cs_sync.git import (
+    apply_saved_patch,
+    build_watch_change,
+    change_from_contents,
+    change_target_bytes,
+    decode_bytes,
+    find_repo_for_rel,
+    patch_already_applied,
+    transfer_line_changes,
+)
+from cs_sync.ignore import PathIgnore, ignore_dirs, load_path_ignore, should_skip
+from cs_sync.merge import apply_line_delta_onto, refresh_local_known, try_merge_cloud_onto_local
+from cs_sync.protocol import MAX_BYTES, eprint
+
+def apply_change(client: Client, local_root: str, rel: str, delete: bool) -> None:
+    if delete:
+        status, body = client.delete_file(rel)
+        action = "本地改动（删除）"
+        fail_prefix = "未同步到云端（删除）"
+    else:
+        full = os.path.join(local_root, rel)
+        with open(full, "rb") as handle:
+            payload = handle.read()
+        status, body = client.put_file(rel, payload, file_mode(full))
+        action = "本地改动"
+        fail_prefix = "未同步到云端"
+    if status != 200 or body.strip() != b"ok":
+        eprint("%s %s ：%s" % (fail_prefix, rel, explain_http(status, body)))
+        return False
+    print("%s %s" % (action, rel), flush=True)
+    return True
+
+
+def is_dry_run(args) -> bool:
+    return bool(getattr(args, "dry_run", False))
+
+
+def print_dry_run_banner(command: str) -> None:
+    print("【演练模式 --dry-run】%s：不会暂存、不会写入/删除文件、不会应用补丁。" % command, flush=True)
+
+
+def summarize_counts(counts: dict) -> str:
+    order = ("add", "modify", "delete", "skip-same", "conflict", "binary", "fail", "upload", "download", "local-only", "remote-only")
+    parts = []
+    for key in order:
+        value = counts.get(key)
+        if value:
+            parts.append("%s %d" % (key, value))
+    for key, value in sorted(counts.items()):
+        if key not in order and value:
+            parts.append("%s %d" % (key, value))
+    return "，".join(parts) if parts else "无变更"
+
+
+def preview_copy_local_to_cloud(local_root: str, ignored: set, remote: Optional[Dict[str, str]]) -> Tuple[int, int, int]:
+    upload = skipped = failed = 0
+    print("变更清单（本地 → 云端）：", flush=True)
+    for rel in sorted(scan(local_root, ignored)):
+        full = os.path.join(local_root, rel)
+        try:
+            digest = sha256_file(full)
+        except OSError as exc:
+            print("  fail     %s （读取本地失败：%s）" % (rel, exc), flush=True)
+            failed += 1
+            continue
+        if remote is not None and remote.get(rel) == digest:
+            print("  skip-same %s" % rel, flush=True)
+            skipped += 1
+            continue
+        if remote is None or rel not in remote:
+            print("  add      %s" % rel, flush=True)
+        else:
+            print("  modify   %s" % rel, flush=True)
+        upload += 1
+    print("演练合计：将本地改动 %d，相同跳过 %d，失败 %d。" % (upload, skipped, failed), flush=True)
+    print("只在云端、本地没有的文件保持原样。", flush=True)
+    return upload, skipped, failed
+
+
+def preview_copy_cloud_to_local(local_root: str, remote: Dict[str, str]) -> Tuple[int, int, int]:
+    download = skipped = failed = 0
+    print("变更清单（云端 → 本地）：", flush=True)
+    for rel, digest in sorted(remote.items()):
+        full = os.path.join(local_root, rel)
+        if os.path.isfile(full) and not os.path.islink(full):
+            try:
+                if sha256_file(full) == digest:
+                    print("  skip-same %s" % rel, flush=True)
+                    skipped += 1
+                    continue
+            except OSError as exc:
+                print("  fail     %s （读取本地失败：%s）" % (rel, exc), flush=True)
+                failed += 1
+                continue
+            print("  modify   %s" % rel, flush=True)
+        else:
+            print("  add      %s" % rel, flush=True)
+        download += 1
+    print("演练合计：将本地写入 %d，相同跳过 %d，失败 %d。" % (download, skipped, failed), flush=True)
+    print("只在本地、云端没有的文件保持原样。", flush=True)
+    return download, skipped, failed
+
+
+def preview_line_changes(changes: list, read_dest) -> Tuple[int, int]:
+    would = failed = 0
+    print("变更清单（git diff 行级）：", 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)
+        try:
+            exists, dest, _mode = read_dest(rel)
+        except OSError as exc:
+            print("  fail     %s （读取对端失败：%s）" % (rel, exc), flush=True)
+            failed += 1
+            continue
+        if kind == "binary":
+            print("  binary   %s （二进制不能按行同步）" % rel, flush=True)
+            failed += 1
+            continue
+        if kind == "add":
+            try:
+                payload = decode_bytes(str(change.get("content") or ""))
+            except ValueError:
+                print("  fail     %s （新增内容无法读取）" % rel, flush=True)
+                failed += 1
+                continue
+            if exists:
+                if dest == payload:
+                    print("  skip-same %s （对端已是目标内容）" % rel, flush=True)
+                else:
+                    print("  conflict %s （对端已有，不会整份覆盖）" % rel, flush=True)
+                    failed += 1
+            else:
+                print("  add      %s" % rel, flush=True)
+                would += 1
+            continue
+        patch_raw = change.get("patch")
+        if not patch_raw:
+            print("  fail     %s （没有 git diff）" % rel, flush=True)
+            failed += 1
+            continue
+        try:
+            patch = decode_bytes(str(patch_raw))
+        except ValueError:
+            print("  fail     %s （git diff 无法读取）" % rel, flush=True)
+            failed += 1
+            continue
+        if kind == "delete":
+            if not exists:
+                print("  skip-same %s （对端已无）" % rel, flush=True)
+                continue
+            outcome, _payload = apply_saved_patch(repo_path, dest, patch)
+            if outcome == "deleted":
+                print("  delete   %s" % rel, flush=True)
+                would += 1
+            else:
+                print("  conflict %s （补丁对不上，不会删除）" % rel, flush=True)
+                failed += 1
+            continue
+        if not exists:
+            print("  fail     %s （对端没有这个文件）" % rel, flush=True)
+            failed += 1
+            continue
+        target = change_target_bytes(change)
+        if (target is not None and dest == target) or patch_already_applied(repo_path, dest, patch):
+            print("  skip-same %s （对端已是补丁结果）" % rel, flush=True)
+            continue
+        outcome, payload = apply_saved_patch(repo_path, dest, patch)
+        if outcome == "ok" and payload is not None:
+            if payload == dest:
+                print("  skip-same %s （对端已是补丁结果）" % rel, flush=True)
+            elif 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):
+                    print("  conflict %s （补丁对不上，不会覆盖）" % rel, flush=True)
+                    failed += 1
+                else:
+                    print("  modify   %s" % rel, flush=True)
+                    would += 1
+            else:
+                print("  modify   %s" % rel, flush=True)
+                would += 1
+        elif target is not None and dest == target:
+            print("  skip-same %s （对端已是目标内容）" % rel, flush=True)
+        else:
+            print("  conflict %s （补丁对不上，不会覆盖）" % rel, flush=True)
+            failed += 1
+    print("演练合计：可应用 %d，不可应用 %d。" % (would, failed), flush=True)
+    return would, failed
+
+
+def preview_sync_divergence(local_root: str, ignored: set, remote: Dict[str, str], pull_enabled: bool) -> None:
+    print("当前双边差异预览（注意：sync 监视只会同步启动之后的保存，不会自动处理启动前差异）：", flush=True)
+    local_files = scan(local_root, ignored)
+    counts = {"upload": 0, "download": 0, "conflict": 0, "skip-same": 0, "local-only": 0, "remote-only": 0}
+    all_rels = sorted(set(local_files) | set(remote))
+    for rel in all_rels:
+        local_exists = rel in local_files
+        remote_exists = rel in remote
+        local_digest = None
+        if local_exists:
+            full = os.path.join(local_root, rel)
+            try:
+                local_digest = sha256_file(full)
+            except OSError as exc:
+                print("  fail     %s （读取本地失败：%s）" % (rel, exc), flush=True)
+                continue
+        if local_exists and remote_exists:
+            if local_digest == remote[rel]:
+                print("  skip-same %s" % rel, flush=True)
+                counts["skip-same"] += 1
+            else:
+                print("  conflict %s （本地与云端内容不同）" % rel, flush=True)
+                counts["conflict"] += 1
+            continue
+        if local_exists and not remote_exists:
+            print("  local-only  %s （sync 启动前不会自动同步到云端；可用 to-cloud）" % rel, flush=True)
+            counts["local-only"] += 1
+            counts["upload"] += 1
+            continue
+        if remote_exists and not local_exists:
+            label = "remote-only %s" % rel
+            if pull_enabled:
+                print("  %s （sync 启动前不会自动拉回；可用 to-local）" % label, flush=True)
+            else:
+                print("  %s （云端旧接收程序，无法拉取）" % label, flush=True)
+            counts["remote-only"] += 1
+            counts["download"] += 1
+    print("演练合计：%s。" % summarize_counts(counts), flush=True)
+    print("未进入持续监视。去掉 --dry-run 才会开始 sync。", flush=True)
+
+
+def copy_local_to_cloud(client: Client, local_root: str, ignored: set, remote: Optional[Dict[str, str]]) -> Tuple[int, int, int]:
+    uploaded = skipped = failed = 0
+    for rel in sorted(scan(local_root, ignored)):
+        full = os.path.join(local_root, rel)
+        if remote is not None:
+            try:
+                if remote.get(rel) == sha256_file(full):
+                    skipped += 1
+                    continue
+            except OSError as exc:
+                eprint("读取本地失败 %s ：%s" % (rel, exc))
+                failed += 1
+                continue
+        if apply_change(client, local_root, rel, False):
+            uploaded += 1
+        else:
+            failed += 1
+    return uploaded, skipped, failed
+
+
+def copy_cloud_to_local(client: Client, local_root: str, remote: Dict[str, str]) -> Tuple[int, int, int]:
+    downloaded = skipped = failed = 0
+    for rel, digest in sorted(remote.items()):
+        full = os.path.join(local_root, rel)
+        if os.path.isfile(full) and not os.path.islink(full):
+            try:
+                if sha256_file(full) == digest:
+                    skipped += 1
+                    continue
+            except OSError:
+                pass
+        status, payload, mode = client.pull_file(rel)
+        if status != 200:
+            eprint("未写入本地 %s ：%s" % (rel, explain_http(status, payload)))
+            failed += 1
+            continue
+        try:
+            write_file(local_root, rel, payload, mode)
+        except (ValueError, OSError) as exc:
+            eprint("本地写入失败 %s ：%s" % (rel, exc))
+            failed += 1
+            continue
+        print("本地写入 %s" % rel, flush=True)
+        downloaded += 1
+    return downloaded, skipped, failed
+
+
+
+def push_watch_edit_to_cloud(
+    rel: str,
+    local_root: str,
+    new_payload: bytes,
+    last_synced: Dict[str, bytes],
+    cloud_reader,
+    cloud_writer,
+    cloud_deleter,
+    last_cloud_synced: Optional[Dict[str, bytes]] = None,
+) -> Tuple[str, Optional[bytes], str]:
+    """把监视到的本地编辑推到云端。
+
+    只把 last_synced→new_local 的行级增量打到当前云端；保留云端启动前独有行。
+    成功后不把合并结果写回本地（本地保持用户刚保存的内容）。
+    返回 (status, cloud_bytes_after, mode)，status 为 ok / conflict / error / noop。
+    """
+    _repo, _prefix, repo_path = find_repo_for_rel(local_root, rel)
+    if not repo_path:
+        repo_path = rel
+    mode = "644"
+    full = os.path.join(local_root, *rel.split("/"))
+    if os.path.isfile(full):
+        mode = file_mode(full)
+    try:
+        exists, cloud_now, cloud_mode = cloud_reader(rel)
+    except urllib.error.URLError:
+        raise
+    except OSError as exc:
+        return "error", None, str(exc)
+    mode_use = cloud_mode or mode
+    old_local = last_synced.get(rel)
+
+    if not exists:
+        # 云端曾有过此文件（启动基线或之后已同步）却已不存在：保留云端删除，不复活
+        if last_cloud_synced is not None and rel in last_cloud_synced:
+            return "conflict", None, "cloud-deleted"
+        # 启动后从未进入云端基线的新文件：整份新增
+        if cloud_writer(rel, new_payload, mode_use):
+            print("本地改动 %s" % rel, flush=True)
+            return "ok", new_payload, mode_use
+        return "error", None, mode_use
+
+    if cloud_now == new_payload:
+        return "noop", cloud_now, mode_use
+
+    if old_local is None:
+        # 缺少行级基线（旧 recv / 启动时未记下本地字节）：回退整份上传，避免已存在文件永远推不上去
+        if cloud_writer(rel, new_payload, mode_use):
+            print("本地改动 %s" % rel, flush=True)
+            return "ok", new_payload, mode_use
+        return "error", None, mode_use
+
+    if old_local == new_payload:
+        return "noop", cloud_now, mode_use
+
+    # 快路径：云端仍等于本地基线，行补丁可直接打上
+    if cloud_now == old_local:
+        change = change_from_contents(rel, repo_path, old_local, new_payload, mode_use)
+        if change is None:
+            return "noop", cloud_now, mode_use
+        if change.get("kind") == "binary":
+            return "conflict", None, "binary"
+        applied, failed = transfer_line_changes(
+            [change], cloud_reader, cloud_writer, cloud_deleter, success_verb="本地改动"
+        )
+        if applied and not failed:
+            return "ok", new_payload, mode_use
+        # 补丁意外失败则走增量合入
+
+    # 云端已分叉：只把 last_synced→new 增量打到云端，不把本地启动前独有行整包推上去。
+    # 不用 git apply 短路：重复行等场景下上下文仍可能命中，插入类 hunk 会再写一遍。
+    change = change_from_contents(rel, repo_path, old_local, new_payload, mode_use)
+    if change is not None and change.get("kind") == "binary":
+        return "conflict", None, "binary"
+
+    merged = apply_line_delta_onto(old_local, new_payload, cloud_now)
+    if merged is None:
+        return "conflict", None, "three-way"
+    if merged == cloud_now:
+        return "noop", cloud_now, mode_use
+    if cloud_writer(rel, merged, mode_use):
+        print("本地改动 %s" % rel, flush=True)
+        return "ok", merged, mode_use
+    return "error", None, mode_use
+
+
+def watch(config: dict) -> None:
+    from cs_sync.cli import command_text
+    from cs_sync.cli import (
+        cloud_change_deleter,
+        cloud_change_reader,
+        cloud_change_writer,
+        local_change_deleter,
+        local_change_reader,
+        local_change_writer,
+    )
+    local_root = config["localRoot"]
+    if not os.path.isdir(local_root):
+        raise SystemExit("本地目录不存在: %s" % local_root)
+    client = Client(config)
+    check_ready(client)
+    ignored = ignore_dirs(config)
+    path_ignore = load_path_ignore(local_root)
+    print("已连上 %s" % client.endpoint, flush=True)
+    ignore_status, _ignore_body = client.push_ignore(ignored)
+    print("正在建立基线…", flush=True)
+    current = scan(local_root, ignored, path_ignore)
+    known = dict(current)
+    pending: Dict[str, FileState] = {}
+    # 上次已成功同步的本地内容（用于本地→云端增量）
+    last_synced: Dict[str, bytes] = {}
+    # 上次已接受的云端内容（用于云端→本地增量；绝不用相对 HEAD 的整份 diff）
+    last_cloud_synced: Dict[str, bytes] = {}
+    print("基线 %d 个文件。之后本地和云端的保存会按行级增量同步。" % len(known), flush=True)
+    print("启动前本地已经改过、且之后没有再保存的文件，不会自动同步到云端。要整份覆盖云端，停掉后改用 %s" % command_text(config, "to-cloud"), flush=True)
+    remote_base, pull_enabled = load_remote_base(client, ignored, ignore_status, path_ignore)
+    diverge_count = 0
+    if pull_enabled:
+        print("已记录云端基线 %d 个文件。之后云端的修改会按启动后增量拉回本地。" % len(remote_base), flush=True)
+        print("启动前云端已经改过、且之后没有再保存的文件，不会自动拉回。要整份覆盖本地，停掉后改用 %s" % command_text(config, "to-local"), flush=True)
+        for rel, digest in list(remote_base.items()):
+            full = os.path.join(local_root, *rel.split("/"))
+            if not os.path.isfile(full) or os.path.islink(full):
+                continue
+            try:
+                if os.path.getsize(full) > MAX_BYTES:
+                    continue
+                with open(full, "rb") as handle:
+                    local_bytes = handle.read()
+            except OSError:
+                continue
+            if len(local_bytes) > MAX_BYTES:
+                continue
+            if sha256_bytes(local_bytes) == digest:
+                last_synced[rel] = local_bytes
+                last_cloud_synced[rel] = local_bytes
+                continue
+            # 启动时两边已不一致：记下云端作增量基线，同时记下当时本地内容，
+            # 之后本地编辑只上传 local_at_start → new_local，不会把启动前本地独有行整包推上云端。
+            status_pull, cloud_payload, _mode = client.pull_file(rel)
+            if status_pull == 200 and len(cloud_payload) <= MAX_BYTES:
+                if sha256_bytes(cloud_payload) != digest:
+                    eprint(
+                        "启动基线跳过 %s ：云端清单与正文不一致，下一轮再记。"
+                        % rel
+                    )
+                    continue
+                last_cloud_synced[rel] = cloud_payload
+                last_synced[rel] = local_bytes
+                diverge_count += 1
+        if diverge_count:
+            print(
+                "启动时有 %d 个文件两边内容不一致，已记录云端基线；只同步启动之后的增量。"
+                % diverge_count,
+                flush=True,
+            )
+    else:
+        print("云端还是旧的接收程序，目前只把本地修改推上去。" , flush=True)
+        print("请在云端升级 code-server-sync 并重启 cs-sync recv，然后再运行 sync。", flush=True)
+        # 旧 recv 无云端清单：仍记下当前本地字节，便于之后行级推送；缺基线时 push 会整份上传
+        for rel in known:
+            full = os.path.join(local_root, *rel.split("/"))
+            if not os.path.isfile(full) or os.path.islink(full):
+                continue
+            try:
+                if os.path.getsize(full) > MAX_BYTES:
+                    continue
+                with open(full, "rb") as handle:
+                    local_bytes = handle.read()
+            except OSError:
+                continue
+            if len(local_bytes) > MAX_BYTES:
+                continue
+            last_synced[rel] = local_bytes
+    missing_seen: set = set()
+    remote_missing: set = set()
+    conflicts: set = set()
+    delete_failed: set = set()
+    cloud_reader = cloud_change_reader(client)
+    cloud_writer = cloud_change_writer(client)
+    cloud_deleter = cloud_change_deleter(client)
+    local_reader = local_change_reader(local_root)
+    local_writer = local_change_writer(local_root)
+    local_deleter = local_change_deleter(local_root)
+
+    def accept_cloud_baseline(rel: str, cloud_payload: bytes, digest: Optional[str] = None) -> None:
+        if digest is None:
+            digest = sha256_bytes(cloud_payload)
+        remote_base[rel] = digest
+        last_cloud_synced[rel] = cloud_payload
+
+    last_network_log = 0.0
+    while True:
+        time.sleep(1)
+        try:
+            try:
+                path_ignore = load_path_ignore(local_root)
+                current = scan(local_root, ignored, path_ignore)
+            except OSError as exc:
+                eprint("扫描失败: %s" % exc)
+                continue
+            remote_now = {}
+            if pull_enabled:
+                status, remote_now = client.manifest()
+                if status != 200:
+                    eprint("读取云端清单失败：%s" % explain_http(status, b""))
+                    remote_now = {}
+                    pull_enabled = False
+                else:
+                    remote_now = {rel: sha for rel, sha in remote_now.items() if not should_skip(rel, ignored, path_ignore)}
+            # 本地 → 云端
+            for rel, state in current.items():
+                if known.get(rel) == state:
+                    pending.pop(rel, None)
+                    continue
+                if pending.get(rel) != state:
+                    pending[rel] = state
+                    continue
+                full_path = os.path.join(local_root, rel)
+                try:
+                    if os.path.getsize(full_path) > MAX_BYTES:
+                        if rel not in conflicts:
+                            eprint("未同步 %s ：文件过大。" % rel)
+                        conflicts.add(rel)
+                        known[rel] = state
+                        pending.pop(rel, None)
+                        continue
+                    with open(full_path, "rb") as handle:
+                        new_payload = handle.read()
+                except OSError as exc:
+                    eprint("读取本地失败 %s ：%s" % (rel, exc))
+                    continue
+                # 相对上次已接受的本地内容无字节变化：只刷新 known，避免空转上传
+                if rel in last_synced and last_synced[rel] == new_payload:
+                    known[rel] = state
+                    pending.pop(rel, None)
+                    conflicts.discard(rel)
+                    continue
+                if len(new_payload) > MAX_BYTES:
+                    if rel not in conflicts:
+                        eprint("未同步 %s ：文件过大。" % rel)
+                    conflicts.add(rel)
+                    known[rel] = state
+                    pending.pop(rel, None)
+                    continue
+                try:
+                    status_push, cloud_after, mode_info = push_watch_edit_to_cloud(
+                        rel, local_root, new_payload, last_synced,
+                        cloud_reader, cloud_writer, cloud_deleter,
+                        last_cloud_synced,
+                    )
+                except urllib.error.URLError:
+                    raise
+                if status_push in ("conflict", "error"):
+                    reason = {
+                        "binary": "二进制文件不能按行同步。",
+                        "no-baseline": "没有启动后本地基线，不能安全按行推送（没有覆盖）。",
+                        "three-way": "与云端同一处改动对不上，已跳过（没有覆盖）。",
+                        "cloud-deleted": "云端已删除该文件，没有用本地改动复活。",
+                    }.get(mode_info, mode_info if status_push == "error" else "与云端合并不上，已跳过（没有覆盖）。")
+                    # known 冻结后同一状态不会再进这里，故每条失败只打一次
+                    eprint("未同步到云端 %s ：%s" % (rel, reason))
+                    conflicts.add(rel)
+                    known[rel] = state
+                    pending.pop(rel, None)
+                    continue
+                known[rel] = state
+                last_synced[rel] = new_payload
+                pending.pop(rel, None)
+                if status_push == "noop":
+                    if cloud_after is not None:
+                        accept_cloud_baseline(rel, cloud_after)
+                        remote_now[rel] = sha256_bytes(cloud_after)
+                    conflicts.discard(rel)
+                    delete_failed.discard(rel)
+                    continue
+                # 推成功后只更新云端基线；云端若仍保留启动前独有行是预期，绝不把那些行写回本地
+                if cloud_after is not None:
+                    cloud_payload = cloud_after
+                    status_cloud = 200
+                else:
+                    status_cloud, cloud_payload, _cloud_mode = client.pull_file(rel)
+                if status_cloud != 200:
+                    if rel not in conflicts:
+                        eprint("冲突 %s ：已推到云端但无法回读校验，没有用本地哈希冒充基线。" % rel)
+                    conflicts.add(rel)
+                    continue
+                cloud_digest = sha256_bytes(cloud_payload)
+                # 推送结果若已含「推送前云端独有行」，不能当成本地已接受的云端基线，
+                # 否则本轮云端→本地会跳过，启动后才出现的云端行进不来。
+                # cloud_after == new_payload 表示云端推送前仍等于本地基线（快路径）。
+                if cloud_payload == new_payload:
+                    accept_cloud_baseline(rel, cloud_payload, cloud_digest)
+                remote_now[rel] = cloud_digest
+                conflicts.discard(rel)
+                delete_failed.discard(rel)
+            missing = {rel for rel in known if rel not in current}
+            for rel in missing & missing_seen:
+                # 内容冲突冻结后用户删了本地：清掉内容冲突，继续把删除同步到云端。
+                # delete_failed 只抑制重复日志，不永久跳过：云端摘要变化或可删时仍再试。
+                conflicts.discard(rel)
+                if pull_enabled and rel in remote_now and remote_base.get(rel) != remote_now.get(rel):
+                    if rel not in delete_failed:
+                        eprint("冲突 %s ：本地删了，云端也改了，这一轮没有覆盖。" % rel)
+                    conflicts.add(rel)
+                    delete_failed.add(rel)
+                    continue
+                change = build_watch_change(local_root, ignored, rel, None, last_synced, deleted=True)
+                if change is None:
+                    if not apply_change(client, local_root, rel, True):
+                        continue
+                else:
+                    if change.get("kind") == "binary":
+                        eprint("未同步到云端（删除） %s ：无法按行处理。" % rel)
+                        conflicts.add(rel)
+                        delete_failed.add(rel)
+                        continue
+                    applied, failed = transfer_line_changes(
+                        [change], cloud_reader, cloud_writer, cloud_deleter, success_verb="本地改动"
+                    )
+                    if not applied or failed:
+                        if rel not in delete_failed:
+                            eprint("未同步到云端（删除） %s ：补丁对不上，已跳过（没有删除）。" % rel)
+                        conflicts.add(rel)
+                        delete_failed.add(rel)
+                        continue
+                known.pop(rel, None)
+                last_synced.pop(rel, None)
+                last_cloud_synced.pop(rel, None)
+                pending.pop(rel, None)
+                remote_base.pop(rel, None)
+                remote_now.pop(rel, None)
+                conflicts.discard(rel)
+                delete_failed.discard(rel)
+            missing_seen = missing
+            if not pull_enabled:
+                continue
+            # 云端 → 本地：只用 last_cloud_synced → cloud_now 的增量，绝不套用相对 HEAD 的 /v1/changes
+            for rel, digest in remote_now.items():
+                full_path = os.path.join(local_root, rel)
+                local_exists = os.path.isfile(full_path) and not os.path.islink(full_path)
+                local_bytes = None
+                local_digest = None
+                if local_exists:
+                    try:
+                        with open(full_path, "rb") as handle:
+                            local_bytes = handle.read()
+                        local_digest = sha256_bytes(local_bytes)
+                    except OSError:
+                        continue
+                if remote_base.get(rel) == digest:
+                    if local_exists and local_digest == digest:
+                        # 用磁盘当前 mtime，避免同一轮本地→云端刚 refresh 过又被 scan 旧 state 盖回去，引发假「本地改动」
+                        try:
+                            st = os.stat(full_path)
+                            known[rel] = (st.st_mtime_ns, st.st_size)
+                        except OSError:
+                            known[rel] = current.get(rel) or known.get(rel)
+                        last_synced[rel] = local_bytes
+                        last_cloud_synced[rel] = local_bytes
+                        pending.pop(rel, None)
+                        conflicts.discard(rel)
+                    elif not local_exists:
+                        conflicts.discard(rel)
+                    elif local_exists and rel not in last_cloud_synced:
+                        # 启动时清单与正文不一致而跳过的分叉基线：本轮再拉并核对后记下
+                        status_b, cloud_b, _mode_b = client.pull_file(rel)
+                        if (
+                            status_b == 200
+                            and len(cloud_b) <= MAX_BYTES
+                            and sha256_bytes(cloud_b) == digest
+                        ):
+                            last_cloud_synced[rel] = cloud_b
+                            last_synced[rel] = local_bytes
+                    continue
+                # 云端相对启动/上次基线有新内容
+                status_c, cloud_payload, cloud_mode = client.pull_file(rel)
+                if status_c != 200:
+                    eprint("未写入本地 %s ：%s" % (rel, explain_http(status_c, cloud_payload)))
+                    continue
+                if sha256_bytes(cloud_payload) != digest:
+                    # 清单与内容短暂不一致，下一轮再试
+                    continue
+                if not local_exists:
+                    # 已跟踪的本地删除/删除冲突：保持缺失，绝不整份写回还原。
+                    # 不用 remote_base 挡：启动时本地不存在的云端路径，启动后云端再改
+                    # 应整份拉回（启动扫描不会给这类路径留下可合并基线）。
+                    if (
+                        rel in known
+                        or rel in missing
+                        or rel in missing_seen
+                        or rel in delete_failed
+                        or rel in conflicts
+                    ):
+                        continue
+                    # 本地不存在且非删除跟踪：整份写入当前云端内容
+                    try:
+                        write_file(local_root, rel, cloud_payload, cloud_mode or "644")
+                    except (ValueError, OSError) as exc:
+                        eprint("本地写入失败 %s ：%s" % (rel, exc))
+                        continue
+                    print("本地写入 %s" % rel, flush=True)
+                    last_synced[rel] = cloud_payload
+                    accept_cloud_baseline(rel, cloud_payload, digest)
+                    refresh_local_known(local_root, rel, known, last_synced)
+                    pending.pop(rel, None)
+                    conflicts.discard(rel)
+                    continue
+                if local_digest == digest:
+                    accept_cloud_baseline(rel, cloud_payload, digest)
+                    known[rel] = current.get(rel) or known.get(rel)
+                    last_synced[rel] = local_bytes
+                    pending.pop(rel, None)
+                    conflicts.discard(rel)
+                    continue
+                # 本地已有文件且内容不同：只应用启动后云端增量，绝不整份覆盖
+                base = last_cloud_synced.get(rel)
+                if base is None and remote_base.get(rel) is not None and local_digest == remote_base.get(rel):
+                    base = local_bytes
+                if base is None:
+                    if rel not in conflicts:
+                        eprint("冲突 %s ：云端有更新但没有启动后云端基线，没有整份覆盖本地。" % rel)
+                    conflicts.add(rel)
+                    continue
+                if base == cloud_payload:
+                    accept_cloud_baseline(rel, cloud_payload, digest)
+                    continue
+                ok_m, merged = try_merge_cloud_onto_local(
+                    rel, local_root, base, cloud_payload, cloud_mode or "644",
+                    local_reader, local_writer, local_deleter,
+                )
+                if ok_m:
+                    # 合完刷新 known，避免下一轮把「下载写盘」误当成用户编辑再上传
+                    refresh_local_known(local_root, rel, known, last_synced)
+                    if merged is not None:
+                        last_synced[rel] = merged
+                    pending.pop(rel, None)
+                    accept_cloud_baseline(rel, cloud_payload, digest)
+                    # 本地仍可能与云端不同（启动前本地独有行）：这是预期，绝不回推云端
+                    conflicts.discard(rel)
+                    continue
+                if rel not in conflicts:
+                    eprint("冲突 %s ：云端行级变更合不到本地（同一处改动对不上），没有整份覆盖。" % rel)
+                conflicts.add(rel)
+            gone = {rel for rel in remote_base if rel not in remote_now}
+            if remote_base and len(gone) > max(20, len(remote_base) // 5):
+                eprint("云端清单一下子少了 %d 个文件，已跳过按云端删除。" % len(gone))
+                gone = set()
+            for rel in gone & remote_missing:
+                if rel in current and known.get(rel) != current.get(rel):
+                    if rel not in conflicts:
+                        eprint("冲突 %s ：云端删了，本地也改了，这一轮没有覆盖。" % rel)
+                        conflicts.add(rel)
+                    continue
+                if rel in current:
+                    full_path = os.path.join(local_root, rel)
+                    try:
+                        with open(full_path, "rb") as handle:
+                            local_bytes = handle.read()
+                    except OSError as exc:
+                        eprint("读取本地失败 %s ：%s" % (rel, exc))
+                        continue
+                    cloud_base = last_cloud_synced.get(rel)
+                    # 只与上次云端基线比较。启动时两边不一致会把当时本地字节写入
+                    # last_synced；若用它判可删，预启动本地独有行会被误删。
+                    safe = cloud_base is not None and local_bytes == cloud_base
+                    if not safe:
+                        if rel not in conflicts:
+                            eprint("冲突 %s ：云端删了，但本地与上次云端基线不一致，没有删除本地。" % rel)
+                        conflicts.add(rel)
+                        continue
+                    try:
+                        remove_file(local_root, rel)
+                    except (ValueError, OSError) as exc:
+                        eprint("按云端删除本地文件失败 %s ：%s" % (rel, exc))
+                        continue
+                    print("本地写入（删除） %s" % rel, flush=True)
+                known.pop(rel, None)
+                last_synced.pop(rel, None)
+                last_cloud_synced.pop(rel, None)
+                pending.pop(rel, None)
+                remote_base.pop(rel, None)
+                conflicts.discard(rel)
+            remote_missing = gone
+        except urllib.error.URLError as exc:
+            reason = getattr(exc, "reason", exc)
+            now = time.time()
+            if now - last_network_log >= 30:
+                eprint("网络超时或中断，稍后重试：%s" % reason)
+                last_network_log = now
+            time.sleep(4)
+            continue
+
+
+
+
+
+
+def load_remote_base(client: Client, ignored: set, ignore_status: int, path_ignore: PathIgnore = None) -> Tuple[Dict[str, str], bool]:
+    if ignore_status == 404:
+        return {}, False
+    status, files = client.manifest()
+    if status == 404:
+        return {}, False
+    if status != 200:
+        eprint("读取云端清单失败：%s" % explain_http(status, b""))
+        return {}, False
+    return {rel: sha for rel, sha in files.items() if not should_skip(rel, ignored, path_ignore)}, True
+
+
+def remote_conflict(local_root: str, rel: str, remote_base: Dict[str, str], remote_now: Dict[str, str]) -> bool:
+    if rel not in remote_base or rel not in remote_now:
+        return False
+    if remote_now[rel] == remote_base[rel]:
+        return False
+    full = os.path.join(local_root, rel)
+    if not os.path.isfile(full) or os.path.islink(full):
+        return False
+    try:
+        return sha256_file(full) != remote_now[rel]
+    except OSError:
+        return False