@thinkingai/ae-cli 6.1.27 → 6.1.28

package/README.md

@@ -62,11 +62,11 @@ ae-cli update --dry-run
 
 Updates use the same global Skills installation and verification as `install`. Older packages need no installer or generated manifest: their bundled Skills define the expected contents. If Skills fail after the CLI installs, the result reports partial completion and can be retried.
 
-Automatic synchronization runs during normal commands after login; host version checks are cached for up to 24 hours. `ae-cli update --host <AE_HOST>` checks immediately. After a downgrade, future updates run the older CLI's own updater, including its historical limitations. To use the new installer logic while following an older host, run `npx @thinkingai/ae-cli@latest update --host <AE_HOST>`; the target remains the host-required version.
+Automatic synchronization runs during normal commands after login; host version checks are cached for up to one hour. `ae-cli update --host <AE_HOST>` checks immediately. After a downgrade, future updates run the older CLI's own updater, including its historical limitations. To use the new installer logic while following an older host, run `npx @thinkingai/ae-cli@latest update --host <AE_HOST>`; the target remains the host-required version.
 
 `ae-cli update` installs the exact version required by the active host rather than npm `latest`. It synchronizes Skills from the installed npm package first and uses the matching GitHub tag only as a fallback.
 
-Starting with the `6.0.37` and `6.1.9` release lines, ordinary business commands can automatically upgrade or downgrade the CLI to the host-required version. After a successful synchronization, the old process exits with `AE_CLI_VERSION_SYNCED`; re-run the original command so it executes with the new CLI and Skills. Installation failures are reported without replacing the business command's JSON output.
+Starting with the `6.0.37` and `6.1.9` release lines, ordinary business commands can automatically upgrade or downgrade the CLI to the host-required version, including switching from `6.0.x` to `6.1.x`. Automatic synchronization requires stable `major.minor.patch` versions at both ends; development and other nonstandard versions are skipped. After a successful synchronization, the old process exits with `AE_CLI_VERSION_SYNCED`; re-run the original command so it executes with the new CLI and Skills. Installation failures are reported without replacing the business command's JSON output.
 
 Useful controls:
 
@@ -144,6 +144,7 @@ The table covers every current root command individually. Use `ae-cli --help` fo
 | Agent platform | `context` | Read the current product-page context authorized for the active Agent Run |
 | Agent platform | `memory` | AgentSpace memory, drafts, shared review, extraction jobs, revisions, and state transitions |
 | Agent platform | `team` | Agent Team and TeamRun execution, chat, results, and artifacts |
+| Agent platform | `evaluation` | Agent Evaluation datasets, LLM judge evaluators, runs, case results, exports, schedules, and model/agent configs |
 | Agent platform | `system` | Root/admin management of members, sandboxes, tools, models, usage, quotas, and channels |
 | General tools | `capability` | Capability discovery, schema inspection, validation, dry-run, and generic execution |
 | General tools | `auth` | Host-scoped login, status, and multi-account management |
@@ -157,6 +158,8 @@ The table covers every current root command individually. Use `ae-cli --help` fo
 | Agent platform | `automation` | Automation configuration, execution, history, and results |
 <!-- root-command-surface:end -->
 
+Evaluation commands follow the current AE Host in personal terminals and sandboxes; use `--host` to select another host. Evaluation requests use the HTTP or HTTPS scheme configured for that AE Host, consistent with other AE commands. Legacy `--endpoint` and `AE_EVAL_BASE_URL` values may only match the current AE Host; other values fail before credentials are sent. Remove these settings and use `--host` to select a host. Outside a sandbox, export `AE_EVAL_ACCESS_TOKEN` with a platform session token; sandboxes can obtain a session automatically. See [endpoint and authentication rules](skills/ae-evaluation/SKILL.md#endpoint-and-authentication).
+
 ## Capability Gateway
 
 Capability Gateway is the preferred entry point for operations that do not need a dedicated curated command:
@@ -170,6 +173,10 @@ ae-cli capability dry-run analysis.report.list --input input.json
 ae-cli capability run analysis.report.list --input input.json
 ```
 
+Administrators can set each member's daily CLI call limit in External Access Management.
+
+For asynchronous exports, omit `--timeout-seconds` to use the server's default timeout. See the [export guide](skills/ae-analysis/references/analysis_data_export.md) for submitting, waiting for, and downloading results.
+
 `--input` accepts inline JSON, a JSON file path, `@<path>`, or `-` for stdin.
 
 Use `validate` while fixing complex nested input. Use `dry-run` when you need the final risk, output mode, cancellation support, or delete confirmation preview. Do not stack `validate` and `dry-run` for the same final payload by default; `dry-run` already validates it.
@@ -195,7 +202,7 @@ ae-cli auth status --host https://host-a.example.com
 # Import a CLI token copied from External Access Management (hidden prompt)
 ae-cli auth set-token --host https://host-a.example.com
 # Non-interactive input for local scripts or tests
-printf '%s' "$AE_CLI_TOKEN" | ae-cli auth set-token --host https://host-a.example.com --token-stdin
+printf '%s' "$IMPORTED_CLI_TOKEN" | ae-cli auth set-token --host https://host-a.example.com --token-stdin
 # For the uncommon case where one Host needs multiple accounts
 ae-cli auth login --host https://host-a.example.com --add
 ae-cli auth list --host https://host-a.example.com
@@ -217,9 +224,28 @@ A regular `auth login` keeps the simple one-Host/one-account behavior and replac
 
 `auth set-token` is for local use with a `cli_` token copied from External Access Management. It prompts without echo by default; `--token-stdin` supports non-interactive local testing. The CLI validates the token against the target Host before replacing the stored credential, encrypts it in the existing per-Host vault, and never includes the value in command output. Add `--add` to retain other accounts for the same Host.
 
+Inject credentials into the current CLI invocation through environment variables or a specified file without changing stored machine accounts. This supports automation scripts, CI/CD, shared Agents, and other workflows:
+
+```bash
+AE_CLI_TOKEN="$CALLER_CLI_TOKEN" AE_CLI_TOKEN_HOST=https://host-a.example.com ae-cli auth status
+AE_CLI_TOKEN_FILE=/secure/caller-token.json ae-cli auth status
+ae-cli --cli-token-file /secure/caller-token.json auth status
+```
+
+The token file is a read-only JSON object: `{"url":"https://host-a.example.com","token":"cli_REPLACE_WITH_USER_TOKEN"}`. The historical `cli-token` key is also accepted. Keep the file private to its owner (for example, mode `600`). Files must be regular JSON files no larger than 64 KiB. The file URL or `AE_CLI_TOKEN_HOST` selects the host for this invocation; an explicit `--host` must match it. External tokens are sent only to that origin; alternate service origins and HTTP redirects are rejected.
+
+Credential precedence is `--cli-token-file` > `AE_CLI_TOKEN` with required `AE_CLI_TOKEN_HOST` > `AE_CLI_TOKEN_FILE` > the existing stored-account/sandbox sources. An explicitly selected source that is empty, malformed, unreadable, or bound to a different host returns `EXTERNAL_CLI_TOKEN_INVALID`; it never falls back to another identity. External credentials also take precedence over sandbox identity headers for Agent calls. `auth status` reports `environment-cli-token` or `file-cli-token`, account and expiration when available, and never reveals the token. Authentication failures do not replace or delete stored credentials.
+
+External mode does not write the token or renewal state to the local credential vault. Renewal is best effort, uses the `cli-token` header, and is limited per host/token per process day; older servers without header-based renewal can still authenticate business calls but cannot automatically extend external tokens. `auth`, `auth login`, `auth set-token`, `auth use`, and `auth logout` return `EXTERNAL_CLI_TOKEN_ACTIVE` while external credentials are selected. Remove these process settings before managing machine accounts; `auth list` continues to list local accounts.
+
 The new CLI persists only CLI tokens, never access or refresh tokens. Multiple accounts live in an encrypted V1 vault while the active account is projected into the historical file shape for automatic downgrades. When the CLI upgrades again, it reconciles login, switch, or logout changes made by the old CLI.
 
 Login uses a cross-platform device-code flow. Use `--no-browser` when the environment cannot open a browser.
+
+On upgraded 6.1 deployments, authorization always uses the UBA device endpoints and the platform `/#/cli/device-activate` page, independently of Kubernetes or Agent state. Only an explicit missing authorization endpoint (HTTP 404) selects the supported legacy Agent flow; network failures, HTML responses and permission denials never change the issuer. Use `auth login --no-wait`, then resume with the returned `--device-code` and the same `--host` for non-interactive authorization. Existing host accounts, CLI tokens and command flags remain compatible.
+
+The CLI calls business endpoints directly; services enforce product License and user/project permissions. An unavailable component returns the actual API error. HTTP 404 can also mean a missing resource or an unsupported route, so it does not by itself establish that a component is not deployed.
+
 Trial guidance is emitted only when no Host is configured; normal commands and authentication flows for configured environments do not display it.
 
 ## Output and Safety

package/README.zh.md

@@ -66,11 +66,11 @@ ae-cli update --dry-run
 
 更新与 `install` 复用全局 Skills 安装和校验。旧包无需包含安装器或生成的清单，直接以目标包内置 Skills 为准。CLI 安装后 Skills 失败会返回部分成功信息，修复后可重复执行。
 
-自动同步在登录后的普通命令中触发，集群版本检查最长缓存 24 小时；`ae-cli update --host <AE_HOST>` 可立即查询。降级后，后续更新由旧版 CLI 自身执行，也受旧版实现限制。需要用新安装逻辑匹配旧集群时，可运行 `npx @thinkingai/ae-cli@latest update --host <AE_HOST>`，目标仍是集群要求的版本。
+自动同步在登录后的普通命令中触发，集群版本检查最长缓存 1 小时；`ae-cli update --host <AE_HOST>` 可立即查询。降级后，后续更新由旧版 CLI 自身执行，也受旧版实现限制。需要用新安装逻辑匹配旧集群时，可运行 `npx @thinkingai/ae-cli@latest update --host <AE_HOST>`，目标仍是集群要求的版本。
 
 `ae-cli update` 安装当前 Host 要求的精确版本，不依赖 npm `latest`。更新时优先从已安装的 npm 包同步 Skills，本地来源失败后才回退到对应的 GitHub tag。
 
-从 `6.0.37` 和 `6.1.9` 维护线开始，普通业务命令可以自动升级或降级到环境要求的版本。同步成功后，旧进程会返回 `AE_CLI_VERSION_SYNCED`；重新执行原命令，即可使用新的 CLI 和 Skills。安装失败会给出提示，但不会用安装输出污染业务命令的 JSON 结果。
+从 `6.0.37` 和 `6.1.9` 维护线开始，普通业务命令可以自动升级或降级到环境要求的版本，包括从 `6.0.x` 切换到 `6.1.x`。自动同步要求本地和目标均为 `主版本.次版本.补丁号` 格式的正式版本，开发版等不规则版本会跳过。同步成功后，旧进程会返回 `AE_CLI_VERSION_SYNCED`；重新执行原命令，即可使用新的 CLI 和 Skills。安装失败会给出提示，但不会用安装输出污染业务命令的 JSON 结果。
 
 常用控制方式：
 
@@ -148,6 +148,7 @@ ae-cli capability list --domain analysis --jq '.data.capabilities[] | .id'
 | Agent 平台 | `context` | 读取当前 Agent Run 已授权的产品页面上下文 |
 | Agent 平台 | `memory` | AgentSpace 记忆、草稿、共享审核、提取任务、版本与状态治理 |
 | Agent 平台 | `team` | Agent Team 和 TeamRun 的执行、对话、结果及产物 |
+| Agent 平台 | `evaluation` | Agent Evaluation 评测数据集、LLM 裁判、评测任务、用例结果、导出、调度，以及模型/Agent 配置 |
 | Agent 平台 | `system` | root/admin 的成员、沙盒、工具、模型、用量、配额和渠道管理 |
 | 通用工具 | `capability` | 能力发现、Schema 查看、参数校验、dry-run 和通用执行 |
 | 通用工具 | `auth` | 按 Host 登录、查看状态及管理同一 Host 的多个账号 |
@@ -161,6 +162,8 @@ ae-cli capability list --domain analysis --jq '.data.capabilities[] | .id'
 | Agent 平台 | `automation` | 自动化配置、执行、历史和结果 |
 <!-- root-command-surface:end -->
 
+评测命令在普通终端和沙箱中均跟随当前 AE Host，可通过 `--host` 切换。评测请求沿用该 AE Host 配置的 HTTP 或 HTTPS 协议，与其他 AE 命令一致。旧 `--endpoint` 和 `AE_EVAL_BASE_URL` 只能与当前 AE Host 一致，其他值会在发送凭证前报错；请移除这些配置，统一使用 `--host` 切换。沙箱外需设置 `AE_EVAL_ACCESS_TOKEN` 平台 session token，沙箱内可自动获取会话。详见 [地址与鉴权规则](skills/ae-evaluation/SKILL.md#endpoint-and-authentication)。
+
 ## Capability Gateway
 
 不需要独立精选命令的能力，应优先通过 Capability Gateway 调用：
@@ -174,6 +177,10 @@ ae-cli capability dry-run analysis.report.list --input input.json
 ae-cli capability run analysis.report.list --input input.json
 ```
 
+管理员可在“外部访问管理”为成员配置每日 CLI 调用限额。
+
+异步导出时，省略 `--timeout-seconds` 即使用服务端默认超时。提交、等待和下载结果的方法见[导出使用指南](skills/ae-analysis/references/analysis_data_export.md)。
+
 `--input` 支持内联 JSON、JSON 文件路径、`@<path>`，或通过 `-` 从 stdin 读取。
 
 复杂嵌套参数尚在调整时使用 `validate`；需要确认最终风险等级、输出模式、取消能力或删除门禁时使用 `dry-run`。默认不要对同一份最终入参连续执行 `validate` 和 `dry-run`，因为 `dry-run` 已包含参数校验。
@@ -199,7 +206,7 @@ ae-cli auth status --host https://host-a.example.com
 # 导入从“外部访问管理”复制的 CLI Token（隐藏输入）
 ae-cli auth set-token --host https://host-a.example.com
 # 本地脚本或测试使用非交互输入
-printf '%s' "$AE_CLI_TOKEN" | ae-cli auth set-token --host https://host-a.example.com --token-stdin
+printf '%s' "$IMPORTED_CLI_TOKEN" | ae-cli auth set-token --host https://host-a.example.com --token-stdin
 # 少量需要同一 Host 多账号的场景
 ae-cli auth login --host https://host-a.example.com --add
 ae-cli auth list --host https://host-a.example.com
@@ -221,9 +228,28 @@ ae-cli config remove pre-production --yes
 
 `auth set-token` 用于在本地导入从“外部访问管理”复制的 `cli_` Token。默认使用不回显的隐藏输入，`--token-stdin` 支持本地测试等非交互场景。CLI 会先向目标 Host 校验 Token，再替换本地凭证，并写入现有的按 Host 加密凭据库；命令输出不会包含 Token。需要保留同一 Host 的其他账号时增加 `--add`。
 
+支持通过环境变量或指定文件，为当前 CLI 调用注入凭证，不改变机器上已保存的账号；适用于自动化脚本、CI/CD、公共Agent等场景。
+
+```bash
+AE_CLI_TOKEN="$CALLER_CLI_TOKEN" AE_CLI_TOKEN_HOST=https://host-a.example.com ae-cli auth status
+AE_CLI_TOKEN_FILE=/secure/caller-token.json ae-cli auth status
+ae-cli --cli-token-file /secure/caller-token.json auth status
+```
+
+Token 文件是只读 JSON 对象：`{"url":"https://host-a.example.com","token":"cli_REPLACE_WITH_USER_TOKEN"}`，也兼容历史字段 `cli-token`。文件应仅允许所有者读取，例如权限 `600`；必须是大小不超过 64 KiB 的普通 JSON 文件。文件中的 URL 或 `AE_CLI_TOKEN_HOST` 决定本次调用的 Host；显式 `--host` 必须与之匹配。外部 Token 仅发送到该 Origin，拒绝其他服务 Origin 和 HTTP 重定向。
+
+凭证优先级为 `--cli-token-file` > `AE_CLI_TOKEN`（必须同时提供 `AE_CLI_TOKEN_HOST`）> `AE_CLI_TOKEN_FILE` > 现有本地账号或沙箱来源。显式来源为空、格式错误、无法读取或 Host 不匹配时返回 `EXTERNAL_CLI_TOKEN_INVALID`，不会回退到其他身份。外部凭证也优先于 Agent 调用的沙箱身份头。`auth status` 的来源为 `environment-cli-token` 或 `file-cli-token`，并在后端支持时展示账号与到期时间，不输出 Token。认证失败不会替换或删除本地凭证。
+
+外部模式不将 Token 或续期状态写入本地凭据库。自动续期使用 `cli-token` 请求头，失败不阻断业务请求，每个进程按 Host、Token 和当天日期限频；旧后端不支持请求头续期时仍可认证业务请求，但不能自动延长外部 Token。选择外部凭证时，`auth`、`auth login`、`auth set-token`、`auth use` 和 `auth logout` 返回 `EXTERNAL_CLI_TOKEN_ACTIVE`。管理机器账号前先移除这些进程设置；`auth list` 仍只列出本地账号。
+
 新版 CLI 只持久化 CLI Token，不保存 access token 或 refresh token。多账号保存在加密的 V1 凭据文件中，同时维护旧文件格式的当前账号投影，保证 CLI 自动降级后仍可登录；再次升级时会合并旧 CLI 对投影的登录、切换或退出变更。
 
 登录使用跨平台设备码流程。当前环境无法打开浏览器时，可使用 `--no-browser`。
+
+已改造的 6.1 环境统一使用 UBA 设备授权接口与平台 `/#/cli/device-activate` 页面，不随 K8s 或 Agent 状态切换。只有授权端点明确不存在（HTTP 404）时才兼容旧 Agent 流程；网络失败、HTML 响应和权限拒绝均不会更换授权方。非交互环境使用 `auth login --no-wait`，再携带返回的 `--device-code` 和同一个 `--host` 继续授权。原有 Host 多账号、CLI Token 与命令参数保持兼容。
+
+CLI 直接请求对应业务接口，由服务端校验产品 License 和用户/项目权限。组件不可用时会返回实际接口错误；HTTP 404 也可能表示资源不存在或路由不支持，不能据此直接判断组件未部署。
+
 试用引导仅在尚未配置 Host 时出现；已配置环境的正常命令和认证流程不会展示该提示。
 
 ## 输出与安全

package/dist/{auth-WA7YGGRT.js → auth-NKD5Z5BQ.js}

@@ -9,13 +9,13 @@ import {
 } from "./chunk-6ZIQV5GW.js";
 import {
   resolveHost
-} from "./chunk-OP44TT4H.js";
+} from "./chunk-P6VFCH3P.js";
 import {
   getLocalCliPackageInfo,
   printError,
   printOutput,
   runHostCompatCheck
-} from "./chunk-6VNIR4AP.js";
+} from "./chunk-ELCR235M.js";
 import {
   CliTokenValidationUnavailableError,
   CredentialStoreUnreadableError,
@@ -31,25 +31,54 @@ import {
   saveCredential,
   updateCredentialMetadata,
   validateCliTokenOnServer
-} from "./chunk-GHXZK54S.js";
+} from "./chunk-P7KL7IOH.js";
 import {
   getFallbackCliToken,
   loadConfig,
-  normalizeUrl,
   saveConfig
-} from "./chunk-ZL7SGNIA.js";
+} from "./chunk-LMCYSVVA.js";
 import {
+  ExternalCliTokenError,
   PermissionError,
-  logger
-} from "./chunk-WNGFSIOB.js";
+  logger,
+  normalizeUrl,
+  readExternalCliToken
+} from "./chunk-ZW4VMY5H.js";
 
 // src/core/device-auth.ts
 import { execFileSync } from "child_process";
+function deviceApiPath(protocol, action) {
+  return protocol === "uba" ? `/v1/ta/cli/auth/device/${action}` : `/api/auth/device/${action}`;
+}
+function ubaAuthorizationDenial(code) {
+  if (code === "CLI_ACCESS_DISABLED") return {
+    code,
+    message: "CLI access is disabled for this account.",
+    hint: "Contact your administrator."
+  };
+  if (code === "ACCOUNT_UNAVAILABLE") return {
+    code,
+    message: "This account is unavailable.",
+    hint: "Contact your administrator or sign in with an active account."
+  };
+  if (code === "ORIGIN_DENIED") return {
+    code,
+    message: "Authorization must be approved from the trusted platform page.",
+    hint: "Open the verification URL on the configured AE host and sign in there."
+  };
+  return {
+    code: "AUTHORIZATION_DENIED",
+    message: "Device authorization was denied.",
+    hint: "Check your account status with your administrator before requesting authorization again."
+  };
+}
 var DeviceFlowUnsupportedError = class extends Error {
-  constructor() {
+  constructor(httpStatus) {
     super("This AE server does not support device code login (it may be an older server version).");
+    this.httpStatus = httpStatus;
     this.name = "DeviceFlowUnsupportedError";
   }
+  httpStatus;
 };
 function looksLikeMissingEndpoint(status, contentType, body) {
   if (status === 404) return true;
@@ -83,29 +112,46 @@ function openBrowser(url, _execFile) {
     exec("xdg-open", [url], { timeout: 5e3 });
     return true;
   } catch (e) {
-    logger.warn(`openBrowser: failed to open ${safeLogUrl}: ${e.message}`);
+    logger.warn(`openBrowser: failed to open ${safeLogUrl}`);
     return false;
   }
 }
-async function authorizeDevice(host) {
+async function authorizeDevice(host, protocol = "legacy") {
   const base = host.replace(/\/+$/, "");
-  const url = `${base}/api/auth/device/authorize`;
+  const url = `${base}${deviceApiPath(protocol, "authorize")}`;
   let resp;
   try {
     resp = await fetch(url, {
       method: "POST",
-      headers: { "Content-Type": "application/json" }
+      headers: {
+        "Content-Type": "application/json",
+        ...protocol === "uba" ? { "X-CLI-Verification-Origin": new URL(host).origin } : {}
+      },
+      redirect: "error",
+      signal: AbortSignal.timeout(1e4)
     });
   } catch (e) {
-    throw new Error(`Device authorize request failed: ${e.message}`);
+    throw new Error("Device authorize request failed. Check the AE host and network, then retry.");
   }
   const contentType = resp.headers.get("content-type");
   const text = await resp.text().catch(() => "");
   if (looksLikeMissingEndpoint(resp.status, contentType, text)) {
-    throw new DeviceFlowUnsupportedError();
+    throw new DeviceFlowUnsupportedError(resp.status);
   }
   if (!resp.ok) {
-    throw new Error(`Device authorize returned HTTP ${resp.status}: ${text}`);
+    if (resp.status === 403) {
+      if (protocol === "uba") {
+        let code;
+        try {
+          code = JSON.parse(text)?.code;
+        } catch {
+        }
+        const denial = ubaAuthorizationDenial(code);
+        throw new PermissionError(denial.message, denial.code, denial.hint);
+      }
+      throw new PermissionError("CLI authorization is not allowed.", "CLI_ACCESS_DISABLED", "Contact your administrator.");
+    }
+    throw new Error(`Device authorize returned HTTP ${resp.status}`);
   }
   let body;
   try {
@@ -113,23 +159,28 @@ async function authorizeDevice(host) {
   } catch {
     throw new Error("Device authorize returned invalid JSON");
   }
-  if (!body.device_code || !body.user_code) {
+  if (typeof body.device_code !== "string" || !body.device_code || typeof body.user_code !== "string" || !body.user_code) {
     throw new Error("Device authorize response missing required fields");
   }
+  if (protocol === "uba" && (!Number.isInteger(body.expires_in) || body.expires_in < 1 || body.expires_in > 300 || !Number.isInteger(body.interval) || body.interval < 1 || body.interval > body.expires_in)) {
+    throw new Error("UBA authorization returned invalid polling limits. Check the server deployment.");
+  }
   return body;
 }
-async function pollDeviceToken(host, deviceCode) {
+async function pollDeviceToken(host, deviceCode, protocol = "legacy") {
   const base = host.replace(/\/+$/, "");
-  const url = `${base}/api/auth/device/token`;
+  const url = `${base}${deviceApiPath(protocol, "token")}`;
   let resp;
   try {
     resp = await fetch(url, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ device_code: deviceCode })
+      body: JSON.stringify({ device_code: deviceCode }),
+      redirect: "error",
+      signal: AbortSignal.timeout(1e4)
     });
   } catch (e) {
-    return { status: "error", message: `Network error: ${e.message}` };
+    return { status: "error", message: "Network error while polling authorization." };
   }
   if (resp.status === 200) {
     let body;
@@ -138,7 +189,7 @@ async function pollDeviceToken(host, deviceCode) {
     } catch {
       return { status: "error", message: "Token response is not valid JSON" };
     }
-    if (!body.access_token) {
+    if (typeof body.access_token !== "string" || !body.access_token) {
       return { status: "error", message: "Token response missing access_token" };
     }
     return { status: "approved", tokens: body };
@@ -154,7 +205,13 @@ async function pollDeviceToken(host, deviceCode) {
     if (err === "authorization_pending") return { status: "pending" };
     if (err === "slow_down") return { status: "slow_down" };
     if (err === "expired_token") return { status: "expired" };
-    return { status: "error", message: `Unknown error: ${err ?? "unknown"}` };
+    if (err === "access_denied") return {
+      status: "denied",
+      code: "AUTHORIZATION_DENIED",
+      message: "Device authorization was denied.",
+      hint: "Run ae-cli auth login again only when you want to request authorization."
+    };
+    return { status: "error", message: "Token endpoint returned an unrecognized authorization error." };
   }
   if (resp.status === 403) {
     let errorBody = {};
@@ -162,6 +219,7 @@ async function pollDeviceToken(host, deviceCode) {
       errorBody = await resp.json();
     } catch {
     }
+    if (protocol === "uba") return { status: "denied", ...ubaAuthorizationDenial(errorBody.code) };
     return {
       status: "denied",
       code: errorBody.code ?? "CLI_ACCESS_DISABLED",
@@ -176,7 +234,10 @@ async function pollDeviceToken(host, deviceCode) {
   }
   return { status: "error", message: `Unexpected HTTP ${resp.status} from token endpoint` };
 }
-function buildVerificationUrl(host, userCode) {
+function buildVerificationUrl(host, userCode, protocol = "legacy") {
+  if (protocol === "uba") {
+    return `${host.replace(/\/+$/, "")}/#/cli/device-activate?user_code=${encodeURIComponent(userCode)}`;
+  }
   return `${host.replace(/\/+$/, "")}/device-activate?user_code=${encodeURIComponent(userCode)}`;
 }
 async function pollDeviceFlow(host, deviceCode, options = {}, onStatus) {
@@ -190,7 +251,7 @@ async function pollDeviceFlow(host, deviceCode, options = {}, onStatus) {
   while (Date.now() < deadline) {
     await sleep(intervalMs);
     pollCount++;
-    const result = await pollDeviceToken(host, deviceCode);
+    const result = await pollDeviceToken(host, deviceCode, options.protocol);
     if (result.status === "approved") {
       emit(`Authorization successful! (polled ${pollCount} time(s))`);
       return result.tokens;
@@ -237,9 +298,9 @@ async function runDeviceFlow(host, options = {}, onStatus) {
     if (onStatus) onStatus(msg);
   };
   emit("Requesting authorization code from server...");
-  const auth = await authorizeDevice(host);
+  const auth = options.authorization ?? await authorizeDevice(host, options.protocol);
   const userCode = auth.user_code;
-  const verifyUrl = buildVerificationUrl(host, userCode);
+  const verifyUrl = buildVerificationUrl(host, userCode, options.protocol);
   const expiresIn = auth.expires_in ?? 300;
   emit("");
   emit(`Verification code: ${userCode}`);
@@ -255,21 +316,47 @@ async function runDeviceFlow(host, options = {}, onStatus) {
     }
     emit("");
   }
-  return pollDeviceFlow(host, auth.device_code, { intervalMs: (auth.interval ?? 5) * 1e3, expiresIn }, onStatus);
+  return pollDeviceFlow(host, auth.device_code, { intervalMs: (auth.interval ?? 5) * 1e3, expiresIn, protocol: options.protocol }, onStatus);
 }
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/core/login-device-flow.ts
+function resolveLegacyLoginBase(host) {
+  const base = host.replace(/\/+$/, "");
+  const basePath = process.env.TE_CLAUDE_BASE_PATH || "/agent";
+  return base.endsWith(basePath) ? base : base + basePath;
+}
+function resolveDeviceSessionRoute(host, deviceCode) {
+  return deviceCode.startsWith("uba_") ? { baseUrl: host, protocol: "uba" } : { baseUrl: resolveLegacyLoginBase(host), protocol: "legacy" };
+}
+async function authorizeLoginDevice(host) {
+  try {
+    const authorization = await authorizeDevice(host, "uba");
+    if (!/^uba_[A-Za-z0-9_-]+$/.test(authorization.device_code)) {
+      throw new Error("UBA authorization returned an unsupported device-code format. Check the server deployment.");
+    }
+    return { baseUrl: host, protocol: "uba", authorization };
+  } catch (error) {
+    if (!(error instanceof DeviceFlowUnsupportedError) || error.httpStatus !== 404) throw error;
+    const baseUrl = resolveLegacyLoginBase(host);
+    return { baseUrl, protocol: "legacy", authorization: await authorizeDevice(baseUrl) };
+  }
+}
+
 // src/commands/auth.ts
 var HOST_OPTION_DESC = "Override active AE host URL (e.g., https://ta.thinkingdata.cn)";
+function shellArgument(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
 function getExplicitAuthHostOverride(program, opts) {
   return opts.host || program.opts().host;
 }
 function resolveAuthHost(program, opts) {
   return resolveHost(getExplicitAuthHostOverride(program, opts));
 }
-async function validateExistingCliToken(host, cliToken) {
+async function validateExistingCliToken(host, cliToken, external = false) {
   try {
     return { valid: true, trusted: false, details: await validateCliTokenOnServer(host, cliToken) };
   } catch (error) {
@@ -286,7 +373,7 @@ async function validateExistingCliToken(host, cliToken) {
     printError(
       "auth",
       error.message,
-      `Run: ae-cli auth logout --host ${host}, then ae-cli auth login --host ${host}`
+      external ? "Replace the external CLI token with a valid token for this host." : `Run: ae-cli auth logout --host ${host}, then ae-cli auth login --host ${host}`
     );
     process.exitCode = 1;
     return { valid: false, trusted: false, details: {} };
@@ -506,12 +593,16 @@ function manualTokenSummary(host, credential) {
   };
 }
 function resolveLoginTeClaudeBase(host) {
-  const base = host.replace(/\/+$/, "");
-  const basePath = process.env.TE_CLAUDE_BASE_PATH || "/agent";
-  return base.endsWith(basePath) ? base : base + basePath;
+  return resolveLegacyLoginBase(host);
 }
 function registerAuth(program) {
   const auth = program.command("auth").description("Manage authentication or switch the active account interactively").hook("preAction", (_command, actionCommand) => {
+    if (["auth", "login", "set-token", "use", "logout"].includes(actionCommand.name()) && readExternalCliToken()) {
+      throw new ExternalCliTokenError(
+        "Stored-account changes are unavailable while an external CLI token is selected.",
+        "EXTERNAL_CLI_TOKEN_ACTIVE"
+      );
+    }
     if (["login", "set-token"].includes(actionCommand.name())) {
       const host = resolveAuthHost(program, actionCommand.opts());
       if (host) assertCredentialsReadable(host);
@@ -536,32 +627,37 @@ function registerAuth(program) {
     }
     const noBrowser = !opts.browser;
     const format = program.opts().format || "json";
-    const teClaudeBase = resolveLoginTeClaudeBase(host);
     const emit = (message) => process.stderr.write(`[ae-cli] ${message}
 `);
     try {
       if (opts.deviceCode) {
-        const tokens2 = await pollDeviceFlow(teClaudeBase, opts.deviceCode, {}, emit);
+        const route = resolveDeviceSessionRoute(host, opts.deviceCode);
+        const tokens2 = await pollDeviceFlow(route.baseUrl, opts.deviceCode, { protocol: route.protocol }, emit);
         const saved2 = await persistDeviceTokens(host, tokens2, { add: opts.add });
         activateHostAfterLogin(host, explicitHost);
         emit("Login successful! CLI token saved securely.");
         await printOutput(loginSummary(host, saved2), format);
         return;
       }
+      const session = await authorizeLoginDevice(host);
+      const authResp = session.authorization;
       if (opts.wait === false) {
-        const authResp = await authorizeDevice(teClaudeBase);
         const addFlag = opts.add ? " --add" : "";
         await printOutput({
           device_code: authResp.device_code,
           user_code: authResp.user_code,
-          verification_url: buildVerificationUrl(teClaudeBase, authResp.user_code),
+          verification_url: buildVerificationUrl(session.baseUrl, authResp.user_code, session.protocol),
           interval: authResp.interval,
           expires_in: authResp.expires_in,
-          next: `Open verification_url in a browser to authorize, then run: ae-cli auth login${addFlag} --device-code ${authResp.device_code}`
+          next: `Open verification_url in a browser to authorize, then run: ae-cli auth login${addFlag} --host ${shellArgument(host)} --device-code ${shellArgument(authResp.device_code)}`
         }, format);
         return;
       }
-      const tokens = await runDeviceFlow(teClaudeBase, { noBrowser }, emit);
+      const tokens = await runDeviceFlow(session.baseUrl, {
+        noBrowser,
+        protocol: session.protocol,
+        authorization: authResp
+      }, emit);
       const saved = await persistDeviceTokens(host, tokens, { add: opts.add });
       activateHostAfterLogin(host, explicitHost);
       emit("Login successful! CLI token saved securely.");
@@ -644,6 +740,22 @@ function registerAuth(program) {
       }, program.opts().format || "json");
       return;
     }
+    const external = readExternalCliToken(host);
+    if (external) {
+      const state = await validateExistingCliToken(host, external.token, true);
+      if (!state.valid) return;
+      await printOutput({
+        authenticated: true,
+        host,
+        source: external.source,
+        cli_token: {
+          status: state.trusted ? "trusted" : "valid",
+          ...state.details.cliTokenExpiresAt ? { expires_at: state.details.cliTokenExpiresAt } : {}
+        },
+        ...state.details.account ? { account: accountOutput(state.details.account) } : {}
+      }, program.opts().format || "json");
+      return;
+    }
     const active = getActiveCredential(host);
     if (active) {
       const state = await validateExistingCliToken(host, active.cliToken);