@topolo/cli 0.13.19 → 0.13.21

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

@@ -0,0 +1,74 @@
+"""Supported native coordinator conversation and typed broker-tool boundary.
+
+The native prompt_id is the deduplication identity. No transcript, chat export,
+or locally generated substitute is consulted when it is missing.
+"""
+import json
+import pathlib
+import sys
+import uuid
+
+from .storage import Library, PackError, read_json
+from .work import require
+
+
+def submit(root, event, send=None):
+    require(isinstance(event, dict), 'Native Claude hook input must be an object')
+    lib = Library(root)
+    binding = read_json(lib.root / 'work/claude-frontdoors.json')
+    require(binding.get('format') == 'topolo-claude-frontdoors-v1',
+            'Claude front-door binding is not installed')
+    require(event.get('hook_event_name') in {'UserPromptSubmit', 'PreToolUse'},
+            'Unsupported Claude front-door hook')
+    rows = [r for r in binding['roles'] if r['sessionId'] == event.get('session_id')
+            and r['cwd'] == event.get('cwd')]
+    require(len(rows) == 1, 'Native Claude session is not the bound front door')
+    role = rows[0]
+    if event['hook_event_name'] == 'PreToolUse':
+        from .coordinator_context import tool_allowed
+        try:allowed=tool_allowed(lib.root,role,event)
+        except (PackError,ValueError,TypeError,OSError):allowed=False
+        return {'hookSpecificOutput': {'hookEventName': 'PreToolUse',
+                'permissionDecision': 'allow' if allowed else 'deny', 'permissionDecisionReason':
+                'Use only the exact broker schemas in the current Topolo coordinator context. For continuation: read the existing task, then Write {requestId: dispatchRequestId, taskId, revision: latest task.revision, intent: continue/request_changes/hold, note} to context/coordinator-request.json and run the installed respond --input command. Do not use {taskId,message}, create a replacement task, or perform engineering effects.'}}
+    identity = event.get('prompt_id')
+    try:
+        valid = isinstance(identity, str) and str(uuid.UUID(identity)) == identity
+    except ValueError:
+        valid = False
+    require(valid, 'Native Claude prompt identity is unavailable; no task was submitted')
+    require(event.get('permission_mode') == 'bypassPermissions',
+            'Claude front-door startup permissions differ from the installation')
+    require(isinstance(event.get('prompt'),str) and 1<=len(event['prompt'])<=16000,'Bounded native human input required')
+    if send is None:
+        from .live import request as live_request
+        send = lambda operation, params: live_request(lib, operation, params)
+    status = send('status', {})
+    require(status.get('harness') == 'claude' and status.get('cloudDispatchReady') is True
+            and status.get('desktopPid') == binding.get('desktopPid'),
+            'Claude cloud dispatch is not active; the coordinator will not execute the request itself')
+    from .coordinator_context import prepare
+    selected=prepare(lib.root,role,event,send('work-list',{}))
+    return {'hookSpecificOutput': {'hookEventName': 'UserPromptSubmit',
+            'additionalContext':'Topolo coordinator context (the original human prompt is unchanged; no task was submitted):\n'+json.dumps(selected,sort_keys=True,separators=(',',':'))}}
+
+
+
+def main(root, stream=None):
+    try:
+        source = (stream or sys.stdin).read(100001)
+        require(len(source) <= 100000, 'Claude hook input exceeds its boundary')
+        event = json.loads(source)
+        if isinstance(event, dict) and event.get('hook_event_name') == 'UserPromptSubmit':
+            from .claude_service import ensure_running, refresh_desktop_owner
+            lib = Library(root)
+            refresh_desktop_owner(lib)
+            ensure_running(lib)
+        result = submit(pathlib.Path(root), event)
+        print(json.dumps(result))
+        return 0
+    except Exception as exc:
+        # Nonzero hook exit blocks direct execution on a failed handoff. Never
+        # print the incoming human prompt or a transcript in a diagnostic.
+        print('Topolo handoff unavailable: ' + str(exc), file=sys.stderr)
+        return 2

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

@@ -0,0 +1,207 @@
+"""Single-use supported Claude Code worker, without a terminal or saved history.
+
+The Desktop front doors remain separate. This adapter retires a process, not a
+Desktop chat, and never represents a CLI process exit as native chat archival.
+"""
+import asyncio
+import json
+import os
+import pathlib
+import shlex
+import signal
+import sys
+import uuid
+
+from .claude import find_binary
+from .storage import atomic_json, read_json, PackError
+from .work import require
+
+
+def public_progress(text):
+    if not text.strip() or '```' in text:
+        return False
+    try:
+        json.loads(text)
+    except ValueError:
+        return True
+    return False
+
+
+def hook(directory, event):
+    directory = pathlib.Path(directory)
+    gate = read_json(directory / 'gate.json')
+    require(event.get('session_id') == gate['sessionId'], 'Worker hook session differs')
+    kind = event.get('hook_event_name')
+    if kind == 'PreToolUse':
+        allowed = gate['phase'] == 'assigned' and gate.get('allowTools') is True and event.get('permission_mode') == 'bypassPermissions'
+        allowed = allowed and event.get('effort', {}).get('level') == gate['effort']
+        allowed = allowed and event.get('tool_name') not in {'Agent', 'Task', 'Skill', 'EnterWorktree', 'ExitWorktree'}
+        return {'hookSpecificOutput': {'hookEventName': kind,
+                'permissionDecision': 'allow' if allowed else 'deny',
+                'permissionDecisionReason': 'Topolo bounded worker phase and native effort gate'}}
+    require(kind in {'UserPromptSubmit', 'Stop'}, 'Unsupported worker hook')
+    with (directory / 'native-settings.jsonl').open('a') as stream:
+        stream.write(json.dumps({k: event.get(k) for k in
+                    ['session_id', 'prompt_id', 'hook_event_name', 'permission_mode', 'effort']}) + '\n')
+    return {}
+
+
+def hook_main(directory):
+    try:
+        raw = sys.stdin.read(100001)
+        require(len(raw) <= 100000, 'Worker hook input exceeds its boundary')
+        print(json.dumps(hook(directory, json.loads(raw))))
+        return 0
+    except Exception as exc:
+        print('Topolo worker gate refused: ' + str(exc), file=sys.stderr)
+        return 2
+
+
+class Session:
+    def __init__(self, cwd, worker_id, model, effort, progress=None):
+        require(str(uuid.UUID(worker_id)) == worker_id, 'Exact worker UUID required')
+        self.cwd = pathlib.Path(cwd)
+        self.id = worker_id
+        self.model = model
+        self.effort = effort
+        self.progress = progress
+        self.directory = self.cwd / '.topolo-worker'
+        self.directory.mkdir(mode=0o700)
+        self.process = None
+        self.pending = None
+        self.results = {}
+        self.init = None
+        self.closed = False
+        self.assigned = False
+        self.allow_tools = True
+        self.expected_email = None
+        self.auth_config_directory = None
+        self.tool_path = None
+
+    async def start(self):
+        binary = find_binary()
+        require(binary is not None, 'Signed-in Claude Code runtime is required')
+        gate = {'sessionId': self.id, 'model': self.model, 'effort': self.effort, 'phase': 'readiness'}
+        atomic_json(self.directory / 'gate.json', gate)
+        adapter = pathlib.Path(__file__).resolve().parents[2] / 'topolo-agent-pack'
+        require(adapter.is_file(), 'Installed bundled worker-hook entrypoint is unavailable')
+        command = shlex.join([sys.executable, str(adapter), 'work', 'claude-worker-hook',
+                             '--harness', 'claude', '--input', str(self.directory)]) + ' || exit 2'
+        settings = {'autoMemoryEnabled': False, 'hooks': {
+            event: [{'hooks': [{'type': 'command', 'command': command, 'timeout': 15}]}]
+            for event in ['UserPromptSubmit', 'Stop', 'PreToolUse']}}
+        atomic_json(self.directory / 'settings.json', settings)
+        env = dict(os.environ)
+        # Use the explicitly bound native profile's supported subscription login;
+        # never copy a token or silently select default-profile/API-key billing.
+        require(not any(env.get(k) for k in ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN',
+                    'CLAUDE_CODE_OAUTH_TOKEN', 'ANTHROPIC_BASE_URL']),
+                'Explicit provider or credential overrides are outside this subscription worker binding')
+        require(self.auth_config_directory is not None, 'An explicitly bound Claude authentication profile is required')
+        env['CLAUDE_CONFIG_DIR'] = self.auth_config_directory
+        env.pop('CLAUDECODE', None)
+        env['PYTHONPATH'] = str(pathlib.Path(__file__).resolve().parent.parent)
+        if self.tool_path is not None:
+            env['PATH'] = self.tool_path
+        auth = await asyncio.create_subprocess_exec(binary, 'auth', 'status', '--json', env=env,
+                stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL)
+        try:
+            stdout, _ = await asyncio.wait_for(auth.communicate(), 15)
+        finally:
+            if auth.returncode is None:
+                auth.kill()
+                await auth.wait()
+        account = json.loads(stdout)
+        require(auth.returncode == 0 and account.get('loggedIn') is True and account.get('authMethod') == 'claude.ai'
+                and self.expected_email is not None and account.get('email') == self.expected_email,
+                'The signed-in Claude subscription account differs from the installation')
+        stderr = (self.directory / 'stderr.log').open('wb')
+        try:
+            self.process = await asyncio.create_subprocess_exec(binary, '--print',
+                '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose',
+                '--replay-user-messages', '--session-id', self.id, '--no-session-persistence',
+                '--model', self.model, '--effort', self.effort, '--permission-mode', 'bypassPermissions',
+                '--setting-sources', '', '--settings', str(self.directory / 'settings.json'),
+                '--strict-mcp-config', '--mcp-config', '{"mcpServers":{}}',
+                '--append-system-prompt-file', str(self.cwd / 'CLAUDE.md'), cwd=self.cwd, env=env,
+                stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, stderr=stderr,
+                limit=2 * 1024 * 1024, start_new_session=True)
+        finally:
+            stderr.close()
+        ready = 'TOPOLO_WORKER_READY:' + self.id
+        result = await self.exchange(self.id, 'Readiness only. Do not use tools or perform work. Reply exactly ' + ready)
+        require(result['output'].strip() == ready and result['toolItems'] == 0,
+                'The exact tool-free readiness probe did not complete')
+        proofs = [json.loads(line) for line in (self.directory / 'native-settings.jsonl').read_text().splitlines()]
+        require(any(p['hook_event_name'] == 'UserPromptSubmit' and p['permission_mode'] == 'bypassPermissions' for p in proofs)
+                and any(p['hook_event_name'] == 'Stop' and isinstance(p['effort'], dict)
+                        and p['effort'].get('level') == self.effort for p in proofs),
+                'Actual native permission and effort acknowledgement is unavailable')
+        return {'model': self.model, 'effort': self.effort, 'sessionId': self.id,
+                'processId': self.process.pid, 'boundary': 'native init, readiness result and Stop hook'}
+
+    async def assign(self, message_id, prompt):
+        require(not self.assigned and self.pending is None, 'This worker already has an assignment; reconcile without resend')
+        self.assigned = True
+        atomic_json(self.directory / 'gate.json', {'sessionId': self.id, 'model': self.model,
+                    'effort': self.effort, 'phase': 'assigned', 'allowTools': self.allow_tools})
+        return await self.exchange(message_id, prompt)
+
+    async def exchange(self, message_id, prompt):
+        require(self.process is not None and not self.closed and self.pending is None,
+                'Native worker is not ready for one exact input')
+        self.pending = message_id
+        # A create-only marker precedes stdin delivery. Lost acknowledgements
+        # retain the UUID; neither startup nor exchange retries it.
+        with (self.directory / (message_id + '.send.json')).open('x') as stream:
+            json.dump({'sessionId': self.id, 'messageId': message_id}, stream)
+            stream.flush()
+            os.fsync(stream.fileno())
+        value = {'type': 'user', 'session_id': self.id, 'uuid': message_id,
+                 'message': {'role': 'user', 'content': prompt}}
+        self.process.stdin.write((json.dumps(value) + '\n').encode())
+        await self.process.stdin.drain()
+        echoed = False
+        tools = 0
+        async with asyncio.timeout(1800):
+            while line := await self.process.stdout.readline():
+                row = json.loads(line)
+                require(row.get('session_id', self.id) == self.id, 'Native event belongs to another session')
+                if row.get('type') == 'system' and row.get('subtype') == 'init':
+                    require(self.init is None and row.get('model') == self.model
+                            and row.get('permissionMode') == 'bypassPermissions', 'Native worker startup tuple differs')
+                    self.init = row
+                if row.get('type') == 'user' and row.get('uuid') == message_id:
+                    require(not echoed, 'Native input acknowledgement is duplicated')
+                    echoed = True
+                if row.get('type') == 'assistant':
+                    content = row.get('message', {}).get('content', [])
+                    tools += sum(item.get('type') == 'tool_use' for item in content)
+                    if self.assigned and self.progress:
+                        text = '\n'.join(item['text'] for item in content if item.get('type') == 'text')
+                        if public_progress(text):
+                            await self.progress(row['uuid'], text[:1600])
+                if row.get('type') == 'result':
+                    require(self.init is not None and echoed and row.get('is_error') is False
+                            and row.get('subtype') == 'success' and row.get('terminal_reason') == 'completed'
+                            and row.get('stop_reason') == 'end_turn' and not row.get('permission_denials')
+                            and set(row.get('modelUsage', {})) == {self.model}
+                            and row.get('queued_turn_count', 0) == 0 and isinstance(row.get('result'), str),
+                            'Native worker did not prove a successful selected-model turn: ' + str(row.get('result', ''))[:300])
+                    receipt = {'id': message_id, 'status': 'completed', 'output': row['result'],
+                               'toolItems': tools, 'nativeSessionId': self.id, 'nativeResultId': row['uuid']}
+                    self.results[message_id] = receipt
+                    self.pending = None
+                    return receipt
+        raise PackError('Native worker ended without its exact terminal receipt; no resend')
+
+    async def close(self):
+        if self.process is not None and self.process.returncode is None:
+            self.process.stdin.close()
+            try:
+                await asyncio.wait_for(self.process.wait(), 8)
+            except TimeoutError:
+                os.killpg(self.process.pid, signal.SIGTERM)
+                await asyncio.wait_for(self.process.wait(), 8)
+        self.closed = True
+        return {'state': 'process-retired', 'sessionId': self.id, 'desktopChatArchived': False}