@thinkingai/ae-cli 6.0.45 → 6.0.47

package/dist/{chunk-ILIU36SU.js → chunk-GJXRF7Y6.js}

@@ -1,19 +1,20 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   internalCallSourceHeaders
-} from "./chunk-6EIJSNBD.js";
+} from "./chunk-Y74WTIKJ.js";
 import {
   clearCliToken,
   getCliToken
-} from "./chunk-4SGZG4XY.js";
+} from "./chunk-RWXIXOZG.js";
 import {
   safeJsonParse
-} from "./chunk-ZZUOD757.js";
+} from "./chunk-KZ6ZHF5J.js";
 import {
   PermissionError
-} from "./chunk-UW5UN47B.js";
+} from "./chunk-533JK3YX.js";
 import {
   logger
-} from "./chunk-LYVNONC4.js";
+} from "./chunk-FR2EDAQM.js";
 
 // src/core/capability-api.ts
 import { readFile } from "fs/promises";

package/dist/{chunk-DWO43OIB.js → chunk-JQ3ENZZH.js}

@@ -1,3 +1,5 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+
 // src/commands/sync/scanners.ts
 import { createHash } from "crypto";
 import { readdirSync, readFileSync as readFileSync2, statSync, lstatSync, existsSync as existsSync2, realpathSync } from "fs";

package/dist/chunk-JYMGHGCE.js

@@ -0,0 +1,191 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  CapabilityGatewayError
+} from "./chunk-GJXRF7Y6.js";
+import {
+  clearCliToken,
+  getCliToken
+} from "./chunk-RWXIXOZG.js";
+import {
+  safeJsonParse
+} from "./chunk-KZ6ZHF5J.js";
+import {
+  PermissionError
+} from "./chunk-533JK3YX.js";
+
+// src/core/mcp-access.ts
+function buildUrl(host, path, params = {}) {
+  const base = host.replace(/\/$/, "");
+  const p = path.startsWith("/") ? path : `/${path}`;
+  const url = new URL(`${base}${p}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+var KbUnauthorizedError = class extends Error {
+};
+function optionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function responseReturnCode(data) {
+  const value = data?.return_code;
+  if (value === void 0 || value === null || value === 0 || value === "0") {
+    return void 0;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return optionalString(value);
+}
+function responseErrorMetadata(data) {
+  const nestedError = data?.error && typeof data.error === "object" ? data.error : void 0;
+  return {
+    code: optionalString(data?.errorCode) ?? optionalString(data?.error_code) ?? optionalString(data?.code) ?? optionalString(nestedError?.code) ?? responseReturnCode(data),
+    hint: optionalString(data?.hint) ?? optionalString(nestedError?.hint)
+  };
+}
+function responseErrorMessage(data) {
+  const nestedError = data?.error && typeof data.error === "object" ? data.error : void 0;
+  return optionalString(typeof data?.error === "string" ? data.error : void 0) ?? optionalString(nestedError?.message) ?? optionalString(data?.message) ?? optionalString(data?.return_message);
+}
+function responseStatus(resp) {
+  const statusText = optionalString(resp.statusText);
+  return statusText ? `${resp.status} ${statusText}` : String(resp.status);
+}
+function malformedResponseError(resp, detail) {
+  if (!resp.ok) {
+    return new Error(`KB API HTTP error: ${responseStatus(resp)} (${detail})`);
+  }
+  return new Error(
+    `KB API protocol error: HTTP ${responseStatus(resp)} (${detail})`
+  );
+}
+var KbHttpError = class extends CapabilityGatewayError {
+  constructor(message, code, status, hint) {
+    super(message, code, status, hint);
+    this.name = "Error";
+  }
+};
+function nonOkResponseError(resp, data, options) {
+  const metadata = responseErrorMetadata(data);
+  const serverMessage = responseErrorMessage(data);
+  const fallbackMessage = `KB API HTTP error: ${responseStatus(resp)}`;
+  const businessCode = options.preserveBusinessErrorCode && typeof data?.error === "string" && metadata.code ? metadata.code : void 0;
+  const message = businessCode ? `${businessCode}: ${serverMessage ?? fallbackMessage}` : serverMessage ?? fallbackMessage;
+  if (metadata.code || metadata.hint) {
+    return new KbHttpError(message, metadata.code, resp.status, metadata.hint);
+  }
+  return new Error(message);
+}
+function parseKbResponse(resp, text, options = {}) {
+  if (resp.status === 403) {
+    let msg = "Permission denied for this resource (HTTP 403)";
+    let metadata = {};
+    try {
+      const d = safeJsonParse(text);
+      const m = d && (typeof d.error === "string" ? d.error : d.error?.message || d.message);
+      if (m && typeof m === "string") msg = m;
+      if (options.preserveErrorMetadata) metadata = responseErrorMetadata(d);
+    } catch {
+    }
+    throw new PermissionError(msg, metadata.code, metadata.hint);
+  }
+  if (resp.status === 401) {
+    throw new KbUnauthorizedError(
+      `KB API token auth failed: HTTP ${resp.status} ${resp.statusText}`
+    );
+  }
+  if (!text.trim()) {
+    throw malformedResponseError(resp, "empty response body");
+  }
+  let data;
+  try {
+    data = safeJsonParse(text);
+  } catch {
+    throw malformedResponseError(resp, "non-JSON response");
+  }
+  if (data?.return_code === -1001) {
+    throw new KbUnauthorizedError(
+      `KB API token auth failed: ${data.return_message || "unauthorized"} (code: ${data.return_code})`
+    );
+  }
+  if (!resp.ok) {
+    throw nonOkResponseError(resp, data, options);
+  }
+  if (data?.return_code !== 0 && data?.return_code !== void 0) {
+    throw new Error(
+      `AE API error: ${data.return_message || "unknown"} (code: ${data.return_code})`
+    );
+  }
+  if (data && typeof data === "object" && typeof data.error === "string" && data.error.trim() && data.return_code === void 0 && data.success === void 0) {
+    if (options.preserveErrorMetadata) {
+      const metadata = responseErrorMetadata(data);
+      throw new CapabilityGatewayError(
+        data.error,
+        metadata.code,
+        resp.status,
+        metadata.hint
+      );
+    }
+    const businessCode = options.preserveBusinessErrorCode && typeof data.code === "string" && data.code.trim() ? data.code.trim() : "";
+    throw new Error(businessCode ? `${businessCode}: ${data.error}` : data.error);
+  }
+  return data?.data !== void 0 ? data.data : data;
+}
+async function fetchWithCliToken(input, init, cliToken, options = {}) {
+  const headers = new Headers(init.headers);
+  headers.set("cli-token", cliToken);
+  const resp = await fetch(input, { ...init, headers });
+  return parseKbResponse(resp, await resp.text(), options);
+}
+async function requestWithCliToken(host, input, init, options) {
+  const request = async () => fetchWithCliToken(input, init, await getCliToken(host), options);
+  try {
+    return await request();
+  } catch (error) {
+    if (!(error instanceof KbUnauthorizedError) || !options.retryUnauthorized) {
+      throw error;
+    }
+    clearCliToken(host);
+    return request();
+  }
+}
+async function getAuthHeaders(ctx) {
+  const cliToken = await getCliToken(ctx.host());
+  return { "cli-token": cliToken };
+}
+async function kbApi(ctx, method, path, params = {}, body, options = {}) {
+  const host = ctx.host();
+  const upperMethod = method.toUpperCase();
+  return requestWithCliToken(
+    host,
+    buildUrl(host, path, params),
+    {
+      method: upperMethod,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: upperMethod === "GET" ? void 0 : JSON.stringify(body ?? {})
+    },
+    options
+  );
+}
+async function kbUpload(ctx, path, form, params = {}, options = {}) {
+  const host = ctx.host();
+  return requestWithCliToken(
+    host,
+    buildUrl(host, path, params),
+    {
+      method: "POST",
+      body: form
+    },
+    options
+  );
+}
+
+export {
+  getAuthHeaders,
+  kbApi,
+  kbUpload
+};

package/dist/{chunk-GT46FPXN.js → chunk-KEWVSO64.js}

@@ -1,16 +1,19 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   peekCliToken
-} from "./chunk-4SGZG4XY.js";
+} from "./chunk-RWXIXOZG.js";
+import {
+  getToken
+} from "./chunk-O6K2ODUE.js";
 import {
   getActiveHost,
   getConfigDir,
-  getToken,
   isAeSandboxRuntime,
   normalizeUrl
-} from "./chunk-ZZUOD757.js";
+} from "./chunk-KZ6ZHF5J.js";
 import {
   logger
-} from "./chunk-LYVNONC4.js";
+} from "./chunk-FR2EDAQM.js";
 
 // src/core/version-sync.ts
 import { spawnSync } from "child_process";
@@ -84,6 +87,7 @@ var HISTORICAL_CLUSTER_TO_PUBLIC_PIN = {
 
 // src/core/version-compat.ts
 var OPEN_SOURCE_AE_CLI_PACKAGE = "@thinkingai/ae-cli";
+var OPEN_SOURCE_NPM_REGISTRY = "https://registry.npmjs.org";
 var AE_CLI_SKILLS_REPO = "ThinkingAIAgenticEngine/ae-cli";
 var PUBLISHED_EXTERNAL_VERSIONS = /* @__PURE__ */ new Set([
   "1.0.15",
@@ -182,7 +186,7 @@ function formatPinCommands(expectedVersion) {
   const ver = resolvePinTarget(expectedVersion);
   if (!ver) return [];
   return [
-    `npm i -g ${OPEN_SOURCE_AE_CLI_PACKAGE}@${ver}`,
+    `npm i -g ${OPEN_SOURCE_AE_CLI_PACKAGE}@${ver} --registry=${OPEN_SOURCE_NPM_REGISTRY}`,
     `npx skills add ${AE_CLI_SKILLS_REPO}#v${ver} -g -y`
   ];
 }
@@ -190,7 +194,7 @@ function formatUpgradeCommands(expectedVersion) {
   const ver = expectedVersion.trim().replace(/^v/i, "");
   if (!/^\d+\.\d+\.\d+(?:[-+].*)?$/.test(ver)) return [];
   return [
-    `npm i -g ${OPEN_SOURCE_AE_CLI_PACKAGE}@${ver}`,
+    `npm i -g ${OPEN_SOURCE_AE_CLI_PACKAGE}@${ver} --registry=${OPEN_SOURCE_NPM_REGISTRY}`,
     `npx skills add ${AE_CLI_SKILLS_REPO}#v${ver} -g -y`
   ];
 }
@@ -353,7 +357,7 @@ function buildVersionInstallPlan(targetRaw, globalRoot = "<npm-root>") {
   return {
     target,
     commands: [
-      `npm install -g ${OPEN_SOURCE_AE_CLI_PACKAGE}@${target}`,
+      `npm install -g ${OPEN_SOURCE_AE_CLI_PACKAGE}@${target} --registry=${OPEN_SOURCE_NPM_REGISTRY}`,
       `npx -y skills add ${localSkills} -g -y`,
       `npx -y skills add ${AE_CLI_SKILLS_REPO}#v${target} -g -y`
     ],
@@ -503,7 +507,13 @@ function installVersion(targetRaw, options = {}) {
       progress(`[ae-cli] [1/2] Installing ae-cli ${target}...`);
       const npmResult = runner(
         npm,
-        ["install", "-g", `${OPEN_SOURCE_AE_CLI_PACKAGE}@${target}`],
+        [
+          "install",
+          "-g",
+          `${OPEN_SOURCE_AE_CLI_PACKAGE}@${target}`,
+          "--registry",
+          OPEN_SOURCE_NPM_REGISTRY
+        ],
         COMMAND_TIMEOUT_MS
       );
       if (!commandSucceeded(npmResult)) {

package/dist/chunk-KZ6ZHF5J.js

@@ -0,0 +1,294 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  logger
+} from "./chunk-FR2EDAQM.js";
+
+// src/core/json-utils.ts
+import fs from "fs";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var JSONbig = require2("json-bigint");
+var jsonParser = JSONbig({ storeAsString: true });
+var INTEGER_TOKEN = /^-?(?:0|[1-9]\d*)$/;
+function normalizeParsedNumbers(lossless, native) {
+  if (typeof lossless === "string" && typeof native === "number") {
+    if (INTEGER_TOKEN.test(lossless) && !Number.isSafeInteger(native)) {
+      return lossless;
+    }
+    return native;
+  }
+  if (Array.isArray(lossless) && Array.isArray(native)) {
+    for (let index = 0; index < lossless.length; index++) {
+      lossless[index] = normalizeParsedNumbers(lossless[index], native[index]);
+    }
+    return lossless;
+  }
+  if (lossless !== null && native !== null && typeof lossless === "object" && typeof native === "object") {
+    for (const key of Object.keys(lossless)) {
+      lossless[key] = normalizeParsedNumbers(lossless[key], native[key]);
+    }
+  }
+  return lossless;
+}
+function safeJsonParse(text) {
+  const lossless = jsonParser.parse(text);
+  return normalizeParsedNumbers(lossless, JSON.parse(text));
+}
+function safeReadJsonFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  return safeJsonParse(content);
+}
+
+// src/core/url-utils.ts
+function normalizeUrl(url) {
+  if (!url) return url;
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    url = `https://${url}`;
+  }
+  return url.replace(/\/$/, "");
+}
+
+// src/core/config.ts
+import fs3 from "fs";
+import path from "path";
+
+// src/core/sandbox-runtime.ts
+import { homedir } from "os";
+import { join } from "path";
+import fs2 from "fs";
+var LINUX_SANDBOX_RUNTIME_ROOT = "/home/ta/te_agent_ta";
+function getDefaultSandboxRuntimeRoot() {
+  if (process.platform === "linux") {
+    return LINUX_SANDBOX_RUNTIME_ROOT;
+  }
+  return homedir();
+}
+function getSandboxRuntimeRoot() {
+  return process.env.SANDBOX_RUNTIME_ROOT || getDefaultSandboxRuntimeRoot();
+}
+function getSandboxAeConfigDir() {
+  return join(getSandboxRuntimeRoot(), ".ae-config");
+}
+function getSandboxCliTokenFilePath() {
+  return join(getSandboxAeConfigDir(), "cli-token.json");
+}
+function isAeSandboxRuntime() {
+  if (process.env.SANDBOX_RUNTIME_ROOT) {
+    return true;
+  }
+  try {
+    if (fs2.existsSync(getSandboxCliTokenFilePath())) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+
+// src/core/config.ts
+var CONFIG_DIR = path.join(process.env.HOME || "", ".ae-cli");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function sandboxCliTokenCandidatePaths() {
+  const paths = [getSandboxCliTokenFilePath()];
+  const homeFallback = path.join(process.env.HOME || "", ".ae-config", "cli-token.json");
+  if (!paths.includes(homeFallback)) {
+    paths.push(homeFallback);
+  }
+  return paths;
+}
+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.token ?? data["cli-token"];
+        if (url && token) {
+          return { url, token };
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function forceMigrateFromFallback() {
+  const entry = readSandboxCliTokenEntry();
+  if (!entry) return null;
+  return { [entry.url]: entry.token };
+}
+function getFallbackCliToken(hostUrl) {
+  const store = forceMigrateFromFallback();
+  if (!store) return null;
+  if (hostUrl && store[hostUrl]) return store[hostUrl];
+  const entries = Object.values(store);
+  if (entries.length === 1) return entries[0];
+  return null;
+}
+function ensureDir() {
+  if (!fs3.existsSync(CONFIG_DIR)) fs3.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+function dedupeNormalizedHosts(config) {
+  const hosts = {};
+  for (const [url, entry] of Object.entries(config.hosts)) {
+    const key = normalizeUrl(url);
+    if (!hosts[key]) {
+      hosts[key] = entry;
+    }
+  }
+  return {
+    activeHost: config.activeHost ? normalizeUrl(config.activeHost) : "",
+    hosts
+  };
+}
+function configNeedsNormalization(config) {
+  if (config.activeHost && normalizeUrl(config.activeHost) !== config.activeHost) return true;
+  const keys = Object.keys(config.hosts);
+  if (keys.some((url) => normalizeUrl(url) !== url)) return true;
+  return new Set(keys.map(normalizeUrl)).size !== keys.length;
+}
+function loadConfig() {
+  try {
+    if (fs3.existsSync(CONFIG_FILE)) {
+      const raw = safeReadJsonFile(CONFIG_FILE);
+      if (raw.defaultHost && !raw.activeHost) {
+        const migrated = dedupeNormalizedHosts(migrateConfig(raw));
+        saveConfig(migrated);
+        return migrated;
+      }
+      const rawConfig = raw;
+      if (configNeedsNormalization(rawConfig)) {
+        const config = dedupeNormalizedHosts(rawConfig);
+        saveConfig(config);
+        return config;
+      }
+      return rawConfig;
+    }
+  } catch (err) {
+    logger.error(`Error loading config: ${err.message}`);
+    console.error(`Error loading config: ${err.message}`);
+  }
+  return { activeHost: "", hosts: {} };
+}
+function migrateConfig(old) {
+  const hosts = {};
+  const oldHost = old.defaultHost;
+  if (old.hosts) {
+    for (const [key, val] of Object.entries(old.hosts)) {
+      const url = normalizeUrl(key.startsWith("http") ? key : `https://${key}`);
+      hosts[url] = val;
+    }
+  }
+  const activeHost = normalizeUrl(oldHost.startsWith("http") ? oldHost : `https://${oldHost}`);
+  if (!hosts[activeHost]) {
+    hosts[activeHost] = { label: "default" };
+  }
+  return { activeHost, hosts };
+}
+function saveConfig(config) {
+  ensureDir();
+  fs3.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  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();
+  return config.activeHost || "";
+}
+function setActiveHost(url) {
+  url = normalizeUrl(url);
+  const config = loadConfig();
+  if (!config.hosts[url]) {
+    throw new Error(`Host ${url} is not in the configured hosts list. Add it first.`);
+  }
+  config.activeHost = url;
+  saveConfig(config);
+}
+function addHost(url, label) {
+  url = normalizeUrl(url);
+  label = normalizeLabel(label);
+  const config = loadConfig();
+  assertUniqueHostLabel(config, label, url);
+  config.hosts[url] = { label };
+  if (!config.activeHost) {
+    config.activeHost = url;
+  }
+  saveConfig(config);
+}
+function updateHostLabel(url, label) {
+  url = normalizeUrl(url);
+  label = normalizeLabel(label);
+  const config = loadConfig();
+  if (!config.hosts[url]) {
+    throw new Error(`Host is not configured: ${url}`);
+  }
+  assertUniqueHostLabel(config, label, url);
+  config.hosts[url].label = label;
+  saveConfig(config);
+}
+function normalizeLabel(label) {
+  const normalized = label.trim();
+  if (!normalized) {
+    throw new Error("Label cannot be empty.");
+  }
+  return normalized;
+}
+function assertUniqueHostLabel(config, label, excludeUrl) {
+  const duplicate = Object.entries(config.hosts).find(([url, entry]) => url !== excludeUrl && entry.label === label);
+  if (duplicate) {
+    throw new Error(`Label already exists: ${label}. Rename the existing label first: ${duplicate[0]}`);
+  }
+}
+function removeHost(url) {
+  url = normalizeUrl(url);
+  const config = loadConfig();
+  delete config.hosts[url];
+  if (config.activeHost === url) {
+    const remaining = Object.keys(config.hosts);
+    config.activeHost = remaining.length > 0 ? remaining[0] : "";
+  }
+  saveConfig(config);
+}
+function listHosts() {
+  const config = loadConfig();
+  return Object.entries(config.hosts).map(([url, entry]) => ({
+    url,
+    label: entry.label,
+    active: url === config.activeHost
+  }));
+}
+function resolveHostSelector(env) {
+  const raw = env.trim();
+  const selector = raw.startsWith("http://") || raw.startsWith("https://") ? normalizeUrl(raw) : raw;
+  const hosts = listHosts();
+  const byUrl = hosts.find((host) => host.url === selector);
+  if (byUrl) return { status: "found", host: byUrl };
+  const byLabel = hosts.filter((host) => host.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 getConfigDir() {
+  return CONFIG_DIR;
+}
+
+export {
+  safeJsonParse,
+  safeReadJsonFile,
+  normalizeUrl,
+  getSandboxRuntimeRoot,
+  isAeSandboxRuntime,
+  getFallbackCliToken,
+  loadConfig,
+  saveConfig,
+  getActiveHost,
+  setActiveHost,
+  addHost,
+  updateHostLabel,
+  removeHost,
+  listHosts,
+  resolveHostSelector,
+  getConfigDir
+};

package/dist/{chunk-QI524WPY.js → chunk-NSIVXKJH.js}

@@ -1,14 +1,15 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   withOutputMetadata
-} from "./chunk-GT46FPXN.js";
+} from "./chunk-KEWVSO64.js";
 import {
   dryRunCapability,
   executeCapabilityWithEnvelope,
   validateCapability
-} from "./chunk-P3FGXJTU.js";
+} from "./chunk-GJXRF7Y6.js";
 import {
   resolveGatewayDomain
-} from "./chunk-PTE56QPL.js";
+} from "./chunk-TKHSULJT.js";
 
 // src/core/capability-command.ts
 import { randomBytes } from "crypto";
@@ -28,13 +29,13 @@ function createCapabilityCommand(config) {
     validateInput: async (ctx) => {
       const gatewayDomain = resolveGatewayDomain(config.cliService, config.gatewayDomain);
       const requestHost = config.requestHost ?? ctx.host();
-      const input = config.buildInput(ctx);
+      const input = withLifecycleRequestId(config, config.buildInput(ctx));
       return validateCapability(requestHost, gatewayDomain, config.capabilityId, input);
     },
     dryRun: async (ctx) => {
       const gatewayDomain = resolveGatewayDomain(config.cliService, config.gatewayDomain);
       const requestHost = config.requestHost ?? ctx.host();
-      const input = config.buildInput(ctx);
+      const input = withLifecycleRequestId(config, config.buildInput(ctx));
       return dryRunCapability(requestHost, gatewayDomain, config.capabilityId, input);
     },
     execute: async (ctx) => {