code-server-sync 0.0.0-stage → 0.1.0

package/cs_sync/ignore.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import os
+import re
+
+DEFAULT_IGNORE_DIRS = {
+    ".agents",
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    "tmp",
+    ".idea",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".next",
+    ".nuxt",
+    ".turbo",
+    ".cache",
+    "vendor",
+}
+IGNORE_FILE_NAMES = {".DS_Store"}
+IGNORE_PREFIXES = (".cursor-tmp", ".tmp-")
+CS_SYNCIGNORE_NAME = ".cs-syncignore"
+
+
+def ignore_dirs(config: dict) -> set:
+    raw = config.get("ignoreDirs") or sorted(DEFAULT_IGNORE_DIRS)
+    return set(raw)
+
+
+def builtin_should_skip(rel: str, ignored: set) -> bool:
+    parts = rel.replace("\\", "/").split("/")
+    if any(part in ignored for part in parts):
+        return True
+    name = parts[-1] if parts else ""
+    if name in IGNORE_FILE_NAMES or name.startswith(IGNORE_PREFIXES):
+        return True
+    if name.endswith(".cs-sync-tmp"):
+        return True
+    return False
+
+
+def fnmatch_path(path: str, pattern: str) -> bool:
+    """类 gitignore：* / ? 不跨段，** 可跨段。"""
+    path = path.replace("\\", "/").strip("/")
+    pattern = pattern.replace("\\", "/").strip("/")
+    if pattern == "**":
+        return True
+    i = 0
+    parts = []
+    while i < len(pattern):
+        if pattern.startswith("**/", i):
+            parts.append("(?:.*/)?")
+            i += 3
+            continue
+        if i + 2 == len(pattern) and pattern.endswith("**") and pattern[i:i + 2] == "**":
+            parts.append(".*")
+            i += 2
+            continue
+        ch = pattern[i]
+        if ch == "*":
+            parts.append("[^/]*")
+        elif ch == "?":
+            parts.append("[^/]")
+        elif ch in ".^$+{}[]|()\\":
+            parts.append("\\" + ch)
+        else:
+            parts.append(ch)
+        i += 1
+    return re.match("^" + "".join(parts) + "$", path) is not None
+
+
+def _pattern_matches(rel: str, pattern: str, dir_only: bool, is_dir: bool) -> bool:
+    rel = rel.replace("\\", "/").strip("/")
+    pattern = pattern.replace("\\", "/")
+    if dir_only and not is_dir:
+        return False
+    # 必须在 strip 之前判断根锚定，否则 "/secret" 会变成 "secret" 并误走基名匹配
+    anchored = pattern.startswith("/")
+    if anchored:
+        pattern = pattern[1:]
+    pattern = pattern.strip("/")
+    if not pattern:
+        return False
+    if anchored:
+        return fnmatch_path(rel, pattern)
+    if "/" not in pattern:
+        base = rel.rsplit("/", 1)[-1]
+        if fnmatch_path(base, pattern) or fnmatch_path(rel, pattern):
+            return True
+        return False
+    return fnmatch_path(rel, pattern)
+
+
+def _ancestor_dir_matched(rel: str, pattern: str, dir_only: bool) -> bool:
+    parts = rel.replace("\\", "/").strip("/").split("/")
+    for idx in range(1, len(parts)):
+        parent = "/".join(parts[:idx])
+        if _pattern_matches(parent, pattern, True, True):
+            return True
+        if _pattern_matches(parent, pattern, dir_only, True):
+            return True
+    return False
+
+
+class PathIgnore:
+    """根目录 .cs-syncignore（类 gitignore）。! 否定只作用于本文件规则，不能抵消内置忽略。"""
+
+    def __init__(self, rules=None):
+        self.rules = list(rules or [])
+
+    @classmethod
+    def load(cls, root: str) -> "PathIgnore":
+        path = os.path.join(root, CS_SYNCIGNORE_NAME)
+        rules = []
+        try:
+            with open(path, "r", encoding="utf-8") as handle:
+                lines = handle.read().splitlines()
+        except (FileNotFoundError, OSError):
+            return cls([])
+        for raw in lines:
+            line = raw.strip()
+            if not line or line.startswith("#"):
+                continue
+            negated = False
+            if line.startswith("!"):
+                negated = True
+                line = line[1:].lstrip()
+            dir_only = line.endswith("/")
+            if dir_only:
+                line = line[:-1]
+            if not line:
+                continue
+            rules.append((negated, line, dir_only))
+        return cls(rules)
+
+    def ignored(self, rel: str, is_dir: bool = False) -> bool:
+        if not self.rules:
+            return False
+        rel = rel.replace("\\", "/").strip("/")
+        if not rel:
+            return False
+        state = None
+        for negated, pattern, dir_only in self.rules:
+            matched = _pattern_matches(rel, pattern, dir_only, is_dir)
+            if not matched and not negated:
+                matched = _ancestor_dir_matched(rel, pattern, dir_only)
+            if matched:
+                state = False if negated else True
+        return bool(state)
+
+
+def load_path_ignore(root: str) -> PathIgnore:
+    return PathIgnore.load(root)
+
+
+def should_skip(rel: str, ignored: set, path_ignore: PathIgnore = None, is_dir: bool = False) -> bool:
+    if builtin_should_skip(rel, ignored):
+        return True
+    if path_ignore is not None and path_ignore.ignored(rel, is_dir=is_dir):
+        return True
+    return False

package/cs_sync/merge.py

@@ -0,0 +1,279 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+from typing import Optional, Tuple
+
+from cs_sync.git import change_from_contents, find_repo_for_rel, transfer_line_changes
+
+def refresh_local_known(local_root: str, rel: str, known: dict, last_synced: Dict[str, bytes]) -> Optional[bytes]:
+    """写入本地后刷新 known / last_synced，返回当前字节。"""
+    full = os.path.join(local_root, *rel.split("/"))
+    try:
+        if not os.path.isfile(full) or os.path.islink(full):
+            known.pop(rel, None)
+            last_synced.pop(rel, None)
+            return None
+        stat = os.stat(full)
+        known[rel] = (stat.st_mtime_ns, stat.st_size)
+        with open(full, "rb") as handle:
+            payload = handle.read()
+        last_synced[rel] = payload
+        return payload
+    except OSError:
+        known.pop(rel, None)
+        last_synced.pop(rel, None)
+        return None
+
+
+def _line_change_ranges(old: list, new: list):
+    """返回 (删除/替换触及的旧行区间列表, 是否仅有插入)。"""
+    import difflib
+    touched = []
+    only_insert = True
+    for tag, i1, i2, j1, j2 in difflib.SequenceMatcher(a=old, b=new, autojunk=False).get_opcodes():
+        if tag == "equal":
+            continue
+        if tag != "insert":
+            only_insert = False
+            if i2 > i1:
+                touched.append((i1, i2))
+    return touched, only_insert
+
+
+def _ranges_overlap(a: list, b: list) -> bool:
+    for a1, a2 in a:
+        for b1, b2 in b:
+            if a1 < b2 and b1 < a2:
+                return True
+    return False
+
+
+def apply_line_delta_onto(base: bytes, new: bytes, target: bytes) -> Optional[bytes]:
+    """把 base→new 的行级变更应用到 target，保留 target 相对 base 的独有内容。
+
+    用于 sync 启动后两边已分叉：只传播启动后增量，不把启动前另一侧独有行并回来。
+    对不上则返回 None。
+    """
+    if target == base:
+        return new
+    if target == new:
+        return target
+    if base == new:
+        return target
+    try:
+        base_l = base.decode("utf-8").splitlines(keepends=True)
+        new_l = new.decode("utf-8").splitlines(keepends=True)
+        target_l = target.decode("utf-8").splitlines(keepends=True)
+    except UnicodeDecodeError:
+        return None
+    import difflib
+    base_to_target = {}
+    for tag, i1, i2, j1, j2 in difflib.SequenceMatcher(a=base_l, b=target_l, autojunk=False).get_opcodes():
+        if tag == "equal":
+            for k in range(i2 - i1):
+                base_to_target[i1 + k] = j1 + k
+    result = list(target_l)
+
+    def map_before(base_idx: int) -> int:
+        """base[base_idx] 之前的插入点，对应到当前 result 下标。"""
+        if base_idx in base_to_target:
+            return base_to_target[base_idx]
+        for k in range(base_idx - 1, -1, -1):
+            if k in base_to_target:
+                return base_to_target[k] + 1
+        for k in range(base_idx, len(base_l)):
+            if k in base_to_target:
+                return base_to_target[k]
+        return len(result)
+
+    ops = [
+        op for op in difflib.SequenceMatcher(a=base_l, b=new_l, autojunk=False).get_opcodes()
+        if op[0] != "equal"
+    ]
+    # 从高到低改，避免前面的插入/删除带动后面的原始下标
+    for tag, i1, i2, j1, j2 in sorted(ops, key=lambda op: op[1], reverse=True):
+        if tag == "insert":
+            pos = map_before(i1)
+            chunk = new_l[j1:j2]
+            # 间隙 = 上一个已映射基线行之后 → 当前插入点（不含 base[i1]）
+            gap_start = 0
+            for k in range(i1 - 1, -1, -1):
+                if k in base_to_target:
+                    gap_start = base_to_target[k] + 1
+                    break
+            if gap_start > pos:
+                return None
+            gap = result[gap_start:pos]
+            # 间隙前缀已是待插入行：视为已应用，跳过，避免重复
+            overlap = 0
+            for k in range(min(len(chunk), len(gap)), 0, -1):
+                if gap[:k] == chunk[:k]:
+                    overlap = k
+                    break
+            if overlap == len(chunk):
+                continue
+            if overlap > 0:
+                # 部分重叠对不齐，交给上层冲突处理
+                return None
+            # 插入点处已是待插入行（锚点漂移后常见）：跳过，避免末尾重复
+            if result[pos:pos + len(chunk)] == chunk:
+                continue
+            # 无后继基线锚点，且插入点后还有对不上的尾部：冲突，避免插错位置
+            has_next_anchor = any(k >= i1 for k in base_to_target)
+            if not has_next_anchor and result[pos:]:
+                return None
+            result[pos:pos] = chunk
+            continue
+        mapped = [base_to_target[k] for k in range(i1, i2) if k in base_to_target]
+        if tag == "delete":
+            if not mapped:
+                # 目标侧找不到这些基线行：仅当 base→target 对该区间是「删除」
+                # （行已不存在）才视为已满足；若是替换（本地改过同一行）则冲突，
+                # 否则会吞掉云端删除并 accept 基线。
+                covered_by_delete = False
+                for ttag, ti1, ti2, _tj1, _tj2 in difflib.SequenceMatcher(
+                    a=base_l, b=target_l, autojunk=False
+                ).get_opcodes():
+                    if ti2 <= i1 or ti1 >= i2:
+                        continue
+                    if ttag == "delete" and ti1 <= i1 and i2 <= ti2:
+                        covered_by_delete = True
+                        continue
+                    return None
+                if covered_by_delete:
+                    continue
+                return None
+            if len(mapped) != (i2 - i1):
+                return None
+            for idx in sorted(mapped, reverse=True):
+                del result[idx]
+            continue
+        if tag == "replace":
+            if len(mapped) != (i2 - i1):
+                return None
+            start, end = min(mapped), max(mapped) + 1
+            if mapped != list(range(start, end)):
+                return None
+            result[start:end] = new_l[j1:j2]
+            continue
+        return None
+    return "".join(result).encode("utf-8")
+
+
+def three_way_merge_bytes(base: bytes, local: bytes, cloud: bytes) -> Optional[bytes]:
+    """以 base 为祖先合并 local 与 cloud。两边改同一行则失败；两侧只是插入可用 union。"""
+    if local == cloud:
+        return local
+    if local == base:
+        return cloud
+    if cloud == base:
+        return local
+    try:
+        base_l = base.decode("utf-8").splitlines(keepends=True)
+        local_l = local.decode("utf-8").splitlines(keepends=True)
+        cloud_l = cloud.decode("utf-8").splitlines(keepends=True)
+    except UnicodeDecodeError:
+        return None
+    with tempfile.TemporaryDirectory(prefix="cs-sync-merge-") as tmp:
+        base_p = os.path.join(tmp, "base")
+        local_p = os.path.join(tmp, "local")
+        cloud_p = os.path.join(tmp, "cloud")
+        with open(base_p, "wb") as handle:
+            handle.write(base)
+        with open(local_p, "wb") as handle:
+            handle.write(local)
+        with open(cloud_p, "wb") as handle:
+            handle.write(cloud)
+        env = dict(os.environ)
+        env["GIT_TERMINAL_PROMPT"] = "0"
+        clean = subprocess.run(
+            ["git", "merge-file", "-p", "-q", local_p, base_p, cloud_p],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=False,
+            env=env,
+        )
+        if clean.returncode == 0:
+            return clean.stdout
+        local_touched, local_insert_only = _line_change_ranges(base_l, local_l)
+        cloud_touched, cloud_insert_only = _line_change_ranges(base_l, cloud_l)
+        if _ranges_overlap(local_touched, cloud_touched):
+            return None
+        # 仅当两侧都只是插入时才 union；一侧替换/删除时 union 会把「已被对端换掉的旧行」又并回来
+        if not (local_insert_only and cloud_insert_only):
+            return None
+        union = subprocess.run(
+            ["git", "merge-file", "-p", "-q", "--union", local_p, base_p, cloud_p],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=False,
+            env=env,
+        )
+        if union.returncode == 0 and b"<<<<<<<" not in union.stdout:
+            return union.stdout
+        return None
+
+
+def try_merge_cloud_onto_local(
+    rel: str,
+    local_root: str,
+    base_bytes: bytes,
+    cloud_payload: bytes,
+    mode: str,
+    local_reader,
+    local_writer,
+    local_deleter,
+) -> Tuple[bool, Optional[bytes]]:
+    """以 base_bytes 为共同祖先，把云端相对 base 的行变更合到本地。成功返回 (True, 合并后本地字节)。"""
+    if base_bytes == cloud_payload:
+        return True, None
+    try:
+        exists, local_bytes, local_mode = local_reader(rel)
+    except OSError:
+        return False, None
+    if not exists or local_bytes is None:
+        # 本地没有文件：整份写入云端内容
+        if local_writer(rel, cloud_payload, mode or "644"):
+            print("本地写入 %s" % rel, flush=True)
+            return True, cloud_payload
+        return False, None
+    if local_bytes == cloud_payload:
+        return True, local_bytes
+    if local_bytes == base_bytes:
+        if local_writer(rel, cloud_payload, local_mode or mode or "644"):
+            print("本地写入 %s" % rel, flush=True)
+            return True, cloud_payload
+        return False, None
+    # 先试行级补丁（本地≈基线时最快）；失败不打日志
+    _repo, _prefix, repo_path = find_repo_for_rel(local_root, rel)
+    if not repo_path:
+        repo_path = rel
+    change = change_from_contents(rel, repo_path, base_bytes, cloud_payload, mode or "644")
+    if change is not None and change.get("kind") != "binary":
+        applied, failed = transfer_line_changes(
+            [change], local_reader, local_writer, local_deleter,
+            success_verb="本地写入", quiet=True,
+        )
+        if applied and not failed:
+            full = os.path.join(local_root, *rel.split("/"))
+            try:
+                with open(full, "rb") as handle:
+                    return True, handle.read()
+            except OSError:
+                return True, None
+    if change is not None and change.get("kind") == "binary":
+        return False, None
+    # 本地相对基线已有独有行：只把 base→cloud 增量打到本地，不把启动前本地/云端分叉互相并回来
+    merged = apply_line_delta_onto(base_bytes, cloud_payload, local_bytes)
+    if merged is None:
+        merged = three_way_merge_bytes(base_bytes, local_bytes, cloud_payload)
+    if merged is None:
+        return False, None
+    if merged == local_bytes:
+        return True, local_bytes
+    if local_writer(rel, merged, local_mode or mode or "644"):
+        print("本地写入 %s" % rel, flush=True)
+        return True, merged
+    return False, None

package/cs_sync/protocol.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import sys
+import urllib.parse
+
+def eprint(message: str) -> None:
+    print(message, file=sys.stderr)
+
+
+DEFAULT_PORT = 27182
+MAX_BYTES = 32 * 1024 * 1024
+ROUTE_FILE = "/v1/file"
+ROUTE_DELETE = "/v1/delete"
+ROUTE_MANIFEST = "/v1/manifest"
+ROUTE_PULL = "/v1/pull"
+ROUTE_IGNORE = "/v1/ignore"
+ROUTE_STAGE = "/v1/stage"
+ROUTE_CHANGES = "/v1/changes"
+ROUTE_HEALTH = "/health"
+ROUTES = (ROUTE_MANIFEST, ROUTE_IGNORE, ROUTE_STAGE, ROUTE_CHANGES, ROUTE_DELETE, ROUTE_PULL, ROUTE_FILE, ROUTE_HEALTH)
+
+
+def route_of(url_path: str) -> str:
+    path = urllib.parse.urlsplit(url_path).path
+    for route in ROUTES:
+        if path == route or path.endswith(route):
+            return route
+    return path