codex-passport-sync 0.1.1__py3-none-any.whl

codex_passport/__init__.py

@@ -0,0 +1,2 @@
+"""Original Codex Passport sync application."""
+__version__ = "0.1.1"

codex_passport/__main__.py

@@ -0,0 +1,2 @@
+from .cli import main
+main()

codex_passport/ble.py

@@ -0,0 +1,127 @@
+"""Cross-platform BLE delivery; paired GATT writes and explicit device receipts."""
+import asyncio
+import json
+import logging
+import time
+
+from .cli import snapshot, device_frame
+
+SERVICE = 'fac06f64-6578-2d70-6173-73706f727401'
+RX = 'fac06f64-6578-2d70-6173-73706f727402'
+TX = 'fac06f64-6578-2d70-6173-73706f727403'
+LOG = logging.getLogger('codex-passport')
+
+
+class Receipts:
+    def __init__(self, store):
+        self.store = store
+        self.buffer = bytearray()
+        self.pending = None
+        self.ack = asyncio.Event()
+
+    def receive(self, _, data):
+        self.buffer.extend(data)
+        while b'\n' in self.buffer:
+            line, _, rest = self.buffer.partition(b'\n')
+            self.buffer = bytearray(rest)
+            try:
+                reply = json.loads(line)
+            except ValueError:
+                continue
+            if not isinstance(reply, dict) or reply.get('v') != 1:
+                continue
+            if self.pending and reply.get('ack') == self.pending[0]:
+                event = self.pending[1]
+                if event and reply.get('event') == event['id']:
+                    self.store.delivered(event['id'])
+                elif event:
+                    continue
+                self.ack.set()
+            read = reply.get('read')
+            if isinstance(read, int) and not isinstance(read, bool) and read >= 0:
+                self.store.mark_read(min(read, self.store.summary()['latest']))
+        if len(self.buffer) > 4096:
+            self.buffer.clear()
+
+
+async def deliver(client, receipts, store, seq):
+    event = store.pending()
+    frame = device_frame(snapshot(store, seq, event))
+    raw = json.dumps(frame, ensure_ascii=False, separators=(',', ':')).encode() + b'\n'
+    if len(raw) > 2048:
+        raise ValueError('Snapshot exceeds the device frame limit')
+    receipts.pending = (seq, event)
+    receipts.ack.clear()
+    size = max(20, min(180, client.mtu_size - 3))
+    security_deadline = time.monotonic() + 110
+    for offset in range(0, len(raw), size):
+        while True:
+            try:
+                await client.write_gatt_char(RX, raw[offset:offset+size], response=True)
+                break
+            except Exception as exc:
+                # CoreBluetooth can return an ATT security error while its PIN dialog
+                # is still open. Keep this connection alive; never downgrade security.
+                security_error = any(s in str(exc).lower() for s in
+                                     ('insufficient encryption', 'insufficient authentication'))
+                if not security_error or not client.is_connected or time.monotonic() >= security_deadline:
+                    raise
+                await asyncio.sleep(1)
+    await asyncio.wait_for(receipts.ack.wait(), timeout=15)
+
+
+async def connect_and_sync(device, store, routing, generation, once=False):
+    from bleak import BleakClient, BleakScanner
+    # Select explicitly; never pair with an arbitrary nearby Passport.
+    found = await BleakScanner.find_device_by_filter(
+        lambda d, ad: d.address.lower() == device.lower() or ad.local_name == device,
+        timeout=30, service_uuids=[SERVICE])
+    if found is None:
+        raise TimeoutError('Selected Passport is not advertising nearby')
+    if routing.view()['generation'] != generation:
+        return False
+    async with BleakClient(found, pair=True, timeout=45) as client:
+        receipts = Receipts(store)
+        await client.start_notify(TX, receipts.receive)
+        seq = int(time.time()*1000) % 2_000_000_000
+        last_send, signature = 0, ''
+        while client.is_connected:
+            route = routing.view()
+            if route['owner'] != 'desktop' or route['generation'] != generation:
+                return False
+            frame = device_frame(snapshot(store, 0, store.pending()))
+            frame.pop('now')
+            current = json.dumps(frame, sort_keys=True)
+            if current != signature or time.monotonic() - last_send >= 10:
+                seq = seq % 2_000_000_000 + 1
+                if last_send:
+                    await asyncio.wait_for(deliver(client, receipts, store, seq), timeout=35)
+                else:
+                    await deliver(client, receipts, store, seq)
+                routing.acknowledged(generation)
+                (LOG.info if not last_send else LOG.debug)('Desktop BLE device ACK confirmed (sequence %d)', seq)
+                last_send, signature = time.monotonic(), current
+                if once:
+                    return True
+            await asyncio.sleep(1)
+        raise ConnectionError('Passport disconnected')
+
+
+async def worker(device, store, routing, once=False):
+    while True:
+        route = routing.view()
+        if route['owner'] == 'desktop':
+            generation = route['generation']
+            try:
+                operation = connect_and_sync(device, store, routing, generation, once)
+                acknowledged = await asyncio.wait_for(operation, 170) if once else await operation
+                if once:
+                    if not acknowledged:
+                        raise TimeoutError('Handoff expired before a device acknowledgement')
+                    return
+            except Exception as exc:
+                LOG.warning('Desktop BLE unavailable (%s); returning ownership to phone', type(exc).__name__)
+                routing.failed(generation)
+                if once:
+                    raise
+        await asyncio.sleep(1)

codex_passport/cli.py

@@ -0,0 +1,270 @@
+"""CLI, lifecycle-hook installation and a reconnecting USB worker."""
+from __future__ import annotations
+import argparse
+import asyncio
+import json
+import logging
+import os
+from pathlib import Path
+import shlex
+import sys
+import time
+from .store import Store, LABELS, clipped
+from .sessions import Sessions
+from .usage import UsageClient
+
+LOG = logging.getLogger('codex-passport')
+HOOK_EVENTS = ['SessionStart', 'SessionEnd', 'UserPromptSubmit', 'Stop', 'Interrupt',
+               'SubagentStart', 'SubagentStop', 'PermissionRequest', 'PreCompact', 'PostCompact',
+               'PreToolUse', 'PostToolUse']
+
+
+def state_dir():
+    return Path(os.environ.get('CODEX_PASSPORT_STATE', str(Path.home()/'.local/state/codex-passport'))).expanduser()
+
+
+def hook_config(command):
+    events = {}
+    for event in HOOK_EVENTS:
+        handler = {'type': 'command', 'command': command, 'timeout': 3}
+        # Small local SQLite write. Synchronous ordering avoids late Stop beating a new turn.
+        group = {'hooks': [handler]}
+        if event == 'PreToolUse':
+            group['matcher'] = '.*(request_user_input|requestUserInput).*'
+        events[event] = [group]
+    return {'hooks': events}
+
+
+def install_hooks(args):
+    target = args.codex_home / 'hooks.json'
+    target.parent.mkdir(parents=True, exist_ok=True)
+    old = json.loads(target.read_text()) if target.exists() else {'hooks': {}}
+    if not isinstance(old, dict) or not isinstance(old.get('hooks', {}), dict):
+        raise ValueError('Existing hooks.json has an unsupported structure')
+    command = shlex.join([sys.executable, '-m', 'codex_passport', '--state-dir', str(args.state_dir.resolve()), 'hook'])
+    merged = json.loads(json.dumps(old))
+    hooks = merged.setdefault('hooks', {})
+    # Idempotent: replace only entries installed by this application.
+    for event, groups in hook_config(command)['hooks'].items():
+        previous = hooks.setdefault(event, [])
+        cleaned = []
+        for group in previous:
+            group = dict(group)
+            group['hooks'] = [h for h in group.get('hooks', []) if '-m codex_passport ' not in h.get('command', '')]
+            if group['hooks']:
+                cleaned.append(group)
+        hooks[event] = cleaned + groups
+    if target.exists():
+        backup = target.with_name('hooks.json.passport-backup-' + str(time.time_ns()))
+        backup.write_bytes(target.read_bytes())
+        backup.chmod(0o600)
+    tmp = target.with_suffix('.passport-tmp')
+    tmp.write_text(json.dumps(merged, indent=2) + '\n')
+    tmp.chmod(0o600)
+    tmp.replace(target)
+    print(f'Hooks installed: {target}. Restart existing Codex sessions to load them.')
+
+
+def port_name(explicit):
+    if explicit:
+        return explicit
+    from serial.tools.list_ports import comports
+    ports = [p.device for p in comports() if p.vid == 0x303A and p.pid == 0x1001]
+    if len(ports) != 1:
+        raise RuntimeError('Connect one Passport by USB, or specify --port')
+    return ports[0]
+
+
+def wire_event(event):
+    return {'id': event['id'], 'kind': event['kind'], 'project': clipped(event['project'],32),
+            'time': int(event['ts']), 'title': clipped(event.get('title') or event['project'],60),
+            'body': clipped(event.get('body') or '',120)}
+
+
+def snapshot(store, seq, event=None):
+    now = int(time.time())
+    usage = store.get('usage', {})
+    windows = []
+    for window in usage.get('windows', [None, None]):
+        if not window or window['reset'] <= now or now-usage.get('updated',0) > 180:
+            windows.append([-1, window['minutes'] if window else 0, 0])
+        else:
+            windows.append([window['remaining'], window['minutes'], window['reset']])
+    frame = {'v': 1, 'seq': seq, 'now': now, **store.summary(), 'windows': windows,
+            'tokens': usage.get('tokens') if isinstance(usage.get('tokens'), int) else -1,
+            'today': usage.get('today') if isinstance(usage.get('today'), int) else -1,
+            'recent': [wire_event(e) for e in store.inbox(4)],
+            'event': wire_event(event) if event else None}
+    # JSON escaping can expand punctuation; keep the BLE line within its 2048-byte limit.
+    while frame['recent'] and len(json.dumps(frame,ensure_ascii=False,separators=(',',':')).encode())>1900:
+        frame['recent'].pop()
+    return frame
+
+
+def device_frame(frame):
+    """The graphical device needs counts, quota and receipt IDs, not conversation text."""
+    result = {k: v for k, v in frame.items() if k != '_link'}
+    result['recent'] = []
+    event = frame.get('event')
+    result['event'] = None if not event else {
+        'id': event['id'], 'kind': event['kind'], 'project': '', 'time': event['time']}
+    return result
+
+
+async def run(args, store):
+    import serial
+    watcher = Sessions(args.codex_home, store)
+    client = UsageClient(args.codex)
+    lock = (args.state_dir / 'worker.lock').open('a+')
+    if os.name == 'posix':
+        import fcntl
+        try:
+            fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            raise RuntimeError('A Passport worker is already running for this state directory')
+    usage_task = None
+    link = None
+    last_usage = last_scan = last_send = 0.0
+    seq = 0
+    pending_seq = 0
+    pending_event = None
+    incoming = bytearray()
+    acknowledged = False
+    try:
+        while True:
+            now = time.monotonic()
+            if now-last_scan >= 1:
+                watcher.poll()
+                last_scan = now
+            if usage_task is None and now-last_usage >= 60:
+                usage_task = asyncio.create_task(client.fetch())
+                last_usage = now
+            if usage_task and usage_task.done():
+                try:
+                    store.put('usage', usage_task.result())
+                    LOG.info('Account usage refreshed')
+                except Exception as exc:
+                    LOG.warning('Usage unavailable (%s); retrying in 60s', type(exc).__name__)
+                usage_task = None
+            if args.dry_run:
+                if usage_task:
+                    try:
+                        store.put('usage', await usage_task)
+                    except Exception as exc:
+                        LOG.warning('Usage unavailable (%s)', type(exc).__name__)
+                    usage_task = None
+                print(json.dumps(snapshot(store, 1), ensure_ascii=False, indent=2))
+                return
+            try:
+                if link is None:
+                    link = serial.Serial(port_name(args.port), 115200, timeout=0, write_timeout=1)
+                    incoming.clear()
+                    pending_seq = 0
+                    last_send = 0
+                    LOG.info('USB connected: %s', link.port)
+                data = link.read(min(link.in_waiting, 8192))
+                incoming.extend(data)
+                while b'\n' in incoming:
+                    line, _, rest = incoming.partition(b'\n')
+                    incoming = bytearray(rest)
+                    try:
+                        reply = json.loads(line)
+                    except ValueError:
+                        continue
+                    if not isinstance(reply, dict) or reply.get('v') != 1:
+                        continue
+                    if reply.get('ack') == pending_seq and pending_seq:
+                        if pending_event:
+                            store.delivered(pending_event['id'])
+                            LOG.info('Notification delivered: #%d %s', pending_event['id'], pending_event['kind'])
+                        pending_seq, pending_event = 0, None
+                        acknowledged = True
+                    if isinstance(reply.get('read'), int):
+                        store.mark_read(min(reply['read'], store.summary()['latest']))
+                if len(incoming) > 16384:
+                    incoming.clear()
+                if pending_seq and now-last_send > 5:
+                    raise RuntimeError('Passport acknowledgement timed out')
+                event = store.pending()
+                if not pending_seq and (event or now-last_send >= 2):
+                    seq = seq + 1 if seq < 2_000_000_000 else 1
+                    payload = json.dumps(snapshot(store, seq, event), ensure_ascii=False, separators=(',', ':')).encode()+b'\n'
+                    if len(payload) > 2048:
+                        raise ValueError('Snapshot exceeds device frame size')
+                    link.write(payload)
+                    pending_seq, pending_event, last_send = seq, event, now
+                if args.once and acknowledged:
+                    return
+            except (serial.SerialException, OSError, RuntimeError) as exc:
+                LOG.warning('USB disconnected (%s); reconnecting', type(exc).__name__)
+                if link:
+                    link.close()
+                link = None
+                await asyncio.sleep(1)
+            await asyncio.sleep(0.1)
+    finally:
+        if link:
+            link.close()
+        if usage_task:
+            usage_task.cancel()
+            await asyncio.gather(usage_task, return_exceptions=True)
+        await client.close()
+        lock.close()
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Codex lifecycle inbox and account usage on AI Passport')
+    parser.add_argument('--state-dir', type=Path, default=state_dir())
+    parser.add_argument('--codex-home', type=Path, default=Path(os.environ.get('CODEX_HOME', str(Path.home()/'.codex'))))
+    sub = parser.add_subparsers(dest='command', required=True)
+    worker = sub.add_parser('run')
+    worker.add_argument('--port')
+    worker.add_argument('--codex', default='codex')
+    worker.add_argument('--dry-run', action='store_true')
+    worker.add_argument('--once', action='store_true', help='Exit after one device acknowledgement')
+    hook = sub.add_parser('hook', help='Consume Codex hook JSON from stdin, or notify JSON argument')
+    hook.add_argument('payload', nargs='?')
+    sub.add_parser('install-hooks')
+    relay = sub.add_parser('serve', help='Expose the authenticated relay to an Android WireGuard peer')
+    relay.add_argument('--host', default='127.0.0.1')
+    relay.add_argument('--port', type=int, default=18765)
+    relay.add_argument('--codex', default='codex')
+    relay.add_argument('--ble', metavar='DEVICE', help='Optional Passport BLE name/address; phone fallback on failure')
+    bluetooth = sub.add_parser('ble', help='Deliver the existing collector state directly over BLE')
+    bluetooth.add_argument('--device', required=True, help='Passport advertising name or OS Bluetooth address')
+    bluetooth.add_argument('--once', action='store_true')
+    sub.add_parser('status')
+    sub.add_parser('events')
+    args = parser.parse_args()
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s %(message)s')
+    store = None
+    try:
+        store = Store(args.state_dir)
+        if args.command == 'run':
+            asyncio.run(run(args, store))
+        elif args.command == 'serve':
+            from .relay import serve
+            asyncio.run(serve(args, store))
+        elif args.command == 'ble':
+            from .ble import worker
+            from .routing import Routing
+            asyncio.run(worker(args.device, store, Routing(desktop=True), args.once))
+        elif args.command == 'hook':
+            raw = args.payload if args.payload is not None else sys.stdin.read(4*1024*1024)
+            store.ingest_hook(json.loads(raw))
+        elif args.command == 'install-hooks':
+            install_hooks(args)
+        elif args.command == 'status':
+            print(json.dumps(snapshot(store, 0), indent=2))
+        elif args.command == 'events':
+            print(json.dumps(store.recent(100), indent=2))
+    except KeyboardInterrupt:
+        pass
+    except Exception as exc:
+        if args.command == 'hook':
+            # Notification failures must never block or authorize a Codex tool.
+            return
+        parser.exit(1, f'{type(exc).__name__}: {exc}\n')
+    finally:
+        if store is not None:
+            store.close()

codex_passport/relay.py

@@ -0,0 +1,133 @@
+"""Authenticated LAN relay intended to be reached over the user's WireGuard tunnel."""
+import asyncio
+import hmac
+import json
+import logging
+import secrets
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from .store import Store
+from .sessions import Sessions
+from .usage import UsageClient
+from .routing import Routing
+
+LOG = logging.getLogger('codex-passport')
+
+
+def token_file(directory):
+    path = directory / 'relay-token'
+    if not path.exists():
+        with path.open('x') as stream:
+            path.chmod(0o600)
+            stream.write(secrets.token_urlsafe(32))
+    return path
+
+
+def handler_factory(directory, token, routing=None):
+    routing = routing or Routing()
+    class Handler(BaseHTTPRequestHandler):
+        def log_message(self, *_):
+            pass
+
+        def authorized(self):
+            return hmac.compare_digest(self.headers.get('Authorization', ''), 'Bearer ' + token)
+
+        def reply(self, status, value):
+            raw = json.dumps(value, ensure_ascii=False, separators=(',', ':')).encode()
+            self.send_response(status)
+            self.send_header('Content-Type', 'application/json')
+            self.send_header('Content-Length', str(len(raw)))
+            self.send_header('Cache-Control', 'no-store')
+            self.end_headers()
+            self.wfile.write(raw)
+
+        def do_GET(self):
+            if not self.authorized():
+                return self.reply(401, {'error': 'unauthorized'})
+            if self.path != '/v1/snapshot':
+                return self.reply(404, {'error': 'not found'})
+            from .cli import snapshot
+            store = Store(directory)
+            try:
+                seq = int(time.time() * 1000) % 2_000_000_000 + 1
+                frame = snapshot(store, seq, store.pending())
+                frame['_link'] = routing.view()
+                self.reply(200, frame)
+            finally:
+                store.close()
+
+        def do_POST(self):
+            if not self.authorized():
+                return self.reply(401, {'error': 'unauthorized'})
+            if self.path not in ('/v1/ack', '/v1/route'):
+                return self.reply(404, {'error': 'not found'})
+            try:
+                length = int(self.headers.get('Content-Length', '-1'))
+                if not 0 <= length <= 1024:
+                    return self.reply(413, {'error': 'invalid length'})
+                self.connection.settimeout(5)
+                payload = json.loads(self.rfile.read(length))
+                if not isinstance(payload, dict):
+                    raise ValueError()
+            except (ValueError, OSError):
+                return self.reply(400, {'error': 'invalid JSON'})
+            if self.path == '/v1/route':
+                try:
+                    return self.reply(200, routing.select(payload.get('owner')))
+                except ValueError as exc:
+                    return self.reply(400, {'error': str(exc)})
+            store = Store(directory)
+            try:
+                event = payload.get('event')
+                read = payload.get('read')
+                if isinstance(event, int) and not isinstance(event, bool) and event > 0:
+                    store.delivered(event)
+                if isinstance(read, int) and not isinstance(read, bool) and read >= 0:
+                    store.mark_read(min(read, store.summary()['latest']))
+                self.reply(200, {'ok': True})
+            finally:
+                store.close()
+    return Handler
+
+
+async def serve(args, store):
+    token = token_file(args.state_dir).read_text().strip()
+    routing = Routing(desktop=bool(args.ble))
+    server = ThreadingHTTPServer((args.host, args.port), handler_factory(args.state_dir, token, routing))
+    server.daemon_threads = True
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    LOG.info('Relay listening at %s:%d; pairing token file: %s', args.host, args.port, token_file(args.state_dir))
+    watcher = Sessions(args.codex_home, store)
+    usage = UsageClient(args.codex)
+    task = None
+    ble_task = None
+    if args.ble:
+        from .ble import worker
+        ble_task = asyncio.create_task(worker(args.ble, store, routing))
+    last = 0
+    try:
+        while True:
+            watcher.poll()
+            if task is None and time.monotonic() - last >= 60:
+                task = asyncio.create_task(usage.fetch())
+                last = time.monotonic()
+            if task and task.done():
+                try:
+                    store.put('usage', task.result())
+                    LOG.info('Account usage refreshed')
+                except Exception as exc:
+                    LOG.warning('Usage refresh unavailable (%s)', type(exc).__name__)
+                task = None
+            await asyncio.sleep(1)
+    finally:
+        if ble_task:
+            ble_task.cancel()
+            await asyncio.gather(ble_task, return_exceptions=True)
+        if task:
+            task.cancel()
+            await asyncio.gather(task, return_exceptions=True)
+        await usage.close()
+        server.shutdown()
+        server.server_close()

codex_passport/routing.py

@@ -0,0 +1,46 @@
+"""One active BLE owner, with a bounded desktop handoff and sticky fallback.
+
+No location inference: a reachable VPN server does not imply Bluetooth proximity.
+"""
+import threading
+import time
+
+
+class Routing:
+    def __init__(self, desktop=False, clock=time.monotonic):
+        self.clock = clock
+        self.lock = threading.Lock()
+        self.desktop = desktop
+        self.owner = 'desktop' if desktop else 'phone'
+        self.state = 'connecting' if desktop else 'idle'
+        self.deadline = clock() + 180 if desktop else 0
+        self.generation = 0
+
+    def view(self):
+        with self.lock:
+            if self.owner == 'desktop' and self.clock() > self.deadline:
+                self.owner, self.state = 'phone', 'fallback'
+                self.generation += 1
+            return dict(owner=self.owner, state=self.state,
+                        desktopAvailable=self.desktop, generation=self.generation)
+
+    def select(self, owner):
+        if owner not in ('phone', 'desktop') or (owner == 'desktop' and not self.desktop):
+            raise ValueError('Desktop BLE is not configured' if owner == 'desktop' else 'Invalid route')
+        with self.lock:
+            self.owner = owner
+            self.state = 'connecting' if owner == 'desktop' else 'idle'
+            self.deadline = self.clock() + 180
+            self.generation += 1
+        return self.view()
+
+    def acknowledged(self, generation):
+        with self.lock:
+            if generation == self.generation and self.owner == 'desktop':
+                self.state, self.deadline = 'connected', self.clock() + 60
+
+    def failed(self, generation):
+        with self.lock:
+            if generation == self.generation:
+                self.owner, self.state = 'phone', 'fallback'
+                self.generation += 1

codex_passport/sessions.py

@@ -0,0 +1,155 @@
+"""Incremental all-session fallback; hooks are the supported event interface."""
+from __future__ import annotations
+import json
+import time
+import sqlite3
+from contextlib import closing
+from datetime import datetime
+from pathlib import Path
+from .store import Store
+
+MAX_LINE = 4 * 1024 * 1024
+
+def internal_session(meta):
+    source = meta.get('source')
+    # These are hidden approval-review workers, not user-visible conversations.
+    if meta.get('thread_source') in ('guardian_review', 'memory_consolidation'):
+        return True
+    if isinstance(source, dict):
+        child = source.get('subagent')
+        return isinstance(child, dict) and child.get('other') in ('guardian', 'memory_consolidation')
+    return False
+
+
+class Sessions:
+    def __init__(self, home: Path, store: Store):
+        self.home, self.store = home, store
+        self.initialized = bool(store.get('sessions_initialized', False))
+        self.baseline = store.get('watch_start', time.time())
+        store.put('watch_start', self.baseline)
+
+    def poll(self):
+        paths = sorted((self.home / 'sessions').rglob('*.jsonl'))
+        # Archived sessions can finish while being moved. Track them too.
+        paths += sorted((self.home / 'archived_sessions').rglob('*.jsonl'))
+        for path in paths:
+            try:
+                self._read(path)
+            except (OSError, UnicodeError):
+                continue
+        self.initialized = True
+        self.store.put('sessions_initialized', True)
+
+    def _read(self, path):
+        stat = path.stat()
+        key = f'file:{stat.st_dev}:{stat.st_ino}'
+        cursor = self.store.get(key, {})
+        if cursor.get('ignored'):
+            return
+        if not cursor.get('checked'):
+            with path.open('rb') as first:
+                try: meta=json.loads(first.readline(MAX_LINE)).get('payload',{})
+                except (ValueError,AttributeError): meta={}
+            if internal_session(meta):
+                self.store.hide_thread(meta.get('id',''))
+                self.store.put(key,{'ignored':True})
+                return
+        offset = cursor.get('offset', 0)
+        thread, turn = cursor.get('thread', path.stem), cursor.get('turn', '')
+        project = cursor.get('project', '')
+        historical = not self.initialized and not cursor
+        if stat.st_size < offset or cursor.get('inode', stat.st_ino) != stat.st_ino:
+            offset = 0
+        if offset == stat.st_size and cursor:
+            if not cursor.get('checked'):
+                cursor['checked']=True
+                self.store.put(key,cursor)
+            return
+        with path.open('rb') as stream:
+            if not cursor:
+                first = stream.readline(MAX_LINE)
+                try:
+                    meta = json.loads(first).get('payload', {})
+                    if internal_session(meta):
+                        self.store.put(key, {'ignored': True})
+                        return
+                    thread = meta.get('id', thread)
+                    project = Path(meta.get('cwd', '')).name
+                except (ValueError, AttributeError, TypeError):
+                    pass
+                if historical:
+                    offset = max(0, stat.st_size - 2 * MAX_LINE)
+                    stream.seek(offset)
+                    if offset:
+                        stream.readline()
+                        offset = stream.tell()
+            stream.seek(offset)
+            # Bounded work per file per poll avoids starving the device heartbeat.
+            end = min(stat.st_size, offset + 8 * MAX_LINE)
+            while stream.tell() < end:
+                before = stream.tell()
+                raw = stream.readline(MAX_LINE + 1)
+                if not raw.endswith(b'\n'):
+                    if len(raw) > MAX_LINE:
+                        while raw and not raw.endswith(b'\n'):
+                            raw = stream.readline(MAX_LINE + 1)
+                        offset = stream.tell()
+                        continue
+                    offset = before  # Never consume a half-written JSON record.
+                    break
+                offset = stream.tell()
+                try:
+                    record = json.loads(raw)
+                except ValueError:
+                    continue
+                if not isinstance(record, dict):
+                    continue
+                p = record.get('payload')
+                if not isinstance(p, dict):
+                    continue
+                stamp = time.time()
+                try:
+                    stamp = datetime.fromisoformat(record['timestamp'].replace('Z', '+00:00')).timestamp()
+                except (KeyError, ValueError, AttributeError):
+                    pass
+                if record.get('type') == 'session_meta':
+                    if internal_session(p):
+                        self.store.put(key, {'ignored': True})
+                        return
+                    thread = p.get('id', thread)
+                    project = Path(p.get('cwd', '')).name
+                if record.get('type') == 'turn_context':
+                    turn = p.get('turn_id', turn)
+                kind = None
+                identity = ''
+                if record.get('type') == 'event_msg':
+                    name = p.get('type')
+                    turn = p.get('turn_id', turn)
+                    kind = {'task_started': 'started', 'task_complete': 'completed',
+                            'turn_aborted': 'interrupted', 'task_failed': 'failed',
+                            'error': 'failed'}.get(name)
+                if record.get('type') == 'response_item':
+                    if p.get('type') in ('function_call', 'custom_tool_call') and 'request_user_input' in p.get('name', ''):
+                        kind, identity = 'input', p.get('call_id', '')
+                    if p.get('type') in ('function_call_output', 'custom_tool_call_output') and not historical:
+                        self.store.resume(thread, turn, identity=p.get("call_id", ""))
+                if kind:
+                    self.store.event(thread, turn, kind, project, identity, stamp, historical or stamp < self.baseline)
+                    title=''
+                    for database in sorted(self.home.glob('state_*.sqlite'),reverse=True)[:1]:
+                        try:
+                            with closing(sqlite3.connect(database.resolve().as_uri()+'?mode=ro',uri=True)) as db:
+                                row=db.execute('SELECT title FROM threads WHERE id=?',(thread,)).fetchone()
+                                if row:title=row[0]
+                        except sqlite3.Error:pass
+                    body=p.get('last_agent_message','') if kind=='completed' else ''
+                    if kind=='input':
+                        try:
+                            args=json.loads(p.get('arguments','{}'))
+                            questions=args.get('questions',[])
+                            if questions and isinstance(questions[0],dict):
+                                body=questions[0].get('question') or questions[0].get('title') or ''
+                        except (ValueError,TypeError,AttributeError):pass
+                    self.store.decorate(thread,title=title,body=body)
+        self.store.put(key, {'offset': offset, 'thread': thread, 'turn': turn,
+                             'project': project, 'inode': stat.st_ino, 'checked':True})

codex_passport/store.py

@@ -0,0 +1,198 @@
+"""Durable metadata-only inbox shared by hooks and the device worker."""
+from __future__ import annotations
+import hashlib
+import re
+import json
+import sqlite3
+import time
+from pathlib import Path
+
+ALERT_KINDS = {"completed", "failed", "interrupted", "approval", "input"}
+
+LABELS = {
+    "started": "Task started", "completed": "Task complete", "failed": "Task failed",
+    "interrupted": "Task interrupted", "approval": "Approval needed",
+    "input": "Your input needed", "session": "Session opened", "closed": "Session closed",
+    "compacting": "Context compacting", "compacted": "Context compacted",
+    "unknown": "Status unavailable",
+}
+
+
+def clipped(value, limit=60):
+    # Bound UTF-8 bytes without splitting a character.
+    return ''.join(c for c in str(value) if ord(c)>=32).encode('utf-8')[:limit].decode('utf-8',errors='ignore')
+
+
+class Store:
+    def __init__(self, directory: Path):
+        directory.mkdir(parents=True, exist_ok=True, mode=0o700)
+        self.db = sqlite3.connect(directory / 'state.sqlite3', timeout=2)
+        self.db.row_factory = sqlite3.Row
+        self.db.execute('PRAGMA journal_mode=WAL')
+        self.db.executescript('''
+          CREATE TABLE IF NOT EXISTS events(
+            id INTEGER PRIMARY KEY AUTOINCREMENT, key TEXT UNIQUE, thread TEXT,
+            kind TEXT, project TEXT, ts REAL, delivered INTEGER DEFAULT 0,
+            read INTEGER DEFAULT 0);
+          CREATE TABLE IF NOT EXISTS sessions(
+            thread TEXT PRIMARY KEY, turn TEXT, status TEXT, project TEXT, updated REAL);
+          CREATE TABLE IF NOT EXISTS waits(thread TEXT, turn TEXT, identity TEXT,
+              PRIMARY KEY(thread,turn,identity));
+          CREATE TABLE IF NOT EXISTS kv(key TEXT PRIMARY KEY, value TEXT);
+        ''')
+        columns={r[1] for r in self.db.execute('PRAGMA table_info(events)')}
+        for col in ('title','body'):
+            if col not in columns:
+                self.db.execute(f"ALTER TABLE events ADD COLUMN {col} TEXT DEFAULT ''")
+        if self.get('notification_policy',0)<2:
+            self.db.execute("UPDATE events SET delivered=1,read=1 WHERE kind NOT IN ('completed','failed','interrupted','approval','input')")
+            self.put('notification_policy',2)
+        self.db.commit()
+
+    def hide_thread(self, thread):
+        self.db.execute('DELETE FROM events WHERE thread=?',(thread,))
+        self.db.execute('DELETE FROM sessions WHERE thread=?',(thread,))
+        self.db.execute('DELETE FROM waits WHERE thread=?',(thread,))
+        self.db.commit()
+
+    def decorate(self, thread, title='', body=''):
+        # Retain human context, redact obvious credentials and omit code blocks.
+        def clean(text,limit):
+            text=re.sub(r'(?s)```.*?```', '', str(text))
+            text=re.sub(r'(?i)(?:sk-|pypi-|ghp_)[A-Za-z0-9_-]+','[redacted]',text)
+            return clipped(' '.join(text.split()),limit)
+        row=self.db.execute('SELECT id FROM events WHERE thread=? ORDER BY id DESC LIMIT 1',(thread,)).fetchone()
+        if row:
+            if title:self.db.execute('UPDATE events SET title=? WHERE id=?',(clean(title,60),row[0]))
+            if body:self.db.execute('UPDATE events SET body=? WHERE id=?',(clean(body,120),row[0]))
+            self.db.commit()
+
+    def get(self, key, default=None):
+        row = self.db.execute('SELECT value FROM kv WHERE key=?', (key,)).fetchone()
+        return json.loads(row[0]) if row else default
+
+    def put(self, key, value):
+        self.db.execute('INSERT OR REPLACE INTO kv VALUES(?,?)', (key, json.dumps(value)))
+        self.db.commit()
+
+    def event(self, thread, turn, kind, project='', identity='', ts=None, silent=False):
+        if kind not in LABELS or not thread:
+            return
+        ts = time.time() if ts is None else ts
+        old = self.db.execute('SELECT * FROM sessions WHERE thread=?', (thread,)).fetchone()
+        turn = turn or (old['turn'] if old else '')
+        project = clipped(project or (old['project'] if old else thread[:8]), 32)
+        key = hashlib.sha256(f'{thread}|{turn}|{kind}|{identity}'.encode()).hexdigest()
+        # Historical tail recovery must never overwrite a newer live hook.
+        if not old or ts >= old['updated']:
+            status = kind
+            if kind == 'session':
+                status = old['status'] if old else 'idle'
+            if kind == 'compacted':
+                status = 'started'
+            if kind in ('approval', 'input'):
+                self.db.execute('INSERT OR IGNORE INTO waits VALUES(?,?,?)',(thread,turn,identity))
+            elif kind in ('completed', 'failed', 'interrupted', 'closed', 'started'):
+                self.db.execute('DELETE FROM waits WHERE thread=? AND turn!=?',(thread,turn))
+                if kind != 'started':
+                    self.db.execute('DELETE FROM waits WHERE thread=?',(thread,))
+            self.db.execute('INSERT OR REPLACE INTO sessions VALUES(?,?,?,?,?)',
+                            (thread, turn, status, project, ts))
+        if not silent:
+            quiet = int(kind not in ALERT_KINDS)
+            self.db.execute('INSERT OR IGNORE INTO events(key,thread,kind,project,ts,delivered,read) VALUES(?,?,?,?,?,?,?)',
+                            (key, thread, kind, project, ts, quiet, quiet))
+        self.db.commit()
+
+    def resume(self, thread, turn='', project='', identity=''):
+        row = self.db.execute('SELECT * FROM sessions WHERE thread=?', (thread,)).fetchone()
+        if identity:
+            self.db.execute('DELETE FROM waits WHERE thread=? AND identity=?',(thread,identity))
+        pending = self.db.execute('SELECT count(*) FROM waits WHERE thread=?',(thread,)).fetchone()[0]
+        if not pending and row and (not turn or turn == row['turn']) and row['status'] in ('approval', 'input', 'compacting'):
+            self.db.execute("UPDATE sessions SET status='started',updated=? WHERE thread=?",
+                            (time.time(), thread))
+            self.db.commit()
+
+    def ingest_hook(self, value):
+        if not isinstance(value, dict):
+            return
+        from .sessions import internal_session
+        transcript=value.get('transcript_path')
+        if transcript:
+            try:
+                with Path(transcript).open('rb') as stream:
+                    meta=json.loads(stream.readline(4*1024*1024)).get('payload',{})
+                if internal_session(meta):
+                    self.hide_thread(meta.get('id',''))
+                    return
+            except (OSError, ValueError, AttributeError):
+                pass
+        if value.get('agent_type') in ('guardian','guardian_review'):
+            return
+        event = value.get('hook_event_name', value.get('type', ''))
+        thread = str(value.get('agent_id') or value.get('thread-id') or value.get('session_id') or '')[:128]
+        turn = str(value.get('turn_id') or value.get('turn-id') or '')[:128]
+        project = Path(str(value.get('cwd') or '')).name
+        tool = str(value.get('tool_name') or '')
+        mapping = {'SessionStart': 'session', 'UserPromptSubmit': 'started', 'Stop': 'completed',
+                   'SubagentStart': 'started', 'SubagentStop': 'completed', 'Interrupt': 'interrupted',
+                   'SessionEnd': 'closed', 'PermissionRequest': 'approval',
+                   'PreCompact': 'compacting', 'PostCompact': 'compacted',
+                   'agent-turn-complete': 'completed'}
+        if event == 'PostToolUse':
+            identity = str(value.get('tool_use_id') or '')
+            hashed = hashlib.sha256(json.dumps(value.get('tool_input', {}), sort_keys=True).encode()).hexdigest()
+            self.resume(thread, turn, project, identity)
+            self.resume(thread, turn, project, hashed)
+            return
+        kind = mapping.get(event)
+        if event == 'PreToolUse' and ('request_user_input' in tool or 'requestUserInput' in tool):
+            kind = 'input'
+        if not kind:
+            return
+        identity = ''
+        if kind in ('approval', 'input'):
+            # Raw tool arguments never enter storage, only their one-way identity hash.
+            identity = str(value.get('tool_use_id') or hashlib.sha256(
+                json.dumps(value.get('tool_input', {}), sort_keys=True).encode()).hexdigest())
+        if kind in ('session', 'closed'):
+            identity = str(int(time.time()) // 5)
+        self.event(thread, turn, kind, project, identity)
+        body=value.get('last_assistant_message') or value.get('last-assistant-message') or ''
+        if kind=='input':
+            tool_input=value.get('tool_input')
+            questions=tool_input.get('questions',[]) if isinstance(tool_input,dict) else []
+            if questions and isinstance(questions[0],dict):
+                body=questions[0].get('question') or questions[0].get('title') or ''
+        self.decorate(thread,body=body)
+
+    def pending(self):
+        row = self.db.execute('SELECT * FROM events WHERE delivered=0 ORDER BY id LIMIT 1').fetchone()
+        return dict(row) if row else None
+
+    def delivered(self, event_id):
+        self.db.execute('UPDATE events SET delivered=1 WHERE id=?', (event_id,))
+        self.db.commit()
+
+    def mark_read(self, event_id):
+        self.db.execute('UPDATE events SET read=1 WHERE id<=?', (event_id,))
+        self.db.commit()
+
+    def summary(self):
+        counts = dict(self.db.execute('SELECT status,count(*) FROM sessions WHERE updated>? GROUP BY status', (time.time()-86400,)))
+        unread = self.db.execute('SELECT count(*) FROM events WHERE read=0').fetchone()[0]
+        latest = self.db.execute('SELECT coalesce(max(id),0) FROM events').fetchone()[0]
+        return {'running': counts.get('started', 0) + counts.get('compacting', 0),
+                'waiting': counts.get('approval', 0) + counts.get('input', 0),
+                'unread': unread, 'latest': latest}
+
+    def inbox(self, limit=4):
+        return [dict(r) for r in self.db.execute(
+            "SELECT * FROM events WHERE id IN (SELECT max(id) FROM events WHERE kind IN ('completed','failed','interrupted','approval','input') GROUP BY thread) ORDER BY id DESC LIMIT ?",(limit,))]
+
+    def recent(self, limit=4):
+        return [dict(r) for r in self.db.execute('SELECT * FROM events ORDER BY id DESC LIMIT ?', (limit,))]
+
+    def close(self):
+        self.db.close()

codex_passport/usage.py

@@ -0,0 +1,87 @@
+"""Read-only JSON-RPC adapter. No authentication files or tokens are inspected."""
+import asyncio
+import json
+import math
+import time
+from . import __version__
+
+
+def normalize(response):
+    buckets = response.get('rateLimitsByLimitId') or {}
+    value = buckets.get('codex') or response.get('rateLimits') or {}
+    windows = []
+    for name in ('primary', 'secondary'):
+        w = value.get(name)
+        if not isinstance(w, dict):
+            windows.append(None)
+            continue
+        used, duration, reset = w.get('usedPercent'), w.get('windowDurationMins'), w.get('resetsAt')
+        if (isinstance(used, bool) or not isinstance(used, (float, int)) or not math.isfinite(used)
+                or not 0 <= used <= 100 or not isinstance(duration, int) or duration <= 0
+                or not isinstance(reset, int) or reset <= 0):
+            windows.append(None)
+        else:
+            windows.append({'remaining': round(100-used), 'minutes': duration, 'reset': reset})
+    return {'windows': windows, 'updated': int(time.time()), 'plan': str(value.get('planType') or 'unknown')[:24]}
+
+
+class UsageClient:
+    def __init__(self, executable='codex'):
+        self.executable = executable
+        self.process = None
+        self.serial = 0
+
+    async def close(self):
+        if self.process is not None:
+            if self.process.returncode is None:
+                self.process.terminate()
+                try:
+                    await asyncio.wait_for(self.process.wait(), 2)
+                except asyncio.TimeoutError:
+                    self.process.kill()
+                    await self.process.wait()
+            self.process = None
+
+    async def request(self, method, params=None):
+        self.serial += 1
+        message = {'id': self.serial, 'method': method}
+        if params is not None:
+            message['params'] = params
+        self.process.stdin.write((json.dumps(message)+'\n').encode())
+        await self.process.stdin.drain()
+        async def response():
+            while True:
+                line = await self.process.stdout.readline()
+                if not line:
+                    raise RuntimeError('Codex app-server closed')
+                data = json.loads(line)
+                if data.get('id') != self.serial or 'method' in data:
+                    continue
+                if 'error' in data:
+                    raise RuntimeError('Codex request unavailable: ' + method)
+                return data.get('result', {})
+        return await asyncio.wait_for(response(), 12)
+
+    async def fetch(self):
+        try:
+            if self.process is None or self.process.returncode is not None:
+                self.process = await asyncio.create_subprocess_exec(
+                    self.executable, 'app-server', stdin=asyncio.subprocess.PIPE,
+                    stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL,
+                    limit=4*1024*1024)
+                await self.request('initialize', {'clientInfo': {'name': 'codex-passport-sync', 'version': __version__}})
+                self.process.stdin.write(b'{"method":"initialized"}\n')
+                await self.process.stdin.drain()
+            limits = normalize(await self.request('account/rateLimits/read'))
+            try:
+                activity = await self.request('account/usage/read')
+                limits['tokens'] = (activity.get('summary') or {}).get('lifetimeTokens')
+                today = time.strftime('%Y-%m-%d')
+                limits['today'] = next((x.get('tokens') for x in activity.get('dailyUsageBuckets') or []
+                                       if x.get('startDate') == today), None)
+            except RuntimeError:
+                pass  # Older Codex versions may not expose token-activity summaries.
+            return limits
+        except BaseException:
+            await self.close()
+            raise

codex_passport_sync-0.1.1.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.5
+Name: codex-passport-sync
+Version: 0.1.1
+Summary: Local Codex lifecycle notifications and usage for FoloToy AI Passport
+Project-URL: Homepage, https://github.com/JuneLeGency/codex-passport
+Project-URL: Documentation, https://github.com/JuneLeGency/codex-passport/blob/main/docs/GETTING_STARTED.zh_CN.md
+Project-URL: Repository, https://github.com/JuneLeGency/codex-passport
+Project-URL: Issues, https://github.com/JuneLeGency/codex-passport/issues
+Project-URL: Changelog, https://github.com/JuneLeGency/codex-passport/releases
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: pyserial<4,>=3.5
+Provides-Extra: ble
+Requires-Dist: bleak<4,>=1.1; extra == 'ble'
+Description-Content-Type: text/markdown
+
+# Codex Passport
+
+Codex session notifications and quota visualization on FoloToy AI Passport, with an Android companion.
+
+**[从零开始：中文一步步入门](https://github.com/JuneLeGency/codex-passport/blob/main/docs/GETTING_STARTED.zh_CN.md)** · [中文介绍](https://github.com/JuneLeGency/codex-passport/blob/main/README.zh_CN.md) · [Python / uvx guide](https://github.com/JuneLeGency/codex-passport/blob/main/docs/PYTHON.md) · [Downloads](https://github.com/JuneLeGency/codex-passport/releases)
+
+<img src="https://raw.githubusercontent.com/JuneLeGency/codex-passport/main/docs/images/dashboard-example.png" alt="Passport graphical quota dashboard" width="240">
+
+Synthetic quota fixture rendered on the physical device; no account or conversation data.
+
+## What it does
+
+- Computer → encrypted BLE → Passport, or computer → private LAN/WireGuard → Android → encrypted BLE → Passport.
+- Meaningful completion, failure, interruption, approval and input notifications across local Codex sessions. Starts and housekeeping update silently; internal guardian/memory workers are excluded.
+- Durable delivery queue, device acknowledgements, offline replay, and one active BLE sender with phone fallback.
+- Remaining quota compared with remaining cycle time. Orange means faster consumption, green balanced, blue slower.
+- Native 240×320 Passport dashboard and physical-button controls. Material 3 Expressive Android overview, notification and connection pages.
+
+Phone notifications show bounded titles and summaries for the four most recent sessions. Passport receives quota, counts and receipt IDs, with no conversation text.
+**This version does not resume conversations, send replies or approve actions.** Those stay in Codex.
+Hooks need existing sessions to restart after installation; incremental logs are a compatibility fallback, not a stable API or Codex Mobile push integration.
+Other computers need their own collectors.
+
+## Get started
+
+The [beginner guide](https://github.com/JuneLeGency/codex-passport/blob/main/docs/GETTING_STARTED.zh_CN.md) covers tool installation, backup/app-only flashing, APK installation without ADB, relay configuration, pairing, a real notification test, startup, switching, troubleshooting and removal.
+It uses the verified macOS + Android + Passport setup. Linux host deployment needs platform adaptation; Windows host deployment has not been validated.
+
+Download the ready-made [Android APK and Passport firmware v0.1.0](https://github.com/JuneLeGency/codex-passport/releases/tag/v0.1.0).
+Python 0.1.1 is a documentation/packaging update compatible with those device files; no device reinstall is needed for this update.
+The APK is debug-signed. Back up the device before flashing and write **only the app at 0x10000 on the documented hardware layout**, preserving its other partitions.
+
+## Python installation
+
+Requires Python 3.10+ and a working, logged-in Codex CLI. Install [uv](https://docs.astral.sh/uv/getting-started/installation/), then try:
+
+```sh
+uvx --from 'codex-passport-sync==0.1.1' codex-passport --help
+```
+
+For persistent hooks, install a persistent tool environment instead:
+
+```sh
+uv tool install 'codex-passport-sync[ble]==0.1.1'
+uv tool update-shell
+```
+
+Open a new terminal, then:
+
+```sh
+codex-passport install-hooks
+export COMPUTER_LAN_IP="replace-with-this-computers-private-IP"
+codex-passport serve --host "$COMPUTER_LAN_IP" --port 18765
+```
+
+Keep that terminal open. Configure Android's Connection page with `http://YOUR_COMPUTER_IP:18765` and the contents of `~/.local/state/codex-passport/relay-token`.
+Allow Bluetooth permissions and enter the current six-digit Passport code in the phone's system pairing dialog.
+Restart existing Codex sessions to load the hooks. The address is the relay API, not wireless ADB or a WireGuard endpoint.
+
+Add `--ble "Passport-XXXXXX"` using your device's actual advertised name for computer BLE. First pairing requires the computer's OS dialog and Bluetooth permission.
+The `[ble]` extra is required for this route. Select the sender on Android's Connection page; a failed computer connection falls back to the phone and stays there until selected again.
+Do not install permanent hooks from a temporary uvx environment, whose cache can be removed.
+
+[PyPI package](https://pypi.org/project/codex-passport-sync/) · [Wheel downloads](https://github.com/JuneLeGency/codex-passport/releases/tag/v0.1.1) · [All installation options and state paths](https://github.com/JuneLeGency/codex-passport/blob/main/docs/PYTHON.md)
+
+## Daily controls and scope
+
+| Control | Result |
+| --- | --- |
+| UP / DOWN | Switch quota windows |
+| Short OK while awake | Mark received notifications read; never approve an action |
+| First press while asleep | Wake only |
+| Hold OK while awake | Reconnect BLE, preserving bonds |
+
+The backlight sleeps after 60 seconds without alerts/buttons. Daily BLE frames contain no conversation text.
+An authenticated private relay and paired BLE protect access; bounded phone summaries can still contain private context.
+Keep the relay within your private network/VPN. Do not expose its HTTP port publicly. The computer must stay awake and run the collector.
+
+Both BLE routes, route switching, replay and physical controls were validated. Off-LAN WireGuard and battery endurance were not measured.
+See the [validation record](https://github.com/JuneLeGency/codex-passport/blob/main/docs/VALIDATION.md) for the exact evidence and limitations.
+
+## Development and attribution
+
+[Build instructions](https://github.com/JuneLeGency/codex-passport/blob/main/docs/DEVELOPMENT.md) · [MIT license](https://github.com/JuneLeGency/codex-passport/blob/main/LICENSE) · [Third-party notices](https://github.com/JuneLeGency/codex-passport/blob/main/THIRD_PARTY.md)
+
+Application code is independently authored. Official FoloToy BSP, Material Components and other dependencies retain their own licenses.
+The [reference application](https://github.com/zt20/codex-usage-ai-passport) was studied, not copied.
+This is a community project, not an official OpenAI or FoloToy product.

codex_passport_sync-0.1.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+codex_passport/__init__.py,sha256=sELAPBjn5zoY87T_R0aplM-DNSwBziCaggeddlZjY6I,70
+codex_passport/__main__.py,sha256=z3OQolCKD8rUd3pKYp_FISq2VctFhFl1mV-DVnaoNOM,29
+codex_passport/ble.py,sha256=lEQ23YexDMQAYc4d4tviExTRI65N-EPgefC9gOWLprY,5481
+codex_passport/cli.py,sha256=uwGVhz0a6Wcm2QHG2zgzrHM-Gvnzbdt1gNT439qXFlQ,12087
+codex_passport/relay.py,sha256=ay5rbApvMikCepsNOgowQ_ZmLGq2KkLkXFFVtOYE0Q0,5162
+codex_passport/routing.py,sha256=qNEITmk1fyEHl9JN4U6Lu-hQnJ3iWEogN1F-46heUng,1798
+codex_passport/sessions.py,sha256=yzuk8ucRhpVNRJIHHvNw1uAJ9BnBm9xvHS0C3D1_yE0,7409
+codex_passport/store.py,sha256=osXCPugZeIF_FTSxkL0w2B_fmo1rhSYzbCU8HLVN8To,10325
+codex_passport/usage.py,sha256=mFj0vKKc1XmWUOZGQ61MT-w9u4nkoQthSY2Y0844E0w,3881
+codex_passport_sync-0.1.1.dist-info/METADATA,sha256=INE7yZSRR1xrJnIERwbuXarzu2lSneC3aP51MRBfblQ,6856
+codex_passport_sync-0.1.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+codex_passport_sync-0.1.1.dist-info/entry_points.txt,sha256=VWjP4rZ2kXGmSmpzBGwM3qJlyA8sh01rGeUbGtv6lOg,59
+codex_passport_sync-0.1.1.dist-info/licenses/LICENSE,sha256=S1uVaafz-ejH7BFkY9odpU54ZqEKtIWZce5YDA-G994,1084
+codex_passport_sync-0.1.1.dist-info/RECORD,,

codex_passport_sync-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

codex_passport_sync-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codex-passport = codex_passport.cli:main

codex_passport_sync-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Codex Passport contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.