review: three more malformed-record + SQLite-error guards (#31, round 3)

  - services/workspace_db.py: isinstance(c, dict) guard in
    _build_composer_id_to_workspace_id. A non-dict entry in
    ``allComposers`` would AttributeError on ``c.get("composerId")`` and
    silently discard the entire workspace's composer mapping.
    Test: tests/test_workspace_db_special_paths.py — list with None /
    string / int / valid dict, only the valid one maps.

  - services/workspace_resolver.py: wrap the per-composer
    ``messageRequestContext:*`` LIKE query in
    _infer_workspace_name_from_context with try/except sqlite3.Error.
    A corrupt cursorDiskKV table previously raised through and crashed
    listing routes that call this helper.
    Test: tests/test_workspace_name_db_errors.py — seeds globalStorage
    with cursorDiskKV missing, asserts helper returns None without
    propagating.

  - services/workspace_tabs.py: validate the parsed tool-call payload.
    ``_parse_tool_call`` may return None (or any non-dict); without the
    guard, ``tool_calls = [None]`` becomes a poison pill that crashes
    the display-text fallback (``NoneType.get('name')``) and drops the
    whole composer. Only store when isinstance(tool_call, dict); also
    guard the display-text fallback site.
    Test: tests/test_workspace_tabs_malformed_nested.py — patches
    _parse_tool_call to return None, asserts the composer still
    appears in the tabs response.

195 tests pass (was 192; +3 new).

Author: timon0305

services/workspace_db.py

@@ -60,6 +60,8 @@ def _build_composer_id_to_workspace_id(workspace_path: str, workspace_entries: l
                 all_composers = data.get("allComposers")
                 if isinstance(all_composers, list):
                     for c in all_composers:
+                        if not isinstance(c, dict):
+                            continue
                         cid = c.get("composerId")
                         if cid:
                             mapping[cid] = entry["name"]

services/workspace_resolver.py

@@ -68,10 +68,13 @@ def _infer_workspace_name_from_context(workspace_path: str, workspace_id: str) -
         if not gconn:
             return None
         for cid in composer_ids:
-            rows = gconn.execute(
-                "SELECT value FROM cursorDiskKV WHERE key LIKE ?",
-                (f"messageRequestContext:{cid}:%",),
-            ).fetchall()
+            try:
+                rows = gconn.execute(
+                    "SELECT value FROM cursorDiskKV WHERE key LIKE ?",
+                    (f"messageRequestContext:{cid}:%",),
+                ).fetchall()
+            except sqlite3.Error:
+                continue
             for row in rows:
                 try:
                     ctx = json.loads(row["value"])

services/workspace_tabs.py

@@ -250,7 +250,8 @@ def assemble_workspace_tabs(
                     tfd = raw.get("toolFormerData")
                     if isinstance(tfd, dict):
                         tool_call = _parse_tool_call(tfd)
-                        tool_calls = [tool_call]
+                        if isinstance(tool_call, dict):
+                            tool_calls = [tool_call]
 
                     # Thinking
                     thinking = None
@@ -271,9 +272,10 @@ def assemble_workspace_tabs(
                     display_text = full_text.strip()
                     if not display_text and tool_calls:
                         tc = tool_calls[0]
-                        display_text = f"**Tool: {tc.get('name', 'unknown')}**"
-                        if tc.get("status"):
-                            display_text += f" ({tc['status']})"
+                        if isinstance(tc, dict):
+                            display_text = f"**Tool: {tc.get('name', 'unknown')}**"
+                            if tc.get("status"):
+                                display_text += f" ({tc['status']})"
                     if not display_text and thinking:
                         display_text = thinking
 

tests/test_workspace_db_special_paths.py

@@ -71,6 +71,34 @@ def test_open_global_db_handles_spaces(self):
                 self.assertIsNotNone(row)
 
 
+class TestMalformedAllComposersEntry(unittest.TestCase):
+    def test_non_dict_entries_skipped_healthy_one_mapped(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            ws_dir = os.path.join(tmp, "ws-mixed")
+            os.makedirs(ws_dir, exist_ok=True)
+            db = os.path.join(ws_dir, "state.vscdb")
+            conn = sqlite3.connect(db)
+            conn.execute("CREATE TABLE ItemTable ([key] TEXT PRIMARY KEY, value TEXT)")
+            conn.execute(
+                "INSERT INTO ItemTable ([key], value) VALUES (?, ?)",
+                (
+                    "composer.composerData",
+                    json.dumps({"allComposers": [
+                        None,                                # malformed: None
+                        "not a dict",                        # malformed: string
+                        42,                                  # malformed: number
+                        {"composerId": "cid-real"},          # healthy
+                    ]}),
+                ),
+            )
+            conn.commit()
+            conn.close()
+
+            entries = [{"name": "ws-mixed", "workspaceJsonPath": ""}]
+            mapping = _build_composer_id_to_workspace_id(tmp, entries)
+            self.assertEqual(mapping, {"cid-real": "ws-mixed"})
+
+
 class TestOpenGlobalDbConnectFailure(unittest.TestCase):
     def test_sqlite_connect_error_yields_none_conn(self):
         with tempfile.TemporaryDirectory() as tmp:

tests/test_workspace_name_db_errors.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import sys
+import tempfile
+import unittest
+from contextlib import contextmanager
+from unittest.mock import patch
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if REPO_ROOT not in sys.path:
+    sys.path.insert(0, REPO_ROOT)
+
+from services.workspace_resolver import _infer_workspace_name_from_context
+
+
+def _seed_local_state(workspace_path: str, workspace_id: str) -> None:
+    """Local state.vscdb with one composer.composerData row + composer ID."""
+    ws_dir = os.path.join(workspace_path, workspace_id)
+    os.makedirs(ws_dir, exist_ok=True)
+    db = os.path.join(ws_dir, "state.vscdb")
+    conn = sqlite3.connect(db)
+    conn.execute("CREATE TABLE ItemTable ([key] TEXT PRIMARY KEY, value TEXT)")
+    conn.execute(
+        "INSERT INTO ItemTable VALUES (?, ?)",
+        (
+            "composer.composerData",
+            json.dumps({"allComposers": [{"composerId": "cid-x"}]}),
+        ),
+    )
+    conn.commit()
+    conn.close()
+
+
+class TestGlobalQueryErrorSwallowed(unittest.TestCase):
+    def test_corrupt_cursordiskkv_does_not_propagate(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            # _open_global_db reads ``<workspace_path>/../globalStorage`` — so
+            # workspaceStorage must be a child of tmp, not tmp itself.
+            ws_root = os.path.join(tmp, "workspaceStorage")
+            os.makedirs(ws_root, exist_ok=True)
+            _seed_local_state(ws_root, "ws-corrupt")
+
+            global_dir = os.path.join(tmp, "globalStorage")
+            os.makedirs(global_dir, exist_ok=True)
+            gdb = os.path.join(global_dir, "state.vscdb")
+            conn = sqlite3.connect(gdb)
+            # Schema deliberately missing cursorDiskKV so the LIKE query
+            # inside _infer_workspace_name_from_context raises
+            # sqlite3.OperationalError("no such table").
+            conn.execute("CREATE TABLE other (x INTEGER)")
+            conn.commit()
+            conn.close()
+
+            try:
+                result = _infer_workspace_name_from_context(ws_root, "ws-corrupt")
+            except sqlite3.Error:
+                self.fail("query error should be caught, not propagated")
+            self.assertIsNone(result)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_workspace_tabs_malformed_nested.py

@@ -6,6 +6,7 @@
 import sys
 import tempfile
 import unittest
+from unittest.mock import patch
 
 from flask import Flask
 
@@ -149,5 +150,66 @@ def test_synthetic_falls_back_to_max_bubble_timestamp(self) -> None:
         self.assertLess(synthetic["timestamp"], now_ms - 10_000_000_000)
 
 
+def _seed_workspace_with_tool_former(parent: str) -> str:
+    ws_root = os.path.join(parent, "workspaceStorage")
+    global_root = os.path.join(parent, "globalStorage")
+    os.makedirs(ws_root, exist_ok=True)
+    os.makedirs(global_root, exist_ok=True)
+    ws_dir = os.path.join(ws_root, "ws-a")
+    os.makedirs(ws_dir, exist_ok=True)
+    with open(os.path.join(ws_dir, "workspace.json"), "w") as f:
+        json.dump({"folder": "/tmp/proj"}, f)
+    sqlite3.connect(os.path.join(ws_dir, "state.vscdb")).close()
+
+    conn = sqlite3.connect(os.path.join(global_root, "state.vscdb"))
+    conn.execute("CREATE TABLE cursorDiskKV ([key] TEXT PRIMARY KEY, value TEXT)")
+    conn.execute(
+        "INSERT INTO cursorDiskKV VALUES (?, ?)",
+        (
+            "composerData:cmp-t",
+            json.dumps({
+                "name": "Tab with toolFormerData",
+                "createdAt": 1_715_000_000_000,
+                "lastUpdatedAt": 1_715_000_500_000,
+                "fullConversationHeadersOnly": [{"bubbleId": "b-t", "type": 2}],
+            }),
+        ),
+    )
+    conn.execute(
+        "INSERT INTO cursorDiskKV VALUES (?, ?)",
+        (
+            "bubbleId:cmp-t:b-t",
+            json.dumps({
+                "text": "assistant message",
+                "createdAt": 1_715_000_400_000,
+                "toolFormerData": {"name": "tool-x"},
+            }),
+        ),
+    )
+    conn.commit()
+    conn.close()
+    return ws_root
+
+
+class TestParseToolCallNonDictReturn(unittest.TestCase):
+    def test_non_dict_parse_result_does_not_drop_composer(self) -> None:
+        app = Flask(__name__)
+        app.config["TESTING"] = True
+        app.config["EXCLUSION_RULES"] = []
+
+        with tempfile.TemporaryDirectory() as tmp:
+            ws_root = _seed_workspace_with_tool_former(tmp)
+            # Force _parse_tool_call to return None — the previous code
+            # would have stored ``tool_calls = [None]`` and crashed in the
+            # display-text fallback with ``NoneType.get``.
+            with patch("services.workspace_tabs._parse_tool_call", return_value=None):
+                with app.test_request_context("/api/workspaces/global/tabs"):
+                    payload, status = assemble_workspace_tabs("global", ws_root, rules=[])
+
+        self.assertEqual(status, 200)
+        ids = [t["id"] for t in payload.get("tabs", [])]
+        self.assertIn("cmp-t", ids)
+
+
 if __name__ == "__main__":
     unittest.main()