cdx-manager 0.3.3 → 0.4.0

package/src/session_service.py

@@ -2,10 +2,12 @@ import os
 import shutil
 import json
 import base64
+import sys
 import tempfile
 from datetime import datetime, timezone
 from urllib.parse import quote
 
+from .backup_bundle import decode_bundle, encode_bundle
 from .config import get_cdx_home
 from .errors import CdxError
 from .session_store import create_session_store
@@ -13,12 +15,15 @@ from .status_source import find_latest_status_artifact
 
 DEFAULT_PROVIDER = "codex"
 ALLOWED_PROVIDERS = {"codex", "claude"}
+MAX_SESSION_NAME_LENGTH = 64
 RESERVED_SESSION_NAMES = {
     "add",
     "clean",
     "cp",
     "doctor",
+    "export",
     "help",
+    "import",
     "login",
     "logout",
     "mv",
@@ -40,10 +45,27 @@ def _encode(name):
     return quote(name, safe="")
 
 
+def _ensure_private_dir(path):
+    os.makedirs(path, exist_ok=True)
+    if sys.platform == "win32":
+        return
+    try:
+        os.chmod(path, 0o700)
+    except OSError:
+        pass
+
+
 def _local_now_iso():
     return datetime.now().astimezone().isoformat()
 
 
+def _safe_relpath(path):
+    normalized = str(path or "").replace("\\", "/").strip("/")
+    if not normalized or normalized.startswith("../") or "/../" in f"/{normalized}/":
+        raise CdxError("Bundle contains an unsafe file path.")
+    return normalized
+
+
 def _to_local_iso(value):
     if not value:
         return value
@@ -222,15 +244,65 @@ def create_session_service(options=None):
     def _validate_new_session_name(name):
         if not name:
             raise CdxError("Session name is required")
+        if str(name) != str(name).strip():
+            raise CdxError("Session name cannot start or end with whitespace")
+        if len(str(name)) > MAX_SESSION_NAME_LENGTH:
+            raise CdxError(f"Session name is too long (max {MAX_SESSION_NAME_LENGTH} characters)")
+        if any(ord(ch) < 32 or ord(ch) == 127 for ch in str(name)):
+            raise CdxError("Session name cannot contain control characters")
         if name in RESERVED_SESSION_NAMES:
             raise CdxError(f"Session name is reserved: {name}")
 
+    def _build_export_session_record(session):
+        return {
+            "name": session["name"],
+            "provider": session["provider"],
+            "createdAt": session.get("createdAt"),
+            "updatedAt": session.get("updatedAt"),
+            "lastLaunchedAt": session.get("lastLaunchedAt"),
+            "lastStatusAt": session.get("lastStatusAt"),
+            "lastStatus": session.get("lastStatus"),
+            "auth": session.get("auth"),
+        }
+
+    def _collect_profile_files(session_root):
+        excluded_dirs = {"log", "tmp", "cache", "__pycache__", "shell_snapshots"}
+        files = []
+        if not os.path.isdir(session_root):
+            return files
+        for dirpath, dirnames, filenames in os.walk(session_root):
+            dirnames[:] = [name for name in dirnames if name not in excluded_dirs]
+            for filename in filenames:
+                full_path = os.path.join(dirpath, filename)
+                if not os.path.isfile(full_path):
+                    continue
+                rel_path = os.path.relpath(full_path, session_root)
+                with open(full_path, "rb") as handle:
+                    content = base64.b64encode(handle.read()).decode("ascii")
+                files.append({"path": rel_path.replace(os.sep, "/"), "data_b64": content})
+        return files
+
+    def _resolve_session_subset(session_names):
+        if not session_names:
+            return list_sessions()
+        by_name = {session["name"]: session for session in list_sessions()}
+        selected = []
+        for name in session_names:
+            session = by_name.get(name)
+            if not session:
+                raise CdxError(f"Unknown session: {name}")
+            selected.append(session)
+        return selected
+
     def create_session(name, provider=DEFAULT_PROVIDER):
         _validate_new_session_name(name)
         normalized_provider = _normalize_provider(provider)
         session_root = _get_session_root(name)
         auth_home = _get_session_auth_home(name, normalized_provider)
-        os.makedirs(auth_home, exist_ok=True)
+        _ensure_private_dir(base_dir)
+        _ensure_private_dir(os.path.join(base_dir, "profiles"))
+        _ensure_private_dir(session_root)
+        _ensure_private_dir(auth_home)
         now = _local_now_iso()
         session = {
             "name": name,
@@ -514,7 +586,6 @@ def create_session_service(options=None):
             rows.append({
                 "session_name": s["name"],
                 "provider": s["provider"],
-                "auth_home": s.get("authHome") or _get_session_auth_home(s["name"], s["provider"]),
                 "remaining_5h_pct": status.get("remaining_5h_pct") if status else None,
                 "remaining_week_pct": status.get("remaining_week_pct") if status else None,
                 "credits": status.get("credits") if status else None,
@@ -543,6 +614,116 @@ def create_session_service(options=None):
     def get_session_root(name):
         return _get_session_root(name)
 
+    def export_bundle(file_path, include_auth=False, session_names=None, passphrase=None, force=False):
+        if not file_path:
+            raise CdxError("Export path is required.")
+        if os.path.exists(file_path) and not force:
+            raise CdxError(f"Export path already exists: {file_path}")
+
+        sessions = _resolve_session_subset(session_names)
+        payload = {
+            "schema_version": 1,
+            "created_at": _local_now_iso(),
+            "include_auth": bool(include_auth),
+            "sessions": [],
+            "states": {},
+            "profiles": {},
+        }
+        for session in sessions:
+            payload["sessions"].append(_build_export_session_record(session))
+            state = store["read_session_state"](session["name"])
+            if state is not None:
+                payload["states"][session["name"]] = state
+            if include_auth:
+                session_root = session.get("sessionRoot") or _get_session_root(session["name"])
+                payload["profiles"][session["name"]] = _collect_profile_files(session_root)
+
+        bundle_bytes = encode_bundle(payload, include_auth=include_auth, passphrase=passphrase)
+        _ensure_private_dir(os.path.dirname(os.path.abspath(file_path)) or ".")
+        with open(file_path, "wb") as handle:
+            handle.write(bundle_bytes)
+        if sys.platform != "win32":
+            try:
+                os.chmod(file_path, 0o600)
+            except OSError:
+                pass
+        return {
+            "path": file_path,
+            "include_auth": include_auth,
+            "session_names": [session["name"] for session in sessions],
+        }
+
+    def import_bundle(file_path, passphrase=None, session_names=None, force=False):
+        if not file_path or not os.path.isfile(file_path):
+            raise CdxError(f"Bundle file not found: {file_path}")
+        with open(file_path, "rb") as handle:
+            decoded = decode_bundle(handle.read(), passphrase=passphrase)
+        payload = decoded["payload"]
+        imported_sessions = payload.get("sessions") or []
+        if payload.get("schema_version") != 1:
+            raise CdxError("Unsupported bundle payload schema version.")
+
+        selected_names = set(session_names or [])
+        if selected_names:
+            imported_sessions = [item for item in imported_sessions if item["name"] in selected_names]
+            missing_names = sorted(selected_names - {item["name"] for item in imported_sessions})
+            if missing_names:
+                raise CdxError(f"Bundle does not contain requested sessions: {', '.join(missing_names)}")
+        names = [item["name"] for item in imported_sessions]
+
+        existing = {session["name"] for session in list_sessions()}
+        conflicts = [name for name in names if name in existing]
+        if conflicts and not force:
+            raise CdxError(f"Import would overwrite existing sessions: {', '.join(conflicts)}")
+
+        for session_payload in imported_sessions:
+            name = session_payload["name"]
+            _validate_new_session_name(name)
+            provider = _normalize_provider(session_payload["provider"])
+            if name in existing:
+                remove_session(name)
+
+            session_root = _get_session_root(name)
+            auth_home = _get_session_auth_home(name, provider)
+            _ensure_private_dir(base_dir)
+            _ensure_private_dir(os.path.join(base_dir, "profiles"))
+            _ensure_private_dir(session_root)
+            _ensure_private_dir(auth_home)
+
+            session_record = {
+                **session_payload,
+                "provider": provider,
+                "sessionRoot": session_root,
+                "authHome": auth_home,
+            }
+            store["replace_session"](name, session_record)
+
+            state = (payload.get("states") or {}).get(name)
+            if state is not None:
+                store["write_session_state"](name, state)
+
+            for item in (payload.get("profiles") or {}).get(name, []):
+                rel_path = _safe_relpath(item.get("path"))
+                try:
+                    content = base64.b64decode(item.get("data_b64", "").encode("ascii"))
+                except (AttributeError, ValueError, UnicodeEncodeError) as error:
+                    raise CdxError(f"Bundle contains invalid file data for session {name}: {rel_path}") from error
+                dest_path = os.path.join(session_root, rel_path)
+                _ensure_private_dir(os.path.dirname(dest_path))
+                with open(dest_path, "wb") as handle:
+                    handle.write(content)
+                if sys.platform != "win32":
+                    try:
+                        os.chmod(dest_path, 0o600)
+                    except OSError:
+                        pass
+
+        return {
+            "path": file_path,
+            "session_names": names,
+            "include_auth": bool(decoded["meta"].get("include_auth")),
+        }
+
     return {
         "create_session": create_session,
         "remove_session": remove_session,
@@ -558,6 +739,8 @@ def create_session_service(options=None):
         "format_list_rows": format_list_rows,
         "get_session_auth_home": get_session_auth_home,
         "get_session_root": get_session_root,
+        "export_bundle": export_bundle,
+        "import_bundle": import_bundle,
         "base_dir": base_dir,
         "normalize_provider": _normalize_provider,
     }

package/src/session_store.py

@@ -1,5 +1,6 @@
 import json
 import os
+import sys
 import tempfile
 from contextlib import contextmanager
 from pathlib import Path
@@ -9,6 +10,16 @@ from .errors import CdxError
 
 def _ensure_dir(path):
     Path(path).mkdir(parents=True, exist_ok=True)
+    _restrict_dir_permissions(path)
+
+
+def _restrict_dir_permissions(path):
+    if sys.platform == "win32":
+        return
+    try:
+        os.chmod(path, 0o700)
+    except OSError:
+        pass
 
 
 def _read_json(file_path, fallback):

package/src/status_source.py

@@ -119,7 +119,9 @@ def _extract_status_blocks_from_text(text, provider=None, source_ref=None, times
                 r"^To continue this session\b", r"^╰",
             ]],
             context_pattern=re.compile(
-                r"^\s*$|^\s*(?:[│|]\s*)?(?:╭|Visit\b|information\b|Model:|Directory:|Permissions:|Agents\.md:|Account:|Collaboration mode:|Session:)",
+                r"^\s*$"
+                r"|^\s*[│|](?:\s|[│|])*$"
+                r"|^\s*(?:[│|]\s*)?(?:╭|Visit\b|information\b|Model:|Directory:|Permissions:|Agents\.md:|Account:|Collaboration mode:|Session:)",
                 re.I,
             ),
             context_stop_patterns=[

package/src/update_check.py

@@ -0,0 +1,107 @@
+import json
+import os
+import urllib.error
+import urllib.request
+from datetime import datetime, timezone
+
+
+UPDATE_CHECK_TTL_SECONDS = 12 * 60 * 60
+LATEST_RELEASE_URL = "https://api.github.com/repos/AlexAgo83/cdx-manager/releases/latest"
+
+
+def _parse_version(value):
+    raw = str(value or "").strip().lstrip("v")
+    parts = raw.split(".")
+    if len(parts) != 3:
+        return None
+    try:
+        return tuple(int(part) for part in parts)
+    except ValueError:
+        return None
+
+
+def _is_newer_version(current_version, latest_version):
+    current = _parse_version(current_version)
+    latest = _parse_version(latest_version)
+    if not current or not latest:
+        return False
+    return latest > current
+
+
+def _cache_path(base_dir):
+    return os.path.join(base_dir, "state", "update-check.json")
+
+
+def _read_cache(path):
+    try:
+        with open(path, "r", encoding="utf-8") as handle:
+            return json.load(handle)
+    except (FileNotFoundError, OSError, json.JSONDecodeError):
+        return None
+
+
+def _write_cache(path, payload):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as handle:
+        json.dump(payload, handle, indent=2)
+        handle.write("\n")
+
+
+def _fetch_latest_release():
+    request = urllib.request.Request(
+        LATEST_RELEASE_URL,
+        headers={
+            "Accept": "application/vnd.github+json",
+            "User-Agent": "cdx-manager-update-check",
+        },
+    )
+    with urllib.request.urlopen(request, timeout=5) as response:
+        payload = json.loads(response.read().decode("utf-8"))
+    return {
+        "latest_version": str(payload.get("tag_name") or "").lstrip("v"),
+        "url": payload.get("html_url") or payload.get("url"),
+    }
+
+
+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())
+    if env.get("CDX_DISABLE_UPDATE_CHECK") in {"1", "true", "TRUE", "yes", "YES"}:
+        return None
+
+    path = _cache_path(base_dir)
+    now_ts = float(now_fn())
+    cached = _read_cache(path) or {}
+    checked_at = cached.get("checked_at")
+    if isinstance(checked_at, (int, float)) and (now_ts - checked_at) < UPDATE_CHECK_TTL_SECONDS:
+        latest_version = cached.get("latest_version")
+        if _is_newer_version(current_version, latest_version):
+            return {
+                "latest_version": latest_version,
+                "url": cached.get("url"),
+                "cached": True,
+            }
+        return None
+
+    try:
+        latest = _fetch_latest_release()
+    except (urllib.error.URLError, TimeoutError, ValueError, OSError):
+        return None
+
+    payload = {
+        "checked_at": now_ts,
+        "latest_version": latest.get("latest_version"),
+        "url": latest.get("url"),
+    }
+    try:
+        _write_cache(path, payload)
+    except OSError:
+        pass
+
+    if _is_newer_version(current_version, latest.get("latest_version")):
+        return {
+            "latest_version": latest.get("latest_version"),
+            "url": latest.get("url"),
+            "cached": False,
+        }
+    return None