@thinkingai/ae-cli 6.0.20 → 6.0.24

package/README.md

@@ -67,12 +67,9 @@ ae-cli kb +read --source '{"scope":"company","name":"engineering-handbook"}' \
 Authentication is handled per-host. Each AE host URL maintains its own token.
 
 ```bash
-# Auto-login for active host (macOS, extracts token from Chrome)
+# Device code login (cross-platform)
 ae-cli auth login
 
-# Manually set token
-ae-cli auth set-token <your-token>
-
 # Check status
 ae-cli auth status
 

package/README.zh.md

@@ -67,12 +67,9 @@ ae-cli kb +read --source '{"scope":"company","name":"engineering-handbook"}' \
 每个 AE 主机 URL 维护独立的身份验证 token。
 
 ```bash
-# 自动登录当前主机（macOS，从 Chrome 提取 token）
+# 设备码登录（跨平台）
 ae-cli auth login
 
-# 手动设置 token
-ae-cli auth set-token <your-token>
-
 # 检查状态
 ae-cli auth status
 

package/dist/{auth-GHBMJ5ZR.js → auth-A2XXG5K4.js}

@@ -1,30 +1,24 @@
 import {
   printError,
   printOutput
-} from "./chunk-2DUEAXV3.js";
+} from "./chunk-ONOA6DYB.js";
 import {
-  clearMcpToken,
-  setMcpTokenManual,
-  validateMcpToken
-} from "./chunk-DMMEPCST.js";
-import "./chunk-PN3OS34E.js";
-import "./chunk-NOO24N7W.js";
+  clearCliToken,
+  mintCliToken
+} from "./chunk-OCQPQYHZ.js";
 import {
   clear,
-  clearToken,
-  getAuthStatus,
   load,
   resolveHost,
-  save,
-  setTokenManual,
-  validateToken
-} from "./chunk-RSHMZ3LG.js";
+  save
+} from "./chunk-PFJFZVCK.js";
 import {
+  getFallbackCliToken,
   loadConfig,
   logger,
   removeHost,
   saveConfig
-} from "./chunk-6W4QOZAL.js";
+} from "./chunk-65DKFJZB.js";
 
 // src/core/device-auth.ts
 import { execFileSync } from "child_process";
@@ -246,7 +240,7 @@ function activateHostAfterLogin(host, explicitHostOverride) {
   saveConfig(config);
   logger.info(`Active host set to ${host} after login`);
 }
-function persistDeviceTokens(host, tokens) {
+async function persistDeviceTokens(host, tokens) {
   const DEFAULT_EXPIRES_IN = 72e3;
   const MAX_EXPIRES_IN = 86400 * 365;
   let expiresInSeconds = tokens.expires_in ?? DEFAULT_EXPIRES_IN;
@@ -258,16 +252,15 @@ function persistDeviceTokens(host, tokens) {
   save(host, {
     accessToken: tokens.access_token,
     refreshToken: tokens.refresh_token ?? "",
-    accessExpiresAt: expiresAt,
-    mcpToken: tokens.mcp_token ?? void 0
+    accessExpiresAt: expiresAt
   });
+  await mintCliToken(host);
 }
 function loginSummary(host, tokens) {
   return {
     authenticated: true,
     host,
-    token: tokens.access_token.slice(0, 8) + "...",
-    mcpToken: tokens.mcp_token ? tokens.mcp_token.slice(0, 8) + "..." : null
+    token: tokens.access_token.slice(0, 8) + "..."
   };
 }
 function resolveLoginTeClaudeBase(host) {
@@ -303,7 +296,7 @@ function registerAuth(program) {
     try {
       if (opts.deviceCode) {
         const tokens2 = await pollDeviceFlow(teClaudeBase, opts.deviceCode, {}, emit);
-        persistDeviceTokens(host, tokens2);
+        await persistDeviceTokens(host, tokens2);
         activateHostAfterLogin(host, explicitHost);
         logger.info(`Device flow login successful for ${host} (resumed)`);
         emit("Login successful! Token saved securely.");
@@ -326,7 +319,7 @@ function registerAuth(program) {
         return;
       }
       const tokens = await runDeviceFlow(teClaudeBase, { noBrowser }, emit);
-      persistDeviceTokens(host, tokens);
+      await persistDeviceTokens(host, tokens);
       activateHostAfterLogin(host, explicitHost);
       logger.info(`Device flow login successful for ${host}`);
       emit("Login successful! Token saved securely.");
@@ -336,7 +329,7 @@ function registerAuth(program) {
         printError(
           "auth",
           err.message,
-          "Use `ae-cli auth set-token <token>` to authenticate, or upgrade the AE server to a version that supports device login."
+          "Upgrade the AE server to a version that supports device login."
         );
         process.exit(1);
       }
@@ -344,39 +337,6 @@ function registerAuth(program) {
       process.exit(1);
     }
   });
-  auth.command("set-token <token>").description("Manually set authentication token for a host (--host or active host)").option("--host <url>", HOST_OPTION_DESC).action(async (token, opts) => {
-    const host = resolveAuthHost(program, opts);
-    if (!host) {
-      printError("config", "No AE host configured.", "Run: ae-cli config set-host <url>");
-      process.exit(1);
-    }
-    const config = loadConfig();
-    if (!config.hosts[host]) {
-      config.hosts[host] = { label: host };
-      if (!config.activeHost) {
-        config.activeHost = host;
-      }
-      saveConfig(config);
-      process.stderr.write(`[ae-cli] Config saved for ${host}
-`);
-      printOutput({ saved: true, config }, program.opts().format || "json");
-    }
-    process.stderr.write(`[ae-cli] Validating token...
-`);
-    const isValid = await validateToken(token, host);
-    if (!isValid) {
-      logger.warn(`Token validation failed for ${host}`);
-      process.stderr.write(`[ae-cli] Token validation failed
-`);
-      printError("auth", "Invalid token", "Please check your token and try again");
-      process.exit(1);
-    }
-    setTokenManual(token, host);
-    logger.info(`Token manually set and validated for ${host}`);
-    process.stderr.write(`[ae-cli] Token verified and saved for ${host}
-`);
-    printOutput({ saved: true, host, verified: true }, program.opts().format || "json");
-  });
   auth.command("status").description("Show authentication status for a host (--host or active host)").option("--host <url>", HOST_OPTION_DESC).action(async (opts) => {
     const host = resolveAuthHost(program, opts);
     if (!host) {
@@ -394,74 +354,38 @@ function registerAuth(program) {
           accessExpiresAt: secureEntry.accessExpiresAt,
           accessExpiresAtNote: "advisory: access token auto-slides on use server-side; re-login only if a command returns an auth error",
           pastStaticExpiry,
-          hasMcpToken: !!secureEntry.mcpToken
+          hasCliToken: !!secureEntry.cliToken
+        },
+        program.opts().format || "json"
+      );
+      return;
+    }
+    const fallbackCliToken = getFallbackCliToken(host);
+    if (fallbackCliToken) {
+      printOutput(
+        {
+          authenticated: true,
+          host,
+          source: "sandbox-cli-token",
+          hasCliToken: true,
+          note: "sandbox-provisioned cli-token.json; no user access token in secure-store"
         },
         program.opts().format || "json"
       );
       return;
     }
-    const tokenStatus = getAuthStatus(host);
-    const authenticated = tokenStatus.authenticated;
-    printOutput({ authenticated, host, source: tokenStatus.source ?? "none" }, program.opts().format || "json");
+    printOutput({ authenticated: false, host, source: "none" }, program.opts().format || "json");
   });
-  auth.command("logout").description("Clear stored token for a host (--host or active host)").option("--host <url>", HOST_OPTION_DESC).action((opts) => {
+  auth.command("logout").description("Clear stored credentials (access token, CLI token, and host config) for a host (--host or active host)").option("--host <url>", HOST_OPTION_DESC).action((opts) => {
     const host = resolveAuthHost(program, opts);
     if (!host) {
       printError("config", "No AE host configured.", "Run: ae-cli config set-host <url>");
       process.exit(1);
     }
-    clearToken(host);
+    clearCliToken(host);
     clear(host);
     removeHost(host);
-    process.stderr.write(`[ae-cli] Token and config cleared for ${host}
-`);
-    printOutput({ cleared: true, host }, program.opts().format || "json");
-  });
-  auth.command("set-mcp-token <token>").description("Manually set MCP token for a host (--host or active host)").option("--host <url>", HOST_OPTION_DESC).action(async (token, opts) => {
-    const host = resolveAuthHost(program, opts);
-    if (!host) {
-      printError("config", "No AE host configured.", "Use --host <url> or run: ae-cli config set-host <url>");
-      process.exit(1);
-    }
-    const config = loadConfig();
-    if (!config.hosts[host]) {
-      config.hosts[host] = { label: host };
-      if (!config.activeHost) {
-        config.activeHost = host;
-      }
-      saveConfig(config);
-      process.stderr.write(`[ae-cli] Host config saved for ${host}
-`);
-    }
-    process.stderr.write(`[ae-cli] Validating MCP token...
-`);
-    const isValid = await validateMcpToken(token, host);
-    if (!isValid) {
-      process.stderr.write(`[ae-cli] MCP token validation failed
-`);
-      printError("auth", "Invalid MCP token", "Please check your MCP token and try again");
-      process.exit(1);
-    }
-    setMcpTokenManual(token, host);
-    process.stderr.write(`[ae-cli] MCP token verified and saved for ${host}
-`);
-    printOutput({ saved: true, host, verified: true, type: "mcp-token" }, program.opts().format || "json");
-  });
-  auth.command("clear-mcp-token").description("Clear stored MCP token for a host (--host or active host; --all clears all)").option("--host <url>", HOST_OPTION_DESC).option("--all", "Clear MCP tokens for all hosts").action((opts) => {
-    if (opts.all) {
-      clearMcpToken();
-      process.stderr.write(`[ae-cli] All MCP tokens cleared
-`);
-      printOutput({ cleared: true, type: "all-mcp-tokens" }, program.opts().format || "json");
-      return;
-    }
-    const host = resolveAuthHost(program, opts);
-    if (!host) {
-      printError("config", "No AE host configured.", "Use --host <url> or run: ae-cli config set-host <url>");
-      process.exit(1);
-    }
-    clearMcpToken(host);
-    process.stderr.write(`[ae-cli] MCP token cleared for ${host}
+    process.stderr.write(`[ae-cli] Credentials and config cleared for ${host}
 `);
     printOutput({ cleared: true, host }, program.opts().format || "json");
   });

package/dist/auth-IDPKDFSY.js

@@ -0,0 +1,13 @@
+import {
+  getToken,
+  invalidateAccessTokenForRetry,
+  resolveHost,
+  validateToken
+} from "./chunk-PFJFZVCK.js";
+import "./chunk-65DKFJZB.js";
+export {
+  getToken,
+  invalidateAccessTokenForRetry,
+  resolveHost,
+  validateToken
+};

package/dist/chunk-2OW2RENH.js

@@ -0,0 +1,193 @@
+import {
+  PermissionError
+} from "./chunk-NOO24N7W.js";
+import {
+  clearCliToken,
+  getCliToken
+} from "./chunk-OCQPQYHZ.js";
+import {
+  logger,
+  safeJsonParse
+} from "./chunk-65DKFJZB.js";
+
+// src/core/capability-api.ts
+import { readFile } from "fs/promises";
+import { basename } from "path";
+var CapabilityGatewayError = class extends Error {
+  constructor(message, code, httpStatus, hint) {
+    super(message);
+    this.code = code;
+    this.httpStatus = httpStatus;
+    this.hint = hint;
+    this.name = "CapabilityGatewayError";
+  }
+  code;
+  httpStatus;
+  hint;
+};
+function buildCapabilityGatewayUrl(host, domain, pathAfterV1, queryParams = {}) {
+  const base = host.replace(/\/+$/, "");
+  const cleanDomain = domain.replace(/^\/+|\/+$/g, "");
+  const cleanPath = pathAfterV1.replace(/^\/+|\/+$/g, "");
+  const gatewayPrefix = cleanDomain === "" ? "/api/cli/v1" : `/api/cli/${cleanDomain}/v1`;
+  const url = new URL(`${base}${gatewayPrefix}/${cleanPath}`);
+  for (const [key, value] of Object.entries(queryParams)) {
+    if (value !== void 0 && value !== null) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+async function permissionMessage(resp) {
+  const text = await resp.text().catch(() => "");
+  try {
+    const d = safeJsonParse(text);
+    const msg = d && (d.error?.message || (typeof d.error === "string" ? d.error : void 0) || d.message);
+    if (msg && typeof msg === "string") return msg;
+  } catch {
+  }
+  return "Permission denied for this resource (HTTP 403)";
+}
+function parseCapabilityResponse(text) {
+  if (!text) return void 0;
+  try {
+    return safeJsonParse(text);
+  } catch {
+    return text;
+  }
+}
+function unwrapCapabilityEnvelope(body) {
+  if (body == null) {
+    throw new CapabilityGatewayError("Empty capability gateway response");
+  }
+  if (typeof body.ok === "boolean") {
+    if (body.ok) {
+      return body.data;
+    }
+    const err = body.error ?? {};
+    const code = nonEmptyString(err.code);
+    const message = nonEmptyString(err.message) ?? code ?? "Capability gateway request failed";
+    const hint = nonEmptyString(err.hint);
+    throw new CapabilityGatewayError(message, code, err.http_status ?? err.httpStatus, hint);
+  }
+  return body;
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function buildCapabilityHttpError(resp, body) {
+  const fallback = `Capability gateway HTTP error: ${resp.status} ${resp.statusText}`.trim();
+  if (body && typeof body === "object") {
+    const err = body.error ?? body.data?.error ?? body;
+    const code = nonEmptyString(err.code) ?? nonEmptyString(err.errorCode) ?? nonEmptyString(body.code);
+    const message = nonEmptyString(err.message) ?? nonEmptyString(body.message);
+    const hint = nonEmptyString(err.hint) ?? nonEmptyString(body.hint);
+    const details = [code, message, hint ? `Hint: ${hint}` : void 0].filter(Boolean);
+    if (details.length > 0) {
+      return new CapabilityGatewayError(message ?? fallback, code, resp.status, hint);
+    }
+  }
+  if (typeof body === "string" && body.trim()) {
+    return new CapabilityGatewayError(`${fallback}: ${body.slice(0, 500)}`, void 0, resp.status);
+  }
+  return new CapabilityGatewayError(fallback, void 0, resp.status);
+}
+async function throwCapabilityHttpError(resp) {
+  const body = parseCapabilityResponse(await resp.text());
+  throw buildCapabilityHttpError(resp, body);
+}
+async function requestOnce(url, method, token, body) {
+  const headers = {
+    "cli-token": token,
+    "Accept": "application/json"
+  };
+  const init = { method, headers };
+  if (body !== void 0 && method !== "GET") {
+    headers["Content-Type"] = "application/json";
+    init.body = JSON.stringify(body);
+  }
+  return fetch(url, init);
+}
+async function requestMultipartOnce(url, token, form) {
+  return fetch(url, {
+    method: "POST",
+    headers: {
+      "cli-token": token,
+      "Accept": "application/json"
+    },
+    body: form
+  });
+}
+async function callGateway(host, domain, pathAfterV1, method, body) {
+  const url = buildCapabilityGatewayUrl(host, domain, pathAfterV1);
+  const token = await getCliToken(host);
+  let resp = await requestOnce(url, method, token, body);
+  if (resp.status === 403) {
+    throw new PermissionError(await permissionMessage(resp));
+  }
+  if (resp.status === 401) {
+    logger.warn(`Capability gateway request failed (HTTP 401) for ${host}, refreshing CLI token`);
+    clearCliToken(host);
+    const newToken = await getCliToken(host);
+    process.stderr.write(`[ae-cli] CLI token refreshed for ${host}
+`);
+    resp = await requestOnce(url, method, newToken, body);
+    if (resp.status === 403) {
+      throw new PermissionError(await permissionMessage(resp));
+    }
+    if (!resp.ok) {
+      await throwCapabilityHttpError(resp);
+    }
+  } else if (!resp.ok) {
+    await throwCapabilityHttpError(resp);
+  }
+  return unwrapCapabilityEnvelope(parseCapabilityResponse(await resp.text()));
+}
+async function executeCapability(host, domain, capabilityId, input = {}) {
+  return callGateway(host, domain, `capabilities/${capabilityId}/execute`, "POST", { input });
+}
+async function uploadInputFile(host, domain, projectId, purpose, filePath) {
+  const fileBytes = await readFile(filePath);
+  return uploadInputFileBytes(host, domain, projectId, purpose, fileBytes, basename(filePath));
+}
+async function uploadInputFileBytes(host, domain, projectId, purpose, bytes, filename, contentType = "application/octet-stream") {
+  const url = buildCapabilityGatewayUrl(host, domain, "input-files");
+  const fileBuffer = bytes instanceof ArrayBuffer ? bytes : bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength
+  );
+  const form = new FormData();
+  form.append("project_id", String(projectId));
+  form.append("purpose", purpose);
+  form.append("file", new Blob([fileBuffer], { type: contentType }), filename);
+  const token = await getCliToken(host);
+  let resp = await requestMultipartOnce(url, token, form);
+  if (resp.status === 403) {
+    throw new PermissionError(await permissionMessage(resp));
+  }
+  if (resp.status === 401) {
+    logger.warn(`Capability gateway request failed (HTTP 401) for ${host}, refreshing CLI token`);
+    clearCliToken(host);
+    const newToken = await getCliToken(host);
+    process.stderr.write(`[ae-cli] CLI token refreshed for ${host}
+`);
+    resp = await requestMultipartOnce(url, newToken, form);
+    if (resp.status === 403) {
+      throw new PermissionError(await permissionMessage(resp));
+    }
+    if (!resp.ok) {
+      await throwCapabilityHttpError(resp);
+    }
+  } else if (!resp.ok) {
+    await throwCapabilityHttpError(resp);
+  }
+  return unwrapCapabilityEnvelope(parseCapabilityResponse(await resp.text()));
+}
+
+export {
+  CapabilityGatewayError,
+  buildCapabilityGatewayUrl,
+  executeCapability,
+  uploadInputFile,
+  uploadInputFileBytes
+};

package/dist/{chunk-I5CRVM2S.js → chunk-4FQ36OGO.js}

@@ -1,7 +1,7 @@
 import {
   getActiveHost,
   getSandboxRuntimeRoot
-} from "./chunk-6W4QOZAL.js";
+} from "./chunk-65DKFJZB.js";
 
 // src/core/te-agent-credentials.ts
 import { readFileSync } from "fs";
@@ -134,39 +134,66 @@ function teClaudeBaseFromActiveHost() {
 async function signRequest(method, path, rawBody) {
   const sandboxCred = tryLoadTeAgentSandboxCredentials();
   if (sandboxCred && sandboxCred.sandboxId && sandboxCred.sandboxSecretKey) {
-    const headers2 = {
+    const headers = {
       "X-Sandbox-Id": sandboxCred.sandboxId,
       "X-Sandbox-Secret-Key": sandboxCred.sandboxSecretKey
     };
     if (method === "POST" || method === "PATCH") {
-      headers2["Content-Type"] = "application/json";
+      headers["Content-Type"] = "application/json";
     }
     return {
       url: `${sandboxCred.url.replace(/\/$/, "")}${path}`,
-      headers: headers2,
+      headers,
       rawBody
     };
   }
-  const { getToken } = await import("./auth-DYC2BGLM.js");
+  const { getToken } = await import("./auth-IDPKDFSY.js");
+  const { getCliToken } = await import("./cli-token-OZXHC3U2.js");
   const baseUrl = sandboxCred?.url || teClaudeBaseFromActiveHost();
+  const hostForToken = getActiveHost() || baseUrl;
   if (!baseUrl) {
     throw new TeAgentCredentialsError(
       "Cannot determine the te-claude service URL",
       "Run ae-cli config set-host <url> to configure the service URL, or execute inside a te-agent sandbox"
     );
   }
-  const accessToken = await getToken(getActiveHost() || baseUrl);
-  const headers = {
-    "Authorization": `bearer ${accessToken}`
-  };
-  if (method === "POST" || method === "PATCH") {
-    headers["Content-Type"] = "application/json";
+  const contentTypeHeader = method === "POST" || method === "PATCH" ? { "Content-Type": "application/json" } : {};
+  let accessToken = null;
+  try {
+    accessToken = await getToken(hostForToken);
+  } catch {
+    accessToken = null;
   }
-  return {
-    url: `${baseUrl.replace(/\/$/, "")}${path}`,
-    headers,
-    rawBody
-  };
+  if (accessToken) {
+    return {
+      url: `${baseUrl.replace(/\/$/, "")}${path}`,
+      headers: {
+        "Authorization": `bearer ${accessToken}`,
+        ...contentTypeHeader
+      },
+      rawBody
+    };
+  }
+  let cliToken = null;
+  try {
+    cliToken = await getCliToken(hostForToken);
+  } catch {
+    cliToken = null;
+  }
+  if (cliToken) {
+    return {
+      url: `${baseUrl.replace(/\/$/, "")}${path}`,
+      headers: {
+        "cli-token": cliToken,
+        ...contentTypeHeader
+      },
+      rawBody
+    };
+  }
+  throw new TeAgentCredentialsError(
+    "No te-claude credentials available",
+    "Run ae-cli auth login, or execute inside a te-agent sandbox"
+  );
 }
 async function parseResponse(response, defaultErrorPrefix) {
   const text = await response.text();
@@ -266,7 +293,7 @@ async function uploadToMainApp(path, formData) {
       "X-Sandbox-Secret-Key": sandboxCred.sandboxSecretKey
     };
   } else {
-    const { getToken } = await import("./auth-DYC2BGLM.js");
+    const { getToken } = await import("./auth-IDPKDFSY.js");
     baseUrl = (sandboxCred?.url || teClaudeBaseFromActiveHost() || "").replace(/\/$/, "");
     if (!baseUrl) {
       throw new TeAgentCredentialsError(

package/dist/{chunk-6W4QOZAL.js → chunk-65DKFJZB.js}

@@ -108,8 +108,8 @@ function getSandboxRuntimeRoot() {
 function getSandboxAeConfigDir() {
   return join(getSandboxRuntimeRoot(), ".ae-config");
 }
-function getSandboxMcpTokenFilePath() {
-  return join(getSandboxAeConfigDir(), "mcp-token.json");
+function getSandboxCliTokenFilePath() {
+  return join(getSandboxAeConfigDir(), "cli-token.json");
 }
 function getSandboxClusterInfoFilePath() {
   return join(getSandboxAeConfigDir(), "cluster-info.json");
@@ -118,22 +118,22 @@ function getSandboxClusterInfoFilePath() {
 // src/core/config.ts
 var CONFIG_DIR = path2.join(process.env.HOME || "", ".ae-cli");
 var CONFIG_FILE = path2.join(CONFIG_DIR, "config.json");
-function sandboxMcpTokenCandidatePaths() {
-  const paths = [getSandboxMcpTokenFilePath()];
-  const homeFallback = path2.join(process.env.HOME || "", ".ae-config", "mcp-token.json");
+function sandboxCliTokenCandidatePaths() {
+  const paths = [getSandboxCliTokenFilePath()];
+  const homeFallback = path2.join(process.env.HOME || "", ".ae-config", "cli-token.json");
   if (!paths.includes(homeFallback)) {
     paths.push(homeFallback);
   }
   return paths;
 }
-function readSandboxMcpTokenEntry() {
-  for (const file of sandboxMcpTokenCandidatePaths()) {
+function readSandboxCliTokenEntry() {
+  for (const file of sandboxCliTokenCandidatePaths()) {
     if (!fs3.existsSync(file)) continue;
     try {
       const data = safeReadJsonFile(file);
       if (data && typeof data === "object" && !Array.isArray(data)) {
         const url = data.url;
-        const token = data["mcp-token"];
+        const token = data.token;
         if (url && token) {
           return { url, token };
         }
@@ -143,15 +143,12 @@ function readSandboxMcpTokenEntry() {
   }
   return null;
 }
-function ensureDir() {
-  if (!fs3.existsSync(CONFIG_DIR)) fs3.mkdirSync(CONFIG_DIR, { recursive: true });
-}
 function forceMigrateFromFallback() {
-  const entry = readSandboxMcpTokenEntry();
+  const entry = readSandboxCliTokenEntry();
   if (!entry) return null;
   return { [entry.url]: entry.token };
 }
-function getFallbackMcpToken(hostUrl) {
+function getFallbackCliToken(hostUrl) {
   const store = forceMigrateFromFallback();
   if (!store) return null;
   if (hostUrl && store[hostUrl]) return store[hostUrl];
@@ -159,6 +156,9 @@ function getFallbackMcpToken(hostUrl) {
   if (entries.length === 1) return entries[0];
   return null;
 }
+function ensureDir() {
+  if (!fs3.existsSync(CONFIG_DIR)) fs3.mkdirSync(CONFIG_DIR, { recursive: true });
+}
 function loadConfig() {
   try {
     if (fs3.existsSync(CONFIG_FILE)) {
@@ -197,9 +197,10 @@ function saveConfig(config) {
   logger.info(`Config saved: activeHost=${config.activeHost}, hosts=${Object.keys(config.hosts).length}`);
 }
 function getActiveHost() {
+  const sandboxHost = readSandboxCliTokenEntry()?.url;
+  if (sandboxHost) return sandboxHost;
   const config = loadConfig();
-  if (config.activeHost) return config.activeHost;
-  return readSandboxMcpTokenEntry()?.url ?? "";
+  return config.activeHost || "";
 }
 function setActiveHost(url) {
   const config = loadConfig();
@@ -233,6 +234,14 @@ function removeHost(url) {
   }
   saveConfig(config);
 }
+function listHosts() {
+  const config = loadConfig();
+  return Object.entries(config.hosts).map(([url, entry]) => ({
+    url,
+    label: entry.label,
+    active: url === config.activeHost
+  }));
+}
 function getConfigDir() {
   return CONFIG_DIR;
 }
@@ -243,12 +252,13 @@ export {
   safeReadJsonFile,
   getSandboxRuntimeRoot,
   getSandboxClusterInfoFilePath,
-  getFallbackMcpToken,
+  getFallbackCliToken,
   loadConfig,
   saveConfig,
   getActiveHost,
   setActiveHost,
   addHost,
   removeHost,
+  listHosts,
   getConfigDir
 };