cdx-manager 0.5.6 → 0.6.0

package/src/session_service.py

@@ -4,6 +4,7 @@ import json
 import base64
 import sys
 import tempfile
+import uuid
 from datetime import datetime, timezone
 from urllib.parse import quote
 
@@ -28,16 +29,21 @@ RESERVED_SESSION_NAMES = {
     "export",
     "help",
     "handoff",
+    "history",
     "import",
     "login",
     "logout",
     "mv",
     "notify",
+    "ready",
     "repair",
     "ren",
     "rename",
     "rmv",
+    "config",
+    "set",
     "status",
+    "unset",
     "update",
     "version",
     "--help",
@@ -47,6 +53,8 @@ RESERVED_SESSION_NAMES = {
 }
 STATUS_CACHE_TTL_SECONDS = 60
 CLAUDE_STATUS_CACHE_TTL_SECONDS = 10 * 60
+LAUNCH_POWER_VALUES = {"low", "medium", "high", "xhigh", "max"}
+LAUNCH_PERMISSION_VALUES = {"review", "default", "auto", "full"}
 
 
 def _encode(name):
@@ -78,10 +86,57 @@ def _seed_codex_auth_from_global(auth_home, env=None):
     return True
 
 
+def _normalize_launch_settings(settings):
+    normalized = {}
+    if not settings:
+        return normalized
+    if "power" in settings and settings["power"] is not None:
+        power = str(settings["power"]).strip().lower()
+        if power not in LAUNCH_POWER_VALUES:
+            raise CdxError(f"Unsupported power: {settings['power']}")
+        normalized["power"] = power
+    if "permission" in settings and settings["permission"] is not None:
+        permission = str(settings["permission"]).strip().lower()
+        if permission not in LAUNCH_PERMISSION_VALUES:
+            raise CdxError(f"Unsupported permission: {settings['permission']}")
+        normalized["permission"] = permission
+    if "fast" in settings and settings["fast"] is not None:
+        value = settings["fast"]
+        if isinstance(value, bool):
+            normalized["fast"] = value
+        else:
+            text = str(value).strip().lower()
+            if text in ("on", "true", "1", "yes"):
+                normalized["fast"] = True
+            elif text in ("off", "false", "0", "no"):
+                normalized["fast"] = False
+            else:
+                raise CdxError(f"Unsupported fast value: {settings['fast']}")
+    return normalized
+
+
 def _local_now_iso():
     return datetime.now().astimezone().isoformat()
 
 
+def _process_is_running(pid):
+    try:
+        pid = int(pid)
+    except (TypeError, ValueError):
+        return False
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        return False
+    return True
+
+
 def _safe_relpath(path):
     normalized = os.path.normpath(str(path or "").replace("\\", "/")).replace("\\", "/")
     if (
@@ -290,6 +345,32 @@ def create_session_service(options=None):
             raise CdxError(f"Unsupported provider: {value}")
         return value
 
+    def _runtime_is_active(runtime):
+        return (
+            isinstance(runtime, dict)
+            and runtime.get("status") == "running"
+            and _process_is_running(runtime.get("pid"))
+        )
+
+    def _session_runtime(name):
+        state = store["read_session_state"](name)
+        if not state:
+            return None
+        runtime = state.get("runtime")
+        if _runtime_is_active(runtime):
+            return runtime
+        if isinstance(runtime, dict) and runtime.get("status") == "running":
+            store["write_session_state"](name, {
+                **state,
+                "status": "ready",
+                "runtime": {
+                    **runtime,
+                    "status": "stale",
+                    "endedAt": _local_now_iso(),
+                },
+            })
+        return None
+
     def _validate_new_session_name(name):
         if not name:
             raise CdxError("Session name is required")
@@ -312,6 +393,7 @@ def create_session_service(options=None):
             "lastLaunchedAt": session.get("lastLaunchedAt"),
             "lastStatusAt": session.get("lastStatusAt"),
             "lastStatus": session.get("lastStatus"),
+            "launch": session.get("launch"),
             "auth": session.get("auth"),
         }
 
@@ -459,6 +541,7 @@ def create_session_service(options=None):
             "lastLaunchedAt": None,
             "lastStatusAt": None,
             "lastStatus": None,
+            **({"launch": source.get("launch")} if source.get("launch") else {}),
             "auth": {
                 "status": "unknown",
                 "lastCheckedAt": None,
@@ -549,6 +632,56 @@ def create_session_service(options=None):
             **s, "updatedAt": now, "lastLaunchedAt": now
         })
 
+    def start_session_runtime(name, payload=None):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        state = store["read_session_state"](name)
+        if not state:
+            raise CdxError(f"Session state missing for {name}. Reconnect required.")
+        payload = dict(payload or {})
+        now = _local_now_iso()
+        runtime = {
+            "status": "running",
+            "runId": payload.get("runId") or uuid.uuid4().hex,
+            "startedAt": payload.get("startedAt") or now,
+            "pid": payload.get("pid") or os.getpid(),
+            "command": payload.get("command"),
+            "label": payload.get("label"),
+            "transcriptPath": payload.get("transcript_path") or payload.get("transcriptPath"),
+        }
+        store["write_session_state"](name, {
+            **state,
+            "status": "running",
+            "runtime": runtime,
+        })
+        return runtime
+
+    def finish_session_runtime(name, run_id=None, payload=None):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        state = store["read_session_state"](name)
+        if not state:
+            return None
+        runtime = state.get("runtime") or {}
+        if run_id and runtime.get("runId") != run_id:
+            return runtime
+        payload = dict(payload or {})
+        updated_runtime = {
+            **runtime,
+            "status": payload.get("status") or "stopped",
+            "endedAt": payload.get("endedAt") or _local_now_iso(),
+        }
+        if "returncode" in payload:
+            updated_runtime["returncode"] = payload["returncode"]
+        store["write_session_state"](name, {
+            **state,
+            "status": "ready",
+            "runtime": updated_runtime,
+        })
+        return updated_runtime
+
     def ensure_session_state(name):
         session = store["get_session"](name)
         if not session:
@@ -581,6 +714,47 @@ def create_session_service(options=None):
             "updatedAt": now,
         })
 
+    def set_launch_settings(name, settings):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        updates = _normalize_launch_settings(settings)
+        if not updates:
+            raise CdxError("At least one launch setting is required.")
+        current = _normalize_launch_settings(session.get("launch") or {})
+        launch = {**current, **updates}
+        now = _local_now_iso()
+        return store["update_session"](name, lambda s: {
+            **s,
+            "launch": launch,
+            "updatedAt": now,
+        })
+
+    def unset_launch_settings(name, keys):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        if not keys:
+            raise CdxError("At least one launch setting is required.")
+        allowed = {"power", "permission", "fast"}
+        unknown = [key for key in keys if key not in allowed]
+        if unknown:
+            raise CdxError(f"Unsupported launch setting: {', '.join(unknown)}")
+        current = dict(session.get("launch") or {})
+        for key in keys:
+            current.pop(key, None)
+        now = _local_now_iso()
+
+        def updater(s):
+            updated = {**s, "updatedAt": now}
+            if current:
+                updated["launch"] = current
+            else:
+                updated.pop("launch", None)
+            return updated
+
+        return store["update_session"](name, updater)
+
     def record_status(name, payload):
         normalized = _normalize_status_payload(payload)
         updated = store["update_session"](name, lambda s: {
@@ -592,6 +766,25 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         return updated
 
+    def record_launch_history(name, payload):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        entry = {
+            "schema_version": 1,
+            "session_name": session["name"],
+            "provider": session["provider"],
+            "launch": session.get("launch") or {},
+            **payload,
+        }
+        store["append_launch_history"](entry)
+        return entry
+
+    def get_launch_history(name=None, limit=20):
+        if name and not store["get_session"](name):
+            raise CdxError(f"Unknown session: {name}")
+        return store["list_launch_history"](session_name=name, limit=limit)
+
     def _resolve_session_status(session, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS):
         current_status = session.get("lastStatus")
         if session.get("enabled", True) is False:
@@ -729,6 +922,7 @@ def create_session_service(options=None):
                 "session_name": s["name"],
                 "provider": s["provider"],
                 "enabled": enabled,
+                "active": bool(_session_runtime(s["name"])) if enabled else False,
                 "status": "enabled" if enabled else "disabled",
                 "remaining_5h_pct": row_status.get("remaining_5h_pct") if row_status else None,
                 "remaining_week_pct": row_status.get("remaining_week_pct") if row_status else None,
@@ -762,8 +956,10 @@ def create_session_service(options=None):
             "name": s["name"],
             "provider": s["provider"] if has_multiple else None,
             "enabled": s.get("enabled", True) is not False,
+            "active": bool(_session_runtime(s["name"])) if s.get("enabled", True) is not False else False,
             "enabled_status": "disabled" if s.get("enabled", True) is False else "enabled",
             "status": s.get("lastStatus"),
+            "launch": s.get("launch") or {},
             "updated_at": _to_local_iso(s.get("updatedAt")),
         } for s in sessions]
 
@@ -914,11 +1110,17 @@ def create_session_service(options=None):
         "copy_session": copy_session,
         "rename_session": rename_session,
         "launch_session": launch_session,
+        "start_session_runtime": start_session_runtime,
+        "finish_session_runtime": finish_session_runtime,
         "ensure_session_state": ensure_session_state,
         "list_sessions": list_sessions,
         "get_session": get_session,
         "set_session_enabled": set_session_enabled,
+        "set_launch_settings": set_launch_settings,
+        "unset_launch_settings": unset_launch_settings,
         "record_status": record_status,
+        "record_launch_history": record_launch_history,
+        "get_launch_history": get_launch_history,
         "update_auth_state": update_auth_state,
         "get_status_rows": get_status_rows,
         "format_list_rows": format_list_rows,

package/src/session_store.py

@@ -105,6 +105,7 @@ def create_session_store(base_dir):
     store_file = os.path.join(base_dir, "sessions.json")
     lock_file = os.path.join(base_dir, ".sessions.lock")
     state_dir = os.path.join(base_dir, "state")
+    launch_history_file = os.path.join(state_dir, "launch_history.jsonl")
 
     def _state_file_path(name):
         return os.path.join(state_dir, f"{_encode(name)}.json")
@@ -259,6 +260,39 @@ def create_session_store(base_dir):
         with _file_lock(lock_file):
             _write_session_state_unlocked(name, state)
 
+    def append_launch_history(entry):
+        with _file_lock(lock_file):
+            _ensure_dir(state_dir)
+            with open(launch_history_file, "a", encoding="utf-8") as handle:
+                handle.write(json.dumps(entry, separators=(",", ":")))
+                handle.write("\n")
+                handle.flush()
+                os.fsync(handle.fileno())
+            _fsync_directory(state_dir)
+
+    def list_launch_history(session_name=None, limit=20):
+        with _file_lock(lock_file):
+            try:
+                with open(launch_history_file, "r", encoding="utf-8") as handle:
+                    lines = handle.readlines()
+            except FileNotFoundError:
+                return []
+            entries = []
+            for line in reversed(lines):
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                except json.JSONDecodeError as error:
+                    raise CdxError(f"Corrupt JSONL file: {launch_history_file}") from error
+                if session_name and entry.get("session_name") != session_name:
+                    continue
+                entries.append(entry)
+                if limit and len(entries) >= limit:
+                    break
+            return entries
+
     return {
         "list_sessions": list_sessions,
         "get_session": get_session,
@@ -269,4 +303,6 @@ def create_session_store(base_dir):
         "replace_session": replace_session,
         "read_session_state": read_session_state,
         "write_session_state": write_session_state,
+        "append_launch_history": append_launch_history,
+        "list_launch_history": list_launch_history,
     }

package/src/status_view.py

@@ -11,6 +11,7 @@ from .cli_render import (
 
 RESET_COUNTDOWN_SAFETY_SECONDS = 60
 PRIORITY_EMPTY_AVAILABLE_THRESHOLD = 5
+BLOCKING_QUOTA_WARNING_THRESHOLD = 10
 
 
 def _format_reset_time(value):
@@ -42,7 +43,11 @@ def _format_reset_time(value):
         if remaining_minutes == 0:
             return f"in {hours}h"
         return f"in {hours}h {remaining_minutes}m"
-    return value
+    days = int(delta_s // (24 * 60 * 60))
+    hours = int((delta_s % (24 * 60 * 60)) // (60 * 60))
+    if hours == 0:
+        return f"in {days}d"
+    return f"in {days}d {hours}h"
 
 
 def _style_reset_time(value, use_color=False):
@@ -77,7 +82,7 @@ def _format_status_rows(rows, use_color=False, small=False):
     priority = _recommend_priority_sessions(active_rows)
     table_rows = []
     for r in priority + disabled_rows:
-        base = [r["session_name"]]
+        base = [_format_session_name(r)]
         if has_provider:
             base.append(r.get("provider") or "n/a")
         status = r.get("status") or ("enabled" if r.get("enabled", True) else "disabled")
@@ -133,6 +138,10 @@ def _format_current_session_line(rows):
     return f"Current: last launched {row['session_name']} ({label})."
 
 
+def _format_session_name(row):
+    return f"{row['session_name']}*" if row.get("active") else row["session_name"]
+
+
 def _recommend_priority_sessions(rows):
     if not rows:
         return []
@@ -166,6 +175,9 @@ def _format_blocking_quota(row):
     remaining_week = row.get("remaining_week_pct")
     if remaining_5h is None and remaining_week is None:
         return "?"
+    known = [value for value in (remaining_5h, remaining_week) if value is not None]
+    if known and min(known) > BLOCKING_QUOTA_WARNING_THRESHOLD:
+        return "-"
     if remaining_5h is None:
         return "WEEK"
     if remaining_week is None:
@@ -284,7 +296,7 @@ def _now_timestamp():
 
 def _format_status_detail(row, use_color=False):
     lines = [
-        f"{_style('Session:', '1', use_color)} {row['session_name']}",
+        f"{_style('Session:', '1', use_color)} {_format_session_name(row)}",
         f"{_style('Provider:', '1', use_color)} {row.get('provider') or 'n/a'}",
         f"{_style('Status:', '1', use_color)} {_style(row.get('status') or ('enabled' if row.get('enabled', True) else 'disabled'), '2' if row.get('enabled', True) is False else '32', use_color)}",
         f"{_style('Available:', '1', use_color)} {_style_pct(row.get('available_pct'), use_color)}",