coding-bridge 2026.7.2.2__tar.gz → 2026.7.3.0__tar.gz

{coding_bridge-2026.7.2.2 → coding_bridge-2026.7.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coding-bridge
-Version: 2026.7.2.2
+Version: 2026.7.3.0
 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

coding_bridge-2026.7.3.0/coding_bridge/channels/__init__.py

@@ -0,0 +1,29 @@
+"""Messaging channels: run a coding-agent turn per inbound external message.
+
+Existing coding-bridge shape: browser ⇄ relay WSS ⇄ ``BridgeConnection`` node.
+Channels shape: external messenger (WeChat / Telegram / …) ⇄ ``ChannelAdapter``
+⇄ ``SessionDispatcher`` ⇄ existing ``Session`` + ``Provider``. The relay path is
+untouched; channels are an additive second entry-point built on the same
+``Provider`` layer.
+
+See ``plans/coding-bridge-channels/01-production-plan.md`` in AceDataCloud/Index
+for the P1..P11 roadmap this module implements.
+"""
+
+from .base import (
+    ChannelAdapter,
+    ChannelTarget,
+    IncomingMessage,
+    MessageHandler,
+    SendResult,
+)
+from .dispatcher import SessionDispatcher
+
+__all__ = [
+    "ChannelAdapter",
+    "ChannelTarget",
+    "IncomingMessage",
+    "MessageHandler",
+    "SendResult",
+    "SessionDispatcher",
+]

coding_bridge-2026.7.3.0/coding_bridge/channels/base.py

@@ -0,0 +1,107 @@
+"""Channel-adapter Protocol and value objects shared by every messenger.
+
+An adapter is the thin glue between one external messaging system (WeChat via
+Wisdom, later Telegram / Discord …) and the dispatcher. It never spawns provider
+processes, tracks sessions, or evaluates prompts — those live in
+``SessionDispatcher`` and reuse the existing ``Session`` / ``Provider`` machinery
+so the browser and WeChat paths share one coding-agent implementation.
+
+Design invariants:
+
+* ``instance_id`` is opaque to the dispatcher but MUST be stable per adapter
+  instance (per configured Wisdom endpoint, per Bot token, …) so multi-instance
+  deployments can namespace dedup keys, log fields, and outbox rows.
+* ``send()`` is expected to return a ``SendResult`` — never raise on a delivery
+  failure — because delivery is best-effort and the dispatcher records the
+  outcome for observability + retry decisions.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from typing import Any, Protocol, runtime_checkable
+
+
+@dataclass(frozen=True)
+class ChannelTarget:
+    """Where a reply for an incoming message should be delivered.
+
+    ``conversation_id`` is the ID of the "room" — a WeChat private chat wxid, a
+    group room id, a Telegram chat_id, etc. ``reply_to_id`` is set only when the
+    external protocol supports a reply-to primitive worth carrying (WeChat
+    Wisdom's ``msg_id``, Telegram's ``reply_to_message_id``); adapters that lack
+    one leave it ``None``.
+    """
+
+    conversation_id: str
+    conversation_type: str = "private"
+    reply_to_id: str | None = None
+    extra: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class IncomingMessage:
+    """A single external message routed to the dispatcher.
+
+    ``sender_id`` MUST be stable per remote identity (WeChat wxid, Telegram
+    user_id, …) — the dispatcher uses it for allowlists, rate limits, and per-
+    sender session keying.
+    """
+
+    sender_id: str
+    sender_name: str | None
+    target: ChannelTarget
+    text: str
+    msg_type: str
+    direction: str  # ``inbound`` / ``outbound`` (per Wisdom's schema)
+    upstream_id: str | None = None
+    received_at_ms: int | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class SendResult:
+    """Outcome of an adapter ``send()`` call. Non-raising by contract."""
+
+    ok: bool
+    upstream_id: str | None = None
+    error: str | None = None
+    latency_ms: int | None = None
+
+
+# ``handler(msg, adapter)`` — the dispatcher installs one before ``run()``.
+MessageHandler = Callable[["IncomingMessage", "ChannelAdapter"], Awaitable[None]]
+
+
+@runtime_checkable
+class ChannelAdapter(Protocol):
+    """One long-lived connection to an external messaging system.
+
+    Lifecycle:
+
+    1. Construct — parse settings, do NOT open sockets yet.
+    2. ``set_handler(h)`` — dispatcher registers the callback.
+    3. ``run()`` — subscribe loop; must call ``handler(msg, self)`` per inbound
+       message. Should reconnect internally on transient failures. Returns only
+       on ``aclose()`` or an unrecoverable auth failure.
+    4. ``send(target, text)`` — outbound reply.
+    5. ``aclose()`` — signal ``run()`` to stop; idempotent.
+
+    Adapters MUST NOT retain references to the dispatcher itself — only the
+    handler callback — so the dispatcher can outlive individual adapters (and
+    vice versa) without leaks.
+    """
+
+    name: str
+    instance_id: str
+
+    def set_handler(self, handler: MessageHandler) -> None: ...
+
+    async def run(self) -> None: ...
+
+    async def send(
+        self, target: ChannelTarget, text: str, *, reply_to: str | None = None
+    ) -> SendResult: ...
+
+    async def aclose(self) -> None: ...

coding_bridge-2026.7.3.0/coding_bridge/channels/dispatcher.py

@@ -0,0 +1,203 @@
+"""Route external messages to per-session provider turns and post replies back.
+
+The dispatcher is the channel-side counterpart of ``BridgeConnection`` — it owns
+the map from ``(instance_id, sender_id, conversation_id)`` to a live ``Session``,
+converts each session's event stream into a single text reply, and hands the
+reply to the originating adapter's ``send()``.
+
+Session lifecycle (v1 = one-shot per message):
+
+* Every inbound message spawns a fresh ``Session`` and immediately closes it
+  when the provider emits ``session.result`` or ``session.error``. Persisting
+  context across messages ("resume") is deferred so v1 stays simple and each
+  send/receive pair is auditable in isolation.
+
+* Concurrency guard: only one in-flight turn per session key. A second message
+  arriving before the current turn completes is deferred to the caller (the
+  adapter decides whether to buffer, drop, or warn) via a ``BusyError``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+import uuid
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from ..config import Settings
+from ..protocol import Event
+from ..providers.base import ProviderFactory
+from ..session import Session
+from .base import ChannelAdapter, ChannelTarget, IncomingMessage, SendResult
+
+logger = logging.getLogger("coding-bridge.channels")
+
+# ``(adapter_name, instance_id, sender_id, conversation_id)`` — the key namespace
+# the dispatcher uses to route replies. ``adapter_name`` guards against future
+# collisions when a user runs both a WeChat and a Telegram adapter at once.
+SessionKey = tuple[str, str, str, str]
+
+# Emitted after a session finishes; carries the concatenated reply text so the
+# adapter can post it. Never raises — the dispatcher swallows adapter errors and
+# logs them so a broken adapter can't kill sibling sessions.
+ReplySink = Callable[[ChannelAdapter, ChannelTarget, str], Awaitable[SendResult]]
+
+
+class BusyError(RuntimeError):
+    """Raised by ``handle_message`` when a session key already has an in-flight turn."""
+
+
+class _Turn:
+    """Accumulates text_delta / text / result events for one provider turn."""
+
+    def __init__(self) -> None:
+        self._parts: list[str] = []
+        self._done = asyncio.Event()
+        self._error: str | None = None
+
+    def on_event(self, payload: dict[str, Any]) -> None:
+        event = payload.get("event")
+        if event in (Event.SESSION_TEXT, Event.SESSION_TEXT_DELTA):
+            text = payload.get("text")
+            if isinstance(text, str) and text:
+                self._parts.append(text)
+        elif event == Event.SESSION_RESULT:
+            # Some providers emit their final text only in ``result.text`` and
+            # never stream a session.text — pick that up so we don't reply blank.
+            result_text = payload.get("text") or payload.get("result")
+            if isinstance(result_text, str) and result_text and not self._parts:
+                self._parts.append(result_text)
+            self._done.set()
+        elif event == Event.SESSION_ERROR:
+            err = payload.get("message") or payload.get("code") or "provider_error"
+            self._error = str(err)
+            self._done.set()
+        elif event == Event.SESSION_CLOSED:
+            self._done.set()
+
+    def text(self) -> str:
+        return "".join(self._parts).strip()
+
+    def error(self) -> str | None:
+        return self._error
+
+    async def wait(self, timeout: float | None) -> bool:
+        try:
+            await asyncio.wait_for(self._done.wait(), timeout=timeout)
+        except asyncio.TimeoutError:
+            return False
+        return True
+
+
+class SessionDispatcher:
+    """Fan external messages into ``Session`` turns and fan replies back out."""
+
+    def __init__(
+        self,
+        settings: Settings,
+        provider_factory: ProviderFactory,
+        *,
+        reply_sink: ReplySink | None = None,
+        turn_timeout: float = 300.0,
+        default_provider: str = "claude",
+    ) -> None:
+        self.settings = settings
+        self._factory = provider_factory
+        self._reply_sink = reply_sink or _default_reply_sink
+        self._turn_timeout = turn_timeout
+        self._default_provider = default_provider
+        self._inflight: dict[SessionKey, asyncio.Task[Any]] = {}
+        self._lock = asyncio.Lock()
+
+    def key_for(self, msg: IncomingMessage, adapter: ChannelAdapter) -> SessionKey:
+        return (adapter.name, adapter.instance_id, msg.sender_id, msg.target.conversation_id)
+
+    async def handle_message(self, msg: IncomingMessage, adapter: ChannelAdapter) -> None:
+        """Spawn one turn for ``msg``. Raises ``BusyError`` if a turn is in flight.
+
+        Non-raising for anything else — a provider crash or send failure is
+        logged and reported to the caller only via the returned coroutine
+        completing (there is no exception to re-raise on the adapter thread).
+        """
+        key = self.key_for(msg, adapter)
+        async with self._lock:
+            if key in self._inflight and not self._inflight[key].done():
+                raise BusyError(f"turn already running for {key!r}")
+            task = asyncio.create_task(self._run_turn(key, msg, adapter))
+            self._inflight[key] = task
+        # Fire-and-forget: the adapter loop must not block on this turn.
+
+    async def aclose(self) -> None:
+        async with self._lock:
+            tasks = [t for t in self._inflight.values() if not t.done()]
+            self._inflight.clear()
+        for t in tasks:
+            t.cancel()
+        for t in tasks:
+            with contextlib.suppress(BaseException):
+                await t
+
+    async def _run_turn(
+        self, key: SessionKey, msg: IncomingMessage, adapter: ChannelAdapter
+    ) -> None:
+        session_id = uuid.uuid4().hex
+        turn = _Turn()
+
+        async def emit(payload: dict[str, Any]) -> None:
+            turn.on_event(payload)
+
+        session = Session(
+            session_id=session_id,
+            provider_factory=self._factory,
+            emit=emit,
+            settings=self.settings,
+            cwd=self.settings.default_cwd,
+            model=self.settings.default_model,
+            permission_mode="default",
+            provider=self._default_provider,
+        )
+        try:
+            await session.start(msg.text)
+            ok = await turn.wait(self._turn_timeout)
+            reply = turn.text()
+            # Error takes precedence over any text already streamed — if the
+            # provider emits SESSION_RESULT and then SESSION_ERROR (buggy
+            # provider), we surface the error instead of silently returning the
+            # stale text.
+            if turn.error():
+                reply = f"(provider error: {turn.error()})"
+            elif not ok:
+                reply = reply or "(provider timed out; no reply)"
+            if not reply:
+                reply = "(no reply)"
+            try:
+                result = await self._reply_sink(adapter, msg.target, reply)
+            except Exception as exc:  # defensive: adapter send should not kill dispatcher
+                logger.exception("channel send failed: %s", exc)
+                return
+            if not result.ok:
+                logger.warning(
+                    "channel send returned failure: adapter=%s instance=%s error=%s",
+                    adapter.name,
+                    adapter.instance_id,
+                    result.error,
+                )
+        finally:
+            with contextlib.suppress(BaseException):
+                await session.close()
+            async with self._lock:
+                if self._inflight.get(key) is asyncio.current_task():
+                    self._inflight.pop(key, None)
+
+
+async def _default_reply_sink(
+    adapter: ChannelAdapter, target: ChannelTarget, text: str
+) -> SendResult:
+    """Fallback sink used when the caller didn't supply one — just calls send()."""
+
+    return await adapter.send(target, text)
+
+
+__all__ = ["SessionDispatcher", "BusyError", "ReplySink"]

{coding_bridge-2026.7.2.2 → coding_bridge-2026.7.3.0}/coding_bridge/connection.py

@@ -334,16 +334,6 @@ class BridgeConnection:
                 **_session_overrides(payload),
             )
             return
-        resume = payload.get("resume_session_id") or None
-        prompt = payload.get("prompt", "")
-        # Continue a Copilot session the CLI can't natively resume (e.g. a VS Code
-        # Copilot Chat session opened from history): seed its transcript into a
-        # fresh session instead of a doomed session/resume.
-        if provider == "copilot" and resume and not history.copilot_native(resume):
-            seed = await asyncio.to_thread(history.build_seed, resume)
-            if seed:
-                prompt = f"{seed}\n\n{prompt}".strip() if prompt else seed
-            resume = None
         session = Session(
             session_id,
             self.provider_factory,
@@ -354,12 +344,14 @@ class BridgeConnection:
             permission_mode=payload.get("permission_mode") or "default",
             provider=provider,
             effort=payload.get("effort") or None,
-            resume=resume,
+            resume=payload.get("resume_session_id") or None,
             trace_id=payload.get("trace_id"),
             on_rekey=self._rekey_session,
         )
         self.sessions[session_id] = session
-        await session.start(prompt, payload.get("images"), payload.get("attachments"))
+        await session.start(
+            payload.get("prompt", ""), payload.get("images"), payload.get("attachments")
+        )
 
     def _session(self, session_id: str | None) -> Session | None:
         """Resolve a session by its canonical id or a still-live provisional alias."""

{coding_bridge-2026.7.2.2 → coding_bridge-2026.7.3.0}/coding_bridge/history.py

@@ -20,7 +20,6 @@ from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 from pathlib import Path
 from typing import Any
-from urllib.parse import unquote, urlparse
 
 # Module-level roots so tests can point them at fixtures via monkeypatch.
 CLAUDE_ROOT = Path.home() / ".claude" / "projects"
@@ -30,33 +29,6 @@ COPILOT_ROOT = (
     Path(os.environ.get("COPILOT_HOME") or str(Path.home() / ".copilot")) / "session-state"
 )
 
-
-def _vscode_chat_roots() -> list[Path]:
-    """Candidate ``workspaceStorage`` dirs for VS Code Copilot Chat transcripts.
-
-    Chat sessions live at ``<storage>/<workspace-hash>/chatSessions/<id>.jsonl``.
-    ``VSCODE_CHAT_HOME`` overrides for tests / non-standard installs.
-    """
-    override = os.environ.get("VSCODE_CHAT_HOME")
-    if override:
-        return [Path(override)]
-    home = Path.home()
-    bases: list[Path | None] = [
-        home / "Library" / "Application Support",  # macOS
-        Path(os.environ["APPDATA"]) if os.environ.get("APPDATA") else None,  # Windows
-        home / ".config",  # Linux
-    ]
-    apps = ("Code", "Code - Insiders", "VSCodium", "Cursor")
-    roots: list[Path] = []
-    for base in bases:
-        if base is None:
-            continue
-        roots.extend(base / app / "User" / "workspaceStorage" for app in apps)
-    return roots
-
-
-VSCODE_CHAT_ROOTS = _vscode_chat_roots()
-
 _TITLE_MAX = 80
 _DETAIL_MAX_EVENTS = 4000
 
@@ -70,14 +42,9 @@ _UUID_RE = re.compile(
 
 # --- public API ------------------------------------------------------------
 def list_sessions(limit: int = 200) -> list[dict[str, Any]]:
-    """Return session summaries from every provider, newest first."""
+    """Return session summaries from both providers, newest first."""
     limit = max(1, min(int(limit or 200), 1000))
-    sessions = (
-        _list_claude(limit)
-        + _list_codex(limit)
-        + _list_copilot(limit)
-        + _list_vscode_chat(limit)
-    )
+    sessions = _list_claude(limit) + _list_codex(limit) + _list_copilot(limit)
     sessions.sort(key=lambda s: s.get("updated_at") or 0, reverse=True)
     return sessions[:limit]
 
@@ -131,54 +98,6 @@ def claude_user_uuid_after(session_id: str, cut_uuid: str | None) -> str | None:
     return None
 
 
-# Cap the seeded transcript so continuing a huge conversation doesn't blow the
-# first prompt; keep the most recent turns (the live context).
-_SEED_MAX_CHARS = 40000
-
-
-def copilot_native(session_id: str) -> bool:
-    """True if a Copilot session id belongs to the CLI store (natively resumable).
-
-    VS Code Copilot Chat sessions live in a different store the CLI can't resume,
-    so they must be continued by seeding the transcript into a fresh session.
-    """
-    return _copilot_path(session_id) is not None
-
-
-def build_seed(session_id: str) -> str:
-    """Render a Copilot transcript as a compact preamble to continue it elsewhere.
-
-    Used when a session can't be natively resumed (e.g. a VS Code Copilot Chat
-    session continued from the phone): the prior user/assistant turns are replayed
-    as context in a fresh session. Tool calls and thinking are omitted; only typed
-    prompts and assistant text are kept, tail-capped at ``_SEED_MAX_CHARS``.
-    """
-    try:
-        detail = read_session("copilot", session_id)
-    except (FileNotFoundError, OSError, ValueError):
-        return ""
-    lines: list[str] = []
-    for event in detail.get("events", []):
-        kind = event.get("kind")
-        text = event.get("text")
-        if not isinstance(text, str) or not text.strip():
-            continue
-        if kind == "prompt":
-            lines.append(f"User: {text.strip()}")
-        elif kind == "text":
-            lines.append(f"Assistant: {text.strip()}")
-    if not lines:
-        return ""
-    body = "\n\n".join(lines)
-    if len(body) > _SEED_MAX_CHARS:
-        body = "…(earlier turns omitted)…\n\n" + body[-_SEED_MAX_CHARS:]
-    return (
-        "[Continuing a previous conversation. Transcript so far:]\n\n"
-        + body
-        + "\n\n[End of previous transcript — continue from here.]"
-    )
-
-
 def read_session(provider: str, session_id: str) -> dict[str, Any]:
     """Return a normalised transcript ``{provider,title,cwd,model,...,events}``."""
     if provider == "claude":
@@ -192,17 +111,10 @@ def read_session(provider: str, session_id: str) -> dict[str, Any]:
             raise FileNotFoundError(f"codex session not found: {session_id}")
         header, events = _codex_read(path, _codex_index())
     elif provider == "copilot":
-        # A "copilot" session may live in the CLI store or the VS Code Copilot
-        # Chat store — both are Copilot to the user. Prefer the CLI store, fall
-        # back to the VS Code panel transcript.
         path = _copilot_path(session_id)
-        if path is not None:
-            header, events = _copilot_read(path)
-        else:
-            vpath = _vscode_chat_path(session_id)
-            if vpath is None:
-                raise FileNotFoundError(f"copilot session not found: {session_id}")
-            header, events = _vscode_chat_read(vpath)
+        if path is None:
+            raise FileNotFoundError(f"copilot session not found: {session_id}")
+        header, events = _copilot_read(path)
     else:
         raise ValueError(f"unknown provider: {provider}")
     # Keep the MOST RECENT events when a transcript is huge — the tail is the
@@ -713,160 +625,6 @@ def _copilot_tool_result_text(data: dict[str, Any]) -> Any:
     return _stringify(error)
 
 
-# --- VS Code Copilot Chat --------------------------------------------------
-# The panel stores each session as an append-only delta log of `{kind, v}` lines
-# (format v3). We don't replay the deltas; we recursively find the request
-# objects (dict with `message.text` + `response`), which is resilient to delta
-# opcode changes across VS Code releases. These are surfaced as ordinary
-# `copilot` sessions (same backend); read-only, so continuing makes a copy.
-def _list_vscode_chat(limit: int) -> list[dict[str, Any]]:
-    files: list[Path] = []
-    for root in VSCODE_CHAT_ROOTS:
-        if root.exists():
-            files.extend(root.glob("*/chatSessions/*.jsonl"))
-    files = sorted(files, key=_safe_mtime, reverse=True)[:limit]
-    return _summaries(files, _vscode_chat_summary)
-
-
-def _vscode_collect_requests(obj: Any, out: list[dict[str, Any]]) -> None:
-    """Collect chat-request objects, pruning descent into the huge `response`."""
-    if isinstance(obj, dict):
-        msg = obj.get("message")
-        if isinstance(msg, dict) and "text" in msg and "response" in obj:
-            out.append(obj)
-            return  # don't recurse into this request's response array
-        for value in obj.values():
-            _vscode_collect_requests(value, out)
-    elif isinstance(obj, list):
-        for value in obj:
-            _vscode_collect_requests(value, out)
-
-
-def _vscode_requests(path: Path) -> list[dict[str, Any]]:
-    seen: dict[str, dict[str, Any]] = {}
-    ordered: list[dict[str, Any]] = []
-    for rec in _iter_jsonl(path):
-        found: list[dict[str, Any]] = []
-        _vscode_collect_requests(rec.get("v"), found)
-        for req in found:
-            rid = req.get("requestId")
-            key = rid if isinstance(rid, str) else str(id(req))
-            if key not in seen:
-                seen[key] = req
-                ordered.append(req)
-    ordered.sort(key=lambda r: r.get("timestamp") or 0)
-    return ordered
-
-
-def _vscode_user_text(req: dict[str, Any]) -> str:
-    msg = req.get("message")
-    text = msg.get("text") if isinstance(msg, dict) else None
-    return text.strip() if isinstance(text, str) else ""
-
-
-def _vscode_chat_summary(path: Path) -> dict[str, Any]:
-    reqs = _vscode_requests(path)
-    title = ""
-    updated_at = _mtime_ms(path)
-    for req in reqs:
-        ts = req.get("timestamp")
-        if isinstance(ts, int):
-            updated_at = max(updated_at, ts)
-        if not title:
-            text = _vscode_user_text(req)
-            if text and not _is_context_noise(text):
-                title = _clean_title(text)
-    return {
-        "provider": "copilot",
-        "session_id": path.stem,
-        "title": title or "(no prompt)",
-        "cwd": _vscode_cwd(path),
-        "git_branch": None,
-        "updated_at": updated_at,
-        "message_count": len(reqs),
-    }
-
-
-def _vscode_chat_read(path: Path) -> tuple[dict[str, Any], list[dict[str, Any]]]:
-    header: dict[str, Any] = {
-        "cwd": _vscode_cwd(path),
-        "git_branch": None,
-        "model": None,
-        "title": "",
-    }
-    events: list[dict[str, Any]] = []
-    for req in _vscode_requests(path):
-        ts = req.get("timestamp") if isinstance(req.get("timestamp"), int) else None
-        model = req.get("modelId")
-        if header["model"] is None and isinstance(model, str) and model:
-            header["model"] = model
-        text = _vscode_user_text(req)
-        if text and not _is_context_noise(text):
-            events.append({"kind": "prompt", "text": text, "ts": ts})
-            if not header["title"]:
-                header["title"] = _clean_title(text)
-        _vscode_response_events(req.get("response"), ts, events)
-    return header, events
-
-
-def _vscode_response_events(response: Any, ts: int | None, events: list[dict[str, Any]]) -> None:
-    if not isinstance(response, list):
-        return
-    for part in response:
-        if not isinstance(part, dict):
-            continue
-        kind = part.get("kind")
-        if kind is None:  # markdown text block: {"value": "...", ...}
-            value = part.get("value")
-            text = value.get("value") if isinstance(value, dict) else value
-            if isinstance(text, str) and text.strip():
-                events.append({"kind": "text", "text": text, "ts": ts})
-        elif kind == "thinking":
-            value = part.get("value")
-            if isinstance(value, str) and value.strip():
-                events.append({"kind": "thinking", "text": value, "ts": ts})
-        elif kind == "toolInvocationSerialized":
-            msg = part.get("pastTenseMessage") or part.get("invocationMessage")
-            label = msg.get("value") if isinstance(msg, dict) else msg
-            events.append(
-                {
-                    "kind": "tool_use",
-                    "tool": part.get("toolId"),
-                    "tool_use_id": part.get("toolCallId"),
-                    "input": label if isinstance(label, str) else None,
-                    "ts": ts,
-                }
-            )
-
-
-def _vscode_chat_path(session_id: str) -> Path | None:
-    if not _safe_id(session_id) or session_id in (".", ".."):
-        return None
-    matches: list[Path] = []
-    for root in VSCODE_CHAT_ROOTS:
-        if root.exists():
-            matches.extend(root.glob(f"*/chatSessions/{session_id}.jsonl"))
-    matches = [p for p in matches if p.is_file()]
-    return max(matches, key=_safe_mtime) if matches else None
-
-
-def _vscode_cwd(path: Path) -> str | None:
-    # chatSessions/<id>.jsonl -> workspace.json sits two levels up (workspace hash dir)
-    meta = path.parent.parent / "workspace.json"
-    try:
-        data = json.loads(meta.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError, ValueError):
-        return None
-    folder = data.get("folder") if isinstance(data, dict) else None
-    if isinstance(folder, str) and folder.startswith("file://"):
-        path = unquote(urlparse(folder).path)
-        # Windows file URLs parse to "/C:/..." — drop the spurious leading slash.
-        if re.match(r"^/[A-Za-z]:/", path):
-            path = path[1:]
-        return path or None
-    return folder if isinstance(folder, str) and folder else None
-
-
 # --- shared helpers --------------------------------------------------------
 def _iter_jsonl(path: Path) -> Iterator[dict[str, Any]]:
     try:

{coding_bridge-2026.7.2.2 → coding_bridge-2026.7.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "coding-bridge"
-version = "2026.7.2.2"
+version = "2026.7.3.0"
 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"