copilot-sessions 1.3.0__tar.gz

copilot_sessions-1.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Haim Cohen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

copilot_sessions-1.3.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: copilot-sessions
+Version: 1.3.0
+Summary: Terminal tool to view and manage GitHub Copilot CLI sessions
+Author: Haim Cohen
+License: MIT
+Project-URL: Homepage, https://github.com/sk3pp3r/copilot-sessions
+Project-URL: Issues, https://github.com/sk3pp3r/copilot-sessions/issues
+Keywords: copilot,github,cli,sessions
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Dynamic: license-file
+
+# 🤖 Copilot Sessions
+
+A terminal tool to view and manage your GitHub Copilot CLI sessions — track usage, costs, premium requests, kill stale sessions, and clean up old ones.
+
+![Python](https://img.shields.io/badge/python-3.9+-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+## Features
+
+- **List & filter** all Copilot CLI sessions
+- **View details** with full 💰 usage breakdown (tokens, models, premium requests, cost)
+- **Active sessions** — see what's running live
+- **Kill** stale/orphan live sessions
+- **Delete & cleanup** old sessions by age
+- **Statistics** — total usage across all sessions
+- **Resume command** — copy-paste to jump back into any session
+
+## Installation
+
+### pipx (Recommended)
+```bash
+pipx install copilot-sessions
+```
+
+### pip
+```bash
+pip install copilot-sessions
+```
+
+### From source
+```bash
+git clone https://github.com/sk3pp3r/copilot-sessions.git
+cd copilot-sessions
+pipx install .
+```
+
+## Usage
+
+```bash
+copilot-sessions              # launch interactive manager
+copilot-sessions --active     # show active sessions only
+copilot-sessions --version    # show version
+copilot-sessions --help       # full help
+```
+
+### Interactive Commands
+
+| Key | Action |
+|-----|--------|
+| `l` | List all sessions |
+| `f` | Filter/search sessions |
+| `a` | Active sessions |
+| `v` | View session detail + 💰 Usage |
+| `s` | Show statistics |
+| `d` | Delete session(s) |
+| `k` | Kill live session(s) |
+| `c` | Cleanup old sessions |
+| `r` | Refresh |
+| `q` | Quit |
+
+## Requirements
+
+- Python 3.9+
+- [rich](https://github.com/Textualize/rich) (installed automatically)
+- GitHub Copilot CLI (`~/.copilot/session-state/` must exist)
+
+## License
+
+MIT © Haim Cohen

copilot_sessions-1.3.0/README.md

@@ -0,0 +1,69 @@
+# 🤖 Copilot Sessions
+
+A terminal tool to view and manage your GitHub Copilot CLI sessions — track usage, costs, premium requests, kill stale sessions, and clean up old ones.
+
+![Python](https://img.shields.io/badge/python-3.9+-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+## Features
+
+- **List & filter** all Copilot CLI sessions
+- **View details** with full 💰 usage breakdown (tokens, models, premium requests, cost)
+- **Active sessions** — see what's running live
+- **Kill** stale/orphan live sessions
+- **Delete & cleanup** old sessions by age
+- **Statistics** — total usage across all sessions
+- **Resume command** — copy-paste to jump back into any session
+
+## Installation
+
+### pipx (Recommended)
+```bash
+pipx install copilot-sessions
+```
+
+### pip
+```bash
+pip install copilot-sessions
+```
+
+### From source
+```bash
+git clone https://github.com/sk3pp3r/copilot-sessions.git
+cd copilot-sessions
+pipx install .
+```
+
+## Usage
+
+```bash
+copilot-sessions              # launch interactive manager
+copilot-sessions --active     # show active sessions only
+copilot-sessions --version    # show version
+copilot-sessions --help       # full help
+```
+
+### Interactive Commands
+
+| Key | Action |
+|-----|--------|
+| `l` | List all sessions |
+| `f` | Filter/search sessions |
+| `a` | Active sessions |
+| `v` | View session detail + 💰 Usage |
+| `s` | Show statistics |
+| `d` | Delete session(s) |
+| `k` | Kill live session(s) |
+| `c` | Cleanup old sessions |
+| `r` | Refresh |
+| `q` | Quit |
+
+## Requirements
+
+- Python 3.9+
+- [rich](https://github.com/Textualize/rich) (installed automatically)
+- GitHub Copilot CLI (`~/.copilot/session-state/` must exist)
+
+## License
+
+MIT © Haim Cohen

copilot_sessions-1.3.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "copilot-sessions"
+version = "1.3.0"
+description = "Terminal tool to view and manage GitHub Copilot CLI sessions"
+authors = [
+  { name = "Haim Cohen" },
+]
+license = { text = "MIT" }
+dependencies = [
+    "rich>=13.0.0",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+    "Topic :: Utilities",
+]
+readme = "README.md"
+requires-python = ">=3.9"
+keywords = ["copilot", "github", "cli", "sessions"]
+
+[project.urls]
+Homepage = "https://github.com/sk3pp3r/copilot-sessions"
+Issues = "https://github.com/sk3pp3r/copilot-sessions/issues"
+
+[project.scripts]
+copilot-sessions = "copilot_dashboard.main:main"

copilot_sessions-1.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

copilot_sessions-1.3.0/src/copilot_dashboard/__init__.py

@@ -0,0 +1,3 @@
+from .main import main
+
+__all__ = ["main"]

copilot_sessions-1.3.0/src/copilot_dashboard/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    main()

copilot_sessions-1.3.0/src/copilot_dashboard/main.py

@@ -0,0 +1,920 @@
+#!/usr/bin/env python3
+"""
+Copilot CLI Sessions Manager
+A terminal-based tool to view and manage GitHub Copilot CLI sessions.
+"""
+
+import argparse
+import csv
+import json
+import os
+import shutil
+import sys
+import time
+from datetime import datetime, timezone
+from io import StringIO
+from pathlib import Path
+
+__app_name__ = "Copilot Sessions"
+__version__ = "1.3.0"
+__author__ = "Haim Cohen"
+__description__ = "Terminal tool to view and manage GitHub Copilot CLI sessions"
+
+try:
+    from rich.console import Console
+    from rich.table import Table
+    from rich.panel import Panel
+    from rich.prompt import Prompt, Confirm, IntPrompt
+    from rich.text import Text
+    from rich.columns import Columns
+    from rich import box
+except ImportError:
+    print("Error: 'rich' library is required. Install with: pip3 install rich")
+    sys.exit(1)
+
+SESSION_STATE_DIR = Path.home() / ".copilot" / "session-state"
+console = Console()
+
+
+def parse_yaml_simple(text: str) -> dict:
+    """Minimal YAML parser for workspace.yaml (flat key-value only)."""
+    result = {}
+    for line in text.strip().splitlines():
+        if ":" in line:
+            key, _, value = line.partition(":")
+            result[key.strip()] = value.strip()
+    return result
+
+
+def get_session_info(session_dir: Path) -> dict:
+    """Extract all metadata for a session."""
+    sid = session_dir.name
+    info = {
+        "id": sid,
+        "short_id": sid[:8],
+        "summary": "",
+        "cwd": "",
+        "git_root": "",
+        "repository": "",
+        "branch": "",
+        "created_at": "",
+        "updated_at": "",
+        "copilot_version": "",
+        "active": False,
+        "pid": None,
+        "has_plan": False,
+        "has_db": False,
+        "user_messages": 0,
+        "events_size": 0,
+        "first_user_msg": "",
+        "dir": session_dir,
+        # Metrics (accumulated across shutdown events)
+        "total_premium_reqs": 0,
+        "total_api_duration_ms": 0,
+        "current_model": "",
+        "current_tokens": 0,
+        "system_tokens": 0,
+        "conversation_tokens": 0,
+        "tool_def_tokens": 0,
+        "model_metrics": {},  # {model: {requests, cost, input_tokens, output_tokens, ...}}
+        "lines_added": 0,
+        "lines_removed": 0,
+        "files_modified": set(),
+        # Live session fallback (from individual events)
+        "live_output_tokens": 0,
+        "live_models": set(),
+    }
+
+    # workspace.yaml
+    ws_file = session_dir / "workspace.yaml"
+    if ws_file.exists():
+        try:
+            ws = parse_yaml_simple(ws_file.read_text())
+            info["summary"] = ws.get("summary", "")
+            info["cwd"] = ws.get("cwd", "")
+            info["git_root"] = ws.get("git_root", "")
+            info["repository"] = ws.get("repository", "")
+            info["branch"] = ws.get("branch", "")
+            info["created_at"] = ws.get("created_at", "")
+            info["updated_at"] = ws.get("updated_at", "")
+        except Exception:
+            pass
+
+    # Lock file = active session
+    for f in session_dir.glob("inuse.*.lock"):
+        info["active"] = True
+        try:
+            info["pid"] = int(f.stem.split(".")[-1])
+        except (ValueError, IndexError):
+            pass
+        break
+
+    # plan.md
+    info["has_plan"] = (session_dir / "plan.md").exists()
+    info["has_db"] = (session_dir / "session.db").exists()
+
+    # events.jsonl
+    events_file = session_dir / "events.jsonl"
+    if events_file.exists():
+        info["events_size"] = events_file.stat().st_size
+        try:
+            with open(events_file) as f:
+                for line in f:
+                    try:
+                        evt = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    if evt.get("type") == "session.start":
+                        data = evt.get("data", {})
+                        info["copilot_version"] = data.get("copilotVersion", "")
+                        if not info["created_at"]:
+                            info["created_at"] = data.get("startTime", "")
+                        ctx = data.get("context", {})
+                        if not info["cwd"]:
+                            info["cwd"] = ctx.get("cwd", "")
+                        if not info["repository"]:
+                            info["repository"] = ctx.get("repository", "")
+                        if not info["branch"]:
+                            info["branch"] = ctx.get("branch", "")
+                    elif evt.get("type") == "user.message":
+                        info["user_messages"] += 1
+                        if not info["first_user_msg"]:
+                            content = evt.get("data", {}).get("content", "")
+                            info["first_user_msg"] = content[:100].replace("\n", " ")
+                    elif evt.get("type") == "session.shutdown":
+                        sd = evt.get("data", {})
+                        info["total_premium_reqs"] += sd.get("totalPremiumRequests", 0)
+                        info["total_api_duration_ms"] += sd.get("totalApiDurationMs", 0)
+                        info["current_model"] = sd.get("currentModel", info["current_model"])
+                        info["current_tokens"] = sd.get("currentTokens", 0)
+                        info["system_tokens"] = sd.get("systemTokens", 0)
+                        info["conversation_tokens"] = sd.get("conversationTokens", 0)
+                        info["tool_def_tokens"] = sd.get("toolDefinitionsTokens", 0)
+                        # Accumulate model metrics across resume segments
+                        for model, metrics in sd.get("modelMetrics", {}).items():
+                            if model not in info["model_metrics"]:
+                                info["model_metrics"][model] = {
+                                    "requests": 0, "cost": 0,
+                                    "input_tokens": 0, "output_tokens": 0,
+                                    "cache_read_tokens": 0, "cache_write_tokens": 0,
+                                }
+                            mm = info["model_metrics"][model]
+                            reqs = metrics.get("requests", {})
+                            mm["requests"] += reqs.get("count", 0)
+                            mm["cost"] += reqs.get("cost", 0)
+                            usage = metrics.get("usage", {})
+                            mm["input_tokens"] += usage.get("inputTokens", 0)
+                            mm["output_tokens"] += usage.get("outputTokens", 0)
+                            mm["cache_read_tokens"] += usage.get("cacheReadTokens", 0)
+                            mm["cache_write_tokens"] += usage.get("cacheWriteTokens", 0)
+                        # Accumulate code changes
+                        cc = sd.get("codeChanges", {})
+                        info["lines_added"] += cc.get("linesAdded", 0)
+                        info["lines_removed"] += cc.get("linesRemoved", 0)
+                        for fp in cc.get("filesModified", []):
+                            info["files_modified"].add(fp)
+                    elif evt.get("type") == "assistant.message":
+                        ot = evt.get("data", {}).get("outputTokens", 0)
+                        if ot:
+                            info["live_output_tokens"] += ot
+                    elif evt.get("type") == "tool.execution_complete":
+                        m = evt.get("data", {}).get("model", "")
+                        if m:
+                            info["live_models"].add(m)
+        except Exception:
+            pass
+
+    # Fallback: use dir mtime for updated_at
+    if not info["updated_at"] and events_file.exists():
+        mtime = events_file.stat().st_mtime
+        info["updated_at"] = datetime.fromtimestamp(mtime, tz=timezone.utc).isoformat()
+    if not info["created_at"]:
+        ctime = session_dir.stat().st_birthtime if hasattr(session_dir.stat(), "st_birthtime") else session_dir.stat().st_ctime
+        info["created_at"] = datetime.fromtimestamp(ctime, tz=timezone.utc).isoformat()
+
+    return info
+
+
+def format_size(size_bytes: int) -> str:
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.1f} KB"
+    else:
+        return f"{size_bytes / (1024 * 1024):.1f} MB"
+
+
+def format_date(iso_str: str) -> str:
+    if not iso_str:
+        return "—"
+    try:
+        dt = datetime.fromisoformat(iso_str.replace("Z", "+00:00"))
+        now = datetime.now(timezone.utc)
+        delta = now - dt
+        if delta.days == 0:
+            hours = delta.seconds // 3600
+            if hours == 0:
+                mins = delta.seconds // 60
+                return f"{mins}m ago"
+            return f"{hours}h ago"
+        elif delta.days < 7:
+            return f"{delta.days}d ago"
+        else:
+            return dt.strftime("%Y-%m-%d")
+    except Exception:
+        return iso_str[:10]
+
+
+def load_all_sessions() -> list[dict]:
+    sessions = []
+    if not SESSION_STATE_DIR.exists():
+        return sessions
+    for entry in SESSION_STATE_DIR.iterdir():
+        if entry.is_dir() and len(entry.name) == 36 and "-" in entry.name:
+            sessions.append(get_session_info(entry))
+    # Sort by updated_at descending (most recent first)
+    sessions.sort(key=lambda s: s.get("updated_at", ""), reverse=True)
+    return sessions
+
+
+def show_session_list(sessions: list[dict], filter_text: str = ""):
+    filtered = sessions
+    if filter_text:
+        fl = filter_text.lower()
+        filtered = [
+            s for s in sessions
+            if fl in s["summary"].lower()
+            or fl in s["id"].lower()
+            or fl in s["cwd"].lower()
+            or fl in s["repository"].lower()
+            or fl in s["first_user_msg"].lower()
+        ]
+
+    table = Table(
+        title=f"🤖 {__app_name__} v{__version__}",
+        box=box.ROUNDED,
+        show_lines=True,
+        title_style="bold cyan",
+        caption=f"{len(filtered)} sessions (of {len(sessions)} total)  ·  © {__author__}",
+        caption_style="dim",
+    )
+
+    table.add_column("#", style="dim", width=4, justify="right")
+    table.add_column("Status", width=8, justify="center")
+    table.add_column("Summary", style="bold", min_width=20, max_width=35)
+    table.add_column("ID", style="dim cyan", width=10)
+    table.add_column("Working Dir", style="green", max_width=25)
+    table.add_column("Repo / Branch", style="yellow", max_width=25)
+    table.add_column("Created", style="blue", width=12)
+    table.add_column("Updated", style="blue", width=12)
+    table.add_column("Msgs", justify="right", width=5)
+    table.add_column("Size", justify="right", width=8)
+    table.add_column("Extras", width=8)
+
+    for i, s in enumerate(filtered):
+        status = Text("● LIVE", style="bold green") if s["active"] else Text("○ idle", style="dim")
+        summary = s["summary"] or s["first_user_msg"][:35] or "—"
+        cwd = s["cwd"].replace(str(Path.home()), "~") if s["cwd"] else "—"
+        repo_branch = ""
+        if s["repository"]:
+            repo_branch = s["repository"]
+        if s["branch"]:
+            repo_branch += f" ({s['branch']})" if repo_branch else s["branch"]
+        repo_branch = repo_branch or "—"
+
+        extras = []
+        if s["has_plan"]:
+            extras.append("📋")
+        if s["has_db"]:
+            extras.append("🗃️")
+
+        table.add_row(
+            str(i + 1),
+            status,
+            summary,
+            s["short_id"] + "…",
+            cwd,
+            repo_branch,
+            format_date(s["created_at"]),
+            format_date(s["updated_at"]),
+            str(s["user_messages"]),
+            format_size(s["events_size"]),
+            " ".join(extras),
+        )
+
+    console.print()
+    console.print(table)
+    return filtered
+
+
+def show_session_detail(session: dict):
+    console.print()
+    panel_content = []
+    panel_content.append(f"[bold cyan]Session ID:[/]     {session['id']}")
+    panel_content.append(f"[bold cyan]Summary:[/]        {session['summary'] or '—'}")
+    panel_content.append(f"[bold cyan]Status:[/]         {'[bold green]● ACTIVE[/]' if session['active'] else '[dim]○ Idle[/]'}")
+    panel_content.append(f"[bold cyan]Working Dir:[/]     {session['cwd'] or '—'}")
+    panel_content.append(f"[bold cyan]Git Root:[/]        {session['git_root'] or '—'}")
+    panel_content.append(f"[bold cyan]Repository:[/]      {session['repository'] or '—'}")
+    panel_content.append(f"[bold cyan]Branch:[/]          {session['branch'] or '—'}")
+    panel_content.append(f"[bold cyan]Copilot Version:[/] {session['copilot_version'] or '—'}")
+    panel_content.append(f"[bold cyan]Created:[/]         {session['created_at'] or '—'}")
+    panel_content.append(f"[bold cyan]Updated:[/]         {session['updated_at'] or '—'}")
+    panel_content.append(f"[bold cyan]User Messages:[/]   {session['user_messages']}")
+    panel_content.append(f"[bold cyan]Events Size:[/]     {format_size(session['events_size'])}")
+    panel_content.append(f"[bold cyan]Has Plan:[/]        {'✅ Yes' if session['has_plan'] else '❌ No'}")
+    panel_content.append(f"[bold cyan]Has DB:[/]          {'✅ Yes' if session['has_db'] else '❌ No'}")
+    panel_content.append(f"[bold cyan]Directory:[/]       {session['dir']}")
+    if session["first_user_msg"]:
+        panel_content.append(f"\n[bold cyan]First Message:[/]\n  [italic]{session['first_user_msg']}[/]")
+
+    cwd = session["cwd"] or "~"
+    resume_cmd = f"cd {cwd} && copilot --resume={session['id']}"
+    panel_content.append(f"\n[bold green]▶ Resume:[/]\n  [white on grey23] {resume_cmd} [/]")
+
+    console.print(Panel(
+        "\n".join(panel_content),
+        title=f"📋 Session Detail — {session['short_id']}…",
+        border_style="cyan",
+        expand=True,
+    ))
+
+    # Usage & Cost panel
+    mm = session["model_metrics"]
+    if mm:
+        usage_table = Table(
+            box=box.SIMPLE_HEAVY,
+            show_header=True,
+            title_style="bold magenta",
+            expand=True,
+        )
+        usage_table.add_column("Model", style="bold yellow")
+        usage_table.add_column("Requests", justify="right", style="cyan")
+        usage_table.add_column("Premium Reqs", justify="right", style="bold red")
+        usage_table.add_column("Input Tokens", justify="right")
+        usage_table.add_column("Output Tokens", justify="right")
+        usage_table.add_column("Cache Read", justify="right", style="dim")
+        usage_table.add_column("Cache Write", justify="right", style="dim")
+
+        total_reqs = 0
+        total_cost = 0
+        total_input = 0
+        total_output = 0
+        total_cache_r = 0
+        total_cache_w = 0
+
+        for model, m in sorted(mm.items()):
+            total_reqs += m["requests"]
+            total_cost += m["cost"]
+            total_input += m["input_tokens"]
+            total_output += m["output_tokens"]
+            total_cache_r += m["cache_read_tokens"]
+            total_cache_w += m["cache_write_tokens"]
+            usage_table.add_row(
+                model,
+                f"{m['requests']:,}",
+                f"{m['cost']:,}",
+                f"{m['input_tokens']:,}",
+                f"{m['output_tokens']:,}",
+                f"{m['cache_read_tokens']:,}",
+                f"{m['cache_write_tokens']:,}",
+            )
+
+        if len(mm) > 1:
+            usage_table.add_row(
+                "[bold]TOTAL[/]",
+                f"[bold]{total_reqs:,}[/]",
+                f"[bold]{total_cost:,}[/]",
+                f"[bold]{total_input:,}[/]",
+                f"[bold]{total_output:,}[/]",
+                f"[bold]{total_cache_r:,}[/]",
+                f"[bold]{total_cache_w:,}[/]",
+            )
+
+        # Summary line
+        api_secs = session["total_api_duration_ms"] / 1000
+        api_time = f"{api_secs:.0f}s" if api_secs < 60 else f"{api_secs / 60:.1f}m"
+
+        summary_parts = []
+        summary_parts.append(f"[bold]Premium Requests:[/] [bold red]{session['total_premium_reqs']}[/]")
+        summary_parts.append(f"[bold]API Time:[/] {api_time}")
+        summary_parts.append(f"[bold]Current Model:[/] [yellow]{session['current_model']}[/]")
+        if session["conversation_tokens"]:
+            summary_parts.append(
+                f"[bold]Context Window:[/] {session['current_tokens']:,} tokens "
+                f"(conversation: {session['conversation_tokens']:,}, "
+                f"system: {session['system_tokens']:,}, "
+                f"tools: {session['tool_def_tokens']:,})"
+            )
+
+        code_parts = []
+        if session["lines_added"] or session["lines_removed"]:
+            code_parts.append(
+                f"[bold]Code Changes:[/] "
+                f"[green]+{session['lines_added']}[/] / [red]-{session['lines_removed']}[/] lines"
+                f" in {len(session['files_modified'])} file(s)"
+            )
+
+        console.print(Panel(
+            "\n".join(summary_parts)
+            + ("\n" + "\n".join(code_parts) if code_parts else ""),
+            title="💰 Usage & Cost",
+            border_style="magenta",
+            expand=True,
+        ))
+        console.print(usage_table)
+
+    elif session["active"] and (session["live_output_tokens"] or session["live_models"]):
+        # Live session without shutdown data yet
+        live_parts = []
+        live_parts.append(f"[bold yellow]⚡ Live session — full metrics available after session ends[/]")
+        if session["live_models"]:
+            live_parts.append(f"[bold]Models in use:[/] {', '.join(sorted(session['live_models']))}")
+        if session["live_output_tokens"]:
+            live_parts.append(f"[bold]Output tokens so far:[/] {session['live_output_tokens']:,}")
+        console.print(Panel("\n".join(live_parts), title="💰 Usage (partial)", border_style="yellow", expand=True))
+
+    # Show plan preview if exists
+    plan_file = session["dir"] / "plan.md"
+    if plan_file.exists():
+        plan_text = plan_file.read_text()[:500]
+        console.print(Panel(plan_text, title="📝 Plan Preview", border_style="yellow", expand=True))
+
+
+def delete_sessions(sessions: list[dict], indices: list[int]):
+    to_delete = []
+    for idx in indices:
+        s = sessions[idx]
+        if s["active"]:
+            console.print(f"  [bold red]⚠ Skipping {s['short_id']}… — session is ACTIVE (use 'k' to kill first)[/]")
+        else:
+            to_delete.append(s)
+
+    if not to_delete:
+        console.print("[yellow]No sessions to delete.[/]")
+        return
+
+    console.print(f"\n[bold red]About to delete {len(to_delete)} session(s):[/]")
+    for s in to_delete:
+        summary = s["summary"] or s["first_user_msg"][:40] or "no summary"
+        console.print(f"  • {s['short_id']}… — {summary}")
+
+    if Confirm.ask("\n[bold]Confirm deletion?[/]", default=False):
+        for s in to_delete:
+            try:
+                shutil.rmtree(s["dir"])
+                # Also remove standalone .jsonl if exists
+                jsonl = SESSION_STATE_DIR / f"{s['id']}.jsonl"
+                if jsonl.exists():
+                    jsonl.unlink()
+                console.print(f"  [green]✓[/] Deleted {s['short_id']}…")
+            except Exception as e:
+                console.print(f"  [red]✗[/] Failed to delete {s['short_id']}…: {e}")
+    else:
+        console.print("[dim]Cancelled.[/]")
+
+
+def kill_sessions(sessions: list[dict]):
+    """Kill active (live) sessions by terminating their process and removing lock files."""
+    import signal
+
+    active = [s for s in sessions if s["active"]]
+    if not active:
+        console.print("[yellow]No active sessions to kill.[/]")
+        return
+
+    table = Table(box=box.SIMPLE, show_header=True, title="⚡ Active Sessions", title_style="bold red")
+    table.add_column("#", width=4, justify="right", style="dim")
+    table.add_column("Summary", style="bold")
+    table.add_column("ID", style="dim cyan", width=10)
+    table.add_column("PID", style="red", justify="right")
+    table.add_column("Working Dir", style="green")
+
+    for i, s in enumerate(active):
+        summary = s["summary"] or s["first_user_msg"][:35] or "—"
+        cwd = s["cwd"].replace(str(Path.home()), "~") if s["cwd"] else "—"
+        table.add_row(str(i + 1), summary, s["short_id"] + "…", str(s["pid"] or "?"), cwd)
+
+    console.print(table)
+
+    raw = Prompt.ask(
+        f"[bold red]Session #(s) to kill[/] (comma-separated, or 'all')",
+    )
+
+    if raw.strip().lower() == "all":
+        targets = list(range(len(active)))
+    else:
+        try:
+            targets = [int(x.strip()) - 1 for x in raw.split(",")]
+            if not all(0 <= i < len(active) for i in targets):
+                console.print("[red]Invalid number(s).[/]")
+                return
+        except ValueError:
+            console.print("[red]Invalid input.[/]")
+            return
+
+    to_kill = [active[i] for i in targets]
+    console.print(f"\n[bold red]About to kill {len(to_kill)} session(s):[/]")
+    for s in to_kill:
+        summary = s["summary"] or s["first_user_msg"][:40] or "no summary"
+        console.print(f"  💀 {s['short_id']}… — {summary} (PID {s['pid'] or '?'})")
+
+    if not Confirm.ask("\n[bold]Confirm kill?[/]", default=False):
+        console.print("[dim]Cancelled.[/]")
+        return
+
+    for s in to_kill:
+        pid = s["pid"]
+        sid_short = s["short_id"]
+
+        # Kill the process
+        if pid:
+            try:
+                os.kill(pid, signal.SIGTERM)
+                console.print(f"  [green]✓[/] Sent SIGTERM to PID {pid} ({sid_short}…)")
+            except ProcessLookupError:
+                console.print(f"  [yellow]⚠[/] PID {pid} not found — process already dead ({sid_short}…)")
+            except PermissionError:
+                console.print(f"  [red]✗[/] Permission denied killing PID {pid} ({sid_short}…)")
+                continue
+        else:
+            console.print(f"  [yellow]⚠[/] No PID found for {sid_short}… — removing lock file only")
+
+        # Remove lock files
+        for lock in s["dir"].glob("inuse.*.lock"):
+            try:
+                lock.unlink()
+                console.print(f"  [green]✓[/] Removed lock {lock.name}")
+            except Exception as e:
+                console.print(f"  [red]✗[/] Failed to remove lock: {e}")
+
+
+def show_stats(sessions: list[dict]):
+    total = len(sessions)
+    active = sum(1 for s in sessions if s["active"])
+    with_plan = sum(1 for s in sessions if s["has_plan"])
+    with_db = sum(1 for s in sessions if s["has_db"])
+    total_size = sum(s["events_size"] for s in sessions)
+    total_msgs = sum(s["user_messages"] for s in sessions)
+    total_premium = sum(s["total_premium_reqs"] for s in sessions)
+    total_disk = sum(
+        sum(f.stat().st_size for f in s["dir"].rglob("*") if f.is_file())
+        for s in sessions
+    )
+
+    repos = set(s["repository"] for s in sessions if s["repository"])
+    versions = set(s["copilot_version"] for s in sessions if s["copilot_version"])
+
+    stats = Table(title="📊 Session Statistics", box=box.SIMPLE_HEAVY, show_header=False, title_style="bold magenta")
+    stats.add_column("Metric", style="bold")
+    stats.add_column("Value", style="cyan")
+
+    stats.add_row("Total Sessions", str(total))
+    stats.add_row("Active (live)", str(active))
+    stats.add_row("Inactive", str(total - active))
+    stats.add_row("With Plan", str(with_plan))
+    stats.add_row("With Database", str(with_db))
+    stats.add_row("Total User Messages", str(total_msgs))
+    stats.add_row("Total Premium Requests", str(total_premium))
+    stats.add_row("Events Data", format_size(total_size))
+    stats.add_row("Total Disk Usage", format_size(total_disk))
+    stats.add_row("Repositories", ", ".join(sorted(repos)) or "—")
+    stats.add_row("Copilot Versions", ", ".join(sorted(versions)) or "—")
+
+    console.print()
+    console.print(stats)
+
+
+def cleanup_old_sessions(sessions: list[dict]):
+    console.print("\n[bold]Cleanup — delete inactive sessions older than N days[/]")
+    days = IntPrompt.ask("Delete sessions older than how many days?", default=30)
+
+    cutoff = datetime.now(timezone.utc).timestamp() - (days * 86400)
+    candidates = []
+    for s in sessions:
+        if s["active"]:
+            continue
+        try:
+            dt = datetime.fromisoformat(s["updated_at"].replace("Z", "+00:00"))
+            if dt.timestamp() < cutoff:
+                candidates.append(s)
+        except Exception:
+            pass
+
+    if not candidates:
+        console.print(f"[green]No inactive sessions older than {days} days found.[/]")
+        return
+
+    console.print(f"\n[yellow]Found {len(candidates)} session(s) older than {days} days:[/]")
+    for s in candidates:
+        summary = s["summary"] or s["first_user_msg"][:40] or "no summary"
+        console.print(f"  • {s['short_id']}… — {summary} (updated {format_date(s['updated_at'])})")
+
+    if Confirm.ask(f"\n[bold red]Delete all {len(candidates)} sessions?[/]", default=False):
+        for s in candidates:
+            try:
+                shutil.rmtree(s["dir"])
+                jsonl = SESSION_STATE_DIR / f"{s['id']}.jsonl"
+                if jsonl.exists():
+                    jsonl.unlink()
+                console.print(f"  [green]✓[/] Deleted {s['short_id']}…")
+            except Exception as e:
+                console.print(f"  [red]✗[/] Failed: {e}")
+    else:
+        console.print("[dim]Cancelled.[/]")
+
+
+def export_sessions(sessions: list[dict]):
+    """Export sessions to CSV, JSON, or HTML."""
+    fmt = Prompt.ask(
+        "[bold]Export format[/]",
+        choices=["csv", "json", "html"],
+        default="csv",
+    )
+
+    default_name = f"copilot-sessions.{fmt}"
+    filepath = Prompt.ask("[bold]File path[/]", default=default_name)
+
+    # Build export data
+    rows = []
+    for s in sessions:
+        total_input = sum(m["input_tokens"] for m in s["model_metrics"].values())
+        total_output = sum(m["output_tokens"] for m in s["model_metrics"].values())
+        total_reqs = sum(m["requests"] for m in s["model_metrics"].values())
+        models_used = ", ".join(sorted(s["model_metrics"].keys())) or ", ".join(sorted(s["live_models"])) or "—"
+
+        rows.append({
+            "id": s["id"],
+            "summary": s["summary"] or s["first_user_msg"][:60] or "—",
+            "status": "ACTIVE" if s["active"] else "idle",
+            "cwd": s["cwd"],
+            "repository": s["repository"],
+            "branch": s["branch"],
+            "copilot_version": s["copilot_version"],
+            "created_at": s["created_at"],
+            "updated_at": s["updated_at"],
+            "user_messages": s["user_messages"],
+            "events_size_bytes": s["events_size"],
+            "premium_requests": s["total_premium_reqs"],
+            "total_requests": total_reqs,
+            "input_tokens": total_input,
+            "output_tokens": total_output,
+            "models": models_used,
+            "api_duration_sec": round(s["total_api_duration_ms"] / 1000, 1),
+            "lines_added": s["lines_added"],
+            "lines_removed": s["lines_removed"],
+            "files_modified": len(s["files_modified"]),
+            "has_plan": s["has_plan"],
+            "has_db": s["has_db"],
+            "resume_cmd": f"cd {s['cwd'] or '~'} && copilot --resume={s['id']}",
+        })
+
+    try:
+        if fmt == "csv":
+            with open(filepath, "w", newline="") as f:
+                writer = csv.DictWriter(f, fieldnames=rows[0].keys())
+                writer.writeheader()
+                writer.writerows(rows)
+
+        elif fmt == "json":
+            with open(filepath, "w") as f:
+                json.dump(rows, f, indent=2, default=str)
+
+        elif fmt == "html":
+            with open(filepath, "w") as f:
+                f.write(_generate_html(rows))
+
+        console.print(f"  [green]✓[/] Exported {len(rows)} sessions to [bold]{filepath}[/]")
+    except Exception as e:
+        console.print(f"  [red]✗[/] Export failed: {e}")
+
+
+def _generate_html(rows: list[dict]) -> str:
+    """Generate a styled HTML report."""
+    now = datetime.now().strftime("%Y-%m-%d %H:%M")
+    html = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>🤖 {__app_name__}</title>
+<style>
+  :root {{ --bg: #0d1117; --card: #161b22; --border: #30363d; --text: #c9d1d9;
+           --cyan: #58a6ff; --green: #3fb950; --red: #f85149; --yellow: #d29922;
+           --magenta: #bc8cff; --dim: #8b949e; }}
+  * {{ margin: 0; padding: 0; box-sizing: border-box; }}
+  body {{ background: var(--bg); color: var(--text); font-family: 'SF Mono', 'Cascadia Code', monospace;
+          padding: 24px; line-height: 1.6; }}
+  h1 {{ color: var(--cyan); margin-bottom: 4px; font-size: 1.4em; }}
+  .subtitle {{ color: var(--dim); margin-bottom: 20px; font-size: 0.85em; }}
+  .stats {{ display: flex; gap: 16px; margin-bottom: 20px; flex-wrap: wrap; }}
+  .stat {{ background: var(--card); border: 1px solid var(--border); border-radius: 8px;
+           padding: 12px 20px; min-width: 140px; }}
+  .stat .label {{ color: var(--dim); font-size: 0.75em; text-transform: uppercase; }}
+  .stat .value {{ color: var(--cyan); font-size: 1.3em; font-weight: bold; }}
+  .stat .value.green {{ color: var(--green); }}
+  .stat .value.red {{ color: var(--red); }}
+  .stat .value.magenta {{ color: var(--magenta); }}
+  table {{ width: 100%; border-collapse: collapse; background: var(--card);
+           border: 1px solid var(--border); border-radius: 8px; overflow: hidden; margin-top: 12px; }}
+  th {{ background: #21262d; color: var(--cyan); padding: 10px 12px; text-align: left;
+        font-size: 0.8em; text-transform: uppercase; letter-spacing: 0.5px; border-bottom: 2px solid var(--border); }}
+  td {{ padding: 8px 12px; border-bottom: 1px solid var(--border); font-size: 0.85em;
+        vertical-align: top; }}
+  tr:hover {{ background: #1c2128; }}
+  .active {{ color: var(--green); font-weight: bold; }}
+  .idle {{ color: var(--dim); }}
+  .num {{ text-align: right; font-variant-numeric: tabular-nums; }}
+  .resume {{ font-size: 0.75em; color: var(--dim); word-break: break-all; }}
+  footer {{ margin-top: 24px; color: var(--dim); font-size: 0.8em; text-align: center; }}
+</style>
+</head>
+<body>
+<h1>🤖 {__app_name__}</h1>
+<div class="subtitle">Generated {now} · v{__version__} · © {__author__} 2026</div>
+"""
+    total = len(rows)
+    active = sum(1 for r in rows if r["status"] == "ACTIVE")
+    total_premium = sum(r["premium_requests"] for r in rows)
+    total_msgs = sum(r["user_messages"] for r in rows)
+
+    html += f"""<div class="stats">
+  <div class="stat"><div class="label">Sessions</div><div class="value">{total}</div></div>
+  <div class="stat"><div class="label">Active</div><div class="value green">{active}</div></div>
+  <div class="stat"><div class="label">Premium Reqs</div><div class="value magenta">{total_premium:,}</div></div>
+  <div class="stat"><div class="label">Messages</div><div class="value">{total_msgs:,}</div></div>
+</div>
+"""
+    html += """<table>
+<tr>
+  <th>Status</th><th>Summary</th><th>ID</th><th>Working Dir</th>
+  <th>Repo / Branch</th><th>Created</th><th>Updated</th>
+  <th>Msgs</th><th>Premium</th><th>Input Tok</th><th>Output Tok</th>
+  <th>Models</th><th>Resume</th>
+</tr>
+"""
+    for r in rows:
+        status_cls = "active" if r["status"] == "ACTIVE" else "idle"
+        status_icon = "● LIVE" if r["status"] == "ACTIVE" else "○ idle"
+        repo_branch = r["repository"]
+        if r["branch"]:
+            repo_branch += f" ({r['branch']})" if repo_branch else r["branch"]
+
+        html += f"""<tr>
+  <td class="{status_cls}">{status_icon}</td>
+  <td>{r['summary']}</td>
+  <td style="color:var(--cyan);font-size:0.8em">{r['id'][:12]}…</td>
+  <td style="font-size:0.8em">{r['cwd']}</td>
+  <td style="color:var(--yellow)">{repo_branch or '—'}</td>
+  <td>{r['created_at'][:10]}</td>
+  <td>{r['updated_at'][:10]}</td>
+  <td class="num">{r['user_messages']}</td>
+  <td class="num" style="color:var(--magenta)">{r['premium_requests']}</td>
+  <td class="num">{r['input_tokens']:,}</td>
+  <td class="num">{r['output_tokens']:,}</td>
+  <td style="font-size:0.8em">{r['models']}</td>
+  <td class="resume">{r['resume_cmd']}</td>
+</tr>
+"""
+
+    html += f"""</table>
+<footer>{__app_name__} v{__version__} · © {__author__} 2026</footer>
+</body>
+</html>"""
+    return html
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="copilot-sessions",
+        description=__description__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "Interactive commands:\n"
+            "  l  List all sessions          f  Filter/search sessions\n"
+            "  a  Active sessions             v  View session detail + Usage\n"
+            "  s  Show statistics             d  Delete session(s)\n"
+            "  k  Kill live session(s)        c  Cleanup old sessions\n"
+            "  e  Export (CSV/JSON/HTML)      r  Refresh\n"
+            "  q  Quit\n"
+            "\n"
+            "Resume a session:\n"
+            "  cd <working-dir> && copilot --resume=<session-id>\n"
+            "\n"
+            "Examples:\n"
+            "  copilot-sessions               # launch interactive manager\n"
+            "  copilot-sessions --active       # show active sessions only\n"
+            "  copilot-sessions --version      # show version\n"
+        ),
+    )
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version=f"%(prog)s {__version__} by {__author__}",
+    )
+    parser.add_argument(
+        "-a", "--active",
+        action="store_true",
+        help="Show only active (live) sessions and exit",
+    )
+    args = parser.parse_args()
+
+    if args.active:
+        sessions = load_all_sessions()
+        active = [s for s in sessions if s["active"]]
+        if not active:
+            console.print("[yellow]No active sessions found.[/]")
+            sys.exit(0)
+        show_session_list(active)
+        for s in active:
+            show_session_detail(s)
+        sys.exit(0)
+
+    first_run = True
+    while True:
+        if first_run:
+            console.clear()
+            console.print(
+                f"[bold cyan]🤖 {__app_name__}[/]  [dim]v{__version__}[/]  ·  "
+                f"[dim]{__description__}[/]  ·  [dim]© {__author__} 2026[/]"
+            )
+            first_run = False
+
+        sessions = load_all_sessions()
+        active_count = sum(1 for s in sessions if s["active"])
+
+        console.print(f"\n[dim]{len(sessions)} sessions, [green]{active_count} active[/][/]")
+        console.print()
+        console.print("  [cyan]l[/]  List all sessions          [cyan]f[/]  Filter/search sessions")
+        console.print("  [cyan]a[/]  Active sessions             [cyan]v[/]  View session detail + 💰 Usage")
+        console.print("  [cyan]s[/]  Show statistics             [cyan]d[/]  Delete session(s)")
+        console.print("  [cyan]k[/]  Kill live session(s)        [cyan]c[/]  Cleanup old sessions")
+        console.print("  [cyan]e[/]  Export (CSV/JSON/HTML)      [cyan]r[/]  Refresh")
+        console.print("  [cyan]q[/]  Quit")
+
+        cmd = Prompt.ask(f"\n[bold cyan]{__app_name__}[/]", choices=["l", "f", "a", "v", "d", "k", "s", "c", "e", "r", "q"], default="l")
+
+        if cmd == "q":
+            console.print("[dim]Goodbye! 👋[/]")
+            break
+
+        elif cmd == "l":
+            show_session_list(sessions)
+
+        elif cmd == "a":
+            active = [s for s in sessions if s["active"]]
+            if not active:
+                console.print("[yellow]No active sessions found.[/]")
+                continue
+            show_session_list(active)
+
+        elif cmd == "f":
+            term = Prompt.ask("[bold]Search term[/] (summary, id, path, repo, message)")
+            show_session_list(sessions, filter_text=term)
+
+        elif cmd == "v":
+            filtered = show_session_list(sessions)
+            if not filtered:
+                continue
+            try:
+                num = IntPrompt.ask(f"[bold]Session # to view[/] (1-{len(filtered)})")
+                if 1 <= num <= len(filtered):
+                    show_session_detail(filtered[num - 1])
+                else:
+                    console.print("[red]Invalid number.[/]")
+            except Exception:
+                pass
+
+        elif cmd == "d":
+            filtered = show_session_list(sessions)
+            if not filtered:
+                continue
+            raw = Prompt.ask(f"[bold]Session #(s) to delete[/] (comma-separated, e.g. 3,5,7)")
+            try:
+                indices = [int(x.strip()) - 1 for x in raw.split(",")]
+                valid = all(0 <= i < len(filtered) for i in indices)
+                if valid:
+                    delete_sessions(filtered, indices)
+                else:
+                    console.print("[red]Invalid number(s).[/]")
+            except ValueError:
+                console.print("[red]Invalid input.[/]")
+
+        elif cmd == "k":
+            kill_sessions(sessions)
+
+        elif cmd == "s":
+            show_stats(sessions)
+
+        elif cmd == "c":
+            cleanup_old_sessions(sessions)
+
+        elif cmd == "e":
+            export_sessions(sessions)
+
+        elif cmd == "r":
+            console.print("[dim]Refreshed.[/]")
+
+
+if __name__ == "__main__":
+    main()

copilot_sessions-1.3.0/src/copilot_sessions.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: copilot-sessions
+Version: 1.3.0
+Summary: Terminal tool to view and manage GitHub Copilot CLI sessions
+Author: Haim Cohen
+License: MIT
+Project-URL: Homepage, https://github.com/sk3pp3r/copilot-sessions
+Project-URL: Issues, https://github.com/sk3pp3r/copilot-sessions/issues
+Keywords: copilot,github,cli,sessions
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Dynamic: license-file
+
+# 🤖 Copilot Sessions
+
+A terminal tool to view and manage your GitHub Copilot CLI sessions — track usage, costs, premium requests, kill stale sessions, and clean up old ones.
+
+![Python](https://img.shields.io/badge/python-3.9+-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+## Features
+
+- **List & filter** all Copilot CLI sessions
+- **View details** with full 💰 usage breakdown (tokens, models, premium requests, cost)
+- **Active sessions** — see what's running live
+- **Kill** stale/orphan live sessions
+- **Delete & cleanup** old sessions by age
+- **Statistics** — total usage across all sessions
+- **Resume command** — copy-paste to jump back into any session
+
+## Installation
+
+### pipx (Recommended)
+```bash
+pipx install copilot-sessions
+```
+
+### pip
+```bash
+pip install copilot-sessions
+```
+
+### From source
+```bash
+git clone https://github.com/sk3pp3r/copilot-sessions.git
+cd copilot-sessions
+pipx install .
+```
+
+## Usage
+
+```bash
+copilot-sessions              # launch interactive manager
+copilot-sessions --active     # show active sessions only
+copilot-sessions --version    # show version
+copilot-sessions --help       # full help
+```
+
+### Interactive Commands
+
+| Key | Action |
+|-----|--------|
+| `l` | List all sessions |
+| `f` | Filter/search sessions |
+| `a` | Active sessions |
+| `v` | View session detail + 💰 Usage |
+| `s` | Show statistics |
+| `d` | Delete session(s) |
+| `k` | Kill live session(s) |
+| `c` | Cleanup old sessions |
+| `r` | Refresh |
+| `q` | Quit |
+
+## Requirements
+
+- Python 3.9+
+- [rich](https://github.com/Textualize/rich) (installed automatically)
+- GitHub Copilot CLI (`~/.copilot/session-state/` must exist)
+
+## License
+
+MIT © Haim Cohen

copilot_sessions-1.3.0/src/copilot_sessions.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/copilot_dashboard/__init__.py
+src/copilot_dashboard/__main__.py
+src/copilot_dashboard/main.py
+src/copilot_sessions.egg-info/PKG-INFO
+src/copilot_sessions.egg-info/SOURCES.txt
+src/copilot_sessions.egg-info/dependency_links.txt
+src/copilot_sessions.egg-info/entry_points.txt
+src/copilot_sessions.egg-info/requires.txt
+src/copilot_sessions.egg-info/top_level.txt

copilot_sessions-1.3.0/src/copilot_sessions.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

copilot_sessions-1.3.0/src/copilot_sessions.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+copilot-sessions = copilot_dashboard.main:main

copilot_sessions-1.3.0/src/copilot_sessions.egg-info/requires.txt

@@ -0,0 +1 @@
+rich>=13.0.0

copilot_sessions-1.3.0/src/copilot_sessions.egg-info/top_level.txt

@@ -0,0 +1 @@
+copilot_dashboard