@zhoujinandrew/te-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,239 @@
+import {
+  printError,
+  printOutput
+} from "./chunk-KM57HI5B.js";
+import {
+  getActiveHost
+} from "./chunk-CFCHSAMQ.js";
+
+// src/index.ts
+import { Command as CommanderCommand } from "commander";
+
+// src/framework/runner.ts
+import * as readline from "readline";
+async function runCommand(cmd, opts, globalOpts) {
+  try {
+    const ctx = createRuntimeContext(cmd, opts, globalOpts);
+    for (const flag of cmd.flags) {
+      if (flag.required) {
+        const val = opts[camelCase(flag.name)];
+        if (val === void 0 || val === null || val === "") {
+          printError("validation", `Missing required flag: --${flag.name}`, `Usage: te-cli ${cmd.service} ${cmd.command} --${flag.name} <value>`);
+          process.exit(1);
+        }
+      }
+    }
+    if (cmd.validate) {
+      cmd.validate(ctx);
+    }
+    if (globalOpts.dryRun) {
+      if (cmd.dryRun) {
+        const dryResult = cmd.dryRun(ctx);
+        printOutput(dryResult, globalOpts.format, globalOpts.jq);
+      } else {
+        printOutput({ message: "No dry-run implementation for this command" }, globalOpts.format);
+      }
+      return;
+    }
+    if (cmd.risk === "write" && !globalOpts.yes) {
+      const confirmed = await confirm(`This is a write operation (${cmd.service} ${cmd.command}). Continue?`);
+      if (!confirmed) {
+        process.stderr.write("Aborted.\n");
+        process.exit(0);
+      }
+    }
+    const result = await cmd.execute(ctx);
+    ctx.out(result);
+  } catch (err) {
+    const message = err.message || String(err);
+    if (message.includes("token") || message.includes("auth") || message.includes("401") || message.includes("403")) {
+      printError("auth", message, "Run: te-cli auth login");
+    } else if (message.includes("TE API error")) {
+      printError("api", message);
+    } else {
+      printError("api", message);
+    }
+    process.exit(1);
+  }
+}
+function createRuntimeContext(cmd, opts, globalOpts) {
+  let _clientModule = null;
+  async function getClient() {
+    if (!_clientModule) {
+      _clientModule = await import("./client-EZSKQFIH.js");
+    }
+    return _clientModule;
+  }
+  const ctx = {
+    str(name) {
+      return String(opts[camelCase(name)] ?? "");
+    },
+    num(name) {
+      const val = opts[camelCase(name)];
+      return val !== void 0 ? Number(val) : 0;
+    },
+    bool(name) {
+      return Boolean(opts[camelCase(name)]);
+    },
+    json(name) {
+      const val = opts[camelCase(name)];
+      if (val === void 0 || val === null) return void 0;
+      if (typeof val === "object") return val;
+      try {
+        return JSON.parse(String(val));
+      } catch {
+        printError("validation", `Invalid JSON for --${name}: ${val}`);
+        process.exit(1);
+      }
+    },
+    async api(method, path, params, data) {
+      const client = await getClient();
+      if (method.toUpperCase() === "GET") {
+        return client.httpGet(path, params, ctx.host());
+      } else {
+        return client.httpPost(path, params, data, ctx.host());
+      }
+    },
+    async querySql(projectId, sql) {
+      const client = await getClient();
+      return client.querySql(projectId, sql, ctx.host());
+    },
+    async queryReportData(projectId, reportId, qp, eventModel, options) {
+      const client = await getClient();
+      return client.queryReportData(projectId, reportId, qp, eventModel, options, ctx.host());
+    },
+    async token() {
+      const { getToken } = await import("./auth-Z652VWDK.js");
+      return getToken(ctx.host());
+    },
+    host() {
+      if (globalOpts.host) return globalOpts.host;
+      return getActiveHost();
+    },
+    out(data) {
+      printOutput(data, globalOpts.format, globalOpts.jq);
+    }
+  };
+  return ctx;
+}
+function camelCase(str) {
+  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+async function confirm(message) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(`${message} [y/N] `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+
+// src/framework/register.ts
+function registerCommands(program2, commands) {
+  const byService = /* @__PURE__ */ new Map();
+  for (const cmd of commands) {
+    const list = byService.get(cmd.service) || [];
+    list.push(cmd);
+    byService.set(cmd.service, list);
+  }
+  for (const [service, cmds] of byService) {
+    let serviceCmd = program2.commands.find((c) => c.name() === service);
+    if (!serviceCmd) {
+      serviceCmd = program2.command(service).description(`${service} domain commands`);
+    }
+    for (const cmd of cmds) {
+      const sub = serviceCmd.command(cmd.command).description(cmd.description);
+      for (const flag of cmd.flags) {
+        const flagStr = buildFlagString(flag);
+        if (flag.type === "boolean") {
+          sub.option(flagStr, flag.desc);
+        } else if (flag.default !== void 0) {
+          sub.option(flagStr, flag.desc, String(flag.default));
+        } else {
+          sub.option(flagStr, flag.desc);
+        }
+      }
+      sub.action(async (opts) => {
+        const globalOpts = extractGlobalOptions(program2);
+        await runCommand(cmd, opts, globalOpts);
+      });
+    }
+  }
+}
+function buildFlagString(flag) {
+  const long = `--${flag.name}`;
+  const short = flag.alias ? `-${flag.alias}, ` : "";
+  if (flag.type === "boolean") {
+    return `${short}${long}`;
+  }
+  return `${short}${long} <value>`;
+}
+function extractGlobalOptions(program2) {
+  const opts = program2.opts();
+  return {
+    host: opts.host,
+    format: opts.format || "json",
+    jq: opts.jq,
+    dryRun: opts.dryRun || false,
+    yes: opts.yes || false
+  };
+}
+
+// src/index.ts
+var program = new CommanderCommand();
+program.name("te-cli").version("1.0.0").description("CLI tool for ThinkingEngine (TE) analytics platform").option("--host <url>", "Override active TE host URL (e.g., https://ta.thinkingdata.cn)").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);
+async function loadCommands() {
+  const commands = [];
+  try {
+    const meta = await import("./meta-ZXBX5RER.js");
+    commands.push(...meta.default);
+  } catch {
+  }
+  try {
+    const analysis = await import("./analysis-SFPXKD3E.js");
+    commands.push(...analysis.default);
+  } catch {
+  }
+  try {
+    const audience = await import("./audience-AZ72TU5F.js");
+    commands.push(...audience.default);
+  } catch {
+  }
+  try {
+    const operation = await import("./operation-6POPVVIZ.js");
+    commands.push(...operation.default);
+  } catch {
+  }
+  return commands;
+}
+async function registerAuthCommands() {
+  try {
+    const { registerAuth } = await import("./auth-V4MDYFHU.js");
+    registerAuth(program);
+  } catch {
+  }
+}
+async function registerConfigCommands() {
+  try {
+    const { registerConfig } = await import("./config-S53L4MQK.js");
+    registerConfig(program);
+  } catch {
+  }
+}
+async function registerApiCommand() {
+  try {
+    const { registerApi } = await import("./raw-YVFTDHSI.js");
+    registerApi(program);
+  } catch {
+  }
+}
+async function main() {
+  const commands = await loadCommands();
+  registerCommands(program, commands);
+  await registerAuthCommands();
+  await registerConfigCommands();
+  await registerApiCommand();
+  program.parse();
+}
+main();

package/dist/meta-ZXBX5RER.js

@@ -0,0 +1,135 @@
+// src/commands/meta/list-events.ts
+var listEvents = {
+  service: "meta",
+  command: "+list-events",
+  description: "Get event catalog for a project",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("GET", "/v1/ta/event/catalog/listEvent", {
+      projectId: ctx.num("project-id")
+    });
+  }
+};
+
+// src/commands/meta/load-event-props.ts
+var loadEventProps = {
+  service: "meta",
+  command: "+load-event-props",
+  description: "Load filterable properties for events (event + user props)",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "events", type: "json", desc: "Events array: [{eventName, eventType?}]" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    const events = ctx.json("events") || [];
+    return ctx.api("POST", "/v1/ta/event/model/meta/loadFiltProps", {
+      projectId: ctx.num("project-id")
+    }, { events });
+  }
+};
+
+// src/commands/meta/load-measure-props.ts
+var loadMeasureProps = {
+  service: "meta",
+  command: "+load-measure-props",
+  description: "Load measurable/aggregatable properties for events",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "events", type: "json", required: true, desc: "Events array: [{eventName, eventType?}]" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("POST", "/v1/ta/event/model/meta/loadPropQuotas", {
+      projectId: ctx.num("project-id")
+    }, { events: ctx.json("events") });
+  }
+};
+
+// src/commands/meta/list-entities.ts
+var listEntities = {
+  service: "meta",
+  command: "+list-entities",
+  description: "List analysis entities (user, account, device, etc.)",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("GET", "/v1/ta/entity/listEntities", {
+      projectId: ctx.num("project-id")
+    });
+  }
+};
+
+// src/commands/meta/list-metrics.ts
+var listMetrics = {
+  service: "meta",
+  command: "+list-metrics",
+  description: "List predefined metrics for a project",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("GET", "/v1/ta/metric/listProjectMetrics", {
+      projectId: ctx.num("project-id")
+    });
+  }
+};
+
+// src/commands/meta/list-tables.ts
+var listTables = {
+  service: "meta",
+  command: "+list-tables",
+  description: "List SQL-queryable tables (event views, user views, tag tables)",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("GET", "/v1/ta/taIde/auth/listProjectTable", {
+      projectId: ctx.num("project-id")
+    });
+  }
+};
+
+// src/commands/meta/get-table-columns.ts
+var getTableColumns = {
+  service: "meta",
+  command: "+get-table-columns",
+  description: "Get column definitions for a specific SQL table",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "table", type: "string", required: true, desc: "Table name" },
+    { name: "schema", type: "string", default: "ta", desc: "Schema name" },
+    { name: "catalog", type: "string", default: "hive", desc: "Catalog name" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("GET", "/v1/ta/taIde/auth/tableColumns", {
+      projectId: ctx.num("project-id"),
+      table: ctx.str("table"),
+      schema: ctx.str("schema") || "ta",
+      catalog: ctx.str("catalog") || "hive"
+    });
+  }
+};
+
+// src/commands/meta/index.ts
+var commands = [
+  listEvents,
+  loadEventProps,
+  loadMeasureProps,
+  listEntities,
+  listMetrics,
+  listTables,
+  getTableColumns
+];
+var meta_default = commands;
+export {
+  meta_default as default
+};

package/dist/operation-6POPVVIZ.js

@@ -0,0 +1,214 @@
+// src/commands/operation/create-task.ts
+var createTask = {
+  service: "operation",
+  command: "+create-task",
+  description: "Create and submit an operation task for approval",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "task-config", type: "json", required: true, desc: "Task configuration (JSON)" }
+  ],
+  risk: "write",
+  execute: async (ctx) => {
+    return ctx.api("POST", "/v1/hermes/operationTask/approval/saveAndSubmit", {}, {
+      projectId: ctx.num("project-id"),
+      ...ctx.json("task-config")
+    });
+  }
+};
+
+// src/commands/operation/list-tasks.ts
+var listTasks = {
+  service: "operation",
+  command: "+list-tasks",
+  description: "List operation tasks for a project",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "page", type: "number", default: 1, desc: "Page number" },
+    { name: "page-size", type: "number", default: 20, desc: "Page size" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("POST", "/v1/hermes/operationTask/query/list", {}, {
+      projectId: ctx.num("project-id"),
+      page: ctx.num("page"),
+      pageSize: ctx.num("page-size")
+    });
+  }
+};
+
+// src/commands/operation/get-task-stats.ts
+var getTaskStats = {
+  service: "operation",
+  command: "+get-task-stats",
+  description: "Get task status statistics and optional performance data",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "task-id", type: "number", desc: "Task ID (optional, for performance data)" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    const projectId = ctx.num("project-id");
+    const taskId = ctx.num("task-id");
+    const [statusStat, perfData] = await Promise.all([
+      ctx.api("POST", "/v1/hermes/operationTask/query/statusStat", {}, { projectId }),
+      taskId ? ctx.api("POST", "/v1/hermes/operationTask/stat/query", {}, { projectId, taskId }) : Promise.resolve(null)
+    ]);
+    return { statusStat, perfData };
+  }
+};
+
+// src/commands/operation/save-flow.ts
+var saveFlow = {
+  service: "operation",
+  command: "+save-flow",
+  description: "Save a flow configuration",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "flow-config", type: "json", required: true, desc: "Flow configuration (JSON)" }
+  ],
+  risk: "write",
+  execute: async (ctx) => {
+    return ctx.api("POST", "/v1/hermes/flow/save", {}, {
+      projectId: ctx.num("project-id"),
+      ...ctx.json("flow-config")
+    });
+  }
+};
+
+// src/commands/operation/list-flows.ts
+var listFlows = {
+  service: "operation",
+  command: "+list-flows",
+  description: "List flows for a project",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("POST", "/v1/hermes/flow/query/list", {}, {
+      projectId: ctx.num("project-id")
+    });
+  }
+};
+
+// src/commands/operation/get-flow.ts
+var getFlow = {
+  service: "operation",
+  command: "+get-flow",
+  description: "Get a flow by its UUID",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "flow-uuid", type: "string", required: true, desc: "Flow UUID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("GET", "/v1/hermes/flow/queryByFlowUuid", {
+      projectId: ctx.num("project-id"),
+      flowUuid: ctx.str("flow-uuid")
+    });
+  }
+};
+
+// src/commands/operation/list-channels.ts
+var listChannels = {
+  service: "operation",
+  command: "+list-channels",
+  description: "List channels for a project",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("GET", "/v1/hermes/channel/query/list", {
+      projectId: ctx.num("project-id")
+    });
+  }
+};
+
+// src/commands/operation/get-channel.ts
+var getChannel = {
+  service: "operation",
+  command: "+get-channel",
+  description: "Get channel details and meta info",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "channel-id", type: "number", required: true, desc: "Channel ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    const projectId = ctx.num("project-id");
+    const channelId = ctx.num("channel-id");
+    const [channel, metaInfo] = await Promise.all([
+      ctx.api("GET", "/v1/hermes/channel/queryById", { projectId, channelId }),
+      ctx.api("GET", "/v1/hermes/channel/queryChannelMetaInfoById", { projectId, channelId })
+    ]);
+    return { ...channel, metaInfo };
+  }
+};
+
+// src/commands/operation/get-space-tree.ts
+var getSpaceTree = {
+  service: "operation",
+  command: "+get-space-tree",
+  description: "Get the space tree for a project",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("GET", "/v1/ta/space/getSpaceTree", {
+      projectId: ctx.num("project-id")
+    });
+  }
+};
+
+// src/commands/operation/get-timezone.ts
+var getTimezone = {
+  service: "operation",
+  command: "+get-timezone",
+  description: "Get the timezone offset for a project",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("GET", "/v1/hermes/common/project/tzOffset", {
+      projectId: ctx.num("project-id")
+    });
+  }
+};
+
+// src/commands/operation/list-mark-times.ts
+var listMarkTimes = {
+  service: "operation",
+  command: "+list-mark-times",
+  description: "List milestone mark times for a project",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("POST", "/v1/ta/projectMilestone/markTime/listMarkTime", {}, {
+      projectId: ctx.num("project-id")
+    });
+  }
+};
+
+// src/commands/operation/index.ts
+var commands = [
+  createTask,
+  listTasks,
+  getTaskStats,
+  saveFlow,
+  listFlows,
+  getFlow,
+  listChannels,
+  getChannel,
+  getSpaceTree,
+  getTimezone,
+  listMarkTimes
+];
+var operation_default = commands;
+export {
+  operation_default as default
+};

package/dist/raw-76GSW4Q4.js

@@ -0,0 +1,59 @@
+import {
+  httpGet,
+  httpPost
+} from "./chunk-KA66K7EL.js";
+import {
+  printError,
+  printOutput
+} from "./chunk-KM57HI5B.js";
+import {
+  resolveHost
+} from "./chunk-4YPCK7T5.js";
+import "./chunk-STTYG7WN.js";
+
+// src/api/raw.ts
+function registerApi(program) {
+  program.command("api").description("Raw API call: te-cli api <METHOD> <PATH> [options]").argument("<method>", "HTTP method (GET, POST)").argument("<path>", "API path (e.g., /v1/ta/event/catalog/listEvent)").option("--params <json>", "URL parameters as JSON").option("--data <json>", "Request body as JSON").action(async (method, apiPath, opts) => {
+    const globalOpts = program.opts();
+    const host = resolveHost(globalOpts.host);
+    const format = globalOpts.format || "json";
+    const jq = globalOpts.jq;
+    if (!host) {
+      printError("config", "No TE host configured.", "Run: te-cli config set-host");
+      process.exit(1);
+    }
+    try {
+      let params = {};
+      let body = void 0;
+      if (opts.params) {
+        try {
+          params = JSON.parse(opts.params);
+        } catch {
+          printError("validation", `Invalid JSON for --params: ${opts.params}`);
+          process.exit(1);
+        }
+      }
+      if (opts.data) {
+        try {
+          body = JSON.parse(opts.data);
+        } catch {
+          printError("validation", `Invalid JSON for --data: ${opts.data}`);
+          process.exit(1);
+        }
+      }
+      let result;
+      if (method.toUpperCase() === "GET") {
+        result = await httpGet(apiPath, params, host);
+      } else {
+        result = await httpPost(apiPath, params, body, host);
+      }
+      printOutput(result, format, jq);
+    } catch (err) {
+      printError("api", err.message);
+      process.exit(1);
+    }
+  });
+}
+export {
+  registerApi
+};

package/dist/raw-K2FR7QAI.js

@@ -0,0 +1,55 @@
+import {
+  httpGet,
+  httpPost
+} from "./chunk-V3D6XL5Z.js";
+import {
+  printError,
+  printOutput
+} from "./chunk-KM57HI5B.js";
+import {
+  resolveHost
+} from "./chunk-C3VJLU5Y.js";
+import "./chunk-KAWQCMDL.js";
+
+// src/api/raw.ts
+function registerApi(program) {
+  program.command("api").description("Raw API call: te-cli api <METHOD> <PATH> [options]").argument("<method>", "HTTP method (GET, POST)").argument("<path>", "API path (e.g., /v1/ta/event/catalog/listEvent)").option("--params <json>", "URL parameters as JSON").option("--data <json>", "Request body as JSON").action(async (method, apiPath, opts) => {
+    const globalOpts = program.opts();
+    const host = resolveHost(globalOpts.host);
+    const format = globalOpts.format || "json";
+    const jq = globalOpts.jq;
+    try {
+      let params = {};
+      let body = void 0;
+      if (opts.params) {
+        try {
+          params = JSON.parse(opts.params);
+        } catch {
+          printError("validation", `Invalid JSON for --params: ${opts.params}`);
+          process.exit(1);
+        }
+      }
+      if (opts.data) {
+        try {
+          body = JSON.parse(opts.data);
+        } catch {
+          printError("validation", `Invalid JSON for --data: ${opts.data}`);
+          process.exit(1);
+        }
+      }
+      let result;
+      if (method.toUpperCase() === "GET") {
+        result = await httpGet(apiPath, params, host);
+      } else {
+        result = await httpPost(apiPath, params, body, host);
+      }
+      printOutput(result, format, jq);
+    } catch (err) {
+      printError("api", err.message);
+      process.exit(1);
+    }
+  });
+}
+export {
+  registerApi
+};