argus-code 0.4.0__tar.gz → 0.4.1__tar.gz

{argus_code-0.4.0 → argus_code-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argus-code
-Version: 0.4.0
+Version: 0.4.1
 Summary: Local-first dashboard for Claude Code cost, token, tool-usage, and full-text search analytics
 Project-URL: Homepage, https://github.com/KrishBhimani/argus-code
 Project-URL: Repository, https://github.com/KrishBhimani/argus-code.git

{argus_code-0.4.0 → argus_code-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "argus-code"
-version = "0.4.0"
+version = "0.4.1"
 description = "Local-first dashboard for Claude Code cost, token, tool-usage, and full-text search analytics"
 readme = "README.md"
 requires-python = ">=3.11"

{argus_code-0.4.0 → argus_code-0.4.1}/python/argus/__init__.py

@@ -1,3 +1,3 @@
 """Argus — local-first analytics for Claude Code and other coding agents."""
 
-__version__ = "0.4.0"
+__version__ = "0.4.1"

{argus_code-0.4.0 → argus_code-0.4.1}/python/argus/server/app.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import signal
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -84,7 +85,27 @@ def build_app(repo: Repository, opts: ServerOpts) -> FastAPI:
 
 
 def serve_blocking(app: FastAPI, *, host: str, port: int) -> None:
-    """Run uvicorn in the current thread until SIGINT or .should_exit."""
+    """Run uvicorn in the current thread until SIGINT/SIGTERM or .should_exit.
+
+    We install our own signal handlers *before* calling ``server.run()`` so that
+    Ctrl+C produces a clean shutdown instead of the spurious
+    ``KeyboardInterrupt`` + ``CancelledError`` traceback uvicorn otherwise dumps.
+
+    Two layers conspire to print that traceback, and our handler defuses both:
+
+      1. ``asyncio.run()`` installs its own SIGINT handler that cancels the main
+         task and raises ``KeyboardInterrupt`` mid-loop -- but only when the
+         current handler is ``signal.default_int_handler`` (see CPython
+         ``asyncio/runners.py``). Installing ours first means asyncio leaves
+         SIGINT alone.
+      2. uvicorn's ``capture_signals()`` re-raises the captured signal after a
+         graceful shutdown. With ours as the restored handler, that re-raise
+         lands on a no-op instead of becoming a ``KeyboardInterrupt``.
+
+    During ``server.run()`` uvicorn's own ``handle_exit`` is the active handler
+    (it sets ``should_exit`` / ``force_exit`` on first/second signal); ours is
+    the benign backstop on either side of that window.
+    """
     config = uvicorn.Config(
         app,
         host=host,
@@ -93,7 +114,25 @@ def serve_blocking(app: FastAPI, *, host: str, port: int) -> None:
         access_log=False,
     )
     server = uvicorn.Server(config)
+
+    def _request_exit(_signum: int, _frame: Any) -> None:
+        if server.should_exit:
+            server.force_exit = True
+        server.should_exit = True
+
+    previous: dict[int, Any] = {}
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            previous[sig] = signal.signal(sig, _request_exit)
+        except (ValueError, OSError):
+            # Not the main thread, or signal unsupported on this platform.
+            pass
+
     try:
         server.run()
-    except KeyboardInterrupt:
-        pass
+    finally:
+        for sig, handler in previous.items():
+            try:
+                signal.signal(sig, handler)
+            except (ValueError, OSError):
+                pass

{argus_code-0.4.0 → argus_code-0.4.1}/python/argus/store/db.py

@@ -5,6 +5,7 @@ is better than a confusing OperationalError deep in searchPrompts later.
 """
 from __future__ import annotations
 
+import re
 import sqlite3
 from pathlib import Path
 
@@ -40,6 +41,74 @@ def _assert_fts5(conn: sqlite3.Connection) -> None:
         )
 
 
+_BLOCK_KW = re.compile(r"\b(BEGIN|CASE|END)\b", re.IGNORECASE)
+
+
+def _split_statements(script: str) -> list[str]:
+    """Split a migration script into individual SQL statements.
+
+    SQLite separates statements with ';', but a ``CREATE TRIGGER`` body holds
+    its own ';'-terminated statements between ``BEGIN`` and ``END``. We track
+    nesting so a trigger is emitted as a single statement rather than being
+    chopped mid-body. ``CASE`` is counted as an opener too: it also closes with
+    ``END``, so counting it keeps ENDs balanced whether a ``CASE`` appears at
+    top level (MIGRATION_002's UPDATE) or inside a future trigger body.
+    """
+    statements: list[str] = []
+    buf: list[str] = []
+    depth = 0
+    for chunk in script.split(";"):
+        buf.append(chunk)
+        for kw in _BLOCK_KW.findall(chunk):
+            if kw.upper() in ("BEGIN", "CASE"):
+                depth += 1
+            elif depth > 0:
+                depth -= 1
+        if depth == 0:
+            stmt = ";".join(buf).strip()
+            buf = []
+            if stmt:
+                statements.append(stmt)
+    tail = ";".join(buf).strip()
+    if tail:
+        statements.append(tail)
+    return statements
+
+
+def _run_migration(conn: sqlite3.Connection, version: int, sql: str) -> None:
+    """Apply one versioned migration and record schema_version atomically.
+
+    The migration's statements and the schema_version bump run inside a single
+    explicit transaction, so a crash mid-migration can never again leave the
+    DB with applied DDL but a stale recorded version (the bug that produced
+    ``duplicate column name`` on restart).
+
+    Recovery: SQLite has no ``ALTER TABLE ... ADD COLUMN IF NOT EXISTS``, so a
+    DB left half-migrated by the old non-atomic runner re-reports
+    ``duplicate column name``. Because the column is already present, we skip
+    just that statement and continue — every other migration statement is
+    ``IF NOT EXISTS`` / ``INSERT OR REPLACE`` / idempotent ``UPDATE``. This is
+    non-destructive: no row is dropped, deleted, or rewritten.
+    """
+    conn.execute("BEGIN")
+    try:
+        for stmt in _split_statements(sql):
+            try:
+                conn.execute(stmt)
+            except sqlite3.OperationalError as e:
+                if "duplicate column name" in str(e).lower():
+                    continue  # column already added by a prior partial run
+                raise
+        conn.execute(
+            "INSERT OR REPLACE INTO app_meta (key, value) VALUES ('schema_version', ?)",
+            (str(version),),
+        )
+        conn.execute("COMMIT")
+    except BaseException:
+        conn.execute("ROLLBACK")
+        raise
+
+
 def open_db(path: str | Path, *, read_only: bool = False) -> sqlite3.Connection:
     """Open the Argus SQLite DB at ``path``.
 
@@ -106,25 +175,18 @@ def open_db(path: str | Path, *, read_only: bool = False) -> sqlite3.Connection:
     ).fetchone()
     current = int(row["value"]) if row else 1
 
-    if current < 2:
-        conn.executescript(MIGRATION_002)
-        current = 2
-    if current < 3:
-        conn.executescript(MIGRATION_003)
-        current = 3
-    if current < 4:
-        conn.executescript(MIGRATION_004)
-        current = 4
-    if current < 5:
-        conn.executescript(MIGRATION_005)
-        current = 5
-    if current < 6:
-        conn.executescript(MIGRATION_006)
-        current = 6
-
-    conn.execute(
-        "INSERT OR REPLACE INTO app_meta (key, value) VALUES ('schema_version', ?)",
-        (str(SCHEMA_VERSION),),
+    # Each migration commits its DDL and its schema_version bump together, so
+    # the recorded version always matches the applied schema. See _run_migration.
+    versioned = (
+        (2, MIGRATION_002),
+        (3, MIGRATION_003),
+        (4, MIGRATION_004),
+        (5, MIGRATION_005),
+        (6, MIGRATION_006),
     )
+    for version, sql in versioned:
+        if current < version:
+            _run_migration(conn, version, sql)
+            current = version
 
     return conn

{argus_code-0.4.0 → argus_code-0.4.1}/tests/server/test_server.py

@@ -1,13 +1,16 @@
 """Server bootstrap — API + static dashboard served from the same app."""
 from __future__ import annotations
 
+import signal
 from pathlib import Path
 
+from fastapi import FastAPI
 from fastapi.testclient import TestClient
 
 from argus.collector.first_run import IngestStatus
 from argus.pricing.types import PricingTable
-from argus.server.app import ServerOpts, build_app
+from argus.server import app as appmod
+from argus.server.app import ServerOpts, build_app, serve_blocking
 
 
 def test_app_serves_api_and_static_from_same_root(repo, tmp_path: Path):
@@ -123,3 +126,47 @@ def test_cross_origin_post_to_alerts_seen_is_rejected(repo, tmp_path: Path):
         headers={"origin": "http://evil.example.com"},
     )
     assert r.status_code == 403
+
+
+def test_serve_blocking_ctrl_c_shuts_down_without_traceback(monkeypatch):
+    """Ctrl+C must shut the server down cleanly, not dump the uvicorn
+    KeyboardInterrupt/CancelledError traceback.
+
+    Two facts make that happen, both asserted here against a fake ``run()`` that
+    stands in for the real serve loop:
+
+      1. By the time uvicorn's loop is running, the SIGINT handler is *ours*,
+         not ``signal.default_int_handler`` -- so ``asyncio.run()``'s Runner
+         declines to install the handler that raises ``KeyboardInterrupt``.
+      2. A SIGINT delivered to our handler (including the re-raise uvicorn's
+         ``capture_signals`` performs on exit) sets ``should_exit`` /
+         ``force_exit`` instead of raising.
+
+    It also pins the cleanup contract: prior signal handlers are restored.
+    """
+    seen: dict[str, object] = {}
+
+    def fake_run(self) -> None:
+        active = signal.getsignal(signal.SIGINT)
+        seen["sigint_is_ours"] = active is not signal.default_int_handler
+        # First Ctrl+C -> graceful shutdown requested.
+        active(signal.SIGINT, None)
+        seen["should_exit"] = self.should_exit
+        # Second Ctrl+C -> force exit (the path that produced the original
+        # traceback at runners.py:157 `raise KeyboardInterrupt()`).
+        active(signal.SIGINT, None)
+        seen["force_exit"] = self.force_exit
+        # uvicorn's capture_signals re-raises the captured signal on exit; with
+        # our handler installed this must be a no-op, not a KeyboardInterrupt.
+        signal.raise_signal(signal.SIGINT)
+
+    monkeypatch.setattr(appmod.uvicorn.Server, "run", fake_run)
+
+    before = signal.getsignal(signal.SIGINT)
+    serve_blocking(FastAPI(), host="127.0.0.1", port=0)  # must not raise
+    after = signal.getsignal(signal.SIGINT)
+
+    assert seen["sigint_is_ours"] is True
+    assert seen["should_exit"] is True
+    assert seen["force_exit"] is True
+    assert after is before  # handlers restored on exit

{argus_code-0.4.0 → argus_code-0.4.1}/tests/store/test_db.py

@@ -117,6 +117,42 @@ def test_migration_006_index_exists(db):
     assert "idx_segments_tool_use" in names
 
 
+def test_open_db_recovers_from_half_applied_migration(db_path):
+    """A DB whose column was added but whose schema_version never advanced
+    must re-open cleanly, not crash with 'duplicate column name'.
+
+    Reproduces the field failure: MIGRATION_006 added transcript_segments.
+    tool_use_id but schema_version stayed < 6 (migrations were committed
+    per-statement while the version was written only at the very end). The
+    re-run then hit a non-idempotent ALTER TABLE ADD COLUMN.
+    """
+    # Build a faithfully half-migrated DB: column present, index missing,
+    # schema_version pinned back to 5.
+    conn = open_db(db_path)
+    conn.execute("DROP INDEX IF EXISTS idx_segments_tool_use")
+    conn.execute(
+        "INSERT OR REPLACE INTO app_meta (key, value) VALUES ('schema_version', '5')"
+    )
+    conn.close()
+
+    # Re-open must not raise, must finish at v6, and must heal the missing index.
+    conn = open_db(db_path)
+    try:
+        ver = conn.execute(
+            "SELECT value FROM app_meta WHERE key = 'schema_version'"
+        ).fetchone()
+        assert int(ver["value"]) == 6
+        cols = {r["name"] for r in conn.execute("PRAGMA table_info(transcript_segments)")}
+        assert "tool_use_id" in cols
+        idx = {
+            r["name"]
+            for r in conn.execute("SELECT name FROM sqlite_master WHERE type = 'index'")
+        }
+        assert "idx_segments_tool_use" in idx
+    finally:
+        conn.close()
+
+
 def test_alerts_has_resolved_at_column(db_path):
     conn = open_db(db_path)
     try: