claude-multiacc 2.0.61 → 2.0.65

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

package/tests/test_codex_mcp_oauth_native.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""Linux process exit must not hide a live native OAuth lock holder."""
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+from unittest.mock import MagicMock, patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'lib'))
+import codex_mcp_oauth_native as N
+from codex_mcp_oauth_store import Deferred
+
+
+def scan_process(process):
+    """Limit the proc fixture to this test's process, retaining real fd operations."""
+    root = MagicMock()
+    root.iterdir.return_value = [process]
+    with patch.object(N, 'Path', return_value=root):
+        return N.linux_handles(set(), set())
+
+
+class NativeProcessTests(unittest.TestCase):
+    def test_denied_live_or_unproven_process_still_defers(self):
+        statuses = [
+            'State:\tS (sleeping)\nThreads:\t1\n',
+            'State:\tZ (zombie)\nThreads:\t2\n',
+            'State:\tZ (zombie)\n',
+            'State:\tZ (zombie)\nThreads:\tinvalid\n',
+            'Threads:\t1\n',
+        ]
+        process = MagicMock(spec=Path)
+        process.name = '12345'
+        process.stat.return_value.st_uid = os.getuid()
+        process.__truediv__.return_value.iterdir.side_effect = PermissionError('denied')
+        for status in statuses:
+            with self.subTest(status=status):
+                process.__truediv__.return_value.read_text.return_value = status
+                with self.assertRaises(Deferred):
+                    scan_process(process)
+
+    def test_denied_single_thread_exit_does_not_block_migration(self):
+        process = MagicMock(spec=Path)
+        process.name = '12345'
+        process.stat.return_value.st_uid = os.getuid()
+        process.__truediv__.return_value.iterdir.side_effect = PermissionError('denied')
+        for state in ('Z (zombie)', 'X (dead)'):
+            with self.subTest(state=state):
+                process.__truediv__.return_value.read_text.return_value = f'State:\t{state}\nThreads:\t1\n'
+                self.assertFalse(scan_process(process))
+
+    def test_unreadable_status_defers_but_vanished_process_does_not(self):
+        process = MagicMock(spec=Path)
+        process.name = '12345'
+        process.stat.return_value.st_uid = os.getuid()
+        process.__truediv__.return_value.iterdir.side_effect = PermissionError('denied')
+        process.__truediv__.return_value.read_text.side_effect = PermissionError('denied')
+        with self.assertRaises(Deferred):
+            scan_process(process)
+        process.__truediv__.return_value.read_text.side_effect = FileNotFoundError('gone')
+        self.assertFalse(scan_process(process))
+
+    @unittest.skipUnless(sys.platform == 'linux', 'requires Linux proc metadata')
+    def test_real_unreaped_child_releases_its_file_descriptors(self):
+        child = subprocess.Popen([sys.executable, '-c', 'pass'])
+        try:
+            os.waitid(os.P_PID, child.pid, os.WEXITED | os.WNOWAIT)
+            process = Path('/proc') / str(child.pid)
+            self.assertTrue(N.exited_process(process))
+            self.assertFalse(scan_process(process))
+        finally:
+            child.wait(timeout=3)
+
+    @unittest.skipUnless(sys.platform == 'linux', 'requires Linux thread-group behavior')
+    def test_zombie_leader_with_living_thread_still_defers(self):
+        script = '''import ctypes,os,sys,threading,time
+ready=threading.Event()
+def owner():
+    with open(sys.argv[1], 'w'):
+        ready.set()
+        time.sleep(10)
+threading.Thread(target=owner).start()
+ready.wait()
+ctypes.CDLL(None).pthread_exit(None)
+'''
+        with tempfile.TemporaryDirectory() as directory:
+            child = subprocess.Popen([sys.executable, '-c', script, str(Path(directory) / 'lock')])
+            try:
+                process = Path('/proc') / str(child.pid)
+                deadline = time.monotonic() + 3
+                while time.monotonic() < deadline:
+                    status = (process / 'status').read_text()
+                    if 'State:\tZ' in status and 'Threads:\t2' in status:
+                        break
+                    time.sleep(0.01)
+                else:
+                    self.fail('fixture did not leave a zombie leader with a living thread')
+                self.assertFalse(N.exited_process(process))
+                with self.assertRaises(Deferred):
+                    scan_process(process)
+            finally:
+                child.kill()
+                child.wait(timeout=3)
+
+
+if __name__ == '__main__':
+    unittest.main()