@thinkingai/ae-cli 1.0.22 → 1.0.27

package/dist/index.js

@@ -1,11 +1,14 @@
 import {
   printError,
   printOutput
-} from "./chunk-KM57HI5B.js";
+} from "./chunk-B4UL2VIJ.js";
 import {
   getActiveHost,
   safeJsonParse
-} from "./chunk-TMMUBSKW.js";
+} from "./chunk-BI5ZVD6T.js";
+import {
+  logger
+} from "./chunk-MNHE6SSI.js";
 
 // src/index.ts
 import { Command as CommanderCommand } from "commander";
@@ -16,6 +19,8 @@ import * as readline from "readline";
 async function runCommand(cmd, opts, globalOpts) {
   try {
     const ctx = createRuntimeContext(cmd, opts, globalOpts);
+    const cmdName = `${cmd.service} ${cmd.command}`;
+    logger.command(cmdName, opts);
     for (const flag of cmd.flags) {
       if (flag.required) {
         const val = opts[camelCase(flag.name)];
@@ -48,6 +53,7 @@ async function runCommand(cmd, opts, globalOpts) {
     ctx.out(result);
   } catch (err) {
     const message = err.message || String(err);
+    logger.error(`Command failed: ${message}`);
     if (message.includes("token") || message.includes("auth") || message.includes("401") || message.includes("403")) {
       printError("auth", message, "Run: ae-cli auth login");
     } else if (message.includes("AE API error")) {
@@ -62,7 +68,7 @@ function createRuntimeContext(cmd, opts, globalOpts) {
   let _clientModule = null;
   async function getClient() {
     if (!_clientModule) {
-      _clientModule = await import("./client-7S23DVHH.js");
+      _clientModule = await import("./client-IU2E5IOL.js");
     }
     return _clientModule;
   }
@@ -88,12 +94,12 @@ function createRuntimeContext(cmd, opts, globalOpts) {
         process.exit(1);
       }
     },
-    async api(method, path, params, data) {
+    async api(method, path2, params, data) {
       const client = await getClient();
       if (method.toUpperCase() === "GET") {
-        return client.httpGet(path, params, ctx.host());
+        return client.httpGet(path2, params, ctx.host());
       } else {
-        return client.httpPost(path, params, data, ctx.host());
+        return client.httpRequest(method, path2, params, data, ctx.host());
       }
     },
     async querySql(projectId, sql) {
@@ -105,7 +111,7 @@ function createRuntimeContext(cmd, opts, globalOpts) {
       return client.queryReportData(projectId, reportId, qp, eventModel, options, ctx.host());
     },
     async token() {
-      const { getToken } = await import("./auth-YM7OI23X.js");
+      const { getToken } = await import("./auth-TXFJHPXU.js");
       return getToken(ctx.host());
     },
     host() {
@@ -202,82 +208,251 @@ function extractGlobalOptions(program2) {
   };
 }
 
+// src/core/update-check.ts
+import fs from "fs";
+import path from "path";
+var CONFIG_DIR = path.join(process.env.HOME || "", ".ae-cli");
+var CACHE_FILE = path.join(CONFIG_DIR, "update-check.json");
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+var REGISTRY_BY_PACKAGE = {
+  "@thinkingai/ae-cli": "https://registry.npmjs.org"
+};
+var UPDATE_CHECK_PACKAGE = "@thinkingai/ae-cli";
+function isUpdateCheckEnabled(packageName) {
+  return packageName === UPDATE_CHECK_PACKAGE;
+}
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+function parseVersion(version2) {
+  const core = version2.trim().split("-")[0];
+  return core.split(".").map((part) => {
+    const n = Number.parseInt(part, 10);
+    return Number.isFinite(n) ? n : 0;
+  });
+}
+function isNewer(latest, current) {
+  const a = parseVersion(latest);
+  const b = parseVersion(current);
+  const len = Math.max(a.length, b.length, 3);
+  for (let i = 0; i < len; i += 1) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    if (av > bv) return true;
+    if (av < bv) return false;
+  }
+  return false;
+}
+function resolveRegistry(packageName) {
+  if (REGISTRY_BY_PACKAGE[packageName]) {
+    return REGISTRY_BY_PACKAGE[packageName];
+  }
+  const envRegistry = process.env.npm_config_registry?.replace(/\/$/, "");
+  return envRegistry || DEFAULT_REGISTRY;
+}
+function buildInstallCommand(packageName, registry) {
+  const base = `npm install -g ${packageName}@latest`;
+  if (registry === DEFAULT_REGISTRY) {
+    return base;
+  }
+  return `${base} --registry=${registry}`;
+}
+function shouldSkipUpdateCheck(argv = process.argv) {
+  if (process.env.AE_CLI_NO_UPDATE_CHECK === "1") return true;
+  if (process.env.CI === "true" || process.env.CI === "1") return true;
+  return argv.slice(2).some((arg) => {
+    if (arg === "--no-update-check") return true;
+    if (arg === "--version" || arg === "-V" || arg === "--help" || arg === "-h") return true;
+    return false;
+  });
+}
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function readCache() {
+  try {
+    if (!fs.existsSync(CACHE_FILE)) return null;
+    const raw = fs.readFileSync(CACHE_FILE, "utf8");
+    const data = JSON.parse(raw);
+    if (!data.packageName || !data.latestVersion || !data.lastCheckedAt) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    ensureConfigDir();
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch {
+  }
+}
+function cacheIsStale(cache, packageName) {
+  if (!cache || cache.packageName !== packageName) return true;
+  const age = Date.now() - new Date(cache.lastCheckedAt).getTime();
+  return age >= CHECK_INTERVAL_MS;
+}
+function printUpdateNotice(current, latest, installCommand) {
+  process.stderr.write(`[ae-cli] Update available: ${current} \u2192 ${latest}
+`);
+  process.stderr.write(`         Run: ${installCommand}
+`);
+}
+async function fetchLatestVersion(packageName, registry) {
+  const url = `${registry.replace(/\/$/, "")}/${encodeURIComponent(packageName)}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const resp = await fetch(url, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json();
+    const latest = data["dist-tags"]?.latest;
+    return typeof latest === "string" && latest.trim() ? latest.trim() : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function refreshCache(pkg2, registry) {
+  const latest = await fetchLatestVersion(pkg2.name, registry);
+  if (!latest) return readCache();
+  const cache = {
+    packageName: pkg2.name,
+    currentVersion: pkg2.version,
+    latestVersion: latest,
+    lastCheckedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeCache(cache);
+  return cache;
+}
+function maybeNotifyFromCache(pkg2, cache, registry) {
+  if (!cache || cache.packageName !== pkg2.name) return;
+  if (!isNewer(cache.latestVersion, pkg2.version)) return;
+  printUpdateNotice(pkg2.version, cache.latestVersion, buildInstallCommand(pkg2.name, registry));
+}
+function notifyIfUpdateAvailable(pkg2) {
+  if (!isUpdateCheckEnabled(pkg2.name)) return;
+  if (shouldSkipUpdateCheck()) return;
+  const registry = resolveRegistry(pkg2.name);
+  const cache = readCache();
+  maybeNotifyFromCache(pkg2, cache, registry);
+  if (!cacheIsStale(cache, pkg2.name)) return;
+  void refreshCache(pkg2, registry).then((fresh) => {
+    if (!fresh) return;
+    if (cache && fresh.latestVersion === cache.latestVersion) return;
+    maybeNotifyFromCache(pkg2, fresh, registry);
+  });
+}
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
-var { version } = require2("../package.json");
+var pkg = require2("../package.json");
+var { version } = pkg;
 var program = new CommanderCommand();
-program.name("ae-cli").version(version).description("CLI tool for ThinkingAI (AE) analytics platform").option("--host <url>", "Override active AE host URL (e.g., https://ta.thinkingdata.cn)").option("--mcp-url <url>", "Override MCP server URL (e.g., http://localhost/mcp/http/example)").option("--format <format>", "Output format: json | table", "json").option("--jq <expr>", "jq filter expression").option("--dry-run", "Show request details without executing", false).option("--yes", "Skip confirmation for write operations", false);
+program.name("ae-cli").version(version).description("CLI tool for ThinkingAI (AE) analytics platform").option("--host <url>", "Override active AE host URL (e.g., https://ta.thinkingdata.cn)").option("--mcp-url <url>", "Override MCP server URL (e.g., http://localhost/mcp/http/example)").option("--format <format>", "Output format: json | table", "json").option("--jq <expr>", "jq filter expression").option("--dry-run", "Show request details without executing", false).option("--yes", "Skip confirmation for write operations", false).option("--no-update-check", "Skip checking for newer ae-cli versions", false);
 async function loadCommands() {
   const commands = [];
   try {
-    const teAnalysis = await import("./te-analysis-RQST6AT3.js");
+    const teAnalysis = await import("./te-analysis-CMXADIJM.js");
     commands.push(...teAnalysis.default);
   } catch {
   }
   try {
-    const teAudience = await import("./te-audience-TJ74UJI3.js");
+    const teAudience = await import("./te-audience-LPZFFSXM.js");
     commands.push(...teAudience.default);
   } catch {
   }
   try {
-    const teMeta = await import("./te-meta-25SLZFXJ.js");
+    const teMeta = await import("./te-meta-NQ4U3VJW.js");
     commands.push(...teMeta.default);
   } catch {
   }
   try {
-    const teCommon = await import("./te-common-W5URM2SH.js");
+    const teCommon = await import("./te-common-BXQFKTB3.js");
     commands.push(...teCommon.default);
   } catch {
   }
   try {
-    const engage = await import("./te-engage-57UKFV74.js");
+    const engage = await import("./te-engage-TBUTGW5F.js");
     commands.push(...engage.default);
   } catch {
   }
   try {
-    const community = await import("./te-community-YRV2VAD4.js");
+    const community = await import("./te-community-K5S3VOZY.js");
     commands.push(...community.default);
   } catch {
   }
   try {
-    const dataops = await import("./te-dataops-ZPH72BCK.js");
+    const dataops = await import("./te-dataops-567IMCQG.js");
     commands.push(...dataops.default);
   } catch {
   }
   try {
-    const teKb = await import("./te-kb-GD7SJRYB.js");
+    const teKb = await import("./te-kb-XHVBWP5E.js");
     commands.push(...teKb.default);
   } catch {
   }
+  try {
+    const teTeam = await import("./te-team-556APRIU.js");
+    commands.push(...teTeam.default);
+  } catch {
+  }
+  try {
+    const teAgent = await import("./te-agent-FLTDYV3L.js");
+    commands.push(...teAgent.default);
+  } catch {
+  }
   return commands;
 }
 async function registerAuthCommands() {
   try {
-    const { registerAuth } = await import("./auth-5S7SPPEJ.js");
+    const { registerAuth } = await import("./auth-W2JZ3DKA.js");
     registerAuth(program);
   } catch {
   }
 }
 async function registerConfigCommands() {
   try {
-    const { registerConfig } = await import("./config-RVUESJRF.js");
+    const { registerConfig } = await import("./config-WH3R3IRY.js");
     registerConfig(program);
   } catch {
   }
 }
 async function registerApiCommand() {
   try {
-    const { registerApi } = await import("./raw-5SYAUCJQ.js");
+    const { registerApi } = await import("./raw-TUHZQ4UB.js");
     registerApi(program);
   } catch {
   }
 }
+async function registerSyncCommand() {
+  try {
+    const { registerSync } = await import("./sync-EVEDS7YE.js");
+    registerSync(program);
+  } catch {
+  }
+}
+async function registerModelCommand() {
+  try {
+    const { registerModel } = await import("./model-CC7U5XOJ.js");
+    registerModel(program);
+  } catch {
+  }
+}
 async function main() {
+  notifyIfUpdateAvailable({ name: pkg.name, version: pkg.version });
   const commands = await loadCommands();
   registerCommands(program, commands);
   await registerAuthCommands();
   await registerConfigCommands();
   await registerApiCommand();
+  await registerSyncCommand();
+  await registerModelCommand();
   program.parse();
 }
 main();

package/dist/model-CC7U5XOJ.js

@@ -0,0 +1,131 @@
+import {
+  MultiselectCancelled,
+  getCurrentWorkspace,
+  promptSingleCheckboxSelect
+} from "./chunk-6T7245YE.js";
+import {
+  TeAgentApiError,
+  TeAgentCredentialsError,
+  getClaudeConfigDir,
+  getSandboxModels,
+  postSandboxModelSelection
+} from "./chunk-TG64AQV4.js";
+
+// src/commands/model/index.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function readCurrentModelSelection() {
+  const settingsPath = join(getClaudeConfigDir(), "settings.json");
+  if (!existsSync(settingsPath)) return { routingModelId: null, providerModelId: null };
+  try {
+    const raw = readFileSync(settingsPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+      return { routingModelId: null, providerModelId: null };
+    }
+    const env = parsed.env && typeof parsed.env === "object" ? parsed.env : {};
+    const headers = typeof env.ANTHROPIC_CUSTOM_HEADERS === "string" ? env.ANTHROPIC_CUSTOM_HEADERS : void 0;
+    const routingModelId = extractModelIdHeader(headers);
+    const providerModelId = typeof parsed.model === "string" && parsed.model ? parsed.model : typeof env.ANTHROPIC_MODEL === "string" && env.ANTHROPIC_MODEL ? env.ANTHROPIC_MODEL : null;
+    return { routingModelId, providerModelId };
+  } catch {
+    return { routingModelId: null, providerModelId: null };
+  }
+}
+function extractModelIdHeader(headers) {
+  if (!headers) return null;
+  for (const line of headers.split(/\r?\n/)) {
+    const match = line.match(/^\s*model-id\s*:\s*(.+?)\s*$/);
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+  return null;
+}
+function isCurrentModel(model, current) {
+  if (current.routingModelId) return model.id === current.routingModelId;
+  return model.scope === "system" && Boolean(current.providerModelId) && model.modelId === current.providerModelId;
+}
+async function runModelPicker() {
+  const current = readCurrentModelSelection();
+  const models = await getSandboxModels();
+  if (models.length === 0) {
+    process.stderr.write("\u5F53\u524D\u7528\u6237\u65E0\u53EF\u89C1\u6A21\u578B\n");
+    return;
+  }
+  const sorted = models.slice().sort((a, b) => {
+    const scopeOrder = {
+      system: 0,
+      company: 1,
+      personal: 2
+    };
+    const scopeDiff = scopeOrder[a.scope] - scopeOrder[b.scope];
+    return scopeDiff !== 0 ? scopeDiff : a.name.localeCompare(b.name);
+  });
+  const picked = await promptSingleCheckboxSelect({
+    title: "\u9009\u62E9\u8981\u4F7F\u7528\u7684\u6A21\u578B",
+    items: sorted.map((model) => {
+      const isCurrent = isCurrentModel(model, current);
+      return {
+        value: model,
+        label: `${model.name}  ${model.scope}`,
+        hint: isCurrent ? "(\u5F53\u524D)" : void 0,
+        preselected: isCurrent
+      };
+    })
+  });
+  const workspace = getCurrentWorkspace();
+  if (!workspace) {
+    process.stderr.write("\u8BF7\u5728 te-agent \u5DE5\u4F5C\u7A7A\u95F4\u76EE\u5F55\u5185\u6267\u884C ae-cli model\n");
+    process.exitCode = 1;
+    return;
+  }
+  if (isCurrentModel(picked, current)) {
+    process.stdout.write("\u5F53\u524D\u5DF2\u4F7F\u7528\u8BE5\u6A21\u578B\n");
+    return;
+  }
+  await postSandboxModelSelection({
+    workspacePath: workspace.name,
+    modelId: picked.id
+  });
+  process.stdout.write(`\u5DF2\u5207\u6362\u4E3A ${picked.name}
+`);
+}
+function registerModel(program) {
+  program.command("model").description("Choose and switch the current workspace model (te-agent sandbox only)").action(async () => {
+    try {
+      await runModelPicker();
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+function handleError(err) {
+  if (err instanceof MultiselectCancelled) {
+    process.stderr.write("\u5DF2\u53D6\u6D88\n");
+    return;
+  }
+  if (err instanceof TeAgentCredentialsError) {
+    process.stderr.write(`\u2717 ${err.message}
+`);
+    if (err.hint) process.stderr.write(`  ${err.hint}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  if (err instanceof TeAgentApiError) {
+    process.stderr.write(`\u2717 \u4E3B\u5E94\u7528\u9519\u8BEF\uFF08${err.status}${err.code ? " " + err.code : ""}\uFF09\uFF1A${err.message}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`\u2717 ${msg}
+`);
+  process.exitCode = 1;
+}
+export {
+  extractModelIdHeader,
+  readCurrentModelSelection,
+  registerModel
+};

package/dist/{raw-5SYAUCJQ.js → raw-TUHZQ4UB.js}

@@ -1,17 +1,18 @@
 import {
   printError,
   printOutput
-} from "./chunk-KM57HI5B.js";
+} from "./chunk-B4UL2VIJ.js";
 import {
   httpGet,
   httpPost
-} from "./chunk-NBFTPIAH.js";
+} from "./chunk-VT6VC4PA.js";
 import {
   resolveHost
-} from "./chunk-24ZKQWG2.js";
+} from "./chunk-SRRUNQIM.js";
 import {
   safeJsonParse
-} from "./chunk-TMMUBSKW.js";
+} from "./chunk-BI5ZVD6T.js";
+import "./chunk-MNHE6SSI.js";
 
 // src/api/raw.ts
 function registerApi(program) {