coding-bridge 2026.6.20.0__py3-none-any.whl

coding_bridge/__init__.py

@@ -0,0 +1,8 @@
+"""Coding Bridge Agent — node daemon for AceDataCloud Coding Bridge.
+
+Runs on a developer's own machine, connects out to the coding-bridge relay, and
+drives local Claude Code sessions on behalf of an authenticated browser. All
+code execution stays local; the bridge only relays messages.
+"""
+
+__version__ = "0.1.0"

coding_bridge/__main__.py

@@ -0,0 +1,7 @@
+"""``python -m coding_bridge`` entry point."""
+from __future__ import annotations
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

coding_bridge/attachments.py

@@ -0,0 +1,155 @@
+"""Download browser-uploaded CDN attachments into cwd-scoped temp files."""
+from __future__ import annotations
+
+import re
+import time
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+import httpx
+
+MAX_ATTACHMENTS = 10
+MAX_ATTACHMENT_BYTES = 50 * 1024 * 1024
+ALLOWED_HOSTS = {"cdn.acedata.cloud", "platform.cdn.acedata.cloud"}
+
+_IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"}
+_EXT_BY_MIME = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/jpg": ".jpg",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "image/bmp": ".bmp",
+    "image/svg+xml": ".svg",
+    "application/pdf": ".pdf",
+    "text/plain": ".txt",
+    "text/markdown": ".md",
+}
+_SAFE_CHARS = re.compile(r"[^A-Za-z0-9._ -]+")
+
+
+def save_attachments(
+    attachments: list | None,
+    cwd: str | None,
+    *,
+    session_id: str,
+    client: httpx.Client | None = None,
+) -> list[dict[str, str]]:
+    """Download trusted CDN attachments and return local file descriptors."""
+    if not attachments:
+        return []
+    root = Path(cwd or ".").expanduser()
+    folder = root / ".tmp" / "attachments" / f"{session_id}-{int(time.time() * 1000)}"
+    results: list[dict[str, str]] = []
+    own_client = client is None
+    http = client or httpx.Client(follow_redirects=True, timeout=30, trust_env=False)
+    try:
+        for index, item in enumerate(attachments[:MAX_ATTACHMENTS]):
+            prepared = _download_one(http, item, folder, index)
+            if prepared:
+                results.append(prepared)
+    finally:
+        if own_client:
+            http.close()
+    return results
+
+
+def attachment_note(
+    prompt: str, files: list[dict[str, str]], image_paths: list[str] | None = None
+) -> str:
+    """Append a concise path list so coding agents can inspect attachments."""
+    lines: list[str] = []
+    for index, path in enumerate(image_paths or [], start=1):
+        lines.append(f"image {index}: {path}")
+    for item in files:
+        label = "image" if item.get("kind") == "image" else "file"
+        name = item.get("name") or Path(item["path"]).name
+        lines.append(f"{label}: {name} -> {item['path']}")
+    if not lines:
+        return prompt
+    note = "[Attachments saved on the local machine:]\n" + "\n".join(lines)
+    return f"{prompt}\n\n{note}" if prompt else note
+
+
+def image_paths(files: list[dict[str, str]]) -> list[str]:
+    return [item["path"] for item in files if item.get("kind") == "image"]
+
+
+def _download_one(
+    client: httpx.Client, item: object, folder: Path, index: int
+) -> dict[str, str] | None:
+    url, name, mime, declared_kind = _extract(item)
+    if not url or not _is_allowed_url(url):
+        return None
+    try:
+        with client.stream("GET", url) as response:
+            if response.status_code >= 400:
+                return None
+            header_mime = response.headers.get("content-type", "").split(";", 1)[0].strip()
+            mime = mime or header_mime or None
+            content_length = response.headers.get("content-length")
+            if content_length and int(content_length) > MAX_ATTACHMENT_BYTES:
+                return None
+            blob = bytearray()
+            for chunk in response.iter_bytes():
+                blob.extend(chunk)
+                if len(blob) > MAX_ATTACHMENT_BYTES:
+                    return None
+    except (OSError, ValueError, httpx.HTTPError):
+        return None
+    if not blob:
+        return None
+    kind = _kind(declared_kind, mime, name or url)
+    filename = _safe_name(name or _name_from_url(url), mime, kind, index)
+    folder.mkdir(parents=True, exist_ok=True)
+    target = folder / filename
+    try:
+        target.write_bytes(bytes(blob))
+    except OSError:
+        return None
+    return {"path": str(target), "name": filename, "kind": kind, "mime": mime or ""}
+
+
+def _extract(item: object) -> tuple[str | None, str | None, str | None, str | None]:
+    if isinstance(item, str):
+        return item, None, None, None
+    if isinstance(item, dict):
+        url = item.get("url") or item.get("file_url") or item.get("image_url")
+        name = item.get("name") or item.get("filename")
+        mime = item.get("mime_type") or item.get("media_type") or item.get("mime")
+        kind = item.get("type") or item.get("kind")
+        return (
+            str(url) if url else None,
+            str(name) if name else None,
+            str(mime) if mime else None,
+            str(kind) if kind else None,
+        )
+    return None, None, None, None
+
+
+def _is_allowed_url(url: str) -> bool:
+    parsed = urlparse(url)
+    host = (parsed.hostname or "").lower()
+    return parsed.scheme == "https" and host in ALLOWED_HOSTS
+
+
+def _kind(declared: str | None, mime: str | None, name: str) -> str:
+    if declared == "image" or (mime or "").lower().startswith("image/"):
+        return "image"
+    return "image" if Path(name).suffix.lower() in _IMAGE_EXTS else "file"
+
+
+def _name_from_url(url: str) -> str | None:
+    path = unquote(urlparse(url).path)
+    name = Path(path).name
+    return name or None
+
+
+def _safe_name(name: str | None, mime: str | None, kind: str, index: int) -> str:
+    ext = _EXT_BY_MIME.get((mime or "").lower(), "")
+    fallback_ext = ext or (".png" if kind == "image" else ".bin")
+    if name:
+        base = _SAFE_CHARS.sub("_", Path(name).name).strip(" .")
+        if base and base not in (".", ".."):
+            return base if Path(base).suffix else base + fallback_ext
+    return f"attachment_{index + 1}{fallback_ext}"

coding_bridge/capabilities.py

@@ -0,0 +1,293 @@
+"""Advertise what this node can do so the browser never hard-codes options.
+
+The browser asks (`capabilities.get`) and the node answers (`capabilities`)
+with the providers it supports, the models/effort tiers/permission modes each
+one offers, and whether the backing CLI is installed. The catalogs live HERE,
+on the node, so a new model or effort tier only needs a node update (or a custom
+value typed in the box) — the web UI renders whatever the node reports.
+
+Each provider also advertises its slash `commands`. For Claude these come from
+the SDK's per-environment `get_server_info()` — the authoritative list of what
+actually runs headlessly (built-ins like `/context`, `/compact`, plus the user's
+own `.claude/commands`). The browser uses it for `/` autocomplete so the user
+discovers exactly what their machine supports.
+"""
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+import os
+import shutil
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger("coding-bridge.capabilities")
+
+# Per-provider model catalogs. Labels are proper nouns shown verbatim by the
+# browser; `value` is what we pass to the CLI. Update this list (or ship a new
+# node release) when a backend adds a model and every browser picks it up.
+_CLAUDE_MODELS: list[dict[str, str]] = [
+    {"value": "sonnet", "label": "Claude Sonnet"},
+    {"value": "opus", "label": "Claude Opus"},
+    {"value": "haiku", "label": "Claude Haiku"},
+]
+_CODEX_MODELS: list[dict[str, str]] = [
+    {"value": "gpt-5-codex", "label": "GPT-5 Codex"},
+    {"value": "gpt-5", "label": "GPT-5"},
+    {"value": "o3", "label": "o3"},
+]
+
+# Effort tokens are semantic; the browser localizes known ones and shows the raw
+# token for anything new. "" means "use the backend default".
+_CLAUDE_EFFORTS: list[str] = ["", "low", "medium", "high", "max"]
+_CODEX_EFFORTS: list[str] = ["", "low", "medium", "high"]
+
+# Permission modes are shared; they map to provider sandboxes in each provider.
+_PERMISSION_MODES: list[str] = ["default", "acceptEdits", "plan", "bypassPermissions"]
+
+
+def _candidate_cli_paths(cli: str) -> list[str]:
+    """Well-known install locations a daemon's PATH commonly omits.
+
+    A node launched outside the user's login shell (no nvm/volta/asdf shims, no
+    ``~/.local/bin``) has a bare PATH, so ``shutil.which`` misses a CLI that is
+    in fact installed. Probing these dirs makes ``available`` reflect reality.
+    """
+    home = Path.home()
+    out: list[str] = []
+    # nvm keeps each node version's globals in its own bin dir, none of which is
+    # on PATH unless nvm was sourced — the #1 reason `claude` looks "missing".
+    nvm_root = home / ".nvm" / "versions" / "node"
+    if nvm_root.is_dir():
+        out += [str(p) for p in sorted(nvm_root.glob(f"*/bin/{cli}"), reverse=True)]
+    fixed = [
+        home / ".local" / "bin" / cli,
+        home / ".npm-global" / "bin" / cli,
+        home / ".volta" / "bin" / cli,
+        Path("/opt/homebrew/bin") / cli,
+        Path("/usr/local/bin") / cli,
+    ]
+    if cli == "claude":
+        fixed.insert(0, home / ".claude" / "local" / "claude")  # native installer
+    out += [str(p) for p in fixed]
+    return out
+
+
+def resolve_cli(cli: str, settings: Any | None = None) -> str | None:
+    """Absolute path to a provider CLI, or None if genuinely absent.
+
+    Resolution order: explicit ``settings.<cli>_path`` override → PATH
+    (``shutil.which``) → well-known install dirs a daemon's PATH commonly misses.
+    The last step is why a node started without the user's shell PATH still
+    detects ``claude``/``codex`` instead of falsely reporting them uninstalled.
+    """
+    override = getattr(settings, f"{cli}_path", None) if settings is not None else None
+    if override:
+        expanded = Path(override).expanduser()
+        if expanded.is_file():
+            return str(expanded)
+    found = shutil.which(cli)
+    if found:
+        return found
+    for cand in _candidate_cli_paths(cli):
+        if Path(cand).is_file() and os.access(cand, os.X_OK):
+            return cand
+    return None
+
+
+def ensure_clis_on_path(settings: Any | None = None) -> list[str]:
+    """Prepend each resolved CLI's directory to PATH so it can actually launch.
+
+    ``resolve_cli`` can find a binary by absolute path, but claude-agent-sdk and
+    ``codex exec`` still look it up on PATH — so a daemon with a bare PATH would
+    detect the CLI yet fail to start it. Called once at startup. Returns the dirs
+    added, for logging.
+    """
+    path_entries = os.environ.get("PATH", "").split(os.pathsep)
+    added: list[str] = []
+    for cli in ("claude", "codex"):
+        resolved = resolve_cli(cli, settings)
+        if not resolved:
+            continue
+        parent = str(Path(resolved).parent)
+        if parent and parent not in path_entries and parent not in added:
+            added.append(parent)
+    if added:
+        os.environ["PATH"] = os.pathsep.join([*added, os.environ.get("PATH", "")])
+    return added
+
+
+def _provider(
+    name: str,
+    label: str,
+    cli: str,
+    models: list[dict[str, str]],
+    efforts: list[str],
+    *,
+    settings: Any | None = None,
+    supports_edit: bool = False,
+    supports_code_restore: bool = False,
+) -> dict[str, Any]:
+    return {
+        "name": name,
+        "label": label,
+        "available": resolve_cli(cli, settings) is not None,
+        "models": models,
+        "efforts": efforts,
+        "permission_modes": list(_PERMISSION_MODES),
+        "allow_custom_model": True,
+        # Whether a past prompt can be edited (the conversation forked at that
+        # turn). Claude has first-class `--resume-session-at` / `--fork-session`;
+        # Codex has no such primitive, so its prompts are not editable.
+        "supports_edit": supports_edit,
+        # Whether editing can also roll back on-disk file changes (file
+        # checkpointing), so the browser can offer a "restore code" choice.
+        "supports_code_restore": supports_code_restore,
+    }
+
+
+def describe(settings: Any | None = None) -> dict[str, Any]:
+    """Build the capabilities descriptor sent to the browser."""
+    return {
+        "providers": [
+            _provider(
+                "claude",
+                "Claude Code",
+                "claude",
+                _CLAUDE_MODELS,
+                _CLAUDE_EFFORTS,
+                settings=settings,
+                supports_edit=True,
+                supports_code_restore=True,
+            ),
+            _provider(
+                "codex", "Codex", "codex", _CODEX_MODELS, _CODEX_EFFORTS, settings=settings
+            ),
+        ],
+    }
+
+
+async def describe_detailed(settings: Any) -> dict[str, Any]:
+    """`describe()` enriched with each provider's slash-command catalog.
+
+    Claude's catalog is fetched once from the SDK (cached); Codex's is derived
+    from its local custom-prompt directory. Falls back to an empty catalog if a
+    backend is unavailable or probing fails — the UI just shows no autocomplete.
+    """
+    desc = describe(settings)
+    claude_commands = await _claude_commands(settings)
+    codex_commands = _codex_commands()
+    for provider in desc["providers"]:
+        if provider["name"] == "claude":
+            provider["commands"] = claude_commands
+        elif provider["name"] == "codex":
+            provider["commands"] = codex_commands
+    return desc
+
+
+def normalize_commands(info: dict[str, Any] | None) -> list[dict[str, Any]]:
+    """Map a `get_server_info()` payload to the wire shape the browser expects."""
+    raw = (info or {}).get("commands") or []
+    out: list[dict[str, Any]] = []
+    for entry in raw:
+        if not isinstance(entry, dict):
+            continue
+        name = entry.get("name")
+        if not name or not isinstance(name, str):
+            continue
+        aliases = [a for a in (entry.get("aliases") or []) if isinstance(a, str)]
+        out.append(
+            {
+                "name": name,
+                "description": entry.get("description") or "",
+                "argument_hint": entry.get("argumentHint") or entry.get("argument_hint") or "",
+                "aliases": aliases,
+            }
+        )
+    return out
+
+
+def command_name_set(commands: list[dict[str, Any]] | None) -> set[str]:
+    """Lower-cased set of every command name and alias, for fast membership checks."""
+    names: set[str] = set()
+    for cmd in commands or []:
+        name = cmd.get("name")
+        if isinstance(name, str):
+            names.add(name.lower())
+        for alias in cmd.get("aliases") or []:
+            if isinstance(alias, str):
+                names.add(alias.lower())
+    return names
+
+
+_claude_commands_cache: list[dict[str, Any]] | None = None
+_claude_commands_lock = asyncio.Lock()
+
+
+async def _claude_commands(settings: Any) -> list[dict[str, Any]]:
+    """Fetch Claude's per-environment slash-command catalog once and cache it.
+
+    Spins up a throwaway streaming SDK client purely to read the `initialize`
+    response (`get_server_info()`), which lists every command the CLI accepts in
+    this environment. Cheap enough to do once on the first `capabilities.get`.
+    """
+    global _claude_commands_cache
+    if _claude_commands_cache is not None:
+        return _claude_commands_cache
+    async with _claude_commands_lock:
+        if _claude_commands_cache is not None:
+            return _claude_commands_cache
+        commands = await _probe_claude_commands(settings)
+        _claude_commands_cache = commands
+        return commands
+
+
+async def _probe_claude_commands(settings: Any) -> list[dict[str, Any]]:
+    if resolve_cli("claude", settings) is None:
+        return []
+    try:
+        from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient
+    except ImportError:
+        return []
+    try:
+        options = ClaudeAgentOptions(
+            cwd=(getattr(settings, "default_cwd", "") or None),
+            system_prompt={"type": "preset", "preset": "claude_code"},
+            setting_sources=["user", "project", "local"],
+        )
+        client = ClaudeSDKClient(options=options)
+        await asyncio.wait_for(client.connect(), timeout=45)
+        try:
+            info = await asyncio.wait_for(client.get_server_info(), timeout=15)
+        finally:
+            with contextlib.suppress(Exception):
+                await client.disconnect()
+        return normalize_commands(info)
+    except Exception as exc:  # noqa: BLE001 - never let probing break capabilities
+        logger.warning("could not probe claude commands: %s", exc)
+        return []
+
+
+def _codex_commands() -> list[dict[str, Any]]:
+    """Codex custom prompts (`$CODEX_HOME/prompts/*.md`) surfaced as slash commands.
+
+    `codex exec` is non-interactive and has no built-in slash processor, so only
+    user-defined prompt files are advertised; the rest of Codex's interactive
+    slash commands cannot run remotely.
+    """
+    home = os.environ.get("CODEX_HOME") or os.path.join(os.path.expanduser("~"), ".codex")
+    prompts_dir = Path(home) / "prompts"
+    if not prompts_dir.is_dir():
+        return []
+    commands: list[dict[str, Any]] = []
+    try:
+        entries = sorted(prompts_dir.glob("*.md"))
+    except OSError:
+        return []
+    for path in entries:
+        name = path.stem
+        if not name:
+            continue
+        commands.append({"name": name, "description": "", "argument_hint": "", "aliases": []})
+    return commands