@topolo/cli 0.12.33 → 0.13.1

package/agent-packs/src/topolo_agent_pack/claude.py

@@ -0,0 +1,265 @@
+"""Versioned Claude Code Desktop session import. Never rewrites live app records.
+
+Fresh role files and CLI transcripts are owned by this adapter. Desktop adopts
+them through its native resume handoff. There is no external archive API in
+that handoff; full roster replacement is therefore refused, not simulated.
+"""
+import argparse
+import hashlib
+import json
+import os
+import pathlib
+import pty
+import select as io_select
+import shutil
+import subprocess
+import sys
+import time
+import uuid
+
+from .storage import Library, PackError, atomic_json, canonical, now, safe_id, select
+
+
+def find_binary():
+    root = pathlib.Path.home() / 'Library/Application Support/Claude/claude-code'
+    candidates = list(root.glob('*/*/claude.app/Contents/MacOS/claude'))
+    if candidates:
+        return str(max(candidates, key=lambda p: tuple(int(x) for x in p.relative_to(root).parts[0].split('.'))))
+    return shutil.which('claude')
+
+
+def handoff(binary, directory, session_id):
+    """Native --desktop requires a TTY. No prompt, model call or shell is used."""
+    if not binary:
+        raise PackError('Claude Code 2.1.285+ is required; install Claude Desktop or Claude Code.')
+    version = subprocess.run([binary, '--version'], capture_output=True, text=True, timeout=10)
+    if version.returncode or not version.stdout.startswith('2.1.289 '):
+        raise PackError('This native import adapter is qualified for Claude Code 2.1.289; selected binary: ' + version.stdout.strip())
+    master, slave = pty.openpty()
+    process = None
+    output = bytearray()
+    try:
+        process = subprocess.Popen([binary, '--desktop', '--resume', session_id],
+                                   cwd=directory, stdin=slave, stdout=slave, stderr=slave)
+        os.close(slave)
+        slave = None
+        deadline = time.monotonic() + 20
+        while process.poll() is None:
+            if time.monotonic() >= deadline:
+                raise PackError('Claude Desktop handoff timed out; run recover to reconcile imports.')
+            if io_select.select([master], [], [], .1)[0]:
+                try:
+                    chunk = os.read(master, 65536)
+                except OSError:
+                    break
+                output.extend(chunk)
+                if len(output) > 65536:
+                    raise PackError('Claude Desktop handoff exceeded its output limit.')
+        process.wait(timeout=2)
+        if process.returncode or ('Opening session ' + session_id) not in output.decode(errors='replace'):
+            raise PackError('Claude refused the native Desktop handoff: ' + output.decode(errors='replace')[-2000:])
+    finally:
+        if process is not None and process.poll() is None:
+            process.terminate()
+            process.wait(timeout=5)
+        if slave is not None:
+            os.close(slave)
+        os.close(master)
+
+
+def project_directory(config, directory):
+    # The native CLI's current path-key codec. A versioned compatibility boundary.
+    import re
+    key = re.sub(r'[^a-zA-Z0-9]', '-', str(directory))
+    if len(key) > 200:
+        raise PackError('Claude project path exceeds the qualified path-key boundary (200 characters).')
+    return config / 'projects' / key
+
+
+def write_new(path, data):
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    if path.exists() or path.is_symlink():
+        if path.is_symlink() or not path.is_file() or path.read_bytes() != data:
+            raise PackError('Refusing to overwrite existing context or transcript: ' + str(path))
+        return
+    with path.open('xb') as stream:
+        stream.write(data)
+        stream.flush()
+        os.fsync(stream.fileno())
+    path.chmod(0o600)
+
+
+def materialize(lib, name, selected, config):
+    manifest, revision = lib.load(name)
+    if manifest.get('startingContext', {}).get('kind') != 'fresh':
+        raise PackError('Claude import requires a fresh pack with reviewed role files; old Codex history is not translated.')
+    records = []
+    root = lib.root / 'claude'
+    for agent in selected:
+        safe_id(agent['set'])
+        safe_id(agent['id'])
+        key = name + '/' + agent['set'] + '/' + agent['id']
+        identity = root / 'identities' / (hashlib.sha256(key.encode()).hexdigest() + '.json')
+        if identity.exists():
+            record = json.loads(identity.read_text())
+            if record['sourceRevision'] != revision:
+                raise PackError('Existing Claude agent uses a different revision; build a new named pack to preserve its context.')
+            if record['importState'] != 'preparing':
+                records.append(record)
+                continue
+        else:
+            session_id = str(uuid.uuid4())
+            workspace = root / 'workspaces' / name / agent['set'] / agent['id']
+            record = {'key': key, 'pack': name, 'set': agent['set'], 'agent': agent['id'],
+                      'title': agent['title'], 'pinnedRequested': agent.get('pinned', False),
+                      'sourceRevision': revision, 'sourceCodexThreadId': agent['threadId'],
+                      'cliSessionId': session_id, 'desktopSessionId': 'local_' + session_id,
+                      'workspace': str(workspace),
+                      'transcript': str(project_directory(config, workspace) / (session_id + '.jsonl')),
+                      'importState': 'preparing', 'createdAt': now(), 'bootstrapUuid': str(uuid.uuid4())}
+            # Save allocation before any workspace/transcript write. Retrying a
+            # interrupted preparation uses the same IDs and compares old bytes.
+            atomic_json(identity, record)
+        original = pathlib.Path(manifest['threads'][agent['threadId']]['cwd'])
+        workspace = pathlib.Path(record['workspace'])
+        if workspace.is_symlink():
+            raise PackError('Claude workspace must not be a symlink')
+        workspace.mkdir(parents=True, exist_ok=True, mode=0o700)
+        resources = [r for r in manifest['resources'] if pathlib.Path(r['original']).is_relative_to(original)]
+        instructions = next((r for r in resources if pathlib.Path(r['original']).relative_to(original).as_posix() == 'AGENTS.md'), None)
+        if instructions is None:
+            raise PackError('Missing reviewed role instructions for ' + key)
+        for resource in resources:
+            relative = pathlib.Path(resource['original']).relative_to(original)
+            if '..' in relative.parts or any(p.is_symlink() for p in (workspace / relative).parents if p != lib.root.parent):
+                raise PackError('Unsafe context path: ' + str(relative))
+            # Never copy runtime state, prior tasks, scripts or credentials into a role.
+            if relative.suffix != '.md' or relative.as_posix() == 'context/TEAM.md':
+                continue
+            if relative.as_posix() == 'AGENTS.md':
+                relative = pathlib.Path('CLAUDE.md')
+            write_new(workspace / relative, lib.object(resource['content']).read_bytes())
+        session_id = record['cliSessionId']
+        transcript = pathlib.Path(record['transcript'])
+        note = (agent['title'] + '. You are this Topolo Agent Pack role in Claude Desktop. '
+                'Read CLAUDE.md and relevant context/ files before work. '
+                'This is starting context only; no assignment, claim or prior conversation is inherited. '
+                'Await a new human request. Coordination requires human authorization.')
+        rows = [{'parentUuid': None, 'isSidechain': False, 'userType': 'external',
+                 'cwd': str(workspace), 'sessionId': session_id, 'version': '2.1.289',
+                 'type': 'user', 'message': {'role': 'user', 'content': note},
+                 'uuid': record['bootstrapUuid'], 'timestamp': record['createdAt']},
+                {'type': 'custom-title', 'sessionId': session_id, 'customTitle': agent['title']}]
+        write_new(transcript, b''.join(canonical(row) + b'\n' for row in rows))
+        record['importState'] = 'prepared'
+        atomic_json(identity, record)
+        records.append(record)
+    team = ('# Claude pack roster\n\nThese are Claude Desktop session identities. '
+            'No task, claim, messaging authorization or hosted connection is granted by this roster.\n\n' +
+            '\n'.join('- ' + a['key'] + ' | ' + a['title'] + ' | ' + a['desktopSessionId'] for a in records) + '\n')
+    for record in records:
+        context = pathlib.Path(record['workspace']) / 'context'
+        write_new(context / ('TEAM-' + hashlib.sha256(team.encode()).hexdigest()[:16] + '.md'), team.encode())
+        pointer = context / 'TEAM.md'
+        if not pointer.exists():
+            write_new(pointer, b'# Claude team identities\n\nRead TEAM-*.md for immutable Claude roster snapshots. Use topolo-agent-pack status --harness claude for current membership. Only human-authorized coordination is permitted.\n')
+    return records
+
+
+def readback(records, app_data):
+    results = []
+    for record in records:
+        files = list((app_data / 'claude-code-sessions').glob('*/*/' + record['desktopSessionId'] + '.json'))
+        if len(files) != 1:
+            results.append({'key': record['key'], 'verified': False, 'reason': 'unique Desktop adoption record missing'})
+            continue
+        state = json.loads(files[0].read_text())
+        ok = (state.get('cliSessionId') == record['cliSessionId'] and
+              state.get('title') == record['title'] and
+              state.get('cwd') == record['workspace'] and not state.get('isArchived'))
+        results.append({'key': record['key'], 'desktopSessionId': record['desktopSessionId'],
+                        'verified': ok, 'completedTurns': state.get('completedTurns') or 0,
+                        'record': str(files[0])})
+    return results
+
+
+def parser():
+    p = argparse.ArgumentParser(description='Claude Code Desktop pack sessions (native sidebar import; full switch is not yet supported).')
+    p.add_argument('--store', default=os.environ.get('CODEX_PACK_HOME', str(pathlib.Path.home() / 'AgentPacks')))
+    p.add_argument('--claude-config', default=str(pathlib.Path.home() / '.claude'))
+    p.add_argument('--claude-data', default=str(pathlib.Path.home() / 'Library/Application Support/Claude'))
+    sub = p.add_subparsers(dest='command', required=True)
+    for action in ['add', 'switch', 'replace']:
+        q = sub.add_parser(action)
+        q.add_argument('source')
+        q.add_argument('--set', '--group', dest='sets', action='append')
+        q.add_argument('--agent', dest='agents', action='append')
+        q.add_argument('--catalog', action='store_true')
+        q.add_argument('--no-open', action='store_true')
+        q.add_argument('--import-only', action='store_true', help='Explicit incomplete native session import; does not activate pack settings')
+        q.add_argument('--claude-bin', default=find_binary())
+    for action in ['status', 'doctor', 'recover', 'list']:
+        sub.add_parser(action)
+    return p
+
+
+def main(argv):
+    args = parser().parse_args(argv)
+    try:
+        lib = Library(args.store)
+        app_data = pathlib.Path(args.claude_data).expanduser().resolve()
+        state_path = lib.root / 'claude/state.json'
+        with lib.lock():
+            state = json.loads(state_path.read_text()) if state_path.exists() else {'schemaVersion': 1, 'harness': 'claude', 'agents': []}
+            if args.command in {'status', 'doctor', 'recover', 'list'}:
+                proof = readback(state['agents'], app_data)
+                active_path = lib.root / 'claude/active.json'
+                pending_path = lib.root / 'claude/native-operation.json'
+                result = {**state, 'adoptionProof': proof, 'verifiedAgents': sum(p['verified'] for p in proof),
+                          'fullPackSwitchSupported': False, 'sidebarGroupsAndPinsVerified': False,
+                          'nativeRecordsRewritten': False, 'modelIdentityResponseVerified': False,
+                          'activationReady': False, 'modelAndPermissionSettingsVerified': False,
+                          'lastVerifiedActiveRoster': json.loads(active_path.read_text()) if active_path.exists() else None,
+                          'nativeRecoveryRequired': pending_path.exists(),
+                          'nativeRecoveryReplayed': False,
+                          'verificationBoundary': 'read-only adoption records; use the explicit native connection for current settings or recovery'}
+            else:
+                if (lib.root / 'claude/native-operation.json').exists():
+                    raise PackError('An unresolved native Claude operation blocks imports and preparation. Use topolo agent-packs recover with the explicit native connection; no effects are replayed.')
+                manifest, revision = lib.load(args.source)
+                chosen = select(manifest, args.sets, args.agents)
+                keys = {args.source + '/' + a['set'] + '/' + a['id'] for a in chosen}
+                outgoing = {a['key'] for a in state['agents']} - keys
+                if args.command in {'switch', 'replace'} and outgoing:
+                    raise PackError('Claude full-pack replacement is not qualified: native --desktop --resume cannot archive the outgoing roster. No changes were made. Use add for sidebar import.')
+                if not args.no_open and not args.import_only:
+                    raise PackError('Claude pack activation requires a qualified live backend for groups, pins, model and permission settings. No changes were made. --no-open prepares context; --import-only explicitly imports sessions without completing pack activation.')
+                records = materialize(lib, args.source, chosen, pathlib.Path(args.claude_config).expanduser().resolve())
+                combined = {a['key']: a for a in state['agents']}
+                combined.update({a['key']: a for a in records})
+                state = {**state, 'agents': list(combined.values()), 'updatedAt': now()}
+                # Durable recovery plan before asking Desktop to adopt a session.
+                atomic_json(state_path, state)
+                if not args.no_open:
+                    for record in records:
+                        if not readback([record], app_data)[0]['verified']:
+                            handoff(args.claude_bin, record['workspace'], record['cliSessionId'])
+                            deadline = time.monotonic() + 15
+                            while not readback([record], app_data)[0]['verified']:
+                                if time.monotonic() > deadline:
+                                    raise PackError('Desktop adoption not verified for ' + record['key'] + '; run recover.')
+                                time.sleep(.1)
+                        record['importState'] = 'desktop-adopted'
+                        atomic_json(state_path, state)
+                proof = readback(records, app_data)
+                result = {'harness': 'claude', 'state': 'prepared' if args.no_open else 'desktop-adopted',
+                          'selectedAgents': len(records), 'verifiedAgents': sum(p['verified'] for p in proof),
+                          'adoptionProof': proof, 'fullPackSwitchSupported': False,
+                          'previousCodexHistoryCopied': False, 'nativeRecordsRewritten': False,
+                          'sidebarGroupsAndPinsVerified': False, 'activationReady': False,
+                          'modelAndPermissionSettingsVerified': False}
+        print(json.dumps(result, indent=2))
+        return 0
+    except (PackError, OSError, ValueError, KeyError, subprocess.SubprocessError) as exc:
+        print('topolo-agent-pack (Claude): ' + str(exc), file=sys.stderr)
+        return 2