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

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

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

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

@@ -334,6 +334,16 @@ 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,
@@ -344,14 +354,12 @@ class BridgeConnection:
             permission_mode=payload.get("permission_mode") or "default",
             provider=provider,
             effort=payload.get("effort") or None,
-            resume=payload.get("resume_session_id") or None,
+            resume=resume,
             trace_id=payload.get("trace_id"),
             on_rekey=self._rekey_session,
         )
         self.sessions[session_id] = session
-        await session.start(
-            payload.get("prompt", ""), payload.get("images"), payload.get("attachments")
-        )
+        await session.start(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.0 → coding_bridge-2026.7.2.2}/coding_bridge/history.py

@@ -20,6 +20,7 @@ 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"
@@ -29,6 +30,33 @@ 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
 
@@ -42,9 +70,14 @@ _UUID_RE = re.compile(
 
 # --- public API ------------------------------------------------------------
 def list_sessions(limit: int = 200) -> list[dict[str, Any]]:
-    """Return session summaries from both providers, newest first."""
+    """Return session summaries from every provider, newest first."""
     limit = max(1, min(int(limit or 200), 1000))
-    sessions = _list_claude(limit) + _list_codex(limit) + _list_copilot(limit)
+    sessions = (
+        _list_claude(limit)
+        + _list_codex(limit)
+        + _list_copilot(limit)
+        + _list_vscode_chat(limit)
+    )
     sessions.sort(key=lambda s: s.get("updated_at") or 0, reverse=True)
     return sessions[:limit]
 
@@ -98,6 +131,54 @@ 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":
@@ -111,10 +192,17 @@ 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 None:
-            raise FileNotFoundError(f"copilot session not found: {session_id}")
-        header, events = _copilot_read(path)
+        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)
     else:
         raise ValueError(f"unknown provider: {provider}")
     # Keep the MOST RECENT events when a transcript is huge — the tail is the
@@ -625,6 +713,160 @@ 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.0 → coding_bridge-2026.7.2.2}/pyproject.toml

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

{coding_bridge-2026.7.2.0 → coding_bridge-2026.7.2.2}/tests/test_history.py

@@ -139,6 +139,7 @@ def _patch_roots(monkeypatch, tmp_path):
     monkeypatch.setattr(history, "CODEX_ROOT", codex_root)
     monkeypatch.setattr(history, "CODEX_INDEX", codex_index)
     monkeypatch.setattr(history, "COPILOT_ROOT", copilot_root)
+    monkeypatch.setattr(history, "VSCODE_CHAT_ROOTS", [tmp_path / "vscode"])
 
 
 def _seed_copilot(root):
@@ -374,6 +375,7 @@ def test_copilot_falls_back_to_transformed_content(monkeypatch, tmp_path):
     monkeypatch.setattr(history, "CODEX_ROOT", tmp_path / "none-codex")
     monkeypatch.setattr(history, "CODEX_INDEX", tmp_path / "none.jsonl")
     monkeypatch.setattr(history, "COPILOT_ROOT", copilot_root)
+    monkeypatch.setattr(history, "VSCODE_CHAT_ROOTS", [tmp_path / "none-vscode"])
     copilot = next(s for s in history.list_sessions() if s["provider"] == "copilot")
     assert copilot["title"] == "show me recent sessions"
     detail = history.read_session("copilot", COPILOT_SID)
@@ -599,3 +601,166 @@ async def test_dispatch_history_get_requires_params():
     await conn._dispatch({"action": Action.HISTORY_GET})
     errors = _payloads(conn, Event.SESSION_ERROR)
     assert errors and "required" in errors[0]["message"]
+
+
+VSCODE_SID = "55555555-5555-5555-5555-555555555555"
+
+
+def _seed_vscode_chat(storage_root):
+    ws = storage_root / "abc123hash"
+    (ws / "chatSessions").mkdir(parents=True, exist_ok=True)
+    (ws / "workspace.json").write_text(
+        json.dumps({"folder": "file:///Users/me/My%20Proj"}), encoding="utf-8"
+    )
+    # v3 delta log: header line then a kind:2 line carrying the request objects.
+    records = [
+        {"kind": 0, "v": {"version": 3, "sessionId": VSCODE_SID, "requests": []}},
+        {
+            "kind": 2,
+            "v": [
+                {
+                    "requestId": "req_1",
+                    "timestamp": 1750000000000,
+                    "modelId": "copilot/claude-opus-4.8",
+                    "message": {"text": "fix the parser"},
+                    "response": [
+                        {"kind": "thinking", "value": "let me look", "id": "t0"},
+                        {"value": "Here is the fix.", "supportThemeIcons": False},
+                        {
+                            "kind": "toolInvocationSerialized",
+                            "toolId": "copilot_readFile",
+                            "toolCallId": "call_1",
+                            "invocationMessage": {"value": "Reading file"},
+                            "isComplete": True,
+                        },
+                    ],
+                }
+            ],
+        },
+    ]
+    _write_jsonl(ws / "chatSessions" / f"{VSCODE_SID}.jsonl", records)
+
+
+def test_vscode_chat_list_and_read(monkeypatch, tmp_path):
+    storage = tmp_path / "workspaceStorage"
+    _seed_vscode_chat(storage)
+    monkeypatch.setattr(history, "VSCODE_CHAT_ROOTS", [storage])
+    monkeypatch.setattr(history, "CLAUDE_ROOT", tmp_path / "none1")
+    monkeypatch.setattr(history, "CODEX_ROOT", tmp_path / "none2")
+    monkeypatch.setattr(history, "COPILOT_ROOT", tmp_path / "none3")
+
+    sessions = history.list_sessions()
+    vs = [s for s in sessions if s["session_id"] == VSCODE_SID]
+    assert len(vs) == 1
+    s = vs[0]
+    assert s["provider"] == "copilot"  # surfaced as ordinary Copilot, no "vscode"
+    assert "origin" not in s
+    assert s["title"] == "fix the parser"
+    assert s["cwd"] == "/Users/me/My Proj"  # file:// unquoted
+
+    detail = history.read_session("copilot", VSCODE_SID)
+    assert "origin" not in detail
+    assert detail["model"] == "copilot/claude-opus-4.8"
+    kinds = [e["kind"] for e in detail["events"]]
+    assert kinds == ["prompt", "thinking", "text", "tool_use"]
+    assert detail["events"][0]["text"] == "fix the parser"
+    assert detail["events"][2]["text"] == "Here is the fix."
+    assert detail["events"][3]["tool"] == "copilot_readFile"
+
+
+def test_vscode_chat_path_rejects_traversal(monkeypatch, tmp_path):
+    storage = tmp_path / "workspaceStorage"
+    storage.mkdir(parents=True, exist_ok=True)
+    monkeypatch.setattr(history, "VSCODE_CHAT_ROOTS", [storage])
+    monkeypatch.setattr(history, "COPILOT_ROOT", tmp_path / "none")
+    assert history._vscode_chat_path("..") is None
+    assert history._vscode_chat_path(".") is None
+    with pytest.raises(FileNotFoundError):
+        history.read_session("copilot", "..")
+
+
+def test_vscode_chat_tolerates_malformed(monkeypatch, tmp_path):
+    storage = tmp_path / "workspaceStorage"
+    ws = storage / "h" / "chatSessions"
+    ws.mkdir(parents=True, exist_ok=True)
+    (ws / f"{VSCODE_SID}.jsonl").write_text(
+        "\n".join(
+            [
+                "not json",
+                json.dumps({"kind": 1, "v": "just a string"}),
+                json.dumps({"kind": 2, "v": [{"message": ["bad"], "response": []}]}),
+                json.dumps(
+                    {
+                        "kind": 2,
+                        "v": [{"requestId": "r", "message": {"text": "real"}, "response": []}],
+                    }
+                ),
+            ]
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(history, "VSCODE_CHAT_ROOTS", [storage])
+    monkeypatch.setattr(history, "COPILOT_ROOT", tmp_path / "none")
+    detail = history.read_session("copilot", VSCODE_SID)
+    prompts = [e["text"] for e in detail["events"] if e["kind"] == "prompt"]
+    assert prompts == ["real"]
+
+
+def test_copilot_native_and_build_seed(monkeypatch, tmp_path):
+    # A VS Code chat session is NOT natively resumable but seeds fine.
+    storage = tmp_path / "workspaceStorage"
+    _seed_vscode_chat(storage)
+    monkeypatch.setattr(history, "VSCODE_CHAT_ROOTS", [storage])
+    monkeypatch.setattr(history, "COPILOT_ROOT", tmp_path / "none")
+
+    assert history.copilot_native(VSCODE_SID) is False
+    seed = history.build_seed(VSCODE_SID)
+    assert "User: fix the parser" in seed
+    assert "Assistant: Here is the fix." in seed
+    assert seed.startswith("[Continuing a previous conversation")
+    assert seed.rstrip().endswith("continue from here.]")
+    # tool_use / thinking are omitted from the seed
+    assert "copilot_readFile" not in seed
+    assert "let me look" not in seed
+
+
+def test_build_seed_missing_returns_empty(monkeypatch, tmp_path):
+    monkeypatch.setattr(history, "VSCODE_CHAT_ROOTS", [tmp_path / "none-vs"])
+    monkeypatch.setattr(history, "COPILOT_ROOT", tmp_path / "none-cli")
+    assert history.build_seed("00000000-0000-0000-0000-000000000000") == ""
+
+
+def test_build_seed_tail_caps(monkeypatch, tmp_path):
+    storage = tmp_path / "workspaceStorage"
+    ws = storage / "h" / "chatSessions"
+    ws.mkdir(parents=True, exist_ok=True)
+    big = "x" * 60000
+    _write_jsonl(
+        ws / f"{VSCODE_SID}.jsonl",
+        [
+            {
+                "kind": 2,
+                "v": [
+                    {
+                        "requestId": "r1",
+                        "timestamp": 1,
+                        "message": {"text": "early turn " + big},
+                        "response": [{"value": "ok"}],
+                    },
+                    {
+                        "requestId": "r2",
+                        "timestamp": 2,
+                        "message": {"text": "latest question"},
+                        "response": [{"value": "latest answer"}],
+                    },
+                ],
+            }
+        ],
+    )
+    monkeypatch.setattr(history, "VSCODE_CHAT_ROOTS", [storage])
+    monkeypatch.setattr(history, "COPILOT_ROOT", tmp_path / "none")
+    seed = history.build_seed(VSCODE_SID)
+    assert len(seed) < 45000  # capped
+    assert "latest question" in seed  # tail kept
+    assert "omitted" in seed