@wangxt0223/codex-switcher 0.5.0 → 0.6.0

package/plugins/codex-switcher/scripts/profile-metrics.py

@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+import argparse
+import base64
+import datetime as dt
+import json
+import os
+import subprocess
+import sys
+import time
+from typing import Any, Dict, Optional
+
+
+USAGE_ENDPOINT = "https://chatgpt.com/backend-api/wham/usage"
+DASH = "-"
+KNOWN_PLANS = {"free", "plus", "pro", "team", "business", "enterprise", "edu"}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Collect account usage metrics for codex-switcher list output.")
+    parser.add_argument("--account-name", required=True)
+    parser.add_argument("--auth-file", required=True)
+    parser.add_argument("--data-path", required=True)
+    parser.add_argument("--timeout-seconds", type=int, default=4)
+    return parser.parse_args()
+
+
+def clamp_percent(value: float) -> int:
+    return int(round(max(0.0, min(100.0, value))))
+
+
+def sanitize_field(value: str) -> str:
+    return value.replace("\t", " ").replace("\n", " ").strip()
+
+
+def decode_jwt_payload(token: str) -> Dict[str, Any]:
+    if not token or "." not in token:
+        return {}
+    parts = token.split(".")
+    if len(parts) < 2:
+        return {}
+    payload = parts[1]
+    padding = "=" * ((4 - len(payload) % 4) % 4)
+    try:
+        raw = base64.urlsafe_b64decode(payload + padding)
+        decoded = json.loads(raw.decode("utf-8"))
+        if isinstance(decoded, dict):
+            return decoded
+    except Exception:
+        return {}
+    return {}
+
+
+def parse_timestamp(value: Any) -> Optional[int]:
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        timestamp = int(value)
+        if timestamp > 10_000_000_000:
+            timestamp = int(timestamp / 1000)
+        return timestamp
+    if isinstance(value, str):
+        s = value.strip()
+        if not s:
+            return None
+        if s.isdigit():
+            return parse_timestamp(int(s))
+        if s.endswith("Z"):
+            s = s[:-1] + "+00:00"
+        try:
+            parsed = dt.datetime.fromisoformat(s)
+            return int(parsed.timestamp())
+        except Exception:
+            return None
+    return None
+
+
+def normalize_plan(plan: Any) -> str:
+    if not isinstance(plan, str):
+        return "unknown"
+    value = plan.strip().lower()
+    if not value:
+        return "unknown"
+    if value in KNOWN_PLANS:
+        return value
+    if value.startswith("chatgpt_"):
+        trimmed = value[len("chatgpt_") :]
+        if trimmed in KNOWN_PLANS:
+            return trimmed
+    return "unknown"
+
+
+def load_json(path: str) -> Dict[str, Any]:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            obj = json.load(f)
+        if isinstance(obj, dict):
+            return obj
+    except Exception:
+        return {}
+    return {}
+
+
+def parse_window(window: Any) -> Optional[Dict[str, Any]]:
+    if not isinstance(window, dict):
+        return None
+
+    used = window.get("used_percent")
+    if not isinstance(used, (int, float)):
+        return None
+
+    minutes = window.get("window_minutes")
+    if not isinstance(minutes, (int, float)):
+        seconds = window.get("limit_window_seconds")
+        if isinstance(seconds, (int, float)) and seconds > 0:
+            minutes = int(round(float(seconds) / 60.0))
+    if not isinstance(minutes, (int, float)):
+        return None
+
+    reset_epoch = parse_timestamp(
+        window.get("resets_at")
+        if "resets_at" in window
+        else window.get("reset_at")
+    )
+    return {
+        "minutes": int(minutes),
+        "remaining_percent": 100.0 - float(used),
+        "reset_epoch": reset_epoch,
+    }
+
+
+def pick_window(windows: Dict[int, Dict[str, Any]], target: int) -> Optional[Dict[str, Any]]:
+    if target in windows:
+        return windows[target]
+    if not windows:
+        return None
+    nearest = min(windows.keys(), key=lambda m: abs(m - target))
+    if target == 300 and abs(nearest - target) <= 30:
+        return windows[nearest]
+    if target == 10080 and abs(nearest - target) <= 720:
+        return windows[nearest]
+    return None
+
+
+def extract_windows_from_usage_blob(blob: Dict[str, Any]) -> Dict[int, Dict[str, Any]]:
+    windows: Dict[int, Dict[str, Any]] = {}
+    candidates = []
+    for key in ("rate_limit", "rate_limits"):
+        value = blob.get(key)
+        if isinstance(value, dict):
+            candidates.append(value)
+    candidates.append(blob)
+
+    for container in candidates:
+        for key in ("primary_window", "secondary_window", "primary", "secondary"):
+            parsed = parse_window(container.get(key))
+            if parsed:
+                windows[parsed["minutes"]] = parsed
+        if isinstance(container.get("windows"), list):
+            for item in container["windows"]:
+                parsed = parse_window(item)
+                if parsed:
+                    windows[parsed["minutes"]] = parsed
+    return windows
+
+
+def request_usage(access_token: str, timeout_seconds: int) -> Optional[Dict[str, Any]]:
+    if not access_token:
+        return None
+    cmd = [
+        "curl",
+        "-fsS",
+        "--connect-timeout",
+        str(max(1, timeout_seconds)),
+        "--max-time",
+        str(max(2, timeout_seconds + 2)),
+        "-H",
+        f"Authorization: Bearer {access_token}",
+        USAGE_ENDPOINT,
+    ]
+    try:
+        result = subprocess.run(
+            cmd,
+            check=False,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+    except Exception:
+        return None
+    if result.returncode != 0 or not result.stdout.strip():
+        return None
+    try:
+        payload = json.loads(result.stdout)
+        if isinstance(payload, dict):
+            return payload
+    except Exception:
+        return None
+    return None
+
+
+def format_usage(window: Optional[Dict[str, Any]]) -> str:
+    if not window:
+        return DASH
+    percent = clamp_percent(float(window["remaining_percent"]))
+    reset_epoch = window.get("reset_epoch")
+    if isinstance(reset_epoch, int):
+        reset_text = dt.datetime.fromtimestamp(reset_epoch).strftime("%H:%M")
+        return f"{percent}% ({reset_text})"
+    return f"{percent}%"
+
+
+def format_relative(last_epoch: Optional[int], now_epoch: int) -> str:
+    if not isinstance(last_epoch, int):
+        return DASH
+    delta = max(0, now_epoch - last_epoch)
+    if delta < 60:
+        return "just now"
+    if delta < 3600:
+        return f"{delta // 60}m ago"
+    if delta < 86400:
+        return f"{delta // 3600}h ago"
+    return f"{delta // 86400}d ago"
+
+
+def collect_local_metrics(data_path: str) -> Dict[str, Any]:
+    sessions_dir = os.path.join(data_path, "sessions")
+    if not os.path.isdir(sessions_dir):
+        return {"source": "local"}
+
+    best: Optional[Dict[str, Any]] = None
+    for root, _, files in os.walk(sessions_dir):
+        for file_name in files:
+            if not file_name.endswith(".jsonl"):
+                continue
+            file_path = os.path.join(root, file_name)
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    for line in f:
+                        if '"rate_limits"' not in line:
+                            continue
+                        obj = json.loads(line)
+                        if not isinstance(obj, dict):
+                            continue
+                        payload = obj.get("payload")
+                        if not isinstance(payload, dict):
+                            continue
+                        rate_limits = payload.get("rate_limits")
+                        if not isinstance(rate_limits, dict):
+                            continue
+
+                        windows = extract_windows_from_usage_blob({"rate_limits": rate_limits})
+                        if not windows:
+                            continue
+
+                        timestamp = parse_timestamp(obj.get("timestamp")) or parse_timestamp(payload.get("timestamp"))
+                        plan = normalize_plan(rate_limits.get("plan_type"))
+                        candidate = {
+                            "windows": windows,
+                            "plan_type": plan,
+                            "last_activity_epoch": timestamp,
+                            "source": "local",
+                        }
+                        if best is None:
+                            best = candidate
+                        else:
+                            prev_ts = best.get("last_activity_epoch")
+                            if isinstance(timestamp, int) and (not isinstance(prev_ts, int) or timestamp > prev_ts):
+                                best = candidate
+            except Exception:
+                continue
+
+    if best:
+        return best
+    return {"source": "local"}
+
+
+def collect_api_metrics(access_token: str, timeout_seconds: int) -> Optional[Dict[str, Any]]:
+    payload = request_usage(access_token, timeout_seconds)
+    if not payload:
+        return None
+
+    windows = extract_windows_from_usage_blob(payload)
+    nested_plan = None
+    for key in ("rate_limit", "rate_limits"):
+        value = payload.get(key)
+        if isinstance(value, dict):
+            nested_plan = value.get("plan_type")
+            if nested_plan:
+                break
+    plan_type = normalize_plan(payload.get("plan_type") or nested_plan)
+    last_activity = parse_timestamp(
+        payload.get("last_activity_at")
+        or payload.get("last_activity")
+        or payload.get("updated_at")
+        or payload.get("timestamp")
+    )
+
+    if not windows and plan_type == "unknown" and last_activity is None:
+        return None
+    return {
+        "windows": windows,
+        "plan_type": plan_type,
+        "last_activity_epoch": last_activity,
+        "source": "api",
+    }
+
+
+def main() -> int:
+    args = parse_args()
+    now_epoch = int(time.time())
+    auth_data = load_json(args.auth_file)
+    tokens = auth_data.get("tokens")
+    if not isinstance(tokens, dict):
+        tokens = {}
+
+    access_token = tokens.get("access_token")
+    if not isinstance(access_token, str):
+        access_token = ""
+    id_token = tokens.get("id_token")
+    if not isinstance(id_token, str):
+        id_token = ""
+
+    claims = decode_jwt_payload(id_token)
+    email = claims.get("email")
+    if not isinstance(email, str):
+        email = ""
+
+    plan_from_claims = normalize_plan(claims.get("chatgpt_plan_type") or claims.get("plan_type"))
+    if plan_from_claims == "unknown":
+        plan_from_claims = normalize_plan(auth_data.get("chatgpt_plan_type") or auth_data.get("plan_type"))
+
+    api_metrics = collect_api_metrics(access_token, args.timeout_seconds)
+    metrics = api_metrics if api_metrics is not None else collect_local_metrics(args.data_path)
+
+    windows = metrics.get("windows")
+    if not isinstance(windows, dict):
+        windows = {}
+    window_5h = pick_window(windows, 300)
+    window_week = pick_window(windows, 10080)
+
+    usage_5h = format_usage(window_5h)
+    usage_weekly = format_usage(window_week)
+    plan = normalize_plan(metrics.get("plan_type"))
+    if plan == "unknown":
+        plan = plan_from_claims
+    if plan == "unknown":
+        plan = "unknown"
+
+    source = metrics.get("source")
+    if source not in ("api", "local"):
+        source = "local"
+
+    last_activity_epoch = metrics.get("last_activity_epoch")
+    if not isinstance(last_activity_epoch, int):
+        last_activity_epoch = None
+    last_activity = format_relative(last_activity_epoch, now_epoch)
+
+    if email:
+        display_email = f"({args.account_name}){email}"
+    else:
+        display_email = f"({args.account_name})-"
+
+    out_fields = [
+        display_email,
+        plan,
+        usage_5h,
+        usage_weekly,
+        last_activity,
+        source,
+    ]
+    print("\t".join(sanitize_field(str(x)) for x in out_fields))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/plugins/codex-switcher/scripts/test-switcher.sh

@@ -8,9 +8,10 @@ bash -n "$SW"
 
 TMPBASE="$(mktemp -d /tmp/codex-switcher-test.XXXXXX)"
 STATE="$TMPBASE/state"
-PROFILES="$TMPBASE/profiles"
+ENVS="$TMPBASE/envs"
+DEFAULT_HOME="$TMPBASE/default-home"
 BIN="$TMPBASE/bin"
-mkdir -p "$BIN"
+mkdir -p "$BIN" "$DEFAULT_HOME"
 
 cleanup() {
   pkill -f "$BIN/fake-codex-app" >/dev/null 2>&1 || true
@@ -32,7 +33,7 @@ if [[ "${1:-}" == "login" && "${2:-}" == "status" ]]; then
 fi
 if [[ "${1:-}" == "login" ]]; then
   mkdir -p "$CODEX_HOME"
-  echo '{"auth_mode":"api_key"}' > "$CODEX_HOME/auth.json"
+  echo '{"auth_mode":"chatgpt","tokens":{"access_token":"fake-access","id_token":"fake.jwt.sig"}}' > "$CODEX_HOME/auth.json"
   exit 0
 fi
 if [[ "${1:-}" == "logout" ]]; then
@@ -58,112 +59,127 @@ exit 0
 NPM
 chmod +x "$BIN/npm"
 
+cat > "$BIN/curl" <<'CURL'
+#!/usr/bin/env bash
+set -euo pipefail
+mode="${CODEX_SWITCHER_TEST_CURL_MODE:-success}"
+if [[ "$mode" == "success" ]]; then
+  cat <<'JSON'
+{"rate_limit":{"plan_type":"plus","primary_window":{"used_percent":40,"limit_window_seconds":18000,"reset_at":"2099-01-01T06:30:00Z"},"secondary_window":{"used_percent":20,"limit_window_seconds":604800,"reset_at":"2099-01-03T08:00:00Z"}},"last_activity_at":"2099-01-01T04:30:00Z"}
+JSON
+  exit 0
+fi
+echo "simulated curl failure" >&2
+exit 22
+CURL
+chmod +x "$BIN/curl"
+
 export PATH="$BIN:$PATH"
 export CODEX_SWITCHER_STATE_DIR="$STATE"
-export CODEX_SWITCHER_PROFILES_DIR="$PROFILES"
+export CODEX_SWITCHER_ENVS_DIR="$ENVS"
+export CODEX_SWITCHER_ACCOUNTS_DIR="$STATE/env-accounts"
 export CODEX_SWITCHER_APP_BIN="$BIN/fake-codex-app"
 export CODEX_SWITCHER_LOCK_WAIT_SECONDS=2
-export CODEX_SWITCHER_DEFAULT_HOME="$TMPBASE/default-home"
+export CODEX_SWITCHER_DEFAULT_HOME="$DEFAULT_HOME"
 export CODEX_SWITCHER_TEST_NPM_LOG="$TMPBASE/npm-args.log"
 export CODEX_SWITCHER_TEST_CODEX_LOG="$TMPBASE/codex-args.log"
+export CODEX_SWITCHER_TEST_CURL_MODE="success"
 : > "$CODEX_SWITCHER_TEST_CODEX_LOG"
 
-mkdir -p "$CODEX_SWITCHER_DEFAULT_HOME/memories"
-echo '{"auth_mode":"chatgpt"}' > "$CODEX_SWITCHER_DEFAULT_HOME/auth.json"
-echo '{"projects":["demo"]}' > "$CODEX_SWITCHER_DEFAULT_HOME/state_5.sqlite"
-echo '{"memo":"persist"}' > "$CODEX_SWITCHER_DEFAULT_HOME/memories/demo.json"
+echo '{"memo":"persist"}' > "$DEFAULT_HOME/shared.json"
 
 check_out="$("$SW" check)"
+echo "$check_out" | grep -Eq '^version: [0-9]+\.[0-9]+\.[0-9]+$'
 echo "$check_out" | grep -q "check: ok"
 init_out="$("$SW" init --dry-run)"
 echo "$init_out" | grep -q "\[dry-run\]"
 "$SW" upgrade
 grep -q "i -g @wangxt0223/codex-switcher@latest --registry https://registry.npmjs.org/" "$CODEX_SWITCHER_TEST_NPM_LOG"
 
-"$SW" add work
-"$SW" add personal
-codex_calls_before="$(wc -l < "$CODEX_SWITCHER_TEST_CODEX_LOG" 2>/dev/null || echo 0)"
-"$SW" use personal --no-launch
-codex_calls_after="$(wc -l < "$CODEX_SWITCHER_TEST_CODEX_LOG" 2>/dev/null || echo 0)"
-[[ "$codex_calls_before" -eq "$codex_calls_after" ]]
-[[ "$("$SW" current cli)" == "personal" ]]
-
-"$SW" use personal -- --version
-grep -Fq "$PROFILES/personal|--version" "$CODEX_SWITCHER_TEST_CODEX_LOG"
-
-set +e
-"$SW" use personal --no-launch -- --version >/tmp/codex_sw_use_no_launch_conflict 2>&1
-use_no_launch_conflict_rc=$?
-set -e
-[[ "$use_no_launch_conflict_rc" -ne 0 ]]
-grep -q "cannot pass codex args with --no-launch" /tmp/codex_sw_use_no_launch_conflict
-
-"$SW" login personal
-"$SW" login sync-login --sync
-[[ -f "$PROFILES/sync-login/state_5.sqlite" ]]
-[[ -f "$PROFILES/sync-login/memories/demo.json" ]]
-[[ -f "$PROFILES/sync-login/auth.json" ]]
-
-echo '{"auth_mode":"api_key","owner":"personal"}' > "$PROFILES/personal/auth.json"
-echo '{"auth_mode":"api_key","owner":"work"}' > "$PROFILES/work/auth.json"
-echo "from-personal-newer" > "$PROFILES/personal/history.jsonl"
-echo "from-work-older-baseline" > "$PROFILES/work/history.jsonl"
-"$SW" switch work --sync
-[[ "$("$SW" current cli)" == "work" ]]
-grep -q "from-personal-newer" "$PROFILES/work/history.jsonl"
-grep -q '"owner":"work"' "$PROFILES/work/auth.json"
-grep -q '"owner":"personal"' "$PROFILES/personal/auth.json"
-
-"$SW" import-default imported
-[[ -f "$PROFILES/imported/state_5.sqlite" ]]
-[[ -f "$PROFILES/imported/memories/demo.json" ]]
-[[ ! -f "$PROFILES/imported/auth.json" ]]
-set +e
-CODEX_HOME="$PROFILES/imported" codex login status >/tmp/codex_sw_imported_login 2>&1
-imported_login_rc=$?
-set -e
-[[ "$imported_login_rc" -ne 0 ]]
-
-"$SW" import-default imported-auth --with-auth
-[[ -f "$PROFILES/imported-auth/auth.json" ]]
-CODEX_HOME="$PROFILES/imported-auth" codex login status >/tmp/codex_sw_imported_auth_login 2>&1
-[[ "$?" -eq 0 ]]
-
-"$SW" logout work
-
-set +e
-"$SW" app open ghost >/tmp/codex_sw_app_open_missing 2>&1
-app_open_missing_rc=$?
-set -e
-[[ "$app_open_missing_rc" -ne 0 ]]
-grep -q "profile 'ghost' not found" /tmp/codex_sw_app_open_missing
-
-set +e
-"$SW" app use work >/tmp/codex_sw_app_use_unauthed 2>&1
-app_use_unauthed_rc=$?
-set -e
-[[ "$app_use_unauthed_rc" -ne 0 ]]
-grep -q "profile 'work' is not logged in" /tmp/codex_sw_app_use_unauthed
+[[ "$("$SW" env current cli)" == "default" ]]
+"$SW" account login personal --env default
+"$SW" account login work --env default
+
+make_id_token() {
+  python3 - "$1" "$2" <<'PY'
+import base64, json, sys
+email = sys.argv[1]
+plan = sys.argv[2]
+header = base64.urlsafe_b64encode(json.dumps({"alg":"none","typ":"JWT"}, separators=(",", ":")).encode()).decode().rstrip("=")
+payload = base64.urlsafe_b64encode(json.dumps({"email":email,"chatgpt_plan_type":plan}, separators=(",", ":")).encode()).decode().rstrip("=")
+print(f"{header}.{payload}.sig")
+PY
+}
 
-"$SW" login work
+personal_id_token="$(make_id_token personal@example.com plus)"
+work_id_token="$(make_id_token work@example.com team)"
+
+cat > "$STATE/env-accounts/default/personal/auth.json" <<JSON
+{"auth_mode":"chatgpt","tokens":{"access_token":"token-personal","id_token":"$personal_id_token"}}
+JSON
+cat > "$STATE/env-accounts/default/work/auth.json" <<JSON
+{"auth_mode":"chatgpt","tokens":{"access_token":"token-work","id_token":"$work_id_token"}}
+JSON
+
+"$SW" account use personal --env default
+grep -q "token-personal" "$DEFAULT_HOME/auth.json"
+"$SW" account use work --env default
+grep -q "token-work" "$DEFAULT_HOME/auth.json"
+grep -q '{"memo":"persist"}' "$DEFAULT_HOME/shared.json"
+"$SW" account use personal --env default --sync
+grep -q '{"memo":"persist"}' "$DEFAULT_HOME/shared.json"
+
+"$SW" env create project --empty
+[[ -d "$ENVS/project/home" ]]
+echo '{"shared":"project"}' > "$ENVS/project/home/shared.json"
+
+corp_id_token="$(make_id_token corp@example.com business)"
+dev_id_token="$(make_id_token dev@example.com pro)"
+mkdir -p "$STATE/env-accounts/project/corp" "$STATE/env-accounts/project/dev"
+cat > "$STATE/env-accounts/project/corp/auth.json" <<JSON
+{"auth_mode":"chatgpt","tokens":{"access_token":"token-corp","id_token":"$corp_id_token"}}
+JSON
+cat > "$STATE/env-accounts/project/dev/auth.json" <<JSON
+{"auth_mode":"chatgpt","tokens":{"access_token":"token-dev","id_token":"$dev_id_token"}}
+JSON
+
+"$SW" account use corp --env project
+[[ "$("$SW" current cli)" == "project/corp" ]]
+grep -q "token-corp" "$ENVS/project/home/auth.json"
+"$SW" account use dev --env project
+[[ "$("$SW" current cli)" == "project/dev" ]]
+grep -q "token-dev" "$ENVS/project/home/auth.json"
+grep -q '{"shared":"project"}' "$ENVS/project/home/shared.json"
+
+"$SW" use corp --no-launch
+[[ "$("$SW" current cli)" == "project/corp" ]]
+
+"$SW" account use work --env default --target app
 "$SW" app use work
-[[ "$("$SW" app current)" == "work" ]]
-
-set +e
-"$SW" status >/tmp/codex_sw_status_1
-status_rc=$?
-set -e
-[[ "$status_rc" -eq 0 ]]
-grep -q "cli(work): logged-in" /tmp/codex_sw_status_1
-grep -q "app(work): logged-in" /tmp/codex_sw_status_1
-
-"$SW" logout work
-set +e
-"$SW" status >/tmp/codex_sw_status_2
-status_rc=$?
-set -e
-[[ "$status_rc" -eq 1 ]]
-grep -q "cli(work): not-logged-in" /tmp/codex_sw_status_2
+[[ "$("$SW" app current)" == "default/work" ]]
+
+"$SW" list >/tmp/codex_sw_list_api
+grep -q "ENV" /tmp/codex_sw_list_api
+grep -q "ACCOUNT" /tmp/codex_sw_list_api
+grep -q "EMAIL" /tmp/codex_sw_list_api
+grep -q "PLAN" /tmp/codex_sw_list_api
+grep -q "5H USAGE" /tmp/codex_sw_list_api
+grep -q "WEEKLY USAGE" /tmp/codex_sw_list_api
+grep -q "LAST ACTIVITY" /tmp/codex_sw_list_api
+grep -q "(personal)personal@example.com" /tmp/codex_sw_list_api
+grep -q "(api)" /tmp/codex_sw_list_api
+grep -q "60% (" /tmp/codex_sw_list_api
+grep -q "80% (" /tmp/codex_sw_list_api
+
+mkdir -p "$ENVS/project/home/sessions/2026/04/12"
+cat > "$ENVS/project/home/sessions/2026/04/12/rollout-test.jsonl" <<'JSONL'
+{"timestamp":"2026-04-12T09:00:00Z","type":"event_msg","payload":{"type":"token_count","rate_limits":{"plan_type":"business","primary":{"used_percent":25,"window_minutes":300,"resets_at":1776004200},"secondary":{"used_percent":70,"window_minutes":10080,"resets_at":1776519000}}}}
+JSONL
+export CODEX_SWITCHER_TEST_CURL_MODE="fail"
+"$SW" list >/tmp/codex_sw_list_local
+grep -q "(local)" /tmp/codex_sw_list_local
+grep -q "75% (" /tmp/codex_sw_list_local
+grep -q "30% (" /tmp/codex_sw_list_local
 
 "$SW" app status >/tmp/codex_sw_app_status_1
 [[ "$?" -eq 0 ]]
@@ -176,24 +192,7 @@ app_status_rc=$?
 set -e
 [[ "$app_status_rc" -eq 1 ]]
 
-printf '***bad***\n' > "$STATE/current_cli"
-set +e
-"$SW" status >/tmp/codex_sw_status_3
-status_rc=$?
-set -e
-[[ "$status_rc" -eq 2 ]]
-
-"$SW" recover
-validate_cli="$("$SW" current cli)"
-[[ -n "$validate_cli" ]]
-
 doctor_out="$("$SW" doctor --fix)"
 echo "$doctor_out" | grep -q "doctor --fix: completed"
-check_out="$("$SW" check)"
-echo "$check_out" | grep -q "check: ok"
-
-"$SW" remove work --force
-"$SW" list >/tmp/codex_sw_list
-grep -q "personal" /tmp/codex_sw_list
 
 echo "smoke-test: ok"