adaptorch-cli 0.1.0__tar.gz → 0.1.1__tar.gz

{adaptorch_cli-0.1.0/src/adaptorch_cli.egg-info → adaptorch_cli-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adaptorch-cli
-Version: 0.1.0
+Version: 0.1.1
 Summary: Command-line client for AdaptOrch
 Author: ClassicMate
 License-Expression: LicenseRef-Proprietary
@@ -11,7 +11,7 @@ Project-URL: Documentation, https://adaptorch.com/mcp-docs
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: adaptorch-client<0.2,>=0.1
+Requires-Dist: adaptorch-client<0.2,>=0.1.2
 Dynamic: license-file
 
 # adaptorch-cli

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.1}/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "adaptorch-cli"
-version = "0.1.0"
+version = "0.1.1"
 description = "Command-line client for AdaptOrch"
 readme = "README.md"
 requires-python = ">=3.11"
 license = "LicenseRef-Proprietary"
 license-files = ["LICENSE"]
 authors = [{ name = "ClassicMate" }]
-dependencies = ["adaptorch-client>=0.1,<0.2"]
+dependencies = ["adaptorch-client>=0.1.2,<0.2"]
 
 [project.urls]
 Homepage = "https://adaptorch.com"

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.1}/src/adaptorch_cli/cli.py

@@ -13,6 +13,7 @@ from adaptorch_client import (
     AdaptOrchAPIError,
     AdaptOrchClient,
     ClientConfig,
+    PollPolicy,
     ProviderCredential,
     validate_api_url,
 )
@@ -39,7 +40,10 @@ def _reject_json_constant(_value: str) -> Never:
 
 
 def _finite_float(text: str) -> float:
-    value = float(text)
+    try:
+        value = float(text)
+    except ValueError:
+        _reject_json_constant(text)
     if not math.isfinite(value):
         raise ValueError("non-finite JSON number")
     return value
@@ -97,11 +101,14 @@ def _require_client(api_url: str) -> AdaptOrchClient:
 
 
 def _submission_credential() -> ProviderCredential | None:
-    resolved, _source = config_store.resolve_provider_credential()
+    resolved, source = config_store.resolve_provider_credential()
     if resolved is None:
         return None
     provider, model, key = resolved
-    return ProviderCredential(provider, model, key)
+    auth_type, account_id = config_store.resolve_provider_auth(source)
+    if auth_type is None and account_id is None:
+        return ProviderCredential(provider, model, key)
+    return ProviderCredential(provider, model, key, auth_type=auth_type, account_id=account_id)
 
 
 def _read_secret(prompt: str, *, stdin_flag: bool) -> str:
@@ -241,6 +248,28 @@ def _run_command(
         case "get":
             run_id: str = args.run_id
             return _result_payload(_require_client(api_url).get_run(run_id)), True
+        case "wait":
+            wait_run_id: str = args.run_id
+            timeout_seconds: float = args.timeout
+            interval_seconds: float = args.interval
+            if not math.isfinite(timeout_seconds) or timeout_seconds <= 0:
+                parser.error("--timeout must be finite positive seconds")
+            if not math.isfinite(interval_seconds) or interval_seconds <= 0:
+                parser.error("--interval must be finite positive seconds")
+            wait_result = _require_client(api_url).wait_for_run(
+                wait_run_id,
+                policy=PollPolicy(
+                    timeout_seconds=timeout_seconds, interval_seconds=interval_seconds
+                ),
+            )
+            wait_payload: dict[str, JSONValue] = {
+                "reason": wait_result.reason.value,
+                "polls": wait_result.polls,
+                "elapsed_seconds": wait_result.elapsed_seconds,
+            }
+            if wait_result.run is not None:
+                wait_payload["run"] = wait_result.run.to_payload()
+            return wait_payload, True
         case "cancel":
             cancel_run_id: str = args.run_id
             reason: str | None = args.reason

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.1}/src/adaptorch_cli/config_store.py

@@ -27,6 +27,8 @@ _PROVIDER_KEY_MAP = {
     "provider.name": "provider",
     "provider.model": "model",
     "provider.api_key": "api_key",
+    "provider.auth_type": "auth_type",
+    "provider.account_id": "account_id",
 }
 _CONFIGURABLE_KEYS = frozenset({"api_url", *_PROVIDER_KEY_MAP})
 
@@ -175,18 +177,50 @@ def resolve_provider_credential() -> tuple[tuple[str, str, str] | None, str]:
     env_provider = os.environ.get("ADAPTORCH_PROVIDER", "").strip()
     env_model = os.environ.get("ADAPTORCH_PROVIDER_MODEL", "").strip()
     env_key = os.environ.get("ADAPTORCH_PROVIDER_API_KEY", "").strip()
-    if env_provider or env_model or env_key:
+    if any(
+        (
+            env_provider,
+            env_model,
+            env_key,
+            os.environ.get("ADAPTORCH_PROVIDER_AUTH_TYPE"),
+            os.environ.get("ADAPTORCH_PROVIDER_ACCOUNT_ID"),
+        )
+    ):
         return (env_provider, env_model, env_key), "env"
     provider_cfg = load_config().get("provider")
     if isinstance(provider_cfg, dict):
         provider = str(provider_cfg.get("provider") or "").strip()
         model = str(provider_cfg.get("model") or "").strip()
         key = str(provider_cfg.get("api_key") or "").strip()
-        if provider or model or key:
+        has_auth_metadata = "auth_type" in provider_cfg or "account_id" in provider_cfg
+        if provider or model or key or has_auth_metadata:
             return (provider, model, key), "config"
     return None, "none"
 
 
+def resolve_provider_auth(source: str) -> tuple[str | None, str | None]:
+    """Read metadata from the same source as the token; never mix identities."""
+    if source == "env":
+        values = (
+            os.environ.get("ADAPTORCH_PROVIDER_AUTH_TYPE"),
+            os.environ.get("ADAPTORCH_PROVIDER_ACCOUNT_ID"),
+        )
+    else:
+        provider = load_config().get("provider")
+        if not isinstance(provider, dict):
+            return None, None
+        values = (provider.get("auth_type"), provider.get("account_id"))
+
+    def optional_text(value: object) -> str | None:
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            raise ValueError("provider authentication metadata must be strings")
+        return value.strip() or None
+
+    return optional_text(values[0]), optional_text(values[1])
+
+
 def mask_secret(value: str | None) -> str | None:
     if not value:
         return None
@@ -209,6 +243,8 @@ def config_view() -> dict[str, Any]:
             "name": provider.get("provider"),
             "model": provider.get("model"),
             "api_key": mask_secret(provider_key if isinstance(provider_key, str) else None),
+            "auth_type": provider.get("auth_type"),
+            "account_id_configured": bool(provider.get("account_id")),
             "source": resolve_provider_credential()[1],
         },
         "config_path": str(config_path()),

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.1}/src/adaptorch_cli/parser.py

@@ -33,6 +33,28 @@ def _add_run_commands(parent: argparse._SubParsersAction[argparse.ArgumentParser
     get = commands.add_parser("get", help="Get a run")
     get.add_argument("run_id")
 
+    wait = commands.add_parser(
+        "wait",
+        help=(
+            "Read an existing run until it reaches a terminal status — the "
+            "CLI's form of the MCP resume_run_id contract. It never submits "
+            "another run; use it after an uncertain submit response."
+        ),
+    )
+    wait.add_argument("run_id")
+    wait.add_argument(
+        "--timeout",
+        type=float,
+        default=120.0,
+        help="Seconds to keep polling before stopping (default: 120)",
+    )
+    wait.add_argument(
+        "--interval",
+        type=float,
+        default=1.0,
+        help="Seconds between status reads (default: 1)",
+    )
+
     cancel = commands.add_parser("cancel", help="Cancel a run")
     cancel.add_argument("run_id")
     cancel.add_argument("--reason")
@@ -76,7 +98,7 @@ def build_parser() -> argparse.ArgumentParser:
     config_commands.add_parser("get", help="Show the merged configuration (secrets masked)")
     config_set = config_commands.add_parser(
         "set",
-        help="Set api_url, provider.name, provider.model, or provider.api_key",
+        help="Set api_url or provider.name/model/api_key/auth_type/account_id",
     )
     config_set.add_argument("key")
     config_set.add_argument("value", nargs="?")

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.1/src/adaptorch_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adaptorch-cli
-Version: 0.1.0
+Version: 0.1.1
 Summary: Command-line client for AdaptOrch
 Author: ClassicMate
 License-Expression: LicenseRef-Proprietary
@@ -11,7 +11,7 @@ Project-URL: Documentation, https://adaptorch.com/mcp-docs
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: adaptorch-client<0.2,>=0.1
+Requires-Dist: adaptorch-client<0.2,>=0.1.2
 Dynamic: license-file
 
 # adaptorch-cli

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.1}/src/adaptorch_cli.egg-info/SOURCES.txt

@@ -16,4 +16,5 @@ src/adaptorch_cli.egg-info/top_level.txt
 tests/test_cli_boundary.py
 tests/test_cli_commands.py
 tests/test_cli_integration.py
-tests/test_cli_login_config.py
+tests/test_cli_login_config.py
+tests/test_cli_oauth.py

adaptorch_cli-0.1.1/src/adaptorch_cli.egg-info/requires.txt

@@ -0,0 +1 @@
+adaptorch-client<0.2,>=0.1.2

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.1}/tests/test_cli_commands.py

@@ -118,6 +118,43 @@ def test_run_get_prints_client_json(run_cli: CliRunner) -> None:
     assert _json_stdout(result.stdout) == {"id": "run-1", "status": "RUNNING"}
 
 
+def test_run_wait_reads_until_terminal_without_resubmitting(run_cli: CliRunner) -> None:
+    result = run_cli(
+        [
+            "--output",
+            "json",
+            "run",
+            "wait",
+            "run-1",
+            "--timeout",
+            "5",
+            "--interval",
+            "0.5",
+        ]
+    )
+
+    assert result.returncode == 0
+    assert _json_stdout(result.stdout) == {
+        "reason": "terminal",
+        "polls": 1,
+        "elapsed_seconds": 0.01,
+        "run": {"id": "run-1", "status": "SUCCEEDED"},
+    }
+    calls = [json.loads(line) for line in result.client_log.splitlines()]
+    assert calls[-1] == {
+        "args": ["run-1"],
+        "kwargs": {"interval_seconds": 0.5, "timeout_seconds": 5.0},
+        "method": "wait_for_run",
+    }
+
+
+def test_run_wait_rejects_non_positive_bounds(run_cli: CliRunner) -> None:
+    result = run_cli(["--output", "json", "run", "wait", "run-1", "--timeout", "0"])
+
+    assert result.returncode != 0
+    assert result.client_log.count("wait_for_run") == 0
+
+
 def test_run_cancel_prints_client_json(run_cli: CliRunner) -> None:
     result = run_cli(["--output", "json", "run", "cancel", "run-1"])
 

adaptorch_cli-0.1.1/tests/test_cli_oauth.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from adaptorch_cli import cli, config_store
+
+
+@pytest.fixture(autouse=True)
+def isolated_config(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    monkeypatch.setenv("ADAPTORCH_CONFIG_DIR", str(tmp_path))
+    for name in (
+        "ADAPTORCH_PROVIDER",
+        "ADAPTORCH_PROVIDER_MODEL",
+        "ADAPTORCH_PROVIDER_API_KEY",
+        "ADAPTORCH_PROVIDER_AUTH_TYPE",
+        "ADAPTORCH_PROVIDER_ACCOUNT_ID",
+    ):
+        monkeypatch.delenv(name, raising=False)
+
+
+def test_cli_resolves_oauth_from_environment_without_persisting_token(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    for name, value in {
+        "ADAPTORCH_PROVIDER": "openai_codex",
+        "ADAPTORCH_PROVIDER_MODEL": "gpt-5-codex",
+        "ADAPTORCH_PROVIDER_API_KEY": "synthetic-oauth-token",
+        "ADAPTORCH_PROVIDER_AUTH_TYPE": "oauth",
+        "ADAPTORCH_PROVIDER_ACCOUNT_ID": "caller-account",
+    }.items():
+        monkeypatch.setenv(name, value)
+    credential = cli._submission_credential()
+    assert credential is not None
+    assert credential.headers["X-Provider-Auth-Type"] == "oauth"
+    assert credential.headers["X-Provider-Account-Id"] == "caller-account"
+    assert not config_store.config_path().exists()
+
+
+def test_cli_environment_credential_never_borrows_account_from_config(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    config_store.save_config(
+        {
+            "provider": {
+                "provider": "openai_codex",
+                "model": "gpt-5-codex",
+                "api_key": "old-token",
+                "auth_type": "oauth",
+                "account_id": "old-account",
+            }
+        }
+    )
+    monkeypatch.setenv("ADAPTORCH_PROVIDER", "openai_codex")
+    monkeypatch.setenv("ADAPTORCH_PROVIDER_MODEL", "gpt-5-codex")
+    monkeypatch.setenv("ADAPTORCH_PROVIDER_API_KEY", "new-token")
+    credential = cli._submission_credential()
+    assert credential is not None
+    assert credential.account_id is None
+    assert credential.api_key == "new-token"
+
+
+def test_cli_oauth_config_keys_and_view_are_safe() -> None:
+    config_store.set_config_value("provider.name", "openai_codex")
+    config_store.set_config_value("provider.model", "gpt-5-codex")
+    config_store.set_config_value("provider.api_key", "synthetic-oauth-token")
+    config_store.set_config_value("provider.auth_type", "oauth")
+    config_store.set_config_value("provider.account_id", "caller-account")
+    credential = cli._submission_credential()
+    assert credential is not None and credential.account_id == "caller-account"
+    view = json.dumps(config_store.config_view())
+    assert "synthetic-oauth-token" not in view
+    assert "caller-account" not in view
+    assert config_store.config_view()["provider"]["account_id_configured"] is True

adaptorch_cli-0.1.0/src/adaptorch_cli.egg-info/requires.txt

@@ -1 +0,0 @@
-adaptorch-client<0.2,>=0.1