sessionbin 0.0.1__tar.gz → 0.2.0__tar.gz

sessionbin-0.2.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: sessionbin
+Version: 0.2.0
+Summary: CLI for uploading and managing sessionbin transcripts
+Author: Martin Prpič
+Author-email: Martin Prpič <martin.prpic@gmail.com>
+License-Expression: MIT
+Requires-Dist: click>=8.1
+Requires-Dist: httpx>=0.27
+Requires-Dist: platformdirs>=4.3
+Requires-Dist: questionary>=2.1
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/sessionbin/sessionbin
+Project-URL: Repository, https://github.com/sessionbin/sessionbin
+Description-Content-Type: text/markdown
+
+# sessionbin CLI
+
+CLI for uploading and managing [sessionbin](https://sessionbin.dev) transcripts.
+
+## Supported harnesses
+
+**Claude Code** sessions are read as files from `~/.claude/projects/`.
+
+**OpenCode** sessions live in a local SQLite database rather than as files, so uploading
+one shells out to `opencode export`. The `opencode` binary must be on your `PATH` (or at
+`~/.opencode/bin/opencode`).
+
+## Installation
+
+```bash
+uv tool install sessionbin
+# or
+pip install --user sessionbin
+```
+
+## Usage
+
+### Upload a session
+
+Upload a specific file:
+
+```bash
+sessionbin upload ~/.claude/projects/-home-user-repos-myproject/abc123.jsonl
+```
+
+Or pick from recent sessions interactively (Claude Code and OpenCode):
+
+```bash
+sessionbin upload
+```
+
+Upload the most recent session directly:
+
+```bash
+sessionbin upload --latest
+```
+
+Use `-y` to skip the confirmation prompt:
+
+```bash
+sessionbin upload --latest -y
+```
+
+### List uploads
+
+```bash
+sessionbin list
+```
+
+Shows locally-tracked uploads (URL, filename, upload time).
+
+### Delete an upload
+
+```bash
+sessionbin delete <slug>
+```
+
+Deletes the paste on the server and removes the local record.
+
+## Configuration
+
+On first run, you'll be prompted for a server URL (defaults to `https://sessionbin.dev`). The choice is saved to `~/.config/sessionbin/config.toml`.
+
+You can override the server URL per-command:
+
+```bash
+sessionbin upload --server http://localhost:8000
+```
+
+Or via environment variable:
+
+```bash
+export SESSIONBIN_URL=http://localhost:8000
+```
+
+Priority: `--server` flag > `SESSIONBIN_URL` env var > `config.toml` > interactive prompt.
+
+## Session data
+
+Upload metadata (slugs, delete tokens) is stored in `~/.config/sessionbin/sessions.json` with `0600` permissions. This file is local-only — the `list` command reads from it without contacting the server.

sessionbin-0.2.0/README.md

@@ -0,0 +1,85 @@
+# sessionbin CLI
+
+CLI for uploading and managing [sessionbin](https://sessionbin.dev) transcripts.
+
+## Supported harnesses
+
+**Claude Code** sessions are read as files from `~/.claude/projects/`.
+
+**OpenCode** sessions live in a local SQLite database rather than as files, so uploading
+one shells out to `opencode export`. The `opencode` binary must be on your `PATH` (or at
+`~/.opencode/bin/opencode`).
+
+## Installation
+
+```bash
+uv tool install sessionbin
+# or
+pip install --user sessionbin
+```
+
+## Usage
+
+### Upload a session
+
+Upload a specific file:
+
+```bash
+sessionbin upload ~/.claude/projects/-home-user-repos-myproject/abc123.jsonl
+```
+
+Or pick from recent sessions interactively (Claude Code and OpenCode):
+
+```bash
+sessionbin upload
+```
+
+Upload the most recent session directly:
+
+```bash
+sessionbin upload --latest
+```
+
+Use `-y` to skip the confirmation prompt:
+
+```bash
+sessionbin upload --latest -y
+```
+
+### List uploads
+
+```bash
+sessionbin list
+```
+
+Shows locally-tracked uploads (URL, filename, upload time).
+
+### Delete an upload
+
+```bash
+sessionbin delete <slug>
+```
+
+Deletes the paste on the server and removes the local record.
+
+## Configuration
+
+On first run, you'll be prompted for a server URL (defaults to `https://sessionbin.dev`). The choice is saved to `~/.config/sessionbin/config.toml`.
+
+You can override the server URL per-command:
+
+```bash
+sessionbin upload --server http://localhost:8000
+```
+
+Or via environment variable:
+
+```bash
+export SESSIONBIN_URL=http://localhost:8000
+```
+
+Priority: `--server` flag > `SESSIONBIN_URL` env var > `config.toml` > interactive prompt.
+
+## Session data
+
+Upload metadata (slugs, delete tokens) is stored in `~/.config/sessionbin/sessions.json` with `0600` permissions. This file is local-only — the `list` command reads from it without contacting the server.

sessionbin-0.2.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["uv_build>=0.12.0,<0.13.0"]
+build-backend = "uv_build"
+
+[project]
+name = "sessionbin"
+version = "0.2.0"
+description = "CLI for uploading and managing sessionbin transcripts"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = [
+    "click>=8.1",
+    "httpx>=0.27",
+    "platformdirs>=4.3",
+    "questionary>=2.1",
+]
+
+[[project.authors]]
+name = "Martin Prpič"
+email = "martin.prpic@gmail.com"
+
+[project.urls]
+Homepage = "https://github.com/sessionbin/sessionbin"
+Repository = "https://github.com/sessionbin/sessionbin"
+
+[project.scripts]
+sessionbin = "sessionbin_cli.cli:cli"
+
+[tool.uv.build-backend]
+module-name = "sessionbin_cli"
+
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+select = [
+    "F",
+    "E",
+    "W",
+    "I",
+    "N",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.mypy]
+python_version = "3.13"
+warn_unused_configs = true
+warn_unreachable = true
+warn_no_return = true
+warn_unused_ignores = true
+
+[dependency-groups]
+dev = ["pytest>=8.4.2"]

sessionbin-0.2.0/pyproject.toml.orig

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["uv_build>=0.12.0,<0.13.0"]
+build-backend = "uv_build"
+
+[project]
+name = "sessionbin"
+version = "0.2.0"
+description = "CLI for uploading and managing sessionbin transcripts"
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Martin Prpič", email = "martin.prpic@gmail.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "click>=8.1",
+    "httpx>=0.27",
+    "platformdirs>=4.3",
+    "questionary>=2.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/sessionbin/sessionbin"
+Repository = "https://github.com/sessionbin/sessionbin"
+
+[project.scripts]
+sessionbin = "sessionbin_cli.cli:cli"
+
+# The distribution is published as `sessionbin`, but the import package is
+# `sessionbin_cli` so it cannot collide with the backend's `sessionbin` package.
+[tool.uv.build-backend]
+module-name = "sessionbin_cli"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.2",
+]
+
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+# https://docs.astral.sh/ruff/rules/
+select = ["F", "E", "W", "I", "N"]
+
+# Present so pytest stops here and does not inherit the backend's Django settings
+# from the repo-root pyproject.toml.
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.mypy]
+python_version = "3.13"
+warn_unused_configs = true
+warn_unreachable = true
+warn_no_return = true
+warn_unused_ignores = true

sessionbin-0.2.0/src/sessionbin_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

sessionbin-0.2.0/src/sessionbin_cli/api.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import httpx
+
+
+class APIError(Exception):
+    def __init__(self, status_code: int, message: str) -> None:
+        self.status_code = status_code
+        self.message = message
+        super().__init__(f"HTTP {status_code}: {message}")
+
+
+class SessionbinClient:
+    def __init__(self, base_url: str, timeout: float = 60.0) -> None:
+        self.client = httpx.Client(base_url=base_url, timeout=timeout)
+
+    def upload(self, data: bytes, filename: str, harness: str | None = None) -> dict:
+        params = {"harness": harness} if harness else {}
+        resp = self.client.post("/api/upload", files={"file": (filename, data)}, params=params)
+        if resp.status_code != 200:
+            raise self._error(resp)
+        return resp.json()
+
+    def delete(self, slug: str, token: str) -> None:
+        resp = self.client.delete(f"/api/p/{slug}", headers={"X-Delete-Token": token})
+        if resp.status_code != 204:
+            raise self._error(resp)
+
+    def _error(self, resp: httpx.Response) -> APIError:
+        try:
+            body = resp.json()
+            message = body.get("error") or body.get("detail") or resp.text
+        except Exception:
+            message = resp.text or resp.reason_phrase
+        return APIError(resp.status_code, message)

sessionbin-0.2.0/src/sessionbin_cli/cli.py

@@ -0,0 +1,271 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+import click
+import questionary
+
+from sessionbin_cli import __version__
+from sessionbin_cli.api import APIError, SessionbinClient
+from sessionbin_cli.config import resolve_server_url
+from sessionbin_cli.detect import SessionInfo, find_all_sessions, most_recent
+from sessionbin_cli.sessions import all as sessions_all
+from sessionbin_cli.sessions import get as session_get
+from sessionbin_cli.sessions import remove as session_remove
+from sessionbin_cli.sessions import save as session_save
+
+# Mirrors the default server cap; another server answers 413 with its own.
+MAX_UPLOAD_BYTES = 20 * 1024 * 1024
+
+CONTEXT_SETTINGS = {
+    "help_option_names": ["-h", "--help"],
+}
+
+
+def _human_size(nbytes: int) -> str:
+    for unit in ("B", "KB", "MB", "GB"):
+        if nbytes < 1024:
+            return f"{nbytes:.1f} {unit}" if unit != "B" else f"{nbytes} {unit}"
+        nbytes /= 1024  # type: ignore[assignment]
+    return f"{nbytes:.1f} TB"
+
+
+def _time_ago(mtime: float) -> str:
+    delta = time.time() - mtime
+    if delta < 60:
+        return "just now"
+    if delta < 3600:
+        mins = int(delta / 60)
+        return f"{mins}m ago"
+    if delta < 86400:
+        hours = int(delta / 3600)
+        return f"{hours}h ago"
+    days = int(delta / 86400)
+    return f"{days}d ago"
+
+
+def _short_summary(info: SessionInfo, max_len: int) -> str:
+    text = info.title or info.summary or info.path.name
+    text = " ".join(text.splitlines())
+    if len(text) > max_len:
+        text = text[:max_len] + "..."
+    return text
+
+
+def _session_size(s: SessionInfo) -> str:
+    if s.harness == "opencode":
+        return "-"
+    try:
+        return _human_size(s.path.stat().st_size)
+    except OSError:
+        return "-"
+
+
+DEFAULT_PICKER_LIMIT = 20
+
+
+def _pick_session(show_all: bool = False) -> SessionInfo | None:
+    all_sessions = find_all_sessions()
+    sessions = all_sessions if show_all else all_sessions[:DEFAULT_PICKER_LIMIT]
+    if not sessions:
+        return None
+
+    sizes = {id(s): _session_size(s) for s in sessions}
+    time_w = max(len(_time_ago(s.mtime)) for s in sessions)
+    size_w = max(len(v) for v in sizes.values())
+    src_w = max(len(s.harness) for s in sessions)
+    proj_w = max(len(s.project) for s in sessions)
+    summary_max = 60
+
+    def row(s: SessionInfo) -> str:
+        ago = _time_ago(s.mtime)
+        summary = _short_summary(s, summary_max)
+        return (
+            f"{ago:<{time_w}}  {sizes[id(s)]:>{size_w}}  {s.harness:<{src_w}}  "
+            f"{s.project:<{proj_w}}  {summary}"
+        )
+
+    header = (
+        f"{'TIME':<{time_w}}  {'SIZE':>{size_w}}  {'SOURCE':<{src_w}}  "
+        f"{'PROJECT':<{proj_w}}  SESSION NAME / SUMMARY"
+    )
+    choices: list[questionary.Choice | questionary.Separator] = [
+        questionary.Separator(header),
+        *[questionary.Choice(title=row(s), value=s) for s in sessions],
+    ]
+    result = questionary.select(
+        "Select a session to upload:",
+        choices=choices,
+        style=questionary.Style([("separator", "fg:#00d26a bold")]),
+    ).unsafe_ask()
+    return result
+
+
+@click.group(context_settings=CONTEXT_SETTINGS)
+@click.version_option(__version__, "-V", "--version")
+def cli():
+    """CLI for uploading and managing sessionbin transcripts."""
+
+
+@cli.command()
+@click.argument("path", required=False, type=click.Path(exists=True))
+@click.option("--server", default=None, help="Override the server URL.")
+@click.option("-l", "--latest", is_flag=True, help="Upload the most recent session.")
+@click.option("-y", "--yes", is_flag=True, help="Skip the confirmation prompt.")
+@click.option(
+    "-a", "--all", "show_all", is_flag=True, help="Show all sessions (default: latest 20)."
+)
+def upload(path: str | None, server: str | None, latest: bool, yes: bool, show_all: bool):
+    """Upload a session file."""
+    session: SessionInfo | None = None
+
+    if path is not None:
+        upload_data = Path(path).read_bytes()
+        upload_filename = Path(path).name
+    elif latest:
+        session = most_recent()
+        if session is None:
+            click.secho("No sessions found.", fg="red", err=True)
+            sys.exit(1)
+        size = _session_size(session)
+        ago = _time_ago(session.mtime)
+        click.echo(f"Found: {session.path} ({size}, modified {ago})")
+        if not yes:
+            if not click.confirm("Upload?", default=False):
+                raise SystemExit(0)
+        if session.harness == "opencode":
+            upload_data, upload_filename = _export_opencode_session(session)
+        else:
+            upload_data, upload_filename = session.path.read_bytes(), session.path.name
+    else:
+        session = _pick_session(show_all=show_all)
+        if session is None:
+            click.secho("No sessions found.", fg="red", err=True)
+            sys.exit(1)
+        if session.harness == "opencode":
+            upload_data, upload_filename = _export_opencode_session(session)
+        else:
+            upload_data, upload_filename = session.path.read_bytes(), session.path.name
+
+    if len(upload_data) > MAX_UPLOAD_BYTES:
+        click.secho(
+            f"Upload is {_human_size(len(upload_data))}, which exceeds the "
+            f"{_human_size(MAX_UPLOAD_BYTES)} upload limit.",
+            fg="red",
+            err=True,
+        )
+        sys.exit(1)
+
+    server_url = resolve_server_url(server)
+    client = SessionbinClient(server_url)
+    harness = session.harness if session else None
+    try:
+        result = client.upload(upload_data, upload_filename, harness=harness)
+    except APIError as e:
+        click.secho(f"Upload failed: {e.message}", fg="red", err=True)
+        sys.exit(1)
+
+    slug = result["slug"]
+    view_url = result["url"]
+    delete_token = result["delete_token"]
+    manage_url = f"{view_url}manage/?token={delete_token}"
+
+    session_save(
+        slug,
+        {
+            "delete_token": delete_token,
+            "url": view_url,
+            "uploaded_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "server": server_url,
+            "filename": upload_filename,
+        },
+    )
+
+    click.echo("Uploaded.")
+    click.secho(f"View:   {view_url}", fg="green")
+    click.secho(f"Manage: {manage_url}", fg="green")
+
+
+def _export_opencode_session(session: SessionInfo) -> tuple[bytes, str]:
+    binary = shutil.which("opencode")
+    if binary is None:
+        fallback = Path.home() / ".opencode" / "bin" / "opencode"
+        if fallback.is_file():
+            binary = str(fallback)
+    if binary is None:
+        click.secho(
+            "opencode binary not found. Install it or add it to PATH.",
+            fg="red",
+            err=True,
+        )
+        sys.exit(1)
+    if not session.session_id:
+        click.secho("Session has no ID for export.", fg="red", err=True)
+        sys.exit(1)
+    tmp_fd, tmp_path = tempfile.mkstemp(suffix=".json")
+    try:
+        with open(tmp_fd, "w") as out:
+            proc = subprocess.run(
+                [binary, "export", session.session_id],
+                stdout=out,
+                stderr=subprocess.PIPE,
+                cwd=session.worktree,
+                timeout=30,
+            )
+        if proc.returncode != 0:
+            stderr = proc.stderr.decode(errors="replace").strip()
+            click.secho(f"opencode export failed: {stderr}", fg="red", err=True)
+            sys.exit(1)
+        return Path(tmp_path).read_bytes(), f"{session.session_id}.json"
+    except subprocess.TimeoutExpired:
+        click.secho("opencode export timed out after 30 seconds.", fg="red", err=True)
+        sys.exit(1)
+    except OSError as e:
+        click.secho(f"opencode export failed: {e}", fg="red", err=True)
+        sys.exit(1)
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)
+
+
+@cli.command("list")
+def list_cmd():
+    """List locally-tracked uploads."""
+    entries = sessions_all()
+    if not entries:
+        click.echo("No uploads tracked locally.")
+        return
+
+    click.echo(f"{'URL':<45} {'FILENAME':<30} UPLOADED")
+    for e in entries:
+        click.echo(f"{e.get('url', ''):<45} {e.get('filename', ''):<30} {e.get('uploaded_at', '')}")
+
+
+@cli.command()
+@click.argument("slug")
+@click.option("--server", default=None, help="Override the server URL.")
+def delete(slug: str, server: str | None):
+    """Delete an uploaded session."""
+    entry = session_get(slug)
+    if entry is None:
+        click.secho(f"No local record for slug '{slug}'.", fg="red", err=True)
+        sys.exit(1)
+
+    server_url = server or entry.get("server")
+    if not server_url:
+        server_url = resolve_server_url(None)
+
+    client = SessionbinClient(server_url)
+    try:
+        client.delete(slug, entry["delete_token"])
+    except APIError as e:
+        click.secho(f"Delete failed: {e.message}", fg="red", err=True)
+        sys.exit(1)
+
+    session_remove(slug)
+    click.echo(f"Deleted {slug}.")

sessionbin-0.2.0/src/sessionbin_cli/config.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import click
+import platformdirs
+
+DEFAULT_SERVER_URL = "https://sessionbin.dev"
+
+
+def config_dir() -> Path:
+    return platformdirs.user_config_path("sessionbin")
+
+
+def config_file() -> Path:
+    return config_dir() / "config.toml"
+
+
+def _read_config_url() -> str | None:
+    path = config_file()
+    if not path.exists():
+        return None
+    for line in path.read_text().splitlines():
+        line = line.strip()
+        if line.startswith("server_url"):
+            _, _, value = line.partition("=")
+            value = value.strip().strip('"').strip("'")
+            if value:
+                return value
+    return None
+
+
+def _prompt_and_save() -> str:
+    click.echo("No server configured. Enter your sessionbin instance URL.")
+    url = click.prompt("Server URL", default=DEFAULT_SERVER_URL)
+    url = url.rstrip("/")
+    path = config_file()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(f'server_url = "{url}"\n')
+    click.echo(f"Saved to {path}")
+    return url
+
+
+def resolve_server_url(server_flag: str | None = None) -> str:
+    if server_flag:
+        return server_flag.rstrip("/")
+
+    env = os.environ.get("SESSIONBIN_URL")
+    if env:
+        return env.rstrip("/")
+
+    from_config = _read_config_url()
+    if from_config:
+        return from_config.rstrip("/")
+
+    return _prompt_and_save()

sessionbin-0.2.0/src/sessionbin_cli/detect.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Literal
+
+import platformdirs
+
+CLAUDE_PROJECTS_DIR = Path.home() / ".claude" / "projects"
+OPENCODE_DB_PATH = platformdirs.user_data_path("opencode") / "opencode.db"
+
+
+@dataclass
+class SessionInfo:
+    path: Path
+    mtime: float
+    project: str
+    title: str | None
+    summary: str | None
+    harness: Literal["claude-code", "opencode"]
+    session_id: str | None = None
+    worktree: Path | None = None
+
+
+def _claude_extract_first_user_message(obj: dict) -> str | None:
+    if obj.get("type") != "user":
+        return None
+    msg = obj.get("message", "")
+    if isinstance(msg, str):
+        text = msg
+    elif isinstance(msg, dict):
+        content = msg.get("content", "")
+        if isinstance(content, str):
+            text = content
+        elif isinstance(content, list):
+            for block in content:
+                if isinstance(block, dict) and block.get("type") == "text":
+                    text = block["text"]
+                    break
+            else:
+                return None
+        else:
+            return None
+    else:
+        return None
+    text = text.strip()
+    if text.startswith("<"):
+        return None
+    return text if text else None
+
+
+def _claude_read_metadata(path: Path) -> tuple[str | None, str | None, str | None]:
+    title = None
+    summary = None
+    cwd = None
+    try:
+        with open(path) as f:
+            for line in f:
+                obj = json.loads(line)
+                if obj.get("type") == "custom-title":
+                    title = obj.get("customTitle")
+                if summary is None:
+                    summary = _claude_extract_first_user_message(obj)
+                if cwd is None and "cwd" in obj:
+                    cwd = obj["cwd"]
+                if title is not None and summary is not None and cwd is not None:
+                    break
+    except (json.JSONDecodeError, OSError):
+        pass
+    return title, summary, cwd
+
+
+def find_claude_sessions() -> list[SessionInfo]:
+    if not CLAUDE_PROJECTS_DIR.is_dir():
+        return []
+    results: list[SessionInfo] = []
+    for project_dir in CLAUDE_PROJECTS_DIR.iterdir():
+        if not project_dir.is_dir():
+            continue
+        for f in project_dir.iterdir():
+            if f.suffix == ".jsonl" and f.is_file():
+                title, summary, cwd = _claude_read_metadata(f)
+                project = Path(cwd).name if cwd else project_dir.name
+                results.append(
+                    SessionInfo(
+                        path=f,
+                        mtime=f.stat().st_mtime,
+                        project=project,
+                        title=title,
+                        summary=summary,
+                        harness="claude-code",
+                        session_id=f.stem,
+                    )
+                )
+    results.sort(key=lambda x: x.mtime, reverse=True)
+    return results
+
+
+def find_opencode_sessions() -> list[SessionInfo]:
+    if not OPENCODE_DB_PATH.is_file():
+        return []
+    try:
+        conn = sqlite3.connect(f"file:{OPENCODE_DB_PATH}?mode=ro", uri=True)
+    except sqlite3.OperationalError:
+        return []
+    try:
+        rows = conn.execute(
+            "SELECT s.id, s.title, s.directory, s.time_updated, p.worktree "
+            "FROM session s "
+            "JOIN project p ON s.project_id = p.id "
+            "WHERE s.time_archived IS NULL"
+        ).fetchall()
+    except sqlite3.OperationalError:
+        return []
+    finally:
+        conn.close()
+    results: list[SessionInfo] = []
+    for sid, title, directory, time_updated, worktree in rows:
+        project = Path(directory).name if directory else Path(worktree).name
+        results.append(
+            SessionInfo(
+                path=Path(directory or worktree),
+                mtime=time_updated / 1000,
+                project=project,
+                title=title,
+                summary=None,
+                session_id=sid,
+                worktree=Path(worktree),
+                harness="opencode",
+            )
+        )
+    return results
+
+
+Detector = Callable[[], list[SessionInfo]]
+DETECTORS: list[Detector] = [find_claude_sessions, find_opencode_sessions]
+
+
+def find_all_sessions() -> list[SessionInfo]:
+    results: list[SessionInfo] = []
+    for detector in DETECTORS:
+        results.extend(detector())
+    results.sort(key=lambda x: x.mtime, reverse=True)
+    return results
+
+
+def most_recent() -> SessionInfo | None:
+    results: list[SessionInfo] = []
+    for detector in DETECTORS:
+        results.extend(detector())
+    return max(results, key=lambda s: s.mtime, default=None)

sessionbin-0.2.0/src/sessionbin_cli/sessions.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from pathlib import Path
+
+from sessionbin_cli.config import config_dir
+
+SESSIONS_FILE = "sessions.json"
+
+
+def _sessions_path() -> Path:
+    return config_dir() / SESSIONS_FILE
+
+
+def load() -> dict[str, dict]:
+    path = _sessions_path()
+    if not path.exists():
+        return {}
+    return json.loads(path.read_text())
+
+
+def save(slug: str, entry: dict) -> None:
+    data = load()
+    data[slug] = entry
+    _write(data)
+
+
+def get(slug: str) -> dict | None:
+    return load().get(slug)
+
+
+def remove(slug: str) -> None:
+    data = load()
+    data.pop(slug, None)
+    _write(data)
+
+
+def all() -> list[dict]:
+    data = load()
+    entries = [{"slug": slug, **v} for slug, v in data.items()]
+    entries.sort(key=lambda e: e.get("uploaded_at", ""), reverse=True)
+    return entries
+
+
+def _write(data: dict) -> None:
+    path = _sessions_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=path.parent, suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w") as f:
+            json.dump(data, f, indent=2)
+            f.write("\n")
+        os.chmod(tmp, 0o600)
+        os.replace(tmp, path)
+    except BaseException:
+        os.unlink(tmp)
+        raise

sessionbin-0.0.1/PKG-INFO

@@ -1,14 +0,0 @@
-Metadata-Version: 2.4
-Name: sessionbin
-Version: 0.0.1
-Summary: sessionbin CLI
-Author: Martin Prpič
-Author-email: Martin Prpič <martin.prpic@gmail.com>
-License-Expression: MIT
-Requires-Dist: click>=8.3.0
-Requires-Python: >=3.10
-Project-URL: Homepage, https://github.com/sessionbin/sessionbin-cli
-Project-URL: Repository, https://github.com/sessionbin/sessionbin-cli
-Description-Content-Type: text/markdown
-
-# sessionbin-cli

sessionbin-0.0.1/README.md

@@ -1 +0,0 @@
-# sessionbin-cli

sessionbin-0.0.1/pyproject.toml

@@ -1,43 +0,0 @@
-[build-system]
-requires = ["uv_build>=0.9.3,<0.10.0"]
-build-backend = "uv_build"
-
-[project]
-name = "sessionbin"
-version = "0.0.1"
-description = "sessionbin CLI"
-readme = "README.md"
-license = "MIT"
-authors = [
-    { name = "Martin Prpič", email = "martin.prpic@gmail.com" }
-]
-requires-python = ">=3.10"
-dependencies = [
-    "click>=8.3.0",
-]
-
-[project.urls]
-Homepage = "https://github.com/sessionbin/sessionbin-cli"
-Repository = "https://github.com/sessionbin/sessionbin-cli"
-
-[project.scripts]
-sessionbin = "sessionbin.cli:cli"
-
-[dependency-groups]
-dev = [
-    "pytest>=8.4.2",
-]
-
-[tool.ruff]
-line-length = 100
-
-[tool.ruff.lint]
-# https://docs.astral.sh/ruff/rules/
-select = ["F", "E", "W", "I", "N"]
-
-[tool.mypy]
-python_version = "3.13"
-warn_unused_configs = true
-warn_unreachable = true
-warn_no_return = true
-warn_unused_ignores = true

sessionbin-0.0.1/src/sessionbin/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.0.1"

sessionbin-0.0.1/src/sessionbin/cli.py

@@ -1,11 +0,0 @@
-import click
-
-CONTEXT_SETTINGS = {
-    "help_option_names": ["-h", "--help"],
-}
-
-
-@click.command(context_settings=CONTEXT_SETTINGS)
-def cli():
-    """sessionbin CLI."""
-    click.echo("sessionbin")