coding-bridge 2026.7.3.1__tar.gz → 2026.7.3.2__tar.gz

{coding_bridge-2026.7.3.1 → coding_bridge-2026.7.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coding-bridge
-Version: 2026.7.3.1
+Version: 2026.7.3.2
 Summary: Node daemon for AceDataCloud Coding Bridge — run Claude Code on your own machine and drive it from the web.
 Project-URL: Homepage, https://github.com/AceDataCloud/CodingBridge
 Project-URL: Issues, https://github.com/AceDataCloud/CodingBridge/issues
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
 Requires-Dist: claude-agent-sdk>=0.1.0
 Requires-Dist: httpx<0.29,>=0.27
+Requires-Dist: tomli>=2.0; python_version < '3.11'
 Requires-Dist: websockets<14,>=12
 Provides-Extra: dev
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'

{coding_bridge-2026.7.3.1 → coding_bridge-2026.7.3.2}/coding_bridge/channels/__init__.py

@@ -17,13 +17,25 @@ from .base import (
     MessageHandler,
     SendResult,
 )
+from .config import (
+    ChannelsConfig,
+    ConfigError,
+    WeChatInstanceConfig,
+    load_channels_config,
+    parse_channels_config,
+)
 from .dispatcher import SessionDispatcher
 
 __all__ = [
     "ChannelAdapter",
     "ChannelTarget",
+    "ChannelsConfig",
+    "ConfigError",
     "IncomingMessage",
     "MessageHandler",
     "SendResult",
     "SessionDispatcher",
+    "WeChatInstanceConfig",
+    "load_channels_config",
+    "parse_channels_config",
 ]

coding_bridge-2026.7.3.2/coding_bridge/channels/config.py

@@ -0,0 +1,282 @@
+"""Channels config schema — parses ``~/.ace-bridge/channels.toml``.
+
+Split from ``coding_bridge.config`` on purpose: channels are optional and evolve
+independently of the core node settings. Users who never touch channels never
+load this module.
+
+Schema (fail-fast; unknown keys raise):
+
+.. code-block:: toml
+
+    [channels]
+    # (reserved for future globals)
+
+    [[channels.wechat]]
+    instance_id = "beijing-cvm"        # required, unique per file
+    base_url = "http://82.156.126.14:8000"  # required, http:// or https://
+    token_env = "WECHAT_TOKEN_BEIJING"   # required unless token_file is set
+    token_file = "/run/secrets/beijing"  # optional alternative to token_env
+    enabled = false                      # default false — explicit opt-in
+    default_provider = "claude"          # optional override for this instance
+
+Design notes:
+
+* The **token itself never lives in the TOML file** — the file references an
+  env var name (`token_env`) or a secrets-file path (`token_file`). This
+  matches the deployment templates in P8 (systemd EnvironmentFile,
+  launchd, Windows service credentials store).
+* `enabled = false` is the default so accidentally shipping a `channels.toml`
+  never puts an unsupervised bot online.
+* Unknown keys raise — a typo like `intance_id` or `allowlist_typo` should
+  fail loudly at boot, not silently degrade to unsafe defaults.
+* A hard 1 MB cap on the TOML file guards against accidentally pointing at
+  ``/dev/urandom`` or a runaway log.
+* ``base_url`` may not contain embedded userinfo (``http://user:pass@host``);
+  credentials go through ``token_env``/``token_file`` only.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+try:
+    import tomllib as _toml
+except ModuleNotFoundError:  # Python 3.10
+    import tomli as _toml  # type: ignore[import-not-found]
+
+_WECHAT_KEYS = frozenset(
+    {"instance_id", "base_url", "token_env", "token_file", "enabled", "default_provider"}
+)
+_CHANNELS_KEYS = frozenset({"wechat"})
+
+# Cap the TOML file size so a misconfigured `channels.toml` pointing at
+# `/dev/urandom` or similar can't OOM the daemon at startup.
+_MAX_TOML_BYTES = 1_000_000
+
+# Cap the token file so `token_file = "/dev/urandom"` also can't OOM us.
+# Real API tokens are ~64–512 bytes; 64 KB is generous.
+_MAX_TOKEN_BYTES = 64 * 1024
+
+
+class ConfigError(ValueError):
+    """Raised for any schema violation — never caught silently."""
+
+
+@dataclass(frozen=True)
+class WeChatInstanceConfig:
+    """One `[[channels.wechat]]` block."""
+
+    instance_id: str
+    base_url: str
+    token_env: str | None = None
+    token_file: str | None = None
+    enabled: bool = False
+    default_provider: str | None = None
+
+    def resolve_token(self, environ: dict[str, str] | None = None) -> str:
+        """Load the token from env var or secrets file. Never logs it.
+
+        Raises ``ConfigError`` with a **redacted** message if the token can't
+        be resolved — the message references the env-var *name* or file path,
+        never the value.
+        """
+        env = environ if environ is not None else dict(os.environ)
+        if self.token_env:
+            token = env.get(self.token_env)
+            if not token:
+                raise ConfigError(
+                    f"wechat instance {self.instance_id!r}: env var "
+                    f"{self.token_env!r} is unset or empty"
+                )
+            return token
+        if self.token_file:
+            path = Path(self.token_file).expanduser()
+            try:
+                # Reject anything that isn't a regular file up front so a
+                # symlink pointing at a directory / device raises a clean
+                # ConfigError instead of a raw OSError / UnicodeDecodeError.
+                if not path.is_file():
+                    raise ConfigError(
+                        f"wechat instance {self.instance_id!r}: token_file "
+                        f"{str(path)!r} is not a regular file"
+                    )
+                size = path.stat().st_size
+                if size > _MAX_TOKEN_BYTES:
+                    raise ConfigError(
+                        f"wechat instance {self.instance_id!r}: token_file "
+                        f"{str(path)!r} exceeds {_MAX_TOKEN_BYTES}-byte limit"
+                    )
+                raw = path.read_bytes()
+            except OSError as exc:
+                raise ConfigError(
+                    f"wechat instance {self.instance_id!r}: cannot read "
+                    f"token_file {str(path)!r}: {exc.__class__.__name__}"
+                ) from None
+            try:
+                token = raw.decode("utf-8").strip()
+            except UnicodeDecodeError:
+                raise ConfigError(
+                    f"wechat instance {self.instance_id!r}: token_file "
+                    f"{str(path)!r} is not valid UTF-8"
+                ) from None
+            if not token:
+                raise ConfigError(
+                    f"wechat instance {self.instance_id!r}: token_file "
+                    f"{str(path)!r} is empty"
+                )
+            return token
+        raise ConfigError(
+            f"wechat instance {self.instance_id!r}: either token_env or "
+            "token_file must be set"
+        )
+
+
+@dataclass(frozen=True)
+class ChannelsConfig:
+    """Root of the channels config file."""
+
+    wechat: tuple[WeChatInstanceConfig, ...] = field(default_factory=tuple)
+
+    @property
+    def enabled_wechat(self) -> tuple[WeChatInstanceConfig, ...]:
+        return tuple(inst for inst in self.wechat if inst.enabled)
+
+
+def _require(kind: str, block: dict[str, Any], key: str) -> Any:
+    value = block.get(key)
+    if value is None or value == "":
+        raise ConfigError(f"{kind}: required field {key!r} is missing or empty")
+    return value
+
+
+def _parse_wechat(block: dict[str, Any], index: int) -> WeChatInstanceConfig:
+    unknown = set(block.keys()) - _WECHAT_KEYS
+    if unknown:
+        raise ConfigError(
+            f"[[channels.wechat]] #{index}: unknown key(s) {sorted(unknown)!r}"
+        )
+    instance_id = _require(f"[[channels.wechat]] #{index}", block, "instance_id")
+    base_url = _require(f"[[channels.wechat]] #{index}", block, "base_url")
+    if not isinstance(instance_id, str):
+        raise ConfigError(f"[[channels.wechat]] #{index}: instance_id must be a string")
+    if not isinstance(base_url, str):
+        raise ConfigError(f"[[channels.wechat]] #{index}: base_url must be a string")
+    if not (base_url.startswith("http://") or base_url.startswith("https://")):
+        raise ConfigError(
+            f"[[channels.wechat]] {instance_id!r}: base_url must start with "
+            "http:// or https://"
+        )
+    # Reject `http://user:pass@host` so tokens never travel via base_url.
+    # `urlparse` folds userinfo into `netloc`; a bare `@` in the path segment
+    # after the host doesn't count because it's not in netloc.
+    if "@" in urlparse(base_url).netloc:
+        raise ConfigError(
+            f"[[channels.wechat]] {instance_id!r}: base_url must not contain "
+            "embedded credentials (user:pass@host); use token_env/token_file"
+        )
+    token_env = block.get("token_env")
+    token_file = block.get("token_file")
+    if token_env is not None and not isinstance(token_env, str):
+        raise ConfigError(f"[[channels.wechat]] {instance_id!r}: token_env must be a string")
+    if token_file is not None and not isinstance(token_file, str):
+        raise ConfigError(f"[[channels.wechat]] {instance_id!r}: token_file must be a string")
+    if token_env and token_file:
+        raise ConfigError(
+            f"[[channels.wechat]] {instance_id!r}: set token_env OR token_file, not both"
+        )
+    enabled = block.get("enabled", False)
+    # `isinstance(True, int) is True` in Python, so guard against the reverse
+    # (`enabled = 1` in TOML → int → we want a hard error, not a silent truthy).
+    if not isinstance(enabled, bool):
+        raise ConfigError(f"[[channels.wechat]] {instance_id!r}: enabled must be a bool")
+    default_provider = block.get("default_provider")
+    if default_provider is not None and not isinstance(default_provider, str):
+        raise ConfigError(
+            f"[[channels.wechat]] {instance_id!r}: default_provider must be a string"
+        )
+    return WeChatInstanceConfig(
+        instance_id=instance_id,
+        base_url=base_url.rstrip("/"),
+        token_env=token_env,
+        token_file=token_file,
+        enabled=enabled,
+        default_provider=default_provider,
+    )
+
+
+def parse_channels_config(data: dict[str, Any]) -> ChannelsConfig:
+    """Parse an already-decoded TOML mapping. Public for test use."""
+    channels = data.get("channels")
+    if channels is None:
+        return ChannelsConfig()
+    if not isinstance(channels, dict):
+        raise ConfigError("[channels]: must be a table")
+    unknown = set(channels.keys()) - _CHANNELS_KEYS
+    if unknown:
+        raise ConfigError(f"[channels]: unknown key(s) {sorted(unknown)!r}")
+
+    wechat_blocks = channels.get("wechat", [])
+    if not isinstance(wechat_blocks, list):
+        raise ConfigError("[[channels.wechat]]: must be an array of tables")
+
+    parsed: list[WeChatInstanceConfig] = []
+    seen_ids: set[str] = set()
+    for i, block in enumerate(wechat_blocks):
+        if not isinstance(block, dict):
+            raise ConfigError(f"[[channels.wechat]] #{i}: must be a table")
+        inst = _parse_wechat(block, i)
+        if inst.instance_id in seen_ids:
+            raise ConfigError(
+                f"[[channels.wechat]]: duplicate instance_id {inst.instance_id!r}"
+            )
+        seen_ids.add(inst.instance_id)
+        parsed.append(inst)
+    return ChannelsConfig(wechat=tuple(parsed))
+
+
+def load_channels_config(path: Path) -> ChannelsConfig:
+    """Read + parse a TOML file. Missing file → empty config (no channels).
+
+    Wraps every filesystem / decode error in ``ConfigError`` so the daemon
+    can surface a clean startup message instead of an unhandled traceback.
+    """
+    if not path.exists():
+        return ChannelsConfig()
+    if not path.is_file():
+        raise ConfigError(f"channels config {str(path)!r} is not a regular file")
+    try:
+        size = path.stat().st_size
+    except OSError as exc:
+        raise ConfigError(
+            f"channels config {str(path)!r}: cannot stat: {exc.__class__.__name__}"
+        ) from None
+    if size > _MAX_TOML_BYTES:
+        raise ConfigError(
+            f"channels config {str(path)!r} exceeds {_MAX_TOML_BYTES}-byte limit "
+            f"({size} bytes)"
+        )
+    try:
+        with path.open("rb") as f:
+            data = _toml.load(f)
+    except _toml.TOMLDecodeError as exc:
+        raise ConfigError(
+            f"channels config {str(path)!r} is not valid TOML: {exc}"
+        ) from None
+    except OSError as exc:
+        raise ConfigError(
+            f"channels config {str(path)!r}: cannot read: {exc.__class__.__name__}"
+        ) from None
+    return parse_channels_config(data)
+
+
+__all__ = [
+    "ChannelsConfig",
+    "ConfigError",
+    "WeChatInstanceConfig",
+    "load_channels_config",
+    "parse_channels_config",
+]

{coding_bridge-2026.7.3.1 → coding_bridge-2026.7.3.2}/coding_bridge/config.py

@@ -105,6 +105,11 @@ class Settings:
     def credentials_path(self) -> Path:
         return self.config_dir / "credentials.json"
 
+    @property
+    def channels_config_path(self) -> Path:
+        """Location of the optional TOML file describing channel adapters."""
+        return self.config_dir / "channels.toml"
+
     @classmethod
     def from_env(cls) -> Settings:
         def _f(name: str, default: float) -> float:

{coding_bridge-2026.7.3.1 → coding_bridge-2026.7.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "coding-bridge"
-version = "2026.7.3.1"
+version = "2026.7.3.2"
 description = "Node daemon for AceDataCloud Coding Bridge — run Claude Code on your own machine and drive it from the web."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -23,6 +23,7 @@ dependencies = [
     "websockets>=12,<14",
     "httpx>=0.27,<0.29",
     "claude-agent-sdk>=0.1.0",
+    "tomli>=2.0;python_version<'3.11'",
 ]
 
 [project.optional-dependencies]

coding_bridge-2026.7.3.2/tests/test_channels_config.py

@@ -0,0 +1,384 @@
+"""Tests for ``coding_bridge.channels.config`` — the TOML schema loader."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from coding_bridge.channels.config import (
+    ChannelsConfig,
+    ConfigError,
+    WeChatInstanceConfig,
+    load_channels_config,
+    parse_channels_config,
+)
+
+
+def _write(tmp_path: Path, body: str) -> Path:
+    p = tmp_path / "channels.toml"
+    p.write_text(body, encoding="utf-8")
+    return p
+
+
+class TestParseHappyPath:
+    def test_empty_file_returns_empty_config(self, tmp_path: Path) -> None:
+        p = _write(tmp_path, "")
+        assert load_channels_config(p) == ChannelsConfig()
+
+    def test_missing_file_returns_empty_config(self, tmp_path: Path) -> None:
+        assert load_channels_config(tmp_path / "does-not-exist.toml") == ChannelsConfig()
+
+    def test_single_wechat_instance_with_token_env(self, tmp_path: Path) -> None:
+        p = _write(
+            tmp_path,
+            """
+[[channels.wechat]]
+instance_id = "beijing-cvm"
+base_url = "http://82.156.126.14:8000"
+token_env = "WECHAT_TOKEN_BEIJING"
+enabled = true
+""",
+        )
+        cfg = load_channels_config(p)
+        assert len(cfg.wechat) == 1
+        inst = cfg.wechat[0]
+        assert inst.instance_id == "beijing-cvm"
+        assert inst.base_url == "http://82.156.126.14:8000"
+        assert inst.token_env == "WECHAT_TOKEN_BEIJING"
+        assert inst.enabled is True
+        assert inst.default_provider is None
+        assert cfg.enabled_wechat == (inst,)
+
+    def test_multiple_wechat_instances(self, tmp_path: Path) -> None:
+        p = _write(
+            tmp_path,
+            """
+[[channels.wechat]]
+instance_id = "one"
+base_url = "http://a"
+token_env = "T1"
+
+[[channels.wechat]]
+instance_id = "two"
+base_url = "https://b"
+token_env = "T2"
+enabled = true
+default_provider = "codex"
+""",
+        )
+        cfg = load_channels_config(p)
+        assert [inst.instance_id for inst in cfg.wechat] == ["one", "two"]
+        # `enabled=false` by default
+        assert cfg.wechat[0].enabled is False
+        assert cfg.wechat[1].enabled is True
+        assert cfg.wechat[1].default_provider == "codex"
+        assert cfg.enabled_wechat == (cfg.wechat[1],)
+
+    def test_base_url_trailing_slash_stripped(self, tmp_path: Path) -> None:
+        p = _write(
+            tmp_path,
+            """
+[[channels.wechat]]
+instance_id = "x"
+base_url = "https://example.com/"
+token_env = "T"
+""",
+        )
+        cfg = load_channels_config(p)
+        assert cfg.wechat[0].base_url == "https://example.com"
+
+    def test_token_file_alternative(self, tmp_path: Path) -> None:
+        p = _write(
+            tmp_path,
+            """
+[[channels.wechat]]
+instance_id = "x"
+base_url = "http://a"
+token_file = "/run/secrets/wechat"
+""",
+        )
+        cfg = load_channels_config(p)
+        assert cfg.wechat[0].token_file == "/run/secrets/wechat"
+        assert cfg.wechat[0].token_env is None
+
+
+class TestParseFailFast:
+    def test_unknown_top_level_key_rejected(self) -> None:
+        with pytest.raises(ConfigError, match=r"\[channels\]: unknown key\(s\)"):
+            parse_channels_config({"channels": {"foo": []}})
+
+    def test_channels_must_be_a_table(self) -> None:
+        with pytest.raises(ConfigError, match=r"\[channels\]: must be a table"):
+            parse_channels_config({"channels": "not a table"})
+
+    def test_wechat_array_must_be_list(self) -> None:
+        with pytest.raises(ConfigError, match=r"\[\[channels\.wechat\]\]"):
+            parse_channels_config({"channels": {"wechat": "not a list"}})
+
+    def test_unknown_wechat_key_rejected(self) -> None:
+        # Typo: `intance_id` instead of `instance_id`
+        with pytest.raises(ConfigError, match=r"unknown key\(s\).*intance_id"):
+            parse_channels_config(
+                {
+                    "channels": {
+                        "wechat": [
+                            {
+                                "intance_id": "typo",
+                                "base_url": "http://a",
+                                "token_env": "T",
+                            }
+                        ]
+                    }
+                }
+            )
+
+    def test_missing_instance_id_rejected(self) -> None:
+        with pytest.raises(ConfigError, match=r"required field 'instance_id'"):
+            parse_channels_config(
+                {"channels": {"wechat": [{"base_url": "http://a", "token_env": "T"}]}}
+            )
+
+    def test_missing_base_url_rejected(self) -> None:
+        with pytest.raises(ConfigError, match=r"required field 'base_url'"):
+            parse_channels_config(
+                {"channels": {"wechat": [{"instance_id": "x", "token_env": "T"}]}}
+            )
+
+    def test_empty_instance_id_rejected(self) -> None:
+        with pytest.raises(ConfigError, match=r"required field 'instance_id'"):
+            parse_channels_config(
+                {
+                    "channels": {
+                        "wechat": [
+                            {"instance_id": "", "base_url": "http://a", "token_env": "T"}
+                        ]
+                    }
+                }
+            )
+
+    def test_bad_base_url_scheme_rejected(self) -> None:
+        with pytest.raises(ConfigError, match=r"base_url must start with http"):
+            parse_channels_config(
+                {
+                    "channels": {
+                        "wechat": [
+                            {
+                                "instance_id": "x",
+                                "base_url": "ftp://oops",
+                                "token_env": "T",
+                            }
+                        ]
+                    }
+                }
+            )
+
+    def test_both_token_env_and_token_file_rejected(self) -> None:
+        with pytest.raises(ConfigError, match=r"set token_env OR token_file, not both"):
+            parse_channels_config(
+                {
+                    "channels": {
+                        "wechat": [
+                            {
+                                "instance_id": "x",
+                                "base_url": "http://a",
+                                "token_env": "T",
+                                "token_file": "/tmp/tok",
+                            }
+                        ]
+                    }
+                }
+            )
+
+    def test_enabled_must_be_bool(self) -> None:
+        with pytest.raises(ConfigError, match=r"enabled must be a bool"):
+            parse_channels_config(
+                {
+                    "channels": {
+                        "wechat": [
+                            {
+                                "instance_id": "x",
+                                "base_url": "http://a",
+                                "token_env": "T",
+                                "enabled": "yes",
+                            }
+                        ]
+                    }
+                }
+            )
+
+    def test_default_provider_must_be_string(self) -> None:
+        with pytest.raises(ConfigError, match=r"default_provider must be a string"):
+            parse_channels_config(
+                {
+                    "channels": {
+                        "wechat": [
+                            {
+                                "instance_id": "x",
+                                "base_url": "http://a",
+                                "token_env": "T",
+                                "default_provider": 123,
+                            }
+                        ]
+                    }
+                }
+            )
+
+    def test_duplicate_instance_id_rejected(self) -> None:
+        with pytest.raises(ConfigError, match=r"duplicate instance_id 'dup'"):
+            parse_channels_config(
+                {
+                    "channels": {
+                        "wechat": [
+                            {"instance_id": "dup", "base_url": "http://a", "token_env": "T"},
+                            {"instance_id": "dup", "base_url": "http://b", "token_env": "U"},
+                        ]
+                    }
+                }
+            )
+
+    def test_malformed_toml_rejected(self, tmp_path: Path) -> None:
+        p = _write(tmp_path, "[[channels.wechat\ninstance_id = 'oops'")
+        with pytest.raises(ConfigError, match=r"is not valid TOML"):
+            load_channels_config(p)
+
+    def test_channels_file_is_directory_rejected(self, tmp_path: Path) -> None:
+        p = tmp_path / "channels.toml"
+        p.mkdir()
+        with pytest.raises(ConfigError, match=r"is not a regular file"):
+            load_channels_config(p)
+
+    def test_channels_file_over_size_limit_rejected(self, tmp_path: Path) -> None:
+        # Write just over 1 MB of harmless comments so parser never runs.
+        p = tmp_path / "channels.toml"
+        p.write_bytes(b"# padding\n" * 110_000)
+        with pytest.raises(ConfigError, match=r"exceeds .*-byte limit"):
+            load_channels_config(p)
+
+    def test_base_url_with_embedded_userinfo_rejected(self) -> None:
+        with pytest.raises(ConfigError, match=r"embedded credentials"):
+            parse_channels_config(
+                {
+                    "channels": {
+                        "wechat": [
+                            {
+                                "instance_id": "x",
+                                "base_url": "http://user:pass@host",
+                                "token_env": "T",
+                            }
+                        ]
+                    }
+                }
+            )
+
+    def test_enabled_as_int_rejected(self) -> None:
+        # TOML doesn't parse `1` as bool, but if a caller passes a Python int
+        # from a hand-built dict this must still fail — not silently truthy.
+        with pytest.raises(ConfigError, match=r"enabled must be a bool"):
+            parse_channels_config(
+                {
+                    "channels": {
+                        "wechat": [
+                            {
+                                "instance_id": "x",
+                                "base_url": "http://a",
+                                "token_env": "T",
+                                "enabled": 1,
+                            }
+                        ]
+                    }
+                }
+            )
+
+
+class TestResolveToken:
+    def test_resolve_from_env(self) -> None:
+        inst = WeChatInstanceConfig(
+            instance_id="x", base_url="http://a", token_env="MY_TOKEN"
+        )
+        assert inst.resolve_token({"MY_TOKEN": "secret-123"}) == "secret-123"
+
+    def test_missing_env_raises_without_leaking_value(self) -> None:
+        inst = WeChatInstanceConfig(
+            instance_id="x", base_url="http://a", token_env="MISSING_VAR"
+        )
+        with pytest.raises(ConfigError) as exc:
+            inst.resolve_token({})
+        # Message references the *name*, not any value
+        assert "MISSING_VAR" in str(exc.value)
+        assert "unset or empty" in str(exc.value)
+
+    def test_empty_env_value_treated_as_missing(self) -> None:
+        inst = WeChatInstanceConfig(
+            instance_id="x", base_url="http://a", token_env="EMPTY"
+        )
+        with pytest.raises(ConfigError, match=r"unset or empty"):
+            inst.resolve_token({"EMPTY": ""})
+
+    def test_resolve_from_file(self, tmp_path: Path) -> None:
+        f = tmp_path / "tok"
+        f.write_text("file-secret\n", encoding="utf-8")
+        inst = WeChatInstanceConfig(
+            instance_id="x", base_url="http://a", token_file=str(f)
+        )
+        # Trailing whitespace stripped
+        assert inst.resolve_token({}) == "file-secret"
+
+    def test_missing_file_raises(self, tmp_path: Path) -> None:
+        inst = WeChatInstanceConfig(
+            instance_id="x", base_url="http://a", token_file=str(tmp_path / "nope")
+        )
+        with pytest.raises(ConfigError) as exc:
+            inst.resolve_token({})
+        assert "is not a regular file" in str(exc.value)
+
+    def test_token_file_is_directory_rejected(self, tmp_path: Path) -> None:
+        d = tmp_path / "dir"
+        d.mkdir()
+        inst = WeChatInstanceConfig(
+            instance_id="x", base_url="http://a", token_file=str(d)
+        )
+        with pytest.raises(ConfigError, match=r"is not a regular file"):
+            inst.resolve_token({})
+
+    def test_token_file_with_invalid_utf8_rejected(self, tmp_path: Path) -> None:
+        f = tmp_path / "tok"
+        f.write_bytes(b"\xff\xfe\xfd")
+        inst = WeChatInstanceConfig(
+            instance_id="x", base_url="http://a", token_file=str(f)
+        )
+        with pytest.raises(ConfigError, match=r"not valid UTF-8"):
+            inst.resolve_token({})
+
+    def test_token_file_over_size_limit_rejected(self, tmp_path: Path) -> None:
+        f = tmp_path / "tok"
+        # 64 KB + 1 byte, filled with an ASCII char that would decode fine —
+        # the size check must fire *before* the read.
+        f.write_bytes(b"a" * (64 * 1024 + 1))
+        inst = WeChatInstanceConfig(
+            instance_id="x", base_url="http://a", token_file=str(f)
+        )
+        with pytest.raises(ConfigError, match=r"exceeds .*-byte limit"):
+            inst.resolve_token({})
+
+    def test_empty_file_raises(self, tmp_path: Path) -> None:
+        f = tmp_path / "tok"
+        f.write_text("   \n\n", encoding="utf-8")
+        inst = WeChatInstanceConfig(
+            instance_id="x", base_url="http://a", token_file=str(f)
+        )
+        with pytest.raises(ConfigError, match=r"is empty"):
+            inst.resolve_token({})
+
+    def test_no_source_configured_raises(self) -> None:
+        inst = WeChatInstanceConfig(instance_id="x", base_url="http://a")
+        with pytest.raises(ConfigError, match=r"either token_env or token_file must be set"):
+            inst.resolve_token({})
+
+
+class TestSettingsIntegration:
+    def test_channels_config_path_is_under_config_dir(self, tmp_path: Path) -> None:
+        from coding_bridge.config import Settings
+
+        s = Settings(config_dir=tmp_path)
+        assert s.channels_config_path == tmp_path / "channels.toml"