cdx-manager 0.25.7 → 0.25.9

package/src/commands/auth.py

@@ -3,6 +3,7 @@
 Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 """
 
+import sys
 import time
 import uuid
 
@@ -53,6 +54,30 @@ def _refresh_result(session, diagnostic):
 
 
 def handle_auth(rest, ctx):
+    if rest and rest[0] == "claude-token":
+        json_flag, args = _parse_json_flag(rest[1:])
+        if len(args) != 1:
+            raise CdxError("Usage: cdx auth claude-token <profile> [--json]")
+        session = ctx["service"]["get_session"](args[0])
+        if not session or session["provider"] != PROVIDER_CLAUDE:
+            raise CdxError("Select an existing Claude profile for cdx auth claude-token.")
+        if ctx["stdin_is_tty"]:
+            raise CdxError("Read the Claude setup token from standard input, without an interactive terminal.")
+        from ..claude_remote_token import store_token
+        stream = ctx.get("prompt_stdin") or sys.stdin
+        token = stream.read(16385)
+        if isinstance(token, bytes):
+            try:
+                token = token.decode("utf-8")
+            except UnicodeDecodeError as error:
+                raise CdxError("Provide one Claude setup token on standard input.") from error
+        store_token(session, token)
+        message = f"Stored remote Claude setup token for {session['name']}"
+        if json_flag:
+            _write_json(ctx, _json_success("auth.claude-token", message))
+        else:
+            ctx["out"](message + "\n")
+        return 0
     parsed = _parse_auth_args(rest)
     target = parsed["target"]
     if target == "all":

package/src/commands/maintenance.py

@@ -53,6 +53,8 @@ def _format_update_all_result(result, use_color=False):
         return _warn(f"skipped: {result['name']} (blocked by {result['blocked_by']})", use_color)
     if result.get("returncode") == 0:
         versions = f" ({result['version_before']} -> {result['version_after']})" if "version_after" in result else ""
+        if result.get("warning"):
+            return _warn(f"done: {result['name']}{versions}\n  {result['warning']['message']}", use_color)
         return _success(f"done: {result['name']}{versions}", use_color)
     detail = str(result.get("stderr") or result.get("stdout") or "No error output.").strip().replace("\n", " ")
     detail = detail[-500:]
@@ -709,7 +711,8 @@ def handle_update(rest, ctx):
         failed = [row for row in results if row.get("returncode") != 0]
         message = "Applied workstation update plan" if not failed else "Workstation update plan completed with failures"
         if parsed["json"]:
-            _write_json(ctx, _json_success("update.all", message, plan=plan, results=results, failed=len(failed)))
+            warnings = [dict(row["warning"], name=row["name"]) for row in results if row.get("warning")]
+            _write_json(ctx, _json_success("update.all", message, warnings=warnings, plan=plan, results=results, failed=len(failed)))
         else:
             ctx["out"](f"{_success(message, ctx['use_color']) if not failed else _warn(message, ctx['use_color'])}\n")
         return 1 if failed else 0

package/src/commands/runs.py

@@ -713,16 +713,26 @@ def handle_run(rest, ctx):
             session = selected["session"]
             selection_row = selected.get("row") or {}
 
+        if parsed.get("remote") and session["provider"] == "antigravity":
+            parsed["isolate_workspace"] = True
         remote_version = None
         if parsed.get("remote"):
-            if session["provider"] != "codex":
-                raise CdxError("--remote is only available for Codex profiles.", code="remote_provider_unsupported")
+            if session["provider"] not in ("codex", "claude", "ollama", "antigravity"):
+                raise CdxError("--remote is only available for Codex, Claude, Ollama and Antigravity profiles.", code="remote_provider_unsupported")
             if parsed.get("continue_run"):
                 raise CdxError("--remote requires a fresh run without --continue-run.")
+            if session["provider"] == "ollama" and not (parsed.get("model") or (session.get("launch") or {}).get("model")):
+                raise CdxError("Remote Ollama text generation requires --model or a configured local model.")
+            if session["provider"] == "claude":
+                from ..claude_remote_token import read_token
+                read_token(session)
+                parsed["isolate_workspace"] = True
             remote_version = preflight(
                 parsed["remote"], {**os.environ, **(ctx.get("env") or {})},
                 remote_prefix=parsed.get("remote_prefix"), isolate_workspace=parsed.get("isolate_workspace", False),
-                cwd=parsed["cwd"], network=parsed.get("network_access", False), writable=parsed.get("permission") != "review")
+                cwd=parsed["cwd"], network=parsed.get("network_access", False), writable=parsed.get("permission") != "review",
+                **({"provider": "ollama", "model": parsed.get("model") or (session.get("launch") or {}).get("model")}
+                   if session["provider"] == "ollama" else {"provider": session["provider"]}))
         cwd = os.path.abspath(parsed["cwd"])
         if not parsed.get("remote") and not os.path.isdir(cwd):
             raise CdxError(f"Invalid cwd: {parsed['cwd']}", code="invalid_cwd")
@@ -1074,6 +1084,9 @@ def handle_run(rest, ctx):
             message = f"Every eligible session was rate limited: {', '.join(attempted)}."
         elif failover_error_code == "failover_limit_reached":
             message = f"Failover stopped after {MAX_FAILOVER_TRANSITIONS} transitions: {', '.join(attempted)}."
+        elif run_info.get("provider_error"):
+            failover_error_code = run_info["provider_error"]
+            message = run_info["provider_message"]
         elif run_info.get("timed_out"):
             message = "Provider process timed out."
         else:

package/src/interactive_usage.py

@@ -1,17 +1,11 @@
 """Best-effort usage readers for interactive provider sessions.
 
-Three providers report usage and one does not:
-
-- Claude and Codex write their own JSONL transcripts, resolved by the
-  conversation id cdx already holds.
-- Ollama writes nothing. Its counts exist only in `--verbose` terminal output,
-  so they are parsed out of the PTY capture cdx takes for every launch.
-- Antigravity has no retrievable source. Its conversation history is
-  schema-less binary protobuf under `~/.gemini/antigravity-cli/conversations/`
-  with no `.proto` available to decode field numbers into token counts, and its
-  logs are plain glog with no usage-bearing line at any verbosity `agy --help`
-  exposes. This was investigated and is a dead end, not an oversight -- do not
-  spend the afternoon rediscovering it.
+- Claude and Codex expose per-session token counts in JSONL transcripts.
+- Ollama exposes counts in the verbose terminal output captured by cdx.
+- Antigravity exposes quota through interactive statusLine stdin (collected by
+  antigravity_status), and per-run tokens through `agy -p --output-format json`
+  (read by run_usage). Interactive per-run token counts remain unavailable;
+  quota changes are not token measurements.
 """
 
 import json

package/src/ollama_remote.py

@@ -0,0 +1,175 @@
+"""Worker-owned Ollama relay and a text-only HTTP client, shipped over SSH."""
+
+import http.client
+import http.server
+import json
+import os
+import pathlib
+import signal
+import socketserver
+import subprocess
+import sys
+import tempfile
+import threading
+from contextlib import contextmanager
+
+OLLAMA_HOST = '127.0.0.1'
+OLLAMA_PORT = 11434
+MAX_BODY = 8 * 1024 * 1024
+
+CLIENT = r'''
+import http.client
+import json
+import socket
+import sys
+
+class Connection(http.client.HTTPConnection):
+    def connect(self):
+        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.sock.settimeout(300)
+        self.sock.connect(sys.argv[1])
+
+try:
+    payload = json.load(sys.stdin)
+    def request(path, body):
+        connection = Connection('localhost', timeout=300)
+        try:
+            connection.request('POST', path, json.dumps(body), {'Content-Type': 'application/json'})
+            response = connection.getresponse()
+            data = json.loads(response.read(8 * 1024 * 1024))
+            if response.status != 200 or not isinstance(data, dict) or data.get('error'):
+                raise ValueError('Ollama request failed')
+            return data
+        finally:
+            connection.close()
+    model = payload['model']
+    info = request('/api/show', {'model': model})
+    if info.get('remote_host') or info.get('remote_model'):
+        raise ValueError('A local model is required')
+    if 'capabilities' in info and 'completion' not in info['capabilities']:
+        raise ValueError('Text completion is required')
+    if payload.get('probe'):
+        print('ollama-http')
+    else:
+        result = request('/api/chat', {'model': model, 'stream': False,
+                         'messages': [{'role': 'user', 'content': payload['prompt']}]})
+        if result.get('done') is not True or not isinstance(result.get('message', {}).get('content'), str):
+            raise ValueError('Incomplete Ollama response')
+        print(json.dumps(result))
+except Exception:
+    print('Ollama text generation failed: check the local model and worker loopback API.', file=sys.stderr)
+    sys.exit(1)
+'''
+
+
+@contextmanager
+def relay(directory, model):
+    """Expose only a fixed loopback destination and a fixed model over a private socket."""
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def log_message(self, *_):
+            pass
+
+        def do_POST(self):
+            try:
+                size = int(self.headers.get('Content-Length', '0'))
+                if not 0 < size <= MAX_BODY or self.headers.get('Transfer-Encoding'):
+                    raise ValueError('Invalid body')
+                self.connection.settimeout(10)
+                data = json.loads(self.rfile.read(size))
+                if not isinstance(data, dict) or data.get('model') != model:
+                    raise ValueError('Invalid model')
+                if self.path == '/api/show':
+                    allowed = set(data) == {'model'}
+                elif self.path == '/api/chat':
+                    messages = data.get('messages')
+                    allowed = (set(data) == {'model', 'stream', 'messages'} and data.get('stream') is False
+                               and isinstance(messages, list) and len(messages) == 1
+                               and isinstance(messages[0], dict) and set(messages[0]) == {'role', 'content'}
+                               and messages[0]['role'] == 'user' and isinstance(messages[0]['content'], str))
+                else:
+                    allowed = False
+                if not allowed:
+                    raise ValueError('Forbidden call')
+            except (ValueError, TypeError, OSError):
+                self.send_error(403, 'Relay call refused')
+                return
+            connection = http.client.HTTPConnection(OLLAMA_HOST, OLLAMA_PORT, timeout=300)
+            try:
+                # No proxies, redirects, forwarded headers or client-selected destination.
+                connection.request('POST', self.path, json.dumps(data), {'Content-Type': 'application/json'})
+                response = connection.getresponse()
+                body = response.read(MAX_BODY + 1)
+                if len(body) > MAX_BODY:
+                    raise ValueError('Oversized response')
+                self.send_response(response.status)
+                self.send_header('Content-Type', 'application/json')
+                self.send_header('Content-Length', str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+            except (OSError, ValueError, http.client.HTTPException):
+                self.send_error(502, 'Ollama unavailable')
+            finally:
+                connection.close()
+
+    class Server(socketserver.ThreadingUnixStreamServer):
+        daemon_threads = True
+
+    path = str(pathlib.Path(directory) / 'api.sock')
+    with Server(path, Handler) as server:
+        os.chmod(path, 0o600)
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        try:
+            yield path
+        finally:
+            server.shutdown()
+            thread.join()
+
+
+def run(payload, sandbox_source, probe=False):
+    """Run a single HTTP completion; no shell tools or model files enter the sandbox."""
+    model = payload.get('model')
+    if not isinstance(model, str) or not model.strip():
+        raise RuntimeError('Remote Ollama requires an installed model')
+    with tempfile.TemporaryDirectory(prefix='cdx-ollama-') as directory, relay(directory, model) as path:
+        command = [sys.executable, '-I', '-c', CLIENT, path]
+        env = None
+        if payload.get('isolate_workspace'):
+            namespace = {'__name__': 'cdx_workspace_sandbox'}
+            exec(compile(sandbox_source, 'workspace_sandbox.py', 'exec'), namespace)
+            command = ['python3', '-I', '-c', CLIENT, '/run/cdx-ollama/api.sock']
+            command, env = namespace['sandbox_command'](
+                command, pathlib.Path(payload['cwd']), network=False, writable=False,
+                provider='ollama', ollama_relay=directory)
+        child = subprocess.Popen(command, cwd=payload['cwd'], env=env, stdin=subprocess.PIPE,
+                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE, start_new_session=True)
+
+        def stop(*_):
+            if child.poll() is None:
+                try:
+                    os.killpg(child.pid, signal.SIGKILL)
+                except ProcessLookupError:
+                    pass
+
+        def disconnected():
+            while os.read(0, 1):
+                pass
+            stop()
+
+        previous = {sig: signal.signal(sig, stop) for sig in (signal.SIGTERM, signal.SIGHUP, signal.SIGINT)}
+        if not probe:
+            threading.Thread(target=disconnected, daemon=True).start()
+        try:
+            output, error = child.communicate(json.dumps({'model': model, 'prompt': payload.get('prompt'), 'probe': probe}).encode(),
+                                              timeout=30 if probe else None)
+            if probe:
+                sys.stdout.write(output.decode())
+            else:
+                print(json.dumps({'stream': 'stdout', 'data': output.decode()}), flush=True)
+            sys.stderr.write(error.decode())
+            return child.returncode
+        finally:
+            stop()
+            child.wait()
+            for sig, handler in previous.items():
+                signal.signal(sig, handler)

package/src/provider_runtime.py

@@ -753,6 +753,9 @@ def _build_launch_spec(session, cwd=None, env_override=None, initial_prompt=None
             "label": "claude",
         }, capture_transcript=capture_transcript, env=env)
     if session["provider"] == PROVIDER_ANTIGRAVITY:
+        from .antigravity_status import install
+
+        install(_get_auth_home(session))
         args = _launch_config_args(session)
         if initial_prompt:
             args += ["--prompt-interactive", initial_prompt]
@@ -1059,6 +1062,18 @@ def _build_headless_launch_spec(session, cwd=None, env_override=None, initial_pr
             "sensitive_args": [initial_prompt] if initial_prompt else [],
         }
 
+    if session["provider"] == PROVIDER_ANTIGRAVITY:
+        args = ["-p", initial_prompt or "", "--output-format", "json"]
+        if model:
+            args += ["--model", model]
+        args += _launch_config_args(session)
+        args += _extra_args(session)
+        return {
+            "command": "agy", "args": args,
+            "options": {"cwd": cwd, "env": {**env, **_antigravity_env_overrides(_get_auth_home(session))}},
+            "label": "antigravity", "sensitive_args": [initial_prompt] if initial_prompt else [],
+        }
+
     return _build_launch_spec(
         session,
         cwd=cwd,

package/src/remote_run.py

@@ -1,4 +1,4 @@
-"""Controller-side temporary Codex credentials and SSH transport."""
+"""Controller-owned remote provider credentials and SSH transport."""
 
 import base64
 import json
@@ -88,6 +88,7 @@ def worker_input():
                for name in ('errors', 'run_usage', 'run_observation')}
     source += 'OBSERVATION_MODULES = ' + repr(modules) + '\n'
     source += f'OBSERVATION_LIMITS = {MAX_TRANSCRIPT_BYTES, MAX_TRANSCRIPT_SCAN_SECONDS!r}\n'
+    source += 'OLLAMA_SOURCE = ' + repr((directory / 'ollama_remote.py').read_text()) + '\n'
     source += (directory / 'remote_worker.py').read_text()
     return json.dumps(source).encode() + b'\n'
 
@@ -109,21 +110,32 @@ def ssh_command(target, mode, remote_prefix=None):
             '-o', 'ServerAliveInterval=5', '-o', 'ServerAliveCountMax=1', target, command]
 
 
-def preflight(target, env=None, *, remote_prefix=None, isolate_workspace=False, cwd=None, network=False, writable=True):
+def preflight(target, env=None, *, remote_prefix=None, isolate_workspace=False, cwd=None, network=False, writable=True, provider="codex", model=None):
     payload = {'isolate_workspace': isolate_workspace, 'cwd': cwd, 'network': network, 'writable': writable}
+    if provider in ('ollama', 'claude', 'antigravity'):
+        payload.update(provider=provider, model=model)
+    if provider in ('claude', 'antigravity'):
+        payload['isolate_workspace'] = True
     try:
-        local = subprocess.check_output(['codex', '--version'], env=env, stderr=subprocess.DEVNULL, timeout=10).decode().strip()
+        local = ('ollama-http' if provider == 'ollama' else
+                 subprocess.check_output(['agy' if provider == 'antigravity' else provider, '--version'], env=env, stderr=subprocess.DEVNULL, timeout=10).decode().strip())
         result = subprocess.run(ssh_command(target, 'probe', remote_prefix), env=env,
                                 input=worker_input() + json.dumps(payload).encode() + b'\n',
                                 capture_output=True, timeout=30)
     except (OSError, subprocess.TimeoutExpired) as error:
-        raise CdxError('Remote worker unreachable or Codex CLI unavailable.', code='remote_unavailable') from error
+        raise CdxError('Remote worker unreachable or provider unavailable.', code='remote_unavailable') from error
     if result.returncode:
+        if provider == 'antigravity' and result.returncode == 120:
+            raise CdxError('Antigravity worker is not signed in or its session file is unsafe; sign in once on the worker.',
+                           code='antigravity_not_signed_in')
+        if provider == 'ollama':
+            raise CdxError('Remote Ollama unavailable: check the installed local model, loopback API and isolation dependencies.',
+                           code='remote_unavailable')
         message = ('Remote workspace isolation unavailable; requires bubblewrap, pasta, nftables, working namespaces and a valid checkout.'
-                   if isolate_workspace else 'Remote worker unreachable or missing Python 3, Codex or memory-backed /dev/shm.')
+                   if payload['isolate_workspace'] else 'Remote worker unreachable or missing Python 3, provider CLI or memory-backed /dev/shm.')
         raise CdxError(message, code='remote_unavailable')
     if local != result.stdout.decode().strip():
-        raise CdxError('Remote Codex CLI version mismatch; install the controller version on the worker.', code='remote_version_mismatch')
+        raise CdxError('Remote provider CLI version mismatch; install the controller version on the worker.', code='remote_version_mismatch')
     return local
 
 
@@ -149,27 +161,53 @@ def run_remote(session, target, version, cwd=None, env_override=None, initial_pr
         _route_termination_to_interrupt,
     )
 
-    home = session['authHome']
-    with remote_auth_lock(home):
-        auth = temporary_auth(home)
-        if auth['tokens'].get('refresh_token') != '':
-            raise CdxError('Refusing to send a refresh token to a worker.')
+    if session['provider'] == 'ollama':
+        launch = session.get('launch') or {}
+        spec = {'command': 'ollama-http', 'args': [], 'env': {}}
+        payload = {'provider': 'ollama', 'model': launch.get('model'), 'prompt': initial_prompt,
+                   'cwd': cwd, 'isolate_workspace': bool(launch.get('isolate_workspace'))}
+    elif session['provider'] == 'antigravity':
+        spec = _build_headless_launch_spec(session, cwd, env_override, initial_prompt)
+        payload = {'provider': 'antigravity', 'args': spec['args'], 'cwd': cwd,
+                   'version': version, 'isolate_workspace': True, 'network': False,
+                   'writable': (session.get('launch') or {}).get('permission') != 'review'}
+    elif session['provider'] == 'claude':
+        from .claude_remote_token import read_token
+        token = read_token(session)
         spec = _build_headless_launch_spec(session, cwd, env_override, initial_prompt)
-        if (session.get('launch') or {}).get('network_access'):
-            index = spec['args'].index('--') if '--' in spec['args'] else len(spec['args'])
-            spec['args'][index:index] = ['-c', 'sandbox_workspace_write.network_access=true']
-        config = nonsecret_config(home)
-        launch_text = json.dumps(spec['args']) + config
-        if any(value and value in launch_text for value in auth['tokens'].values()):
+        if token in json.dumps(spec['args']):
             raise CdxError('Refusing a credential embedded in the remote prompt or configuration.')
-        payload = {'auth': auth, 'config': config, 'args': spec['args'], 'cwd': cwd,
-                   'version': version, 'expires_at': token_expiry(auth['tokens']['access_token']),
-                   'isolate_workspace': bool((session.get('launch') or {}).get('isolate_workspace')),
+        if '--bare' in spec['args']:
+            raise CdxError('Remote Claude OAuth runs do not support --bare.')
+        index = spec['args'].index('--') if '--' in spec['args'] else len(spec['args'])
+        # Bubblewrap owns tool permissions, matching isolated local headless runs.
+        spec['args'][index:index] = ['--permission-mode', 'bypassPermissions']
+        payload = {'provider': 'claude', 'token': token, 'args': spec['args'], 'cwd': cwd,
+                   'version': version, 'isolate_workspace': True,
                    'network': bool((session.get('launch') or {}).get('network_access')),
                    'writable': (session.get('launch') or {}).get('permission') != 'review'}
-        rotating = json.loads((pathlib.Path(home) / 'auth.json').read_text())['tokens'].get('refresh_token')
-        if rotating and rotating in json.dumps(payload):
-            raise CdxError('Refusing to send a refresh token to a worker.')
+    else:
+        home = session['authHome']
+        with remote_auth_lock(home):
+            auth = temporary_auth(home)
+            if auth['tokens'].get('refresh_token') != '':
+                raise CdxError('Refusing to send a refresh token to a worker.')
+            spec = _build_headless_launch_spec(session, cwd, env_override, initial_prompt)
+            if (session.get('launch') or {}).get('network_access'):
+                index = spec['args'].index('--') if '--' in spec['args'] else len(spec['args'])
+                spec['args'][index:index] = ['-c', 'sandbox_workspace_write.network_access=true']
+            config = nonsecret_config(home)
+            launch_text = json.dumps(spec['args']) + config
+            if any(value and value in launch_text for value in auth['tokens'].values()):
+                raise CdxError('Refusing a credential embedded in the remote prompt or configuration.')
+            payload = {'auth': auth, 'config': config, 'args': spec['args'], 'cwd': cwd,
+                       'version': version, 'expires_at': token_expiry(auth['tokens']['access_token']),
+                       'isolate_workspace': bool((session.get('launch') or {}).get('isolate_workspace')),
+                       'network': bool((session.get('launch') or {}).get('network_access')),
+                       'writable': (session.get('launch') or {}).get('permission') != 'review'}
+            rotating = json.loads((pathlib.Path(home) / 'auth.json').read_text())['tokens'].get('refresh_token')
+            if rotating and rotating in json.dumps(payload):
+                raise CdxError('Refusing to send a refresh token to a worker.')
     paths = _headless_artifact_paths(session, run_id, attempt)
     paths['remote'] = target
     start = datetime.now(timezone.utc)
@@ -208,7 +246,7 @@ def run_remote(session, target, version, cwd=None, env_override=None, initial_pr
         child.stdin.flush()
         deadline = time.monotonic() + timeout_seconds if timeout_seconds else None
         while child.poll() is None:
-            if time.time() >= payload['expires_at']:
+            if time.time() >= payload.get('expires_at', float('inf')):
                 credential_expired = True
                 break
             with observation_lock:
@@ -259,7 +297,7 @@ def run_remote(session, target, version, cwd=None, env_override=None, initial_pr
         error.cancelled = True
         error.run_info = {**info, 'returncode': 130}
         raise error
-    if credential_expired or time.time() >= payload['expires_at'] or child.returncode == 123:
+    if credential_expired or time.time() >= payload.get('expires_at', float('inf')) or child.returncode == 123:
         error = CdxError('Remote temporary credential expired; start a new run from the controller.', code='remote_credential_expired')
         error.run_info = info
         raise error
@@ -269,4 +307,10 @@ def run_remote(session, target, version, cwd=None, env_override=None, initial_pr
         raise error
     if timed_out or budget_exceeded:
         info['returncode'] = 125 if budget_exceeded else 124
+    if session['provider'] == 'antigravity':
+        from .run_usage import antigravity_outcome
+        info = antigravity_outcome(info)
+        if child.returncode in (120, 121):
+            info.update(returncode=1, provider_error='antigravity_not_signed_in' if child.returncode == 120 else 'antigravity_session_busy',
+                        provider_message='Antigravity worker is not signed in.' if child.returncode == 120 else 'Antigravity worker session is busy.')
     return info