claude-multiacc 2.0.61 → 2.0.64

package/tests/test_autoresume_cwd_tmux.py

@@ -0,0 +1,54 @@
+"""A quota restart restores the saved directory before Codex checks directory and trust."""
+
+import json
+import time
+import unittest
+
+from autoresume_tmux_support import SID, TMUX, TmuxScenario
+
+QUOTA = {"type": "task_complete", "error": {"message": "You've hit your usage limit.",
+                                           "codex_error_info": "usage_limit_exceeded"}}
+
+
+@unittest.skipUnless(TMUX, "real tmux is unavailable")
+class CodexCwdTmuxTests(unittest.TestCase):
+    def test_quota_restart_restores_latest_directory_before_trust_and_prompt(self):
+        self.check_restart("turn_context")
+
+    def test_settings_change_restores_directory_before_the_next_turn(self):
+        self.check_restart("thread_settings_applied")
+
+    def check_restart(self, record_type):
+        case = TmuxScenario(FAKE_REQUIRE_RESUME_CWD="1", FAKE_REQUIRE_TRUST="1")
+        self.addCleanup(case.close)
+        saved = case.home / "saved project Ω"
+        saved.mkdir()
+        source = case.pool / "acct-01/config.toml"
+        target = case.pool / "acct-02/config.toml"
+        source.write_text("# The original account stays unchanged.\n")
+        case.start()
+        context = {"timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                   "type": "turn_context", "payload": {"cwd": str(saved)}}
+        if record_type == "thread_settings_applied":
+            context.update(type="event_msg", payload={"type": record_type, "thread_id": SID,
+                                                     "thread_settings": {"cwd": str(saved)}})
+        with case.rollout.open("a") as stream:
+            stream.write(json.dumps(context) + "\n")
+        case.append(QUOTA)
+        case.wait(lambda: "autoresume switch" in case.log.read_text(), "restart in saved directory confirmed")
+        first, second = case.records("launch")
+        self.assertEqual([first["cwd"], second["cwd"]], [str(case.work), str(saved)])
+        self.assertEqual([first["account"], second["account"]], ["acct-01", "acct-02"])
+        self.assertIn(SID, second["argv"])
+        self.assertEqual([row["matches"] for row in case.records("resume-cwd")], [True])
+        self.assertEqual([(row["trusted"], row["cwd"]) for row in case.records("trust")], [(True, str(saved))])
+        self.assertIn('[projects.' + json.dumps(str(saved), ensure_ascii=False) + ']', target.read_text())
+        self.assertNotIn(str(case.work), target.read_text())
+        self.assertEqual(source.read_text(), "# The original account stays unchanged.\n")
+        self.assertEqual(len(case.records("prompt")), 1)
+        self.assertEqual(case.log.read_text().count("autoresume switch"), 1)
+        self.assertEqual(case.records("keys"), [], "neither TUI receives a keystroke")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_codex_exec_stdin.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""Exercise finite Node pipe prompts against the real shim and fake native Codex."""
+
+import base64
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+
+REPO = Path(__file__).resolve().parents[1]
+SHIM = os.environ.get('MULTIACC_TEST_SHIM', str(REPO / 'bin/codex'))
+NODE = shutil.which('node')
+PROMPT = b'Original image brief\nUnicode: \xf0\x9f\x8c\xb1\nBinary fidelity: \x00\xff\n'
+FAKE = '''import base64, json, os, pathlib, sys
+root = pathlib.Path(os.environ['FAKE_ROOT'])
+account = pathlib.Path(os.environ['CODEX_HOME']).name
+args = sys.argv[1:]
+data = sys.stdin.buffer.read() if args[-1:] == ['-'] and os.environ.get('FAKE_READ', '1') == '1' else b''
+with (root / 'calls.jsonl').open('a') as handle:
+    handle.write(json.dumps({'account': account, 'argv': args,
+                            'selected_home': os.environ.get('CODEX_MULTIACC_SELECTED_HOME'),
+                            'stdin': base64.b64encode(data).decode()}) + '\\n')
+mode = os.environ.get('FAKE_MODE', 'quota')
+if mode == 'ordinary':
+    print('ordinary failure', file=sys.stderr)
+    sys.exit(7)
+if mode == 'all-quota' or (account == 'acct-01' and mode in ('quota', 'auth')):
+    print(json.dumps({'type': 'turn.failed', 'partial': account}))
+    print('ERROR: You’ve hit your usage limit.' if mode != 'auth' else
+          'Error: token expired. Please run codex login again', file=sys.stderr)
+    sys.exit(1)
+print(json.dumps({'type': 'turn.completed', 'account': account}))
+'''
+LAUNCH = '''const {spawn} = require('node:child_process');
+const child = spawn(process.env.TEST_SHIM, JSON.parse(process.env.TEST_ARGS),
+  {stdio: ['pipe', 'pipe', 'pipe']});
+child.stdout.pipe(process.stdout); child.stderr.pipe(process.stderr);
+child.stdin.on('error', error => { if (error.code !== 'EPIPE') throw error; });
+if (process.env.TEST_KEEP_OPEN !== '1') {
+  child.stdin.end(Buffer.from(process.env.TEST_INPUT, 'base64'));
+}
+child.on('close', code => { child.stdin.destroy(); process.exitCode = code; });
+'''
+
+
+@unittest.skipUnless(NODE, 'Node is required for the actual child-process transport')
+class CodexExecStdinTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory(prefix='multiacc-exec-stdin-')
+        self.addCleanup(self.tmp.cleanup)
+        self.root = Path(self.tmp.name)
+        self.pool = self.root / 'pool'
+        self.pool.mkdir()
+        (self.pool / 'accounts.json').write_text('{"threshold":90,"accounts":[]}')
+        (self.pool / '.limits-kick').touch()
+        for index in (1, 2):
+            account = self.pool / f'acct-{index:02d}'
+            account.mkdir()
+            (account / 'auth.json').write_text('{"access_token":"fake-offline-only"}')
+            (account / 'limits.json').write_text(json.dumps({
+                'fetched_at': int(time.time()), 'weekly_percent': index * 10,
+                'session_percent': 5, 'max_percent': index * 10, 'buckets': []}))
+        fakebin = self.root / 'bin'
+        fakebin.mkdir()
+        fake = fakebin / 'codex'
+        fake.write_text(f'#!{sys.executable}\n' + FAKE)
+        fake.chmod(0o755)
+        self.env = {
+            'HOME': str(self.root), 'PATH': f'{fakebin}:/usr/bin:/bin:/usr/sbin:/sbin',
+            'CODEX_ACCOUNTS_ROOT': str(self.pool), 'CODEX_MULTIACC_HEADROOM_BAND': '0',
+            'CODEX_MULTIACC_MCP': '0', 'CODEX_MULTIACC_AUTO_RESET': '0',
+            'CODEX_MULTIACC_MODEL_CATALOG': '0', 'CLAUDE_MULTIACC_PATH_PROBE': '0',
+            'FAKE_ROOT': str(self.root), 'TEST_SHIM': SHIM,
+            'TEST_INPUT': base64.b64encode(PROMPT).decode(), 'LANG': 'en_US.UTF-8',
+        }
+        self.args = ['exec', '-C', str(self.root), '--skip-git-repo-check', '--ephemeral',
+                     '--ignore-user-config', '--json', '--color', 'never', '-s', 'workspace-write',
+                     '-c', 'model_reasoning_effort=medium', '-c', 'project_doc_max_bytes=0', '-']
+
+    def run_node(self, args=None, **changes):
+        env = {**self.env, 'TEST_ARGS': json.dumps(args or self.args), **changes}
+        result = subprocess.run([NODE, '-e', LAUNCH], env=env, capture_output=True, timeout=15)
+        calls = self.root / 'calls.jsonl'
+        rows = [json.loads(line) for line in calls.read_text().splitlines()] if calls.exists() else []
+        return result, rows
+
+    def test_quota_retries_exact_node_image_prompt_with_identical_bytes(self):
+        result, calls = self.run_node()
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual([row['account'] for row in calls], ['acct-01', 'acct-02'])
+        self.assertTrue(all(base64.b64decode(row['stdin']) == PROMPT for row in calls))
+        self.assertTrue(all(row['argv'] == self.args for row in calls))
+        self.assertTrue(all(row['selected_home'] == str(self.pool / row['account']) for row in calls))
+        self.assertNotIn(b'turn.failed', result.stdout)
+        self.assertNotIn(b'usage limit', result.stderr)
+        self.assertIn('error-cooldown', (self.pool / 'acct-01/.limited').read_text())
+        self.assertIn('retry from=acct-01 to=acct-02', (self.pool / 'selection.log').read_text())
+
+    def test_auth_failure_rotates_and_parks_only_rejected_account(self):
+        result, calls = self.run_node(FAKE_MODE='auth')
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(len(calls), 2)
+        self.assertIn('reason=auth-error', (self.pool / 'acct-01/.expired').read_text())
+        self.assertFalse((self.pool / 'acct-02/.expired').exists())
+
+    def test_success_and_ordinary_failure_never_replay(self):
+        for mode, expected in [('success', 0), ('ordinary', 7)]:
+            with self.subTest(mode=mode):
+                (self.root / 'calls.jsonl').unlink(missing_ok=True)
+                result, calls = self.run_node(FAKE_MODE=mode)
+                self.assertEqual(result.returncode, expected, result.stderr)
+                self.assertEqual(len(calls), 1)
+                self.assertFalse((self.pool / 'acct-01/.limited').exists())
+
+    def test_two_exhausted_accounts_return_actual_final_failure_once(self):
+        result, calls = self.run_node(FAKE_MODE='all-quota')
+        self.assertEqual(result.returncode, 1)
+        self.assertEqual(len(calls), 2)
+        self.assertEqual(result.stderr.count(b'usage limit'), 1)
+        self.assertNotIn(b'turn.completed', result.stdout)
+        self.assertEqual(json.loads(result.stdout)['partial'], 'acct-02')
+
+    def test_explicit_pins_and_disable_keep_the_existing_passthrough_contract(self):
+        for changes in [{'CODEX_HOME': str(self.pool / 'acct-01')},
+                        {'CODEX_ACCOUNT': 'acct-01'}, {'CODEX_SHIM_RETRY': '0'}]:
+            with self.subTest(changes=changes):
+                (self.root / 'calls.jsonl').unlink(missing_ok=True)
+                result, calls = self.run_node(**changes)
+                self.assertEqual(result.returncode, 1, result.stderr)
+                self.assertEqual(len(calls), 1)
+                self.assertEqual(calls[0]['account'], 'acct-01')
+
+    def test_nonconsuming_open_pipe_is_not_buffered(self):
+        commands = [['exec', 'prompt supplied in argv'], ['exec', '--image', '-'],
+                    ['exec', '--config', '--json', '-'], ['exec', '--full-auto', '-'],
+                    ['exec', '--help', '-'], ['exec', '-o', '-'], ['exec', '--future-option', '-']]
+        for args in commands:
+            with self.subTest(args=args):
+                (self.root / 'calls.jsonl').unlink(missing_ok=True)
+                result, calls = self.run_node(args, TEST_KEEP_OPEN='1', FAKE_MODE='success', FAKE_READ='0')
+                self.assertEqual(result.returncode, 0, result.stderr)
+                self.assertEqual(len(calls), 1)
+
+    def test_auto_selection_provenance_does_not_turn_explicit_pins_into_pool_requests(self):
+        selected = str(self.pool / 'acct-01')
+        scenarios = [({}, selected), ({'CODEX_HOME': selected}, None),
+                     ({'CODEX_ACCOUNT': 'acct-01', 'CODEX_MULTIACC_SELECTED_HOME': selected}, None),
+                     ({'CODEX_HOME': str(self.pool / 'acct-02'),
+                       'CODEX_MULTIACC_SELECTED_HOME': selected}, selected)]
+        for changes, expected in scenarios:
+            with self.subTest(changes=changes):
+                (self.root / 'calls.jsonl').unlink(missing_ok=True)
+                result, calls = self.run_node(FAKE_MODE='success', **changes)
+                self.assertEqual(result.returncode, 0, result.stderr)
+                self.assertEqual(len(calls), 1)
+                self.assertEqual(calls[0]['selected_home'], expected)
+
+    def test_parser_only_accepts_explicit_prompt_not_option_values_or_early_exits(self):
+        parser = ['bash', str(REPO / 'lib/codex_exec_stdin.sh')]
+        accepted = [self.args, ['--no-daemon', 'e', '--image', 'one.png', 'two.png', '-'],
+                    ['exec', '--', '-'], ['--model=gpt-6.1-sol', 'exec', '-']]
+        rejected = [['exec', '-o', '-'], ['exec', '--color', '-'], ['exec', '--help', '-'],
+                    ['exec', '--future-option', '-'], ['exec', 'resume', '-'],
+                    ['mcp', 'add', 'exec', '-'], ['exec', 'text'], ['exec', '--image', 'one.png'],
+                    ['exec', '--image', '-'], ['exec', '--config', '--json', '-'], ['exec', '--full-auto', '-']]
+        for args in accepted + rejected:
+            with self.subTest(args=args):
+                result = subprocess.run(parser + args, capture_output=True)
+                self.assertEqual(result.returncode, 0 if args in accepted else 1)
+
+
+if __name__ == '__main__':
+    unittest.main()

package/tests/test_codex_mcp_oauth.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""Native-layout synthetic tests; no real pool, credentials, keyring, or network."""
+import fcntl
+import json
+import multiprocessing
+import os
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'lib'))
+import codex_mcp_oauth as M
+from codex_mcp_oauth_store import PLACEHOLDER, SENTINEL
+
+KEY = 'motionsites|1234567890abcdef'
+ENTRY = {'server_name': 'motionsites', 'server_url': 'https://example.invalid/mcp',
+         'issuer': 'https://example.invalid', 'client_id': 'fake-client', 'access_token': 'fake-access',
+         'refresh_token': 'fake-refresh', 'expires_at': 1900000000000, 'scopes': ['read']}
+
+
+def native_update(account, key, entry):
+    """Mirror native O_NOFOLLOW, aggregate flock, truncate-in-place, empty unlink."""
+    lock = account / 'mcp-oauth-locks' / 'file-store.lock'
+    with lock.open('a') as handle:
+        fcntl.flock(handle, fcntl.LOCK_EX)
+        path = account / '.credentials.json'
+        doc = json.loads(path.read_text())
+        if entry is None:
+            doc.pop(key, None)
+        else:
+            doc[key] = entry
+        if not doc:
+            path.unlink()
+            return
+        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_NOFOLLOW, 0o600)
+        with os.fdopen(fd, 'w') as stream:
+            stream.truncate(0)
+            json.dump(doc, stream)
+
+
+class SharedStoreTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.root = Path(self.temp.name)
+        self.accounts = [self.root / 'acct-01', self.root / 'acct-02']
+        for path in self.accounts:
+            path.mkdir()
+            (path / 'auth.json').write_text('subscription-login-must-stay-byte-identical')
+        (self.root / 'accounts.json').write_text(json.dumps({'accounts': [{'id': p.name} for p in self.accounts]}))
+        self.shared = self.root / M.SHARED_DIR
+
+    def seed(self, account=0, entry=None):
+        path = self.accounts[account] / '.credentials.json'
+        path.write_text(json.dumps({KEY: ENTRY if entry is None else entry}))
+        return path
+
+    def test_share_native_refresh_and_last_logout_without_resurrection(self):
+        source = self.seed()
+        inode = source.stat().st_ino
+        self.assertTrue(M.ensure(self.root))
+        for account in self.accounts:
+            self.assertEqual((account / '.credentials.json').stat().st_ino, inode)
+            self.assertEqual((account / 'auth.json').read_text(), 'subscription-login-must-stay-byte-identical')
+        native_update(self.accounts[1], KEY, dict(ENTRY, access_token='rotated-fake'))
+        self.assertEqual(json.loads(source.read_text())[KEY]['access_token'], 'rotated-fake')
+        native_update(self.accounts[1], KEY, None)
+        self.assertTrue(M.ensure(self.root))
+        for account in self.accounts:
+            self.assertEqual(json.loads((account / '.credentials.json').read_text()), {SENTINEL: PLACEHOLDER})
+        self.assertEqual(source.stat().st_mode & 0o777, 0o600)
+        before = source.stat().st_mtime_ns
+        receipt_before = (self.shared / 'managed.json').stat().st_mtime_ns
+        self.assertTrue(M.ensure(self.root))
+        self.assertEqual(source.stat().st_mtime_ns, before)
+        self.assertEqual((self.shared / 'managed.json').stat().st_mtime_ns, receipt_before)
+
+    def test_empty_and_disabled_pools_have_no_auth_state(self):
+        self.assertFalse(M.ensure(self.root))
+        self.assertFalse(self.shared.exists())
+        self.seed()
+        with patch.dict(os.environ, {'CODEX_MULTIACC_MCP_OAUTH': '0'}):
+            self.assertFalse(M.ensure(self.root))
+        self.assertFalse(self.shared.exists())
+        self.assertTrue(M.ensure(self.root, initialize=True))
+
+    def test_conflicting_grants_and_scoped_credentials_are_untouched(self):
+        first = self.seed()
+        second = self.seed(1, dict(ENTRY, refresh_token='different-grant'))
+        before = [first.read_bytes(), second.read_bytes()]
+        self.assertFalse(M.ensure(self.root))
+        self.assertEqual([first.read_bytes(), second.read_bytes()], before)
+        self.assertFalse(self.shared.exists())
+        second.unlink()
+        for update in ({'executor_owned': True}, {'server_name': 'ema-idp:private'}):
+            self.seed(entry=dict(ENTRY, **update))
+            self.assertFalse(M.ensure(self.root))
+            self.assertFalse(self.shared.exists())
+
+    def test_native_lock_contention_defers_and_preserves_owner_inode(self):
+        self.seed()
+        directory = self.accounts[0] / 'mcp-oauth-locks'
+        directory.mkdir()
+        file_lock = directory / 'file-store.lock'
+        file_lock.touch()
+        file_inode = file_lock.stat().st_ino
+        path = directory / ('a' * 64 + '.lock')
+        with path.open('w') as handle:
+            inode = path.stat().st_ino
+            fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            self.assertFalse(M.ensure(self.root))
+            self.assertFalse((self.accounts[1] / '.credentials.json').exists())
+        self.assertTrue(M.ensure(self.root))
+        self.assertEqual((self.shared / 'locks' / path.name).stat().st_ino, inode)
+        self.assertEqual((self.shared / 'locks' / 'file-store.lock').stat().st_ino, file_inode)
+        with (self.accounts[0] / 'mcp-oauth-locks' / path.name).open('a') as handle:
+            fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            other = os.open(self.accounts[1] / 'mcp-oauth-locks' / path.name, os.O_RDWR)
+            try:
+                with self.assertRaises(BlockingIOError):
+                    fcntl.flock(other, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            finally:
+                os.close(other)
+
+    def test_concurrent_native_writers_preserve_both_servers(self):
+        self.seed()
+        self.assertTrue(M.ensure(self.root))
+        processes = []
+        context = multiprocessing.get_context('fork')
+        for index, account in enumerate(self.accounts):
+            name = 'server' + str(index)
+            process = context.Process(target=native_update, args=(account, name, dict(ENTRY, server_name=name)))
+            process.start()
+            processes.append(process)
+        for process in processes:
+            process.join(5)
+            self.assertEqual(process.exitcode, 0)
+        doc = json.loads((self.shared / 'credentials.json').read_text())
+        self.assertIn('server0', doc)
+        self.assertIn('server1', doc)
+
+
+if __name__ == '__main__':
+    unittest.main()

package/tests/test_codex_mcp_oauth_adopt.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""The documented default-home adoption is the only supported external account link."""
+import json
+import os
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'lib'))
+import codex_mcp_oauth as M
+
+ENTRY = {'server_name': 'demo', 'server_url': 'https://example.invalid/mcp',
+         'client_id': 'fake-client', 'access_token': 'fake-access', 'refresh_token': 'fake-refresh'}
+
+
+class DefaultAdoptionTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.home = Path(self.temp.name).resolve()
+        environment = patch.dict(os.environ, {'HOME': str(self.home)})
+        environment.start()
+        self.addCleanup(environment.stop)
+        self.root = self.home / '.codex-accounts'
+        self.root.mkdir()
+        self.default = self.home / '.codex'
+        self.default.mkdir()
+        self.adopted = self.root / 'acct-01'
+        self.adopted.symlink_to(self.default, target_is_directory=True)
+        self.regular = self.root / 'acct-02'
+        self.regular.mkdir()
+        (self.root / 'accounts.json').write_text(json.dumps({'accounts': [{'id': 'acct-01'}, {'id': 'acct-02'}]}))
+        (self.regular / '.credentials.json').write_text(json.dumps({'demo|1234': ENTRY}))
+        (self.default / 'auth.json').write_text('default-subscription-login')
+        (self.regular / 'auth.json').write_text('regular-subscription-login')
+
+    def test_adopted_default_joins_storage_preserving_logical_identity(self):
+        self.assertTrue(M.ensure(self.root, self.adopted))
+        authority = self.root / M.SHARED_DIR / 'credentials.json'
+        for path in (self.default, self.adopted, self.regular):
+            self.assertTrue(os.path.samefile(path / '.credentials.json', authority))
+            self.assertEqual((path / 'mcp-oauth-locks').resolve(), self.root / M.SHARED_DIR / 'locks')
+        receipt = json.loads((self.root / M.SHARED_DIR / 'managed.json').read_text())
+        self.assertEqual(receipt['accounts'], ['acct-01', 'acct-02'])
+        self.assertEqual((self.default / 'auth.json').read_text(), 'default-subscription-login')
+        self.assertEqual((self.regular / 'auth.json').read_text(), 'regular-subscription-login')
+        self.assertTrue(self.adopted.is_symlink())
+        self.assertTrue(M.ensure(self.root, self.default))
+        self.assertTrue(M.ensure(self.root, self.regular))
+
+    def test_foreign_adopted_target_and_duplicate_homes_are_rejected(self):
+        foreign = self.home / 'foreign'
+        foreign.mkdir()
+        self.adopted.unlink()
+        self.adopted.symlink_to(foreign, target_is_directory=True)
+        self.assertFalse(M.ensure(self.root, self.adopted))
+        self.assertEqual(list(foreign.iterdir()), [])
+        self.assertFalse((self.root / M.SHARED_DIR).exists())
+        self.adopted.unlink()
+        self.adopted.symlink_to(self.default, target_is_directory=True)
+        extra = self.root / 'acct-03'
+        extra.symlink_to(self.default, target_is_directory=True)
+        names = ['acct-01', 'acct-02', 'acct-03']
+        (self.root / 'accounts.json').write_text(json.dumps({'accounts': [{'id': name} for name in names]}))
+        self.assertFalse(M.ensure(self.root, self.default))
+        self.assertFalse((self.root / M.SHARED_DIR).exists())
+        self.assertFalse((self.default / '.credentials.json').exists())
+
+    def test_unlisted_default_home_and_retargeted_account_are_rejected(self):
+        (self.root / 'accounts.json').write_text(json.dumps({'accounts': [{'id': 'acct-02'}]}))
+        self.assertFalse(M.ensure(self.root, self.default))
+        self.assertFalse((self.root / M.SHARED_DIR).exists())
+        (self.root / 'accounts.json').write_text(json.dumps({'accounts': [{'id': 'acct-01'}, {'id': 'acct-02'}]}))
+        accounts = M.account_dirs(self.root)
+        foreign = self.home / 'foreign'
+        foreign.mkdir()
+        self.adopted.unlink()
+        self.adopted.symlink_to(foreign, target_is_directory=True)
+        with self.assertRaises(M.Deferred):
+            M.check_paths(self.root, accounts)
+        self.assertEqual(list(foreign.iterdir()), [])
+
+
+if __name__ == '__main__':
+    unittest.main()

package/tests/test_codex_mcp_oauth_migration.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""Migration keeps preexisting native lock descriptors serialized through cutover."""
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'lib'))
+import codex_mcp_oauth as M
+import codex_mcp_oauth_locks as L
+from codex_mcp_oauth_store import Deferred
+
+DOCUMENT = {'demo|1234': {'server_name': 'demo', 'server_url': 'https://example.invalid',
+                          'client_id': 'fake-client', 'access_token': 'fake-access'}}
+WAITER = '''import fcntl,os,sys,time
+fd=os.open(sys.argv[1],os.O_RDWR)
+print('opened',flush=True)
+time.sleep(0.3)
+try:
+ fcntl.flock(fd,fcntl.LOCK_EX|fcntl.LOCK_NB)
+ print('unsafe',flush=True)
+except BlockingIOError:
+ print('blocked',flush=True)
+os.close(fd)
+'''
+
+
+class MigrationTests(unittest.TestCase):
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory()
+        self.addCleanup(temporary.cleanup)
+        self.root = Path(temporary.name)
+        self.accounts = [self.root / 'acct-01', self.root / 'acct-02']
+        for account in self.accounts:
+            (account / 'mcp-oauth-locks').mkdir(parents=True)
+            (account / 'mcp-oauth-locks' / 'file-store.lock').touch()
+        (self.root / 'accounts.json').write_text(json.dumps({'accounts': [{'id': p.name} for p in self.accounts]}))
+        self.source = self.accounts[0] / '.credentials.json'
+        self.source.write_text(json.dumps(DOCUMENT))
+        self.shared = self.root / M.SHARED_DIR / 'locks'
+
+    def test_open_unlocked_descriptor_defers_before_any_cutover(self):
+        path = self.accounts[1] / 'mcp-oauth-locks' / 'file-store.lock'
+        fd = os.open(path, os.O_RDWR)
+        try:
+            self.assertFalse(M.ensure(self.root))
+            self.assertTrue(all(not (account / 'mcp-oauth-locks').is_symlink() for account in self.accounts))
+            self.assertEqual(json.loads(self.source.read_text()), DOCUMENT)
+            self.assertFalse((self.accounts[1] / '.credentials.json').exists())
+            self.assertEqual(path.stat().st_ino, os.fstat(fd).st_ino)
+        finally:
+            os.close(fd)
+        self.assertTrue(M.ensure(self.root))
+
+    def test_waiter_opened_after_preflight_drains_before_credentials_are_shared(self):
+        original = L.exchange
+        children = []
+
+        def exchange_with_waiter(source, target):
+            if source.parent.name == self.accounts[1].name:
+                child = subprocess.Popen([sys.executable, '-c', WAITER, str(source / 'file-store.lock')],
+                                         stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+                children.append(child)
+                self.assertEqual(child.stdout.readline().strip(), 'opened')
+                self.assertFalse((self.accounts[1] / '.credentials.json').exists())
+            original(source, target)
+            self.assertTrue(source.is_symlink())
+            self.assertTrue(target.is_dir() and not target.is_symlink())
+
+        started = time.monotonic()
+        with patch.object(L, 'exchange', side_effect=exchange_with_waiter):
+            self.assertTrue(M.ensure(self.root))
+        self.assertGreaterEqual(time.monotonic() - started, 0.3)
+        for child in children:
+            output, error = child.communicate(timeout=5)
+            self.assertEqual((child.returncode, output.strip(), error), (0, 'blocked', ''))
+        self.assertTrue(os.path.samefile(self.source, self.accounts[1] / '.credentials.json'))
+        self.assertEqual(list((self.shared.parent / 'retired-locks').iterdir()), [])
+
+    def test_lock_created_after_snapshot_keeps_its_inode(self):
+        original = L.exchange
+        created = []
+        name = 'a' * 64 + '.lock'
+
+        def exchange_with_new_lock(source, target):
+            if source.parent.name == self.accounts[1].name:
+                path = source / name
+                path.touch()
+                created.append(path.stat().st_ino)
+            original(source, target)
+
+        with patch.object(L, 'exchange', side_effect=exchange_with_new_lock):
+            self.assertTrue(M.ensure(self.root))
+        self.assertEqual((self.shared / name).stat().st_ino, created[0])
+
+    def test_unavailable_exchange_defers_without_mutating_credentials(self):
+        with patch.object(L, 'exchange_supported', side_effect=Deferred('unavailable')):
+            self.assertFalse(M.ensure(self.root))
+        self.assertEqual(json.loads(self.source.read_text()), DOCUMENT)
+        self.assertTrue(all(not (account / 'mcp-oauth-locks').is_symlink() for account in self.accounts))
+
+    def test_completed_migration_never_probes_process_handles_again(self):
+        self.assertTrue(M.ensure(self.root))
+        with patch.object(L, 'external_handles', side_effect=AssertionError('unnecessary process probe')):
+            self.assertTrue(M.ensure(self.root))
+
+    def test_partial_cutover_failure_drains_waiter_before_releasing_locks(self):
+        third = self.root / 'acct-03'
+        (third / 'mcp-oauth-locks').mkdir(parents=True)
+        (third / 'mcp-oauth-locks' / 'file-store.lock').touch()
+        self.accounts.append(third)
+        (self.root / 'accounts.json').write_text(json.dumps({'accounts': [{'id': p.name} for p in self.accounts]}))
+        original, children = L.exchange, []
+
+        def interrupted_exchange(source, target):
+            if source.parent.name == 'acct-03':
+                raise Deferred('injected cutover failure')
+            if source.parent.name == 'acct-02':
+                child = subprocess.Popen([sys.executable, '-c', WAITER, str(source / 'file-store.lock')],
+                                         stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+                children.append(child)
+                self.assertEqual(child.stdout.readline().strip(), 'opened')
+            original(source, target)
+
+        with patch.object(L, 'exchange', side_effect=interrupted_exchange):
+            self.assertFalse(M.ensure(self.root))
+        self.assertEqual(json.loads(self.source.read_text()), DOCUMENT)
+        self.assertFalse((self.accounts[1] / '.credentials.json').exists())
+        for child in children:
+            output, error = child.communicate(timeout=5)
+            self.assertEqual((child.returncode, output.strip(), error), (0, 'blocked', ''))
+        self.assertTrue(M.ensure(self.root))
+
+
+if __name__ == '__main__':
+    unittest.main()