adaptorch-cli 0.1.0__tar.gz

adaptorch_cli-0.1.0/LICENSE

@@ -0,0 +1,14 @@
+Copyright (c) 2026 ClassicMate. All rights reserved.
+
+This software and associated documentation files (the "Software") are proprietary
+and confidential. Unauthorized copying, distribution, modification, public
+display, or any use of the Software other than as expressly authorized by ClassicMate
+is strictly prohibited.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

adaptorch_cli-0.1.0/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: adaptorch-cli
+Version: 0.1.0
+Summary: Command-line client for AdaptOrch
+Author: ClassicMate
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://adaptorch.com
+Project-URL: Repository, https://github.com/dmae97/Adaptorch-MCP
+Project-URL: Issues, https://github.com/dmae97/Adaptorch-MCP/issues
+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
+Dynamic: license-file
+
+# adaptorch-cli
+
+Independent AdaptOrch SaaS CLI. Installs the `adaptorchctl` command and uses `adaptorch-client`; it does not invoke `adaptorch` or `adaptorch-mcp`.
+
+Log in once and every command picks the credential up:
+
+```bash
+adaptorchctl auth login      # prompts for the key, verifies it, stores it at
+                             # ~/.config/adaptorch/config.json (mode 0600)
+adaptorchctl auth status     # shows credential_source: env | config | none
+adaptorchctl auth logout     # removes the stored key
+```
+
+`ADAPTORCH_API_KEY` still works and always wins over the stored key, so CI
+keeps injecting secrets via the environment. `config set provider.{name,model,
+api_key}` persists BYOK wiring for `run submit`; the env vars
+`ADAPTORCH_PROVIDER`, `ADAPTORCH_PROVIDER_MODEL`, and
+`ADAPTORCH_PROVIDER_API_KEY` override the stored values. Provider credentials
+become `X-Provider`, `X-Provider-Model`, and `X-Provider-Key` only on
+`run submit`; reads and cancellation never receive the provider key.
+`ADAPTORCH_API_KEY` remains the separate tenant key.
+
+Install the current `adaptorch-client` and `adaptorch-cli` source packages together.
+A git push does not replace a previously published PyPI version.
+
+See [`../../docs/adaptorchctl-usage.ko.md`](../../docs/adaptorchctl-usage.ko.md) for usage.
+
+## License
+
+Proprietary — Copyright ClassicMate. All rights reserved. See [LICENSE](https://github.com/dmae97/Adaptorch-MCP/blob/main/LICENSE).

adaptorch_cli-0.1.0/README.md

@@ -0,0 +1,30 @@
+# adaptorch-cli
+
+Independent AdaptOrch SaaS CLI. Installs the `adaptorchctl` command and uses `adaptorch-client`; it does not invoke `adaptorch` or `adaptorch-mcp`.
+
+Log in once and every command picks the credential up:
+
+```bash
+adaptorchctl auth login      # prompts for the key, verifies it, stores it at
+                             # ~/.config/adaptorch/config.json (mode 0600)
+adaptorchctl auth status     # shows credential_source: env | config | none
+adaptorchctl auth logout     # removes the stored key
+```
+
+`ADAPTORCH_API_KEY` still works and always wins over the stored key, so CI
+keeps injecting secrets via the environment. `config set provider.{name,model,
+api_key}` persists BYOK wiring for `run submit`; the env vars
+`ADAPTORCH_PROVIDER`, `ADAPTORCH_PROVIDER_MODEL`, and
+`ADAPTORCH_PROVIDER_API_KEY` override the stored values. Provider credentials
+become `X-Provider`, `X-Provider-Model`, and `X-Provider-Key` only on
+`run submit`; reads and cancellation never receive the provider key.
+`ADAPTORCH_API_KEY` remains the separate tenant key.
+
+Install the current `adaptorch-client` and `adaptorch-cli` source packages together.
+A git push does not replace a previously published PyPI version.
+
+See [`../../docs/adaptorchctl-usage.ko.md`](../../docs/adaptorchctl-usage.ko.md) for usage.
+
+## License
+
+Proprietary — Copyright ClassicMate. All rights reserved. See [LICENSE](https://github.com/dmae97/Adaptorch-MCP/blob/main/LICENSE).

adaptorch_cli-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "adaptorch-cli"
+version = "0.1.0"
+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"]
+
+[project.urls]
+Homepage = "https://adaptorch.com"
+Repository = "https://github.com/dmae97/Adaptorch-MCP"
+Issues = "https://github.com/dmae97/Adaptorch-MCP/issues"
+Documentation = "https://adaptorch.com/mcp-docs"
+
+[project.scripts]
+adaptorchctl = "adaptorch_cli.cli:entrypoint"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+adaptorch_cli = ["py.typed"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true

adaptorch_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

adaptorch_cli-0.1.0/src/adaptorch_cli/__init__.py

@@ -0,0 +1 @@
+"""AdaptOrch command-line client."""

adaptorch_cli-0.1.0/src/adaptorch_cli/__main__.py

@@ -0,0 +1,3 @@
+from adaptorch_cli.cli import entrypoint
+
+entrypoint()

adaptorch_cli-0.1.0/src/adaptorch_cli/cli.py

@@ -0,0 +1,351 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import sys
+import uuid
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Never, Protocol, TypeAlias
+
+from adaptorch_client import (
+    AdaptOrchAPIError,
+    AdaptOrchClient,
+    ClientConfig,
+    ProviderCredential,
+    validate_api_url,
+)
+
+from adaptorch_cli import config_store
+from adaptorch_cli.parser import build_parser, parse_args
+
+JSONValue: TypeAlias = bool | int | float | str | list["JSONValue"] | dict[str, "JSONValue"] | None
+JSONMapping: TypeAlias = dict[str, JSONValue]
+
+_MAX_SUBMIT_BYTES = 8 * 1024 * 1024
+
+
+class PayloadResult(Protocol):
+    def to_payload(self) -> JSONMapping: ...
+
+
+def _write_json(payload: JSONMapping) -> None:
+    print(json.dumps(payload, allow_nan=False, sort_keys=True, separators=(",", ":")))
+
+
+def _reject_json_constant(_value: str) -> Never:
+    raise ValueError("non-finite JSON number")
+
+
+def _finite_float(text: str) -> float:
+    value = float(text)
+    if not math.isfinite(value):
+        raise ValueError("non-finite JSON number")
+    return value
+
+
+def _validated_api_url(api_url: str, parser: argparse.ArgumentParser) -> str:
+    try:
+        return validate_api_url(api_url)
+    except ValueError:
+        parser.error(
+            "invalid --api-url: expected an https:// origin (or exact loopback http://)"
+            " without credentials, path, query, or fragment"
+        )
+
+
+def _read_submit_bytes(file_name: str, parser: argparse.ArgumentParser) -> bytes:
+    try:
+        if file_name == "-":
+            return sys.stdin.buffer.read(_MAX_SUBMIT_BYTES + 1)
+        with Path(file_name).open("rb") as stream:
+            return stream.read(_MAX_SUBMIT_BYTES + 1)
+    except OSError:
+        parser.error("submit input must be a readable JSON object")
+
+
+def _read_submit_payload(file_name: str, parser: argparse.ArgumentParser) -> JSONMapping:
+    raw = _read_submit_bytes(file_name, parser)
+    if len(raw) > _MAX_SUBMIT_BYTES:
+        parser.error("submit input exceeds the 8 MiB limit")
+    try:
+        value: JSONValue = json.loads(
+            raw.decode("utf-8"),
+            parse_constant=_reject_json_constant,
+            parse_float=_finite_float,
+        )
+    # pi-lens-ignore: unreachable-except
+    except RecursionError:
+        parser.error("submit input JSON is too deeply nested")
+    except ValueError:
+        parser.error("submit input must be a readable JSON object")
+    if not isinstance(value, dict):
+        parser.error("submit input must be a JSON object")
+    return value
+
+
+def _require_client(api_url: str) -> AdaptOrchClient:
+    api_key, _source = config_store.resolve_api_key()
+    if not api_key:
+        print(
+            "authentication required: run `adaptorchctl auth login` or set ADAPTORCH_API_KEY",
+            file=sys.stderr,
+        )
+        raise SystemExit(3)
+    return AdaptOrchClient(ClientConfig(api_url=api_url, api_key=api_key))
+
+
+def _submission_credential() -> ProviderCredential | None:
+    resolved, _source = config_store.resolve_provider_credential()
+    if resolved is None:
+        return None
+    provider, model, key = resolved
+    return ProviderCredential(provider, model, key)
+
+
+def _read_secret(prompt: str, *, stdin_flag: bool) -> str:
+    """Read a secret from stdin (piped or --value-stdin) or a hidden prompt.
+
+    Never echoed: values on argv are rejected upstream by _CREDENTIAL_FLAGS.
+    """
+    if stdin_flag or not sys.stdin.isatty():
+        value = sys.stdin.read().strip()
+    else:
+        import getpass
+
+        value = getpass.getpass(prompt).strip()
+    return value
+
+
+def _result_payload(result: PayloadResult) -> JSONMapping:
+    return result.to_payload()
+
+
+def _auth_command(
+    args: argparse.Namespace,
+    api_url: str,
+    parser: argparse.ArgumentParser,
+) -> JSONMapping:
+    sub: str = args.auth_command
+    if sub == "status":
+        api_key, source = config_store.resolve_api_key()
+        return {
+            "authenticated": api_key is not None,
+            "credential_source": source,
+            "api_url": api_url,
+        }
+    if sub == "logout":
+        removed = config_store.clear_credentials()
+        return {"logged_out": True, "removed_stored_key": removed}
+    if sub == "login":
+        login_url = getattr(args, "login_api_url", None) or api_url
+        try:
+            login_url = validate_api_url(login_url)
+        except ValueError:
+            parser.error(
+                "invalid --api-url: expected an https:// origin (or exact loopback http://)"
+            )
+        key = _read_secret("AdaptOrch API key: ", stdin_flag=False)
+        if not key:
+            parser.error("no API key provided on stdin or at the prompt")
+        verified: bool | None = None
+        if not args.no_verify:
+            try:
+                whoami = AdaptOrchClient(ClientConfig(api_url=login_url, api_key=key)).whoami()
+                verified = True
+                _ = whoami
+            except AdaptOrchAPIError as error:
+                print(
+                    f"login verification failed (HTTP {error.status_code}); "
+                    "key not saved. Retry with --no-verify to store anyway.",
+                    file=sys.stderr,
+                )
+                raise SystemExit(3) from error
+        config_store.store_credentials(api_key=key, api_url=login_url)
+        return {
+            "logged_in": True,
+            "api_url": login_url,
+            "verified": bool(verified),
+            "config_path": str(config_store.config_path()),
+        }
+    parser.error("unknown auth command")
+
+
+def _config_command(
+    args: argparse.Namespace,
+    api_url: str,
+    parser: argparse.ArgumentParser,
+) -> JSONMapping:
+    sub: str = args.config_command
+    if sub == "get":
+        view = config_store.config_view()
+        view["api_url"] = api_url
+        return view
+    if sub == "set":
+        key: str = args.key
+        if key not in config_store.configurable_keys():
+            parser.error(
+                "unknown config key; expected one of: "
+                + ", ".join(config_store.configurable_keys())
+            )
+        value = getattr(args, "value", None)
+        if config_store.is_secret_key(key):
+            if value is not None:
+                parser.error(f"{key} is a secret; pass it via --value-stdin or a piped stdin")
+            value = _read_secret("Value: ", stdin_flag=args.value_stdin)
+        elif args.value_stdin:
+            value = sys.stdin.read().strip()
+        elif value is None:
+            parser.error("config set requires a value (or --value-stdin)")
+        if key == "api_url":
+            try:
+                value = validate_api_url(value)
+            except ValueError:
+                parser.error(
+                    "invalid api_url: expected an https:// origin (or exact loopback http://)"
+                )
+        config_store.set_config_value(key, value)
+        return {"set": key, "config_path": str(config_store.config_path())}
+    if sub == "unset":
+        removed = config_store.unset_config_value(args.key)
+        return {"unset": args.key, "removed": removed}
+    parser.error("unknown config command")
+
+
+def _run_command(
+    args: argparse.Namespace,
+    api_url: str,
+    parser: argparse.ArgumentParser,
+) -> tuple[JSONMapping, bool]:
+    command: str = args.run_command
+    match command:
+        case "submit":
+            file_name: str = args.file
+            request_id: str | None = args.request_id
+            payload = _read_submit_payload(file_name, parser)
+            submit_result = _require_client(api_url).submit_run(
+                payload,
+                idempotency_key=request_id or str(uuid.uuid4()),
+                provider_credential=_submission_credential(),
+            )
+            return _result_payload(submit_result), False
+        case "list":
+            status: str | None = args.status
+            project_id: str | None = args.project_id
+            list_result = _require_client(api_url).list_runs(
+                status=status,
+                project_id=project_id,
+            )
+            return _result_payload(list_result), False
+        case "get":
+            run_id: str = args.run_id
+            return _result_payload(_require_client(api_url).get_run(run_id)), True
+        case "cancel":
+            cancel_run_id: str = args.run_id
+            reason: str | None = args.reason
+            cancel_result = _require_client(api_url).cancel_run(
+                cancel_run_id,
+                reason=reason,
+            )
+            return _result_payload(cancel_result), False
+        case _:
+            parser.error("unknown run command")
+
+
+def _execute(
+    args: argparse.Namespace,
+    api_url: str,
+    parser: argparse.ArgumentParser,
+) -> tuple[JSONMapping, bool]:
+    command: str = args.command
+    match command:
+        case "auth":
+            return _auth_command(args, api_url, parser), False
+        case "config":
+            return _config_command(args, api_url, parser), False
+        case "whoami":
+            return _result_payload(_require_client(api_url).whoami()), False
+        case "capabilities":
+            return _result_payload(_require_client(api_url).capabilities()), False
+        case "run":
+            return _run_command(args, api_url, parser)
+        case "evidence":
+            evidence_run_id: str = args.run_id
+            return _result_payload(_require_client(api_url).get_evidence(evidence_run_id)), False
+        case "artifact":
+            artifact_run_id: str = args.run_id
+            return _result_payload(_require_client(api_url).list_artifacts(artifact_run_id)), False
+        case _:
+            parser.error("unknown command")
+
+
+def _api_exit_code(error: AdaptOrchAPIError) -> int:
+    status_code = error.status_code
+    if status_code in {401, 403}:
+        return 3
+    if status_code == 404:
+        return 4
+    if status_code == 409:
+        return 5
+    if status_code == 429:
+        return 6
+    if status_code is None or 500 <= status_code <= 599:
+        return 7
+    return 10
+
+
+def _payload_status(payload: JSONMapping) -> str:
+    status = payload.get("status")
+    if isinstance(status, str):
+        return status
+    data = payload.get("data")
+    if isinstance(data, dict):
+        nested = data.get("status")
+        if isinstance(nested, str):
+            return nested
+    return ""
+
+
+def _run_status_exit(payload: JSONMapping) -> int:
+    normalized = _payload_status(payload).lower()
+    if normalized == "failed":
+        return 8
+    if normalized == "cancelled":
+        return 9
+    if normalized == "inconclusive":
+        return 10
+    return 0
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parse_args(argv)
+    flag_url = getattr(args, "api_url", None)
+    if flag_url is not None and not flag_url.strip():
+        parser.error("invalid --api-url: expected an https:// origin (or exact loopback http://)")
+    resolved_url, _url_source = config_store.resolve_api_url(flag_url)
+    api_url = _validated_api_url(resolved_url, parser)
+    try:
+        payload, check_run_status = _execute(args, api_url, parser)
+        try:
+            _write_json(payload)
+        except ValueError:
+            print("response contained non-encodable JSON values", file=sys.stderr)
+            return 7
+        return _run_status_exit(payload) if check_run_status else 0
+    # pi-lens-ignore: unreachable-except
+    except KeyboardInterrupt:
+        print("interrupted", file=sys.stderr)
+        return 130
+    # pi-lens-ignore: unreachable-except
+    except AdaptOrchAPIError as error:
+        code = _api_exit_code(error)
+        print(f"request failed (HTTP {error.status_code})", file=sys.stderr)
+        return code
+    except ValueError:
+        parser.error("invalid CLI input")
+
+
+def entrypoint() -> None:
+    raise SystemExit(main())