claude-multiacc 2.0.43 → 2.0.45

package/tests/test_claude_token_identity.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""Organization binding uses fake tokens and a loopback Messages endpoint only."""
+
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+from functools import partial
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+import hashlib
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import threading
+import unittest
+from unittest.mock import patch
+
+REPO = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(REPO / "lib"))
+import claude_token_identity as identity
+
+ORG = "11111111-2222-4333-8444-555555555555"
+OTHER = "99999999-8888-4777-8666-555555555555"
+TOKEN = "sk-ant-oat01-sandbox-token-a"
+SECOND = "sk-ant-oat01-sandbox-token-b"
+EMAIL = "sandbox@example.invalid"
+NOW = 1790292600
+
+
+class IdentityHandler(BaseHTTPRequestHandler):
+    def do_POST(self):
+        state = self.server.state
+        size = int(self.headers.get("Content-Length", 0))
+        state["requests"].append({"path": self.path, "body": self.rfile.read(size).decode(),
+                                  "headers": dict(self.headers), "method": self.command})
+        code, org = state["code"], state.get("org")
+        if state.get("serialize_test"):
+            if len(state["requests"]) == 1:
+                state["first_seen"].set()
+                state["second_seen"].wait(0.2)
+                code, org = 429, OTHER
+            else:
+                state["second_seen"].set()
+                state["allow_second"].wait(2)
+                code, org = 200, None
+        self.send_response(code)
+        if org is not None:
+            self.send_header("anthropic-organization-id", org)
+        if state.get("location"):
+            self.send_header("Location", state["location"])
+        self.send_header("Content-Length", "0")
+        self.end_headers()
+
+    do_GET = do_POST
+
+    def log_message(self, _format, *_args):
+        pass
+
+
+class TokenIdentityTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory(prefix="multiacc-token-identity-")
+        self.account = Path(self.temp.name) / "acct-01"
+        self.account.mkdir()
+        (self.account / "server.token").write_text(TOKEN)
+        self.manifest = self.account.parent / "accounts.json"
+        self.manifest.write_text(json.dumps({"accounts": [{"id": "acct-01", "email": EMAIL}]}))
+        self.config = self.account / ".claude.json"
+        self.config.write_text(json.dumps({"oauthAccount": {"organizationUuid": ORG, "emailAddress": EMAIL}}))
+        self.server = ThreadingHTTPServer(("127.0.0.1", 0), IdentityHandler)
+        self.server.state = {"code": 200, "org": ORG, "requests": []}
+        self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
+        self.thread.start()
+        self.url = f"http://127.0.0.1:{self.server.server_port}/v1/messages?beta=true"
+        self.check = partial(identity.check_identity, self.account, endpoint=self.url, version="2.1.282")
+        self.env = patch.dict(os.environ, {"HOME": self.temp.name, "PATH": os.defpath}, clear=True)
+        self.env.start()
+
+    def tearDown(self):
+        self.env.stop()
+        self.server.shutdown()
+        self.server.server_close()
+        self.thread.join(timeout=5)
+        self.temp.cleanup()
+
+    def test_match_is_bound_and_legacy_auth_receipt_cannot_skip_probe(self):
+        (self.account / ".server-token-verified").write_text(hashlib.sha256(TOKEN.encode()).hexdigest())
+        result = self.check(now=NOW)
+        self.assertEqual(result["state"], "match")
+        self.assertFalse(result["cached"])
+        self.assertEqual(identity.cached_identity(self.account, now=NOW)["state"], "match")
+        self.assertTrue(self.check(now=NOW + 86400)["cached"])
+        requests = self.server.state["requests"]
+        self.assertEqual(len(requests), 1)
+        request = requests[0]
+        self.assertEqual(request["path"], "/v1/messages?beta=true")
+        self.assertEqual(json.loads(request["body"]), {
+            "model": identity.MODEL, "max_tokens": 1, "messages": [{"role": "user", "content": "quota"}]})
+        self.assertLess(len(request["body"]), 256)
+        headers = {k.lower(): v for k, v in request["headers"].items()}
+        self.assertEqual(headers["authorization"], "Bearer " + TOKEN)
+        self.assertIn("oauth-2025-04-20", headers["anthropic-beta"])
+        self.assertEqual(headers["user-agent"], "claude-cli/2.1.282 (external, cli, client-app/claude-multiacc)")
+        receipt = self.account / identity.RECEIPT
+        self.assertEqual(receipt.stat().st_mode & 0o777, 0o600)
+        self.assertNotIn(TOKEN, receipt.read_text())
+        self.assertNotIn(ORG, json.dumps(result))
+        self.assertEqual(json.loads(receipt.read_text())["expected_org"], ORG)
+
+    def test_quota_rejection_identifies_mismatch_and_persists(self):
+        self.config.write_text(json.dumps({"oauthAccount": {"organizationUuid": ORG, "emailAddress": EMAIL},
+                                           "projects": {"sandbox": {"history": "x" * 32768}}}))
+        self.assertGreater(self.config.stat().st_size, 16384)
+        self.server.state.update(code=429, org=OTHER)
+        with patch.object(identity.os, "replace", side_effect=PermissionError):
+            result = self.check(now=NOW, model="claude-opus-4-6")
+        self.assertEqual(result["state"], "mismatch")
+        self.assertFalse((self.account / identity.RECEIPT).exists())
+        headers = {k.lower(): v for k, v in self.server.state["requests"][0]["headers"].items()}
+        self.assertIn("claude-code-20250219", headers["anthropic-beta"])
+        with patch.object(identity.os, "open", side_effect=PermissionError):
+            self.assertEqual(self.check(now=NOW)["state"], "mismatch")
+        self.assertFalse((self.account / identity.RECEIPT).exists())
+        result = self.check(now=NOW)
+        self.assertEqual(result["state"], "mismatch")
+        self.assertEqual(result["http_status"], 429)
+        self.server.state.update(code=200, org=ORG)
+        self.assertEqual(self.check(now=NOW + 365 * 86400)["state"], "mismatch")
+        self.assertEqual(len(self.server.state["requests"]), 3)
+        stored = json.loads((self.account / identity.RECEIPT).read_text())
+        self.assertEqual(stored["actual_org"], OTHER)
+        self.assertNotIn(OTHER, json.dumps(result))
+        self.config.write_text("{}")
+        candidate = self.check(expected_email=EMAIL, persist=False, now=NOW)
+        self.assertEqual(candidate["state"], "mismatch")
+        self.assertTrue(candidate["cached"])
+        conflict = self.check(expected_email="different@example.invalid", persist=False, now=NOW)
+        self.assertEqual((conflict["state"], conflict["reason"]), ("mismatch", "profile_manifest_mismatch"))
+        self.assertEqual(len(self.server.state["requests"]), 3)
+
+    def test_token_and_expected_organization_changes_invalidate_cache(self):
+        self.assertEqual(self.check(now=NOW)["state"], "match")
+        receipt_before = (self.account / identity.RECEIPT).read_bytes()
+        self.server.state["org"] = OTHER
+        self.assertEqual(self.check(SECOND, now=NOW, persist=False)["state"], "mismatch")
+        self.assertEqual((self.account / identity.RECEIPT).read_bytes(), receipt_before)
+        self.assertEqual(identity.cached_identity(self.account, now=NOW)["state"], "match")
+        self.server.state["org"] = ORG
+        (self.account / "server.token").write_text(SECOND)
+        self.assertFalse(self.check(now=NOW + 1)["cached"])
+        self.config.write_text(json.dumps({"oauthAccount": {"organizationUuid": OTHER}}))
+        self.assertEqual(self.check(now=NOW + 2)["state"], "mismatch")
+        self.config.write_text(json.dumps({"oauthAccount": {"organizationUuid": ORG.upper()}}))
+        self.assertEqual(self.check(now=NOW + 3)["state"], "match")
+        self.assertEqual(len(self.server.state["requests"]), 5)
+        stored = json.loads((self.account / identity.RECEIPT).read_text())
+        self.assertEqual(stored["token_digest"], hashlib.sha256(SECOND.encode()).hexdigest())
+        self.config.write_text("{}")
+        self.assertEqual(identity.cached_identity(self.account, now=NOW + 4)["state"], "match")
+        self.assertTrue(self.check(now=NOW + 4)["cached"])
+        self.manifest.write_text(json.dumps({"accounts": [{"id": "acct-01", "email": "changed@example.invalid"}]}))
+        self.assertEqual(identity.cached_identity(self.account, now=NOW + 5)["state"], "unknown")
+        moved = self.account.parent / "acct-02"
+        self.account.rename(moved)
+        self.manifest.write_text(json.dumps({"accounts": [{"id": "acct-02", "email": EMAIL}]}))
+        self.assertEqual(identity.cached_identity(moved, now=NOW + 6)["state"], "unknown")
+        self.assertEqual(len(self.server.state["requests"]), 5)
+
+    def test_unknown_and_auth_failures_back_off_then_retry(self):
+        for code, org, reason in [(200, None, "missing_organization"), (401, None, "auth_failed"),
+                                  (403, None, "auth_failed"), (429, "bad-id", "missing_organization")]:
+            with self.subTest(code=code, org=org):
+                (self.account / identity.RECEIPT).unlink(missing_ok=True)
+                self.server.state.update(code=code, org=org)
+                result = self.check(now=NOW)
+                self.assertEqual((result["state"], result["reason"]), ("unknown", reason))
+                count = len(self.server.state["requests"])
+                self.server.state.update(code=200, org=ORG)
+                self.assertTrue(self.check(now=NOW + 59)["cached"])
+                self.assertEqual(len(self.server.state["requests"]), count)
+                self.assertEqual(self.check(now=NOW + 60)["state"], "match")
+        (self.account / identity.RECEIPT).unlink()
+        with patch.object(identity.urllib.request.OpenerDirector, "open", side_effect=TimeoutError) as opened:
+            result = self.check(now=NOW)
+        self.assertEqual((result["state"], result["reason"]), ("unknown", "request_failed"))
+        self.assertEqual(opened.call_count, 1)
+        self.assertEqual(opened.call_args.kwargs["timeout"], 10)
+        (self.account / identity.RECEIPT).unlink()
+        self.server.state.update(serialize_test=True, requests=[], first_seen=threading.Event(),
+                                 second_seen=threading.Event(), allow_second=threading.Event())
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            first = executor.submit(self.check, now=NOW)
+            self.assertTrue(self.server.state["first_seen"].wait(2))
+            second = executor.submit(self.check, now=NOW)
+            first_result = first.result(timeout=3)
+            self.server.state["allow_second"].set()
+            second_result = second.result(timeout=3)
+        self.assertEqual([first_result["state"], second_result["state"]], ["mismatch", "mismatch"])
+        self.assertEqual(len(self.server.state["requests"]), 1)
+        self.assertEqual(identity.cached_identity(self.account, now=NOW)["state"], "mismatch")
+
+    def test_redirects_never_forward_the_token(self):
+        for url in ("https://example.invalid/v1/messages", "http://[invalid"):
+            (self.account / identity.RECEIPT).unlink(missing_ok=True)
+            result = identity.check_identity(self.account, endpoint=url, now=NOW)
+            self.assertEqual((result["state"], result["reason"]), ("unknown", "invalid_endpoint"))
+        self.assertEqual(len(self.server.state["requests"]), 0)
+        for code in (301, 302, 303, 307, 308):
+            with self.subTest(code=code):
+                (self.account / identity.RECEIPT).unlink(missing_ok=True)
+                self.server.state.update(code=code, org=OTHER, location=self.url + "&redirected=1")
+                count = len(self.server.state["requests"])
+                result = self.check(now=NOW)
+                self.assertEqual((result["state"], result["reason"]), ("unknown", "redirect"))
+                self.assertEqual(len(self.server.state["requests"]), count + 1)
+
+    def test_cli_exact_stdin_and_missing_config_are_safe(self):
+        env = dict(os.environ, CLAUDE_MULTIACC_TOKEN_IDENTITY_URL=self.url,
+                   CLAUDE_MULTIACC_CLI_VERSION="2.1.282")
+        done = subprocess.run([sys.executable, str(REPO / "lib/claude_token_identity.py"),
+                               "check", str(self.account), "--token-stdin"],
+                              input=SECOND, text=True, capture_output=True, env=env, timeout=15)
+        self.assertEqual(done.returncode, 0, done.stderr)
+        result = json.loads(done.stdout)
+        self.assertEqual(result["state"], "match")
+        self.assertEqual(result["token_digest"], hashlib.sha256(SECOND.encode()).hexdigest())
+        self.assertNotIn(SECOND, done.stdout + done.stderr)
+        self.assertNotIn(ORG, done.stdout + done.stderr)
+        self.assertEqual(self.server.state["requests"][0]["headers"]["Authorization"], "Bearer " + SECOND)
+        cached = subprocess.run([sys.executable, str(REPO / "lib/claude_token_identity.py"),
+                                 "cached", str(self.account), "--token-stdin", "--format", "state"],
+                                input=SECOND, text=True, capture_output=True, env=env, timeout=15)
+        self.assertEqual(cached.stdout, "match\n")
+        for document in ("not-json", "[]", "{}"):
+            self.config.write_text(document)
+            self.assertEqual(self.check(now=NOW)["reason"], "missing_expected_organization")
+        self.assertEqual(len(self.server.state["requests"]), 1)
+        self.config.write_text(json.dumps({"oauthAccount": {
+            "organizationUuid": ORG, "emailAddress": "different@example.invalid"}}))
+        conflict = identity.cached_identity(self.account)
+        self.assertEqual((conflict["state"], conflict["reason"]), ("mismatch", "profile_manifest_mismatch"))
+        self.assertEqual(self.check()["state"], "mismatch")
+        self.assertEqual(len(self.server.state["requests"]), 1)
+        self.manifest.write_text('{"accounts": []}')
+        candidate = subprocess.run([sys.executable, str(REPO / "lib/claude_token_identity.py"),
+                                    "check", str(self.account), "--token-stdin", "--no-store",
+                                    "--expected-email", EMAIL, "--format", "state"],
+                                   input=SECOND, text=True, capture_output=True, env=env, timeout=15)
+        self.assertEqual(candidate.stdout, "mismatch\n")
+        self.config.write_text(json.dumps({"oauthAccount": {"organizationUuid": ORG}}))
+        result = self.check(expected_email=EMAIL, persist=False)
+        self.assertEqual((result["state"], result["reason"]), ("unknown", "missing_profile_email"))
+        self.assertEqual(len(self.server.state["requests"]), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_token_identity_ceremony.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""Exercise real account commands against an isolated CLI and organization server."""
+
+import hashlib
+from http.server import BaseHTTPRequestHandler, HTTPServer
+import json
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+import threading
+import unittest
+
+REPO = Path(__file__).resolve().parents[1]
+EXPECTED = "00000000-0000-4000-8000-000000000001"
+OTHER = "00000000-0000-4000-8000-000000000002"
+TOKEN = "sk-ant-oat01-" + "C" * 96
+OLD_TOKEN = "sk-ant-oat01-" + "O" * 96
+FAKE_CLI = r'''#!/usr/bin/env bash
+case "${1:-}" in
+  --version) echo '2.1.282 (Claude Code)' ;;
+  auth) echo '{"loggedIn":true,"authMethod":"oauth_token","apiProvider":"firstParty"}' ;;
+  setup-token)
+    if [ -n "${TEST_CEREMONY_PROFILE:-}" ]; then
+      printf '%s' "$TEST_CEREMONY_PROFILE" > "$CLAUDE_CONFIG_DIR/.claude.json"
+    fi
+    echo 'Long-lived authentication token created successfully!'
+    echo 'Your OAuth token (valid for 1 year):'
+    printf '%s\n' "$TEST_CANDIDATE_TOKEN"
+    echo 'Store this token securely.' ;;
+  -p) echo inference >> "$TEST_INFERENCE_LOG"; echo OK ;;
+  *) exit 2 ;;
+esac
+'''
+
+
+class IdentityHandler(BaseHTTPRequestHandler):
+    def do_POST(self):
+        self.rfile.read(int(self.headers.get("Content-Length", "0")))
+        self.server.calls += 1
+        self.send_response(self.server.code)
+        if self.server.organization:
+            self.send_header("anthropic-organization-id", self.server.organization)
+        self.end_headers()
+        self.wfile.write(b'{}')
+
+    def log_message(self, *_args):
+        pass
+
+
+class TokenIdentityCeremonyTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory(prefix="multiacc-identity-ceremony-")
+        self.work = Path(self.tmp.name)
+        self.root = self.work / "accounts"
+        self.account = self.root / "acct-01"
+        self.account.mkdir(parents=True)
+        self.manifest = {"accounts": [{"id": "acct-01", "email": "one@test", "home": "mac"}]}
+        (self.root / "accounts.json").write_text(json.dumps(self.manifest))
+        (self.account / ".claude.json").write_text(json.dumps({"oauthAccount": {
+            "organizationUuid": EXPECTED, "emailAddress": "one@test"}}))
+        (self.account / "server.token").write_text(OLD_TOKEN)
+        self.receipt = self.account / ".server-token-identity.json"
+        self.receipt.write_text(json.dumps({"preserve": "existing credential receipt"}))
+        self.receipt_before = self.receipt.read_bytes()
+        fakebin = self.work / "bin"
+        fakebin.mkdir()
+        cli = fakebin / "claude"
+        cli.write_text(FAKE_CLI)
+        cli.chmod(0o755)
+        self.inference_log = self.work / "inference.log"
+        self.server = HTTPServer(("127.0.0.1", 0), IdentityHandler)
+        self.server.code, self.server.organization, self.server.calls = 429, OTHER, 0
+        self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
+        self.thread.start()
+        self.env = {k: v for k, v in os.environ.items() if not k.startswith(("CLAUDE_", "CODEX_", "ANTHROPIC_"))}
+        self.env.update(HOME=str(self.work), PATH=f"{fakebin}:{os.environ['PATH']}",
+                        CLAUDE_ACCOUNTS_ROOT=str(self.root), CLAUDE_MULTIACC_NO_SYNC="1",
+                        CLAUDE_MULTIACC_KEYCHAIN="0", CLAUDE_MULTIACC_PATH_PROBE="0",
+                        CLAUDE_MULTIACC_FORCE_TTY="1", TEST_CANDIDATE_TOKEN=TOKEN,
+                        TEST_INFERENCE_LOG=str(self.inference_log),
+                        CLAUDE_MULTIACC_TOKEN_IDENTITY_URL=f"http://127.0.0.1:{self.server.server_port}/v1/messages")
+
+    def tearDown(self):
+        self.server.shutdown()
+        self.thread.join(timeout=5)
+        self.server.server_close()
+        self.tmp.cleanup()
+
+    def run_cli(self, args, stdin=None):
+        result = subprocess.run([str(REPO / "bin/claude-accounts"), *args], input=stdin,
+                                capture_output=True, text=True, env=self.env, cwd=self.work, timeout=25)
+        self.assertNotIn(TOKEN, result.stdout + result.stderr)
+        self.assertNotIn(OLD_TOKEN, result.stdout + result.stderr)
+        return result
+
+    def test_mismatch_refused_before_save_or_inference(self):
+        cases = [(["mint", "acct-01", "--paste"], TOKEN + "\n"),
+                 (["login", "acct-01", "--token", "--force"], None)]
+        for args, payload in cases:
+            with self.subTest(command=args[0]):
+                result = self.run_cli(args, payload)
+                self.assertNotEqual(result.returncode, 0, result.stdout + result.stderr)
+                self.assertIn("organization does not match", result.stderr)
+                self.assertEqual((self.account / "server.token").read_text(), OLD_TOKEN)
+                self.assertEqual(self.receipt.read_bytes(), self.receipt_before)
+        self.assertFalse(self.inference_log.exists())
+        self.assertEqual(self.server.calls, 2)
+
+    def test_matching_organization_still_proves_auth(self):
+        self.server.organization = EXPECTED
+        result = self.run_cli(["mint", "acct-01", "--paste"], TOKEN + "\n")
+        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+        self.assertIn("organization matches", result.stdout)
+        self.assertEqual((self.account / "server.token").read_text(), TOKEN)
+        self.assertEqual((self.account / ".server-token-verified").read_text().strip(),
+                         hashlib.sha256(TOKEN.encode()).hexdigest())
+        self.assertEqual(self.receipt.read_bytes(), self.receipt_before)
+        self.assertEqual(self.inference_log.read_text().splitlines(), ["inference"])
+
+    def test_unavailable_organization_preserves_existing_acceptance(self):
+        self.server.code, self.server.organization = 503, None
+        result = self.run_cli(["mint", "acct-01", "--paste"], TOKEN + "\n")
+        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+        self.assertIn("organization could not be checked", result.stderr)
+        self.assertNotIn("organization matches", result.stdout)
+        self.assertEqual((self.account / "server.token").read_text(), TOKEN)
+        self.assertEqual(self.receipt.read_bytes(), self.receipt_before)
+
+    def test_new_token_only_account_needs_no_unavailable_profile(self):
+        self.env["TEST_CEREMONY_PROFILE"] = json.dumps({"oauthAccount": {
+            "organizationUuid": OTHER, "emailAddress": "wrong@test"}})
+        result = self.run_cli(["add", "new@test", "--token"])
+        self.assertNotEqual(result.returncode, 0, result.stdout + result.stderr)
+        self.assertFalse((self.root / "acct-02").exists())
+        self.assertFalse(self.inference_log.exists())
+        self.assertEqual(json.loads((self.root / "accounts.json").read_text()), self.manifest)
+        del self.env["TEST_CEREMONY_PROFILE"]
+        result = self.run_cli(["add", "new@test", "--token"])
+        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+        self.assertIn("identity unverifiable", result.stdout)
+        accounts = json.loads((self.root / "accounts.json").read_text())["accounts"]
+        added = next(row for row in accounts if row["email"] == "new@test")
+        self.assertEqual((self.root / added["id"] / "server.token").read_text(), TOKEN)
+        self.assertEqual(self.server.calls, 0)
+
+    def test_direct_imports_refuse_wrong_organization_without_mutation(self):
+        blob = {"format": "claude-multiacc/credential", "version": 1, "provider": "claude",
+                "class": "portable", "account": self.manifest["accounts"][0],
+                "credential": {"type": "setup-token", "value": TOKEN}}
+        cases = [(["import", "one@test", "--id", "acct-01", "--token-file", "-", "--no-sync"], TOKEN),
+                 (["import-credential", "acct-01", "--no-sync"], json.dumps(blob))]
+        before = (self.root / "accounts.json").read_bytes()
+        for args, payload in cases:
+            with self.subTest(command=args[0]):
+                result = self.run_cli(args, payload)
+                self.assertNotEqual(result.returncode, 0, result.stdout + result.stderr)
+                self.assertIn("organization does not match", result.stderr)
+                self.assertEqual((self.account / "server.token").read_text(), OLD_TOKEN)
+                self.assertEqual(self.receipt.read_bytes(), self.receipt_before)
+                self.assertEqual((self.root / "accounts.json").read_bytes(), before)
+        self.assertEqual(self.server.calls, 2)
+        self.assertFalse(self.inference_log.exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_token_identity_integration.py

@@ -0,0 +1,207 @@
+"""Exercise token organization checks through the actual shim, reports and writer.
+
+Only synthetic credentials and a loopback Messages endpoint are used. The fake
+Claude executable would accept every token, including one from the wrong account.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import time
+import unittest
+from unittest.mock import patch
+
+from test_claude_reset import ClaudePoolSandbox, ORG, REPO, ResetHandler, usage_doc
+
+sys.path.insert(0, str(REPO / "lib"))
+
+WRONG_ORG = "aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee"
+WRONG_TOKEN = "sk-ant-oat01-synthetic-wrong-organization"
+RIGHT_TOKEN = "sk-ant-oat01-synthetic-right-organization"
+FAKE_CLI = r'''#!/usr/bin/env python3
+import json, os, pathlib, sys
+args = sys.argv[1:]
+if args == ['--version']:
+    print('2.1.280')
+elif args[:2] == ['auth', 'status']:
+    print(json.dumps({'loggedIn': True, 'email': 'test@example.invalid'}))
+else:
+    row = {'account': pathlib.Path(os.environ.get('CLAUDE_CONFIG_DIR', '/default')).name,
+           'token': bool(os.environ.get('CLAUDE_CODE_OAUTH_TOKEN')), 'args': args}
+    with open(os.environ['IDENTITY_TEST_COMMANDS'], 'a') as handle:
+        handle.write(json.dumps(row) + '\n')
+    print('OK' if '-p' in args else json.dumps(row))
+'''
+
+
+class IdentityHandler(ResetHandler):
+    def do_POST(self):  # noqa: N802 - HTTP handler contract
+        if self.path.startswith("/api/organizations/"):
+            return super().do_POST()
+        length = int(self.headers.get("Content-Length") or 0)
+        self.rfile.read(length)
+        state = self.server.state
+        state["identity_calls"] += 1
+        authorization = self.headers.get("Authorization", "")
+        token = authorization[7:] if authorization.startswith("Bearer ") else authorization
+        org = ORG if token == RIGHT_TOKEN else state["identity_org"]
+        headers = {"anthropic-organization-id": org} if org else {}
+        self._send(state["identity_status"], {"content": [{"type": "text", "text": "OK"}]}, headers)
+
+
+class TokenIdentityIntegrationTests(ClaudePoolSandbox, unittest.TestCase):
+    def setUp(self):
+        super().setUp()
+        self.server.RequestHandlerClass = IdentityHandler
+        self.server.state.update(identity_calls=0, identity_org=WRONG_ORG, identity_status=200)
+        self.home = Path(self.temp.name) / "home"
+        self.fakebin = Path(self.temp.name) / "fakebin"
+        self.home.mkdir()
+        self.fakebin.mkdir()
+        executable = self.fakebin / "claude"
+        executable.write_text(FAKE_CLI)
+        executable.chmod(0o755)
+        self.commands = self.home / "commands.jsonl"
+        self.oauth = (self.account / ".credentials.json").read_text()
+        (self.account / ".credentials.json").unlink()
+        (self.account / "server.token").write_text(WRONG_TOKEN)
+        (self.account / ".server-token-verified").write_text(hashlib.sha256(WRONG_TOKEN.encode()).hexdigest())
+        self.profile = json.loads((self.account / ".claude.json").read_text())
+        self.profile["oauthAccount"]["emailAddress"] = "test@example.invalid"
+        (self.account / ".claude.json").write_text(json.dumps(self.profile))
+        control = self.pool / "acct-02"
+        control.mkdir()
+        (control / ".credentials.json").write_text(self.oauth)
+        manifest = json.loads((self.pool / "accounts.json").read_text())
+        manifest.update(server="none", peers=[])
+        manifest["accounts"].append({"id": "acct-02", "email": "control@example.invalid", "home": "mac"})
+        (self.pool / "accounts.json").write_text(json.dumps(manifest))
+        for account, percent in ((self.account, 0), (control, 80)):
+            (account / "limits.json").write_text(json.dumps({"fetched_at": int(time.time()), "source": "oauth",
+                "weekly_percent": percent, "session_percent": 0, "max_percent": percent,
+                "weekly_resets_epoch": int(time.time()) + 86400, "buckets": []}))
+        (self.pool / ".limits-kick").touch()
+        (self.pool / "autoresume.off").touch()
+        self.environ = self.env(HOME=str(self.home), PATH=f"{self.fakebin}:{os.environ['PATH']}",
+            CLAUDE_ACCOUNTS_ROOT=str(self.pool), CLAUDE_MULTIACC_MCP="0", CLAUDE_MULTIACC_CLIENT_LIMITS="0",
+            CLAUDE_MULTIACC_AUTO_RESET="0", CLAUDE_SHIM_RETRY="0", IDENTITY_TEST_COMMANDS=str(self.commands),
+            CLAUDE_MULTIACC_TOKEN_IDENTITY_URL=f"http://127.0.0.1:{self.server.server_port}/v1/messages")
+        for name in ("CLAUDE_ACCOUNT", "CLAUDE_CONFIG_DIR", "CLAUDE_CODE_OAUTH_TOKEN", "CLAUDE_SHIM_ACTIVE",
+                     "ANTHROPIC_API_KEY", "TMUX", "TMUX_PANE", "CLAUDE_MULTIACC_AR_PROBE"):
+            self.environ.pop(name, None)
+
+    def run_cli(self, command="claude", *args, **overrides):
+        arguments = list(args) or ["--identity-test"]
+        return subprocess.run([str(REPO / "bin" / command), *arguments], cwd=self.home,
+                              env={**self.environ, **overrides}, capture_output=True, text=True,
+                              input="", timeout=30, check=False)
+
+    def identity(self, *, refresh=False):
+        from claude_token_identity import cached_identity, check_identity
+        with patch.dict(os.environ, self.environ, clear=True):
+            return check_identity(str(self.account)) if refresh else cached_identity(str(self.account))
+
+    def test_old_auth_proof_and_touched_token_cannot_bypass_a_mismatch(self):
+        self.server.state["identity_status"] = 429
+        first = self.run_cli()
+        self.assertEqual(first.returncode, 0, first.stderr)
+        self.assertEqual(json.loads(first.stdout)["account"], "acct-02")
+        self.assertEqual(self.identity()["state"], "mismatch")
+        calls = self.server.state["identity_calls"]
+        stamp = time.time() + 5
+        os.utime(self.account / "server.token", (stamp, stamp))
+        again = self.run_cli()
+        self.assertEqual(json.loads(again.stdout)["account"], "acct-02")
+        self.assertEqual(self.server.state["identity_calls"], calls)
+        report = self.run_cli("claude-accounts", "status", "--json")
+        row = next(row for row in json.loads(report.stdout)["accounts"] if row["id"] == "acct-01")
+        self.assertFalse(row["selectable"])
+        self.assertIn("organization", row["reason"].lower())
+        from claude_token_identity import RECEIPT
+        receipt_path = self.account / RECEIPT
+        receipt_path.unlink()
+        receipt_path.mkdir()  # Atomic receipt replacement must fail even when tests run as root.
+        unsaved = self.run_cli()
+        self.assertEqual(unsaved.returncode, 0, unsaved.stderr)
+        self.assertEqual(json.loads(unsaved.stdout)["account"], "acct-02")
+        self.assertGreater(self.server.state["identity_calls"], calls)
+        commands_before = self.commands.read_bytes()
+        exhausted = self.run_cli(CLAUDE_MULTIACC_PREFLIGHT_DEPTH="64")
+        self.assertNotEqual(exhausted.returncode, 0)
+        self.assertEqual(self.commands.read_bytes(), commands_before)
+
+    def test_changed_token_and_expected_organization_trigger_a_new_check(self):
+        self.assertEqual(self.identity(refresh=True)["state"], "mismatch")
+        (self.account / "server.token").write_text(RIGHT_TOKEN)
+        selected = self.run_cli()
+        self.assertEqual(json.loads(selected.stdout)["account"], "acct-01")
+        self.assertEqual(self.identity()["state"], "match")
+        (self.account / "server.token").write_text(WRONG_TOKEN)
+        self.assertEqual(self.identity(refresh=True)["state"], "mismatch")
+        self.profile["oauthAccount"]["organizationUuid"] = WRONG_ORG
+        (self.account / ".claude.json").write_text(json.dumps(self.profile))
+        selected = self.run_cli()
+        self.assertEqual(json.loads(selected.stdout)["account"], "acct-01")
+        self.assertEqual(self.identity()["state"], "match")
+
+    def test_working_oauth_and_its_usage_reset_preserve_the_token_receipt(self):
+        self.assertEqual(self.identity(refresh=True)["state"], "mismatch")
+        receipt = self.identity()
+        (self.account / ".credentials.json").write_text(self.oauth)
+        selected = self.run_cli()
+        self.assertEqual(json.loads(selected.stdout),
+                         {"account": "acct-01", "token": False, "args": ["--identity-test"]})
+        report = self.run_cli("claude-accounts", "status", "--json")
+        row = next(row for row in json.loads(report.stdout)["accounts"] if row["id"] == "acct-01")
+        self.assertTrue(row["selectable"])
+        verified = self.run_cli("claude-accounts", "verify")
+        self.assertEqual(verified.returncode, 0, verified.stdout + verified.stderr)
+        self.assertEqual(self.identity(), receipt)
+        self.server.state["usage"] = usage_doc(session=95, weekly=95, exhausted=["seven_day"])
+        self.server.state["responses"] = [(200, {"result": "reset", "resets_left": 0,
+            "cleared": ["five_hour", "seven_day", "seven_day_overage_included"]}, True)]
+        refreshed = self.run_cli("claude-accounts", "limits", "--force", "--quiet",
+                                 CLAUDE_MULTIACC_AUTO_RESET="1")
+        self.assertEqual(refreshed.returncode, 0, refreshed.stderr)
+        self.assertEqual(len(self.server.state["posts"]), 1)
+        self.assertEqual(self.identity(), receipt)
+        (self.account / ".credentials.json").unlink()
+        again = self.run_cli()
+        self.assertEqual(json.loads(again.stdout)["account"], "acct-02")
+
+    def test_explicit_pin_refuses_known_wrong_identity_before_user_command(self):
+        self.assertEqual(self.identity(refresh=True)["state"], "mismatch")
+        pinned = self.run_cli(CLAUDE_ACCOUNT="acct-01")
+        self.assertNotEqual(pinned.returncode, 0)
+        self.assertIn("organization", (pinned.stdout + pinned.stderr).lower())
+        self.assertFalse(self.commands.exists())
+
+    def test_verify_fails_wrong_organization_even_when_inference_would_answer_ok(self):
+        verified = self.run_cli("claude-accounts", "verify")
+        self.assertNotEqual(verified.returncode, 0, verified.stdout)
+        lines = [line for line in verified.stdout.splitlines() if "acct-01 " in line]
+        self.assertTrue(lines, verified.stdout)
+        self.assertNotIn(": PASS", "\n".join(lines))
+        self.assertIn("organization", "\n".join(lines).lower())
+        self.assertEqual(self.identity()["state"], "mismatch")
+
+    def test_missing_identity_or_endpoint_evidence_remains_fail_open(self):
+        for mode in ("profile", "header", "unavailable"):
+            with self.subTest(mode=mode):
+                profile = {} if mode == "profile" else self.profile
+                (self.account / ".claude.json").write_text(json.dumps(profile))
+                self.server.state["identity_org"] = None
+                self.server.state["identity_status"] = 503 if mode == "unavailable" else 200
+                selected = self.run_cli()
+                self.assertEqual(selected.returncode, 0, selected.stderr)
+                self.assertEqual(json.loads(selected.stdout)["account"], "acct-01")
+                self.assertNotEqual(self.identity().get("state"), "mismatch")
+
+
+if __name__ == "__main__":
+    unittest.main()