codetherapy 0.1.0__py3-none-any.whl

codetherapy/__init__.py

@@ -0,0 +1,3 @@
+"""Code Therapy: talk to your Claude Code projects (by voice, from claude.ai) about how they're doing."""
+
+__version__ = "0.1.0"

codetherapy/__main__.py

@@ -0,0 +1,3 @@
+from codetherapy.cli import main
+
+raise SystemExit(main())

codetherapy/cli.py

@@ -0,0 +1,494 @@
+"""Command-line interface: setup, serve, url, rotate, start and doctor."""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import dataclasses
+import os
+import re
+import shutil
+import signal
+import socket
+import subprocess
+import sys
+import threading
+import time
+from pathlib import Path
+
+from mcp import Client
+
+from codetherapy import __version__, clipboard, procutil, server, tunnel
+from codetherapy import config as cfgmod
+from codetherapy.config import Config, ConfigError
+
+CLAUDE_DOCS = "https://docs.claude.com/en/docs/claude-code"
+CONNECTORS_PAGE = "https://claude.ai/settings/connectors"
+EXPECTED_TOOLS = 6
+LIVE_TIMEOUT = 20
+_PUBLIC_CHECK = True  # tests turn this off: there is no real public endpoint
+_children: list[subprocess.Popen] = []
+_sleep = time.sleep  # tests patch this, not the global time.sleep
+SERVER_LABEL = "The Code Therapy server"
+NGROK_LABEL = "ngrok"
+STOP_SIGNALS = ("SIGTERM", "SIGHUP", "SIGBREAK")  # treated like Ctrl+C by a blocking start
+
+
+def connector_url(config: Config) -> str:
+    return f"https://{config.public_host}/mcp/{config.token}"
+
+
+def _normalize_host(raw: str) -> str:
+    host = re.sub(r"^https?://", "", raw.strip(), flags=re.I)
+    host = re.split(r"[/?#]", host, maxsplit=1)[0]
+    return host.rpartition("@")[2].strip().lower()
+
+
+def _valid_host(host: str) -> bool:
+    return bool(host) and "." in host and not host.endswith(".") and not re.search(r"\s", host)
+
+
+def _err(message: str) -> None:
+    print(message, file=sys.stderr)
+
+
+def _config_file(args: argparse.Namespace) -> Path:
+    return Path(args.config).expanduser() if args.config else cfgmod.config_path()
+
+
+def _ngrok_install_hint(first_line: str, file=None) -> None:
+    for line in (first_line, "    Windows: winget install ngrok.ngrok", "    macOS:   brew install ngrok",
+                 "    Other:   https://ngrok.com/download"):
+        print(line, file=file)
+
+
+def _check_prerequisites(use_ngrok: bool) -> bool:
+    if shutil.which("claude"):
+        print("✓ claude found on PATH")
+    else:
+        print(f"! claude not found on PATH: the ask_project tool won't work until Claude Code is installed ({CLAUDE_DOCS})")
+    if not use_ngrok:
+        return True
+    ngrok = tunnel.find_ngrok()
+    if not ngrok:
+        _ngrok_install_hint("! ngrok not found. Install it, then run `codetherapy setup` again:")
+        return False
+    print("✓ ngrok found")
+    if not tunnel.ngrok_has_authtoken(ngrok):
+        print("! ngrok has no authtoken. Copy yours from https://dashboard.ngrok.com/get-started/your-authtoken, then run:")
+        print("    ngrok config add-authtoken <token>")
+        return False
+    print("✓ ngrok authtoken configured")
+    return True
+
+
+def _cmd_setup(args: argparse.Namespace) -> int:
+    path = _config_file(args)
+    values = cfgmod.read_values(path)
+    print(f"Code Therapy setup — config file: {path}")
+    if args.no_tunnel:
+        values["CODETHERAPY_TUNNEL"] = "none"
+    elif args.ngrok:
+        values["CODETHERAPY_TUNNEL"] = "ngrok"
+    use_ngrok = values.get("CODETHERAPY_TUNNEL", "ngrok").lower() != "none"
+    print("Tunnel: ngrok" if use_ngrok else "Tunnel: none (bring your own)")
+    if not _check_prerequisites(use_ngrok):
+        return 1
+
+    host = _normalize_host(args.public_host) if args.public_host else values.get("CODETHERAPY_PUBLIC_HOST", "")
+    if not host:
+        if not use_ngrok:
+            _err("With --no-tunnel, pass --public-host <your tunnel's hostname> (e.g. box.tailnet.ts.net).")
+            return 1
+        if args.yes:
+            _err("No public host known. Pass --public-host <your domain>.")
+            return 1
+        host = _normalize_host(input("Your ngrok static domain (dashboard.ngrok.com → Domains), e.g. name.ngrok-free.dev: "))
+    if not _valid_host(host):
+        _err(f"'{host}' is not a valid host name (expected something like name.ngrok-free.dev).")
+        return 1
+    values["CODETHERAPY_PUBLIC_HOST"] = host
+
+    if args.port is not None:
+        values["CODETHERAPY_PORT"] = str(args.port)
+    if args.projects_dir:
+        values["CODETHERAPY_PROJECTS_DIR"] = args.projects_dir
+    if args.rotate or not values.get("CODETHERAPY_TOKEN"):
+        values["CODETHERAPY_TOKEN"] = cfgmod.generate_token()
+    cfgmod.save_values(values, path)
+    print("Saved. Next: run `codetherapy start`.")
+    return 0
+
+
+def _cmd_serve(args: argparse.Namespace) -> int:
+    server.run(cfgmod.load_config(_config_file(args)))
+    return 0
+
+
+def _cmd_url(args: argparse.Namespace) -> int:
+    config = cfgmod.load_config(_config_file(args))
+    if not config.public_host:
+        _err("No public host configured. Run `codetherapy setup` first.")
+        return 1
+    _err("This URL is your connector's password. Don't share it.")
+    url = connector_url(config)
+    print(url)
+    if args.copy:
+        _err("copied" if clipboard.copy(url) else "(copy it from above)")
+    return 0
+
+
+def _cmd_rotate(args: argparse.Namespace) -> int:
+    path = _config_file(args)
+    values = cfgmod.read_values(path)
+    values["CODETHERAPY_TOKEN"] = cfgmod.generate_token()
+    cfgmod.save_values(values, path)
+    print("New token saved. Restart `codetherapy start`, then update the connector URL on claude.ai "
+          "(run `codetherapy url`).")
+    return 0
+
+
+def _port_arg(text: str) -> int:
+    try:
+        port = int(text)
+    except ValueError:
+        port = 0
+    if not 1 <= port <= 65535:
+        raise argparse.ArgumentTypeError(f"{text!r} is not a port number (1-65535)")
+    return port
+
+
+def port_open(port: int, timeout: float = 0.3) -> bool:
+    try:
+        with socket.create_connection(("127.0.0.1", port), timeout):
+            return True
+    except (OSError, OverflowError, ValueError):
+        return False
+
+
+def wait_port(port: int, proc: subprocess.Popen, timeout: float) -> bool:
+    deadline = time.monotonic() + timeout
+    while True:
+        if proc.poll() is not None:
+            return False
+        if port_open(port):
+            return True
+        if time.monotonic() >= deadline:
+            return False
+        time.sleep(0.25)
+
+
+def stop_children() -> None:
+    """Kill every child tree. Ctrl+C is ignored meanwhile, so a second press can't leave one running."""
+    ignoring = threading.current_thread() is threading.main_thread()
+    previous = signal.signal(signal.SIGINT, signal.SIG_IGN) if ignoring else None
+    try:
+        while _children:
+            try:
+                procutil.kill_tree(_children[-1])
+            except KeyboardInterrupt:  # raised before SIG_IGN took effect, or by a stop signal; retry
+                continue
+            _children.pop()
+    finally:
+        if ignoring:
+            signal.signal(signal.SIGINT, previous)
+
+
+def _stop_signal(signum, frame):
+    raise KeyboardInterrupt
+
+
+def _install_stop_handlers() -> dict:
+    """Make SIGTERM, SIGHUP and SIGBREAK behave like Ctrl+C, so `finally` cleanup runs."""
+    if threading.current_thread() is not threading.main_thread():
+        return {}
+    previous = {}
+    for name in STOP_SIGNALS:
+        sig = getattr(signal, name, None)
+        if sig is not None:
+            previous[sig] = signal.signal(sig, _stop_signal)
+    return previous
+
+
+def _restore_handlers(previous: dict) -> None:
+    for sig, handler in previous.items():
+        signal.signal(sig, handler)
+
+
+def _spawn(cmd: list[str], **kwargs) -> subprocess.Popen:
+    proc = subprocess.Popen(cmd, **kwargs, **procutil.popen_group_kwargs())
+    _children.append(proc)
+    return proc
+
+
+def _launch(config: Config, ngrok: list[str] | None, config_file: Path | None,
+            use_tunnel: bool) -> list[tuple[str, subprocess.Popen]] | None:
+    """Start the server (and ngrok); return the labelled children, or None after reporting a failure."""
+    ngrok_cmd: list[str] | None = None
+    if use_tunnel:  # check before starting anything, so a missing ngrok doesn't leave a server behind
+        if not config.public_host:
+            _err("No public host configured. Run `codetherapy setup` first.")
+            return None
+        if ngrok is None:
+            found = tunnel.find_ngrok()
+            if not found:
+                _ngrok_install_hint("ngrok not found. Install it, then run `codetherapy start` again:", file=sys.stderr)
+                return None
+            ngrok_cmd = tunnel.ngrok_command(found, config.port, config.public_host)
+        else:
+            ngrok_cmd = [*ngrok, *tunnel.ngrok_command("ngrok", config.port, config.public_host)[1:]]
+
+    serve_cmd = [sys.executable, "-m", "codetherapy", *(["--config", str(config_file)] if config_file else []), "serve"]
+    env = {**os.environ, "CODETHERAPY_PORT": str(config.port)}
+    if config.public_host:  # so a --public-host override reaches the server's allowed-hosts list
+        env["CODETHERAPY_PUBLIC_HOST"] = config.public_host
+    server_proc = _spawn(serve_cmd, env=env)
+    procs = [(SERVER_LABEL, server_proc)]
+    if not wait_port(config.port, server_proc, 20):
+        _err("Code Therapy server didn't start (see messages above).")
+        return None
+
+    if ngrok_cmd:
+        ngrok_proc = _spawn(ngrok_cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                            text=True, encoding="utf-8", errors="replace")
+        procs.append((NGROK_LABEL, ngrok_proc))
+        ok, problem = tunnel.wait_online(ngrok_proc, 20)
+        if not ok:
+            _err(problem)
+            _report_ngrok_lines(_ngrok_lines(ngrok_proc, wait=1.0))  # e.g. "ERROR: unknown flag: --url"
+            return None
+
+    if use_tunnel or config.public_host:
+        url, note = connector_url(config), None
+    else:
+        url = f"http://127.0.0.1:{config.port}/mcp/{config.token}"
+        note = (f"Note: claude.ai needs a public HTTPS URL. Put a tunnel in front of port {config.port}, then run "
+                "`codetherapy setup --no-tunnel --public-host <its hostname>`.")
+    print("Code Therapy is running.")
+    print("Connector URL (keep it secret — it's the password):")
+    print(f"  {url}")
+    print("(copied to clipboard)" if clipboard.copy(url) else "(copy it from above)")
+    if note:
+        print(note)
+    print(f"Add it at {CONNECTORS_PAGE} → Add custom connector. Press Ctrl+C to stop.", flush=True)
+    return procs
+
+
+def _ngrok_lines(proc: subprocess.Popen, wait: float) -> list[str]:
+    """ngrok's recent non-blank output. Its args hold only the host, never the token."""
+    return [line.strip() for line in tunnel.recent_output(proc, wait=wait) if line.strip()]
+
+
+def _report_ngrok_lines(lines: list[str]) -> None:
+    if lines:
+        _err("Last ngrok messages:\n  " + "\n  ".join(line[:300] for line in lines[-5:]))
+
+
+def _report_stopped(label: str, proc: subprocess.Popen) -> None:
+    _err(f"{label} stopped (exit code {proc.returncode}).")
+    if label != NGROK_LABEL:
+        return
+    lines = _ngrok_lines(proc, wait=2.0)
+    hint = next((h for line in reversed(lines) if (h := tunnel.hint_for(line))), None)
+    if hint:
+        _err(hint)
+    else:
+        _report_ngrok_lines(lines)
+
+
+def _supervise(procs: list[tuple[str, subprocess.Popen]]) -> int:
+    """Wait for Ctrl+C (or a stop signal) or a child exiting; then stop everything."""
+    try:
+        while True:
+            for label, proc in procs:
+                if proc.poll() is not None:
+                    _report_stopped(label, proc)
+                    return 1
+            _sleep(0.5)
+    except KeyboardInterrupt:
+        return 0
+    finally:
+        stop_children()
+        print("Stopped.", flush=True)
+
+
+def start(config: Config, *, ngrok: list[str] | None = None, config_file: Path | None = None,
+          no_tunnel: bool = False, block: bool = True) -> int:
+    if port_open(config.port):
+        _err(f"port {config.port} is in use — is Code Therapy already running? Stop it or pass --port.")
+        return 1
+    use_tunnel = config.tunnel == "ngrok" and not no_tunnel
+    previous = _install_stop_handlers() if block else {}
+    try:
+        try:
+            procs = _launch(config, ngrok, config_file, use_tunnel)
+        except KeyboardInterrupt:
+            stop_children()
+            print("Stopped.", flush=True)
+            return 130
+        except BaseException:
+            stop_children()
+            raise
+        if procs is None:
+            stop_children()
+            return 1
+        return _supervise(procs) if block else 0
+    finally:
+        _restore_handlers(previous)
+
+
+def _cmd_start(args: argparse.Namespace) -> int:
+    path = _config_file(args)
+    config = cfgmod.load_config(path)
+    if args.port is not None:
+        config = dataclasses.replace(config, port=args.port)
+    if args.public_host:
+        host = _normalize_host(args.public_host)
+        if not _valid_host(host):
+            _err(f"'{host}' is not a valid host name (expected something like name.ngrok-free.dev).")
+            return 1
+        config = dataclasses.replace(config, public_host=host)
+    return start(config, config_file=path, no_tunnel=args.no_tunnel)
+
+
+async def _probe(url: str) -> tuple[int, str]:
+    async with Client(url) as client:
+        tools = await client.list_tools()
+        result = await client.call_tool("list_projects", {})
+    text = next((block.text for block in result.content if getattr(block, "text", None)), "")
+    return len(tools.tools), text
+
+
+def _live_check(url: str, token: str) -> str | None:
+    """Run list_tools and list_projects against url; return a problem description, or None if it works."""
+    try:
+        count, text = asyncio.run(asyncio.wait_for(_probe(url), LIVE_TIMEOUT))
+    except TimeoutError:
+        return f"no answer within {LIVE_TIMEOUT}s"
+    except Exception as exc:  # report, don't crash: doctor is for when things are broken
+        while isinstance(exc, BaseExceptionGroup) and exc.exceptions:
+            exc = exc.exceptions[0]
+        detail = (str(exc) or type(exc).__name__).replace(token, "<token>")
+        return f"{type(exc).__name__}: {detail}"[:300]
+    if count != EXPECTED_TOOLS:
+        return f"expected {EXPECTED_TOOLS} tools, got {count}"
+    if not text:
+        return "list_projects returned no text"
+    return None
+
+
+def doctor(config_file: Path | None, *, port: int | None = None) -> int:
+    failed = False
+
+    def check(ok: bool, good: str, bad: str, *, warn_only: bool = False) -> bool:
+        nonlocal failed
+        if ok:
+            print(f"✓ {good}")
+        else:
+            print(f"{'!' if warn_only else '✗'} {bad}")
+            failed = failed or not warn_only
+        return ok
+
+    path = config_file or cfgmod.config_path()
+    if not path.is_file():
+        check(False, "", f"no config file at {path}. Run `codetherapy setup`.")
+        return 1
+    try:
+        config = cfgmod.load_config(path)
+    except ConfigError as exc:
+        check(False, "", str(exc))
+        return 1
+    check(True, f"config file loads ({path})", "")
+    if port is not None:  # match a `start --port N` run
+        config = dataclasses.replace(config, port=port)
+    check(bool(shutil.which("claude")), "claude found on PATH",
+          f"claude not found on PATH: the ask_project tool won't work until Claude Code is installed ({CLAUDE_DOCS})",
+          warn_only=True)
+    if config.tunnel == "ngrok":
+        check(bool(config.public_host), f"public host: {config.public_host}",
+              "no public host configured. Run `codetherapy setup`.")
+        ngrok = tunnel.find_ngrok()
+        if check(bool(ngrok), "ngrok found", "ngrok not found. Install it: winget install ngrok.ngrok (Windows), "
+                 "brew install ngrok (macOS), or https://ngrok.com/download"):
+            check(tunnel.ngrok_has_authtoken(ngrok), "ngrok authtoken configured",
+                  "ngrok has no authtoken. Run `ngrok config add-authtoken <token>` "
+                  "(token: https://dashboard.ngrok.com/get-started/your-authtoken).")
+
+    if not port_open(config.port):
+        print("! not running — start it with `codetherapy start`")
+        return 1 if failed else 0
+    print(f"✓ something is listening on port {config.port}")
+
+    problem = _live_check(f"http://127.0.0.1:{config.port}/mcp/{config.token}", config.token)
+    check(problem is None, f"local endpoint answers ({EXPECTED_TOOLS} tools, list_projects works)",
+          f"local endpoint failed: {problem}. Is another program using port {config.port}, or is the server "
+          "running with an old token? Restart `codetherapy start`.")
+    if _PUBLIC_CHECK:
+        if not config.public_host:
+            print("! no public host configured, so the public endpoint can't be checked")
+        else:
+            problem = _live_check(f"https://{config.public_host}/mcp/{config.token}", config.token)
+            check(problem is None, f"public endpoint answers through {config.public_host}",
+                  f"public endpoint failed: {problem}. Is the tunnel running and pointing at port {config.port}?")
+    return 1 if failed else 0
+
+
+def _cmd_doctor(args: argparse.Namespace) -> int:
+    return doctor(_config_file(args), port=args.port)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="codetherapy", description="Talk to your Claude Code projects about how they're doing.")
+    parser.add_argument("--version", action="store_true", help="show the version and exit")
+    parser.add_argument("--config", metavar="PATH", help="config file to use (default: per-user location)")
+    sub = parser.add_subparsers(dest="command")
+
+    setup = sub.add_parser("setup", help="check prerequisites and write the config file")
+    setup.add_argument("--public-host", metavar="HOST", help="public hostname (e.g. your ngrok static domain)")
+    tun = setup.add_mutually_exclusive_group()
+    tun.add_argument("--no-tunnel", action="store_true", help="use your own tunnel; requires --public-host")
+    tun.add_argument("--ngrok", action="store_true", help="switch back to the built-in ngrok tunnel")
+    setup.add_argument("--port", type=_port_arg, metavar="N", help="local port (default 8765)")
+    setup.add_argument("--projects-dir", metavar="DIR", help="Claude Code projects directory")
+    setup.add_argument("--rotate", action="store_true", help="generate a new token")
+    setup.add_argument("--yes", action="store_true", help="never prompt")
+    setup.set_defaults(func=_cmd_setup)
+
+    sub.add_parser("serve", help="run the server only (no tunnel)").set_defaults(func=_cmd_serve)
+    url = sub.add_parser("url", help="print the connector URL")
+    url.add_argument("--copy", action="store_true", help="also copy it to the clipboard")
+    url.set_defaults(func=_cmd_url)
+    sub.add_parser("rotate", help="replace the token").set_defaults(func=_cmd_rotate)
+    start_p = sub.add_parser("start", help="run the server and tunnel")
+    start_p.add_argument("--no-tunnel", action="store_true", help="don't start ngrok (bring your own tunnel)")
+    start_p.add_argument("--port", type=_port_arg, metavar="N", help="local port for this run")
+    start_p.add_argument("--public-host", metavar="HOST", help="public hostname for this run")
+    start_p.set_defaults(func=_cmd_start)
+    doctor_p = sub.add_parser("doctor", help="diagnose problems")
+    doctor_p.add_argument("--port", type=_port_arg, metavar="N", help="check this port (if you ran `start --port N`)")
+    doctor_p.set_defaults(func=_cmd_doctor)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            try:
+                stream.reconfigure(errors="replace")
+            except (ValueError, OSError):
+                pass
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.version:
+        print(f"codetherapy {__version__}")
+        return 0
+    if not getattr(args, "func", None):
+        parser.print_help()
+        return 2
+    try:
+        return args.func(args)
+    except ConfigError as exc:
+        _err(str(exc))
+        return 1
+    except (KeyboardInterrupt, EOFError) as exc:
+        _err("Aborted. Nothing was saved.")
+        return 130 if isinstance(exc, KeyboardInterrupt) else 1

codetherapy/clipboard.py

@@ -0,0 +1,30 @@
+"""Best-effort clipboard copy; callers print the text anyway."""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+
+
+def _command() -> list[str] | None:
+    if sys.platform == "win32":
+        return ["clip"]
+    if sys.platform == "darwin":
+        tool = shutil.which("pbcopy")
+        return [tool] if tool else None
+    for name, args in (("wl-copy", []), ("xclip", ["-selection", "clipboard"]), ("xsel", ["--clipboard", "--input"])):
+        tool = shutil.which(name)
+        if tool:
+            return [tool, *args]
+    return None
+
+
+def copy(text: str) -> bool:
+    cmd = _command()
+    if not cmd:
+        return False
+    try:
+        return subprocess.run(cmd, input=text, text=True, stdout=subprocess.DEVNULL,
+                              stderr=subprocess.DEVNULL, timeout=5).returncode == 0
+    except (OSError, ValueError, subprocess.TimeoutExpired):
+        return False

codetherapy/config.py

@@ -0,0 +1,99 @@
+"""Settings from the per-user config file and CODETHERAPY_* environment variables."""
+from __future__ import annotations
+
+import os
+import secrets
+import sys
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+APP = "codetherapy"
+PREFIX = "CODETHERAPY_"
+MIN_TOKEN_LENGTH = 32
+DEFAULT_PORT = 8765
+TUNNELS = ("ngrok", "none")
+KEY_ORDER = ("CODETHERAPY_TOKEN", "CODETHERAPY_PUBLIC_HOST", "CODETHERAPY_PORT",
+             "CODETHERAPY_TUNNEL", "CODETHERAPY_PROJECTS_DIR")
+
+
+class ConfigError(ValueError):
+    """Configuration is missing or invalid; the message tells the user what to do."""
+
+
+@dataclass(frozen=True)
+class Config:
+    token: str
+    port: int
+    projects_dir: Path
+    public_host: str
+    tunnel: str = "ngrok"
+
+
+def config_path(environ: Mapping[str, str] | None = None, platform: str | None = None,
+                home: Path | None = None) -> Path:
+    environ = os.environ if environ is None else environ
+    platform = sys.platform if platform is None else platform
+    home = Path.home() if home is None else home
+    if environ.get("CODETHERAPY_CONFIG"):
+        return Path(environ["CODETHERAPY_CONFIG"]).expanduser()
+    if platform == "win32":
+        base = Path(environ["APPDATA"]) if environ.get("APPDATA") else home / "AppData" / "Roaming"
+    elif platform == "darwin":
+        base = home / "Library" / "Application Support"
+    else:
+        base = Path(environ["XDG_CONFIG_HOME"]) if environ.get("XDG_CONFIG_HOME") else home / ".config"
+    return base / APP / "config.env"
+
+
+def read_values(path: Path) -> dict[str, str]:
+    values: dict[str, str] = {}
+    if not path.is_file():
+        return values
+    for line in path.read_text(encoding="utf-8-sig").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        values[key.strip()] = value.strip().strip('"').strip("'")
+    return values
+
+
+def save_values(values: dict[str, str], path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    ordered = [k for k in KEY_ORDER if k in values] + sorted(k for k in values if k not in KEY_ORDER)
+    body = "# Code Therapy settings. Keep this file private: the token is your connector's password.\n"
+    body += "".join(f"{key}={values[key]}\n" for key in ordered)
+    path.write_text(body, encoding="utf-8", newline="\n")
+    if sys.platform != "win32":
+        os.chmod(path, 0o600)
+
+
+def generate_token() -> str:
+    return secrets.token_urlsafe(32)
+
+
+def load_config(path: Path | None = None, environ: Mapping[str, str] | None = None) -> Config:
+    environ = os.environ if environ is None else environ
+    path = path or config_path(environ)
+    values = read_values(path)
+    values.update({k: v for k, v in environ.items() if k.startswith(PREFIX)})
+    token = values.get("CODETHERAPY_TOKEN", "")
+    if len(token) < MIN_TOKEN_LENGTH:
+        raise ConfigError(f"No valid token in {path}. Run `codetherapy setup` first.")
+    try:
+        port = int(values.get("CODETHERAPY_PORT", str(DEFAULT_PORT)))
+    except ValueError:
+        raise ConfigError(f"CODETHERAPY_PORT must be a number (in {path}). Run `codetherapy setup` to fix it.") from None
+    tunnel = values.get("CODETHERAPY_TUNNEL", "ngrok").lower()
+    if tunnel not in TUNNELS:
+        raise ConfigError(f"CODETHERAPY_TUNNEL must be one of {', '.join(TUNNELS)} (in {path}). "
+                          "Run `codetherapy setup` to fix it.")
+    default_dir = Path.home() / ".claude" / "projects"
+    return Config(
+        token=token,
+        port=port,
+        projects_dir=Path(values.get("CODETHERAPY_PROJECTS_DIR", str(default_dir))).expanduser(),
+        public_host=values.get("CODETHERAPY_PUBLIC_HOST", ""),
+        tunnel=tunnel,
+    )