cdx-manager 0.9.10 → 0.9.11

package/src/cli_helpers.py

@@ -0,0 +1,385 @@
+#!/usr/bin/env python3
+"""Shared helpers for cdx commands: JSON envelopes, formatting, handoff transcripts.
+
+Split out of cli_commands.py as the low-level, side-effect-light helper layer
+(no command dispatch). Imported back into cli_commands and used by handlers.
+"""
+
+import json
+import os
+import re
+from datetime import datetime
+
+from .cli_render import _dim, _info, _warn
+from .config import PROVIDER_CODEX
+from .provider_runtime import _list_launch_transcript_paths
+from .status_source import _normalize_terminal_transcript
+
+API_SCHEMA_VERSION = 1
+HANDOFF_TRANSCRIPT_CHARS = 120000
+HANDOFF_NATIVE_TRANSCRIPT_CANDIDATES = 64
+
+
+def _local_now_iso():
+    return datetime.now().astimezone().isoformat()
+
+
+def _json_success(action, message, warnings=None, **extra):
+    payload = {
+        "schema_version": API_SCHEMA_VERSION,
+        "ok": True,
+        "action": action,
+        "message": message,
+        "warnings": warnings or [],
+    }
+    payload.update(extra)
+    return payload
+
+
+def _json_failure(action, code, message, source="cdx", exit_code=1, warnings=None, **extra):
+    payload = {
+        "schema_version": API_SCHEMA_VERSION,
+        "ok": False,
+        "action": action,
+        "warnings": warnings or [],
+        "error": {
+            "source": source,
+            "code": code,
+            "message": message,
+            "exit_code": exit_code,
+        },
+    }
+    payload.update(extra)
+    return payload
+
+
+def _write_json(ctx, payload):
+    ctx["out"](f"{json.dumps(payload, indent=2)}\n")
+
+
+def _update_notice_warning(ctx):
+    notices = ctx.get("update_notices") or []
+    if not notices:
+        return None
+    warnings = _update_notice_warnings(ctx)
+    return warnings[0] if warnings else None
+
+
+def _update_notice_warnings(ctx):
+    warnings = []
+    for notice in ctx.get("update_notices") or []:
+        tool = notice.get("tool") or "cdx-manager"
+        current = notice.get("current_version") or ctx.get("version")
+        command = notice.get("update_command") or ("cdx update" if tool == "cdx-manager" else None)
+        message = f"Update available: {tool} {notice['latest_version']}"
+        if current:
+            message = f"{message} (current {current})"
+        if command:
+            message = f"{message}. Run: {command}"
+        warnings.append({
+            "code": "update_available" if tool == "cdx-manager" else f"{tool.replace('-', '_')}_update_available",
+            "message": message,
+            "tool": tool,
+            "latest_version": notice["latest_version"],
+            "current_version": current,
+            "update_command": command,
+            "url": notice.get("url"),
+        })
+    return warnings
+
+
+def _write_update_notice(ctx):
+    warnings = _update_notice_warnings(ctx)
+    if not warnings:
+        return
+    for warning in warnings:
+        ctx["out"](f"{_warn(warning['message'], ctx['use_color'])}\n")
+
+
+def _format_bytes(value):
+    if value is None:
+        return "n/a"
+    try:
+        amount = float(value)
+    except (TypeError, ValueError):
+        return str(value)
+    units = ["B", "KB", "MB", "GB", "TB"]
+    unit = units[0]
+    for unit in units:
+        if amount < 1024 or unit == units[-1]:
+            break
+        amount /= 1024
+    if unit == "B":
+        return f"{int(amount)} B"
+    return f"{amount:.1f} {unit}"
+
+
+def _format_export_report(result):
+    lines = [
+        f"Path: {result['path']}",
+        f"Sessions: {', '.join(result['session_names']) or '-'}",
+        f"Auth: {'included and encrypted' if result['include_auth'] else 'not included'}",
+        f"Bundle size: {_format_bytes(result.get('bundle_size_bytes'))}",
+    ]
+    if result.get("include_auth"):
+        lines.extend([
+            f"Auth files: {result.get('profile_file_count', 0)}",
+            f"Auth data: {_format_bytes(result.get('profile_bytes'))}",
+        ])
+    return "\n".join(lines)
+
+
+def _make_export_progress(ctx):
+    def progress(event):
+        kind = event.get("event")
+        if kind == "export_started":
+            auth = " with auth" if event.get("include_auth") else ""
+            message = f"Exporting {event.get('session_count', 0)} session(s){auth}..."
+            ctx["out"](f"{_info(message, ctx['use_color'])}\n")
+        elif kind == "session_started":
+            message = f"Collecting {event.get('session_name')}..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "profile_progress":
+            message = f"  {event.get('session_name')}: {event.get('file_count', 0)} files, {_format_bytes(event.get('bytes'))}"
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "encoding_started":
+            ctx["out"](f"{_dim('Encoding and encrypting bundle...', ctx['use_color'])}\n")
+        elif kind == "writing_started":
+            message = f"Writing {_format_bytes(event.get('bundle_size_bytes'))}..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+    return progress
+
+
+def _make_status_progress(ctx):
+    progress_state = {"checked": 0, "total": 0}
+
+    def progress(event):
+        kind = event.get("event")
+        if kind == "status_started":
+            progress_state["checked"] = 0
+            progress_state["total"] = event.get("check_count", event.get("session_count", 0)) or 0
+            message = f"Resolving status for {event.get('session_count', 0)} session(s)..."
+            ctx["out"](f"{_info(message, ctx['use_color'])}\n")
+        elif kind == "session_started":
+            provider = event.get("provider") or "session"
+            message = f"Checking {event.get('session_name')} ({provider})..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "session_finished" and not event.get("cache_hit"):
+            progress_state["checked"] += 1
+            total = progress_state["total"] or progress_state["checked"]
+            message = f"Checked {event.get('session_name')} ({progress_state['checked']}/{total})."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "status_finished":
+            message = f"Resolved {event.get('row_count', 0)} status row(s)."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+    return progress
+
+
+def _make_notify_progress(ctx):
+    progress_state = {"checked": 0, "total": 0}
+
+    def progress(event):
+        kind = event.get("event")
+        if kind == "notify_check_started":
+            target = event.get("session_name") or "next ready session"
+            ctx["out"](f"{_info(f'Checking notification target: {target}...', ctx['use_color'])}\n")
+        elif kind == "status_started":
+            progress_state["checked"] = 0
+            progress_state["total"] = event.get("check_count", event.get("session_count", 0)) or 0
+            message = f"Loading status for {event.get('session_count', 0)} session(s)..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "session_started":
+            provider = event.get("provider") or "session"
+            message = f"Checking {event.get('session_name')} ({provider})..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "session_finished" and not event.get("cache_hit"):
+            progress_state["checked"] += 1
+            total = progress_state["total"] or progress_state["checked"]
+            message = f"Checked {event.get('session_name')} ({progress_state['checked']}/{total})."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+        elif kind == "notify_waiting":
+            message = f"{event.get('message')}; checking again in {event.get('poll')}s..."
+            ctx["out"](f"{_dim(message, ctx['use_color'])}\n")
+    return progress
+
+
+def _latest_launch_transcript_path(session):
+    paths = _list_launch_transcript_paths(session)
+    if not paths:
+        return None
+    return max(paths, key=lambda path: (os.path.getmtime(path), path))
+
+
+def _get_session_home(session):
+    return session.get("authHome") or session.get("sessionRoot") or session.get("codexHome", "")
+
+
+def _safe_stat(path):
+    try:
+        return os.stat(path)
+    except OSError:
+        return None
+
+
+def _sort_recent_paths(paths):
+    stats = {path: stat for path, stat in ((_path, _safe_stat(_path)) for _path in set(paths)) if stat}
+    return sorted(stats, key=lambda path: (stats[path].st_mtime, path), reverse=True)
+
+
+def _collect_native_handoff_transcript_paths(session):
+    root = _get_session_home(session)
+    if not root:
+        return []
+    candidates = []
+    direct = [
+        os.path.join(root, "history.jsonl"),
+        os.path.join(root, "session_index.jsonl"),
+    ]
+    candidates.extend(path for path in direct if _safe_stat(path))
+
+    scan_roots = [
+        os.path.join(root, "sessions"),
+        os.path.join(root, ".claude", "projects"),
+        os.path.join(root, "projects"),
+    ]
+    skip_dirs = {"cache", "plugins", "skills", "memories", "sqlite", "shell_snapshots", "tmp", "__pycache__"}
+    for scan_root in scan_roots:
+        if not os.path.isdir(scan_root):
+            continue
+        for dirpath, dirnames, filenames in os.walk(scan_root):
+            dirnames[:] = [name for name in dirnames if not name.startswith(".") and name not in skip_dirs]
+            for filename in filenames:
+                if filename.endswith(".jsonl") or filename.endswith(".log"):
+                    candidates.append(os.path.join(dirpath, filename))
+    return _sort_recent_paths(candidates)[:HANDOFF_NATIVE_TRANSCRIPT_CANDIDATES]
+
+
+def _latest_handoff_transcript_path(session):
+    launch_path = _latest_launch_transcript_path(session)
+    if launch_path:
+        return launch_path
+    native_paths = _collect_native_handoff_transcript_paths(session)
+    return native_paths[0] if native_paths else None
+
+
+def _collect_handoff_text_fragments(value):
+    fragments = []
+    if isinstance(value, str):
+        text = value.strip()
+        if text:
+            fragments.append(text)
+    elif isinstance(value, list):
+        for item in value:
+            fragments.extend(_collect_handoff_text_fragments(item))
+    elif isinstance(value, dict):
+        if isinstance(value.get("text"), str):
+            fragments.extend(_collect_handoff_text_fragments(value.get("text")))
+        if isinstance(value.get("content"), (str, list, dict)):
+            fragments.extend(_collect_handoff_text_fragments(value.get("content")))
+        if isinstance(value.get("message"), dict):
+            fragments.extend(_collect_handoff_text_fragments(value.get("message")))
+        if isinstance(value.get("payload"), dict):
+            fragments.extend(_collect_handoff_text_fragments(value.get("payload")))
+    return fragments
+
+
+def _jsonl_record_to_handoff_text(record):
+    if not isinstance(record, dict):
+        return None
+    message = record.get("message") if isinstance(record.get("message"), dict) else {}
+    role = (
+        message.get("role")
+        or record.get("role")
+        or record.get("type")
+        or record.get("sender")
+        or "entry"
+    )
+    text_sources = []
+    for key in ("content", "text", "payload"):
+        if key in record:
+            text_sources.append(record.get(key))
+    for key in ("content", "text"):
+        if key in message:
+            text_sources.append(message.get(key))
+    fragments = []
+    for value in text_sources:
+        fragments.extend(_collect_handoff_text_fragments(value))
+    text = "\n".join(fragment for fragment in fragments if fragment).strip()
+    if not text:
+        return None
+    role = re.sub(r"[^A-Za-z0-9_-]+", "-", str(role).strip()).strip("-") or "entry"
+    return f"[{role}]\n{text}"
+
+
+def _read_jsonl_handoff_transcript(path):
+    entries = []
+    with open(path, encoding="utf-8", errors="replace") as handle:
+        for line in handle:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                text = _jsonl_record_to_handoff_text(json.loads(line))
+            except json.JSONDecodeError:
+                text = None
+            if text:
+                entries.append(text)
+    if entries:
+        return "\n\n".join(entries)
+    with open(path, encoding="utf-8", errors="replace") as handle:
+        return handle.read()
+
+
+def _read_handoff_transcript(path):
+    if path.endswith(".jsonl"):
+        content = _read_jsonl_handoff_transcript(path)
+    else:
+        with open(path, encoding="utf-8", errors="replace") as handle:
+            # `script`-captured PTY transcript: strip ANSI/control noise before
+            # the char-budget truncation so the tail holds real text, not escapes.
+            content = _normalize_terminal_transcript(handle.read())
+    if len(content) <= HANDOFF_TRANSCRIPT_CHARS:
+        return content, False
+    return content[-HANDOFF_TRANSCRIPT_CHARS:], True
+
+
+def _build_handoff_context(source, target, transcript_path, transcript, truncated=False):
+    truncation_note = (
+        "Only the tail of the previous transcript is included because the log was large."
+        if truncated else
+        "The previous transcript is included below."
+    )
+    return "\n".join([
+        "# Shared Context",
+        "",
+        "## Goal",
+        f"Resume the work from `{source['name']}` in `{target['name']}` because the source account has no usage left.",
+        "",
+        "## Current State",
+        f"- Source session: `{source['name']}` ({source['provider']})",
+        f"- Target session: `{target['name']}` ({target['provider']})",
+        f"- Transcript source: `{transcript_path}`",
+        f"- {truncation_note}",
+        "",
+        "## Previous Session Transcript",
+        transcript.rstrip(),
+        "",
+        "## Next Steps",
+        "- Read the transcript above.",
+        "- Continue the task from the latest actionable state.",
+        "- Preserve the target account authentication; do not copy source credentials.",
+    ])
+
+
+def _handoff_launch_prompt(session, install=None):
+    if session.get("provider") == PROVIDER_CODEX:
+        context_ref = "$CODEX_HOME/shared-context.md"
+    else:
+        context_ref = (install or {}).get("target_path") or os.path.join(
+            session.get("authHome") or session.get("sessionRoot") or "~",
+            "shared-context.md",
+        )
+    return (
+        f"Read {context_ref} first, then resume the previous session "
+        "from the latest actionable state. Do not ask me to paste the context again."
+    )

package/src/cli_render.py

@@ -3,7 +3,6 @@ import re
 import sys
 from datetime import datetime, timezone
 
-
 ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
 
 

package/src/cli_view.py

@@ -1,5 +1,4 @@
-import json
-
+from .cli_helpers import _json_success, _write_json
 from .cli_render import _warn
 from .errors import CdxError
 from .logics_view import (
@@ -11,25 +10,7 @@ from .logics_view import (
 )
 from .update_check import check_logics_manager_for_update
 
-
 VIEW_USAGE = "Usage: cdx view [--json] [--lan] [--lan-rw] [--focus <ref>] [--read] [--port <port>] [--host <host>] [--refresh-interval <s>] [--tls] [--open] [--no-open]"
-API_SCHEMA_VERSION = 1
-
-
-def _json_success(action, message, warnings=None, **extra):
-    payload = {
-        "schema_version": API_SCHEMA_VERSION,
-        "ok": True,
-        "action": action,
-        "message": message,
-        "warnings": warnings or [],
-    }
-    payload.update(extra)
-    return payload
-
-
-def _write_json(ctx, payload):
-    ctx["out"](f"{json.dumps(payload, indent=2)}\n")
 
 
 def _update_notice_warnings(notices):

package/src/context_store.py

@@ -7,7 +7,6 @@ from datetime import datetime
 from .errors import CdxError
 from .session_store import _ensure_dir
 
-
 DEFAULT_CONTEXT_TEMPLATE = """# Shared Context
 
 ## Goal
@@ -49,7 +48,7 @@ def get_context_meta_path(base_dir, cwd=None):
 def read_context(base_dir, cwd=None):
     path = get_context_path(base_dir, cwd)
     try:
-        with open(path, "r", encoding="utf-8") as handle:
+        with open(path, encoding="utf-8") as handle:
             return handle.read()
     except FileNotFoundError:
         return ""

package/src/logics_view.py

@@ -2,7 +2,6 @@ import os
 import shutil
 import subprocess
 
-
 LOGICS_MANAGER_INSTALL_HINT = "Install or update it with: npm install -g @grifhinz/logics-manager"
 
 

package/src/notify.py

@@ -13,7 +13,6 @@ from .status_view import (
     _recommend_priority_sessions,
 )
 
-
 NOTIFY_USAGE = "Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--schedule] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--schedule] [--refresh]"
 
 

package/src/provider_runtime.py

@@ -1,20 +1,19 @@
 import json
 import os
 import re
-import signal
 import shlex
 import shutil
+import signal
 import subprocess
 import sys
 import uuid
-import base64
 from datetime import datetime, timezone
 
+from .claude_usage import _clean_oauth_token, _decode_jwt_claims
 from .codex_usage import codex_auth_lock
 from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
 from .errors import CdxError
 
-
 LOG_ROTATE_BYTES = 10 * 1024 * 1024  # 10 MB
 REASONING_EFFORT_VALUES = {"minimal", "low", "medium", "high", "xhigh"}
 RTK_PROMPT = (
@@ -90,15 +89,6 @@ def _anthropic_credentials_path(auth_home):
     return os.path.join(auth_home, "credentials", f"{_anthropic_profile_name()}.json")
 
 
-def _clean_oauth_token(token):
-    if not token:
-        return None
-    text = re.sub(r"\x1b\[[0-9;?]*[ -/]*[@-~]", "", str(token)).strip()
-    if not text or text.startswith("<") or any(ord(ch) < 32 or ord(ch) == 127 for ch in text):
-        return None
-    return text
-
-
 def _claude_env(base_env, auth_home):
     env = {**base_env, **_home_env_overrides(auth_home)}
     env.pop("CLAUDE_CONFIG_DIR", None)
@@ -109,7 +99,7 @@ def _claude_env(base_env, auth_home):
 
 def _read_anthropic_oauth_token(auth_home):
     try:
-        with open(_anthropic_credentials_path(auth_home), "r", encoding="utf-8") as handle:
+        with open(_anthropic_credentials_path(auth_home), encoding="utf-8") as handle:
             credentials = json.load(handle)
     except (FileNotFoundError, OSError, json.JSONDecodeError):
         return None
@@ -119,7 +109,7 @@ def _read_anthropic_oauth_token(auth_home):
 
 def _has_local_claude_auth(auth_home):
     try:
-        with open(os.path.join(auth_home, ".claude", ".credentials.json"), "r", encoding="utf-8") as handle:
+        with open(os.path.join(auth_home, ".claude", ".credentials.json"), encoding="utf-8") as handle:
             credentials = json.load(handle)
     except (FileNotFoundError, OSError, json.JSONDecodeError):
         return False
@@ -135,7 +125,7 @@ def _read_claude_launch_oauth_token(auth_home):
 
 def _has_local_codex_auth(auth_home):
     try:
-        with open(os.path.join(auth_home, "auth.json"), "r", encoding="utf-8") as handle:
+        with open(os.path.join(auth_home, "auth.json"), encoding="utf-8") as handle:
             auth = json.load(handle)
     except (FileNotFoundError, OSError, json.JSONDecodeError):
         return False
@@ -150,23 +140,9 @@ def _has_local_codex_auth(auth_home):
     )
 
 
-def _decode_jwt_claims(token):
-    if not token or "." not in str(token):
-        return {}
-    parts = str(token).split(".")
-    if len(parts) < 2:
-        return {}
-    padding = "=" * (-len(parts[1]) % 4)
-    try:
-        decoded = base64.urlsafe_b64decode(parts[1] + padding)
-        return json.loads(decoded.decode("utf-8"))
-    except (ValueError, json.JSONDecodeError, UnicodeDecodeError):
-        return {}
-
-
 def _read_codex_account_email(auth_home):
     try:
-        with open(os.path.join(auth_home, "auth.json"), "r", encoding="utf-8") as handle:
+        with open(os.path.join(auth_home, "auth.json"), encoding="utf-8") as handle:
             auth = json.load(handle)
     except (FileNotFoundError, OSError, json.JSONDecodeError):
         return None
@@ -211,7 +187,7 @@ def codex_auth_diagnostic(session, spawn_sync=None, env_override=None):
 def _read_claude_account_email(auth_home):
     config_path = os.path.join(auth_home, ".claude.json")
     try:
-        with open(config_path, "r", encoding="utf-8") as handle:
+        with open(config_path, encoding="utf-8") as handle:
             config = json.load(handle)
     except (FileNotFoundError, OSError, json.JSONDecodeError):
         return None
@@ -685,7 +661,7 @@ def _combine_headless_transcript(paths):
                 continue
             transcript.write(f"--- {label} ---\n")
             try:
-                with open(path, "r", encoding="utf-8", errors="replace") as handle:
+                with open(path, encoding="utf-8", errors="replace") as handle:
                     content = handle.read()
             except OSError:
                 content = ""
@@ -907,7 +883,7 @@ def _probe_provider_auth(session, spawn_sync=None, env_override=None, trust_loca
             stderr = result.get("stderr") if isinstance(result, dict) else getattr(result, "stderr", "")
             output = (stdout or "") + (stderr or "")
     except FileNotFoundError as error:
-        raise _format_probe_failure(session, spec, error)
+        raise _format_probe_failure(session, spec, error) from error
     return spec["parser"](output)
 
 

package/src/run_command.py

@@ -8,7 +8,7 @@ def read_run_prompt(parsed):
     if parsed.get("prompt") is not None:
         return parsed["prompt"]
     try:
-        with open(parsed["prompt_file"], "r", encoding="utf-8") as handle:
+        with open(parsed["prompt_file"], encoding="utf-8") as handle:
             return handle.read()
     except OSError as error:
         raise CdxError(f"Unable to read prompt file: {parsed['prompt_file']}") from error

package/src/run_registry.py

@@ -14,7 +14,7 @@ def registry_path(base_dir):
 
 def _read_registry(path):
     try:
-        with open(path, "r", encoding="utf-8") as handle:
+        with open(path, encoding="utf-8") as handle:
             data = json.load(handle)
     except FileNotFoundError:
         return {"schema_version": 1, "runs": []}
@@ -158,7 +158,7 @@ def read_text_file(path, limit=120000):
     if not path:
         return ""
     try:
-        with open(path, "r", encoding="utf-8", errors="replace") as handle:
+        with open(path, encoding="utf-8", errors="replace") as handle:
             return handle.read(limit)
     except OSError:
         return ""

package/src/run_usage.py

@@ -1,6 +1,5 @@
 import json
 
-
 USAGE_KEYS = ("input_tokens", "output_tokens", "reasoning_tokens", "total_tokens")
 SUPPORTED_PROVIDERS = {"claude", "codex"}
 
@@ -15,7 +14,7 @@ def extract_run_usage(provider, stdout_path):
     if provider not in SUPPORTED_PROVIDERS:
         return empty_usage()
     try:
-        with open(stdout_path, "r", encoding="utf-8", errors="replace") as handle:
+        with open(stdout_path, encoding="utf-8", errors="replace") as handle:
             text = handle.read()
     except OSError:
         return empty_usage()

package/src/session_service.py

@@ -1,7 +1,7 @@
+import base64
+import json
 import os
 import shutil
-import json
-import base64
 import sys
 import tempfile
 import uuid
@@ -10,8 +10,9 @@ from datetime import datetime, timezone
 from urllib.parse import quote
 
 from .backup_bundle import decode_bundle, encode_bundle
-from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDERS, get_cdx_home
+from .claude_usage import _decode_jwt_claims
 from .codex_usage import fetch_codex_rate_limits
+from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDERS, get_cdx_home
 from .errors import CdxError
 from .fs_utils import remove_tree
 from .session_store import create_session_store
@@ -389,25 +390,10 @@ def _is_low_confidence_status_source(status):
     return "/sessions/" in source_ref and "/rollout" in source_ref
 
 
-def _decode_jwt_claims(token):
-    if not token or "." not in str(token):
-        return {}
-    parts = str(token).split(".")
-    if len(parts) < 2:
-        return {}
-    payload = parts[1]
-    padding = "=" * (-len(payload) % 4)
-    try:
-        decoded = base64.urlsafe_b64decode(payload + padding)
-        return json.loads(decoded.decode("utf-8"))
-    except (ValueError, json.JSONDecodeError, UnicodeDecodeError):
-        return {}
-
-
 def _read_expected_account_email(auth_home):
     auth_path = os.path.join(auth_home, "auth.json")
     try:
-        with open(auth_path, "r", encoding="utf-8") as handle:
+        with open(auth_path, encoding="utf-8") as handle:
             auth = json.load(handle)
     except (FileNotFoundError, OSError, json.JSONDecodeError):
         return None
@@ -429,7 +415,7 @@ def _ensure_claude_attribution_disabled(auth_home):
     settings_path = os.path.join(settings_dir, "settings.json")
     try:
         os.makedirs(settings_dir, exist_ok=True)
-        with open(settings_path, "r", encoding="utf-8") as handle:
+        with open(settings_path, encoding="utf-8") as handle:
             settings = json.load(handle)
     except FileNotFoundError:
         settings = {}