@thinkingai/ae-cli 6.1.18 → 6.1.20

package/dist/{te-engage-KZPR5R22.js → te-engage-4XG6OJML.js}

@@ -1,29 +1,28 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   createCapabilityCommand
-} from "./chunk-Y3LOALAV.js";
-import {
-  registerCapabilityGatewayRoute,
-  resolveGatewayDomain
-} from "./chunk-3KWQYGYI.js";
-import {
-  printError,
-  withOutputMetadata
-} from "./chunk-BYYS3ANB.js";
+} from "./chunk-TAL6CZH6.js";
 import {
   CapabilityGatewayError,
   buildCapabilityGatewayUrl,
   fetchCapabilityGateway,
   requestCapabilityGateway,
   requestCapabilityGatewayWithEnvelope
-} from "./chunk-ZQ47LWTI.js";
-import "./chunk-SERWF6G5.js";
-import "./chunk-J2DEBMRF.js";
-import "./chunk-ZQKDZXDO.js";
-import "./chunk-3FY3RJ26.js";
+} from "./chunk-QJQZH5GQ.js";
+import {
+  registerCapabilityGatewayRoute,
+  resolveGatewayDomain
+} from "./chunk-TKHSULJT.js";
+import {
+  printError,
+  withOutputMetadata
+} from "./chunk-CZU3V3DQ.js";
+import "./chunk-Y74WTIKJ.js";
+import "./chunk-ATSM5XAW.js";
+import "./chunk-WZ6YVQSF.js";
 import {
   CliValidationError
-} from "./chunk-UW5UN47B.js";
-import "./chunk-JHENBQ5B.js";
+} from "./chunk-4P355ZWB.js";
 
 // src/commands/te-engage/shared.ts
 function createEngageCapabilityCommand(cliService, config) {
@@ -323,6 +322,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 +337,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 +373,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 +678,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 +4680,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-6BITX4RD.js → te-experiment-VXUWPINJ.js}

@@ -1,17 +1,16 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   createCapabilityCommand
-} from "./chunk-JRJY5DMJ.js";
+} from "./chunk-TAL6CZH6.js";
+import "./chunk-QJQZH5GQ.js";
 import {
   registerCapabilityGatewayRoute
-} from "./chunk-3KWQYGYI.js";
-import "./chunk-BYYS3ANB.js";
-import "./chunk-OMPRXM3V.js";
-import "./chunk-6EIJSNBD.js";
-import "./chunk-J2DEBMRF.js";
-import "./chunk-ZQKDZXDO.js";
-import "./chunk-3FY3RJ26.js";
-import "./chunk-UW5UN47B.js";
-import "./chunk-JHENBQ5B.js";
+} from "./chunk-TKHSULJT.js";
+import "./chunk-CZU3V3DQ.js";
+import "./chunk-Y74WTIKJ.js";
+import "./chunk-ATSM5XAW.js";
+import "./chunk-WZ6YVQSF.js";
+import "./chunk-4P355ZWB.js";
 
 // src/commands/te-experiment/capability-shared.ts
 function createExperimentCapabilityCommand(config) {
@@ -650,6 +649,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",
@@ -661,12 +732,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") })
 });