@thinkingai/ae-cli 1.0.27 → 1.0.30

package/dist/chunk-U6TKB3IV.js

@@ -0,0 +1,171 @@
+import {
+  SecureStoreAuthError,
+  getValidAccessToken
+} from "./chunk-JM34JPCO.js";
+import {
+  getActiveHost,
+  getConfigDir,
+  logger,
+  safeJsonParse,
+  safeReadJsonFile
+} from "./chunk-SRJIAOBN.js";
+
+// src/core/auth.ts
+import fs from "fs";
+import path from "path";
+var TOKENS_FILE = path.join(getConfigDir(), "tokens.json");
+var LEGACY_MCP_TOKENS_FILE = path.join(getConfigDir(), "mcp-tokens.json");
+var LEGACY_DIR = path.join(process.env.HOME || "", ".te-mcp");
+(function removeLegacyMcpTokens() {
+  try {
+    if (fs.existsSync(LEGACY_MCP_TOKENS_FILE)) {
+      fs.rmSync(LEGACY_MCP_TOKENS_FILE);
+      logger.info("auth: removed legacy mcp-tokens.json (plaintext MCP token file)");
+    }
+  } catch {
+  }
+})();
+function ensureDir() {
+  const dir = getConfigDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+function resolveHost(hostOverride) {
+  if (hostOverride) return hostOverride;
+  return getActiveHost();
+}
+async function validateToken(token, hostUrl) {
+  const url = `${hostUrl}/v1/oauth/checkToken`;
+  try {
+    const resp = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({ accessToken: token }).toString()
+    });
+    const respJson = safeJsonParse(await resp.text());
+    return respJson?.return_code === 0;
+  } catch {
+    return false;
+  }
+}
+function loadAllTokens() {
+  try {
+    const legacyTokens = path.join(LEGACY_DIR, "tokens.json");
+    if (fs.existsSync(legacyTokens) && !fs.existsSync(TOKENS_FILE)) {
+      const data = safeReadJsonFile(legacyTokens);
+      const migrated = {};
+      for (const [key, val] of Object.entries(data)) {
+        const url = key.startsWith("http") ? key : `https://${key}`;
+        migrated[url] = val;
+      }
+      ensureDir();
+      fs.writeFileSync(TOKENS_FILE, JSON.stringify(migrated, null, 2));
+      return migrated;
+    }
+    if (fs.existsSync(TOKENS_FILE)) {
+      const data = safeReadJsonFile(TOKENS_FILE);
+      let needsMigration = false;
+      const migrated = {};
+      for (const [key, val] of Object.entries(data)) {
+        if (!key.startsWith("http")) {
+          migrated[`https://${key}`] = val;
+          needsMigration = true;
+        } else {
+          migrated[key] = val;
+        }
+      }
+      if (needsMigration) {
+        fs.writeFileSync(TOKENS_FILE, JSON.stringify(migrated, null, 2));
+        return migrated;
+      }
+      return data;
+    }
+  } catch {
+  }
+  return {};
+}
+function saveAllTokens(tokens) {
+  ensureDir();
+  fs.writeFileSync(TOKENS_FILE, JSON.stringify(tokens, null, 2));
+  try {
+    fs.chmodSync(TOKENS_FILE, 384);
+  } catch {
+  }
+}
+function loadToken(hostUrl) {
+  const tokens = loadAllTokens();
+  const entry = tokens[hostUrl];
+  if (!entry || !entry.token) return null;
+  return { host: hostUrl, token: entry.token, updatedAt: entry.updatedAt };
+}
+function saveToken(token, hostUrl) {
+  const tokens = loadAllTokens();
+  tokens[hostUrl] = { token, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  saveAllTokens(tokens);
+  logger.info(`Token saved for ${hostUrl}`);
+}
+function clearToken(hostUrl) {
+  const tokens = loadAllTokens();
+  delete tokens[hostUrl];
+  saveAllTokens(tokens);
+}
+function setTokenManual(token, hostUrl) {
+  saveToken(token, hostUrl);
+}
+function getAuthStatus(hostUrl) {
+  if (process.env.TE_TOKEN) {
+    return { authenticated: true, host: hostUrl, source: "env:TE_TOKEN" };
+  }
+  const cached = loadToken(hostUrl);
+  if (cached) {
+    const ageMs = Date.now() - new Date(cached.updatedAt).getTime();
+    const hours = Math.round(ageMs / 36e5);
+    return { authenticated: true, host: hostUrl, tokenAge: `${hours}h ago`, source: "cache" };
+  }
+  return { authenticated: false, host: hostUrl };
+}
+async function getToken(hostUrl) {
+  if (!hostUrl) {
+    throw new Error(
+      `No AE host configured.
+Run: ae-cli config set-host <url>`
+    );
+  }
+  if (process.env.TE_TOKEN) {
+    logger.info("Using token from env:TE_TOKEN");
+    return process.env.TE_TOKEN;
+  }
+  const cached = loadToken(hostUrl);
+  if (cached && cached.token) {
+    logger.info(`Using cached token for ${hostUrl}`);
+    return cached.token;
+  }
+  try {
+    const secureToken = await getValidAccessToken(hostUrl);
+    logger.info(`Using secure-store token for ${hostUrl}`);
+    return secureToken;
+  } catch (e) {
+    if (e instanceof SecureStoreAuthError) {
+      logger.info(`secure-store: ${e.message}`);
+    } else {
+      logger.warn(`secure-store unexpected error: ${e.message}`);
+    }
+  }
+  throw new Error(
+    `Cannot obtain token for ${hostUrl}.
+Options:
+  1. ae-cli auth login   (device code flow, cross-platform)
+  2. ae-cli auth set-token <token>
+  3. export TE_TOKEN=<token>  (CI/headless)`
+  );
+}
+
+export {
+  resolveHost,
+  validateToken,
+  loadToken,
+  saveToken,
+  clearToken,
+  setTokenManual,
+  getAuthStatus,
+  getToken
+};

package/dist/{chunk-TG64AQV4.js → chunk-VJFUB3H3.js}

@@ -1,3 +1,8 @@
+import {
+  getActiveHost,
+  getSandboxRuntimeRoot
+} from "./chunk-SRJIAOBN.js";
+
 // src/core/te-agent-credentials.ts
 import { readFileSync } from "fs";
 import { homedir } from "os";
@@ -6,8 +11,7 @@ function getCredentialsPath() {
   return join(process.env.HOME || homedir(), ".te-agent", "credentials.json");
 }
 function getPersistentEnvPath() {
-  const runtimeRoot = process.env.SANDBOX_RUNTIME_ROOT ?? "/home/ta/te_agent_ta";
-  return join(runtimeRoot, ".env");
+  return join(getSandboxRuntimeRoot(), ".env");
 }
 function parseDotEnv(raw) {
   const result = {};
@@ -32,8 +36,8 @@ function readPersistentEnv() {
   } catch (err) {
     if (err?.code === "ENOENT") return null;
     throw new TeAgentCredentialsError(
-      `${envPath} \u8BFB\u53D6\u5931\u8D25\uFF1A${err?.message ?? err}`,
-      "\u8BF7\u68C0\u67E5\u6587\u4EF6\u6743\u9650\uFF0C\u6216\u901A\u8FC7 TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY \u6CE8\u5165\u8FD0\u884C\u65F6\u51ED\u8BC1"
+      `Failed to read ${envPath}: ${err?.message ?? err}`,
+      "Check file permissions, or inject runtime credentials via TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY"
     );
   }
 }
@@ -56,43 +60,30 @@ function readLegacyCredentials() {
     if (err?.code === "ENOENT") return null;
     if (err instanceof SyntaxError) {
       throw new TeAgentCredentialsError(
-        `${credPath} \u89E3\u6790\u5931\u8D25\uFF1A${err.message}`,
-        "\u51ED\u8BC1\u6587\u4EF6\u53EF\u80FD\u5DF2\u635F\u574F\uFF1B\u4E5F\u53EF\u4EE5\u901A\u8FC7 TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY \u6CE8\u5165\u8FD0\u884C\u65F6\u51ED\u8BC1"
+        `Failed to parse ${credPath}: ${err.message}`,
+        "The credentials file may be corrupted; alternatively inject runtime credentials via TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY"
       );
     }
     throw new TeAgentCredentialsError(
-      `${credPath} \u8BFB\u53D6\u5931\u8D25\uFF1A${err?.message ?? err}`,
-      "\u8BF7\u68C0\u67E5\u6587\u4EF6\u6743\u9650\uFF0C\u6216\u901A\u8FC7 TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY \u6CE8\u5165\u8FD0\u884C\u65F6\u51ED\u8BC1"
+      `Failed to read ${credPath}: ${err?.message ?? err}`,
+      "Check file permissions, or inject runtime credentials via TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY"
     );
   }
 }
-function loadTeAgentCredentials() {
+function tryLoadTeAgentSandboxCredentials() {
   const legacy = readLegacyCredentials();
-  const credPath = getCredentialsPath();
-  const envPath = getPersistentEnvPath();
   const persistent = readPersistentEnv();
   const url = process.env.TE_CLAUDE_BASE_URL || persistent?.TE_CLAUDE_BASE_URL || legacy?.url;
-  const sandboxId = process.env.SANDBOX_ID || persistent?.SANDBOX_ID || legacy?.sandboxId;
-  const sandboxSecretKey = process.env.SECRET_KEY || process.env.SANDBOX_SECRET_KEY || persistent?.SECRET_KEY || persistent?.SANDBOX_SECRET_KEY || legacy?.sandboxSecretKey || legacy?.secretKey;
   if (typeof url !== "string" || !url) {
-    throw new TeAgentCredentialsError(
-      "TE_CLAUDE_BASE_URL \u7F3A\u5931",
-      `\u8BF7\u5728 te-agent \u6C99\u7BB1\u5185\u6267\u884C\uFF0C\u6216\u914D\u7F6E ${envPath} / ${credPath}`
-    );
-  }
-  if (typeof sandboxId !== "string" || !sandboxId) {
-    throw new TeAgentCredentialsError(
-      "SANDBOX_ID \u7F3A\u5931",
-      `\u8BF7\u5728 te-agent \u6C99\u7BB1\u5185\u6267\u884C\uFF0C\u6216\u914D\u7F6E ${envPath} / ${credPath}`
-    );
-  }
-  if (typeof sandboxSecretKey !== "string" || !sandboxSecretKey) {
-    throw new TeAgentCredentialsError(
-      "SECRET_KEY \u7F3A\u5931",
-      `\u8BF7\u5728 te-agent \u6C99\u7BB1\u5185\u6267\u884C\uFF0C\u6216\u914D\u7F6E ${envPath} / ${credPath}`
-    );
+    return null;
   }
-  return { mainApp: { url, sandboxId, sandboxSecretKey } };
+  const sandboxId = process.env.SANDBOX_ID || persistent?.SANDBOX_ID || legacy?.sandboxId || null;
+  const sandboxSecretKey = process.env.SECRET_KEY || process.env.SANDBOX_SECRET_KEY || persistent?.SECRET_KEY || persistent?.SANDBOX_SECRET_KEY || legacy?.sandboxSecretKey || legacy?.secretKey || null;
+  return {
+    url,
+    sandboxId: typeof sandboxId === "string" ? sandboxId : null,
+    sandboxSecretKey: typeof sandboxSecretKey === "string" ? sandboxSecretKey : null
+  };
 }
 function getClaudeConfigDir() {
   const fromEnv = process.env.CLAUDE_CONFIG_DIR;
@@ -124,19 +115,49 @@ async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_TIMEOUT_MS) {
     return await fetch(url, { ...init, signal: controller.signal });
   } catch (err) {
     if (err?.name === "AbortError") {
-      throw new TeAgentApiError(`\u8BF7\u6C42\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09\uFF1A${url}`, 0, "TIMEOUT");
+      throw new TeAgentApiError(`Request timed out (${timeoutMs}ms): ${url}`, 0, "TIMEOUT");
     }
-    throw new TeAgentApiError(`\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25\uFF1A${err?.message ?? err}`, 0, "NETWORK_ERROR");
+    throw new TeAgentApiError(`Network request failed: ${err?.message ?? err}`, 0, "NETWORK_ERROR");
   } finally {
     clearTimeout(timer);
   }
 }
-function signRequest(method, path, rawBody) {
-  const cred = loadTeAgentCredentials();
-  const { url: baseUrl, sandboxId, sandboxSecretKey } = cred.mainApp;
+function teClaudeBaseFromActiveHost() {
+  const override = process.env.TE_CLAUDE_BASE_URL;
+  if (override) return override.replace(/\/+$/, "");
+  const h = getActiveHost();
+  if (!h) return void 0;
+  const base = h.replace(/\/+$/, "");
+  const bp = process.env.TE_CLAUDE_BASE_PATH || "/agent";
+  return base.endsWith(bp) ? base : base + bp;
+}
+async function signRequest(method, path, rawBody) {
+  const sandboxCred = tryLoadTeAgentSandboxCredentials();
+  if (sandboxCred && sandboxCred.sandboxId && sandboxCred.sandboxSecretKey) {
+    const headers2 = {
+      "X-Sandbox-Id": sandboxCred.sandboxId,
+      "X-Sandbox-Secret-Key": sandboxCred.sandboxSecretKey
+    };
+    if (method === "POST" || method === "PATCH") {
+      headers2["Content-Type"] = "application/json";
+    }
+    return {
+      url: `${sandboxCred.url.replace(/\/$/, "")}${path}`,
+      headers: headers2,
+      rawBody
+    };
+  }
+  const { getToken } = await import("./auth-U25QJU5D.js");
+  const baseUrl = sandboxCred?.url || teClaudeBaseFromActiveHost();
+  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 = {
-    "X-Sandbox-Id": sandboxId,
-    "X-Sandbox-Secret-Key": sandboxSecretKey
+    "Authorization": `bearer ${accessToken}`
   };
   if (method === "POST" || method === "PATCH") {
     headers["Content-Type"] = "application/json";
@@ -158,6 +179,14 @@ async function parseResponse(response, defaultErrorPrefix) {
     }
   }
   if (!response.ok) {
+    if (response.status === 401) {
+      throw new TeAgentApiError(
+        `Session expired or unauthorized. Please run: ae-cli auth login`,
+        response.status,
+        "auth_expired",
+        parsed
+      );
+    }
     const message = typeof parsed === "object" && parsed && typeof parsed.error === "string" ? parsed.error : `${defaultErrorPrefix} ${response.status}`;
     const code = typeof parsed === "object" && parsed && typeof parsed.code === "string" ? parsed.code : void 0;
     throw new TeAgentApiError(message, response.status, code, parsed);
@@ -166,21 +195,21 @@ async function parseResponse(response, defaultErrorPrefix) {
 }
 async function postToMainApp(path, body) {
   const rawBody = JSON.stringify(body);
-  const signed = signRequest("POST", path, rawBody);
+  const signed = await signRequest("POST", path, rawBody);
   const response = await fetchWithTimeout(signed.url, {
     method: "POST",
     headers: signed.headers,
     body: signed.rawBody
   });
-  return parseResponse(response, "\u4E3B\u5E94\u7528\u8FD4\u56DE");
+  return parseResponse(response, "Main app returned");
 }
 async function getFromMainApp(path) {
-  const signed = signRequest("GET", path, "");
+  const signed = await signRequest("GET", path, "");
   const response = await fetchWithTimeout(signed.url, {
     method: "GET",
     headers: signed.headers
   });
-  return parseResponse(response, "\u4E3B\u5E94\u7528\u8FD4\u56DE");
+  return parseResponse(response, "Main app returned");
 }
 async function getSandboxModels(currentModelId) {
   const qs = currentModelId ? `?current=${encodeURIComponent(currentModelId)}` : "";
@@ -205,45 +234,59 @@ async function postSandboxSyncPull(args) {
     kind: args.kind,
     skills: args.skills,
     mcp: args.mcp,
-    mode: "merge",
-    ifUnmodifiedSince: args.ifUnmodifiedSince
+    mode: "merge"
   });
 }
 async function deleteFromMainApp(path) {
-  const signed = signRequest("DELETE", path, "");
+  const signed = await signRequest("DELETE", path, "");
   const response = await fetchWithTimeout(signed.url, {
     method: "DELETE",
     headers: signed.headers
   });
-  return parseResponse(response, "\u4E3B\u5E94\u7528\u8FD4\u56DE");
+  return parseResponse(response, "Main app returned");
 }
 async function patchToMainApp(path, body) {
   const rawBody = JSON.stringify(body);
-  const signed = signRequest("PATCH", path, rawBody);
+  const signed = await signRequest("PATCH", path, rawBody);
   const response = await fetchWithTimeout(signed.url, {
     method: "PATCH",
     headers: signed.headers,
     body: signed.rawBody
   });
-  return parseResponse(response, "\u4E3B\u5E94\u7528\u8FD4\u56DE");
+  return parseResponse(response, "Main app returned");
 }
 async function uploadToMainApp(path, formData) {
-  const cred = loadTeAgentCredentials();
-  const baseUrl = cred.mainApp.url.replace(/\/$/, "");
-  const url = `${baseUrl}${path}`;
+  const sandboxCred = tryLoadTeAgentSandboxCredentials();
+  let baseUrl;
+  let authHeaders;
+  if (sandboxCred && sandboxCred.sandboxId && sandboxCred.sandboxSecretKey) {
+    baseUrl = sandboxCred.url.replace(/\/$/, "");
+    authHeaders = {
+      "X-Sandbox-Id": sandboxCred.sandboxId,
+      "X-Sandbox-Secret-Key": sandboxCred.sandboxSecretKey
+    };
+  } else {
+    const { getToken } = await import("./auth-U25QJU5D.js");
+    baseUrl = (sandboxCred?.url || teClaudeBaseFromActiveHost() || "").replace(/\/$/, "");
+    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);
+    authHeaders = { "Authorization": `bearer ${accessToken}` };
+  }
   const response = await fetchWithTimeout(
-    url,
+    `${baseUrl}${path}`,
     {
       method: "POST",
-      headers: {
-        "X-Sandbox-Id": cred.mainApp.sandboxId,
-        "X-Sandbox-Secret-Key": cred.mainApp.sandboxSecretKey
-      },
+      headers: authHeaders,
       body: formData
     },
     UPLOAD_TIMEOUT_MS
   );
-  return parseResponse(response, "\u4E0A\u4F20\u5931\u8D25");
+  return parseResponse(response, "Upload failed");
 }
 
 export {

package/dist/{client-IU2E5IOL.js → client-IN42F223.js}

@@ -7,10 +7,10 @@ import {
   queryReportData,
   querySql,
   wsQuery
-} from "./chunk-VT6VC4PA.js";
-import "./chunk-SRRUNQIM.js";
-import "./chunk-BI5ZVD6T.js";
-import "./chunk-MNHE6SSI.js";
+} from "./chunk-I42JGQ2J.js";
+import "./chunk-U6TKB3IV.js";
+import "./chunk-JM34JPCO.js";
+import "./chunk-SRJIAOBN.js";
 export {
   httpDelete,
   httpGet,

package/dist/config-64G36TJL.js

@@ -0,0 +1,130 @@
+import {
+  printError,
+  printOutput
+} from "./chunk-CLJF7MQA.js";
+import {
+  GLOBAL_QUERY_CONFIG_KEY,
+  getAnalysisMappingPathForClusterMode,
+  getClusterInfoFilePath,
+  isGlobalQueryModeEnabled,
+  setGlobalQueryModeEnabled
+} from "./chunk-GSJGPNKK.js";
+import {
+  addHost,
+  loadConfig,
+  setActiveHost
+} from "./chunk-SRJIAOBN.js";
+
+// src/commands/config.ts
+function registerConfig(program) {
+  const configCmd = program.command("config").description("AE host and environment configuration").action(() => {
+    printError("config", "Missing subcommand.", "Run: ae-cli config --help");
+    process.exit(1);
+  });
+  configCmd.command("list").description("List configured AE environments").action(() => {
+    printConfigList(program);
+  });
+  configCmd.command("current").description("Show the active AE environment").action(() => {
+    printCurrentConfig(program);
+  });
+  configCmd.command("use <env>").description("Switch active AE environment by exact URL or unique label").action((env) => {
+    useConfigEnv(program, env);
+  });
+  configCmd.command("set-host <url>").description("Set the active AE host non-interactively (adds it if not already configured)").option("--label <label>", "Display label for this host (defaults to the host URL)").action((url, opts) => {
+    const normalized = normalizeUrl(url);
+    const label = opts.label || normalized;
+    addHost(normalized, label);
+    setActiveHost(normalized);
+    printOutput({ activeHost: normalized, label }, program.opts().format || "json");
+  });
+  const clusterMode = configCmd.command("cluster-mode").description("Manage local multi-cluster analysis MCP mode").action(() => {
+    printClusterModeStatus(program);
+  });
+  clusterMode.command("status").description("Show local multi-cluster analysis MCP mode").action(() => {
+    printClusterModeStatus(program);
+  });
+  clusterMode.command("enable").description("Enable local multi-cluster analysis MCP mode").action(() => {
+    setGlobalQueryModeEnabled(true);
+    printClusterModeStatus(program);
+  });
+  clusterMode.command("disable").description("Disable local multi-cluster analysis MCP mode").action(() => {
+    setGlobalQueryModeEnabled(false);
+    printClusterModeStatus(program);
+  });
+}
+function printClusterModeStatus(program) {
+  const enabled = isGlobalQueryModeEnabled();
+  printOutput({
+    [GLOBAL_QUERY_CONFIG_KEY]: enabled,
+    path: getClusterInfoFilePath(),
+    analysisMappingPath: getAnalysisMappingPathForClusterMode(enabled)
+  }, program.opts().format || "json", program.opts().jq);
+}
+function readHostViews() {
+  const config = loadConfig();
+  const hosts = Object.entries(config.hosts).map(([url, entry]) => ({
+    url,
+    label: entry.label,
+    active: url === config.activeHost
+  }));
+  return { activeHost: config.activeHost, hosts };
+}
+function printConfigList(program) {
+  const { activeHost, hosts } = readHostViews();
+  printOutput({ activeHost, hosts }, program.opts().format || "json", program.opts().jq);
+}
+function printCurrentConfig(program) {
+  const { activeHost, hosts } = readHostViews();
+  const current = hosts.find((h) => h.url === activeHost);
+  if (!current) {
+    failConfig("No active AE environment configured.", "Run: ae-cli config use <env> or ae-cli config list");
+    return;
+  }
+  printOutput({ activeHost: current.url, label: current.label }, program.opts().format || "json", program.opts().jq);
+}
+function useConfigEnv(program, env) {
+  const target = resolveHost(env);
+  if (target.status === "not-found") {
+    failConfig(
+      `No AE environment matched: ${env}`,
+      target.hosts.length > 0 ? `Available environments: ${formatHostOptions(target.hosts)}` : "Run: ae-cli config list"
+    );
+    return;
+  }
+  if (target.status === "duplicate-label") {
+    failConfig(
+      `Duplicate label: ${env}`,
+      `Rename duplicate labels first. Run: ae-cli config list \u2014 ${formatHostOptions(target.matches)}`
+    );
+    return;
+  }
+  setActiveHost(target.host.url);
+  printOutput({ activeHost: target.host.url, label: target.host.label }, program.opts().format || "json", program.opts().jq);
+}
+function resolveHost(env) {
+  const raw = env.trim();
+  const selector = raw.startsWith("http://") || raw.startsWith("https://") ? normalizeUrl(raw) : raw;
+  const { hosts } = readHostViews();
+  const byUrl = hosts.find((h) => h.url === selector);
+  if (byUrl) return { status: "found", host: byUrl };
+  const byLabel = hosts.filter((h) => h.label === raw);
+  if (byLabel.length === 1) return { status: "found", host: byLabel[0] };
+  if (byLabel.length > 1) return { status: "duplicate-label", matches: byLabel };
+  return { status: "not-found", hosts };
+}
+function formatHostOptions(hosts) {
+  return hosts.map((h) => `${h.label} (${h.url})`).join(", ");
+}
+function failConfig(message, hint) {
+  printError("config", message, hint);
+  process.exitCode = 1;
+}
+function normalizeUrl(url) {
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    url = `https://${url}`;
+  }
+  return url.replace(/\/$/, "");
+}
+export {
+  registerConfig
+};