@qingflow-tech/qingflow-app-builder-mcp 1.0.2 → 1.0.4

package/src/qingflow_mcp/cli/main.py

@@ -44,6 +44,9 @@ def run(
         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)
@@ -53,6 +56,8 @@ def run(
         if not bool(args.json):
             _emit_cli_effective_context_notice(args, context, stream=err)
         result = handler(args, context)
+    except SystemExit as exc:
+        return int(exc.code or 0)
     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)
@@ -152,6 +157,7 @@ def _emit_cli_effective_context_notice(args: argparse.Namespace, context: CliCon
     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
@@ -168,9 +174,13 @@ def _emit_cli_effective_context_notice(args: argparse.Namespace, context: CliCon
         workspace_label = f"{workspace_name} ({workspace_id})"
     else:
         workspace_label = str(workspace_id)
-    lines = [f"Context: profile={profile_name} workspace={workspace_label}"]
+    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")
 
 

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,218 @@
+from __future__ import annotations
+
+import os
+import select
+import shutil
+import textwrap
+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"
+# Give terminal escape sequences a slightly roomier window so arrow keys
+# still parse correctly when an outer Node/npm launcher adds a bit of PTY lag.
+ESCAPE_SEQUENCE_TIMEOUT_SECONDS = 0.2
+ESCAPE_SEQUENCE_FOLLOWUP_TIMEOUT_SECONDS = 0.02
+
+
+@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 = _render_multiline_text(title, width=terminal_width)
+    lines.extend(
+        [
+            "↑/↓ 或 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 _render_multiline_text(text: str, *, width: int) -> list[str]:
+    parts = text.splitlines() or [text]
+    rendered: list[str] = []
+    wrap_width = max(1, width)
+    for part in parts:
+        if not part:
+            rendered.append("")
+            continue
+        initial_indent = ""
+        subsequent_indent = ""
+        stripped = part.lstrip()
+        if stripped.startswith("- "):
+            leading_spaces = len(part) - len(stripped)
+            initial_indent = part[:leading_spaces] + "- "
+            subsequent_indent = part[:leading_spaces] + "  "
+            content = stripped[2:]
+        else:
+            content = part
+        wrapped = textwrap.wrap(
+            content,
+            width=wrap_width,
+            initial_indent=initial_indent,
+            subsequent_indent=subsequent_indent,
+            replace_whitespace=False,
+            drop_whitespace=False,
+            break_long_words=True,
+        )
+        rendered.extend(wrapped or [""])
+    return rendered
+
+
+def _read_key(input_stream: TextIO) -> str:
+    fd = input_stream.fileno()
+    first_bytes = os.read(fd, 1)
+    if not first_bytes:
+        return ""
+    first = first_bytes.decode("utf-8", errors="ignore")
+    if first != "\x1b":
+        return first
+    chunks = [first]
+    if not select.select([fd], [], [], ESCAPE_SEQUENCE_TIMEOUT_SECONDS)[0]:
+        return first
+    while True:
+        chunk = os.read(fd, 1).decode("utf-8", errors="ignore")
+        if not chunk:
+            break
+        chunks.append(chunk)
+        if len(chunks) >= 3:
+            break
+        if not select.select([fd], [], [], ESCAPE_SEQUENCE_FOLLOWUP_TIMEOUT_SECONDS)[0]:
+            break
+    return "".join(chunks)

package/src/qingflow_mcp/config.py

@@ -22,7 +22,7 @@ DEFAULT_REPOSITORY_AUTHOR_NAME = "qingflow-mcp"
 DEFAULT_REPOSITORY_AUTHOR_EMAIL = "qingflow-mcp@local.invalid"
 DEFAULT_REPOSITORY_INTERNAL_SHARE_TOKEN_KEY = "tokenKey"
 DEFAULT_CREDIT_USAGE_RECORD_PATH = "/user/credit/usage"
-DEFAULT_MCPORTER_CONFIG_PATH = "/root/.openclaw/workspace/config/mcporter.json"
+DEFAULT_MCPORTER_CONFIG_PATH = "~/.openclaw/workspace/config/mcporter.json"
 
 
 def get_mcp_home() -> Path:

package/src/qingflow_mcp/errors.py

@@ -43,19 +43,19 @@ class QingflowApiError(Exception):
     def auth_required(cls, profile: str) -> "QingflowApiError":
         return cls(
             category="auth",
-            message=f"Profile '{profile}' is not logged in. Run auth_use_credential first.",
+            message=f"Profile '{profile}' is not logged in. Run auth login or auth_use_credential first.",
         )
 
     @classmethod
     def workspace_not_selected(cls, profile: str) -> "QingflowApiError":
         return cls(
             category="workspace",
-            message=f"WORKSPACE_NOT_SELECTED: profile '{profile}' has no workspace from auth context. Re-run auth_use_credential.",
+            message=f"WORKSPACE_NOT_SELECTED: profile '{profile}' has no workspace from auth context. Re-run auth login or auth_use_credential.",
         )
 
     @classmethod
-    def config_error(cls, message: str) -> "QingflowApiError":
-        return cls(category="config", message=message)
+    def config_error(cls, message: str, *, details: JSONObject | None = None) -> "QingflowApiError":
+        return cls(category="config", message=message, details=details)
 
     @classmethod
     def not_supported(cls, message: str) -> "QingflowApiError":

package/src/qingflow_mcp/export_store.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from datetime import timedelta
+from pathlib import Path
+
+from .import_store import _JsonEntryStore, _store_dir
+
+
+class ExportJobStore(_JsonEntryStore):
+    def __init__(self, base_dir: Path | None = None, *, ttl_seconds: int = 24 * 3600) -> None:
+        super().__init__(
+            base_dir=base_dir or _store_dir("QINGFLOW_MCP_EXPORT_JOB_HOME", "export-jobs"),
+            ttl=timedelta(seconds=ttl_seconds),
+        )

package/src/qingflow_mcp/id_utils.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .errors import QingflowApiError
+
+
+JS_MAX_SAFE_INTEGER = 9_007_199_254_740_991
+
+
+def stringify_backend_id(value: Any) -> str | None:
+    """Return an exact public id string for backend-originated identifiers."""
+    if value in (None, ""):
+        return None
+    if isinstance(value, bool):
+        return None
+    text = str(value).strip()
+    return text or None
+
+
+def normalize_positive_id_text(value: Any, *, field_name: str) -> str:
+    """Normalize a user-supplied id while rejecting JS-unsafe numeric input."""
+    if value in (None, "") or isinstance(value, bool):
+        raise QingflowApiError.config_error(f"{field_name} must be positive")
+    if isinstance(value, int):
+        if value <= 0:
+            raise QingflowApiError.config_error(f"{field_name} must be positive")
+        if value > JS_MAX_SAFE_INTEGER:
+            raise QingflowApiError.config_error(
+                f"{field_name} exceeds JavaScript's safe integer range; pass it as a string to avoid precision loss"
+            )
+        return str(value)
+    if isinstance(value, str):
+        text = value.strip()
+        if not text.isdecimal() or int(text) <= 0:
+            raise QingflowApiError.config_error(f"{field_name} must be a positive integer string")
+        return text
+    raise QingflowApiError.config_error(f"{field_name} must be a positive integer string")
+
+
+def normalize_positive_id_int(value: Any, *, field_name: str) -> int:
+    """Normalize an id to Python int after the public boundary preserves it as text."""
+    return int(normalize_positive_id_text(value, field_name=field_name))
+
+
+def ids_equal(left: Any, right: Any) -> bool:
+    left_text = stringify_backend_id(left)
+    right_text = stringify_backend_id(right)
+    return left_text is not None and right_text is not None and left_text == right_text

package/src/qingflow_mcp/public_surface.py

@@ -30,10 +30,13 @@ def tool_key(domain: str, tool_name: str) -> str:
 
 
 USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
+    PublicToolSpec(USER_DOMAIN, "auth_login", cli_route=("auth", "login"), mcp_public=False),
     PublicToolSpec(USER_DOMAIN, "auth_use_credential", ("auth_use_credential",), ("auth", "use-credential")),
     PublicToolSpec(USER_DOMAIN, "auth_whoami", ("auth_whoami",), ("auth", "whoami")),
     PublicToolSpec(USER_DOMAIN, "auth_logout", ("auth_logout",), ("auth", "logout")),
     PublicToolSpec(USER_DOMAIN, "workspace_list", ("workspace_list",), ("workspace", "list")),
+    PublicToolSpec(USER_DOMAIN, "workspace_get", ("workspace_get",), ("workspace", "get")),
+    PublicToolSpec(USER_DOMAIN, "workspace_select", ("workspace_select",), ("workspace", "select")),
     PublicToolSpec(USER_DOMAIN, "app_list", ("app_list",), ("app", "list"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "app_search", ("app_search",), ("app", "search"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "app_get", ("app_get",), ("app", "get"), cli_show_effective_context=True),
@@ -88,11 +91,21 @@ USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(USER_DOMAIN, "record_import_repair_local", ("record_import_repair_local",), ("import", "repair")),
     PublicToolSpec(USER_DOMAIN, "record_import_start", ("record_import_start",), ("import", "start")),
     PublicToolSpec(USER_DOMAIN, "record_import_status_get", ("record_import_status_get",), ("import", "status")),
+    PublicToolSpec(USER_DOMAIN, "record_export_start", ("record_export_start",), ("export", "start"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_export_status_get", ("record_export_status_get",), ("export", "status"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_export_get", ("record_export_get",), ("export", "get"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_export_direct", ("record_export_direct",), ("export", "direct"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_code_block_run", ("record_code_block_run",), ("record", "code-block-run"), cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(USER_DOMAIN, "task_list", ("task_list",), ("task", "list"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "task_get", ("task_get",), ("task", "get"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "task_action_execute", ("task_action_execute",), ("task", "action"), cli_show_effective_context=True, cli_context_write=True),
-    PublicToolSpec(USER_DOMAIN, "task_associated_report_detail_get", ("task_associated_report_detail_get",), cli_public=False, cli_show_effective_context=True),
+    PublicToolSpec(
+        USER_DOMAIN,
+        "task_associated_report_detail_get",
+        ("task_associated_report_detail_get",),
+        ("task", "report"),
+        cli_show_effective_context=True,
+    ),
     PublicToolSpec(USER_DOMAIN, "task_workflow_log_get", ("task_workflow_log_get",), ("task", "log"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "directory_search", ("directory_search",), cli_public=False),
     PublicToolSpec(USER_DOMAIN, "directory_list_internal_users", ("directory_list_internal_users",), cli_public=False),
@@ -109,6 +122,7 @@ BUILDER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(BUILDER_DOMAIN, "auth_whoami", ("auth_whoami",), ("builder", "auth", "whoami"), cli_public=False),
     PublicToolSpec(BUILDER_DOMAIN, "auth_logout", ("auth_logout",), ("builder", "auth", "logout"), cli_public=False),
     PublicToolSpec(BUILDER_DOMAIN, "workspace_list", ("workspace_list",), ("builder", "workspace", "list"), cli_public=False),
+    PublicToolSpec(BUILDER_DOMAIN, "workspace_get", ("workspace_get",), ("builder", "workspace", "get"), cli_public=False),
     PublicToolSpec(BUILDER_DOMAIN, "file_upload_local", ("file_upload_local",), ("builder", "file", "upload-local"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "feedback_submit", ("feedback_submit",), ("builder", "feedback", "submit"), has_contract=True),
     PublicToolSpec(BUILDER_DOMAIN, "builder_tool_contract", ("builder_tool_contract",), ("builder", "contract"), has_contract=False),
@@ -120,6 +134,7 @@ BUILDER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(BUILDER_DOMAIN, "role_create", ("role_create",), ("builder", "role", "create"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_release_edit_lock_if_mine", ("app_release_edit_lock_if_mine",), ("builder", "app", "release-edit-lock-if-mine"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_resolve", ("app_resolve",), ("builder", "app", "resolve"), has_contract=True, cli_show_effective_context=True),
+    PublicToolSpec(BUILDER_DOMAIN, "button_style_catalog_get", ("button_style_catalog_get",), ("builder", "button", "catalog"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_custom_button_list", ("app_custom_button_list",), ("builder", "button", "list"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_custom_button_get", ("app_custom_button_get",), ("builder", "button", "get"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_custom_button_create", ("app_custom_button_create",), ("builder", "button", "create"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),