code-server-sync 0.0.0-stage → 0.1.0

package/cs_sync/client.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import http.client
+import json
+import socket
+import ssl
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Optional, Tuple
+
+from cs_sync.protocol import (
+    MAX_BYTES,
+    ROUTE_CHANGES,
+    ROUTE_DELETE,
+    ROUTE_FILE,
+    ROUTE_HEALTH,
+    ROUTE_IGNORE,
+    ROUTE_MANIFEST,
+    ROUTE_PULL,
+    ROUTE_STAGE,
+)
+
+def ssl_context(insecure: bool) -> ssl.SSLContext:
+    if insecure:
+        context = ssl._create_unverified_context()
+        return context
+    return ssl.create_default_context()
+
+
+def origin_of(endpoint: str) -> str:
+    parts = urllib.parse.urlsplit(endpoint)
+    return urllib.parse.urlunsplit((parts.scheme, parts.netloc, "", "", ""))
+
+
+class Client:
+    def __init__(self, config: dict):
+        self.endpoint = config["endpoint"].rstrip("/")
+        self.token = config.get("token") or ""
+        self.cookie = config.get("cookie") or ""
+        self.auth_optional = config.get("auth") == "none"
+        self.insecure = bool(config.get("insecure"))
+        self.context = ssl_context(self.insecure)
+
+    def request(self, route: str, payload: Optional[bytes] = None, headers: Optional[dict] = None, method: Optional[str] = None):
+        data = payload
+        request_method = method or ("POST" if payload is not None else "GET")
+        request = urllib.request.Request(self.endpoint + route, data=data, method=request_method)
+        if self.cookie:
+            request.add_header("Cookie", self.cookie)
+        if self.token and (headers is None or "X-Sync-Token" not in headers):
+            request.add_header("X-Sync-Token", self.token)
+        if headers:
+            for key, value in headers.items():
+                request.add_header(key, value)
+        if payload is not None:
+            request.add_header("Content-Length", str(len(payload)))
+        try:
+            with urllib.request.urlopen(request, context=self.context, timeout=60) as response:
+                return response.status, response.headers, response.read()
+        except urllib.error.HTTPError as exc:
+            return exc.code, exc.headers, exc.read()
+        except urllib.error.URLError:
+            raise
+        except (TimeoutError, socket.timeout, ConnectionError, ssl.SSLError, http.client.IncompleteRead) as exc:
+            # 读超时等瞬时断网：统一成 URLError，供 sync 监视循环捕获后重试
+            raise urllib.error.URLError(exc) from exc
+
+    def open(self, route: str, payload: Optional[bytes] = None, headers: Optional[dict] = None, method: Optional[str] = None):
+        status, _headers, body = self.request(route, payload, headers, method)
+        return status, body
+
+    def health(self) -> Tuple[int, bytes]:
+        return self.open(ROUTE_HEALTH)
+
+    def put_file(self, rel: str, payload: bytes, mode: str) -> Tuple[int, bytes]:
+        headers = {
+            "X-Sync-Token": self.token,
+            "X-Rel-Path": urllib.parse.quote(rel, safe="/"),
+            "X-File-Mode": mode,
+            "Content-Type": "application/octet-stream",
+        }
+        return self.open(ROUTE_FILE, payload, headers, "POST")
+
+    def delete_file(self, rel: str) -> Tuple[int, bytes]:
+        headers = {
+            "X-Sync-Token": self.token,
+            "X-Rel-Path": urllib.parse.quote(rel, safe="/"),
+            "Content-Length": "0",
+        }
+        return self.open(ROUTE_DELETE, b"", headers, "POST")
+
+    def push_ignore(self, names) -> Tuple[int, bytes]:
+        payload = json.dumps({"dirs": sorted(names)}).encode("utf-8")
+        headers = {"X-Sync-Token": self.token, "Content-Type": "application/json"}
+        return self.open(ROUTE_IGNORE, payload, headers, "POST")
+
+    def manifest(self) -> Tuple[int, dict]:
+        status, body = self.open(ROUTE_MANIFEST, headers={"X-Sync-Token": self.token})
+        if status != 200:
+            return status, {}
+        try:
+            data = json.loads(body.decode("utf-8"))
+        except ValueError:
+            return status, {}
+        files = data.get("files") if isinstance(data, dict) else None
+        if not isinstance(files, dict):
+            return status, {}
+        return status, {str(key): str(value) for key, value in files.items()}
+
+    def pull_file(self, rel: str) -> Tuple[int, bytes, int]:
+        headers = {
+            "X-Sync-Token": self.token,
+            "X-Rel-Path": urllib.parse.quote(rel, safe="/"),
+        }
+        status, response_headers, body = self.request(ROUTE_PULL, headers=headers, method="GET")
+        if status == 200 and len(body) > MAX_BYTES:
+            return 400, ("文件过大\n").encode("utf-8"), 0o644
+        mode = 0o755 if response_headers and response_headers.get("X-File-Mode") == "755" else 0o644
+        return status, body, mode
+
+    def stage(self) -> Tuple[int, dict]:
+        headers = {"X-Sync-Token": self.token, "Content-Type": "application/json"}
+        status, body = self.open(ROUTE_STAGE, b"{}", headers, "POST")
+        if status != 200:
+            return status, {}
+        try:
+            data = json.loads(body.decode("utf-8"))
+        except ValueError:
+            return status, {}
+        if not isinstance(data, dict) or not isinstance(data.get("staged"), list):
+            return status, {}
+        return status, data
+
+    def changes(self) -> Tuple[int, dict]:
+        headers = {"X-Sync-Token": self.token, "Content-Type": "application/json"}
+        status, body = self.open(ROUTE_CHANGES, b"{}", headers, "POST")
+        if status != 200:
+            return status, {}
+        try:
+            data = json.loads(body.decode("utf-8"))
+        except ValueError:
+            return status, {}
+        if not isinstance(data, dict) or not isinstance(data.get("changes"), list):
+            return status, {}
+        return status, data
+
+
+def explain_http(status: int, body: bytes) -> str:
+    text = body.decode("utf-8", errors="replace")[:180].replace("\n", " ")
+    if status == 200:
+        return "通"
+    if b"<html" in body.lower() or b"<!doctype" in body.lower():
+        return "code-server 返回了网页（登录已失效，或代理没开）。状态 %d" % status
+    if status in (500, 502) and b"ECONNREFUSED" in body:
+        return "云端接收程序还没启动。先在 code-server 终端执行 token 命令打印的那一行。"
+    if status == 502 or status == 404:
+        return "云端接收程序没在听同步端口，或 /proxy 被关掉。状态 %d %s" % (status, text)
+    if status == 403:
+        return "令牌不一致。状态 403"
+    if status == 400:
+        if "文件过大" in text:
+            return "文件过大（超过 %d 字节）。状态 400" % MAX_BYTES
+        return "云端拒绝了路径。状态 400 %s" % text
+    return "状态 %d %s" % (status, text)
+
+
+def check_ready(client: Client) -> None:
+    if not client.token or len(client.token) < 16:
+        raise SystemExit("配置里的 token 为空。先运行 cs-sync init --name 名称 --local 本地目录 --remote 云端绝对路径 --base https://主机:端口")
+    if client.endpoint.startswith("https://") and not client.cookie and not client.auth_optional:
+        raise SystemExit(
+            "还没有 code-server 登录凭证。运行 cs-sync login，"
+            "或执行 cs-sync cookie '浏览器里的 code-server-session'。"
+        )
+    try:
+        status, body = client.health()
+    except urllib.error.URLError as exc:
+        raise SystemExit("连不上 %s ：%s" % (client.endpoint, exc.reason))
+    if status != 200 or body.strip() != b"ok":
+        raise SystemExit(explain_http(status, body))
+    status, body = client.put_file("../probe", b"", "644")
+    if status == 403:
+        raise SystemExit("接收程序拒绝了令牌。确认云端 --token 和本机配置是同一个。")
+    if status != 400:
+        raise SystemExit(explain_http(status, body))

package/cs_sync/config.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import json
+import os
+
+from cs_sync.ignore import DEFAULT_IGNORE_DIRS
+from cs_sync.protocol import DEFAULT_PORT
+
+def config_dir() -> str:
+    return os.path.abspath(os.path.expanduser(os.environ.get("CS_SYNC_HOME") or "~/.config/cs-sync"))
+
+
+def host_path() -> str:
+    return os.path.join(config_dir(), "host.json")
+
+
+def projects_dir() -> str:
+    return os.path.join(config_dir(), "projects")
+
+
+def load_json(path: str) -> dict:
+    with open(path, "r", encoding="utf-8") as handle:
+        data = json.load(handle)
+    if not isinstance(data, dict):
+        raise SystemExit("配置文件格式不对: %s" % path)
+    return data
+
+
+def load_host() -> dict:
+    path = host_path()
+    if not os.path.exists(path):
+        return {}
+    return load_json(path)
+
+
+def save_host(host: dict) -> None:
+    save_config(host_path(), host)
+
+
+def valid_name(name: str) -> bool:
+    if not name or len(name) > 64 or not name[0].isalnum():
+        return False
+    return all(char.isalnum() or char in "._-" for char in name)
+
+
+def project_filename(name: str) -> str:
+    parts = []
+    for char in name:
+        if char.isupper():
+            parts.append("~" + char.lower())
+        elif char == "~":
+            parts.append("~~")
+        else:
+            parts.append(char)
+    return "".join(parts) + ".json"
+
+
+def project_entries() -> list:
+    entries = []
+    root = config_dir()
+    if os.path.isdir(root):
+        for filename in os.listdir(root):
+            if filename.endswith(".json") and filename != "host.json":
+                entries.append(os.path.join(root, filename))
+    folder = projects_dir()
+    if os.path.isdir(folder):
+        for filename in os.listdir(folder):
+            if filename.endswith(".json"):
+                entries.append(os.path.join(folder, filename))
+    return entries
+
+
+def stored_project_name(path: str) -> str:
+    stored = load_json(path).get("name")
+    if isinstance(stored, str) and stored:
+        return stored
+    return os.path.basename(path)[: -len(".json")]
+
+
+def project_paths() -> Dict[str, list]:
+    grouped: Dict[str, list] = {}
+    for path in project_entries():
+        try:
+            key = stored_project_name(path)
+        except (OSError, ValueError):
+            continue
+        grouped.setdefault(key, []).append(path)
+    return grouped
+
+
+def project_files() -> Dict[str, str]:
+    found: Dict[str, str] = {}
+    folder = projects_dir()
+    for key, paths in project_paths().items():
+        chosen = paths[0]
+        for path in paths:
+            if os.path.dirname(path) == folder:
+                chosen = path
+                break
+        found[key] = chosen
+    return found
+
+
+def compose(host: dict, project: dict) -> dict:
+    config = dict(project)
+    port = int(config.get("port") or DEFAULT_PORT)
+    config["port"] = port
+    if not config.get("endpoint"):
+        base = str(host.get("baseUrl") or "").rstrip("/")
+        if not base:
+            raise SystemExit("还没有 code-server 地址。初始化项目时加上 --base https://主机:端口")
+        config["endpoint"] = "%s/proxy/%d" % (base, port)
+    if not config.get("cookie"):
+        config["cookie"] = host.get("cookie") or ""
+    if host.get("auth") and not config.get("auth"):
+        config["auth"] = host["auth"]
+    if "insecure" not in project:
+        config["insecure"] = bool(host.get("insecure", True))
+    if not config.get("ignoreDirs"):
+        config["ignoreDirs"] = sorted(DEFAULT_IGNORE_DIRS)
+    return config
+
+
+def next_port() -> int:
+    used = set()
+    host = load_host()
+    for path in project_files().values():
+        config = compose(host, load_json(path))
+        used.add(int(config.get("port") or DEFAULT_PORT))
+    port = DEFAULT_PORT
+    while port in used:
+        port += 1
+    return port
+
+
+def resolve_project(name: str = "", config_path: str = "") -> dict:
+    if config_path:
+        return compose(load_host(), load_json(config_path))
+    files = project_files()
+    if name:
+        path = files.get(name)
+        if not path:
+            known = "、".join(sorted(files)) or "（无）"
+            raise SystemExit("没有名为 %s 的项目。已有: %s" % (name, known))
+        return compose(load_host(), load_json(path))
+    cwd = os.path.abspath(os.getcwd())
+    host = load_host()
+    matches = []
+    for path in files.values():
+        config = compose(host, load_json(path))
+        root = os.path.abspath(os.path.expanduser(str(config.get("localRoot") or "")))
+        if root and (cwd == root or cwd.startswith(root + os.sep)):
+            matches.append(config)
+    if len(matches) == 1:
+        return matches[0]
+    if len(files) == 1 and not matches:
+        only = next(iter(files.values()))
+        return compose(host, load_json(only))
+    known = "、".join(sorted(files)) or "（无）"
+    raise SystemExit("请用 --name 指定项目。已有: %s" % known)
+
+
+def save_config(path: str, config: dict) -> None:
+    directory = os.path.dirname(path)
+    os.makedirs(directory, exist_ok=True)
+    flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
+    fd = os.open(path, flags, 0o600)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(config, handle, ensure_ascii=False, indent=2)
+            handle.write("\n")
+            fd = -1
+    finally:
+        if fd >= 0:
+            os.close(fd)
+    os.chmod(path, 0o600)
+
+
+def ensure_config(name: str = "", config_path: str = "") -> dict:
+    if not config_path and not project_files() and not name:
+        raise SystemExit(
+            "还没有项目。先运行: cs-sync init --name 名称 --local 本地目录 --remote 云端绝对路径 --base https://主机:端口"
+        )
+    return resolve_project(name, config_path)

package/cs_sync/files.py

@@ -0,0 +1,199 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import threading
+import urllib.parse
+from typing import Dict, Tuple
+
+from cs_sync.ignore import DEFAULT_IGNORE_DIRS, IGNORE_PREFIXES, PathIgnore, load_path_ignore, should_skip
+from cs_sync.protocol import MAX_BYTES, eprint
+
+FileState = Tuple[int, int]
+
+
+def safe_destination(root: str, rel: str) -> str:
+    rel = urllib.parse.unquote(rel).replace("\\", "/").strip()
+    if not rel or rel.startswith("/") or "\x00" in rel:
+        raise ValueError("非法路径")
+    parts = rel.split("/")
+    if any(part in ("", ".", "..") for part in parts):
+        raise ValueError("非法路径")
+    root_real = os.path.realpath(root)
+    current = root_real
+    for part in parts[:-1]:
+        current = os.path.join(current, part)
+        if os.path.islink(current):
+            raise ValueError("路径中含有符号链接")
+        if os.path.exists(current) and not os.path.isdir(current):
+            raise ValueError("父级不是目录")
+        if os.path.isdir(current):
+            current_real = os.path.realpath(current)
+            if current_real != root_real and not current_real.startswith(root_real + os.sep):
+                raise ValueError("路径越界")
+    dest = os.path.normpath(os.path.join(root_real, *parts))
+    if dest != root_real and not dest.startswith(root_real + os.sep):
+        raise ValueError("路径越界")
+    return dest
+
+
+def write_file(root: str, rel: str, payload: bytes, mode: int) -> str:
+    dest = safe_destination(root, rel)
+    parent = os.path.dirname(dest)
+    root_real = os.path.realpath(root)
+    current = root_real
+    relative_parent = os.path.relpath(parent, root_real)
+    if relative_parent != ".":
+        for part in relative_parent.split(os.sep):
+            current = os.path.join(current, part)
+            if os.path.islink(current):
+                raise ValueError("路径中含有符号链接")
+            if os.path.isdir(current):
+                continue
+            if os.path.exists(current):
+                raise ValueError("父级不是目录")
+            os.mkdir(current, 0o755)
+    tmp = dest + ".cs-sync-tmp"
+    flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
+    if hasattr(os, "O_NOFOLLOW"):
+        flags |= os.O_NOFOLLOW
+    fd = os.open(tmp, flags, mode)
+    try:
+        view = payload
+        while view:
+            written = os.write(fd, view)
+            if written <= 0:
+                raise OSError("写入中断")
+            view = view[written:]
+    finally:
+        os.close(fd)
+    os.chmod(tmp, mode)
+    os.replace(tmp, dest)
+    return dest
+
+
+def remove_file(root: str, rel: str) -> str:
+    dest = safe_destination(root, rel)
+    if os.path.islink(dest) or os.path.isfile(dest):
+        os.remove(dest)
+        parent = os.path.dirname(dest)
+        root_real = os.path.realpath(root)
+        while parent != root_real and parent.startswith(root_real + os.sep):
+            try:
+                os.rmdir(parent)
+            except OSError:
+                break
+            parent = os.path.dirname(parent)
+    return dest
+
+
+def sha256_file(path: str) -> str:
+    digest = hashlib.sha256()
+    with open(path, "rb") as handle:
+        while True:
+            chunk = handle.read(1024 * 1024)
+            if not chunk:
+                break
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def sha256_bytes(payload: bytes) -> str:
+    return hashlib.sha256(payload).hexdigest()
+
+
+class FileIndex:
+    def __init__(self, root: str):
+        self.root = root
+        self.ignore = set(DEFAULT_IGNORE_DIRS)
+        self.files: Dict[str, str] = {}
+        self.stats: Dict[str, FileState] = {}
+        self.lock = threading.Lock()
+
+    def set_ignore(self, names) -> None:
+        with self.lock:
+            self.ignore = set(names) or set(DEFAULT_IGNORE_DIRS)
+
+    def note_write(self, rel: str, payload: bytes) -> None:
+        digest = sha256_bytes(payload)
+        full = os.path.join(self.root, rel)
+        try:
+            stat = os.stat(full)
+            state = (stat.st_mtime_ns, stat.st_size)
+        except OSError:
+            state = (0, len(payload))
+        with self.lock:
+            self.files[rel] = digest
+            self.stats[rel] = state
+
+    def note_delete(self, rel: str) -> None:
+        with self.lock:
+            self.files.pop(rel, None)
+            self.stats.pop(rel, None)
+
+    def manifest(self) -> Dict[str, str]:
+        with self.lock:
+            return dict(self.files)
+
+    def scan(self, announce: bool = False) -> None:
+        ignored = set(self.ignore)
+        current = scan(self.root, ignored)
+        digests: Dict[str, str] = {}
+        with self.lock:
+            previous = dict(self.stats)
+            cached = dict(self.files)
+        for rel, state in current.items():
+            if previous.get(rel) == state and rel in cached:
+                digests[rel] = cached[rel]
+                continue
+            full = os.path.join(self.root, rel)
+            try:
+                digests[rel] = sha256_file(full)
+            except OSError:
+                continue
+            if announce and cached.get(rel) != digests[rel]:
+                print("云端改动 %s (%d 字节)" % (rel, state[1]), flush=True)
+        if announce:
+            for rel in cached:
+                if rel not in current and previous.get(rel) == self.stats.get(rel):
+                    print("云端改动（删除） %s" % rel, flush=True)
+        with self.lock:
+            for rel, state in list(current.items()):
+                if self.stats.get(rel) != previous.get(rel) and rel in self.files:
+                    digests[rel] = self.files[rel]
+                    current[rel] = self.stats[rel]
+            self.stats = current
+            self.files = digests
+
+
+def file_mode(path: str) -> str:
+    return "755" if os.stat(path).st_mode & 0o111 else "644"
+
+
+def scan(root: str, ignored: set, path_ignore: PathIgnore = None) -> Dict[str, FileState]:
+    if path_ignore is None:
+        path_ignore = load_path_ignore(root)
+    found: Dict[str, FileState] = {}
+    root = os.path.abspath(root)
+    for dirpath, dirnames, filenames in os.walk(root):
+        kept = []
+        for name in dirnames:
+            if name in ignored 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
+            kept.append(name)
+        dirnames[:] = kept
+        for name in filenames:
+            full = os.path.join(dirpath, name)
+            rel = os.path.relpath(full, root).replace(os.sep, "/")
+            if should_skip(rel, ignored, path_ignore):
+                continue
+            if os.path.islink(full) or not os.path.isfile(full):
+                continue
+            stat = os.stat(full)
+            if stat.st_size > MAX_BYTES:
+                continue
+            found[rel] = (stat.st_mtime_ns, stat.st_size)
+    return found