openrunner-sdk 2.4.4__tar.gz → 2.6.0__tar.gz

{openrunner_sdk-2.4.4 → openrunner_sdk-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 2.4.4
+Version: 2.6.0
 Summary: OpenRunner SDK - W&B-compatible ML experiment tracking client
 Project-URL: Homepage, https://github.com/jqueguiner/openrunner
 Project-URL: Repository, https://github.com/jqueguiner/openrunner

{openrunner_sdk-2.4.4 → openrunner_sdk-2.6.0}/openrunner/__init__.py

@@ -120,7 +120,7 @@ launch.from_run = _launch_from_run  # type: ignore[attr-defined]
 # openrunner.trace.patch_openai() syntax
 trace.patch_openai = _patch_openai  # type: ignore[attr-defined]
 
-__version__ = "2.4.4"
+__version__ = "2.6.0"
 
 logger = logging.getLogger("openrunner")
 

{openrunner_sdk-2.4.4 → openrunner_sdk-2.6.0}/openrunner/api_client.py

@@ -693,27 +693,38 @@ class APIClient:
         2. Absolute URL — try direct PUT, fall back to proxy on ConnectError
         3. ConnectError fallback — PUT via /runs/{run_id}/files/{name}
         """
+        import os
+
         try:
-            with open(file_path, "rb") as f:
-                data = f.read()
+            file_size = os.path.getsize(file_path)
+            # Use streaming for large files, read into memory for small ones
+            if file_size > 50 * 1024 * 1024:  # 50 MB
+                data = open(file_path, "rb")  # noqa: SIM115
+            else:
+                with open(file_path, "rb") as f:
+                    data = f.read()
+
+            # Scale timeout by file size (minimum 60s, ~30s per 100MB)
+            upload_timeout = max(60.0, file_size / (3 * 1024 * 1024))
 
             # Case 1: relative proxy URL from server
             if presigned_url.startswith("/"):
                 api_path = presigned_url.replace("/api/v1/", "/", 1) if presigned_url.startswith("/api/v1/") else presigned_url
-                resp = self._request("put", api_path, content=data)
+                resp = self._client.put(api_path, content=data, timeout=upload_timeout)
                 return resp.status_code == 200
 
             # Case 2: absolute presigned URL (direct to S3)
             try:
-                resp = httpx.put(presigned_url, content=data, timeout=300.0)
+                resp = httpx.put(presigned_url, content=data, timeout=upload_timeout)
                 resp.raise_for_status()
                 return True
             except (httpx.ConnectError, httpx.ConnectTimeout):
                 # Case 3: fallback to API proxy
                 if run_id:
-                    import os
                     fname = os.path.basename(file_path)
-                    proxy_resp = self._request("put", f"/runs/{run_id}/files/{fname}", content=data)
+                    proxy_resp = self._client.put(
+                        f"/runs/{run_id}/files/{fname}", content=data, timeout=upload_timeout
+                    )
                     return proxy_resp.status_code == 200
                 return False
         except Exception as e:

{openrunner_sdk-2.4.4 → openrunner_sdk-2.6.0}/openrunner/cli.py

@@ -2362,3 +2362,105 @@ def _builtin_suggest(
             result[name] = spec
 
     return result if result else None
+
+
+# ---------------------------------------------------------------------------
+# session commands — AI session capture
+# ---------------------------------------------------------------------------
+
+
+@main.group()
+def session() -> None:
+    """Capture and log AI coding sessions (Claude Code, ChatGPT, Codex, Qwen)."""
+    pass
+
+
+@session.command("sync")
+@click.option("--hours", "-h", default=24.0, help="Look back N hours (default: 24)")
+@click.option("--project", "-p", default=None, help="Target project (default: research-sessions)")
+@click.option("--dry-run", is_flag=True, help="Show what would be synced without uploading")
+def session_sync(hours: float, project: str | None, dry_run: bool) -> None:
+    """Sync recent AI sessions to OpenRunner."""
+    from openrunner.session import discover_all_sessions, sync_all
+
+    if dry_run:
+        sessions = discover_all_sessions(hours)
+        if not sessions:
+            click.echo("No sessions found.")
+            return
+        click.echo(f"Found {len(sessions)} session(s):")
+        for s in sessions:
+            ts = time.strftime("%Y-%m-%d %H:%M", time.localtime(s["mtime"]))
+            size = s["size"] / 1024
+            click.echo(f"  [{s['source']}] {ts} ({size:.0f} KB) {s['path'].name}")
+        return
+
+    synced = sync_all(since_hours=hours, project=project)
+    if synced:
+        click.echo(f"Synced {len(synced)} session(s) to OpenRunner.")
+        for run_id in synced:
+            click.echo(f"  -> run {run_id}")
+    else:
+        click.echo("No new sessions to sync.")
+
+
+@session.command("watch")
+@click.option("--interval", "-i", default=60, help="Check interval in seconds (default: 60)")
+@click.option("--project", "-p", default=None, help="Target project")
+def session_watch(interval: int, project: str | None) -> None:
+    """Watch for new sessions and sync them continuously (daemon mode)."""
+    from openrunner.session import watch
+    click.echo(f"Watching for AI sessions (every {interval}s). Ctrl+C to stop.")
+    try:
+        watch(interval=interval, project=project)
+    except KeyboardInterrupt:
+        click.echo("\nStopped.")
+
+
+@session.command("list")
+@click.option("--hours", "-h", default=24.0, help="Look back N hours")
+def session_list(hours: float) -> None:
+    """List discovered AI sessions."""
+    from openrunner.session import discover_all_sessions, _load_sync_state
+
+    sessions = discover_all_sessions(hours)
+    state = _load_sync_state()
+
+    if not sessions:
+        click.echo("No sessions found.")
+        return
+
+    click.echo(f"{'SOURCE':<14} {'TIME':<18} {'SIZE':<10} {'STATUS'}")
+    click.echo("-" * 60)
+    for s in sessions:
+        from openrunner.session import _session_hash
+        ts = time.strftime("%Y-%m-%d %H:%M", time.localtime(s["mtime"]))
+        size = f"{s['size'] / 1024:.0f} KB"
+        h = _session_hash(s["path"])
+        synced_info = state.get("synced", {}).get(h)
+        status = f"synced ({synced_info['run_id']})" if synced_info else "new"
+        click.echo(f"  {s['source']:<12} {ts:<18} {size:<10} {status}")
+
+
+@session.command("hook")
+@click.argument("action", type=click.Choice(["install", "uninstall"]))
+def session_hook(action: str) -> None:
+    """Install/uninstall Claude Code auto-capture hook."""
+    if action == "install":
+        from openrunner.session import install_claude_hook
+        path = install_claude_hook()
+        click.echo(f"Claude Code hook installed.")
+        click.echo(f"  Config: {path}")
+        click.echo("  Sessions will be auto-logged on exit.")
+    else:
+        from pathlib import Path
+        hooks_file = Path.home() / ".claude" / "hooks.json"
+        if hooks_file.exists():
+            import json as json_mod
+            hooks = json_mod.loads(hooks_file.read_text())
+            stop_hooks = hooks.get("hooks", {}).get("Stop", [])
+            hooks["hooks"]["Stop"] = [h for h in stop_hooks if "openrunner" not in str(h)]
+            hooks_file.write_text(json_mod.dumps(hooks, indent=2))
+            click.echo("Claude Code hook removed.")
+        else:
+            click.echo("No hooks.json found.")

{openrunner_sdk-2.4.4 → openrunner_sdk-2.6.0}/openrunner/run.py

@@ -825,13 +825,21 @@ class Run:
 
             # Upload files that need uploading (dedup may skip some)
             # Reference files and reused files never have upload URLs.
+            all_uploaded = True
             for url_entry in result.get("upload_urls", []):
                 local = next(
                     f for f in artifact._files if f["name"] == url_entry["name"]
                 )
-                self._client.upload_file_to_presigned_url(
+                ok = self._client.upload_file_to_presigned_url(
                     url_entry["presigned_url"], local["local_path"]
                 )
+                if not ok:
+                    logger.warning("upload failed for %s", url_entry["name"])
+                    all_uploaded = False
+
+            if not all_uploaded:
+                logger.error("artifact upload incomplete — not confirming version")
+                return None
 
             # Confirm the version
             self._client.confirm_artifact_version(result["version_id"])

openrunner_sdk-2.6.0/openrunner/session.py

@@ -0,0 +1,531 @@
+"""AI session capture — sniff and log coding sessions from Claude Code, ChatGPT, Codex, Qwen.
+
+Usage:
+    openrunner session watch          # daemon mode, auto-logs new sessions
+    openrunner session sync           # one-shot, sync recent unlogged sessions
+    openrunner session hook install   # install Claude Code hook for auto-capture
+    openrunner session list           # list captured sessions
+
+Supports:
+    - Claude Code (~/.claude/projects/*/*.jsonl)
+    - ChatGPT API logs (if OPENAI_LOG_DIR set)
+    - Codex CLI (~/.codex/sessions/)
+    - Qwen Code (~/.qwen-code/sessions/)
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import os
+import re
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger("openrunner.session")
+
+# ---------------------------------------------------------------------------
+# Session source detectors
+# ---------------------------------------------------------------------------
+
+CLAUDE_CODE_DIR = Path.home() / ".claude" / "projects"
+CODEX_DIR = Path.home() / ".codex" / "sessions"
+QWEN_DIR = Path.home() / ".qwen-code" / "sessions"
+CHATGPT_LOG_DIR = Path(os.environ.get("OPENAI_LOG_DIR", "~/.openai/logs")).expanduser()
+
+# Track which sessions we've already synced
+SYNC_STATE_FILE = Path.home() / ".openrunner" / "session_sync_state.json"
+
+
+def _load_sync_state() -> dict:
+    """Load set of already-synced session hashes."""
+    if SYNC_STATE_FILE.exists():
+        return json.loads(SYNC_STATE_FILE.read_text())
+    return {"synced": {}}
+
+
+def _save_sync_state(state: dict) -> None:
+    SYNC_STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    SYNC_STATE_FILE.write_text(json.dumps(state, indent=2))
+
+
+def _session_hash(path: Path) -> str:
+    """Stable hash for a session file (path + size + mtime)."""
+    stat = path.stat()
+    key = f"{path}:{stat.st_size}:{int(stat.st_mtime)}"
+    return hashlib.md5(key.encode()).hexdigest()[:12]
+
+
+# ---------------------------------------------------------------------------
+# Claude Code parser
+# ---------------------------------------------------------------------------
+
+
+def discover_claude_sessions(since_hours: float = 24) -> list[dict]:
+    """Find recent Claude Code session files."""
+    sessions = []
+    if not CLAUDE_CODE_DIR.exists():
+        return sessions
+
+    cutoff = time.time() - (since_hours * 3600)
+    for jsonl in CLAUDE_CODE_DIR.rglob("*.jsonl"):
+        if jsonl.stat().st_mtime < cutoff:
+            continue
+        sessions.append({
+            "source": "claude-code",
+            "path": jsonl,
+            "mtime": jsonl.stat().st_mtime,
+            "size": jsonl.stat().st_size,
+        })
+    return sorted(sessions, key=lambda s: s["mtime"], reverse=True)
+
+
+def parse_claude_session(path: Path) -> dict[str, Any]:
+    """Parse a Claude Code .jsonl session into structured data."""
+    messages = []
+    tools_used = set()
+    files_touched = set()
+    total_tokens = 0
+
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                entry = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            # Claude Code format: {type, message: {role, content}, ...}
+            msg = entry.get("message", entry)
+            role = msg.get("role", entry.get("type", ""))
+            content = msg.get("content", "")
+
+            # Handle content as list (Claude API format)
+            if isinstance(content, list):
+                text_parts = []
+                for block in content:
+                    if isinstance(block, dict):
+                        if block.get("type") == "text":
+                            text_parts.append(block.get("text", ""))
+                        elif block.get("type") == "tool_use":
+                            tools_used.add(block.get("name", "unknown"))
+                            # Track files from Read/Write/Edit
+                            inp = block.get("input", {})
+                            if "file_path" in inp:
+                                files_touched.add(inp["file_path"])
+                            elif "path" in inp:
+                                files_touched.add(inp["path"])
+                        elif block.get("type") == "tool_result":
+                            pass
+                content = "\n".join(text_parts)
+
+            if role == "user" and content:
+                messages.append({"role": "user", "content": content[:2000]})
+            elif role == "assistant" and content:
+                messages.append({"role": "assistant", "content": content[:2000]})
+
+            # Token counting from usage field (may be at entry or message level)
+            usage = entry.get("usage", msg.get("usage", {}))
+            total_tokens += usage.get("input_tokens", 0) + usage.get("output_tokens", 0)
+
+    # Extract project context from path
+    # ~/.claude/projects/-home-user-myproject/session.jsonl
+    project_hint = path.parent.name.replace("-", "/").lstrip("/")
+
+    # Build summary
+    user_messages = [m for m in messages if m["role"] == "user"]
+    first_msg = user_messages[0]["content"][:200] if user_messages else "Empty session"
+
+    return {
+        "source": "claude-code",
+        "session_file": str(path),
+        "project_hint": project_hint,
+        "started_at": datetime.fromtimestamp(path.stat().st_mtime - _estimate_duration(path), tz=timezone.utc).isoformat(),
+        "ended_at": datetime.fromtimestamp(path.stat().st_mtime, tz=timezone.utc).isoformat(),
+        "message_count": len(messages),
+        "user_message_count": len(user_messages),
+        "tools_used": sorted(tools_used),
+        "files_touched": sorted(files_touched)[:50],
+        "total_tokens": total_tokens,
+        "first_message": first_msg,
+        "summary": _summarize_session(messages),
+        "messages": messages[:100],  # cap at 100 for storage
+    }
+
+
+def _estimate_duration(path: Path) -> float:
+    """Rough session duration estimate from file size."""
+    # ~500 bytes per message exchange, ~30s per exchange
+    size = path.stat().st_size
+    exchanges = size / 500
+    return min(exchanges * 30, 7200)  # cap at 2h
+
+
+def _summarize_session(messages: list[dict]) -> str:
+    """Generate a text summary from messages."""
+    user_msgs = [m["content"] for m in messages if m["role"] == "user"]
+    if not user_msgs:
+        return "Empty session"
+
+    # Use first and last user messages as summary
+    parts = []
+    if user_msgs:
+        parts.append(f"Started: {user_msgs[0][:100]}")
+    if len(user_msgs) > 1:
+        parts.append(f"Last: {user_msgs[-1][:100]}")
+    parts.append(f"({len(user_msgs)} user messages)")
+    return " | ".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Codex / Qwen / ChatGPT parsers (simpler)
+# ---------------------------------------------------------------------------
+
+
+def discover_codex_sessions(since_hours: float = 24) -> list[dict]:
+    """Find recent Codex sessions."""
+    sessions = []
+    if not CODEX_DIR.exists():
+        return sessions
+    cutoff = time.time() - (since_hours * 3600)
+    for f in CODEX_DIR.glob("*.json"):
+        if f.stat().st_mtime < cutoff:
+            continue
+        sessions.append({"source": "codex", "path": f, "mtime": f.stat().st_mtime, "size": f.stat().st_size})
+    return sessions
+
+
+def discover_qwen_sessions(since_hours: float = 24) -> list[dict]:
+    """Find recent Qwen Code sessions."""
+    sessions = []
+    if not QWEN_DIR.exists():
+        return sessions
+    cutoff = time.time() - (since_hours * 3600)
+    for f in QWEN_DIR.rglob("*.json"):
+        if f.stat().st_mtime < cutoff:
+            continue
+        sessions.append({"source": "qwen", "path": f, "mtime": f.stat().st_mtime, "size": f.stat().st_size})
+    return sessions
+
+
+def discover_chatgpt_sessions(since_hours: float = 24) -> list[dict]:
+    """Find ChatGPT API log files."""
+    sessions = []
+    if not CHATGPT_LOG_DIR.exists():
+        return sessions
+    cutoff = time.time() - (since_hours * 3600)
+    for f in CHATGPT_LOG_DIR.rglob("*.jsonl"):
+        if f.stat().st_mtime < cutoff:
+            continue
+        sessions.append({"source": "chatgpt", "path": f, "mtime": f.stat().st_mtime, "size": f.stat().st_size})
+    return sessions
+
+
+def parse_generic_session(path: Path, source: str) -> dict[str, Any]:
+    """Parse a generic JSON/JSONL session file."""
+    messages = []
+    try:
+        if path.suffix == ".jsonl":
+            with open(path) as f:
+                for line in f:
+                    if line.strip():
+                        try:
+                            messages.append(json.loads(line))
+                        except json.JSONDecodeError:
+                            pass
+        else:
+            data = json.loads(path.read_text())
+            if isinstance(data, list):
+                messages = data
+            elif isinstance(data, dict) and "messages" in data:
+                messages = data["messages"]
+    except Exception:
+        pass
+
+    return {
+        "source": source,
+        "session_file": str(path),
+        "project_hint": "",
+        "started_at": datetime.fromtimestamp(path.stat().st_mtime - 1800, tz=timezone.utc).isoformat(),
+        "ended_at": datetime.fromtimestamp(path.stat().st_mtime, tz=timezone.utc).isoformat(),
+        "message_count": len(messages),
+        "user_message_count": sum(1 for m in messages if isinstance(m, dict) and m.get("role") == "user"),
+        "tools_used": [],
+        "files_touched": [],
+        "total_tokens": 0,
+        "first_message": str(messages[0])[:200] if messages else "Empty",
+        "summary": f"{source} session with {len(messages)} messages",
+        "messages": messages[:100],
+    }
+
+
+# ---------------------------------------------------------------------------
+# Sync to OpenRunner
+# ---------------------------------------------------------------------------
+
+
+def sync_session_to_openrunner(
+    parsed: dict[str, Any],
+    project: str | None = None,
+    api_key: str | None = None,
+    base_url: str | None = None,
+) -> str | None:
+    """Upload a parsed session to OpenRunner as a run with notes.
+
+    Returns the run ID on success, None on failure.
+    """
+    from openrunner.api_client import APIClient
+
+    # Load settings from ~/.openrunner/settings.json
+    if not api_key or not base_url:
+        settings_file = Path.home() / ".openrunner" / "settings.json"
+        settings = {}
+        if settings_file.exists():
+            try:
+                settings = json.loads(settings_file.read_text())
+            except (json.JSONDecodeError, OSError):
+                pass
+        api_key = api_key or os.environ.get("OPENRUNNER_API_KEY") or settings.get("api_key")
+        base_url = base_url or os.environ.get("OPENRUNNER_BASE_URL") or settings.get("base_url")
+
+    if not api_key or not base_url:
+        logger.warning("No API key or base URL configured. Run 'openrunner login' first.")
+        return None
+
+    # Determine project
+    if not project:
+        project = os.environ.get("OPENRUNNER_SESSION_PROJECT", "research-sessions")
+
+    client = APIClient(base_url=base_url, api_key=api_key)
+
+    # Create run
+    source = parsed["source"]
+    timestamp = parsed.get("ended_at", "")[:16].replace("T", " ")
+    run_name = f"{source}/{timestamp}"
+
+    run_data = {
+        "project": project,
+        "display_name": run_name,
+        "config": {
+            "source": source,
+            "session_file": parsed.get("session_file", ""),
+            "project_hint": parsed.get("project_hint", ""),
+            "message_count": parsed.get("message_count", 0),
+            "user_message_count": parsed.get("user_message_count", 0),
+            "tools_used": parsed.get("tools_used", []),
+            "total_tokens": parsed.get("total_tokens", 0),
+        },
+        "tags": [f"source:{source}", "ai-session"],
+        "notes": _format_session_notes(parsed),
+        "state": "finished",
+    }
+
+    result = client.create_run(run_data)
+    if not result:
+        logger.warning("Failed to create session run")
+        client.close()
+        return None
+
+    run_id = result.get("id")
+
+    # Log metrics
+    metrics = []
+    if parsed.get("total_tokens"):
+        metrics.append({"key": "tokens", "value": parsed["total_tokens"], "step": 1})
+    if parsed.get("message_count"):
+        metrics.append({"key": "messages", "value": parsed["message_count"], "step": 1})
+    if parsed.get("user_message_count"):
+        metrics.append({"key": "user_messages", "value": parsed["user_message_count"], "step": 1})
+    if parsed.get("files_touched"):
+        metrics.append({"key": "files_touched", "value": len(parsed["files_touched"]), "step": 1})
+
+    if metrics and run_id:
+        client.post_metrics(run_id, metrics)
+
+    # Log files touched as summary
+    if parsed.get("files_touched") and run_id:
+        client.update_run(run_id, {
+            "summary": {
+                "files_touched": len(parsed["files_touched"]),
+                "tools_used": len(parsed.get("tools_used", [])),
+                "tokens": parsed.get("total_tokens", 0),
+            }
+        })
+
+    client.close()
+    return run_id
+
+
+def _format_session_notes(parsed: dict) -> str:
+    """Format parsed session into readable notes."""
+    lines = []
+    lines.append(f"# {parsed['source'].title()} Session")
+    lines.append(f"**Time:** {parsed.get('started_at', '?')[:16]} → {parsed.get('ended_at', '?')[:16]}")
+    lines.append("")
+
+    if parsed.get("first_message"):
+        lines.append(f"## First Request")
+        lines.append(parsed["first_message"])
+        lines.append("")
+
+    if parsed.get("tools_used"):
+        lines.append(f"## Tools Used ({len(parsed['tools_used'])})")
+        for t in parsed["tools_used"][:20]:
+            lines.append(f"- {t}")
+        lines.append("")
+
+    if parsed.get("files_touched"):
+        lines.append(f"## Files Touched ({len(parsed['files_touched'])})")
+        for f in parsed["files_touched"][:30]:
+            lines.append(f"- `{f}`")
+        lines.append("")
+
+    if parsed.get("summary"):
+        lines.append(f"## Summary")
+        lines.append(parsed["summary"])
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Discovery + sync orchestration
+# ---------------------------------------------------------------------------
+
+
+def discover_all_sessions(since_hours: float = 24) -> list[dict]:
+    """Discover sessions from all sources."""
+    all_sessions = []
+    all_sessions.extend(discover_claude_sessions(since_hours))
+    all_sessions.extend(discover_codex_sessions(since_hours))
+    all_sessions.extend(discover_qwen_sessions(since_hours))
+    all_sessions.extend(discover_chatgpt_sessions(since_hours))
+    return sorted(all_sessions, key=lambda s: s["mtime"], reverse=True)
+
+
+def sync_all(
+    since_hours: float = 24,
+    project: str | None = None,
+    dry_run: bool = False,
+) -> list[str]:
+    """Discover and sync all new sessions. Returns list of synced run IDs."""
+    state = _load_sync_state()
+    sessions = discover_all_sessions(since_hours)
+    synced_ids = []
+
+    for session_info in sessions:
+        h = _session_hash(session_info["path"])
+        if h in state["synced"]:
+            continue
+
+        if dry_run:
+            logger.info(f"[dry-run] Would sync: {session_info['source']} {session_info['path']}")
+            continue
+
+        # Parse
+        if session_info["source"] == "claude-code":
+            parsed = parse_claude_session(session_info["path"])
+        else:
+            parsed = parse_generic_session(session_info["path"], session_info["source"])
+
+        # Sync
+        run_id = sync_session_to_openrunner(parsed, project=project)
+        if run_id:
+            state["synced"][h] = {
+                "run_id": run_id,
+                "source": session_info["source"],
+                "synced_at": datetime.now(timezone.utc).isoformat(),
+            }
+            synced_ids.append(run_id)
+            logger.info(f"Synced {session_info['source']} session -> run {run_id}")
+
+    _save_sync_state(state)
+    return synced_ids
+
+
+# ---------------------------------------------------------------------------
+# Claude Code hook installer
+# ---------------------------------------------------------------------------
+
+
+HOOK_SCRIPT = '''#!/usr/bin/env python3
+"""Auto-log Claude Code session to OpenRunner on exit."""
+import sys
+from pathlib import Path
+
+def main():
+    # Find the most recent session file that was just written
+    from openrunner.session import discover_claude_sessions, parse_claude_session, sync_session_to_openrunner
+
+    sessions = discover_claude_sessions(since_hours=0.1)  # last 6 minutes
+    if not sessions:
+        return
+
+    latest = sessions[0]
+    parsed = parse_claude_session(latest["path"])
+
+    # Only sync if meaningful (>2 user messages)
+    if parsed.get("user_message_count", 0) < 2:
+        return
+
+    run_id = sync_session_to_openrunner(parsed)
+    if run_id:
+        print(f"openrunner: Session logged as run {run_id}", file=sys.stderr)
+
+if __name__ == "__main__":
+    main()
+'''
+
+
+def install_claude_hook() -> str:
+    """Install Claude Code hook for auto-session capture.
+
+    Returns path to the installed hook config.
+    """
+    claude_dir = Path.home() / ".claude"
+    claude_dir.mkdir(exist_ok=True)
+
+    # Write hook script
+    hook_script_path = claude_dir / "openrunner_session_hook.py"
+    hook_script_path.write_text(HOOK_SCRIPT)
+    hook_script_path.chmod(0o755)
+
+    # Update or create hooks.json
+    hooks_file = claude_dir / "hooks.json"
+    if hooks_file.exists():
+        hooks = json.loads(hooks_file.read_text())
+    else:
+        hooks = {"hooks": {}}
+
+    # Add to Stop hooks
+    stop_hooks = hooks.setdefault("hooks", {}).setdefault("Stop", [])
+    hook_cmd = f"python3 {hook_script_path}"
+
+    # Don't duplicate
+    if not any(hook_cmd in str(h) for h in stop_hooks):
+        stop_hooks.append({"command": hook_cmd})
+
+    hooks_file.write_text(json.dumps(hooks, indent=2))
+    return str(hooks_file)
+
+
+# ---------------------------------------------------------------------------
+# Watch mode (daemon)
+# ---------------------------------------------------------------------------
+
+
+def watch(interval: int = 60, project: str | None = None) -> None:
+    """Watch for new sessions and sync them continuously."""
+    logger.info(f"Watching for AI sessions (interval={interval}s)...")
+    while True:
+        try:
+            synced = sync_all(since_hours=1, project=project)
+            if synced:
+                logger.info(f"Synced {len(synced)} new session(s)")
+        except Exception as e:
+            logger.warning(f"Watch cycle error: {e}")
+        time.sleep(interval)

{openrunner_sdk-2.4.4 → openrunner_sdk-2.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openrunner-sdk"
-version = "2.4.4"
+version = "2.6.0"
 description = "OpenRunner SDK - W&B-compatible ML experiment tracking client"
 readme = "README.md"
 license = {text = "MIT"}