makea-cli 0.1.1__py3-none-any.whl

makea_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

makea_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Allow ``python -m makea_cli`` (used by the optional npm wrapper)."""
+
+from makea_cli.main import app
+
+if __name__ == "__main__":
+    app()

makea_cli/api_client.py

@@ -0,0 +1,376 @@
+from __future__ import annotations
+
+import json
+from pathlib import PurePosixPath
+from typing import Any
+from urllib.parse import unquote
+
+import httpx
+
+from makea_cli.config import api_base_url
+from makea_cli.auth_pkce import ensure_fresh_id_token
+
+
+def _headers() -> dict[str, str]:
+    token = ensure_fresh_id_token()
+    return {"Authorization": f"Bearer {token}", "Accept": "application/json"}
+
+
+def _filename_from_content_disposition(header: str | None) -> str | None:
+    """Best-effort parse of ``Content-Disposition`` filename / filename*."""
+    if not header:
+        return None
+    for part in header.split(";"):
+        part = part.strip()
+        low = part.lower()
+        if low.startswith("filename*="):
+            _, _, value = part.partition("=")
+            value = value.strip().strip('"')
+            if value.lower().startswith("utf-8''"):
+                value = value[7:]
+            return unquote(value)
+        if low.startswith("filename="):
+            _, _, value = part.partition("=")
+            return value.strip().strip('"')
+    return None
+
+
+def get_json(
+    path: str, *, params: dict[str, Any] | None = None, timeout: float = 60.0
+) -> Any:
+    url = f"{api_base_url()}{path}"
+    with httpx.Client(timeout=timeout) as client:
+        r = client.get(url, headers=_headers(), params=params)
+    if r.status_code >= 400:
+        try:
+            detail = r.json()
+        except json.JSONDecodeError:
+            detail = r.text
+        raise RuntimeError(f"HTTP {r.status_code}: {detail}")
+    return r.json()
+
+
+def post_json(path: str, body: Any, *, timeout: float = 60.0) -> Any:
+    url = f"{api_base_url()}{path}"
+    headers = {**_headers(), "Content-Type": "application/json"}
+    with httpx.Client(timeout=timeout) as client:
+        r = client.post(url, headers=headers, json=body)
+    if r.status_code >= 400:
+        try:
+            detail = r.json()
+        except json.JSONDecodeError:
+            detail = r.text
+        raise RuntimeError(f"HTTP {r.status_code}: {detail}")
+    return r.json()
+
+
+def send_admin_raw_email(body: dict[str, Any]) -> Any:
+    """
+    POST /admin/email/send — queue HTML email (from must be @makea.co).
+
+    Body keys: ``from`` (or ``from_email``), ``to`` (non-empty list), ``subject`` (or ``title``),
+    ``html`` (or ``html_body``); optional ``cc`` (list; duplicates of ``to`` are dropped server-side);
+    optional ``text`` (plain MIME alternative).
+    """
+    return post_json("/admin/email/send", body)
+
+
+def post_multipart_simple(
+    path: str, form_fields: dict[str, str], *, timeout: float = 120.0
+) -> Any:
+    """
+    POST multipart/form-data with text-only parts (value sent as a part without filename).
+    """
+    url = f"{api_base_url()}{path}"
+    headers = _headers()
+    files = {key: (None, value) for key, value in form_fields.items()}
+    with httpx.Client(timeout=timeout) as client:
+        r = client.post(url, headers=headers, files=files)
+    if r.status_code >= 400:
+        try:
+            detail = r.json()
+        except json.JSONDecodeError:
+            detail = r.text
+        raise RuntimeError(f"HTTP {r.status_code}: {detail}")
+    return r.json()
+
+
+def get_all_users(*, limit: int | None, offset: int) -> Any:
+    params: dict[str, Any] = {"offset": offset}
+    if limit is not None:
+        params["limit"] = limit
+    return get_json("/admin/users", params=params)
+
+
+def get_all_suppliers() -> Any:
+    return get_json("/admin/supplier/get_all_suppliers")
+
+
+def add_supplier(body: dict[str, Any]) -> Any:
+    """POST /admin/supplier/add_supplier — body must be {\"supplier\": {...}}."""
+    return post_json("/admin/supplier/add_supplier", body)
+
+
+def backfill_supplier_id_with_quote_requests(
+    *,
+    user_id: str,
+    old_supplier_id: str,
+    dry_run: bool = True,
+    skip_s3_documents: bool = False,
+    skip_quote_request_backfill: bool = False,
+    quote_request_only: bool = False,
+    delete_old_supplier_at_end: bool = False,
+    confirm_delete_old_supplier: bool = False,
+) -> Any:
+    """POST /admin/supplier/backfill_supplier_id_with_quote_requests."""
+    body = {
+        "user_id": user_id,
+        "old_supplier_id": old_supplier_id,
+        "dry_run": dry_run,
+        "skip_s3_documents": skip_s3_documents,
+        "skip_quote_request_backfill": skip_quote_request_backfill,
+        "quote_request_only": quote_request_only,
+        "delete_old_supplier_at_end": delete_old_supplier_at_end,
+        "confirm_delete_old_supplier": confirm_delete_old_supplier,
+    }
+    return post_json("/admin/supplier/backfill_supplier_id_with_quote_requests", body)
+
+
+def get_all_product_orders(
+    *,
+    limit: int | None,
+    offset: int,
+    user_id: str | None,
+    searchby: str | None,
+) -> Any:
+    params: dict[str, Any] = {"offset": offset}
+    if limit is not None:
+        params["limit"] = limit
+    if user_id is not None:
+        params["user_id"] = user_id
+    if searchby is not None:
+        params["searchby"] = searchby
+    return get_json("/admin/designer/get_all_product_orders", params=params)
+
+
+def get_product_orders_by_user(designer_user_id: str) -> Any:
+    """GET /admin/designer/get_all_product_orders/{user_id}/orders — one designer's products."""
+    return get_json(f"/admin/designer/get_all_product_orders/{designer_user_id}/orders")
+
+
+def get_quote_requests(*, product_id: str | None = None) -> Any:
+    """
+    GET /admin/quote_requests — admin quote requests list (optionally filtered by product_id).
+    """
+    params: dict[str, Any] | None = None
+    if product_id is not None:
+        params = {"product_id": product_id}
+    return get_json("/admin/quote_requests", params=params)
+
+
+def get_quote_requests_by_supplier_id(
+    *,
+    supplier_id: str,
+    status: str | None = None,
+    limit: int | None = None,
+) -> Any:
+    """
+    GET /admin/quote_requests/supplier/{supplier_id} — direct supplier filter on backend.
+    """
+    params: dict[str, Any] = {}
+    if status is not None:
+        params["status"] = status
+    if limit is not None:
+        params["limit"] = limit
+    return get_json(
+        f"/admin/quote_requests/supplier/{supplier_id}",
+        params=params or None,
+    )
+
+
+def get_linked_suppliers_for_product(
+    *,
+    product_id: str,
+    link_type: str | None = None,
+) -> Any:
+    """
+    GET /admin/product/linked_suppliers — requires product_id, optional link_type.
+    """
+    params: dict[str, Any] = {"product_id": product_id}
+    if link_type is not None:
+        params["link_type"] = link_type
+    return get_json("/admin/product/linked_suppliers", params=params)
+
+
+def get_supplier_links_by_supplier_id(
+    *,
+    supplier_id: str,
+    link_type: str | None = None,
+) -> Any:
+    """
+    GET /admin/product/linked_suppliers/by_supplier/{supplier_id} — direct supplier filter.
+    """
+    params: dict[str, Any] | None = None
+    if link_type is not None:
+        params = {"link_type": link_type}
+    return get_json(
+        f"/admin/product/linked_suppliers/by_supplier/{supplier_id}",
+        params=params,
+    )
+
+
+def effective_user_id_for_document_download(
+    product_row: dict[str, Any], document_entry: dict[str, Any]
+) -> str:
+    """
+    ``user_id`` query param for GET /admin/document/download — same rule as server
+    ``download_all_product_documents`` (prefer ``admin_user_id`` when present).
+    """
+    owner = (product_row.get("user_id") or "").strip()
+    admin_uid = (document_entry.get("admin_user_id") or "").strip()
+    if admin_uid:
+        return admin_uid
+    return owner
+
+
+def get_all_sampling_orders(
+    *,
+    limit: int | None,
+    offset: int,
+    include_document_metadata: bool | None = None,
+) -> Any:
+    """GET /admin/sampling_orders/get_all — admin global sampling order list."""
+    params: dict[str, Any] = {"offset": offset}
+    if limit is not None:
+        params["limit"] = limit
+    if include_document_metadata is not None:
+        params["include_document_metadata"] = (
+            "true" if include_document_metadata else "false"
+        )
+    return get_json("/admin/sampling_orders/get_all", params=params)
+
+
+def get_all_production_orders(
+    *,
+    limit: int | None,
+    offset: int,
+    order_type: str | None,
+) -> Any:
+    """
+    GET /admin/production_orders — admin global production order list.
+    ``order_type`` is PRODUCTION, RESTOCK, or None for all (per server behavior).
+    """
+    params: dict[str, Any] = {"offset": offset}
+    if limit is not None:
+        params["limit"] = limit
+    if order_type:
+        params["type"] = order_type
+    return get_json("/admin/production_orders", params=params)
+
+
+def get_sampling_orders_by_product(product_reference_id: str) -> Any:
+    return get_json(f"/admin/products/{product_reference_id}/sampling_orders")
+
+
+def get_production_orders_by_product(
+    product_reference_id: str,
+    *,
+    limit: int | None,
+    offset: int,
+) -> Any:
+    params: dict[str, Any] = {"offset": offset}
+    if limit is not None:
+        params["limit"] = limit
+    return get_json(
+        f"/admin/products/{product_reference_id}/production_orders",
+        params=params,
+    )
+
+
+def get_cumulative_payment_and_platform_revenue(
+    *,
+    start_date: str,
+    end_date: str,
+    granularity: str | None = None,
+    currency: str | None = None,
+    order_type: str | None = None,
+) -> Any:
+    """
+    GET /admin/business-metrics/cumulative-payment-and-platform-revenue —
+    platform-wide cumulative payment received and platform revenue (service fee +
+    transaction fee) within a date range, bucketed by day/week/month.
+    """
+    params: dict[str, Any] = {"start_date": start_date, "end_date": end_date}
+    if granularity is not None:
+        params["granularity"] = granularity
+    if currency is not None:
+        params["currency"] = currency
+    if order_type is not None:
+        params["order_type"] = order_type
+    return get_json(
+        "/admin/business-metrics/cumulative-payment-and-platform-revenue",
+        params=params,
+    )
+
+
+def extract_ai_tech_specifications(
+    product_reference_id: str, *, timeout: float = 300.0
+) -> Any:
+    """
+    GET /admin/products/{id}/extract-tech-specifications — synchronous AI extraction;
+    allow a longer client timeout than normal GETs.
+    """
+    return get_json(
+        f"/admin/products/{product_reference_id}/extract-tech-specifications",
+        timeout=timeout,
+    )
+
+
+def download_admin_document(
+    *,
+    user_id: str,
+    document_id: str,
+    timeout: float = 120.0,
+) -> tuple[bytes, str | None]:
+    """
+    GET /admin/document/download — binary file or redirect to presigned URL.
+
+    The server requires ``user_id`` (document owner context) and ``document_id``.
+    Returns ``(body_bytes, suggested_filename_or_none)`` from the final response.
+    """
+    url = f"{api_base_url()}/admin/document/download"
+    token = ensure_fresh_id_token()
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "*/*",
+    }
+    params = {"user_id": user_id, "document_id": document_id}
+    with httpx.Client(timeout=timeout, follow_redirects=True) as client:
+        r = client.get(url, headers=headers, params=params)
+    if r.status_code >= 400:
+        try:
+            detail = r.json()
+        except json.JSONDecodeError:
+            detail = r.text
+        raise RuntimeError(f"HTTP {r.status_code}: {detail}")
+    name = _filename_from_content_disposition(r.headers.get("content-disposition"))
+    if name:
+        name = PurePosixPath(name).name or None
+    return r.content, name
+
+
+def update_product_technical_specifications(
+    product_id: str,
+    technical_specifications: list[dict[str, Any]],
+    *,
+    timeout: float = 120.0,
+) -> Any:
+    """
+    POST /admin/products/{id}/technical-specifications — multipart field
+    ``technical_specifications`` (JSON array) persists specs on the product.
+    """
+    return post_multipart_simple(
+        f"/admin/products/{product_id}/technical-specifications",
+        {"technical_specifications": json.dumps(technical_specifications)},
+        timeout=timeout,
+    )

makea_cli/auth_pkce.py

@@ -0,0 +1,251 @@
+"""
+Cognito Hosted UI login via OAuth 2.0 Authorization Code + PKCE (public client).
+
+The Makea API validates Bearer tokens as Cognito JWTs with audience = app client id,
+which matches Cognito ID tokens — store and send id_token to the API.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import secrets
+import threading
+import time
+import urllib.parse
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+import httpx
+
+from makea_cli.config import (
+    cognito_client_id,
+    cognito_domain_host,
+    load_credentials,
+    redirect_uri,
+    save_credentials,
+)
+
+
+def _b64url(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+
+
+def _pkce_pair() -> tuple[str, str]:
+    verifier = secrets.token_urlsafe(48)
+    challenge = _b64url(hashlib.sha256(verifier.encode("ascii")).digest())
+    return verifier, challenge
+
+
+def _parse_query(path: str) -> dict[str, str]:
+    q = urllib.parse.urlparse(path).query
+    return dict(urllib.parse.parse_qsl(q))
+
+
+def _token_url(domain_host: str) -> str:
+    return f"https://{domain_host}/oauth2/token"
+
+
+def _post_token(domain_host: str, body: dict) -> dict:
+    with httpx.Client(timeout=30.0) as client:
+        r = client.post(
+            _token_url(domain_host),
+            data=body,
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+        )
+    if r.status_code >= 400:
+        try:
+            err = r.json()
+        except json.JSONDecodeError:
+            err = r.text
+        raise RuntimeError(f"Cognito token endpoint error ({r.status_code}): {err}")
+    return r.json()
+
+
+def exchange_code_for_tokens(
+    *,
+    domain_host: str,
+    client_id: str,
+    code: str,
+    redirect_uri_value: str,
+    code_verifier: str,
+) -> dict:
+    body = {
+        "grant_type": "authorization_code",
+        "client_id": client_id,
+        "code": code,
+        "redirect_uri": redirect_uri_value,
+        "code_verifier": code_verifier,
+    }
+    return _post_token(domain_host, body)
+
+
+def refresh_tokens(
+    *,
+    domain_host: str,
+    client_id: str,
+    refresh_token: str,
+) -> dict:
+    body = {
+        "grant_type": "refresh_token",
+        "client_id": client_id,
+        "refresh_token": refresh_token,
+    }
+    return _post_token(domain_host, body)
+
+
+def run_browser_login() -> dict:
+    """
+    Open system browser to Cognito Hosted UI; receive authorization code on localhost.
+
+    Returns token JSON from Cognito (includes id_token, refresh_token, expires_in, ...).
+    """
+    domain_host = cognito_domain_host()
+    client_id = cognito_client_id()
+    redirect_uri_value = redirect_uri()
+    verifier, challenge = _pkce_pair()
+
+    auth_params = {
+        "response_type": "code",
+        "client_id": client_id,
+        "redirect_uri": redirect_uri_value,
+        "scope": "openid email profile",
+        "code_challenge_method": "S256",
+        "code_challenge": challenge,
+    }
+    auth_url = (
+        f"https://{domain_host}/oauth2/authorize?{urllib.parse.urlencode(auth_params)}"
+    )
+
+    code_holder: dict[str, str | None] = {"code": None, "error": None}
+    done = threading.Event()
+
+    class Handler(BaseHTTPRequestHandler):
+        def log_message(self, _format: str, *_args: object) -> None:
+            return
+
+        def do_GET(self) -> None:  # noqa: N802
+            params = _parse_query(self.path)
+            if "code" in params:
+                code_holder["code"] = params["code"]
+                self.send_response(200)
+                self.send_header("Content-Type", "text/html; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(
+                    b"<html><body><p>Login successful. You can close this tab.</p></body></html>"
+                )
+            else:
+                err = (
+                    params.get("error_description")
+                    or params.get("error")
+                    or "unknown_error"
+                )
+                code_holder["error"] = err
+                self.send_response(400)
+                self.send_header("Content-Type", "text/html; charset=utf-8")
+                self.end_headers()
+                msg = urllib.parse.quote(str(err), safe="")
+                self.wfile.write(
+                    f"<html><body><p>Login failed: {msg}</p></body></html>".encode(
+                        "utf-8"
+                    )
+                )
+            done.set()
+
+    parsed = urllib.parse.urlparse(redirect_uri_value)
+    if parsed.hostname not in ("127.0.0.1", "localhost"):
+        raise RuntimeError(
+            "Login callback must use 127.0.0.1 or localhost. Use the built-in default; no extra setup."
+        )
+    port = parsed.port
+    if not port:
+        raise RuntimeError(
+            "Login callback URL must include a port (the default already does)."
+        )
+
+    bind_host = parsed.hostname or "127.0.0.1"
+    if bind_host == "localhost":
+        bind_host = "127.0.0.1"
+
+    server = HTTPServer((bind_host, port), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+
+    webbrowser.open(auth_url)
+
+    if not done.wait(timeout=300):
+        server.shutdown()
+        raise TimeoutError("No OAuth callback received within 5 minutes.")
+
+    server.shutdown()
+
+    if code_holder["error"]:
+        raise RuntimeError(f"Cognito error: {code_holder['error']}")
+    code = code_holder["code"]
+    if not code:
+        raise RuntimeError("No authorization code in callback.")
+
+    tokens = exchange_code_for_tokens(
+        domain_host=domain_host,
+        client_id=client_id,
+        code=code,
+        redirect_uri_value=redirect_uri_value,
+        code_verifier=verifier,
+    )
+    if "id_token" not in tokens:
+        raise RuntimeError("Cognito token response missing id_token.")
+    return tokens
+
+
+def persist_tokens(tokens: dict) -> None:
+    expires_in = int(tokens.get("expires_in") or 0)
+    saved_at = time.time()
+    save_credentials(
+        {
+            "id_token": tokens["id_token"],
+            "refresh_token": tokens.get("refresh_token"),
+            "expires_in": expires_in,
+            "saved_at": saved_at,
+        }
+    )
+
+
+def ensure_fresh_id_token() -> str:
+    """
+    Return a usable id_token, refreshing with refresh_token when close to expiry if possible.
+    """
+    creds = load_credentials()
+    if not creds or not creds.get("id_token"):
+        raise RuntimeError("尚未登录。请先执行：makea-cli auth")
+
+    expires_in = int(creds.get("expires_in") or 0)
+    saved_at = float(creds.get("saved_at") or 0)
+    if expires_in <= 0:
+        return creds["id_token"]
+
+    remaining = saved_at + expires_in - time.time()
+    refresh_token = creds.get("refresh_token")
+    if remaining > 120 or not refresh_token:
+        return creds["id_token"]
+
+    domain_host = cognito_domain_host()
+    client_id = cognito_client_id()
+    new_tokens = refresh_tokens(
+        domain_host=domain_host,
+        client_id=client_id,
+        refresh_token=refresh_token,
+    )
+    merged = {
+        "id_token": new_tokens.get("id_token") or creds["id_token"],
+        "refresh_token": new_tokens.get("refresh_token") or refresh_token,
+        "expires_in": int(new_tokens.get("expires_in") or expires_in),
+        "saved_at": time.time(),
+    }
+    save_credentials(merged)
+    return merged["id_token"]
+
+
+def login_and_save() -> None:
+    tokens = run_browser_login()
+    persist_tokens(tokens)

makea_cli/commands/__init__.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import typer
+
+from makea_cli.commands.auth.cmd import register as register_auth
+from makea_cli.commands.directory.cmd import register as register_directory
+from makea_cli.commands.document.cmd import register as register_document
+from makea_cli.commands.email.cmd import register as register_email
+from makea_cli.commands.metrics.cmd import register as register_metrics
+from makea_cli.commands.orders.cmd import register as register_orders
+from makea_cli.commands.product.cmd import register as register_product
+from makea_cli.commands.supplier.cmd import register as register_supplier
+
+
+def register_all(app: typer.Typer) -> None:
+    register_auth(app)
+    register_directory(app)
+    register_document(app)
+    register_supplier(app)
+    register_orders(app)
+    register_product(app)
+    register_metrics(app)
+    register_email(app)

makea_cli/commands/_util.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+import typer
+from rich.console import Console
+
+
+def print_json_or_exit(console: Console, fetch: Callable[[], Any]) -> None:
+    try:
+        data = fetch()
+    except Exception as e:
+        console.print(f"[red]{e}[/red]")
+        raise typer.Exit(1) from e
+    console.print_json(data=data)

makea_cli/commands/auth/__init__.py

@@ -0,0 +1,3 @@
+from makea_cli.commands.auth.cmd import register
+
+__all__ = ["register"]