wechat-cli 0.1.0__py3-none-any.whl

wechat_cli/config.py

@@ -0,0 +1,84 @@
+"""Private machine configuration; never store runtime state in uv's disposable cache."""
+
+import json
+import os
+import secrets
+import tempfile
+from pathlib import Path
+
+from .errors import AppError
+
+ASSETS = Path(__file__).parent / "assets"
+
+
+def data_directory(value=None):
+    return (
+        Path(
+            value
+            or os.environ.get("WECHAT_CLI_DATA_DIR")
+            or Path.home() / "Library/Application Support/wechat-cli"
+        )
+        .expanduser()
+        .resolve()
+    )
+
+
+def private_directory(path):
+    path.mkdir(parents=True, exist_ok=True, mode=0o700)
+    path.chmod(0o700)
+    return path
+
+
+def private_write(path, value):
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    fd, name = tempfile.mkstemp(dir=path.parent, prefix=".write-")
+    try:
+        with os.fdopen(fd, "w") as output:
+            output.write(value)
+        os.replace(name, path)
+    finally:
+        Path(name).unlink(missing_ok=True)
+
+
+def save_json(path, value):
+    private_write(path, json.dumps(value, indent=2) + "\n")
+
+
+def api_token(directory):
+    private_directory(directory)
+    path = directory / "api-token"
+    # Exclusive creation keeps concurrent CLI invocations on the same token.
+    try:
+        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    except FileExistsError:
+        pass
+    else:
+        with os.fdopen(fd, "w") as output:
+            output.write(secrets.token_hex(32) + "\n")
+    token = path.read_text().strip()
+    if not 16 <= len(token) <= 512 or any(c.isspace() for c in token):
+        raise AppError("invalid_api_token", f"Invalid API token in {path}", 424)
+    path.chmod(0o600)
+    return token
+
+
+def load_runtime(directory):
+    try:
+        value = json.loads((directory / "native-runtime.json").read_text())
+        app = Path(value["app"])
+        library = value["supportLibrary"]
+        if not app.is_absolute() or not isinstance(library, str):
+            raise ValueError()
+        if (
+            Path(library).name != library
+            or not library.startswith("native-reader-")
+            or not library.endswith(".dylib")
+        ):
+            raise ValueError()
+        if not (app / "Contents/Frameworks" / library).is_file():
+            raise ValueError()
+        return {"app": str(app.resolve()), "supportLibrary": library}
+    except (OSError, ValueError, KeyError, TypeError):
+        raise AppError(
+            "native_setup_required", "Run wechat-cli setup --app /path/to/patched/WeChat.app", 424
+        ) from None

wechat_cli/controls.py

@@ -0,0 +1,223 @@
+"""macOS Accessibility operations scoped to the configured WeChat process."""
+
+import hashlib
+import json
+import os
+import re
+import subprocess
+import tempfile
+import threading
+import time
+import unicodedata
+from pathlib import Path
+
+from .config import ASSETS, load_runtime, private_directory
+from .errors import AppError
+from .media import decode_upload
+from .setup import execute
+
+
+class Controls:
+    def __init__(self, directory):
+        self.directory = directory
+        self.lock = threading.Lock()
+
+    def invoke(self, action, **extra):
+        runtime = load_runtime(self.directory)
+        source = ASSETS / "controls.swift"
+        digest = hashlib.sha256(source.read_bytes()).hexdigest()[:16]
+        binary = self.directory / f"native-controls-{digest}"
+        if not binary.exists():
+            temporary = binary.with_suffix(f".{os.getpid()}.tmp")
+            try:
+                execute(
+                    [
+                        "/usr/bin/swiftc",
+                        "-module-cache-path",
+                        self.directory / "swift-cache",
+                        source,
+                        "-o",
+                        temporary,
+                    ]
+                )
+                os.replace(temporary, binary)
+            finally:
+                temporary.unlink(missing_ok=True)
+        processes = execute(["/bin/ps", "-axo", "pid=,comm="], timeout=5).decode()
+        expected = Path(runtime["app"]) / "Contents/MacOS/WeChat"
+        matches = matching_processes(processes, expected)
+        if len(matches) != 1:
+            raise AppError("native_process_identity_mismatch", "Configured WeChat is not running", 409)
+        try:
+            result = subprocess.run(
+                [str(binary)],
+                input=json.dumps({"pid": int(matches[0]), "app": runtime["app"], "action": action, **extra}),
+                text=True,
+                capture_output=True,
+                timeout=20,
+                check=True,
+            )
+            value = json.loads(result.stdout)
+        except (OSError, ValueError, subprocess.SubprocessError):
+            raise AppError(
+                "native_control_failed", "Native control failed; inspect WeChat before retrying", 502
+            ) from None
+        if value.get("error"):
+            code = value["error"]
+            message = (
+                "Allow Accessibility for the terminal running wechat-cli in macOS System Settings."
+                if code == "native_accessibility_required"
+                else code.replace("_", " ")
+            )
+            error = AppError(code, message, 409)
+            error.possible_send = value.get("possibleSend", True)
+            raise error
+        return value
+
+    @staticmethod
+    def chat_name(native, chat_id):
+        chats = native.chats()["items"]
+        chat = next((chat for chat in chats if chat["id"] == chat_id), None)
+        name = chat.get("displayName") or chat.get("displayString") if chat else None
+        if not name or sum((c.get("displayName") or c.get("displayString")) == name for c in chats) != 1:
+            raise AppError("native_chat_name_ambiguous", "This operation requires a uniquely named chat", 409)
+        return name
+
+    def download_attachment(self, native, chat_id, identifier):
+        if not self.lock.acquire(blocking=False):
+            raise AppError("native_control_busy", "Another control action is running", 409)
+        try:
+            name = self.chat_name(native, chat_id)
+            from .media import find_message
+
+            message = find_message(native, chat_id, identifier)
+            if message["kind"] != "file":
+                raise AppError("invalid_media_type", "Choose a file attachment")
+            state = self.invoke("status")
+            if state.get("chatName") != name or state.get("fileUiReady") is False:
+                raise AppError(
+                    "native_active_chat_mismatch", "Open the requested chat and close other dialogs", 409
+                )
+            self.invoke("attachment.download", chatName=name, fileName=message["details"]["fileName"])
+            for _ in range(40):
+                result = native.request("attachmentData", {"chatId": chat_id, "id": identifier})
+                if len(result.get("files", [])) == 1:
+                    return {"source": "native", "chatId": chat_id, "id": identifier, "status": "available"}
+                self.invoke("attachment.status", fileName=message["details"]["fileName"])
+                time.sleep(0.5)
+            return {"source": "native", "chatId": chat_id, "id": identifier, "status": "pending"}
+        finally:
+            self.lock.release()
+
+    def send_file(self, native, input):
+        if set(input) != {"chatId", "name", "dataBase64"}:
+            raise AppError("invalid_input", "Use chatId, name and dataBase64")
+        name = input["name"]
+        if (
+            not isinstance(name, str)
+            or not name.strip()
+            or name != name.strip()
+            or len(name.encode()) > 200
+            or re.search(r"[\\/\x00-\x1f\x7f]", name)
+            or name in {".", ".."}
+        ):
+            raise AppError("invalid_input", "Use a single filename of at most 200 UTF-8 bytes")
+        data = decode_upload(input["dataBase64"])
+        if not self.lock.acquire(blocking=False):
+            raise AppError("native_control_busy", "Another control action is running", 409)
+        invoked, directory = False, None
+        try:
+            chat_id = input["chatId"]
+            chat_name = self.chat_name(native, chat_id)
+            state = self.invoke("status")
+            if state.get("chatName") != chat_name or state.get("fileUiReady") is False:
+                raise AppError(
+                    "native_active_chat_mismatch", "Open the requested chat and close other dialogs", 409
+                )
+            if state.get("draft"):
+                raise AppError("native_draft_not_empty", "Clear or save the existing WeChat draft first", 409)
+            self_id = native.request("selfId")["id"]
+            before = {m["id"] for m in native.messages(chat_id, 100)["items"]}
+            root = private_directory(self.directory / "outgoing")
+            retained = []
+            for path in root.glob("file-*"):
+                if path.is_dir() and not path.is_symlink():
+                    if time.time() - path.stat().st_mtime > 600:
+                        import shutil
+
+                        shutil.rmtree(path)
+                    else:
+                        retained.append(path)
+            if len(retained) >= 16:
+                raise AppError("native_file_staging_full", "Wait for retained uploads to expire", 429)
+            directory = Path(tempfile.mkdtemp(prefix="file-", dir=root))
+            path = directory / name
+            path.write_bytes(data)
+            path.chmod(0o600)
+            invoked = True
+            try:
+                self.invoke("file.send", chatName=chat_name, filePath=str(path), fileName=name)
+            except AppError as error:
+                if getattr(error, "possible_send", True) is False:
+                    invoked = False
+                    raise
+            deadline, accepted = time.monotonic() + 45, None
+            while time.monotonic() < deadline:
+                matches = [
+                    m
+                    for m in native.messages(chat_id, 100)["items"]
+                    if m["id"] not in before
+                    and m.get("from") == self_id
+                    and m.get("to") == chat_id
+                    and m.get("kind") == "file"
+                    and m["details"].get("sizeBytes") == len(data)
+                    and unicodedata.normalize("NFC", m["details"].get("fileName", ""))
+                    == unicodedata.normalize("NFC", name)
+                ]
+                if len(matches) > 1:
+                    raise AppError(
+                        "native_send_outcome_unknown", "Multiple matching file messages observed", 502
+                    )
+                if matches:
+                    message = matches[0]
+                    accepted = {
+                        "source": "native",
+                        "chatId": chat_id,
+                        "requestId": message["id"],
+                        "messageId": message["id"],
+                        "name": name,
+                        "size": len(data),
+                        "acceptedByClient": True,
+                        "acknowledgedByServer": bool(re.fullmatch(r"[1-9]\d*", message.get("serverId", ""))),
+                    }
+                    if accepted["acknowledgedByServer"]:
+                        return accepted
+                time.sleep(0.25)
+            if accepted:
+                return accepted
+            raise AppError(
+                "native_send_outcome_unknown", "File selection ran; check WeChat history before retrying", 504
+            )
+        except Exception as error:
+            if invoked and not (isinstance(error, AppError) and error.code == "native_send_outcome_unknown"):
+                raise AppError(
+                    "native_send_outcome_unknown", "File send outcome is unknown; inspect WeChat", 502
+                ) from None
+            raise
+        finally:
+            if directory and not invoked:
+                import shutil
+
+                shutil.rmtree(directory)
+            self.lock.release()
+
+
+def matching_processes(snapshot, expected):
+    expected = expected.resolve()
+    matches = []
+    for line in snapshot.splitlines():
+        fields = line.strip().split(None, 1)
+        if len(fields) == 2 and fields[0].isdigit() and fields[1].endswith("/Contents/MacOS/WeChat"):
+            if Path(fields[1]).resolve() == expected:
+                matches.append(fields[0])
+    return matches

wechat_cli/errors.py

@@ -0,0 +1,7 @@
+class AppError(Exception):
+    def __init__(self, code: str, message: str, status: int = 400):
+        super().__init__(message)
+        self.code, self.status = code, status
+
+    def as_dict(self):
+        return {"error": self.code, "message": str(self)}

wechat_cli/idempotency.py

@@ -0,0 +1,82 @@
+"""Durable send deduplication, including uncertain results after a server restart."""
+
+import hashlib
+import json
+import sqlite3
+import threading
+import time
+
+from .config import private_directory
+from .errors import AppError
+
+
+class Idempotency:
+    def __init__(self, directory):
+        private_directory(directory)
+        path = directory / "requests.sqlite3"
+        self.connection = sqlite3.connect(path, check_same_thread=False)
+        path.chmod(0o600)
+        self.lock = threading.Lock()
+        self.connection.execute(
+            "CREATE TABLE IF NOT EXISTS requests "
+            "(route TEXT, key TEXT, digest TEXT, created REAL, status INTEGER, response TEXT, "
+            "PRIMARY KEY(route,key))"
+        )
+        self.connection.commit()
+
+    def once(self, route, key, payload, action):
+        signature = hashlib.sha256(
+            json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()
+        ).hexdigest()
+        # Serialize mutations through completion; concurrent retries see the same result.
+        with self.lock:
+            db = self.connection
+            db.execute("DELETE FROM requests WHERE created < ?", (time.time() - 86400,))
+            old = db.execute(
+                "SELECT digest,status,response FROM requests WHERE route=? AND key=?", (route, key)
+            ).fetchone()
+            if old:
+                if old[0] != signature:
+                    raise AppError("idempotency_conflict", "This key was used with a different request", 409)
+                if old[2] is None:
+                    raise AppError(
+                        "native_send_outcome_unknown",
+                        "An earlier attempt was interrupted. Inspect WeChat; do not resend with another key.",
+                        409,
+                    )
+                response = json.loads(old[2])
+                if old[1] >= 400:
+                    raise AppError(response["error"], response["message"], old[1])
+                return response
+            if db.execute("SELECT COUNT(*) FROM requests").fetchone()[0] >= 10000:
+                raise AppError("idempotency_capacity", "Request retention capacity reached", 503)
+            db.execute(
+                "INSERT INTO requests VALUES (?,?,?,?,NULL,NULL)", (route, key, signature, time.time())
+            )
+            db.commit()  # Commit intent before a native operation can enqueue anything.
+            try:
+                response = action()
+            except AppError as error:
+                db.execute(
+                    "UPDATE requests SET status=?,response=? WHERE route=? AND key=?",
+                    (error.status, json.dumps(error.as_dict()), route, key),
+                )
+                db.commit()
+                raise
+            except Exception:
+                # Leave the durable intent unresolved: retry must never send again.
+                raise AppError(
+                    "native_send_outcome_unknown",
+                    "Operation was interrupted; inspect WeChat before retrying",
+                    502,
+                ) from None
+            db.execute(
+                "UPDATE requests SET status=200,response=? WHERE route=? AND key=?",
+                (json.dumps(response), route, key),
+            )
+            db.commit()
+            return response
+
+    def close(self):
+        with self.lock:
+            self.connection.close()

wechat_cli/lifecycle.py

@@ -0,0 +1,141 @@
+"""One persistent Python service per data directory; no PID-based killing."""
+
+import fcntl
+import json
+import os
+import signal
+import subprocess
+import sys
+import threading
+import time
+from contextlib import contextmanager
+
+from .client import ApiClient
+from .config import private_directory, save_json
+from .errors import AppError
+from .native import NativeBridge
+
+
+@contextmanager
+def lock_file(path, blocking=True):
+    private_directory(path.parent)
+    with path.open("a+") as handle:
+        path.chmod(0o600)
+        try:
+            fcntl.flock(handle, fcntl.LOCK_EX | (0 if blocking else fcntl.LOCK_NB))
+        except BlockingIOError:
+            raise AppError(
+                "server_already_running", "A service is already running for this data directory", 409
+            ) from None
+        try:
+            yield
+        finally:
+            fcntl.flock(handle, fcntl.LOCK_UN)
+
+
+def configured_port(directory, explicit=None):
+    if explicit is not None:
+        return explicit
+    try:
+        value = json.loads((directory / "server.json").read_text())
+        return int(value["port"])
+    except (OSError, ValueError, KeyError):
+        return 8787
+
+
+def health(directory, port):
+    value = ApiClient(directory, port, timeout=1).request("/api/health")
+    if value.get("service") != "wechat-cli":
+        raise AppError("port_in_use", "Port belongs to another service", 409)
+    return value
+
+
+def ensure_server(directory, port, timeout=75):
+    with lock_file(directory / "launch.lock"):
+        try:
+            return health(directory, port)
+        except AppError as error:
+            if error.code != "api_unavailable":
+                raise
+        # Wait for a shutting-down service to finish releasing its worker and socket.
+        with lock_file(directory / "server.lock"):
+            pass
+        # Validate before spawning so configuration errors are immediately actionable.
+        from .config import load_runtime
+
+        load_runtime(directory)
+        log = directory / "server.log"
+        fd = os.open(log, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "w") as output:
+            child = subprocess.Popen(
+                [
+                    sys.executable,
+                    "-m",
+                    "wechat_cli",
+                    "serve",
+                    "--data-dir",
+                    str(directory),
+                    "--port",
+                    str(port),
+                ],
+                stdin=subprocess.DEVNULL,
+                stdout=output,
+                stderr=output,
+                start_new_session=True,
+            )
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            if child.poll() is not None:
+                try:
+                    error = json.loads(log.read_text().splitlines()[-1])
+                    raise AppError(error["error"], error["message"], 424)
+                except (ValueError, KeyError, IndexError):
+                    raise AppError(
+                        "server_start_failed", f"Service failed to start; inspect {log}", 424
+                    ) from None
+            try:
+                return health(directory, port)
+            except AppError as error:
+                if error.code != "api_unavailable":
+                    raise
+            time.sleep(0.1)
+        # This is our own child, never a process selected from a stale PID file.
+        child.terminate()
+        raise AppError("server_start_timeout", f"Service startup timed out; inspect {log}", 504)
+
+
+def serve(directory, port):
+    from .server import ApiServer
+
+    with lock_file(directory / "server.lock", blocking=False):
+        native = NativeBridge(directory)
+        server = None
+        try:
+            # Connect eagerly: start really launches WeChat, rather than waiting for the first API call.
+            native.connect()
+            server = ApiServer(("127.0.0.1", port), directory, native=native)
+            save_json(
+                directory / "server.json",
+                {"port": server.server_address[1], "instance": server.instance, "pid": os.getpid()},
+            )
+
+            def stop(_signal, _frame):
+                threading.Thread(target=server.shutdown, daemon=True).start()
+
+            previous = {sig: signal.signal(sig, stop) for sig in [signal.SIGINT, signal.SIGTERM]}
+            print(json.dumps({"listening": f"http://127.0.0.1:{server.server_address[1]}"}), flush=True)
+            try:
+                server.serve_forever(poll_interval=0.1)
+            finally:
+                for sig, handler in previous.items():
+                    signal.signal(sig, handler)
+        except OSError as error:
+            raise AppError(
+                "server_bind_failed", f"Cannot bind 127.0.0.1:{port}; choose another --port", 409
+            ) from error
+        finally:
+            if server:
+                server.server_close()
+            else:
+                native.close()
+            (directory / "server.json").unlink(missing_ok=True)