@josephyan/qingflow-app-builder-mcp 0.2.0-beta.998 → 0.2.0-beta.999

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-app-builder-mcp@0.2.0-beta.998
+npm install @josephyan/qingflow-app-builder-mcp@0.2.0-beta.999
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-app-builder-mcp@0.2.0-beta.998 qingflow-app-builder-mcp
+npx -y -p @josephyan/qingflow-app-builder-mcp@0.2.0-beta.999 qingflow-app-builder-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-builder-mcp",
-  "version": "0.2.0-beta.998",
+  "version": "0.2.0-beta.999",
   "description": "Builder MCP for Qingflow app/package/system design and staged solution workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "0.2.0b998"
+version = "0.2.0b999"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/__init__.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 __all__ = ["__version__"]
 
-_FALLBACK_VERSION = "0.2.0b998"
+_FALLBACK_VERSION = "0.2.0b999"
 
 
 def _resolve_local_pyproject_version() -> str | None:

package/src/qingflow_mcp/cli/commands/workspace.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 import argparse
+import json
 
 from ..context import CliContext
+from ..terminal_ui import SelectionOption, select_option
 
 
 def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
@@ -20,7 +22,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     get_parser.set_defaults(handler=_handle_get, format_hint="workspace_get")
 
     select_parser = workspace_subparsers.add_parser("select", help="切换当前工作区")
-    select_parser.add_argument("--ws-id", type=int, required=True)
+    select_parser.add_argument("--ws-id", type=int, default=0, help="不传时在交互终端中选择工作区")
     select_parser.set_defaults(handler=_handle_select, format_hint="workspace_get")
 
 
@@ -41,7 +43,68 @@ def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
 
 
 def _handle_select(args: argparse.Namespace, context: CliContext) -> dict:
+    if int(args.ws_id or 0) <= 0:
+        selected_ws_id = _choose_workspace_interactively(args, context)
+        if selected_ws_id is None:
+            raise RuntimeError(
+                json.dumps(
+                    {
+                        "category": "config",
+                        "message": "workspace select requires --ws-id, or an interactive terminal to choose a workspace",
+                    },
+                    ensure_ascii=False,
+                )
+            )
+        args.ws_id = selected_ws_id
     return context.workspace.workspace_select(
         profile=args.profile,
         ws_id=int(args.ws_id),
     )
+
+
+def _choose_workspace_interactively(args: argparse.Namespace, context: CliContext) -> int | None:
+    input_stream = getattr(args, "_stdin", None)
+    output_stream = getattr(args, "_stderr_stream", None)
+    if input_stream is None or output_stream is None:
+        return None
+    if not bool(getattr(input_stream, "isatty", lambda: False)()):
+        return None
+    page = context.workspace.workspace_list(
+        profile=args.profile,
+        page_num=1,
+        page_size=100,
+        include_external=False,
+    ).get("page")
+    items = page.get("list") if isinstance(page, dict) and isinstance(page.get("list"), list) else []
+    if not items:
+        return None
+    current_ws_id = None
+    sessions = getattr(context, "sessions", None)
+    if sessions is not None and hasattr(sessions, "get_profile"):
+        try:
+            session_profile = sessions.get_profile(args.profile)
+        except Exception:
+            session_profile = None
+        current_ws_id = getattr(session_profile, "selected_ws_id", None) if session_profile is not None else None
+    options: list[SelectionOption[int]] = []
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        ws_id = int(item.get("wsId") or 0)
+        if ws_id <= 0:
+            continue
+        workspace_name = str(item.get("workspaceName") or item.get("wsName") or f"Workspace {ws_id}")
+        remark = str(item.get("remark") or "").strip()
+        label = workspace_name
+        if remark:
+            label = f"{workspace_name} - {remark}"
+        hint = f"ws_id={ws_id}"
+        if current_ws_id == ws_id:
+            hint += " · 当前"
+        options.append(SelectionOption(value=ws_id, label=label, hint=hint))
+    return select_option(
+        title="选择工作区",
+        options=options,
+        input_stream=input_stream,
+        output_stream=output_stream,
+    )

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)

package/src/qingflow_mcp/cli/terminal_ui.py

@@ -0,0 +1,172 @@
+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")
+
+
+@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("\n".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)