claude-multiacc 2.0.61 → 2.0.65

package/lib/codex_mcp_oauth_native.py

@@ -0,0 +1,102 @@
+"""Native lock migration primitives; inspect only task-owned lock file metadata."""
+from __future__ import annotations
+
+import ctypes
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+
+from codex_mcp_oauth_store import Deferred
+
+
+def exchange_supported():
+    libc = ctypes.CDLL(None, use_errno=True)
+    name = 'renamex_np' if sys.platform == 'darwin' else 'renameat2'
+    if sys.platform not in ('darwin', 'linux') or not hasattr(libc, name):
+        raise Deferred('atomic native lock migration is unavailable')
+    if sys.platform == 'darwin' and not shutil.which('lsof'):
+        raise Deferred('native lock migration requires lsof')
+    if sys.platform == 'linux' and not Path('/proc/self/fd').is_dir():
+        raise Deferred('native lock migration requires process file metadata')
+
+
+def exchange(source, target):
+    """Swap a directory and prepared symlink without an absent native pathname."""
+    libc = ctypes.CDLL(None, use_errno=True)
+    left, right = os.fsencode(source), os.fsencode(target)
+    if sys.platform == 'darwin':
+        result = libc.renamex_np(ctypes.c_char_p(left), ctypes.c_char_p(right), ctypes.c_uint(2))
+    else:
+        result = libc.renameat2(-100, ctypes.c_char_p(left), -100, ctypes.c_char_p(right), ctypes.c_uint(2))
+    if result:
+        raise Deferred('atomic native lock migration failed')
+
+
+def linux_handles(identities, owned_fds):
+    for process in Path('/proc').iterdir():
+        if not process.name.isdecimal():
+            continue
+        try:
+            if process.stat().st_uid != os.getuid():
+                continue
+            for descriptor in (process / 'fd').iterdir():
+                if int(process.name) == os.getpid() and int(descriptor.name) in owned_fds:
+                    continue
+                try:
+                    info = descriptor.stat()
+                    if (info.st_dev, info.st_ino) in identities:
+                        return True
+                except FileNotFoundError:
+                    continue
+        except FileNotFoundError:
+            continue
+        except PermissionError as exc:
+            if exited_process(process):
+                continue
+            raise Deferred('native lock handles could not be inspected') from exc
+    return False
+
+
+def exited_process(process):
+    """A reaped or single-thread zombie process cannot retain a native lock fd."""
+    try:
+        fields = dict(line.split(':', 1) for line in (process / 'status').read_text().splitlines()
+                      if ':' in line)
+    except FileNotFoundError:
+        return True
+    except OSError:
+        return False
+    # A zombie thread-group leader can still have living threads and open files.
+    state = fields.get('State', '').split()
+    return bool(state and state[0] in ('Z', 'X') and fields.get('Threads', '').strip() == '1')
+
+
+def mac_handles(paths, owned_fds):
+    try:
+        result = subprocess.run(['lsof', '-nP', '-Fpf', '--', *map(str, paths)],
+                                capture_output=True, text=True, timeout=5, check=False)
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        raise Deferred('native lock handles could not be inspected') from exc
+    if result.returncode not in (0, 1) or result.returncode == 1 and result.stderr:
+        raise Deferred('native lock handles could not be inspected')
+    pid = None
+    for line in result.stdout.splitlines():
+        if line.startswith('p') and line[1:].isdecimal():
+            pid = int(line[1:])
+        elif line.startswith('f'):
+            number = line[1:].rstrip('ruw')
+            if pid != os.getpid() or not number.isdecimal() or int(number) not in owned_fds:
+                return True
+    return False
+
+
+def external_handles(paths, owned_fds):
+    paths = list(paths)
+    if not paths:
+        return False
+    identities = {(path.stat().st_dev, path.stat().st_ino) for path in paths}
+    if sys.platform == 'linux':
+        return linux_handles(identities, owned_fds)
+    return mac_handles(paths, owned_fds)

package/lib/codex_mcp_oauth_store.py

@@ -0,0 +1,149 @@
+"""Native Codex fallback document validation and shared-inode persistence."""
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import stat
+from pathlib import Path
+
+SENTINEL = '__multiacc_shared_store__|0000000000000000'
+PLACEHOLDER = {
+    'server_name': '__multiacc_shared_store__', 'server_url': 'urn:claude-multiacc:shared-mcp-store',
+    'client_id': '', 'access_token': '', 'refresh_token': None, 'expires_at': 0, 'scopes': [],
+}
+MAX_BYTES = 4 << 20
+
+
+class Deferred(Exception):
+    """Leave an unsafe or contended store unchanged; never include credential values."""
+
+
+def read_json(path):
+    try:
+        fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
+    except FileNotFoundError:
+        return {}
+    with os.fdopen(fd, 'r', encoding='utf-8') as stream:
+        if not stat.S_ISREG(os.fstat(stream.fileno()).st_mode):
+            raise Deferred('non-regular document')
+        raw = stream.read(MAX_BYTES + 1)
+    if len(raw) > MAX_BYTES:
+        raise Deferred('oversized document')
+    doc = json.loads(raw)
+    if not isinstance(doc, dict):
+        raise Deferred('invalid document')
+    return doc
+
+
+def validate(doc):
+    identities = {}
+    for key, entry in doc.items():
+        if key == SENTINEL:
+            if entry != PLACEHOLDER:
+                raise Deferred('reserved identity conflict')
+            continue
+        if not isinstance(entry, dict) or not isinstance(key, str):
+            raise Deferred('invalid credential entry')
+        for field in ('server_name', 'server_url', 'client_id', 'access_token'):
+            if not isinstance(entry.get(field), str):
+                raise Deferred('invalid credential fields')
+        if 'executor_owned' in entry and type(entry['executor_owned']) is not bool:
+            raise Deferred('invalid credential owner')
+        name = entry['server_name']
+        if entry.get('executor_owned') or name.startswith(('executor:', 'ema-idp:')) or key.startswith('ema-idp:'):
+            raise Deferred('scoped credential cannot be shared')
+        if name.removeprefix('local:') == PLACEHOLDER['server_name']:
+            raise Deferred('reserved identity conflict')
+        issuer = entry.get('issuer')
+        if issuer is not None and not isinstance(issuer, str):
+            raise Deferred('invalid issuer field')
+        refresh, expiry = entry.get('refresh_token'), entry.get('expires_at')
+        scopes = entry.get('scopes', [])
+        if (refresh is not None and not isinstance(refresh, str)
+                or expiry is not None and (type(expiry) is not int or expiry < 0)
+                or not isinstance(scopes, list) or not all(isinstance(value, str) for value in scopes)):
+            raise Deferred('invalid credential fields')
+        identity = (name.removeprefix('local:'), entry['server_url'])
+        if identity in identities and identities[identity] != (key, entry):
+            raise Deferred('duplicate credential identity')
+        identities[identity] = (key, entry)
+    return doc
+
+
+def merge(documents):
+    result = {}
+    grants = [{key: entry for key, entry in doc.items() if key != SENTINEL} for doc in documents]
+    populated = [doc for doc in grants if doc]
+    if populated and any(doc != populated[0] for doc in populated[1:]):
+        raise Deferred('independent credential documents require separate authorization')
+    for doc in documents:
+        validate(doc)
+        for key, entry in doc.items():
+            if key in result and result[key] != entry:
+                raise Deferred('conflicting credential grants')
+            result[key] = entry
+    validate(result)
+    result[SENTINEL] = dict(PLACEHOLDER)
+    return result
+
+
+def write_shared(path, doc):
+    """Native Codex truncates in place too; callers hold its file-store lock."""
+    data = json.dumps(doc, separators=(',', ':')).encode()
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_NOFOLLOW | os.O_NONBLOCK, 0o600)
+    with os.fdopen(fd, 'wb') as stream:
+        if not stat.S_ISREG(os.fstat(stream.fileno()).st_mode):
+            raise Deferred('non-regular shared document')
+        os.fchmod(stream.fileno(), 0o600)
+        stream.truncate(0)
+        stream.write(data)
+        stream.flush()
+        os.fsync(stream.fileno())
+
+
+@contextlib.contextmanager
+def staged_links(source, accounts, locks):
+    """Prove every hardlink and symlink can be created before changing native state."""
+    pending, scratch_paths = [], []
+    try:
+        for account in accounts:
+            if source.stat().st_dev != account.stat().st_dev:
+                raise Deferred('account credentials are on different filesystems')
+            target = account / '.credentials.json'
+            if not target.exists() or not os.path.samefile(source, target):
+                scratch = account / '.codex-mcp-oauth-link'
+                if scratch.is_symlink() or scratch.exists() and not os.path.samefile(source, scratch):
+                    raise Deferred('foreign staged credential link')
+                if not scratch.exists():
+                    os.link(source, scratch)
+                scratch_paths.append(scratch)
+                pending.append((scratch, target))
+            if not (account / 'mcp-oauth-locks').is_symlink():
+                scratch = account / '.codex-mcp-oauth-locks-link'
+                if scratch.is_symlink():
+                    if scratch.resolve() != locks:
+                        raise Deferred('foreign staged native lock link')
+                elif scratch.exists():
+                    raise Deferred('foreign staged native lock link')
+                else:
+                    scratch.symlink_to(locks, target_is_directory=True)
+                scratch_paths.append(scratch)
+        yield pending
+    finally:
+        for scratch in scratch_paths:
+            scratch.unlink(missing_ok=True)
+
+
+def commit_links(pending):
+    for scratch, target in pending:
+        os.replace(scratch, target)
+
+
+def save_receipt(path, accounts):
+    document = {'accounts': sorted(item.name for item in accounts)}
+    if read_json(path) == document:
+        return
+    scratch = path.with_name('managed.pending.json')
+    write_shared(scratch, document)
+    os.replace(scratch, path)

package/lib/codex_resume_cwd.py

@@ -0,0 +1,57 @@
+"""Recover Codex's saved working directory from its bound main-thread rollout."""
+
+import os
+
+from session_settings import _record, _reverse_lines
+
+
+def _directory(value):
+    if isinstance(value, str) and os.path.isabs(value) and not any(c in value for c in "\0\n\r"):
+        return value
+    return None
+
+
+def _record_cwd(doc, own):
+    payload = doc.get("payload") if doc else None
+    if not isinstance(payload, dict) or payload.get("thread_id") not in (None, own):
+        return None
+    if doc.get("type") == "turn_context":
+        turn, root = payload.get("turn_id"), payload.get("root_turn_id")
+        if turn and root and turn != root:
+            return None
+        return _directory(payload.get("cwd"))
+    if doc.get("type") == "event_msg" and payload.get("type") == "thread_settings_applied":
+        settings = payload.get("thread_settings")
+        return _directory(settings.get("cwd")) if isinstance(settings, dict) else None
+    return None
+
+
+def codex_resume_cwd(path, sid=None, upto=None):
+    """Latest saved main-thread cwd, then its initial cwd; unknown/unreadable gives None.
+
+    Match the native resume picker: a settings change can update cwd before the next
+    turn_context. Read independently of the watcher's quota cursor so chained restarts
+    still recover settings written before that cursor. Only the first metadata record
+    identifies this thread; a fork can contain its parent's metadata later in the file.
+    ``upto`` bounds history to a validated handoff snapshot's byte boundary.
+    """
+    if not path:
+        return None
+    try:
+        with open(path, "rb") as fh:
+            meta = _record(fh.readline(4 << 20))
+        payload = meta.get("payload") if meta and meta.get("type") == "session_meta" else None
+        if not isinstance(payload, dict) or not isinstance(payload.get("id"), str):
+            return None
+        own = payload["id"]
+        if sid is not None and sid != own:
+            return None
+        for line in _reverse_lines(path, upto):
+            if b'"cwd"' not in line:
+                continue
+            directory = _record_cwd(_record(line), own)
+            if directory is not None:
+                return directory
+        return _directory(payload.get("cwd"))
+    except (OSError, ValueError):
+        return None

package/lib/codex_retry_process.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# Sourced only by the buffered exec retry path. The caller keeps prompt input on fd 3
+# and owns stdout/stderr redirections and its EXIT cleanup; this helper preserves them.
+
+codex_retry_signal() {
+  codex_retry_pending_signal="$1"
+  codex_retry_signal_status="$2"
+  # A signal can arrive between installing the traps and assigning the async PID.
+  # Remember it; codex_retry_run delivers it as soon as the owned PID is known.
+  [ -n "$codex_retry_child_pid" ] || return 0
+  trap '' TERM INT HUP
+  kill -s "$codex_retry_pending_signal" "$codex_retry_child_pid" 2>/dev/null || true
+  wait "$codex_retry_child_pid" 2>/dev/null || true
+  codex_retry_child_pid=""
+  exit "$codex_retry_signal_status"
+}
+
+codex_retry_run() {
+  local codex_retry_child_pid="" codex_retry_pending_signal="" codex_retry_signal_status=0
+  local codex_retry_previous_traps rc
+  codex_retry_previous_traps="$(trap -p TERM INT HUP)"
+  trap 'codex_retry_signal TERM 143' TERM
+  trap 'codex_retry_signal INT 130' INT
+  trap 'codex_retry_signal HUP 129' HUP
+  [ -z "$codex_retry_pending_signal" ] || exit "$codex_retry_signal_status"
+  "$@" <&3 &
+  codex_retry_child_pid=$!
+  if [ -n "$codex_retry_pending_signal" ]; then
+    codex_retry_signal "$codex_retry_pending_signal" "$codex_retry_signal_status"
+  fi
+  if wait "$codex_retry_child_pid"; then rc=0; else rc=$?; fi
+  codex_retry_child_pid=""
+  trap - TERM INT HUP
+  # trap -p emits shell-quoted definitions from this process, never fetched input.
+  eval "$codex_retry_previous_traps"
+  return "$rc"
+}