cdx-manager 0.5.7 → 0.6.1

package/src/cli_render.py

@@ -98,6 +98,19 @@ def _dim(text, use_color=False):
     return _style(text, "2", use_color)
 
 
+def _format_launch_text(launch):
+    if not launch:
+        return "default"
+    parts = []
+    if launch.get("power"):
+        parts.append(launch["power"])
+    if launch.get("permission"):
+        parts.append(launch["permission"])
+    if launch.get("fast") is True:
+        parts.append("fast-on")
+    return "/".join(parts) or "default"
+
+
 def format_error(error, env=None, stderr=None):
     return _style(str(error), "31", _should_use_color(env or os.environ, stderr or sys.stderr))
 
@@ -116,40 +129,26 @@ def _format_sessions(service, use_color=False):
     headers = [_style(header, "1", use_color) for header in headers]
     table_rows = []
     for r in rows:
-        parts = [r["name"]]
+        name = f"{r['name']}*" if r.get("active") else r["name"]
+        parts = [name]
         if has_provider:
             parts.append(r.get("provider") or "n/a")
         status = r.get("enabled_status") or ("enabled" if r.get("enabled", True) else "disabled")
         parts.append(_style(status, "2" if status == "disabled" else "32", use_color))
         if has_launch:
             launch = r.get("launch") or {}
-            if launch:
-                launch_text = "/".join([
-                    launch.get("power") or "-",
-                    launch.get("permission") or "-",
-                    "fast-on" if launch.get("fast") is True else "fast-off" if launch.get("fast") is False else "-",
-                ])
-            else:
-                launch_text = "default"
-            parts.append(_dim(launch_text, use_color))
+            parts.append(_dim(_format_launch_text(launch), use_color))
         parts.append(_dim(_format_relative_age(r.get("updated_at")), use_color))
         table_rows.append(parts)
     lines = [_style("Known sessions:", "1", use_color), _pad_table([headers] + table_rows), ""]
     lines += [
         _style("Next actions:", "1", use_color),
-        f"  {_style('cdx add <name>', '36', use_color)}",
-        f"  {_style('cdx <name>', '36', use_color)}",
-        f"  {_style('cdx login <name>', '36', use_color)}",
-        f"  {_style('cdx logout <name>', '36', use_color)}",
-        f"  {_style('cdx config <name>', '36', use_color)}",
+        f"  {_style('cdx status', '36', use_color)}",
+        f"  {_style('cdx ready', '36', use_color)}",
         f"  {_style('cdx set <name> --power medium --permission default --fast off', '36', use_color)}",
-        f"  {_style('cdx context show', '36', use_color)}",
-        f"  {_style('cdx handoff <name>', '36', use_color)}",
         f"  {_style('cdx handoff <source> <target>', '36', use_color)}",
-        f"  {_style('cdx disable <name>', '36', use_color)}",
-        f"  {_style('cdx enable <name>', '36', use_color)}",
-        f"  {_style('cdx ren <source> <dest>', '36', use_color)}",
-        f"  {_style('cdx rmv <name>', '36', use_color)}",
-        f"  {_style('cdx status', '36', use_color)}",
+        f"  {_style('cdx history', '36', use_color)}",
+        f"  {_style('cdx help', '36', use_color)}",
+        f"  {_style('cdx update', '36', use_color)}",
     ]
     return "\n".join(lines)

package/src/provider_runtime.py

@@ -131,7 +131,7 @@ def _wrap_launch_with_transcript(session, spec, capture_transcript=True, env=Non
             args = args + [transcript_path]
         args = args + [spec["command"]] + spec["args"]
     else:
-        args = ["-q", "-F", transcript_path, spec["command"]] + spec["args"]
+        args = _default_script_args(transcript_path, spec)
     return {
         "command": script_bin,
         "args": args,
@@ -142,6 +142,13 @@ def _wrap_launch_with_transcript(session, spec, capture_transcript=True, env=Non
     }
 
 
+def _default_script_args(transcript_path, spec):
+    if sys.platform.startswith("linux"):
+        command = shlex.join([spec["command"]] + spec["args"])
+        return ["-q", "-F", "-c", command, transcript_path]
+    return ["-q", "-F", transcript_path, spec["command"]] + spec["args"]
+
+
 def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None):
     if initial_prompt is not None:
         if not isinstance(initial_prompt, str):
@@ -277,7 +284,7 @@ def _signal_name(sig):
 
 def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
                                       env_override=None, signal_emitter=None,
-                                      initial_prompt=None):
+                                      initial_prompt=None, lifecycle_callback=None):
     spawn = spawn or subprocess.Popen
     spec = (
         _build_launch_spec(session, cwd=cwd, env_override=env_override, initial_prompt=initial_prompt)
@@ -293,11 +300,32 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
             **{k: v for k, v in current_spec.get("options", {}).items() if k != "stdio"},
         )
 
+    start_time = datetime.now(timezone.utc)
+
+    child_pid = None
+
+    def run_info(current_spec, returncode=None):
+        end_time = datetime.now(timezone.utc)
+        return {
+            "started_at": start_time.isoformat().replace("+00:00", "Z"),
+            "ended_at": end_time.isoformat().replace("+00:00", "Z"),
+            "duration_ms": int((end_time - start_time).total_seconds() * 1000),
+            "command": current_spec.get("command"),
+            "args": list(current_spec.get("args") or []),
+            "label": current_spec.get("label"),
+            "transcript_path": current_spec.get("transcript_path"),
+            "pid": child_pid,
+            "returncode": returncode,
+        }
+
     try:
         child = start_child(spec)
     except FileNotFoundError as error:
         spec = _fallback_launch_spec_or_raise(spec, error)
         child = start_child(spec)
+    child_pid = getattr(child, "pid", None) or os.getpid()
+    if lifecycle_callback:
+        lifecycle_callback("started", run_info(spec))
 
     forwarded_signal = None
     handlers = []
@@ -336,6 +364,9 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
         if forwarded_signal is None and child.returncode != 0 and _should_retry_without_transcript(spec):
             spec = _fallback_launch_spec_or_raise(spec)
             child = start_child(spec)
+            child_pid = getattr(child, "pid", None) or os.getpid()
+            if lifecycle_callback:
+                lifecycle_callback("started", run_info(spec))
             child.wait()
     finally:
         if use_emitter:
@@ -352,14 +383,26 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
                     pass
 
     if forwarded_signal is not None:
-        raise CdxError(
+        error = CdxError(
             f"{spec['label']} interrupted by {_signal_name(forwarded_signal)} for session {session['name']}",
             _signal_exit_code(forwarded_signal),
         )
+        error.run_info = run_info(spec, returncode=error.exit_code)
+        if lifecycle_callback:
+            lifecycle_callback("finished", error.run_info)
+        raise error
     if child.returncode != 0:
-        raise CdxError(
+        error = CdxError(
             f"{spec['label']} exited with code {child.returncode} for session {session['name']}"
         )
+        error.run_info = run_info(spec, returncode=child.returncode)
+        if lifecycle_callback:
+            lifecycle_callback("finished", error.run_info)
+        raise error
+    info = run_info(spec, returncode=child.returncode)
+    if lifecycle_callback:
+        lifecycle_callback("finished", info)
+    return info
 
 
 def _fallback_launch_spec_or_raise(spec, original_error=None):

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,11 +29,13 @@ RESERVED_SESSION_NAMES = {
     "export",
     "help",
     "handoff",
+    "history",
     "import",
     "login",
     "logout",
     "mv",
     "notify",
+    "ready",
     "repair",
     "ren",
     "rename",
@@ -116,6 +119,24 @@ 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 (
@@ -324,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")
@@ -585,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:
@@ -669,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:
@@ -806,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,
@@ -839,6 +956,7 @@ 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 {},
@@ -992,6 +1110,8 @@ 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,
@@ -999,6 +1119,8 @@ def create_session_service(options=None):
         "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)}",

package/src/update_check.py

@@ -9,6 +9,10 @@ UPDATE_CHECK_TTL_SECONDS = 12 * 60 * 60
 LATEST_RELEASE_URL = "https://api.github.com/repos/AlexAgo83/cdx-manager/releases/latest"
 
 
+class LatestReleaseCheckError(Exception):
+    pass
+
+
 def _parse_version(value):
     raw = str(value or "").strip().lstrip("v")
     parts = raw.split(".")
@@ -51,13 +55,22 @@ def _write_cache(path, payload):
         handle.write("\n")
 
 
-def _fetch_latest_release():
+def _github_token(env=None):
+    env = env or os.environ
+    return env.get("GH_TOKEN") or env.get("GITHUB_TOKEN")
+
+
+def _fetch_latest_release(env=None):
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "User-Agent": "cdx-manager-update-check",
+    }
+    token = _github_token(env)
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
     request = urllib.request.Request(
         LATEST_RELEASE_URL,
-        headers={
-            "Accept": "application/vnd.github+json",
-            "User-Agent": "cdx-manager-update-check",
-        },
+        headers=headers,
     )
     with urllib.request.urlopen(request, timeout=5) as response:
         payload = json.loads(response.read().decode("utf-8"))
@@ -67,13 +80,39 @@ def _fetch_latest_release():
     }
 
 
-def fetch_latest_release():
+def _format_fetch_error(error):
+    if isinstance(error, urllib.error.HTTPError):
+        if error.code == 403:
+            return (
+                "GitHub API rate limit reached while checking the latest cdx-manager release. "
+                "Try again later, set GH_TOKEN or GITHUB_TOKEN, or run cdx update --version <version>."
+            )
+        if error.code == 404:
+            return "Unable to find the latest cdx-manager release on GitHub."
+        return f"GitHub returned HTTP {error.code} while checking the latest cdx-manager release."
+    if isinstance(error, urllib.error.URLError):
+        reason = getattr(error, "reason", None)
+        suffix = f" ({reason})" if reason else ""
+        return f"Unable to reach GitHub while checking the latest cdx-manager release{suffix}."
+    if isinstance(error, TimeoutError):
+        return "Timed out while checking the latest cdx-manager release."
+    return "Unable to check for the latest cdx-manager release."
+
+
+def fetch_latest_release(env=None):
     try:
-        return _fetch_latest_release()
+        return _fetch_latest_release(env=env)
     except (urllib.error.URLError, TimeoutError, ValueError, OSError):
         return None
 
 
+def fetch_latest_release_or_raise(env=None):
+    try:
+        return _fetch_latest_release(env=env)
+    except (urllib.error.URLError, TimeoutError, ValueError, OSError) as error:
+        raise LatestReleaseCheckError(_format_fetch_error(error)) from error
+
+
 def check_for_update(base_dir, current_version, env=None, now_fn=None):
     env = env or os.environ
     now_fn = now_fn or (lambda: datetime.now(timezone.utc).timestamp())
@@ -94,7 +133,7 @@ def check_for_update(base_dir, current_version, env=None, now_fn=None):
             }
         return None
 
-    latest = fetch_latest_release()
+    latest = fetch_latest_release(env=env)
     if not latest:
         return None