cdx-manager 0.25.7 → 0.25.9

package/src/remote_worker.py

@@ -13,10 +13,12 @@ import tempfile
 import threading
 import time
 import types
+from contextlib import ExitStack
 from datetime import datetime, timezone
 
 # Supplied by the controller before this module is executed.
 SANDBOX_SOURCE = globals().get('SANDBOX_SOURCE', '')
+OLLAMA_SOURCE = globals().get('OLLAMA_SOURCE', '')
 OBSERVATION_MODULES = globals().get('OBSERVATION_MODULES', {})
 OBSERVATION_LIMITS = globals().get('OBSERVATION_LIMITS', (128 * 1024 * 1024, 1))
 
@@ -34,8 +36,8 @@ def observation_runtime():
     return sys.modules[package.__name__ + '.run_usage'], sys.modules[package.__name__ + '.run_observation']
 
 
-def version():
-    return subprocess.check_output(["codex", "--version"], stderr=subprocess.DEVNULL, timeout=10).decode().strip()
+def version(provider="codex"):
+    return subprocess.check_output(["agy" if provider == "antigravity" else provider, "--version"], stderr=subprocess.DEVNULL, timeout=10).decode().strip()
 
 
 def storage():
@@ -75,16 +77,26 @@ def isolation_probe_command(payload, home, env):
     # Execute exactly the local confinement implementation, shipped over stdin.
     namespace = {'__name__': 'cdx_workspace_sandbox'}
     exec(compile(SANDBOX_SOURCE, 'workspace_sandbox.py', 'exec'), namespace)
+    provider = payload.get('provider', 'codex')
     return namespace['sandbox_command'](
-        ['codex', '--version'], pathlib.Path(payload['cwd']), network=payload['network'],
-        writable=payload['writable'], source=env, auth_home=str(home), provider='codex',
-        observation_home=str(home / 'sessions'))
+        ['agy' if provider == 'antigravity' else provider, '--version'], pathlib.Path(payload['cwd']), network=payload['network'],
+        writable=payload['writable'], source=env, auth_home=str(home), provider=provider,
+        observation_home=str(home) if provider in ('claude', 'antigravity') else str(home / 'sessions'),
+        claude_token_stdin=provider == 'claude')
 
 
 def probe(root, payload):
     if not payload.get('isolate_workspace'):
         print(version())
         return 0
+    if payload.get('provider') == 'antigravity':
+        namespace = {'__name__': 'cdx_workspace_sandbox'}
+        exec(compile(SANDBOX_SOURCE, 'workspace_sandbox.py', 'exec'), namespace)
+        try:
+            namespace['antigravity_token']()
+        except RuntimeError:
+            print('Antigravity worker is not signed in or its session file is unsafe.', file=sys.stderr)
+            return 120
     # Exercise mounts, namespaces and the nft setup with a dummy home before
     # the controller reads or sends a credential. Binary presence is insufficient.
     with tempfile.TemporaryDirectory(prefix='probe-', dir=root) as directory:
@@ -93,7 +105,7 @@ def probe(root, payload):
         os.chmod(home / 'auth.json', 0o600)
         (home / 'sessions').mkdir()
         command, env = isolation_probe_command(payload, home, dict(os.environ))
-        result = subprocess.run(command, env=env, stdin=subprocess.DEVNULL,
+        result = subprocess.run(command, env=env, input=b'"probe-only"\n' if payload.get('provider') == 'claude' else b'',
                                 capture_output=True, timeout=20)
         if result.returncode:
             raise RuntimeError('Remote workspace isolation unavailable')
@@ -102,14 +114,21 @@ def probe(root, payload):
 
 
 def main():
-    root = storage()
     payload = json.loads(sys.stdin.buffer.readline())
+    if payload.get('provider') == 'ollama':
+        namespace = {'__name__': 'cdx_ollama_remote'}
+        exec(compile(OLLAMA_SOURCE, 'ollama_remote.py', 'exec'), namespace)
+        return namespace['run'](payload, SANDBOX_SOURCE, probe=sys.argv[-1] == 'probe')
+    root = storage()
     if sys.argv[-1] == 'probe':
         return probe(root, payload)
-    auth = payload['auth']
-    if auth['tokens'].get('refresh_token') != '':
+    provider = payload.get('provider', 'codex')
+    agy = provider == 'antigravity'
+    claude = provider == 'claude'
+    auth = payload.get('auth')
+    if not (claude or agy) and auth['tokens'].get('refresh_token') != '':
         raise RuntimeError('Refusing a rotating remote credential')
-    if version() != payload['version']:
+    if version(provider) != payload['version']:
         raise RuntimeError('Remote Codex CLI version mismatch')
     child = None
     stopped = threading.Event()
@@ -135,40 +154,70 @@ def main():
     signal.signal(signal.SIGHUP, stop)
     signal.signal(signal.SIGINT, stop)
     home, live = allocate(root)
+    auth_context = ExitStack()
     try:
         if stopped.is_set():
             return 130
         os.umask(0o077)
-        (home / 'auth.json').write_text(json.dumps(auth))
-        os.chmod(home / 'auth.json', 0o600)
-        (home / 'config.toml').write_text('cli_auth_credentials_store = "file"\n' + payload['config'])
-        env = {key: value for key, value in os.environ.items()
-               if key not in ('OPENAI_API_KEY', 'OPENAI_ACCESS_TOKEN', 'CODEX_ACCESS_TOKEN', 'CODEX_API_KEY', 'CODEX_HOME')}
-        env['CODEX_HOME'] = str(home)
-        command = ['codex', *payload['args']]
-        if payload.get('isolate_workspace'):
-            (home / 'sessions').mkdir(mode=0o700)
-            args = payload['args'][:]
-            while '-s' in args:
-                index = args.index('-s')
-                del args[index:index + 2]
-            if '--dangerously-bypass-approvals-and-sandbox' not in args:
-                index = args.index('--') if '--' in args else len(args)
-                args[index:index] = ['--dangerously-bypass-approvals-and-sandbox']
+        if agy:
+            namespace = {'__name__': 'cdx_workspace_sandbox'}
+            exec(compile(SANDBOX_SOURCE, 'workspace_sandbox.py', 'exec'), namespace)
+            try:
+                attempt_home = auth_context.enter_context(namespace['antigravity_attempt'](home))
+            except RuntimeError as error:
+                print(str(error), file=sys.stderr)
+                return 121 if 'busy' in str(error) else 120
+            command, env = namespace['sandbox_command'](
+                ['agy', *payload['args']], pathlib.Path(payload['cwd']), network=False,
+                writable=payload['writable'], source=dict(os.environ), provider='antigravity',
+                observation_home=attempt_home)
+        elif claude:
+            claude_home = home / 'claude-home'
+            claude_home.mkdir(mode=0o700)
+            if not payload.get('isolate_workspace') or '--bare' in payload['args']:
+                raise RuntimeError('Remote Claude requires isolated OAuth execution')
             namespace = {'__name__': 'cdx_workspace_sandbox'}
             exec(compile(SANDBOX_SOURCE, 'workspace_sandbox.py', 'exec'), namespace)
             command, env = namespace['sandbox_command'](
-                ['codex', *args], pathlib.Path(payload['cwd']), network=payload['network'],
-                writable=payload['writable'], source=env, auth_home=str(home), provider='codex',
-                observation_home=str(home / 'sessions'))
+                ['claude', *payload['args']], pathlib.Path(payload['cwd']), network=payload['network'],
+                writable=payload['writable'], source=dict(os.environ), provider='claude',
+                observation_home=str(claude_home), claude_token_stdin=True)
+        else:
+            (home / 'auth.json').write_text(json.dumps(auth))
+            os.chmod(home / 'auth.json', 0o600)
+            (home / 'config.toml').write_text('cli_auth_credentials_store = "file"\n' + payload['config'])
+            env = {key: value for key, value in os.environ.items()
+                   if key not in ('OPENAI_API_KEY', 'OPENAI_ACCESS_TOKEN', 'CODEX_ACCESS_TOKEN', 'CODEX_API_KEY', 'CODEX_HOME')}
+            env['CODEX_HOME'] = str(home)
+            command = ['codex', *payload['args']]
+            if payload.get('isolate_workspace'):
+                (home / 'sessions').mkdir(mode=0o700)
+                args = payload['args'][:]
+                while '-s' in args:
+                    index = args.index('-s')
+                    del args[index:index + 2]
+                if '--dangerously-bypass-approvals-and-sandbox' not in args:
+                    index = args.index('--') if '--' in args else len(args)
+                    args[index:index] = ['--dangerously-bypass-approvals-and-sandbox']
+                namespace = {'__name__': 'cdx_workspace_sandbox'}
+                exec(compile(SANDBOX_SOURCE, 'workspace_sandbox.py', 'exec'), namespace)
+                command, env = namespace['sandbox_command'](
+                    ['codex', *args], pathlib.Path(payload['cwd']), network=payload['network'],
+                    writable=payload['writable'], source=env, auth_home=str(home), provider='codex',
+                    observation_home=str(home / 'sessions'))
         started_at = datetime.now(timezone.utc).isoformat()
         child = subprocess.Popen(command, cwd=payload['cwd'], env=env,
-                                 stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                                 stdin=subprocess.PIPE if claude else subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                                  start_new_session=True)
+        if claude:
+            child.stdin.write(json.dumps(payload['token']).encode() + b'\n')
+            child.stdin.close()
         if stopped.is_set():
             stop()
         threading.Thread(target=disconnected, daemon=True).start()
-        secrets = [value for value in auth['tokens'].values() if isinstance(value, str) and value]
+        secrets = (namespace['antigravity_secrets']() if agy else
+                   [payload['token']] if claude else
+                   [value for value in auth['tokens'].values() if isinstance(value, str) and value])
 
         output_lock = threading.Lock()
         usage_reader, observation_reader = observation_runtime()
@@ -176,6 +225,8 @@ def main():
         stdout_path.touch(mode=0o600)
 
         def snapshot():
+            if claude or agy:
+                return
             # Read the same exact-thread evidence as the local supervisor before
             # volatile storage is removed. Only normalized metadata is exported.
             with output_lock:
@@ -229,7 +280,7 @@ def main():
         for thread in threads:
             thread.join()
         snapshot()
-        if time.time() >= payload['expires_at']:
+        if time.time() >= payload.get('expires_at', float('inf')):
             print('Remote temporary credential expired; start a new run from the controller.', file=sys.stderr)
             return 123
         return 130 if stopped.is_set() else result
@@ -237,6 +288,7 @@ def main():
         stop()
         shutil.rmtree(home)
         live.close()
+        auth_context.close()
 
 
 if __name__ == '__main__':
@@ -244,5 +296,5 @@ if __name__ == '__main__':
         sys.exit(main())
     except Exception:
         # Never render exception values: input and provider errors may contain credentials.
-        print('Remote worker setup or execution failed; check Python, Codex, cwd, /dev/shm and isolation dependencies.', file=sys.stderr)
+        print('Remote worker setup or execution failed; check Python, provider CLI, cwd, /dev/shm and isolation dependencies.', file=sys.stderr)
         sys.exit(126)

package/src/run_command.py

@@ -4,6 +4,7 @@ import sys
 from .cli_args import ARG_CODE_INVALID_VALUE
 from .errors import CdxArgumentError, CdxError
 from .provider_runtime import headless_permission_disables_network
+from .run_registry import final_message
 from .run_usage import cost_fields, empty_usage, estimate_cost, extract_run_observation
 
 PROMPT_STDIN = "-"
@@ -169,6 +170,9 @@ def run_launch_payload(api_schema_version, parsed, session, artifacts, cwd=None,
         "ok": True,
         "action": "run",
         "launcher": "cdx",
+        **({"execution_mode": "text_generation",
+            "execution_note": "Ollama generates text only; it is not an autonomous coding agent and does not edit the repository."}
+           if parsed.get("remote") and session and session.get("provider") == "ollama" else {}),
         **({"remote": parsed["remote"]} if parsed.get("remote") else {}),
         "project": parsed.get("project"),
         "project_source": parsed.get("project_source", "unknown"),
@@ -222,6 +226,9 @@ def run_result_payload(api_schema_version, ok, parsed, session, run_info=None,
         "ok": bool(ok),
         "action": "run",
         "launcher": "cdx",
+        **({"execution_mode": "text_generation",
+            "execution_note": "Ollama generates text only; it is not an autonomous coding agent and does not edit the repository."}
+           if parsed.get("remote") and session and session.get("provider") == "ollama" else {}),
         **({"remote": parsed["remote"]} if parsed.get("remote") else {}),
         "project": parsed.get("project"),
         "project_source": parsed.get("project_source", "unknown"),
@@ -242,6 +249,8 @@ def run_result_payload(api_schema_version, ok, parsed, session, run_info=None,
         "transcript_path": run_info.get("transcript_path"),
         "stdout_path": run_info.get("stdout_path"),
         "stderr_path": run_info.get("stderr_path"),
+        **({"result": final_message({"artifacts": run_info})}
+           if parsed.get("remote") and session and session.get("provider") == "ollama" else {}),
         "usage": usage,
         "usage_model": usage_model,
         "usage_models": run_info.get("usage_models", [usage_model] if usage_model else []),

package/src/run_registry.py

@@ -462,6 +462,11 @@ def _record_final_message(record):
     """The final assistant text one provider record carries, or None."""
     if not isinstance(record, dict):
         return None
+    if record.get("status") == "SUCCESS" and isinstance(record.get("response"), str):
+        return record["response"]
+    message = record.get("message")
+    if record.get("done") is True and isinstance(message, dict) and isinstance(message.get("content"), str):
+        return message["content"]
     # Claude: `--output-format json` ends with a `result` envelope.
     if record.get("type") == "result" and isinstance(record.get("result"), str):
         return record["result"]

package/src/run_usage.py

@@ -10,6 +10,10 @@ definitions without saying so.
 
 The definitions below are therefore normative, not a suggestion:
 
+  Antigravity exception: the native input/cache/thinking relationship is not
+  established by the measured CLI output. Preserve its counters and reported
+  total rather than inventing a subset relationship or recomputing that total.
+
   input_tokens          Uncached input only. Claude reports it this way
                         natively; Codex does not, so its cache-inclusive count
                         is reduced here rather than left for a reader to guess.
@@ -64,9 +68,9 @@ TOKEN_USAGE_KEYS = (
     "total_tokens",
 )
 USAGE_KEYS = (*TOKEN_USAGE_KEYS, "cache_hit_ratio")
-#: Derived values are never read from a provider.
+#: Derived values are never read from a provider, except Antigravity's native total.
 DERIVED_USAGE_KEYS = ("cached_input_tokens", "total_tokens", "cache_hit_ratio")
-SUPPORTED_PROVIDERS = {"claude", "codex"}
+SUPPORTED_PROVIDERS = {"claude", "codex", "ollama", "antigravity"}
 
 
 def empty_usage():
@@ -456,6 +460,8 @@ def coerce_usage(usage, provider=None):
         reasoning_tokens=usage.get("reasoning_tokens"),
         cache_creation_1h_tokens=usage.get("cache_creation_1h_tokens"),
     )
+    if provider == "antigravity":
+        record["total_tokens"] = _first_int(usage.get("total_tokens"))
     if record["cached_input_tokens"] is None:
         # A legacy record carrying only the fused figure: keep it visible rather
         # than dropping a number someone already recorded, but leave the split
@@ -635,10 +641,25 @@ def _usage_from_dict(value, provider=None):
     tokens. The fix is not arithmetic in this function: it is that the split
     parts go to `normalize_usage`, which owns every derived figure.
     """
+    if provider == "ollama":
+        prompt = _first_int(value.get("prompt_eval_count"))
+        output = _first_int(value.get("eval_count"))
+        return {**normalize_usage(input_tokens=prompt, output_tokens=output),
+                "prompt_eval_count": prompt, "eval_count": output}
     usage = value.get("usage") if isinstance(value.get("usage"), dict) else value
     if not isinstance(usage, dict):
         return empty_usage()
 
+    if provider == "antigravity":
+        # agy reports thinking separately. Without a documented cache subset
+        # relationship, retain its input count and its measured total verbatim.
+        record = normalize_usage(
+            input_tokens=usage.get("input_tokens"), output_tokens=usage.get("output_tokens"),
+            cache_read_tokens=usage.get("cache_read_tokens"), reasoning_tokens=usage.get("thinking_tokens"),
+        )
+        record["total_tokens"] = _first_int(usage.get("total_tokens"))
+        return record
+
     cache_creation = _first_int(usage.get("cache_creation_input_tokens"))
     if cache_creation is None:
         cache_creation = _first_int(usage.get("cache_write_input_tokens"))
@@ -720,3 +741,43 @@ def _int_value(*values):
 
 def _has_usage(usage):
     return isinstance(usage, dict) and any(usage.get(key) is not None for key in USAGE_KEYS)
+
+
+def antigravity_outcome(info):
+    """Fail closed on missing completion, authentication errors and refused tools."""
+    if info.get("timed_out") or info.get("budget_exceeded"):
+        return info
+    try:
+        with open(info["stdout_path"], encoding="utf-8") as handle:
+            records = _parse_json_records(handle.read())
+        with open(info["stderr_path"], encoding="utf-8") as handle:
+            error_text = handle.read().lower()
+    except OSError:
+        records, error_text = [], ""
+    def objects(value):
+        if isinstance(value, dict):
+            yield value
+            for child in value.values():
+                yield from objects(child)
+        elif isinstance(value, list):
+            for child in value:
+                yield from objects(child)
+
+    statuses = [record.get("status") for record in records if isinstance(record, dict) and "status" in record]
+    errors = [record.get("error") for record in objects(records) if record.get("error")]
+    text = json.dumps(errors if statuses and statuses[-1] == "SUCCESS" else records).lower() + error_text
+    expired = any(word in text for word in ("invalid_grant", "unauthenticated", "session expired", "token expired",
+                                          "login required", "sign in", "not authenticated", "authentication required"))
+    refused = any(record.get(key) for record in objects(records)
+                  for key in ("permission_denials", "refused_actions", "denied_actions"))
+    refused = refused or any(str(record.get("status", "")).upper() in ("REFUSED", "DENIED", "PERMISSION_DENIED")
+                             for record in objects(records))
+    if expired:
+        code, message = "antigravity_session_expired", "Antigravity worker session has expired; sign in again on the worker."
+    elif refused:
+        code, message = "antigravity_action_refused", "Antigravity refused one or more requested actions."
+    elif not statuses or statuses[-1] != "SUCCESS":
+        code, message = "antigravity_status_failed", "Antigravity did not report JSON status SUCCESS."
+    else:
+        return info
+    return {**info, "returncode": info.get("returncode") or 1, "provider_error": code, "provider_message": message}

package/src/session_service.py

@@ -644,6 +644,10 @@ def create_session(base_dir, env, store, name, provider=DEFAULT_PROVIDER):
         _seed_codex_auth_from_global(auth_home, env=env)
     if normalized_provider == PROVIDER_CLAUDE:
         _ensure_claude_attribution_disabled(auth_home)
+    if normalized_provider == "antigravity":
+        from .antigravity_status import install
+
+        install(auth_home)
     now = _local_now_iso()
     session = {
         "name": name,

package/src/session_status.py

@@ -359,6 +359,12 @@ def session_paths(session):
 
 def _status_row_from_session(store, s):
     status = s.get("lastStatus")
+    antigravity = None
+    if s["provider"] == "antigravity":
+        from .antigravity_status import read_status
+
+        antigravity = read_status(s.get("authHome") or s.get("sessionRoot") or "")
+        status = antigravity
     enabled = s.get("enabled", True) is not False
     row_status = status if enabled else None
     runtime = _session_runtime(store, s["name"])
@@ -401,6 +407,13 @@ def _status_row_from_session(store, s):
         "updated_at": _to_local_iso(s.get("lastStatusAt")),
         "last_launched_at": _to_local_iso(s.get("lastLaunchedAt")),
     }
+    if antigravity is not None:
+        row.update({key: antigravity[key] for key in (
+            "quota", "quota_status", "quota_stale", "reading_age_seconds", "plan_tier", "updated_at",
+            "reset_5h_at_iso", "reset_week_at_iso",
+        )})
+        if enabled and antigravity["quota_stale"]:
+            row["status"] = "stale"
     row["runs_out_at_iso"] = _runs_out(row)
     return row
 
@@ -434,6 +447,9 @@ def _resolve_session_status(store, base_dir, env, fetch_codex_status, session,
     cache_only=False,
     status_timeout_seconds=None,):
     current_status = session.get("lastStatus")
+    if session["provider"] == "antigravity":
+        # The local statusLine file is the only Antigravity quota source.
+        return None
     if session.get("enabled", True) is False:
         return current_status
     if cache_only:

package/src/status_view.py

@@ -369,6 +369,7 @@ def _format_status_detail(row, use_color=False):
         f"{_style('Session:', '1', use_color)} {_format_session_name(row)}",
         f"{_style('Provider:', '1', use_color)} {row.get('provider') or 'n/a'}",
         f"{_style('Status:', '1', use_color)} {_style(row.get('status') or ('enabled' if row.get('enabled', True) else 'disabled'), '2' if row.get('enabled', True) is False else '32', use_color)}",
+        *([f"{_style('Plan:', '1', use_color)} {row['plan_tier']}"] if row.get("plan_tier") else []),
         f"{_style('Auth:', '1', use_color)} {_style(auth, auth_color, use_color)}",
         *([f"{_style('Auth type:', '1', use_color)} {_auth_type_label(row)[0]}"] if row.get("auth_type") else []),
         f"{_style('Available:', '1', use_color)} {_style_pct(row.get('available_pct'), use_color)}",

package/src/update_all.py

@@ -241,9 +241,15 @@ def apply_update_all_plan(plan, service, env=None, runner=None, progress=None):
             advanced = (_newer(after, item["version"]) and
                         (not item["latest_version"] or after == item["latest_version"] or _newer(after, item["latest_version"])))
             if not (advanced or (after and after == item["version"] and reports_current)):
-                result["returncode"] = 1
-                result["reason"] = "Update verification failed: installed version did not advance to the expected release and updater did not confirm it is current."
-                result["stderr"] = (result["stderr"] + "\n" + result["reason"]).strip()
+                if item["name"] == PROVIDER_ANTIGRAVITY and not _newer(item["latest_version"], item["version"]):
+                    result["warning"] = {
+                        "code": "update_unverified",
+                        "message": "agy update exited successfully, but currency could not be verified: no expected newer CLI version is known. Status remains unknown.",
+                    }
+                else:
+                    result["returncode"] = 1
+                    result["reason"] = "Update verification failed: installed version did not advance to the expected release and updater did not confirm it is current."
+                    result["stderr"] = (result["stderr"] + "\n" + result["reason"]).strip()
         results.append(result)
         if result["returncode"] == 0 and step.get("id"):
             completed.add(step["id"])