@josephyan/qingflow-cli 0.2.0-beta.58 → 0.2.0-beta.59

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-cli@0.2.0-beta.58
+npm install @josephyan/qingflow-cli@0.2.0-beta.59
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-cli@0.2.0-beta.58 qingflow
+npx -y -p @josephyan/qingflow-cli@0.2.0-beta.59 qingflow
 ```
 
 Environment:
@@ -28,3 +28,4 @@ Note:
 
 - The skill files are included in the npm package.
 - On install, the package copies them to `$CODEX_HOME/skills` (or `~/.codex/skills` if `CODEX_HOME` is unset).
+- If a stdio MCP client reports `Transport closed`, delete `.npm-python`, reinstall the package, and make sure CLI/user/builder packages are on the same version. The stdio entrypoints refuse runtime bootstrap so install logs never corrupt MCP stdout.

package/docs/local-agent-install.md

@@ -233,3 +233,12 @@ rm -rf .npm-python
 ```bash
 npm install
 ```
+
+如果 MCP 客户端一调用工具就报 `Transport closed`，优先检查这几件事：
+
+1. 不要混用不同版本的 `@josephyan/qingflow-cli`、`@josephyan/qingflow-app-user-mcp`、`@josephyan/qingflow-app-builder-mcp`
+2. 删除安装目录下的 `.npm-python`
+3. 重新执行 `npm install` 或重新安装对应 tgz/npm 包
+4. 再启动 MCP 客户端
+
+现在 stdio MCP 入口会拒绝在启动瞬间“边启动边重建 Python 运行时”，因为安装日志一旦写进 stdout，就会破坏 MCP 握手并表现成 `Transport closed`。如果运行时缺失或版本不一致，入口会直接报错并提示重装，而不是静默自修复。

package/npm/bin/qingflow.mjs

@@ -2,4 +2,4 @@
 import { spawnServer, getPackageRoot } from "../lib/runtime.mjs";
 
 const packageRoot = getPackageRoot(import.meta.url);
-spawnServer(packageRoot, process.argv.slice(2), "qingflow");
+spawnServer(packageRoot, process.argv.slice(2), "qingflow", { allowRuntimeBootstrap: true });

package/npm/lib/runtime.mjs

@@ -7,14 +7,16 @@ const WINDOWS = process.platform === "win32";
 
 function runChecked(command, args, options = {}) {
   const result = spawnSync(command, args, {
-    stdio: "inherit",
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
     ...options,
   });
   if (result.error) {
     throw result.error;
   }
   if (result.status !== 0) {
-    throw new Error(`Command failed: ${command} ${args.join(" ")}`);
+    const details = [result.stderr, result.stdout].filter((value) => typeof value === "string" && value.trim()).join("\n");
+    throw new Error(details ? `Command failed: ${command} ${args.join(" ")}\n${details}` : `Command failed: ${command} ${args.join(" ")}`);
   }
 }
 
@@ -92,6 +94,95 @@ function readPackageVersion(packageRoot) {
   }
 }
 
+function readBootstrapStamp(stampPath) {
+  if (!fs.existsSync(stampPath)) {
+    return { exists: false, version: null };
+  }
+  try {
+    const payload = JSON.parse(fs.readFileSync(stampPath, "utf8"));
+    const version = typeof payload.package_version === "string" && payload.package_version.trim() ? payload.package_version.trim() : null;
+    return { exists: true, version };
+  } catch {
+    return { exists: true, version: null };
+  }
+}
+
+export function inspectPythonEnv(packageRoot, commandName = "qingflow-mcp") {
+  const venvDir = getVenvDir(packageRoot);
+  const serverCommand = getVenvServerCommand(packageRoot, commandName);
+  const stampPath = path.join(venvDir, ".bootstrap.json");
+  const packageVersion = readPackageVersion(packageRoot);
+  const stamp = readBootstrapStamp(stampPath);
+  const problems = [];
+
+  if (!packageVersion) {
+    problems.push("package-version-missing");
+  }
+  if (!fs.existsSync(serverCommand)) {
+    problems.push("server-command-missing");
+  }
+  if (!stamp.exists) {
+    problems.push("bootstrap-stamp-missing");
+  } else if (!stamp.version) {
+    problems.push("bootstrap-stamp-invalid");
+  } else if (packageVersion && stamp.version !== packageVersion) {
+    problems.push("bootstrap-version-mismatch");
+  }
+
+  return {
+    ready: problems.length === 0,
+    packageVersion,
+    stampVersion: stamp.version,
+    stampExists: stamp.exists,
+    stampPath,
+    serverCommand,
+    venvDir,
+    problems,
+  };
+}
+
+function formatRuntimeProblem(runtime, commandName, { allowRuntimeBootstrap = false } = {}) {
+  const problemLines = [];
+  for (const problem of runtime.problems) {
+    switch (problem) {
+      case "package-version-missing":
+        problemLines.push("- package.json is missing a valid version field");
+        break;
+      case "server-command-missing":
+        problemLines.push(`- missing Python entrypoint: ${runtime.serverCommand}`);
+        break;
+      case "bootstrap-stamp-missing":
+        problemLines.push(`- missing bootstrap stamp: ${runtime.stampPath}`);
+        break;
+      case "bootstrap-stamp-invalid":
+        problemLines.push(`- bootstrap stamp is unreadable or invalid: ${runtime.stampPath}`);
+        break;
+      case "bootstrap-version-mismatch":
+        problemLines.push(
+          `- bootstrap version mismatch: package=${runtime.packageVersion ?? "unknown"}, runtime=${runtime.stampVersion ?? "unknown"}`
+        );
+        break;
+      default:
+        problemLines.push(`- ${problem}`);
+        break;
+    }
+  }
+
+  const action = allowRuntimeBootstrap
+    ? "Delete .npm-python and retry, or rerun npm install to rebuild the embedded Python runtime."
+    : "Delete .npm-python and rerun npm install, or reinstall the npm package before starting the MCP server.";
+
+  const bootstrapNote = allowRuntimeBootstrap
+    ? ""
+    : "\nRuntime bootstrap is disabled for stdio MCP entrypoints so install logs can never corrupt the MCP stdout transport.";
+
+  return [
+    `[qingflow-mcp] Python runtime for ${commandName} is not ready.`,
+    ...problemLines,
+    action + bootstrapNote,
+  ].join("\n");
+}
+
 function getVenvPip(packageRoot) {
   return WINDOWS
     ? path.join(getVenvDir(packageRoot), "Scripts", "pip.exe")
@@ -129,20 +220,9 @@ export function findPython() {
 
 export function ensurePythonEnv(packageRoot, { force = false, commandName = "qingflow-mcp" } = {}) {
   const python = findPython();
-  const venvDir = getVenvDir(packageRoot);
+  const runtime = inspectPythonEnv(packageRoot, commandName);
   const venvPython = getVenvPython(packageRoot);
-  const serverCommand = getVenvServerCommand(packageRoot, commandName);
-  const stampPath = path.join(venvDir, ".bootstrap.json");
-  const packageVersion = readPackageVersion(packageRoot);
-  let stampVersion = null;
-  if (fs.existsSync(stampPath)) {
-    try {
-      const payload = JSON.parse(fs.readFileSync(stampPath, "utf8"));
-      stampVersion = typeof payload.package_version === "string" && payload.package_version.trim() ? payload.package_version.trim() : null;
-    } catch {
-      stampVersion = null;
-    }
-  }
+  const { packageVersion, serverCommand, stampPath, venvDir, stampVersion } = runtime;
 
   if (!force && fs.existsSync(serverCommand) && fs.existsSync(stampPath) && stampVersion && stampVersion === packageVersion) {
     return serverCommand;
@@ -179,17 +259,72 @@ export function ensurePythonEnv(packageRoot, { force = false, commandName = "qin
   return serverCommand;
 }
 
-export function spawnServer(packageRoot, args, commandName = "qingflow-mcp") {
-  const serverCommand = fs.existsSync(getVenvServerCommand(packageRoot, commandName))
-    ? getVenvServerCommand(packageRoot, commandName)
-    : ensurePythonEnv(packageRoot, { commandName });
+function proxyStreams(child) {
+  if (process.stdin.readable && child.stdin) {
+    process.stdin.pipe(child.stdin);
+    child.stdin.on("error", (error) => {
+      if (error.code !== "EPIPE") {
+        console.error(`[qingflow-mcp] Failed to forward stdin: ${error.message}`);
+      }
+    });
+  } else if (child.stdin) {
+    child.stdin.end();
+  }
+
+  if (child.stdout) {
+    child.stdout.pipe(process.stdout);
+  }
+  if (child.stderr) {
+    child.stderr.pipe(process.stderr);
+  }
+}
+
+function forwardSignal(child, signal) {
+  process.on(signal, () => {
+    if (!child.killed) {
+      child.kill(signal);
+    }
+  });
+}
+
+export function spawnServer(packageRoot, args, commandName = "qingflow-mcp", { allowRuntimeBootstrap = false } = {}) {
+  let runtime = inspectPythonEnv(packageRoot, commandName);
+  let serverCommand = runtime.serverCommand;
+
+  if (!runtime.ready) {
+    if (!allowRuntimeBootstrap) {
+      console.error(formatRuntimeProblem(runtime, commandName, { allowRuntimeBootstrap }));
+      process.exit(1);
+      return;
+    }
+
+    try {
+      serverCommand = ensurePythonEnv(packageRoot, { commandName });
+      runtime = inspectPythonEnv(packageRoot, commandName);
+    } catch (error) {
+      console.error(`[qingflow-mcp] Failed to prepare Python runtime for ${commandName}: ${error.message}`);
+      process.exit(1);
+      return;
+    }
+
+    if (!runtime.ready) {
+      console.error(formatRuntimeProblem(runtime, commandName, { allowRuntimeBootstrap }));
+      process.exit(1);
+      return;
+    }
+  }
 
   const child = spawn(serverCommand, args, {
-    stdio: "inherit",
+    stdio: ["pipe", "pipe", "pipe"],
     env: process.env,
+    windowsHide: true,
   });
 
-  child.on("exit", (code, signal) => {
+  proxyStreams(child);
+  forwardSignal(child, "SIGINT");
+  forwardSignal(child, "SIGTERM");
+
+  child.on("close", (code, signal) => {
     if (signal) {
       process.kill(process.pid, signal);
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-cli",
-  "version": "0.2.0-beta.58",
+  "version": "0.2.0-beta.59",
   "description": "Human-friendly Qingflow command line interface for auth, record operations, import, tasks, and stable builder flows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

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

package/src/qingflow_mcp/builder_facade/service.py

@@ -161,7 +161,18 @@ class AiBuilderFacade:
                 "package_name is required",
                 suggested_next_call=None,
             )
-        listing = self.packages.package_list(profile=profile, trial_status="all", include_raw=False)
+        normalized_args = {"package_name": requested}
+        try:
+            listing = self.packages.package_list(profile=profile, trial_status="all", include_raw=False)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "PACKAGE_RESOLVE_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"package_name": requested},
+                suggested_next_call={"tool_name": "package_list", "arguments": {"profile": profile, "trial_status": "all"}},
+            )
         items = listing.get("items") if isinstance(listing.get("items"), list) else []
         matches = [
             {"tag_id": item.get("tagId"), "tag_name": item.get("tagName")}
@@ -212,6 +223,7 @@ class AiBuilderFacade:
                 suggested_next_call=None,
             )
         existing = self.package_resolve(profile=profile, package_name=requested)
+        lookup_permission_blocked = None
         if existing.get("status") == "success":
             return {
                 "status": "success",
@@ -231,6 +243,16 @@ class AiBuilderFacade:
             }
         if existing.get("error_code") == "AMBIGUOUS_PACKAGE":
             return existing
+        if existing.get("error_code") == "PACKAGE_RESOLVE_FAILED":
+            if existing.get("backend_code") not in {40002, 40027}:
+                return existing
+            lookup_permission_blocked = {
+                "backend_code": existing.get("backend_code"),
+                "http_status": existing.get("http_status"),
+                "request_id": existing.get("request_id"),
+            }
+        elif existing.get("error_code") not in {"PACKAGE_NOT_FOUND"}:
+            return existing
         try:
             created = self.packages.package_create(profile=profile, payload={"tagName": requested})
         except (QingflowApiError, RuntimeError) as error:
@@ -239,7 +261,10 @@ class AiBuilderFacade:
                 "PACKAGE_CREATE_FAILED",
                 api_error,
                 normalized_args=normalized_args,
-                details={"package_name": requested},
+                details={
+                    "package_name": requested,
+                    **({"lookup_permission_blocked": lookup_permission_blocked} if lookup_permission_blocked is not None else {}),
+                },
                 suggested_next_call={"tool_name": "package_create", "arguments": {"profile": profile, "package_name": requested}},
             )
         result = created.get("result") if isinstance(created.get("result"), dict) else {}
@@ -259,7 +284,7 @@ class AiBuilderFacade:
             "normalized_args": normalized_args,
             "missing_fields": [],
             "allowed_values": {},
-            "details": {},
+            "details": {"lookup_permission_blocked": lookup_permission_blocked} if lookup_permission_blocked is not None else {},
             "request_id": None,
             "suggested_next_call": None
             if verified
@@ -1012,7 +1037,20 @@ class AiBuilderFacade:
                     details={"app_name": requested, "package_tag_id": package_tag_id, "matches": package_matches},
                     suggested_next_call=None,
                 )
-        search = self.apps.app_search(profile=profile, keyword=requested, page_num=1, page_size=200)
+        search_error: QingflowApiError | None = None
+        try:
+            search = self.apps.app_search(profile=profile, keyword=requested, page_num=1, page_size=200)
+        except (QingflowApiError, RuntimeError) as exc:
+            api_error = _coerce_api_error(exc)
+            if package_tag_id is None or package_tag_id <= 0 or api_error.backend_code not in {40002, 40027}:
+                return _failed_from_api_error(
+                    "APP_NOT_FOUND" if api_error.http_status == 404 else "APP_RESOLVE_FAILED",
+                    api_error,
+                    details={"app_name": requested, "package_tag_id": package_tag_id},
+                    suggested_next_call=None,
+                )
+            search = {}
+            search_error = api_error
         apps = search.get("apps") if isinstance(search.get("apps"), list) else []
         matches = []
         for item in apps:
@@ -1046,11 +1084,72 @@ class AiBuilderFacade:
                     "tag_ids": tag_ids,
                 }
             )
+        if not matches and package_tag_id is not None and package_tag_id > 0 and search_error is not None:
+            visible_matches = self._resolve_app_matches_in_visible_apps(
+                profile=profile,
+                app_name=requested,
+                package_tag_id=package_tag_id,
+            )
+            if len(visible_matches) == 1:
+                match = visible_matches[0]
+                return {
+                    "status": "success",
+                    "error_code": None,
+                    "recoverable": False,
+                    "message": "resolved app",
+                    "normalized_args": {"app_name": requested, "package_tag_id": package_tag_id},
+                    "missing_fields": [],
+                    "allowed_values": {},
+                    "details": {
+                        "match_scope": "visible_apps",
+                        "search_permission_blocked": {
+                            "backend_code": search_error.backend_code,
+                            "http_status": search_error.http_status,
+                            "request_id": search_error.request_id,
+                        },
+                    },
+                    "request_id": None,
+                    "suggested_next_call": None,
+                    "noop": False,
+                    "verification": {},
+                    **match,
+                }
+            if len(visible_matches) > 1:
+                return _failed(
+                    "AMBIGUOUS_APP",
+                    f"multiple apps matched '{requested}' inside package {package_tag_id}",
+                    details={
+                        "app_name": requested,
+                        "package_tag_id": package_tag_id,
+                        "matches": visible_matches,
+                        "search_permission_blocked": {
+                            "backend_code": search_error.backend_code,
+                            "http_status": search_error.http_status,
+                            "request_id": search_error.request_id,
+                        },
+                    },
+                    suggested_next_call=None,
+                )
         if not matches:
             return _failed(
                 "APP_NOT_FOUND",
                 f"app '{requested}' was not found",
-                details={"app_name": requested, "package_tag_id": package_tag_id},
+                details={
+                    "app_name": requested,
+                    "package_tag_id": package_tag_id,
+                    **(
+                        {
+                            "search_permission_blocked": {
+                                "backend_code": search_error.backend_code,
+                                "http_status": search_error.http_status,
+                                "request_id": search_error.request_id,
+                            },
+                            "match_scope": "visible_apps_fallback",
+                        }
+                        if search_error is not None
+                        else {}
+                    ),
+                },
                 suggested_next_call=None,
             )
         if len(matches) > 1:
@@ -1077,6 +1176,39 @@ class AiBuilderFacade:
             **match,
         }
 
+    def _resolve_app_matches_in_visible_apps(
+        self,
+        *,
+        profile: str,
+        app_name: str,
+        package_tag_id: int,
+    ) -> list[JSONObject]:
+        try:
+            listing = self.apps.app_list(profile=profile, ship_auth=False)
+        except (QingflowApiError, RuntimeError):
+            return []
+        items = listing.get("items") if isinstance(listing.get("items"), list) else []
+        matches: list[JSONObject] = []
+        seen_app_keys: set[str] = set()
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            title = str(item.get("title") or item.get("app_name") or "").strip()
+            if title != app_name:
+                continue
+            candidate_key = str(item.get("app_key") or item.get("appKey") or "").strip()
+            if not candidate_key or candidate_key in seen_app_keys:
+                continue
+            tag_ids = _coerce_int_list(item.get("tag_ids"))
+            tag_id = _coerce_positive_int(item.get("tag_id"))
+            if tag_id is not None and tag_id not in tag_ids:
+                tag_ids.append(tag_id)
+            if package_tag_id not in tag_ids:
+                continue
+            seen_app_keys.add(candidate_key)
+            matches.append({"app_key": candidate_key, "app_name": title, "tag_ids": tag_ids})
+        return matches
+
     def _resolve_app_matches_in_package(
         self,
         *,

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

@@ -6,29 +6,29 @@ from ..context import CliContext
 
 
 def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
-    parser = subparsers.add_parser("apps", help="应用发现")
-    app_subparsers = parser.add_subparsers(dest="apps_command", required=True)
+    parser = subparsers.add_parser("app", help="应用发现")
+    app_subparsers = parser.add_subparsers(dest="app_command", required=True)
 
     list_parser = app_subparsers.add_parser("list", help="列出可见应用")
-    list_parser.set_defaults(handler=_handle_list, format_hint="apps_list")
+    list_parser.set_defaults(handler=_handle_list, format_hint="app_list")
 
-    find = app_subparsers.add_parser("find", help="搜索应用")
-    find.add_argument("--keyword", default="")
-    find.add_argument("--page", type=int, default=1)
-    find.add_argument("--page-size", type=int, default=50)
-    find.set_defaults(handler=_handle_find, format_hint="apps_list")
+    search = app_subparsers.add_parser("search", help="搜索应用")
+    search.add_argument("--keyword", default="")
+    search.add_argument("--page", type=int, default=1)
+    search.add_argument("--page-size", type=int, default=50)
+    search.set_defaults(handler=_handle_search, format_hint="app_search")
 
-    show = app_subparsers.add_parser("show", help="读取应用信息")
-    show.add_argument("--app", required=True)
-    show.set_defaults(handler=_handle_show, format_hint="app_show")
+    get = app_subparsers.add_parser("get", help="读取应用可访问视图与导入能力")
+    get.add_argument("--app-key", required=True)
+    get.set_defaults(handler=_handle_get, format_hint="app_get")
 
 
 def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.apps.list(profile=args.profile)
+    return context.app.app_list(profile=args.profile)
 
 
-def _handle_find(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.apps.find(
+def _handle_search(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.app.app_search(
         profile=args.profile,
         keyword=args.keyword,
         page_num=args.page,
@@ -36,5 +36,5 @@ def _handle_find(args: argparse.Namespace, context: CliContext) -> dict:
     )
 
 
-def _handle_show(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.apps.show(profile=args.profile, app_key=args.app)
+def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.app.app_get(profile=args.profile, app_key=args.app_key)

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

@@ -10,34 +10,33 @@ from .common import read_secret_arg
 
 
 def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
-    me = subparsers.add_parser("me", help="查看当前会话")
-    me.set_defaults(handler=_handle_me, format_hint="me")
+    parser = subparsers.add_parser("auth", help="认证与会话")
+    auth_subparsers = parser.add_subparsers(dest="auth_command", required=True)
 
-    login = subparsers.add_parser("login", help="邮箱密码登录")
+    login = auth_subparsers.add_parser("login", help="邮箱密码登录")
     login.add_argument("--base-url")
     login.add_argument("--qf-version")
     login.add_argument("--email", required=True)
     login.add_argument("--password")
     login.add_argument("--password-stdin", action="store_true")
     login.add_argument("--persist", action=argparse.BooleanOptionalAction, default=True)
-    login.set_defaults(handler=_handle_login, format_hint="session")
+    login.set_defaults(handler=_handle_login, format_hint="auth_whoami")
 
-    use_token = subparsers.add_parser("use-token", help="直接接入 token")
+    use_token = auth_subparsers.add_parser("use-token", help="直接注入 token")
     use_token.add_argument("--base-url")
     use_token.add_argument("--qf-version")
     use_token.add_argument("--token")
     use_token.add_argument("--token-stdin", action="store_true")
-    use_token.add_argument("--ws", dest="ws_id", type=int)
+    use_token.add_argument("--ws-id", type=int)
     use_token.add_argument("--persist", action=argparse.BooleanOptionalAction, default=False)
-    use_token.set_defaults(handler=_handle_use_token, format_hint="session")
-
-    logout = subparsers.add_parser("logout", help="退出当前会话")
-    logout.add_argument("--forget-persisted", action="store_true")
-    logout.set_defaults(handler=_handle_logout, format_hint="session")
+    use_token.set_defaults(handler=_handle_use_token, format_hint="auth_whoami")
 
+    whoami = auth_subparsers.add_parser("whoami", help="查看当前登录态")
+    whoami.set_defaults(handler=_handle_whoami, format_hint="auth_whoami")
 
-def _handle_me(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.auth.me(profile=args.profile)
+    logout = auth_subparsers.add_parser("logout", help="退出登录")
+    logout.add_argument("--forget-persisted", action="store_true")
+    logout.set_defaults(handler=_handle_logout, format_hint="")
 
 
 def _handle_login(args: argparse.Namespace, context: CliContext) -> dict:
@@ -49,7 +48,7 @@ def _handle_login(args: argparse.Namespace, context: CliContext) -> dict:
             password = getpass.getpass("Password: ")
         else:
             raise QingflowApiError.config_error("password is required; use --password or --password-stdin")
-    return context.auth.login(
+    return context.auth.auth_login(
         profile=args.profile,
         base_url=args.base_url,
         qf_version=args.qf_version,
@@ -61,7 +60,7 @@ def _handle_login(args: argparse.Namespace, context: CliContext) -> dict:
 
 def _handle_use_token(args: argparse.Namespace, context: CliContext) -> dict:
     token = read_secret_arg(args.token, stdin_enabled=bool(args.token_stdin), label="token")
-    return context.auth.use_token(
+    return context.auth.auth_use_token(
         profile=args.profile,
         base_url=args.base_url,
         qf_version=args.qf_version,
@@ -71,5 +70,9 @@ def _handle_use_token(args: argparse.Namespace, context: CliContext) -> dict:
     )
 
 
+def _handle_whoami(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.auth.auth_whoami(profile=args.profile)
+
+
 def _handle_logout(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.auth.logout(profile=args.profile, forget_persisted=bool(args.forget_persisted))
+    return context.auth.auth_logout(profile=args.profile, forget_persisted=bool(args.forget_persisted))