cp

Author: daveey

metta/tools/play.py

@@ -129,21 +129,4 @@ def invoke(self, args: dict[str, str]) -> int | None:
         # Print agent inventories table
         episode.print_agent_stats()
 
-        # Print agent inventories
-        if episode.agent_inventories and episode.resource_names:
-            console.print("\n[bold cyan]Agent Inventories:[/bold cyan]")
-            for agent_id, inventory in enumerate(episode.agent_inventories):
-                inv_str = ", ".join(f"{k}={v}" for k, v in sorted(inventory.items()) if v > 0)
-                console.print(f"  Agent {agent_id}: {inv_str if inv_str else '(empty)'}")
-
-            # Print resource totals
-            console.print("\n[bold cyan]Resource Totals:[/bold cyan]")
-            resource_totals: dict[str, int] = {}
-            for inventory in episode.agent_inventories:
-                for resource, amount in inventory.items():
-                    resource_totals[resource] = resource_totals.get(resource, 0) + amount
-            for resource in episode.resource_names:
-                total = resource_totals.get(resource, 0)
-                console.print(f"  {resource}: {total}")
-
         return None

projects/skydeck/CLAUDE.md

@@ -0,0 +1,50 @@
+# SkyDeck Development Guidelines
+
+## SkyPilot Integration
+
+**IMPORTANT**: Always use the SkyPilot API for accessing job and cluster information. Never query the SkyPilot SQLite databases directly (e.g., `~/.sky/jobs.db`, `~/.sky/state.db`).
+
+### API Access
+
+- API endpoint: `https://skypilot-api.softmax-research.net`
+- Authentication: OAuth2 cookies stored in `~/.sky/cookies.txt`
+- Configuration: `~/.sky/config.yaml`
+
+### Why Use the API
+
+1. **Centralized data**: The API provides access to managed jobs across all users and clusters
+2. **Up-to-date information**: The API reflects the current state of the jobs controller
+3. **Proper abstractions**: The API provides structured data with proper types
+4. **Security**: Direct database access bypasses authentication and auditing
+
+## Database
+
+**Database Location**: SkyDeck uses SQLite for persistent storage.
+
+- **Default location**: `~/.skydeck/skydeck.db`
+- **Configuration**: Can be overridden with `--db-path` flag or `SKYDECK_DB_PATH` environment variable
+- **Schema**: Defined in `skydeck/database.py` with automatic migrations on startup
+
+### Database Scripts
+
+When working with the database directly:
+
+```bash
+# Backfill checkpoint versions (example)
+uv run python -c "
+import asyncio
+from pathlib import Path
+from skydeck.backfill_versions import backfill_checkpoint_versions
+db_path = str(Path.home() / '.skydeck' / 'skydeck.db')
+asyncio.run(backfill_checkpoint_versions(db_path))
+"
+
+# Query database directly
+sqlite3 ~/.skydeck/skydeck.db "SELECT COUNT(*) FROM experiments;"
+```
+
+### Code Style
+
+- Always use `uv` for pip and python operations
+- Imports should go at the top of the file if possible
+- Follow existing patterns in the codebase for consistency

projects/skydeck/discover_api.py

@@ -0,0 +1,73 @@
+"""Discover SkyPilot API endpoints."""
+
+import http.cookiejar
+import json
+import urllib.request
+
+from skydeck.services import ServiceEndpoints
+
+
+def load_cookies():
+    """Load cookies from ~/.sky/cookies.txt."""
+    jar = http.cookiejar.MozillaCookieJar()
+    jar.load("/Users/daveey/.sky/cookies.txt", ignore_discard=True, ignore_expires=True)
+    return jar
+
+
+def try_endpoint(path):
+    """Try an API endpoint and return the response."""
+    url = f"{ServiceEndpoints.SKYPILOT_API}{path}"
+    jar = load_cookies()
+    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar))
+
+    try:
+        req = urllib.request.Request(url)
+        req.add_header("Accept", "application/json")
+        response = opener.open(req, timeout=10)
+        data = response.read().decode("utf-8")
+        try:
+            parsed = json.loads(data)
+            print(f"✓ {path}")
+            print(f"  Status: {response.status}")
+            print(f"  Response: {json.dumps(parsed, indent=2)[:200]}...")
+            return True
+        except json.JSONDecodeError:
+            print(f"✗ {path} - Not JSON: {data[:100]}")
+            return False
+    except urllib.error.HTTPError as e:
+        print(f"✗ {path} - HTTP {e.code}: {e.reason}")
+        return False
+    except Exception as e:
+        print(f"✗ {path} - Error: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    endpoints = [
+        # Try different API paths
+        "/api/jobs",
+        "/api/v1/jobs",
+        "/api/v2/jobs",
+        "/api/managed_jobs",
+        "/api/queue",
+        "/api/status",
+        "/jobs",
+        "/queue",
+        "/v1/jobs",
+        "/v1/managed_jobs",
+        # Try specific job
+        "/api/jobs/9588",
+        "/api/v1/jobs/9588",
+        "/jobs/9588",
+        # Try listing endpoints
+        "/api",
+        "/api/v1",
+        "",
+    ]
+
+    print("Testing SkyPilot API endpoints...")
+    print("=" * 60)
+
+    for endpoint in endpoints:
+        try_endpoint(endpoint)
+        print()

projects/skydeck/skydeck/app.py

@@ -259,14 +259,24 @@ async def update_experiment_starred(experiment_id: str, data: dict):
 
 @app.delete("/api/experiments/{experiment_id}")
 async def delete_experiment(experiment_id: str):
-    """Delete an experiment."""
+    """Soft-delete an experiment."""
     try:
         await desired_state_manager.delete_experiment(experiment_id)
         return {"message": "Experiment deleted"}
     except ValueError as e:
         raise HTTPException(status_code=404, detail=str(e)) from e
 
 
+@app.post("/api/experiments/{experiment_id}/undelete")
+async def undelete_experiment(experiment_id: str):
+    """Restore a soft-deleted experiment."""
+    try:
+        await db.undelete_experiment(experiment_id)
+        return {"message": "Experiment restored"}
+    except Exception as e:
+        raise HTTPException(status_code=404, detail=str(e)) from e
+
+
 @app.post("/api/experiments/{experiment_id}/state")
 async def update_desired_state(experiment_id: str, request: UpdateDesiredStateRequest):
     """Update experiment desired state."""
@@ -284,9 +294,8 @@ async def get_experiment_status(experiment_id: str) -> ExperimentStatus:
     if not experiment:
         raise HTTPException(status_code=404, detail="Experiment not found")
 
-    current_job = None
-    if experiment.current_job_id:
-        current_job = await db.get_job(experiment.current_job_id)
+    # Get current active job dynamically
+    current_job = await db.get_current_job_for_experiment(experiment_id)
 
     recent_jobs = await db.get_jobs_for_experiment(experiment_id, limit=10)
 
@@ -321,7 +330,7 @@ async def update_experiment_flags(experiment_id: str, request: UpdateFlagsReques
 @app.get("/api/experiments/{experiment_id}/checkpoints")
 async def get_experiment_checkpoints(experiment_id: str, limit: int = 50):
     """Get checkpoints for an experiment."""
-    from urllib.parse import quote
+    from .services import ObservatoryService
 
     experiment = await desired_state_manager.get_experiment(experiment_id)
     if not experiment:
@@ -332,7 +341,7 @@ async def get_experiment_checkpoints(experiment_id: str, limit: int = 50):
     # Enrich checkpoints with Observatory URLs
     for checkpoint in checkpoints:
         policy_name = f"{experiment_id}.{checkpoint.epoch}"
-        checkpoint.observatory_url = f"https://observatory.softmax-research.net/policy/{quote(policy_name, safe='')}"
+        checkpoint.observatory_url = ObservatoryService.get_policy_web_url(policy_name)
 
     return {"checkpoints": checkpoints}
 

projects/skydeck/skydeck/backfill_versions.py

@@ -0,0 +1,94 @@
+"""Script to backfill policy versions for all checkpoints in the database."""
+
+import asyncio
+import logging
+from datetime import datetime
+
+from .database import Database
+from .services import ObservatoryService
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+async def backfill_checkpoint_versions(db_path: str = "skydeck.db"):
+    """Backfill policy versions for all checkpoints missing them.
+
+    Args:
+        db_path: Path to the SQLite database
+    """
+    db = Database(db_path)
+    await db.connect()
+
+    try:
+        # Get all experiments
+        experiments = await db.get_all_experiments()
+        logger.info(f"Found {len(experiments)} experiments")
+
+        total_checkpoints = 0
+        updated_checkpoints = 0
+
+        for exp in experiments:
+            logger.info(f"Processing experiment: {exp.id}")
+
+            # Get all checkpoints for this experiment (no limit)
+            cursor = await db._conn.execute(
+                """
+                SELECT * FROM checkpoints
+                WHERE experiment_id = ?
+                ORDER BY epoch DESC
+                """,
+                (exp.id,),
+            )
+            rows = await cursor.fetchall()
+            checkpoints = [db._row_to_checkpoint(row) for row in rows]
+
+            total_checkpoints += len(checkpoints)
+            logger.info(f"  Found {len(checkpoints)} checkpoints")
+
+            # Filter checkpoints that need backfill
+            needs_backfill = [cp for cp in checkpoints if not cp.policy_version]
+
+            if not needs_backfill:
+                logger.info("  All checkpoints have versions, skipping")
+                continue
+
+            logger.info(f"  {len(needs_backfill)} checkpoints need version backfill")
+
+            # Fetch policy version once per experiment
+            policy_version = ObservatoryService.fetch_policy_version(exp.id)
+            observatory_url = ObservatoryService.get_policy_api_url(exp.id, limit=500)
+
+            if policy_version:
+                logger.info(f"  Found policy version: {policy_version}")
+            else:
+                logger.warning(f"  Could not fetch policy version for {exp.id}")
+
+            # Update all checkpoints that need backfill
+            for cp in needs_backfill:
+                # Update the checkpoint fields
+                cp.policy_version = policy_version
+                cp.observatory_url = observatory_url
+                cp.synced_at = datetime.utcnow()
+
+                # Save the updated checkpoint
+                await db.save_checkpoint(cp)
+                updated_checkpoints += 1
+
+            logger.info(f"  Updated {len(needs_backfill)} checkpoints")
+
+        logger.info("\nBackfill complete:")
+        logger.info(f"  Total checkpoints: {total_checkpoints}")
+        logger.info(f"  Updated checkpoints: {updated_checkpoints}")
+
+    finally:
+        await db.close()
+
+
+async def main():
+    """Main entry point."""
+    await backfill_checkpoint_versions()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())