@josephyan/qingflow-cli 0.2.0-beta.1000

package/src/qingflow_mcp/cli/main.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import Any, Callable, TextIO
+
+from ..errors import QingflowApiError
+from ..public_surface import cli_public_tool_spec_from_namespace
+from ..response_trim import resolve_cli_tool_name, trim_error_response, trim_public_response
+from .context import CliContext, build_cli_context
+from .formatters import emit_json_result, emit_text_result
+from .commands import register_all_commands
+
+
+Handler = Callable[[argparse.Namespace, CliContext], dict[str, Any]]
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="qingflow", description="Qingflow CLI")
+    parser.add_argument("--profile", default="default", help="会话 profile，默认 default")
+    parser.add_argument("--json", action="store_true", help="输出 JSON")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    register_all_commands(subparsers)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    raise SystemExit(run(argv))
+
+
+def run(
+    argv: list[str] | None = None,
+    *,
+    context_factory: Callable[[], CliContext] = build_cli_context,
+    stdout: TextIO | None = None,
+    stderr: TextIO | None = None,
+) -> int:
+    out = stdout or sys.stdout
+    err = stderr or sys.stderr
+    parser = build_parser()
+    normalized_argv = _normalize_global_args(list(argv) if argv is not None else sys.argv[1:])
+    try:
+        args = parser.parse_args(normalized_argv)
+    except SystemExit as exc:
+        return int(exc.code or 0)
+    setattr(args, "_stdin", sys.stdin)
+    setattr(args, "_stdout_stream", out)
+    setattr(args, "_stderr_stream", err)
+    handler = getattr(args, "handler", None)
+    if handler is None:
+        parser.print_help(out)
+        return 2
+    context = context_factory()
+    try:
+        if not bool(args.json):
+            _emit_cli_effective_context_notice(args, context, stream=err)
+        result = handler(args, context)
+    except RuntimeError as exc:
+        payload = trim_error_response(_parse_error_payload(exc))
+        return _emit_error(payload, json_mode=bool(args.json), stdout=out, stderr=err)
+    except QingflowApiError as exc:
+        payload = trim_error_response(exc.to_dict())
+        return _emit_error(payload, json_mode=bool(args.json), stdout=out, stderr=err)
+    finally:
+        context.close()
+
+    exit_code = _result_exit_code(result)
+    trimmed_result = trim_public_response(resolve_cli_tool_name(args), result) if isinstance(result, dict) else result
+    stream = out if bool(args.json) or exit_code == 0 else err
+    if bool(args.json):
+        emit_json_result(trimmed_result, stream=stream)
+    else:
+        emit_text_result(trimmed_result, hint=getattr(args, "format_hint", ""), stream=stream)
+    return exit_code
+
+
+def _normalize_global_args(argv: list[str]) -> list[str]:
+    global_args: list[str] = []
+    remaining: list[str] = []
+    index = 0
+    while index < len(argv):
+        token = argv[index]
+        if token == "--json":
+            global_args.append(token)
+            index += 1
+            continue
+        if token == "--profile":
+            global_args.append(token)
+            if index + 1 >= len(argv):
+                global_args.append("")
+                break
+            global_args.append(argv[index + 1])
+            index += 2
+            continue
+        if token.startswith("--profile="):
+            global_args.append(token)
+            index += 1
+            continue
+        remaining.append(token)
+        index += 1
+    return global_args + remaining
+
+
+def _parse_error_payload(exc: RuntimeError) -> dict[str, Any]:
+    raw = str(exc)
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError:
+        return {"category": "runtime", "message": raw}
+    return payload if isinstance(payload, dict) else {"category": "runtime", "message": raw}
+
+
+def _emit_error(payload: dict[str, Any], *, json_mode: bool, stdout: TextIO, stderr: TextIO) -> int:
+    exit_code = _error_exit_code(payload)
+    if json_mode:
+        emit_json_result(payload, stream=stdout)
+        return exit_code
+    lines = [
+        f"Category: {payload.get('category') or 'error'}",
+        f"Message: {payload.get('message') or 'Unknown error'}",
+    ]
+    if payload.get("backend_code") is not None:
+        lines.append(f"Backend Code: {payload.get('backend_code')}")
+    if payload.get("request_id"):
+        lines.append(f"Request ID: {payload.get('request_id')}")
+    details = payload.get("details")
+    if isinstance(details, dict):
+        for key, value in details.items():
+            if isinstance(value, (str, int, float, bool)) or value is None:
+                lines.append(f"{key}: {value}")
+    stderr.write("\n".join(lines) + "\n")
+    return exit_code
+
+
+def _error_exit_code(payload: dict[str, Any]) -> int:
+    category = str(payload.get("category") or "").lower()
+    if category in {"auth", "workspace"}:
+        return 3
+    return 4
+
+
+def _result_exit_code(result: dict[str, Any]) -> int:
+    if not isinstance(result, dict):
+        return 0
+    if result.get("ok") is False:
+        return 4
+    status = str(result.get("status") or "").lower()
+    if status in {"failed", "blocked"}:
+        return 4
+    return 0
+
+
+def _emit_cli_effective_context_notice(args: argparse.Namespace, context: CliContext, *, stream: TextIO) -> None:
+    spec = cli_public_tool_spec_from_namespace(args)
+    if spec is None or not spec.cli_show_effective_context:
+        return
+    hide_context_line = bool(getattr(args, "hide_effective_context_line", False))
+    sessions = getattr(context, "sessions", None)
+    if sessions is None or not hasattr(sessions, "get_profile"):
+        return
+    profile_name = str(getattr(args, "profile", "default") or "default")
+    try:
+        session_profile = sessions.get_profile(profile_name)
+    except Exception:
+        session_profile = None
+    workspace_id = getattr(session_profile, "selected_ws_id", None) if session_profile is not None else None
+    workspace_name = getattr(session_profile, "selected_ws_name", None) if session_profile is not None else None
+    if workspace_id is None:
+        workspace_label = "(not selected)"
+    elif workspace_name:
+        workspace_label = f"{workspace_name} ({workspace_id})"
+    else:
+        workspace_label = str(workspace_id)
+    lines: list[str] = []
+    if not hide_context_line:
+        lines.append(f"Context: profile={profile_name} workspace={workspace_label}")
+    if spec.cli_context_write and profile_name == "default":
+        lines.append("Warning: using default profile for a workspace-sensitive write command")
+    if not lines:
+        return
+    stream.write("\n".join(lines) + "\n")
+
+
+if __name__ == "__main__":
+    main()

package/src/qingflow_mcp/cli/qingflow_login.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass
+from typing import Any
+
+from Crypto.Cipher import PKCS1_v1_5
+from Crypto.PublicKey import RSA
+
+from ..backend_client import BackendClient
+from ..config import get_default_base_url, get_timeout_seconds, normalize_base_url
+from ..errors import QingflowApiError
+
+
+@dataclass(slots=True)
+class QingflowNativeLoginResult:
+    token: str
+    user_info: dict[str, Any]
+    login_token: str | None = None
+    flow: str = "qingflow_password"
+
+
+class QingflowNativeLoginHelper:
+    def __init__(self, *, backend: BackendClient | None = None) -> None:
+        self._owns_backend = backend is None
+        self._backend = backend or BackendClient(timeout=get_timeout_seconds())
+
+    def close(self) -> None:
+        if self._owns_backend:
+            self._backend.close()
+
+    def login_with_password(
+        self,
+        *,
+        base_url: str | None,
+        email: str,
+        password: str,
+    ) -> QingflowNativeLoginResult:
+        normalized_base_url = normalize_base_url(base_url) or get_default_base_url()
+        normalized_email = str(email or "").strip()
+        normalized_password = str(password or "")
+        if not normalized_base_url:
+            raise QingflowApiError.config_error("base_url is required or configure default_base_url")
+        if not normalized_email:
+            raise QingflowApiError.config_error("email is required for Qingflow account login")
+        if not normalized_password:
+            raise QingflowApiError.config_error("password is required for Qingflow account login")
+
+        pubkey_payload = self._backend.public_request("GET", normalized_base_url, "/user/pubkey", qf_version=None)
+        pubkey = self._extract_pubkey(pubkey_payload)
+        encrypted_password = _encrypt_password(normalized_password, pubkey)
+        login_payload = self._backend.public_request(
+            "POST",
+            normalized_base_url,
+            "/user/login",
+            json_body={"email": normalized_email, "password": encrypted_password},
+            qf_version=None,
+        )
+        if not isinstance(login_payload, dict):
+            raise QingflowApiError(category="auth", message="Qingflow login did not return a valid response")
+
+        token = str(login_payload.get("token") or "").strip()
+        login_token = str(login_payload.get("loginToken") or "").strip() or None
+        if not token:
+            if login_token:
+                raise QingflowApiError(
+                    category="auth",
+                    message=(
+                        "Qingflow account login requires additional security verification. "
+                        "CLI password login currently does not complete the loginToken verification step."
+                    ),
+                    details={"login_token_present": True},
+                )
+            raise QingflowApiError(
+                category="auth",
+                message="Qingflow login succeeded but did not return a token",
+            )
+
+        user_info = login_payload.get("userInfo")
+        if not isinstance(user_info, dict):
+            user_info = {}
+        return QingflowNativeLoginResult(
+            token=token,
+            login_token=login_token,
+            user_info=user_info,
+        )
+
+    def _extract_pubkey(self, payload: Any) -> str:
+        if not isinstance(payload, dict):
+            raise QingflowApiError(category="auth", message="Qingflow pubkey response is invalid")
+        pubkey = str(payload.get("pubkey") or "").strip()
+        if not pubkey:
+            raise QingflowApiError(category="auth", message="Qingflow pubkey response did not include pubkey")
+        return pubkey
+
+
+def login_with_qingflow_password(
+    *,
+    base_url: str | None,
+    email: str,
+    password: str,
+) -> QingflowNativeLoginResult:
+    helper = QingflowNativeLoginHelper()
+    try:
+        return helper.login_with_password(base_url=base_url, email=email, password=password)
+    finally:
+        helper.close()
+
+
+def _encrypt_password(password: str, pubkey: str) -> str:
+    public_key = RSA.import_key(
+        "-----BEGIN PUBLIC KEY-----\n" + pubkey.strip() + "\n-----END PUBLIC KEY-----\n"
+    )
+    cipher = PKCS1_v1_5.new(public_key)
+    encrypted = cipher.encrypt(password.encode("utf-8"))
+    return base64.b64encode(encrypted).decode("ascii")

package/src/qingflow_mcp/cli/terminal_ui.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import os
+import select
+import shutil
+from dataclasses import dataclass
+from typing import Generic, Sequence, TextIO, TypeVar
+
+try:
+    import termios
+    import tty
+except ImportError:  # pragma: no cover - non-POSIX fallback
+    termios = None
+    tty = None
+
+
+T = TypeVar("T")
+RAW_TTY_NEWLINE = "\r\n"
+
+
+@dataclass(slots=True)
+class SelectionOption(Generic[T]):
+    value: T
+    label: str
+    hint: str | None = None
+
+
+def select_option(
+    *,
+    title: str,
+    options: Sequence[SelectionOption[T]],
+    input_stream: TextIO,
+    output_stream: TextIO,
+    page_size: int = 8,
+) -> T | None:
+    if not options:
+        return None
+    if len(options) == 1:
+        return options[0].value
+    if not _supports_raw_selection(input_stream=input_stream, output_stream=output_stream):
+        return _select_option_via_prompt(title=title, options=options, input_stream=input_stream, output_stream=output_stream)
+    return _select_option_via_raw_terminal(
+        title=title,
+        options=options,
+        input_stream=input_stream,
+        output_stream=output_stream,
+        page_size=max(3, page_size),
+    )
+
+
+def _supports_raw_selection(*, input_stream: TextIO, output_stream: TextIO) -> bool:
+    if termios is None or tty is None:
+        return False
+    if not bool(getattr(input_stream, "isatty", lambda: False)()) or not bool(getattr(output_stream, "isatty", lambda: False)()):
+        return False
+    return hasattr(input_stream, "fileno")
+
+
+def _select_option_via_prompt(
+    *,
+    title: str,
+    options: Sequence[SelectionOption[T]],
+    input_stream: TextIO,
+    output_stream: TextIO,
+) -> T | None:
+    output_stream.write(title + "\n")
+    for index, option in enumerate(options, start=1):
+        suffix = f" ({option.hint})" if option.hint else ""
+        output_stream.write(f"{index}. {option.label}{suffix}\n")
+    output_stream.write("请输入编号并回车，留空取消: ")
+    output_stream.flush()
+    line = input_stream.readline()
+    selected = str(line or "").strip()
+    if not selected:
+        return None
+    if not selected.isdigit():
+        return None
+    index = int(selected) - 1
+    if index < 0 or index >= len(options):
+        return None
+    return options[index].value
+
+
+def _select_option_via_raw_terminal(
+    *,
+    title: str,
+    options: Sequence[SelectionOption[T]],
+    input_stream: TextIO,
+    output_stream: TextIO,
+    page_size: int,
+) -> T | None:
+    fd = input_stream.fileno()
+    original_mode = termios.tcgetattr(fd)
+    selected_index = 0
+    output_stream.write("\x1b[?1049h\x1b[?25l")
+    output_stream.flush()
+    try:
+        tty.setraw(fd)
+        while True:
+            _render_options(
+                title=title,
+                options=options,
+                selected_index=selected_index,
+                output_stream=output_stream,
+                page_size=page_size,
+            )
+            key = _read_key(input_stream)
+            if key in ("\r", "\n"):
+                return options[selected_index].value
+            if key in ("\x03", "\x1b", "q", "Q"):
+                return None
+            if key in ("\x1b[A", "k", "K"):
+                selected_index = (selected_index - 1) % len(options)
+                continue
+            if key in ("\x1b[B", "j", "J"):
+                selected_index = (selected_index + 1) % len(options)
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, original_mode)
+        output_stream.write("\x1b[?25h\x1b[?1049l")
+        output_stream.flush()
+
+
+def _render_options(
+    *,
+    title: str,
+    options: Sequence[SelectionOption[object]],
+    selected_index: int,
+    output_stream: TextIO,
+    page_size: int,
+) -> None:
+    terminal_width = shutil.get_terminal_size((100, 20)).columns
+    total = len(options)
+    page_start = max(0, min(selected_index - page_size // 2, max(total - page_size, 0)))
+    visible = options[page_start: page_start + page_size]
+    lines = [
+        title,
+        "↑/↓ 或 j/k 选择，Enter 确认，q / Esc 取消",
+        "",
+    ]
+    for offset, option in enumerate(visible, start=page_start):
+        marker = ">" if offset == selected_index else " "
+        suffix = f"  [{option.hint}]" if option.hint else ""
+        lines.append(_truncate_line(f"{marker} {option.label}{suffix}", width=terminal_width))
+    if total > page_size:
+        lines.append("")
+        lines.append(f"{selected_index + 1}/{total}")
+    output_stream.write("\x1b[2J\x1b[H")
+    output_stream.write(RAW_TTY_NEWLINE.join(lines))
+    output_stream.flush()
+
+
+def _truncate_line(text: str, *, width: int) -> str:
+    if width <= 0 or len(text) <= width:
+        return text
+    if width <= 1:
+        return text[:width]
+    return text[: width - 1] + "…"
+
+
+def _read_key(input_stream: TextIO) -> str:
+    first = input_stream.read(1)
+    if first != "\x1b":
+        return first
+    chunks = [first]
+    fd = input_stream.fileno()
+    while select.select([fd], [], [], 0.02)[0]:
+        chunk = os.read(fd, 1).decode("utf-8", errors="ignore")
+        if not chunk:
+            break
+        chunks.append(chunk)
+        if len(chunks) >= 3:
+            break
+    return "".join(chunks)