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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coding-bridge
-Version: 2026.7.2.2
+Version: 2026.7.2.3
 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.2 → coding_bridge-2026.7.2.3}/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.2.3}/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.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "coding-bridge"
-version = "2026.7.2.2"
+version = "2026.7.2.3"
 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.2 → coding_bridge-2026.7.2.3}/tests/test_history.py

@@ -139,7 +139,6 @@ 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):
@@ -375,7 +374,6 @@ 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)
@@ -601,166 +599,3 @@ 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