adaptorch-cli 0.1.0__py3-none-any.whl

adaptorch_cli/__init__.py

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

adaptorch_cli/__main__.py

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

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())

adaptorch_cli/config_store.py

@@ -0,0 +1,215 @@
+"""Persisted CLI configuration (~/.config/adaptorch/config.json).
+
+Railway-style credential store: `auth login` writes the tenant API key and the
+resolved API URL here so every later command works without exporting
+ADAPTORCH_API_KEY. `config set provider.*` wires a BYOK provider/model the same
+way ADAPTORCH_PROVIDER* env vars do.
+
+Precedence is always: environment variable > persisted config > built-in
+default. Env wins so CI and one-shot overrides never fight stored state.
+
+Secrets are stored as plain fields but the file is written mode 0600 and never
+echoed back to stdout — `config get` and `auth status` mask them.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+CONFIG_DIR_ENV = "ADAPTORCH_CONFIG_DIR"
+DEFAULT_API_URL = "https://adaptorch.com"
+
+# user-facing key -> stored leaf under the "provider" object
+_PROVIDER_KEY_MAP = {
+    "provider.name": "provider",
+    "provider.model": "model",
+    "provider.api_key": "api_key",
+}
+_CONFIGURABLE_KEYS = frozenset({"api_url", *_PROVIDER_KEY_MAP})
+
+# Keys whose values must never travel on argv or appear in stdout.
+_SECRET_KEYS = frozenset({"provider.api_key"})
+
+
+def config_dir() -> Path:
+    override = os.environ.get(CONFIG_DIR_ENV)
+    if override and override.strip():
+        return Path(override.strip()).expanduser()
+    xdg = os.environ.get("XDG_CONFIG_HOME")
+    if xdg and xdg.strip():
+        return Path(xdg.strip()).expanduser() / "adaptorch"
+    return Path.home() / ".config" / "adaptorch"
+
+
+def config_path() -> Path:
+    return config_dir() / "config.json"
+
+
+def load_config() -> dict[str, Any]:
+    path = config_path()
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        return {}
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return raw if isinstance(raw, dict) else {}
+
+
+def save_config(config: dict[str, Any]) -> None:
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(config, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    os.chmod(tmp, 0o600)
+    tmp.replace(path)
+
+
+def configurable_keys() -> tuple[str, ...]:
+    return tuple(sorted(_CONFIGURABLE_KEYS))
+
+
+def is_secret_key(key: str) -> bool:
+    return key in _SECRET_KEYS
+
+
+def get_config_value(key: str) -> str | None:
+    config = load_config()
+    if key == "api_url":
+        value = config.get("api_url")
+    elif key in _PROVIDER_KEY_MAP:
+        provider = config.get("provider")
+        leaf = _PROVIDER_KEY_MAP[key]
+        value = provider.get(leaf) if isinstance(provider, dict) else None
+    else:
+        return None
+    return value.strip() if isinstance(value, str) and value.strip() else None
+
+
+def set_config_value(key: str, value: str) -> None:
+    if key not in _CONFIGURABLE_KEYS:
+        raise KeyError(key)
+    config = load_config()
+    if key == "api_url":
+        config["api_url"] = value
+    else:
+        provider = config.setdefault("provider", {})
+        if not isinstance(provider, dict):
+            provider = {}
+            config["provider"] = provider
+        provider[_PROVIDER_KEY_MAP[key]] = value
+    save_config(config)
+
+
+def unset_config_value(key: str) -> bool:
+    config = load_config()
+    removed = False
+    if key == "api_url":
+        removed = "api_url" in config
+        config.pop("api_url", None)
+    elif key == "api_key":
+        removed = "api_key" in config
+        config.pop("api_key", None)
+    elif key == "provider":
+        removed = "provider" in config
+        config.pop("provider", None)
+    elif key in _PROVIDER_KEY_MAP:
+        provider = config.get("provider")
+        leaf = _PROVIDER_KEY_MAP[key]
+        if isinstance(provider, dict) and leaf in provider:
+            provider.pop(leaf, None)
+            removed = True
+        if isinstance(provider, dict) and not provider:
+            config.pop("provider", None)
+    else:
+        return False
+    if removed:
+        save_config(config)
+    return removed
+
+
+def store_credentials(*, api_key: str, api_url: str) -> None:
+    config = load_config()
+    config["api_key"] = api_key
+    config["api_url"] = api_url
+    save_config(config)
+
+
+def clear_credentials() -> bool:
+    config = load_config()
+    if "api_key" not in config:
+        return False
+    config.pop("api_key", None)
+    save_config(config)
+    return True
+
+
+def resolve_api_key() -> tuple[str | None, str]:
+    env_value = os.environ.get("ADAPTORCH_API_KEY")
+    if env_value and env_value.strip():
+        return env_value.strip(), "env"
+    stored = load_config().get("api_key")
+    if isinstance(stored, str) and stored.strip():
+        return stored.strip(), "config"
+    return None, "none"
+
+
+def resolve_api_url(flag_value: str | None) -> tuple[str, str]:
+    # Explicit --api-url wins over everything (same precedence the argparse
+    # default gave it before); then env, then stored config, then default.
+    if flag_value and flag_value.strip():
+        return flag_value.strip(), "flag"
+    env_value = os.environ.get("ADAPTORCH_API_URL")
+    if env_value and env_value.strip():
+        return env_value.strip(), "env"
+    stored = get_config_value("api_url")
+    if stored:
+        return stored, "config"
+    return DEFAULT_API_URL, "default"
+
+
+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:
+        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:
+            return (provider, model, key), "config"
+    return None, "none"
+
+
+def mask_secret(value: str | None) -> str | None:
+    if not value:
+        return None
+    if len(value) <= 8:
+        return "****"
+    return f"{value[:4]}…{value[-4:]}"
+
+
+def config_view() -> dict[str, Any]:
+    config = load_config()
+    provider_raw = config.get("provider")
+    provider: dict[str, Any] = provider_raw if isinstance(provider_raw, dict) else {}
+    stored_key = config.get("api_key")
+    provider_key = provider.get("api_key")
+    return {
+        "api_url": config.get("api_url"),
+        "api_key": mask_secret(stored_key if isinstance(stored_key, str) else None),
+        "credential_source": resolve_api_key()[1],
+        "provider": {
+            "name": provider.get("provider"),
+            "model": provider.get("model"),
+            "api_key": mask_secret(provider_key if isinstance(provider_key, str) else None),
+            "source": resolve_provider_credential()[1],
+        },
+        "config_path": str(config_path()),
+    }

adaptorch_cli/parser.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from collections.abc import Sequence
+
+_DEFAULT_API_URL = "https://adaptorch.com"
+_CREDENTIAL_FLAGS = ("--token", "--api-key")
+_IDEMPOTENCY_KEY_RE = re.compile(
+    r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE
+)
+
+
+def _idempotency_key(value: str) -> str:
+    if not _IDEMPOTENCY_KEY_RE.fullmatch(value):
+        raise argparse.ArgumentTypeError("request ID must be a hyphenated UUID")
+    return value
+
+
+def _add_run_commands(parent: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    run = parent.add_parser("run", help="Manage runs")
+    commands = run.add_subparsers(dest="run_command", required=True)
+
+    submit = commands.add_parser("submit", help="Submit a run")
+    submit.add_argument("--file", required=True, help="JSON request path, or - for stdin")
+    submit.add_argument("--request-id", type=_idempotency_key, help="UUID idempotency key")
+
+    list_parser = commands.add_parser("list", help="List runs")
+    list_parser.add_argument("--status")
+    list_parser.add_argument("--project-id")
+
+    get = commands.add_parser("get", help="Get a run")
+    get.add_argument("run_id")
+
+    cancel = commands.add_parser("cancel", help="Cancel a run")
+    cancel.add_argument("run_id")
+    cancel.add_argument("--reason")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="adaptorchctl")
+    parser.add_argument(
+        "--api-url",
+        default=None,
+        help=(
+            "Control-plane origin. Resolution order: this flag, "
+            "ADAPTORCH_API_URL, the stored config (auth login), then "
+            f"{_DEFAULT_API_URL}."
+        ),
+    )
+    parser.add_argument("--output", choices=("json",), default="json")
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    auth = commands.add_parser("auth", help="Manage authentication")
+    auth_commands = auth.add_subparsers(dest="auth_command", required=True)
+    auth_commands.add_parser("status", help="Show the effective credential source")
+    login = auth_commands.add_parser(
+        "login",
+        help="Store a tenant API key (reads it from the prompt or piped stdin)",
+    )
+    login.add_argument(
+        "--api-url",
+        dest="login_api_url",
+        help="Control-plane origin to persist (default: current --api-url resolution)",
+    )
+    login.add_argument(
+        "--no-verify",
+        action="store_true",
+        help="Skip the whoami check before saving (offline login)",
+    )
+    auth_commands.add_parser("logout", help="Remove the stored API key")
+
+    config = commands.add_parser("config", help="Inspect and update configuration")
+    config_commands = config.add_subparsers(dest="config_command", required=True)
+    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",
+    )
+    config_set.add_argument("key")
+    config_set.add_argument("value", nargs="?")
+    config_set.add_argument(
+        "--value-stdin",
+        action="store_true",
+        help="Read the value from stdin (required for secrets)",
+    )
+    config_unset = config_commands.add_parser(
+        "unset",
+        help="Remove api_url, api_key, provider, or a provider.* field",
+    )
+    config_unset.add_argument("key")
+
+    commands.add_parser("whoami", help="Show the authenticated identity")
+    commands.add_parser("capabilities", help="Show server capabilities")
+    _add_run_commands(commands)
+
+    evidence = commands.add_parser("evidence", help="Inspect run evidence")
+    show = evidence.add_subparsers(dest="evidence_command", required=True).add_parser("show")
+    show.add_argument("run_id")
+
+    artifact = commands.add_parser("artifact", help="Inspect run artifacts")
+    list_artifacts = artifact.add_subparsers(dest="artifact_command", required=True).add_parser(
+        "list"
+    )
+    list_artifacts.add_argument("run_id")
+    return parser
+
+
+def parse_args(argv: Sequence[str] | None) -> argparse.Namespace:
+    arguments = list(argv) if argv is not None else None
+    inspected = arguments if arguments is not None else sys.argv[1:]
+    if any(argument.startswith(flag) for argument in inspected for flag in _CREDENTIAL_FLAGS):
+        build_parser().error("credential flags are not supported; use ADAPTORCH_API_KEY")
+    return build_parser().parse_args(arguments)

adaptorch_cli-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,12 @@
+adaptorch_cli/__init__.py,sha256=TdTlC9AgxqPXk9r6DF65q5DKHe2JMT_4gl1UKRuyvZU,37
+adaptorch_cli/__main__.py,sha256=FZ_NGpkbOJoyt0KrNSfGfIqz0fw3PFe7VAJzFIrfq64,55
+adaptorch_cli/cli.py,sha256=2jUQ0jZ5S9N3oFsrf-CfzR6WJYM4BM40OgnfIqAEyUQ,11897
+adaptorch_cli/config_store.py,sha256=P__8yl5-WXrAiDsO21M_8OGvKiPh-FpdMl6TdBs_kPo,7075
+adaptorch_cli/parser.py,sha256=nHpY_Yj9hvYKG9J0i5sPoiAX0bqHmD04a5ObE6xwiCg,4520
+adaptorch_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adaptorch_cli-0.1.0.dist-info/licenses/LICENSE,sha256=nTFgpQO0Lh5wFPjLzTIu-GnUVAFLlmdI6mLUkXjivpE,783
+adaptorch_cli-0.1.0.dist-info/METADATA,sha256=fjxt0S-9rap01HeH0Ce5-DEa2EGQ0ihkDjQ2KmEtI1k,2000
+adaptorch_cli-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+adaptorch_cli-0.1.0.dist-info/entry_points.txt,sha256=5GY-UW4_v5YKxWvhWuxcM3Z1EGWlVFQ38Y4QoqseWa8,62
+adaptorch_cli-0.1.0.dist-info/top_level.txt,sha256=zUfCzlUONIzyiRRRi6CYq1D1r_0FNfEFRmIKa51Jgwg,14
+adaptorch_cli-0.1.0.dist-info/RECORD,,

adaptorch_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

adaptorch_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+adaptorchctl = adaptorch_cli.cli:entrypoint

adaptorch_cli-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+adaptorch_cli