devlift-cli 0.1.0__py3-none-any.whl

devlift_cli/__init__.py

@@ -0,0 +1,3 @@
+"""DevLift command-line tool."""
+
+__version__ = "0.1.0"

devlift_cli/__main__.py

@@ -0,0 +1,4 @@
+from devlift_cli.app import main
+
+if __name__ == "__main__":
+    main()

devlift_cli/api/approvals.py

@@ -0,0 +1,53 @@
+"""The review lane: change requests on a service configuration.
+
+    GET  /approvals                         requests you raised or can act on (status, resource_code filters)
+    GET  /approvals/{queue_code}            one request: frozen diff, snapshot, history, your flags
+    GET  /approvals/services                reviewer inbox, one row per service with pending/approved counts
+    GET  /approvals/history?resource_code=  every request ever raised against one configuration
+    GET  /approvals/permissions?resource_code=   what you may do on a configuration
+    POST /approvals/{queue_code}/<verb>     submit | withdraw | discard | approve | request-changes | reject | revoke
+
+    POST /deployments/multiple-deploy       ship the approved change set of one configuration
+    GET  /deployments/multiple-deploy/status/{workflow_id}
+"""
+
+from __future__ import annotations
+
+from devlift_cli.api.client import ApiClient
+
+VERBS = ("submit", "withdraw", "discard", "approve", "request-changes", "reject", "revoke")
+
+
+def list_requests(api: ApiClient, *, status: str | None = None, resource_code: str | None = None, limit: int = 200) -> list[dict]:
+    return api.get("/approvals", {"status": status, "resource_code": resource_code, "limit": limit}).get("approvals", [])
+
+
+def get_request(api: ApiClient, queue_code: str) -> dict:
+    return api.get(f"/approvals/{queue_code}")
+
+
+def services_awaiting(api: ApiClient) -> list[dict]:
+    return api.get("/approvals/services").get("services", [])
+
+
+def history(api: ApiClient, resource_code: str, limit: int = 50) -> list[dict]:
+    return api.get("/approvals/history", {"resource_code": resource_code, "limit": limit}).get("approvals", [])
+
+
+def permissions(api: ApiClient, resource_code: str) -> dict:
+    return api.get("/approvals/permissions", {"resource_code": resource_code})
+
+
+def act(api: ApiClient, queue_code: str, verb: str, comment: str = "") -> dict:
+    if verb not in VERBS:
+        raise ValueError(verb)
+    body = {} if verb == "discard" else {"comment": comment or ""}
+    return api.post(f"/approvals/{queue_code}/{verb}", body)
+
+
+def multiple_deploy(api: ApiClient, service_config_code: str) -> dict:
+    return api.post("/deployments/multiple-deploy", {"service_config_code": service_config_code})
+
+
+def multiple_deploy_status(api: ApiClient, workflow_id: str) -> dict:
+    return api.get(f"/deployments/multiple-deploy/status/{workflow_id}")

devlift_cli/api/catalog.py

@@ -0,0 +1,96 @@
+"""Read-only catalog calls: the things a user picks from.
+
+Each function returns the server's list as-is (dicts), so `-o json` shows
+exactly what the backend said. Filtering by name happens in resolve/names.py.
+"""
+
+from __future__ import annotations
+
+from devlift_cli.api.client import ApiClient
+
+
+def list_applications(api: ApiClient, active: bool | None = None) -> list[dict]:
+    body = {"limit": 500}
+    if active is not None:
+        body["is_active"] = active
+    return api.post("/applications/get-all-applications", body).get("applications", [])
+
+
+def list_services(
+    api: ApiClient,
+    application_code: str | None = None,
+    resource_group_code: str | None = None,
+    search: str | None = None,
+    active: bool | None = None,
+) -> list[dict]:
+    body: dict = {"limit": 500}
+    if application_code:
+        body["application_code"] = application_code
+    if resource_group_code:
+        body["resource_group_mst_code"] = resource_group_code
+    if search:
+        body["search_query"] = search
+    if active is not None:
+        body["is_active"] = active
+    return api.post("/services/get-all-services", body).get("services", [])
+
+
+def get_service(api: ApiClient, service_code: str) -> dict:
+    return api.post("/services/get-service-detail", {"service_code": service_code})
+
+
+def list_vendor_regions(api: ApiClient, vendor: str = "aws") -> list[dict]:
+    return api.get("/regions", {"vendor": vendor}).get("regions", [])
+
+
+def list_infrastructure_types(api: ApiClient) -> list[dict]:
+    return api.get("/infrastructure-types/get-all-infrastructure-types").get("infrastructure_types", [])
+
+
+def list_resource_groups(api: ApiClient, application_code: str | None = None, kind: str | None = None) -> list[dict]:
+    return api.get(
+        "/resource-groups/get-all-resource-groups",
+        {"application_code": application_code, "kind": kind, "limit": 500},
+    ).get("resource_groups", [])
+
+
+def list_repositories(api: ApiClient) -> list[dict]:
+    """Repositories the tenant's GitHub App can see: {name, full_name,
+    default_branch, private, html_url, updated_at}."""
+    return api.get("/github/repositories").get("repositories", [])
+
+
+def list_branches(api: ApiClient, full_name: str) -> list[dict]:
+    """Branches of one repository (owner/name): {name, protected}."""
+    owner, _, repo = full_name.partition("/")
+    return api.get(f"/github/repositories/{owner}/{repo}/branches").get("branches", [])
+
+
+def placement_options(api: ApiClient, infra_type: str | None = None) -> list[dict]:
+    """The product → environment → region tree the tenant may place things in.
+
+    Each product: {product_code, product_name, applications_mst_code,
+    environments: [{environment_enum, environment_label,
+    geo_locations: [{geo_loc_mst_code, geo_loc_name}]}]}.
+    """
+    body = {"infra_type": infra_type} if infra_type else {}
+    return api.post("/placement-parameters/get-placement-options", body).get("products", [])
+
+
+def placement_rows(products: list[dict]) -> list[dict]:
+    """Flatten the tree into one row per (product, environment, region)."""
+    rows = []
+    for product in products:
+        for env in product.get("environments", []):
+            for geo in env.get("geo_locations", []):
+                rows.append(
+                    {
+                        "product": product.get("product_name"),
+                        "application_code": product.get("applications_mst_code") or product.get("product_code"),
+                        "environment": env.get("environment_enum"),
+                        "environment_label": env.get("environment_label"),
+                        "region": geo.get("geo_loc_name"),
+                        "geo_loc_mst_code": geo.get("geo_loc_mst_code"),
+                    }
+                )
+    return rows

devlift_cli/api/client.py

@@ -0,0 +1,125 @@
+"""HTTP client for obs_tool's REST API.
+
+One instance per command invocation. Every non-2xx answer becomes a CliError
+with the server's `detail` as the message and the HTTP status mapped to the
+exit-code table in errors.py, so commands never inspect status codes
+themselves. A 401 is retried once after a token refresh.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+import httpx
+
+from devlift_cli import __version__
+from devlift_cli.auth.session import TokenSource
+from devlift_cli.config import Profile
+from devlift_cli.errors import (
+    EXIT_CONFLICT,
+    EXIT_ERROR,
+    EXIT_INPUT,
+    EXIT_NOT_FOUND,
+    EXIT_PERMISSION,
+    AuthError,
+    CliError,
+)
+
+_TIMEOUT = httpx.Timeout(120.0, connect=10.0)
+
+_STATUS_TO_EXIT = {
+    400: EXIT_INPUT,
+    403: EXIT_PERMISSION,
+    404: EXIT_NOT_FOUND,
+    409: EXIT_CONFLICT,
+    422: EXIT_INPUT,
+}
+
+
+def _detail_text(resp: httpx.Response) -> str:
+    try:
+        body = resp.json()
+    except ValueError:
+        return resp.text[:500] or resp.reason_phrase
+    detail = body.get("detail", body) if isinstance(body, dict) else body
+    if isinstance(detail, dict):
+        return str(detail.get("message") or detail.get("detail") or json.dumps(detail))
+    if isinstance(detail, list):
+        # FastAPI validation errors: [{loc, msg, type}, …]
+        parts = []
+        for item in detail:
+            if isinstance(item, dict) and "msg" in item:
+                loc = ".".join(str(p) for p in item.get("loc", []) if p not in ("body", "query"))
+                parts.append(f"{loc}: {item['msg']}" if loc else item["msg"])
+            else:
+                parts.append(str(item))
+        return "; ".join(parts)
+    return str(detail)
+
+
+class ApiClient:
+    def __init__(self, profile: Profile, tokens: TokenSource, debug: bool = False):
+        self.profile = profile
+        self.tokens = tokens
+        self.debug = debug
+        self._http = httpx.Client(
+            base_url=profile.api_url,
+            timeout=_TIMEOUT,
+            headers={"User-Agent": f"devlift-cli/{__version__}", "Accept": "application/json"},
+        )
+
+    def close(self) -> None:
+        self._http.close()
+
+    # ── verbs ────────────────────────────────────────────────────────────
+    def get(self, path: str, params: dict | None = None) -> Any:
+        return self.request("GET", path, params=params)
+
+    def post(self, path: str, json: Any = None, params: dict | None = None) -> Any:
+        return self.request("POST", path, json=json, params=params)
+
+    def put(self, path: str, json: Any = None) -> Any:
+        return self.request("PUT", path, json=json)
+
+    def delete(self, path: str) -> Any:
+        return self.request("DELETE", path)
+
+    def request(self, method: str, path: str, *, json: Any = None, params: dict | None = None) -> Any:
+        clean_params = {k: v for k, v in (params or {}).items() if v is not None}
+        token = self.tokens.current()
+        resp = self._send(method, path, token, json, clean_params)
+        if resp.status_code == 401:
+            token = self.tokens.force_refresh()
+            if token is None:
+                raise AuthError("Your session is not valid any more.")
+            resp = self._send(method, path, token, json, clean_params)
+            if resp.status_code == 401:
+                raise AuthError("Your session is not valid any more.")
+        if resp.status_code >= 300:
+            code = _STATUS_TO_EXIT.get(resp.status_code, EXIT_ERROR)
+            raise CliError(_detail_text(resp), code, http_status=resp.status_code)
+        if resp.status_code == 204 or not resp.content:
+            return None
+        try:
+            return resp.json()
+        except ValueError:
+            return resp.text
+
+    def _send(self, method: str, path: str, token: str, json: Any, params: dict) -> httpx.Response:
+        headers = {"Authorization": f"Bearer {token}"}
+        if self.debug:
+            print(f"> {method} {self.profile.api_url}{path} {params or ''}", file=sys.stderr)
+        try:
+            resp = self._http.request(method, path, json=json, params=params, headers=headers)
+        except httpx.ConnectError as exc:
+            raise CliError(
+                f"Could not connect to {self.profile.base_url}: {exc}",
+                hint="Is the DevLift backend running? Use --endpoint-url or `devlift configure`.",
+            ) from exc
+        except httpx.TimeoutException as exc:
+            raise CliError(f"{method} {path} timed out: {exc}") from exc
+        if self.debug:
+            print(f"< {resp.status_code} ({len(resp.content)} bytes)", file=sys.stderr)
+        return resp

devlift_cli/api/context.py

@@ -0,0 +1,21 @@
+"""GET /cli/context — who am I, and where is everything."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from devlift_cli.api.client import ApiClient
+
+
+class CliContext(BaseModel):
+    user_code: str
+    email: str | None = None
+    tenant_code: str
+    tenant_name: str | None = None
+    secrets_api_base_url: str | None = None
+    frontend_base_url: str | None = None
+    features: dict[str, bool] = {}
+
+
+def get_context(api: ApiClient) -> CliContext:
+    return CliContext.model_validate(api.get("/cli/context"))

devlift_cli/api/deployments.py

@@ -0,0 +1,37 @@
+"""Deployment history and live application status — what the dashboard's
+Deployments tab and the assistant's status tools read.
+
+    GET /deployments/history                         one row per workflow: status, PR, resources, who, when
+    GET /deployments/history/{workflow_id}           the same row plus its pipeline stages
+    GET /deployments/application-status              ArgoCD's view of one service configuration
+"""
+
+from __future__ import annotations
+
+from devlift_cli.api.client import ApiClient
+
+TERMINAL = {"COMPLETED", "FAILED", "TIMEOUT", "TIMEDOUT", "CANCELLED", "CANCELED"}
+
+
+def history(
+    api: ApiClient,
+    *,
+    status: str | None = None,
+    application_code: str | None = None,
+    environment: str | None = None,
+    user_code: str | None = None,
+    limit: int = 20,
+) -> tuple[list[dict], int]:
+    data = api.get("/deployments/history", {
+        "status": status, "application_code": application_code, "environment": environment,
+        "user_code": user_code, "limit": limit,
+    })
+    return data.get("items", []), int(data.get("total") or 0)
+
+
+def history_detail(api: ApiClient, workflow_id: str) -> dict:
+    return api.get(f"/deployments/history/{workflow_id}")
+
+
+def application_status(api: ApiClient, service_config_code: str, workflow_id: str | None = None) -> dict:
+    return api.get("/deployments/application-status", {"service_config_code": service_config_code, "workflow_id": workflow_id})

devlift_cli/api/infra.py

@@ -0,0 +1,94 @@
+"""Infrastructure rows, the transaction queue, and deployments of queue items.
+
+These are the calls behind `s3 / sqs / dynamodb create|update`, in the order
+the web and the in-process provisioning path use them:
+
+    POST /infrastructures                      → the resource row (code)
+    POST /transaction-queue/add-to-queue       → a queue item for it (id, code)
+    POST /transaction-queue/bulk-approve       → mark it approved
+    POST /transaction-queue/deploy             → start the deployment (workflow_id or PR)
+    GET  /transaction-queue/deploy-status/{id} → poll the workflow
+"""
+
+from __future__ import annotations
+
+from devlift_cli.api.client import ApiClient
+
+TABLE_INFRASTRUCTURE = "INFRASTRUCTURE"
+
+DUPLICATE_CHECKS = {
+    "s3_infrastructuretype_ref": ("/aws-ops/s3/validate-duplicate-bucket", "bucket_name"),
+    "sqs_infrastructuretype_ref": ("/aws-ops/sqs/validate-duplicate-queue", "queue_name"),
+    "dynamodb_infrastructuretype_ref": ("/aws-ops/dynamodb/validate-duplicate-table", "table_name"),
+}
+
+
+def validate_duplicate(api: ApiClient, infra_type: str, product_code: str, environment: str, geo_loc: str, name: str) -> dict | None:
+    """The server's own duplicate-name check, or None when the type has none."""
+    check = DUPLICATE_CHECKS.get(infra_type)
+    if not check:
+        return None
+    path, name_key = check
+    return api.post(path, {"product_code": product_code, "environment": environment, "geo_loc": geo_loc, name_key: name})
+
+
+def create_infrastructure(
+    api: ApiClient,
+    *,
+    infra_type: str,
+    application_code: str,
+    environment: str,
+    geo_loc_mst_code: str,
+    type_specific_config: dict,
+    code: str | None = None,
+    service_mst_code: str | None = None,
+    created_by: str | None = None,
+) -> dict:
+    body = {
+        "infrastructuretype_ref_code": infra_type,
+        "application_code": application_code,
+        "environment": environment,
+        "geo_loc_mst_code": geo_loc_mst_code,
+        "type_specific_config": type_specific_config,
+    }
+    if code:
+        body["code"] = code
+    if service_mst_code:
+        body["service_mst_code"] = service_mst_code
+    if created_by:
+        body["created_by"] = created_by
+    return api.post("/infrastructures", body)
+
+
+def add_to_queue(api: ApiClient, *, transaction_code: str, table_name: str, config_snapshot: dict, case_ref_code: str, queue_code: str | None = None) -> dict:
+    body = {
+        "transaction_code": transaction_code,
+        "table_name": table_name,
+        "config_snapshot": config_snapshot,
+        "case_ref_code": case_ref_code,
+    }
+    if queue_code:
+        body["queue_code"] = queue_code
+    return api.post("/transaction-queue/add-to-queue", body)
+
+
+def bulk_approve(api: ApiClient, queue_ids: list[int]) -> dict:
+    return api.post("/transaction-queue/bulk-approve", {"queue_ids": queue_ids})
+
+
+def deploy_queue_items(api: ApiClient, item_ids: list[int], environment: str | None = None) -> dict:
+    body: dict = {"item_ids": item_ids}
+    if environment:
+        body["environment"] = environment
+    return api.post("/transaction-queue/deploy", body)
+
+
+def deploy_status(api: ApiClient, workflow_id: str) -> dict:
+    return api.get(f"/transaction-queue/deploy-status/{workflow_id}")
+
+
+def list_queue(api: ApiClient, environment: str | None = None) -> list[dict]:
+    data = api.get("/transaction-queue", {"environment": environment})
+    if isinstance(data, dict):
+        return data.get("items") or data.get("queue_items") or data.get("queue") or []
+    return data or []

devlift_cli/api/infra_list.py

@@ -0,0 +1,61 @@
+"""Reading infrastructure rows: GET /infrastructure-mst/list and
+POST /infrastructure-mst/get-detail."""
+
+from __future__ import annotations
+
+from devlift_cli.api.client import ApiClient
+
+
+def list_infrastructures(
+    api: ApiClient,
+    *,
+    infra_type: str | None = None,
+    environment: str | None = None,
+    geo_loc_mst_code: str | None = None,
+    application_code: str | None = None,
+) -> list[dict]:
+    return api.get(
+        "/infrastructure-mst/list",
+        {
+            "infrastructuretype_ref_code": infra_type,
+            "environment": environment,
+            "geo_loc_mst_code": geo_loc_mst_code,
+            "applications_mst_code": application_code,
+        },
+    ).get("infrastructures", [])
+
+
+def list_clusters(
+    api: ApiClient,
+    *,
+    infra_type: str | None = None,
+    environment: str | None = None,
+    geo_loc_mst_code: str | None = None,
+    search: str | None = None,
+) -> list[dict]:
+    """EKS and ECS-EC2 clusters, as the dashboard's Clusters screen lists them.
+
+    Unlike `/list`, this includes clusters that are not registered and ones
+    hidden from the canvas, reporting both flags — `is_registered` is the
+    "may take a new service" flag, so a cluster without it cannot be chosen
+    by `eks create`.
+    """
+    return api.get(
+        "/infrastructure-mst/clusters",
+        {
+            "infrastructuretype_ref_code": infra_type,
+            "environment": environment,
+            "geo_loc_mst_code": geo_loc_mst_code,
+            "search": search,
+        },
+    ).get("clusters", [])
+
+
+def get_infrastructure(api: ApiClient, code: str) -> dict:
+    return api.post("/infrastructure-mst/get-detail", {"code": code})
+
+
+def display_name(row: dict) -> str:
+    """The name the user typed: the locator's identifier, else the stored name."""
+    locator = row.get("locator") or {}
+    return str(locator.get("identifier") or row.get("resource_identifier") or row.get("name") or row.get("code"))

devlift_cli/api/kong.py

@@ -0,0 +1,29 @@
+"""Kong gateway routes of a service, the way the dashboard's Gateway tab
+reads and writes them:
+
+    GET  /service-configs/env-geo-options/{service_code}     → the service's configurations (config_code per env/region)
+    GET  /kong-route-configs/gateway/by-config/{config_code} → the gateway state: route groups, paths, pending edits
+    POST /transaction/kong-gateway/{config_code}             → the change, parked as a DRAFT queue row (gateway half)
+"""
+
+from __future__ import annotations
+
+from devlift_cli.api.client import ApiClient
+
+GATEWAY_CASE_REF = "add_route"
+
+
+def env_geo_options(api: ApiClient, service_code: str) -> list[dict]:
+    """[{environment, geo_loc_code, geo_loc_name, config_code, cluster_name, ...}]"""
+    return api.get(f"/service-configs/env-geo-options/{service_code}").get("options", [])
+
+
+def gateway_state(api: ApiClient, config_code: str) -> dict:
+    """{service_name, environment, geo_loc_mst_code, groups: [{code, route_group_key,
+    http_method, plugins, regex_priority, updated_at, paths: [{code, route_path}],
+    pending: [...]}], ...}"""
+    return api.get(f"/kong-route-configs/gateway/by-config/{config_code}")
+
+
+def save_gateway_draft(api: ApiClient, config_code: str, gateway_groups: list[dict]) -> dict:
+    return api.post(f"/transaction/kong-gateway/{config_code}", {"gateway_groups": gateway_groups})

devlift_cli/api/services.py

@@ -0,0 +1,106 @@
+"""Services and their per-environment configuration.
+
+The calls behind `devlift eks create`, in the order the web's "Create & Add"
+and the Settings tab's Save use them:
+
+    POST /services/create-service                      → the service (service_code)
+    POST /service-configs                              → its baseline row for one placement (code)
+    POST /transaction/service-settings/{config_code}   → the settings, parked as a DRAFT queue row
+
+Plus the two read-only lists the command picks from:
+
+    GET  /languages/language-versions/grouped          → language → versions (language_ref_code)
+    GET  /service-configs/eks/language-templates       → per-language starting values
+"""
+
+from __future__ import annotations
+
+from devlift_cli.api.client import ApiClient
+
+EKS_INFRA_TYPE = "eks_infrastructuretype_ref"
+SETTINGS_CASE_REF = "update_service"
+
+
+def create_service(
+    api: ApiClient,
+    *,
+    application_code: str,
+    resource_group_code: str,
+    service_name: str,
+    service_type: str,
+    is_public_facing: bool = False,
+) -> dict:
+    return api.post(
+        "/services/create-service",
+        {
+            "application_code": application_code,
+            "resource_group_code": resource_group_code,
+            "service_name": service_name,
+            "service_type": service_type,
+            "is_active": True,
+            "is_public_facing": is_public_facing,
+        },
+    )
+
+
+def create_service_config(
+    api: ApiClient,
+    *,
+    services_mst_code: str,
+    environment: str,
+    geo_loc_mst_code: str,
+    infrastructure_mst_code: str | None,
+    config: dict,
+    infra_type: str = EKS_INFRA_TYPE,
+    vendor: str = "aws",
+) -> dict:
+    body = {
+        "services_mst_code": services_mst_code,
+        "infrastructuretype_ref_code": infra_type,
+        "infra_vendor_enum": vendor,
+        "environment": environment,
+        "geo_loc_mst_code": geo_loc_mst_code,
+        "config": config,
+    }
+    if infrastructure_mst_code:
+        body["infrastructure_mst_code"] = infrastructure_mst_code
+    return api.post("/service-configs", body)
+
+
+def save_settings_draft(
+    api: ApiClient,
+    *,
+    service_config_code: str,
+    config_snapshot: dict,
+    case_ref_code: str = SETTINGS_CASE_REF,
+    queue_code: str | None = None,
+) -> dict:
+    body: dict = {"config_snapshot": config_snapshot, "case_ref_code": case_ref_code}
+    if queue_code:
+        body["queue_code"] = queue_code
+    return api.post(f"/transaction/service-settings/{service_config_code}", body)
+
+
+def get_service_config(api: ApiClient, config_code: str) -> dict:
+    """The live configuration row: config, language_ref_code, cluster, placement."""
+    return api.get(f"/service-configs/by-code/{config_code}")
+
+
+def settings_diff(api: ApiClient, config_code: str) -> dict:
+    """{service_config_code, has_deployed_baseline, items: [{field, label, current_value, deployed_value}]}"""
+    return api.get(f"/service-configs/{config_code}/settings-diff")
+
+
+def language_version(api: ApiClient, code: str) -> dict:
+    """{code, name ('Go 1.24'), version ('1.24'), ...}"""
+    return api.get(f"/languages/language-versions/{code}")
+
+
+def language_versions_grouped(api: ApiClient) -> list[dict]:
+    """[{language_name, versions: [{code, name, version, ...}]}]"""
+    return api.get("/languages/language-versions/grouped").get("languages", [])
+
+
+def eks_language_templates(api: ApiClient) -> dict:
+    """{language label: template block} — the values a new service starts from."""
+    return api.get("/service-configs/eks/language-templates").get("languages", {})

devlift_cli/api/vpc.py

@@ -0,0 +1,24 @@
+"""Canvas placement context: which AWS account and cloud region a resource
+belongs to on the dashboard.
+
+    GET /vpc-discovery/fetch_vpc_and_resources?application_code=&environment=
+
+The dashboard's canvas is built from this response. Its `geoLocations`,
+`accounts` and `cloudRegions` are the three levels a resource node is nested
+in, and a resource whose locator does not name an account and a cloud region
+is skipped when the canvas is assembled. So every client that creates a
+resource has to resolve and store that context: the web does it in its create
+modal, the MCP in `_resolve_canvas_placement`, and this is the CLI's copy.
+"""
+
+from __future__ import annotations
+
+from devlift_cli.api.client import ApiClient
+
+
+def placement_context(api: ApiClient, application_code: str, environment: str) -> dict:
+    """{geoLocations, accounts, cloudRegions, ...} for one product and environment."""
+    return api.get(
+        "/vpc-discovery/fetch_vpc_and_resources",
+        {"application_code": application_code, "environment": environment},
+    )