claude-multiacc 2.0.43 → 2.0.44

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()

package/tests/test_token_identity_retry.py

@@ -0,0 +1,95 @@
+"""Identity checks must cover retry accounts and the token handed to the command."""
+
+import hashlib
+import json
+from pathlib import Path
+import subprocess
+import unittest
+
+import test_token_identity_integration as integration
+from test_token_identity_integration import IdentityHandler, RIGHT_TOKEN, WRONG_TOKEN
+
+RETRY_CLI = r'''#!/usr/bin/env python3
+import json, os, pathlib, sys
+args = sys.argv[1:]
+if args == ['--version']:
+    print('2.1.280')
+elif 'USER_IDENTITY_SENTINEL' not in args:
+    print('OK')
+else:
+    account = pathlib.Path(os.environ['CLAUDE_CONFIG_DIR']).name
+    wrong = os.environ.get('CLAUDE_CODE_OAUTH_TOKEN') == 'sk-ant-oat01-synthetic-wrong-organization'
+    with open(os.environ['IDENTITY_TEST_COMMANDS'], 'a') as handle:
+        handle.write(json.dumps({'account': account, 'wrong_token': wrong}) + '\n')
+    if account == os.environ.get('IDENTITY_TEST_FAIL_ACCOUNT'):
+        print('rate limit exceeded (429)', file=sys.stderr)
+        sys.exit(1)
+    print('served:' + account)
+'''
+
+
+class SwappingIdentityHandler(IdentityHandler):
+    def do_POST(self):  # noqa: N802 - HTTP handler contract
+        if self.headers.get("Authorization") == f"Bearer {RIGHT_TOKEN}":
+            self.server.swap_token.write_text(WRONG_TOKEN)
+        return super().do_POST()
+
+
+class TokenIdentityRetryTests(unittest.TestCase):
+    def fixture(self):
+        pool = integration.TokenIdentityIntegrationTests()
+        pool.setUp()
+        self.addCleanup(pool.tearDown)
+        (pool.fakebin / "claude").write_text(RETRY_CLI)
+        startup = Path(pool.temp.name) / "fixed-random.sh"
+        startup.write_text("unset RANDOM\nRANDOM=1\n")
+        pool.environ.update(CLAUDE_SHIM_RETRY="1", CLAUDE_MULTIACC_HEADROOM_BAND="0", BASH_ENV=str(startup))
+        return pool
+
+    def run_user(self, pool, **overrides):
+        return subprocess.run([str(integration.REPO / "bin/claude"), "-p", "USER_IDENTITY_SENTINEL"],
+                              cwd=pool.home, env={**pool.environ, **overrides}, stdin=subprocess.DEVNULL,
+                              capture_output=True, text=True, timeout=30, check=False)
+
+    def test_retry_skips_an_unchecked_wrong_token_before_sending_the_user_command(self):
+        pool = self.fixture()
+        (pool.account / ".credentials.json").write_text(pool.oauth)
+        wrong = pool.pool / "acct-02"
+        (wrong / ".credentials.json").unlink()
+        (wrong / "server.token").write_text(WRONG_TOKEN)
+        (wrong / ".server-token-verified").write_text(hashlib.sha256(WRONG_TOKEN.encode()).hexdigest())
+        profile = json.loads(json.dumps(pool.profile))
+        profile["oauthAccount"]["emailAddress"] = "control@example.invalid"
+        (wrong / ".claude.json").write_text(json.dumps(profile))
+        control = pool.pool / "acct-03"
+        control.mkdir()
+        (control / ".credentials.json").write_text(pool.oauth)
+        (control / "limits.json").write_bytes((wrong / "limits.json").read_bytes())
+        manifest = json.loads((pool.pool / "accounts.json").read_text())
+        manifest["accounts"].append({"id": "acct-03", "email": "third@example.invalid", "home": "mac"})
+        (pool.pool / "accounts.json").write_text(json.dumps(manifest))
+        result = self.run_user(pool, IDENTITY_TEST_FAIL_ACCOUNT="acct-01")
+        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+        commands = [json.loads(line) for line in pool.commands.read_text().splitlines()]
+        self.assertEqual(commands, [{"account": "acct-01", "wrong_token": False},
+                                    {"account": "acct-03", "wrong_token": False}])
+        self.assertEqual(result.stdout.strip(), "served:acct-03")
+        self.assertGreater(pool.server.state["identity_calls"], 0)
+
+    def test_a_token_replaced_during_identity_check_is_never_sent_without_verification(self):
+        pool = self.fixture()
+        (pool.account / "server.token").write_text(RIGHT_TOKEN)
+        (pool.account / ".server-token-verified").write_text(hashlib.sha256(RIGHT_TOKEN.encode()).hexdigest())
+        pool.server.RequestHandlerClass = SwappingIdentityHandler
+        pool.server.swap_token = pool.account / "server.token"
+        result = self.run_user(pool)
+        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+        self.assertEqual((pool.account / "server.token").read_text(), WRONG_TOKEN)
+        commands = [json.loads(line) for line in pool.commands.read_text().splitlines()]
+        self.assertEqual(len(commands), 1)
+        self.assertFalse(commands[0]["wrong_token"], commands)
+        self.assertIn(commands[0]["account"], {"acct-01", "acct-02"})
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_token_identity_sync.py

@@ -0,0 +1,139 @@
+"""Bootstrap token identity on the source and export only proven receipts."""
+
+import json
+import unittest
+
+import test_token_identity_integration as integration
+from test_token_identity_integration import IdentityHandler, RIGHT_TOKEN
+
+UNKNOWN_TOKEN = "sk-ant-oat01-synthetic-no-identity-header"
+RSYNC_RECORDER = r'''#!/usr/bin/env python3
+import json, os, pathlib, sys
+files = []
+for argument in sys.argv[1:]:
+    if argument.startswith('--files-from='):
+        files.extend(pathlib.Path(argument.split('=', 1)[1]).read_text().splitlines())
+    elif not argument.startswith('-') and pathlib.Path(argument).is_file():
+        path = pathlib.Path(argument)
+        files.append(path.parent.name + '/' + path.name)
+with open(os.environ['IDENTITY_TEST_TRANSFERS'], 'a') as handle:
+    handle.write(json.dumps(files) + '\n')
+'''
+
+
+class OptionalHeaderHandler(IdentityHandler):
+    def do_POST(self):  # noqa: N802 - HTTP handler contract
+        if self.headers.get("Authorization") == f"Bearer {UNKNOWN_TOKEN}":
+            self.rfile.read(int(self.headers.get("Content-Length") or 0))
+            self.server.state["identity_calls"] += 1
+            return self._send(200, {"content": [{"type": "text", "text": "OK"}]})
+        return super().do_POST()
+
+
+class TokenIdentitySyncTests(unittest.TestCase):
+    def fixture(self):
+        pool = integration.TokenIdentityIntegrationTests()
+        pool.setUp()
+        self.addCleanup(pool.tearDown)
+        (pool.account / ".credentials.json").write_text(pool.oauth)
+        pool.server.RequestHandlerClass = OptionalHeaderHandler
+        pool.transfers = pool.home / "transfers.jsonl"
+        pool.environ["IDENTITY_TEST_TRANSFERS"] = str(pool.transfers)
+        for name, body in (("rsync", RSYNC_RECORDER), ("ssh", "#!/bin/sh\nexit 0\n")):
+            path = pool.fakebin / name
+            path.write_text(body)
+            path.chmod(0o755)
+        return pool
+
+    def export_candidates(self, pool):
+        # Only the remote-sync command is Mac-gated; shim tests need the native OS's stat flags.
+        uname = pool.fakebin / "uname"
+        uname.write_text("#!/bin/sh\necho Darwin\n")
+        uname.chmod(0o755)
+        manifest = json.loads((pool.pool / "accounts.json").read_text())
+        manifest.update(server="fixture@peer.invalid", server_root="/fixture/pool", server_repo="/fixture/repo")
+        for aid, token, email in (("acct-02", UNKNOWN_TOKEN, "control@example.invalid"),
+                                   ("acct-03", RIGHT_TOKEN, "matching@example.invalid")):
+            account = pool.pool / aid
+            account.mkdir(exist_ok=True)
+            (account / "server.token").write_text(token)
+            (account / ".credentials.json").write_text(pool.oauth)
+            profile = json.loads(json.dumps(pool.profile))
+            profile["oauthAccount"]["emailAddress"] = email
+            (account / ".claude.json").write_text(json.dumps(profile))
+            (account / "limits.json").write_bytes((pool.account / "limits.json").read_bytes())
+            if aid == "acct-03":
+                manifest["accounts"].append({"id": aid, "email": email, "home": "mac"})
+        (pool.pool / "accounts.json").write_text(json.dumps(manifest))
+
+    def exported_receipts(self, pool):
+        entries = [entry for line in pool.transfers.read_text().splitlines() for entry in json.loads(line)]
+        self.assertFalse(any(entry.endswith("/.credentials.json") for entry in entries), entries)
+        return {entry for entry in entries if entry.endswith("/.server-token-identity.json")}
+
+    def test_local_source_sync_checks_tokens_even_with_a_working_oauth_login(self):
+        pool = self.fixture()
+        self.assertEqual(pool.identity()["state"], "unknown")
+        synced = pool.run_cli("claude-accounts", "sync", "--no-server")
+        self.assertEqual(synced.returncode, 0, synced.stdout + synced.stderr)
+        self.assertEqual(pool.identity()["state"], "mismatch")
+        self.assertEqual(pool.server.state["identity_calls"], 1)
+        self.assertFalse(pool.transfers.exists())
+        selected = pool.run_cli()
+        self.assertEqual(selected.returncode, 0, selected.stdout + selected.stderr)
+        self.assertEqual(json.loads(selected.stdout)["account"], "acct-01")
+        self.assertFalse(json.loads(selected.stdout)["token"])
+
+    def test_verify_bootstraps_token_identity_and_reports_the_healthy_oauth_pass(self):
+        pool = self.fixture()
+        self.assertEqual(pool.identity()["state"], "unknown")
+        verified = pool.run_cli("claude-accounts", "verify")
+        self.assertEqual(verified.returncode, 0, verified.stdout + verified.stderr)
+        self.assertIn("acct-01 test@example.invalid: PASS", verified.stdout)
+        self.assertIn("portable setup-token belongs to a different organization", verified.stdout)
+        self.assertEqual(pool.identity()["state"], "mismatch")
+        commands = [json.loads(line) for line in pool.commands.read_text().splitlines()]
+        self.assertTrue(commands)
+        self.assertFalse(any(command["token"] for command in commands))
+
+    def test_both_distribution_paths_export_match_and_mismatch_but_never_unknown(self):
+        from claude_token_identity import cached_identity
+        pool = self.fixture()
+        self.export_candidates(pool)
+        expected = {"acct-01/.server-token-identity.json", "acct-03/.server-token-identity.json"}
+        for command in ("limits-distribute-now", "sync"):
+            with self.subTest(command=command):
+                pool.transfers.write_text("")
+                sent = pool.run_cli("claude-accounts", command)
+                self.assertEqual(sent.returncode, 0, sent.stdout + sent.stderr)
+                self.assertEqual(self.exported_receipts(pool), expected)
+                self.assertEqual(pool.identity()["state"], "mismatch")
+                self.assertEqual(cached_identity(str(pool.pool / "acct-02"))["state"], "unknown")
+                self.assertEqual(cached_identity(str(pool.pool / "acct-03"))["state"], "match")
+
+    def test_profile_conflict_does_not_export_the_underlying_unknown_receipt(self):
+        from claude_token_identity import RECEIPT, cached_identity, check_identity
+        pool = self.fixture()
+        self.export_candidates(pool)
+        account = pool.pool / "acct-02"
+        unknown = check_identity(str(account), endpoint=pool.environ["CLAUDE_MULTIACC_TOKEN_IDENTITY_URL"])
+        self.assertEqual(unknown["state"], "unknown")
+        receipt = (account / RECEIPT).read_bytes()
+        profile = json.loads((account / ".claude.json").read_text())
+        profile["oauthAccount"]["emailAddress"] = "different-profile@example.invalid"
+        (account / ".claude.json").write_text(json.dumps(profile))
+        computed = cached_identity(str(account))
+        self.assertEqual(computed["state"], "mismatch")
+        self.assertFalse(computed["cached"])
+        expected = {"acct-01/.server-token-identity.json", "acct-03/.server-token-identity.json"}
+        for command in ("limits-distribute-now", "sync"):
+            with self.subTest(command=command):
+                pool.transfers.write_text("")
+                sent = pool.run_cli("claude-accounts", command)
+                self.assertEqual(sent.returncode, 0, sent.stdout + sent.stderr)
+                self.assertEqual(self.exported_receipts(pool), expected)
+                self.assertEqual((account / RECEIPT).read_bytes(), receipt)
+
+
+if __name__ == "__main__":
+    unittest.main()