code-puppy-core-plugins 0.0.12__tar.gz → 0.0.13__tar.gz

{code_puppy_core_plugins-0.0.12 → code_puppy_core_plugins-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.12
+Version: 0.0.13
 Summary: Official plugin bundle for Code Puppy
 Project-URL: Repository, https://github.com/mpfaffenberger/code_puppy_core_plugins
 Project-URL: Homepage, https://github.com/mpfaffenberger/code_puppy_core_plugins

code_puppy_core_plugins-0.0.13/code_puppy_core_plugins/logfire_sessions/__init__.py

@@ -0,0 +1,7 @@
+"""Mirror Code Puppy chat sessions into Logfire as structured log records.
+
+The record schema lives under the ``cp.hist.*`` namespace -- deliberately NOT
+``cp.session.*``. Logfire's hosted MCP query path scrubs keys and values that
+contain sensitive keywords, and "session" is on that list, which would render
+every listing useless and corrupt restored payloads.
+"""

code_puppy_core_plugins-0.0.13/code_puppy_core_plugins/logfire_sessions/mirror.py

@@ -0,0 +1,108 @@
+"""Write path: mirror a saved session envelope into Logfire records.
+
+Called from the ``post_autosave`` hook. Local JSON stays canonical; Logfire is
+a roaming/backup layer. Everything here raises on failure -- the hook wrapper
+owns the fail-soft policy.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+from . import sync
+
+_CONFIGURED = False
+
+
+def _configure_once() -> None:
+    """Point the logfire SDK at the onboarded project's write token."""
+    global _CONFIGURED
+    if _CONFIGURED:
+        return
+    import logfire
+
+    from ..logfire_oauth.oauth import load_project_credentials
+
+    credentials = load_project_credentials()
+    if credentials is None:
+        raise RuntimeError("no Logfire project credentials; run /logfire onboard")
+    logfire.configure(
+        service_name="code-puppy",
+        token=credentials.token,
+        send_to_logfire="always",
+        console=False,
+    )
+    _CONFIGURED = True
+
+
+@lru_cache(maxsize=8)
+def _git(args: tuple[str, ...], cwd: str) -> str | None:
+    try:
+        result = subprocess.run(
+            ("git", *args),
+            capture_output=True,
+            text=True,
+            cwd=cwd,
+            timeout=5,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    return result.stdout.strip() or None
+
+
+def workspace_metadata() -> dict[str, str | None]:
+    """Best-effort workspace identity: resolved cwd, git remote, branch.
+
+    ``remote`` is the cross-machine join key (paths differ between machines);
+    ``scope_key`` is the machine-local grouping used by session resume.
+    """
+    cwd = str(Path.cwd())
+    return {
+        "scope_key": cwd,
+        "project_name": Path(cwd).name or None,
+        "remote": _git(("remote", "get-url", "origin"), cwd),
+        "branch": _git(("rev-parse", "--abbrev-ref", "HEAD"), cwd),
+    }
+
+
+def mirror_session(metadata: Any) -> tuple[int, int]:
+    """Emit not-yet-synced messages of a saved session. Returns (emitted, total)."""
+    from code_puppy.session_storage import read_envelope_file
+
+    envelope = read_envelope_file(Path(metadata.json_path))
+    messages = envelope.get("messages") or []
+    fps = [sync.fingerprint(message) for message in messages]
+
+    key = f"{metadata.scope_key or ''}/{metadata.session_name}"
+    state = sync.load_state()
+    previous = (state["sessions"].get(key) or {}).get("fingerprints")
+    start = sync.plan_sync(previous, fps)
+    if start >= len(messages):
+        return 0, len(messages)
+
+    meta = workspace_metadata()
+    _configure_once()
+    import logfire
+
+    emitted = 0
+    for seq in range(start, len(messages)):
+        for attrs in sync.encode_message_records(
+            name=metadata.session_name,
+            seq=seq,
+            message=messages[seq],
+            scope_key=meta["scope_key"],
+            project_name=meta["project_name"],
+            remote=meta["remote"],
+            branch=meta["branch"],
+        ):
+            logfire.info("cp.hist.message", **attrs)
+            emitted += 1
+    logfire.force_flush()
+
+    state["sessions"][key] = sync.synced_entry(fps)
+    sync.save_state(state)
+    return emitted, len(messages)

code_puppy_core_plugins-0.0.13/code_puppy_core_plugins/logfire_sessions/query.py

@@ -0,0 +1,119 @@
+"""Read path: list sessions that have been mirrored into Logfire.
+
+Listing goes through Logfire's hosted MCP ``query_run`` tool -- the exact same
+path as the agent-facing ``logfire_query`` tool. Two consequences:
+
+* The MCP layer scrubs keys/values containing sensitive keywords. The
+  ``cp.hist.*`` namespace dodges key-based scrubbing; occasional value-level
+  scrubbing in previews is cosmetic for a list view.
+* Machine restore must NOT use this path (payloads would silently corrupt).
+  Restore belongs behind a minted read token + ``/v2/query`` once the OAuth
+  scope question is settled.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import time
+from typing import Any
+
+import httpx
+
+LIST_SESSIONS_SQL = """
+SELECT
+  attributes->>'cp.hist.name'               AS name,
+  attributes->>'cp.project.name'            AS project,
+  attributes->>'cp.project.remote'          AS remote,
+  count(DISTINCT attributes->>'cp.hist.seq') AS messages,
+  max(start_timestamp)                      AS last_active
+FROM records
+WHERE attributes->>'cp.hist.name' IS NOT NULL
+GROUP BY 1, 2, 3
+ORDER BY max(start_timestamp) DESC
+LIMIT {limit}
+"""
+
+
+class SessionsQueryError(RuntimeError):
+    """Raised when sessions cannot be listed from Logfire."""
+
+
+def fresh_tokens() -> Any:
+    """Return usable OAuth tokens, refreshing them when expired.
+
+    Mirrors RFC 6749's refresh grant against the token endpoint discovered via
+    RFC 8414 -- the same discovery the device flow uses. Refreshed tokens are
+    persisted so other consumers stay warm.
+    """
+    from ..logfire_oauth.oauth import load_tokens, save_tokens
+
+    tokens = load_tokens()
+    if tokens is None:
+        raise SessionsQueryError(
+            "Logfire is not authenticated. Run /logfire auth first."
+        )
+    if tokens.expires_at > time.time() + 30:
+        return tokens
+    if not tokens.refresh_token:
+        raise SessionsQueryError(
+            "The Logfire OAuth access token expired and cannot be refreshed. "
+            "Run /logfire auth again."
+        )
+    try:
+        with httpx.Client(timeout=30) as client:
+            metadata = client.get(
+                f"{tokens.base_url}/.well-known/oauth-authorization-server"
+            )
+            metadata.raise_for_status()
+            token_endpoint = metadata.json()["token_endpoint"]
+            response = client.post(
+                token_endpoint,
+                data={
+                    "grant_type": "refresh_token",
+                    "client_id": tokens.client_id,
+                    "refresh_token": tokens.refresh_token,
+                },
+            )
+            response.raise_for_status()
+            payload = response.json()
+    except (httpx.HTTPError, KeyError, ValueError) as exc:
+        raise SessionsQueryError(
+            f"Could not refresh the Logfire access token: {type(exc).__name__}"
+        ) from exc
+
+    tokens = dataclasses.replace(
+        tokens,
+        access_token=payload["access_token"],
+        expires_at=time.time() + float(payload.get("expires_in", 300)),
+        refresh_token=payload.get("refresh_token") or tokens.refresh_token,
+    )
+    save_tokens(tokens)
+    return tokens
+
+
+def list_sessions(limit: int = 25) -> list[dict[str, Any]]:
+    """Return mirrored sessions ordered by most recent activity."""
+    from ..logfire_oauth.oauth import load_project_credentials
+    from ..logfire_oauth.query_tool import _query_mcp
+
+    credentials = load_project_credentials()
+    if credentials is None:
+        raise SessionsQueryError(
+            "No Logfire project is configured. Run /logfire onboard first."
+        )
+
+    tokens = fresh_tokens()
+    result = _query_mcp(
+        base_url=tokens.base_url,
+        access_token=tokens.access_token,
+        query=LIST_SESSIONS_SQL.format(limit=limit),
+        project=credentials.project_name,
+        start=None,
+        end=None,
+    )
+    if isinstance(result, dict) and result.get("error"):
+        raise SessionsQueryError(str(result["error"]))
+    rows = result.get("rows") if isinstance(result, dict) else None
+    if rows is None:
+        raise SessionsQueryError("Unexpected response from the Logfire query API.")
+    return rows

code_puppy_core_plugins-0.0.13/code_puppy_core_plugins/logfire_sessions/register_callbacks.py

@@ -0,0 +1,138 @@
+"""Register the Logfire session-mirroring plugin.
+
+Opt-in by design: mirroring ships full chat histories to the user's own
+Logfire project, so it stays off until ``enable_logfire_sessions`` is set
+(via ``/set`` or ``/logfire-sessions on``) AND a project write token exists
+(from ``/logfire onboard``).
+
+``post_autosave`` is a decorative hook surface: a misbehaving mirror must
+never poison the save path, so every failure is swallowed here.
+"""
+
+from __future__ import annotations
+
+import traceback
+from typing import Any
+
+from code_puppy.callbacks import register_callback
+from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
+
+COMMAND_NAMES = {"logfire-sessions"}
+
+_PULL_STUB = (
+    "Restoring sessions from Logfire is not implemented yet. It needs a "
+    "read token (the hosted MCP query path scrubs values containing words "
+    "like 'session', which would corrupt restored payloads). Prerequisite: "
+    "extend ONBOARD_SCOPES with read-token minting permission, then pull via "
+    "POST /v2/query and rebuild the envelope locally."
+)
+
+
+def _enabled() -> bool:
+    from code_puppy.config import get_value
+
+    return str(get_value("enable_logfire_sessions") or "").strip().lower() in {
+        "1",
+        "true",
+        "yes",
+        "on",
+    }
+
+
+def _on_post_autosave(metadata: Any) -> None:
+    """Mirror the just-saved session into Logfire. Never raises."""
+    try:
+        if not _enabled():
+            return
+        from .mirror import mirror_session
+
+        emitted, total = mirror_session(metadata)
+        if emitted:
+            emit_info(
+                f"Mirrored {emitted} new message(s) of '{metadata.session_name}' "
+                f"to Logfire ({total} total)."
+            )
+    except Exception:
+        traceback.print_exc()  # forensics only; the save path must not care
+
+
+def _status() -> None:
+    from ..logfire_oauth.oauth import load_project_credentials
+
+    if not _enabled():
+        emit_warning("Session mirroring is disabled (/logfire-sessions on).")
+    else:
+        emit_info("Session mirroring: enabled")
+    credentials = load_project_credentials()
+    if credentials is None:
+        emit_warning("No Logfire write token (/logfire onboard first).")
+    else:
+        emit_info(f"Write-token project: {credentials.project_name}")
+    from . import sync
+
+    state = sync.load_state()
+    sessions = state.get("sessions", {})
+    emit_info(f"Locally synced sessions: {len(sessions)}")
+
+
+def _list(limit: int) -> None:
+    from .query import SessionsQueryError, list_sessions
+
+    try:
+        rows = list_sessions(limit=limit)
+    except SessionsQueryError as exc:
+        emit_error(str(exc))
+        return
+    if not rows:
+        emit_info("No mirrored sessions found in Logfire.")
+        return
+    emit_info(f"Mirrored sessions ({len(rows)}):")
+    for row in rows:
+        project = row.get("project") or "?"
+        remote = row.get("remote") or "-"
+        name = row.get("name") or "?"
+        messages = row.get("messages", "?")
+        last_active = str(row.get("last_active", ""))[:19]
+        emit_info(f"  {name}  [{project}]  {messages} msgs  {last_active}  {remote}")
+
+
+def _handle(command: str, name: str) -> bool | None:
+    if name not in COMMAND_NAMES:
+        return None
+
+    from code_puppy.config import set_value
+
+    parts = command.split()[1:]
+    action = parts[0].lower() if parts else "status"
+    args = parts[1:]
+
+    if action == "on":
+        set_value("enable_logfire_sessions", "true")
+        emit_success("Logfire session mirroring enabled.")
+    elif action == "off":
+        set_value("enable_logfire_sessions", "false")
+        emit_success("Logfire session mirroring disabled.")
+    elif action == "list":
+        limit = int(args[0]) if args and args[0].isdigit() else 25
+        _list(min(limit, 100))
+    elif action == "pull":
+        emit_warning(_PULL_STUB)
+    elif action == "status":
+        _status()
+    else:
+        emit_info("Usage: /logfire-sessions [status|on|off|list [limit]|pull]")
+    return True
+
+
+def _help() -> list[tuple[str, str]]:
+    return [
+        (
+            "logfire-sessions",
+            "Mirror chat sessions to Logfire; status/on/off/list/pull",
+        )
+    ]
+
+
+register_callback("post_autosave", _on_post_autosave)
+register_callback("custom_command_help", _help)
+register_callback("custom_command", _handle)

code_puppy_core_plugins-0.0.13/code_puppy_core_plugins/logfire_sessions/sync.py

@@ -0,0 +1,153 @@
+"""Pure encode/decode/state logic for mirroring sessions into Logfire.
+
+No I/O beyond the sync-state JSON file, so everything here is unit-testable
+without a Logfire project or network.
+
+Record shape (one log record per message chunk)::
+
+    cp.hist.name       session file stem
+    cp.hist.seq        message index within the history
+    cp.hist.chunk      "i/n" -- gzipped base64 payload chunk i of n
+    cp.hist.payload    one base64(gzip(json(message))) chunk
+    cp.hist.scope_key  resolved cwd of the session (compute_scope_key)
+    cp.project.name / remote / branch   best-effort workspace metadata
+
+Restore-side note: histories can be re-synced after compaction, so Logfire may
+hold multiple versions of the same seq. :func:`decode_message_rows` therefore
+deduplicates by ``seq``, keeping the *latest* row.
+"""
+
+from __future__ import annotations
+
+import base64
+import gzip
+import hashlib
+import json
+import time
+from pathlib import Path
+from typing import Any, Iterable
+
+CHUNK_CHARS = 16_000  # conservative attribute-size budget per record
+STATE_VERSION = 1
+
+
+def fingerprint(message: Any) -> str:
+    """Stable sha256 for one jsonable pydantic-ai message."""
+    canonical = json.dumps(message, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(canonical.encode()).hexdigest()
+
+
+def plan_sync(previous: list[str] | None, current: list[str]) -> int:
+    """Return the index in ``current`` to start emitting from.
+
+    Append-only growth continues where the last sync stopped. Anything else
+    (divergence from compaction/branching, or a shrunken history) triggers a
+    full re-emit; Logfire keeps both generations and restore dedupes by seq.
+    """
+    if not previous:
+        return 0
+    overlap = min(len(previous), len(current))
+    if previous[:overlap] == current[:overlap]:
+        return max(overlap, 0) if len(current) >= len(previous) else 0
+    return 0
+
+
+def _chunk_b64(payload: bytes) -> list[str]:
+    blob = base64.b64encode(gzip.compress(payload)).decode()
+    return [blob[i : i + CHUNK_CHARS] for i in range(0, len(blob), CHUNK_CHARS)]
+
+
+def encode_message_records(
+    *,
+    name: str,
+    seq: int,
+    message: Any,
+    scope_key: str | None,
+    project_name: str | None,
+    remote: str | None,
+    branch: str | None,
+) -> list[dict[str, Any]]:
+    """Encode one jsonable message as the Logfire records that carry it."""
+    body = json.dumps(message, separators=(",", ":")).encode()
+    chunks = _chunk_b64(body)
+    total = len(chunks)
+    records = []
+    for index, chunk in enumerate(chunks):
+        attrs: dict[str, Any] = {
+            "cp.hist.name": name,
+            "cp.hist.seq": seq,
+            "cp.hist.chunk": f"{index}/{total}",
+            "cp.hist.payload": chunk,
+        }
+        if scope_key:
+            attrs["cp.hist.scope_key"] = scope_key
+        if project_name:
+            attrs["cp.project.name"] = project_name
+        if remote:
+            attrs["cp.project.remote"] = remote
+        if branch:
+            attrs["cp.project.branch"] = branch
+        records.append(attrs)
+    return records
+
+
+def decode_message_rows(rows: Iterable[dict[str, Any]]) -> list[Any]:
+    """Rebuild the messages list from normalized rows.
+
+    Each row is ``{"attributes": {...}, "timestamp": float | None}``. Rows
+    sharing a ``seq`` are joined along their chunk index; when a seq appears
+    more than once (re-synced history), the latest timestamp wins.
+    """
+    by_seq: dict[int, tuple[float, dict[int, str]]] = {}
+    for row in rows:
+        attrs = row.get("attributes") or {}
+        name = attrs.get("cp.hist.name")
+        if name is None or "cp.hist.seq" not in attrs:
+            continue
+        seq = int(attrs["cp.hist.seq"])
+        chunk_index, _, _ = str(attrs.get("cp.hist.chunk", "0/1")).partition("/")
+        timestamp = float(row.get("timestamp") or 0.0)
+        seen_ts, chunks = by_seq.get(seq, (-1.0, {}))
+        if timestamp >= seen_ts:
+            # Later generations of a re-synced seq win, regardless of row order.
+            chunks[int(chunk_index)] = attrs.get("cp.hist.payload", "")
+        by_seq[seq] = (max(seen_ts, timestamp), chunks)
+
+    messages: list[Any] = []
+    for seq in sorted(by_seq):
+        chunks = by_seq[seq][1]
+        blob = "".join(chunks[i] for i in range(len(chunks)))
+        raw = gzip.decompress(base64.b64decode(blob))
+        messages.append(json.loads(raw))
+    return messages
+
+
+def state_path() -> Path:
+    """Sync bookkeeping lives user-side, never next to plugin code (the trust
+    hash covers the plugin directory; writing runtime state there would
+    self-tamper and demand re-acceptance on every boot)."""
+    return Path.home() / ".code_puppy" / "logfire_session_sync.json"
+
+
+def load_state() -> dict[str, Any]:
+    try:
+        state = json.loads(state_path().read_text(encoding="utf-8"))
+    except (FileNotFoundError, OSError, json.JSONDecodeError):
+        return {"version": STATE_VERSION, "sessions": {}}
+    if not isinstance(state.get("sessions"), dict):
+        return {"version": STATE_VERSION, "sessions": {}}
+    return state
+
+
+def save_state(state: dict[str, Any]) -> None:
+    path = state_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(state, indent=2), encoding="utf-8")
+
+
+def synced_entry(fingerprints: list[str]) -> dict[str, Any]:
+    return {
+        "fingerprints": fingerprints,
+        "message_count": len(fingerprints),
+        "synced_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+    }

{code_puppy_core_plugins-0.0.12 → code_puppy_core_plugins-0.0.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.12"
+version = "0.0.13"
 description = "Official plugin bundle for Code Puppy"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"
@@ -57,6 +57,7 @@ herdr = "code_puppy_core_plugins.herdr.register_callbacks"
 hook_creator = "code_puppy_core_plugins.hook_creator.register_callbacks"
 hook_manager = "code_puppy_core_plugins.hook_manager.register_callbacks"
 logfire_oauth = "code_puppy_core_plugins.logfire_oauth.register_callbacks"
+logfire_sessions = "code_puppy_core_plugins.logfire_sessions.register_callbacks"
 meta_oauth = "code_puppy_core_plugins.meta_oauth.register_callbacks"
 namespace_skill_search = "code_puppy_core_plugins.namespace_skill_search.register_callbacks"
 no_tools = "code_puppy_core_plugins.no_tools.register_callbacks"