@thinkingai/ae-cli 6.1.17 → 6.1.19

package/dist/{te-engage-FGBGQ4IY.js → te-engage-TPKLRVTL.js}

@@ -1,29 +1,30 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   createCapabilityCommand
-} from "./chunk-VR3LCBHW.js";
+} from "./chunk-DKEXH6Q5.js";
 import {
   registerCapabilityGatewayRoute,
   resolveGatewayDomain
-} from "./chunk-PTE56QPL.js";
+} from "./chunk-TKHSULJT.js";
 import {
   printError,
   withOutputMetadata
-} from "./chunk-GT46FPXN.js";
+} from "./chunk-KEWVSO64.js";
 import {
   CapabilityGatewayError,
   buildCapabilityGatewayUrl,
   fetchCapabilityGateway,
   requestCapabilityGateway,
   requestCapabilityGatewayWithEnvelope
-} from "./chunk-ILIU36SU.js";
-import "./chunk-6EIJSNBD.js";
-import "./chunk-4SGZG4XY.js";
-import "./chunk-ZZUOD757.js";
+} from "./chunk-GJXRF7Y6.js";
+import "./chunk-Y74WTIKJ.js";
+import "./chunk-RWXIXOZG.js";
+import "./chunk-O6K2ODUE.js";
+import "./chunk-KZ6ZHF5J.js";
 import {
   CliValidationError
-} from "./chunk-UW5UN47B.js";
-import "./chunk-LYVNONC4.js";
-import "./chunk-QGM4M3NI.js";
+} from "./chunk-533JK3YX.js";
+import "./chunk-FR2EDAQM.js";
 
 // src/commands/te-engage/shared.ts
 function createEngageCapabilityCommand(cliService, config) {
@@ -323,6 +324,9 @@ function validateSemanticMetricDefinition(value, path) {
 function validateEmbeddedSemanticDefinitions(value, path) {
   walk(value, path);
 }
+function validateFlowAbIndicatorDefinitions(value, path) {
+  walkFlowAbIndicators(value, path);
+}
 function validateTaskTriggerPeriodDefinition(value, path) {
   const request = object(value, path);
   if (!isObject(request.triggerConfig)) return;
@@ -335,6 +339,20 @@ function validateTaskTriggerPeriodDefinition(value, path) {
   required(primaryRule.periodTimeSymbol, symbolPath);
   enumValue(primaryRule.periodTimeSymbol, TASK_TRIGGER_PERIOD_SYMBOLS, symbolPath);
 }
+function validateTaskAudienceChannelCompatibility(value, path) {
+  const request = object(value, path);
+  if (!isObject(request.channelConfig) || !isObject(request.targetConfig)) return;
+  const channelType = request.channelConfig.channelType;
+  const targetClusterType = request.targetConfig.targetClusterType;
+  if (typeof channelType !== "number" || typeof targetClusterType !== "number") return;
+  const clientSide = channelType === 3;
+  if (clientSide && targetClusterType === 2) {
+    invalid(`${path}.targetConfig.targetClusterType=2 (existing cluster) is not supported for client-side delivery; use 1 or 3.`);
+  }
+  if (!clientSide && targetClusterType === 3) {
+    invalid(`${path}.targetConfig.targetClusterType=3 (all users) is not supported for server-side delivery; use 1 or 2.`);
+  }
+}
 function walk(value, path) {
   if (Array.isArray(value)) {
     value.forEach((item, index) => walk(item, `${path}[${index}]`));
@@ -357,6 +375,60 @@ function walk(value, path) {
     }
   }
 }
+function walkFlowAbIndicators(value, path) {
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => walkFlowAbIndicators(item, `${path}[${index}]`));
+    return;
+  }
+  if (!isObject(value)) return;
+  if (value.indicatorsDef !== void 0 && value.indicatorsDef !== null) {
+    array(value.indicatorsDef, `${path}.indicatorsDef`).forEach((item, index) => {
+      const indicatorPath = `${path}.indicatorsDef[${index}]`;
+      const indicator = object(item, indicatorPath);
+      const hasDefinition = indicator.eventDefinition !== void 0 && indicator.eventDefinition !== null;
+      const hasLegacyEvent = indicator.event !== void 0 && indicator.event !== null;
+      if (hasDefinition && hasLegacyEvent) {
+        invalid(`${indicatorPath} cannot contain both event and eventDefinition.`);
+      }
+      if (!hasDefinition && !hasLegacyEvent) {
+        invalid(`${indicatorPath} must contain eventDefinition or legacy event.`);
+      }
+      if (hasDefinition) validateFlowAbIndicatorEvent(indicator.eventDefinition, `${indicatorPath}.eventDefinition`);
+    });
+  }
+  for (const [key, item] of Object.entries(value)) {
+    const itemPath = `${path}.${key}`;
+    if (key === "config" && typeof item === "string") {
+      try {
+        walkFlowAbIndicators(JSON.parse(item), itemPath);
+      } catch (error) {
+        if (error instanceof SyntaxError) invalid(`${itemPath} must contain valid JSON.`);
+        throw error;
+      }
+    } else {
+      walkFlowAbIndicators(item, itemPath);
+    }
+  }
+}
+function validateFlowAbIndicatorEvent(value, path) {
+  validateSemanticEventDefinition(value, path);
+  const event = object(value, path);
+  enumValue(event.aggregation, AUDIENCE_AGGREGATIONS, `${path}.aggregation`);
+  enumValue(event.operator, /* @__PURE__ */ new Set(["eq", "neq", "lt", "lte", "gt", "gte"]), `${path}.operator`);
+  required(event.value, `${path}.value`);
+  optionalNumber(event.value, `${path}.value`);
+  if (["sum", "avg", "max", "min", "distinct_count"].includes(String(event.aggregation))) {
+    nonBlankString(event.property, `${path}.property`);
+  }
+  if (isObject(event.filters)) {
+    array(event.filters.items, `${path}.filters.items`, 1).forEach((filterValue, index) => {
+      const filter = object(filterValue, `${path}.filters.items[${index}]`);
+      if (!["exists", "not_exists", "is_true", "is_false"].includes(String(filter.operator))) {
+        array(filter.values, `${path}.filters.items[${index}].values`, 1);
+      }
+    });
+  }
+}
 function validateTriggerDefinition(value, path) {
   const definition = object(value, path);
   rejectUnknown(definition, ["rules"], path);
@@ -608,6 +680,7 @@ function readRequest(ctx) {
     throw new Error("Flag --req.sourceFlowUuid is unsupported; get the source flow and build nodes/edges instead");
   }
   validateEmbeddedSemanticDefinitions(req, "--req");
+  validateFlowAbIndicatorDefinitions(req, "--req");
   return req;
 }
 var flowSave = createEngageFlowCapabilityCommand({
@@ -4609,6 +4682,7 @@ var taskSave = createEngageTaskCapabilityCommand({
   validate: (ctx) => {
     const req = readRequiredJsonObject(ctx, "req");
     validateEmbeddedSemanticDefinitions(req, "--req");
+    validateTaskAudienceChannelCompatibility(req, "--req");
     validateTaskTriggerPeriodDefinition(req, "--req");
   },
   buildInput: (ctx) => ({ project_id: ctx.num("project-id"), req: readRequiredJsonObject(ctx, "req") })

package/dist/{te-experiment-SO5MPDMJ.js → te-experiment-6BYKTCY7.js}

@@ -1,17 +1,18 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   createCapabilityCommand
-} from "./chunk-VR3LCBHW.js";
+} from "./chunk-DKEXH6Q5.js";
 import {
   registerCapabilityGatewayRoute
-} from "./chunk-PTE56QPL.js";
-import "./chunk-GT46FPXN.js";
-import "./chunk-ILIU36SU.js";
-import "./chunk-6EIJSNBD.js";
-import "./chunk-4SGZG4XY.js";
-import "./chunk-ZZUOD757.js";
-import "./chunk-UW5UN47B.js";
-import "./chunk-LYVNONC4.js";
-import "./chunk-QGM4M3NI.js";
+} from "./chunk-TKHSULJT.js";
+import "./chunk-KEWVSO64.js";
+import "./chunk-GJXRF7Y6.js";
+import "./chunk-Y74WTIKJ.js";
+import "./chunk-RWXIXOZG.js";
+import "./chunk-O6K2ODUE.js";
+import "./chunk-KZ6ZHF5J.js";
+import "./chunk-533JK3YX.js";
+import "./chunk-FR2EDAQM.js";
 
 // src/commands/te-experiment/capability-shared.ts
 function createExperimentCapabilityCommand(config) {
@@ -283,6 +284,54 @@ var experimentUpdateGroup = createExperimentCapabilityCommand({
   })
 });
 
+// src/commands/te-experiment/experiment/update-metrics.ts
+var METRIC_ROLES = /* @__PURE__ */ new Set(["primary", "secondary", "guardrail"]);
+function readMetricBindings(ctx) {
+  const value = ctx.json("metrics");
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error("Flag --metrics must be a non-empty JSON array");
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const item = value[index];
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      throw new Error(`Flag --metrics[${index}] must be a JSON object`);
+    }
+    const metricId = item.metricId;
+    const metricRole = item.metricRole;
+    if (typeof metricId !== "string" || metricId.trim() === "") {
+      throw new Error(`Flag --metrics[${index}].metricId must be a non-empty string`);
+    }
+    if (typeof metricRole !== "string" || !METRIC_ROLES.has(metricRole)) {
+      throw new Error(`Flag --metrics[${index}].metricRole must be one of primary, secondary, guardrail`);
+    }
+  }
+  return value;
+}
+var experimentUpdateMetrics = createExperimentCapabilityCommand({
+  resource: "experiment",
+  command: "update-metrics",
+  capabilityId: "experiment.experiment.save",
+  description: "Replace experiment metric bindings and assign primary, secondary, or guardrail roles.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "exp-id", type: "string", required: true, desc: "Experiment draft ID." },
+    {
+      name: "metrics",
+      type: "json",
+      required: true,
+      desc: "Non-empty metric binding array with camelCase metricId and metricRole fields; replaces all saved bindings."
+    }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    readMetricBindings(ctx);
+  },
+  buildInput: (ctx) => ({
+    project_id: ctx.num("project-id"),
+    req: { expId: ctx.str("exp-id"), metrics: readMetricBindings(ctx) }
+  })
+});
+
 // src/commands/te-experiment/feature/batch-delete.ts
 var featureBatchDelete = createExperimentCapabilityCommand({
   resource: "feature",
@@ -402,6 +451,166 @@ var featureOperationLogQuery = createExperimentCapabilityCommand({
   })
 });
 
+// src/commands/te-experiment/feature-whitelist/shared.ts
+function readRuleIds(ctx) {
+  const value = ctx.json("rule-ids");
+  if (!Array.isArray(value) || value.length === 0 || !value.every((item) => typeof item === "string" && item.trim() !== "")) {
+    throw new Error("Flag --rule-ids must be a non-empty JSON array of strings");
+  }
+  return value;
+}
+function readWhitelist(ctx) {
+  const value = ctx.json("whitelist");
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error("Flag --whitelist must be a non-empty JSON array");
+  }
+  const bucketIds = /* @__PURE__ */ new Set();
+  value.forEach((bucket, bucketIndex) => {
+    if (!bucket || typeof bucket !== "object" || Array.isArray(bucket)) {
+      throw new Error(`Flag --whitelist[${bucketIndex}] must be a JSON object`);
+    }
+    const item = bucket;
+    if (typeof item.bucket_id !== "string" || item.bucket_id.trim() === "") {
+      throw new Error(`Flag --whitelist[${bucketIndex}].bucket_id must be a non-empty string`);
+    }
+    if (bucketIds.has(item.bucket_id)) {
+      throw new Error(`Flag --whitelist contains duplicate bucket_id: ${item.bucket_id}`);
+    }
+    bucketIds.add(item.bucket_id);
+    if (!Array.isArray(item.rules) || item.rules.length === 0) {
+      throw new Error(`Flag --whitelist[${bucketIndex}].rules must be a non-empty array`);
+    }
+    const bucketValueIds = /* @__PURE__ */ new Set();
+    item.rules.forEach((rule, ruleIndex) => {
+      if (!rule || typeof rule !== "object" || Array.isArray(rule)) {
+        throw new Error(`Flag --whitelist[${bucketIndex}].rules[${ruleIndex}] must be a JSON object`);
+      }
+      const row = rule;
+      if (!Array.isArray(row.ids) || row.ids.length === 0 || !row.ids.every((id) => typeof id === "string" && id.trim() !== "")) {
+        throw new Error(`Flag --whitelist[${bucketIndex}].rules[${ruleIndex}].ids must be a non-empty string array`);
+      }
+      row.ids.forEach((id) => {
+        if (bucketValueIds.has(id)) {
+          throw new Error(`Flag --whitelist bucket ${item.bucket_id} contains duplicate ID: ${id}`);
+        }
+        bucketValueIds.add(id);
+      });
+      if (typeof row.value !== "string") {
+        throw new Error(`Flag --whitelist[${bucketIndex}].rules[${ruleIndex}].value must be a string`);
+      }
+    });
+  });
+  return value;
+}
+
+// src/commands/te-experiment/feature-whitelist/batch-delete.ts
+function buildBody(ctx) {
+  return { project_id: ctx.num("project-id"), rule_ids: readRuleIds(ctx) };
+}
+var featureWhitelistBatchDelete = createExperimentCapabilityCommand({
+  resource: "feature whitelist",
+  command: "batch-delete",
+  capabilityId: "experiment.feature_whitelist.batch_delete",
+  description: "Delete Feature whitelist rules; enabled whitelist rules are allowed and trigger RCC resync.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "rule-ids", type: "json", required: true, desc: "Non-empty JSON array of whitelist rule IDs." }
+  ],
+  risk: "high-risk-write",
+  validate: (ctx) => {
+    buildBody(ctx);
+  },
+  buildInput: buildBody
+});
+
+// src/commands/te-experiment/feature-whitelist/list.ts
+function buildInput5(ctx) {
+  return {
+    project_id: ctx.num("project-id"),
+    feature_key: ctx.str("feature-key")
+  };
+}
+var featureWhitelistList = createExperimentCapabilityCommand({
+  resource: "feature whitelist",
+  command: "list",
+  capabilityId: "experiment.feature_whitelist.list",
+  description: "List explicit whitelist rules for one Feature.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "feature-key", type: "string", required: true, desc: "Existing Feature key." }
+  ],
+  risk: "read",
+  buildInput: buildInput5
+});
+
+// src/commands/te-experiment/feature-whitelist/save.ts
+function buildInput6(ctx) {
+  const ruleId = ctx.str("rule-id").trim();
+  const status = ctx.str("status").trim() || "draft";
+  if (!["draft", "enable", "disable"].includes(status)) {
+    throw new Error("Flag --status must be one of draft, enable, disable");
+  }
+  const input = {
+    project_id: ctx.num("project-id"),
+    feature_key: ctx.str("feature-key"),
+    whitelist: readWhitelist(ctx),
+    status
+  };
+  if (ruleId) input.rule_id = ruleId;
+  const priority = ctx.str("priority");
+  if (priority !== "") input.priority = ctx.num("priority");
+  return input;
+}
+var featureWhitelistSave = createExperimentCapabilityCommand({
+  resource: "feature whitelist",
+  command: "save",
+  capabilityId: "experiment.feature_whitelist.save",
+  description: "Create or modify a Feature whitelist rule and optionally enable it.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "feature-key", type: "string", required: true, desc: "Existing Feature key." },
+    { name: "rule-id", type: "string", desc: "Existing whitelist rule ID; omit to create a new rule." },
+    { name: "priority", type: "number", desc: "Rule priority; omitted create requests use the server-assigned next priority." },
+    { name: "status", type: "string", default: "draft", desc: "Rule status: draft, enable, or disable." },
+    {
+      name: "whitelist",
+      type: "json",
+      required: true,
+      desc: 'Whitelist bucket array: [{"bucket_id":"#user_id","rules":[{"ids":["u1"],"value":"on"}]}].'
+    }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    buildInput6(ctx);
+  },
+  buildInput: buildInput6
+});
+
+// src/commands/te-experiment/feature-whitelist/update-status.ts
+function buildBody2(ctx) {
+  const status = ctx.str("status");
+  if (!["enable", "disable"].includes(status)) {
+    throw new Error("Flag --status must be one of enable, disable");
+  }
+  return { project_id: ctx.num("project-id"), rule_id: ctx.str("rule-id"), status };
+}
+var featureWhitelistUpdateStatus = createExperimentCapabilityCommand({
+  resource: "feature whitelist",
+  command: "update-status",
+  capabilityId: "experiment.feature_whitelist.update_status",
+  description: "Enable or disable a Feature whitelist rule; enabled rules sync an online Feature to RCC.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "rule-id", type: "string", required: true, desc: "Whitelist rule ID." },
+    { name: "status", type: "string", required: true, desc: "Target status: enable or disable." }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    buildBody2(ctx);
+  },
+  buildInput: buildBody2
+});
+
 // src/commands/te-experiment/metric/delete.ts
 var metricDelete = createExperimentCapabilityCommand({
   resource: "metric",
@@ -442,6 +651,78 @@ var metricList = createExperimentCapabilityCommand({
 });
 
 // src/commands/te-experiment/metric/save.ts
+var aggregations = /* @__PURE__ */ new Set([
+  "total_count",
+  "user_count",
+  "active_days",
+  "sum",
+  "avg",
+  "max",
+  "distinct_count"
+]);
+var propertyAggregations = /* @__PURE__ */ new Set(["sum", "avg", "max", "distinct_count"]);
+var metricDefinitionFields = /* @__PURE__ */ new Set([
+  "type",
+  "event",
+  "aggregation",
+  "property",
+  "filters"
+]);
+function validateMetricFilters(rawFilters) {
+  if (rawFilters === void 0) return;
+  if (!rawFilters || typeof rawFilters !== "object" || Array.isArray(rawFilters)) {
+    throw new Error("Flag --req.metricDefinition.filters must be a JSON object");
+  }
+  const filters = rawFilters;
+  if (!["and", "or"].includes(String(filters.relation))) {
+    throw new Error("Flag --req.metricDefinition.filters.relation must be one of: and, or");
+  }
+  if (!Array.isArray(filters.items) || filters.items.length === 0) {
+    throw new Error("Flag --req.metricDefinition.filters.items must be a non-empty array");
+  }
+  filters.items.forEach((rawItem, index) => {
+    const path = `Flag --req.metricDefinition.filters.items[${index}]`;
+    if (!rawItem || typeof rawItem !== "object" || Array.isArray(rawItem)) {
+      throw new Error(`${path} must be a JSON object`);
+    }
+    const item = rawItem;
+    const field = item.field;
+    const validField = typeof field === "string" && field.trim() !== "" || Boolean(field && typeof field === "object" && !Array.isArray(field) && typeof field.name === "string" && String(field.name).trim() !== "");
+    if (!validField) throw new Error(`${path}.field is required`);
+    if (typeof item.operator !== "string" || item.operator.trim() === "") {
+      throw new Error(`${path}.operator is required and expresses the property comparison`);
+    }
+    if (!Array.isArray(item.values)) {
+      throw new Error(`${path}.values must be an array containing the comparison value(s)`);
+    }
+  });
+}
+function validateMetricSaveRequest(req) {
+  const rawDefinition = req.metricDefinition;
+  if (rawDefinition === void 0 && req.update === true) return;
+  if (!rawDefinition || typeof rawDefinition !== "object" || Array.isArray(rawDefinition)) {
+    throw new Error("Flag --req.metricDefinition must be a JSON object");
+  }
+  const definition = rawDefinition;
+  for (const field of Object.keys(definition)) {
+    if (!metricDefinitionFields.has(field)) {
+      throw new Error(`Flag --req.metricDefinition.${field} is not supported`);
+    }
+  }
+  if (definition.type !== "event") {
+    throw new Error("Flag --req.metricDefinition.type must be event");
+  }
+  if (typeof definition.event !== "string" || definition.event.trim() === "") {
+    throw new Error("Flag --req.metricDefinition.event is required");
+  }
+  if (typeof definition.aggregation !== "string" || !aggregations.has(definition.aggregation)) {
+    throw new Error(`Flag --req.metricDefinition.aggregation must be one of: ${[...aggregations].join(", ")}`);
+  }
+  if (propertyAggregations.has(definition.aggregation) && (typeof definition.property !== "string" || definition.property.trim() === "")) {
+    throw new Error(`Flag --req.metricDefinition.property is required for ${definition.aggregation}`);
+  }
+  validateMetricFilters(definition.filters);
+}
 var metricSave = createExperimentCapabilityCommand({
   resource: "metric",
   command: "save",
@@ -453,12 +734,12 @@ var metricSave = createExperimentCapabilityCommand({
       name: "req",
       type: "json",
       required: true,
-      desc: "Native camelCase request; use metricDefinition, never metricConfig or calcType."
+      desc: "Native camelCase request. Property comparisons use metricDefinition.filters={relation,items:[{field,operator,values}]}. Never use metricConfig, calcType, or raw filts."
     }
   ],
   risk: "write",
   validate: (ctx) => {
-    readRequiredObject(ctx, "req");
+    validateMetricSaveRequest(readRequiredObject(ctx, "req"));
   },
   buildInput: (ctx) => ({ project_id: ctx.num("project-id"), req: readRequiredObject(ctx, "req") })
 });
@@ -709,6 +990,7 @@ var commands = [
   experimentConflictCheck,
   experimentManage,
   experimentUpdateGroup,
+  experimentUpdateMetrics,
   experimentBatchDelete,
   operationLogQuery,
   saveBuildGuide,
@@ -731,6 +1013,10 @@ var commands = [
   featureVersionList,
   featureOperationLogQuery,
   featureBatchDelete,
+  featureWhitelistList,
+  featureWhitelistSave,
+  featureWhitelistUpdateStatus,
+  featureWhitelistBatchDelete,
   bucketList
 ];
 var te_experiment_default = commands;
@@ -746,6 +1032,7 @@ export {
   experimentReadyCheck,
   experimentSave,
   experimentUpdateGroup,
+  experimentUpdateMetrics,
   featureBatchDelete,
   featureGet,
   featureList,
@@ -753,6 +1040,10 @@ export {
   featureSave,
   featureUpdateStatus,
   featureVersionList,
+  featureWhitelistBatchDelete,
+  featureWhitelistList,
+  featureWhitelistSave,
+  featureWhitelistUpdateStatus,
   metricDelete,
   metricGet,
   metricList,