@thinkingai/ae-cli 6.0.48 → 6.0.49

package/dist/{chunk-BBEFP4SB.js → chunk-HBGADCKA.js}

@@ -4,14 +4,14 @@ import {
 } from "./chunk-Y74WTIKJ.js";
 import {
   getCliToken
-} from "./chunk-ATSM5XAW.js";
+} from "./chunk-7XGFSUOM.js";
 import {
   getActiveHost,
   getSandboxRuntimeRoot
-} from "./chunk-WZ6YVQSF.js";
+} from "./chunk-7FTTULED.js";
 import {
   PermissionError
-} from "./chunk-4P355ZWB.js";
+} from "./chunk-MAPZ7VB6.js";
 
 // src/core/te-agent-credentials.ts
 import { readFileSync } from "fs";

package/dist/{chunk-QJQZH5GQ.js → chunk-HFGZGYCG.js}

@@ -5,30 +5,32 @@ import {
 import {
   SecureStoreAuthError,
   getCliToken
-} from "./chunk-ATSM5XAW.js";
+} from "./chunk-7XGFSUOM.js";
 import {
   safeJsonParse
-} from "./chunk-WZ6YVQSF.js";
+} from "./chunk-7FTTULED.js";
 import {
   PermissionError
-} from "./chunk-4P355ZWB.js";
+} from "./chunk-MAPZ7VB6.js";
 
 // src/core/capability-api.ts
 import { readFile } from "fs/promises";
 import { basename } from "path";
 var CapabilityGatewayError = class extends Error {
-  constructor(message, code, httpStatus, hint, meta) {
+  constructor(message, code, httpStatus, hint, meta, type = "api") {
     super(message);
     this.code = code;
     this.httpStatus = httpStatus;
     this.hint = hint;
     this.meta = meta;
+    this.type = type;
     this.name = "CapabilityGatewayError";
   }
   code;
   httpStatus;
   hint;
   meta;
+  type;
 };
 function buildCapabilityGatewayUrl(host, domain, pathAfterV1, queryParams = {}) {
   const base = host.replace(/\/+$/, "");
@@ -93,7 +95,8 @@ function parseCapabilityEnvelope(body) {
       code,
       err.http_status ?? err.httpStatus,
       hint,
-      isRecord(body.meta) ? body.meta : void 0
+      isRecord(body.meta) ? body.meta : void 0,
+      err.type === "validation" ? "validation" : "api"
     );
   }
   return { ok: true, data: body };
@@ -121,7 +124,8 @@ function buildCapabilityHttpError(resp, body) {
         code,
         resp.status,
         hint,
-        isRecord(body.meta) ? body.meta : void 0
+        isRecord(body.meta) ? body.meta : void 0,
+        err.type === "validation" ? "validation" : "api"
       );
     }
   }

package/dist/{chunk-ECBLHAZO.js → chunk-JOCDD4ON.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from 'node:module'; const require =
 import {
   getActiveHost,
   normalizeUrl
-} from "./chunk-WZ6YVQSF.js";
+} from "./chunk-7FTTULED.js";
 
 // src/core/auth.ts
 function resolveHost(hostOverride) {

package/dist/{chunk-TKHSULJT.js → chunk-KPQY44JQ.js}

@@ -22,6 +22,11 @@ function findGatewayDomain(cliService) {
 function listRegisteredCapabilityDomains() {
   return [...cliServiceRoutes.keys()].sort();
 }
+function listCapabilityDiscoveryPrefixes(cliService) {
+  const route = cliServiceRoutes.get(cliService);
+  const rawPrefixes = route?.capabilityPrefixes?.length ? route.capabilityPrefixes : [cliService];
+  return [...new Set(rawPrefixes.map((prefix) => prefix.trim().toLowerCase()).filter(Boolean).map((prefix) => prefix.endsWith(".") ? prefix : `${prefix}.`))];
+}
 function resolveGatewayDomain(cliService, override) {
   const envDomain = envGatewayDomain(cliService);
   if (envDomain !== void 0) {
@@ -43,5 +48,6 @@ export {
   registerCapabilityGatewayRoute,
   findGatewayDomain,
   listRegisteredCapabilityDomains,
+  listCapabilityDiscoveryPrefixes,
   resolveGatewayDomain
 };

package/dist/chunk-L2QUIZTS.js

@@ -0,0 +1,155 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  resolveGatewayDomain
+} from "./chunk-KPQY44JQ.js";
+import {
+  dryRunCapability,
+  executeCapabilityWithEnvelope,
+  validateCapability
+} from "./chunk-HFGZGYCG.js";
+import {
+  withOutputMetadata
+} from "./chunk-DX5CDO34.js";
+import {
+  CliValidationError
+} from "./chunk-MAPZ7VB6.js";
+
+// src/core/definition-intent.ts
+import { createHash } from "crypto";
+var definitionIntentSnapshotFlag = {
+  name: "intent-snapshot",
+  type: "json",
+  required: false,
+  desc: 'Optional user-confirmed intent snapshot: {"schema_version":1,"requirement":"...","definition":{...}}. ae-cli rejects drift between this snapshot and the final definition before validate, dry-run, or execute. The snapshot is not sent to the Gateway.'
+};
+var modelDefinitionIntentSnapshotFlag = {
+  name: "intent-snapshot",
+  type: "json",
+  required: false,
+  desc: 'Optional user-confirmed intent snapshot: {"schema_version":1,"requirement":"...","model_type":"event","definition":{...}}. ae-cli rejects drift between this snapshot and the final model-type/definition before validate, dry-run, or execute. The snapshot is not sent to the Gateway.'
+};
+function verifyDefinitionIntent(ctx, config) {
+  const snapshotFlag = config.snapshotFlag ?? "intent-snapshot";
+  const snapshot = ctx.json(snapshotFlag);
+  if (snapshot === void 0) return void 0;
+  if (!isRecord(snapshot) || snapshot.schema_version !== 1) {
+    throw mismatch("Intent snapshot must be an object with schema_version=1.");
+  }
+  if (typeof snapshot.requirement !== "string" || snapshot.requirement.trim().length === 0) {
+    throw mismatch("Intent snapshot requirement must be a non-empty string.");
+  }
+  if (!Object.prototype.hasOwnProperty.call(snapshot, "definition")) {
+    throw mismatch("Intent snapshot must include definition.");
+  }
+  const definitionFlag = config.definitionFlag ?? "definition";
+  const finalDefinition = ctx.json(definitionFlag);
+  if (finalDefinition === void 0 || !jsonEqual(snapshot.definition, finalDefinition)) {
+    throw mismatch("Final definition does not match the user-confirmed intent snapshot.");
+  }
+  if (config.modelTypeFlag) {
+    const finalModelType = ctx.str(config.modelTypeFlag);
+    if (typeof snapshot.model_type !== "string" || snapshot.model_type !== finalModelType) {
+      throw mismatch("Final model type does not match the user-confirmed intent snapshot.");
+    }
+  }
+  return {
+    checked: true,
+    matched: true,
+    schema_version: 1,
+    snapshot_sha256: createHash("sha256").update(canonicalJson(snapshot)).digest("hex")
+  };
+}
+function mismatch(message) {
+  return new CliValidationError(message, {
+    code: "DEFINITION_INTENT_MISMATCH",
+    hint: "Rebuild the final definition from the confirmed snapshot, or ask the user to confirm a new snapshot."
+  });
+}
+function jsonEqual(left, right) {
+  return canonicalJson(left) === canonicalJson(right);
+}
+function canonicalJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJson).join(",")}]`;
+  }
+  if (isRecord(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+  }
+  const encoded = JSON.stringify(value);
+  return encoded === void 0 ? "null" : encoded;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/core/capability-command.ts
+import { randomBytes } from "crypto";
+function createCapabilityCommand(config) {
+  return {
+    service: config.cliService,
+    resource: config.resource,
+    command: config.command,
+    capabilityId: config.capabilityId,
+    description: config.description,
+    helpText: config.helpText,
+    flags: config.flags,
+    risk: config.risk,
+    validate: config.validate || config.intentConsistency ? (ctx) => {
+      config.validate?.(ctx);
+      if (config.intentConsistency) verifyDefinitionIntent(ctx, config.intentConsistency);
+    } : void 0,
+    preflight: (ctx) => {
+      config.buildInput(ctx);
+    },
+    validateInput: async (ctx) => {
+      const gatewayDomain = resolveGatewayDomain(config.cliService, config.gatewayDomain);
+      const requestHost = config.requestHost ?? ctx.host();
+      const input = withLifecycleRequestId(config, config.buildInput(ctx));
+      const evidence = config.intentConsistency ? verifyDefinitionIntent(ctx, config.intentConsistency) : void 0;
+      const intentMeta = evidence ? { intent_consistency: evidence } : void 0;
+      return withOutputMetadata(await validateCapability(requestHost, gatewayDomain, config.capabilityId, input), intentMeta);
+    },
+    dryRun: async (ctx) => {
+      const gatewayDomain = resolveGatewayDomain(config.cliService, config.gatewayDomain);
+      const requestHost = config.requestHost ?? ctx.host();
+      const input = withLifecycleRequestId(config, config.buildInput(ctx));
+      const evidence = config.intentConsistency ? verifyDefinitionIntent(ctx, config.intentConsistency) : void 0;
+      const intentMeta = evidence ? { intent_consistency: evidence } : void 0;
+      return withOutputMetadata(await dryRunCapability(requestHost, gatewayDomain, config.capabilityId, input), intentMeta);
+    },
+    execute: async (ctx) => {
+      const gatewayDomain = resolveGatewayDomain(config.cliService, config.gatewayDomain);
+      const requestHost = config.requestHost ?? ctx.host();
+      const input = withLifecycleRequestId(config, config.buildInput(ctx));
+      const evidence = config.intentConsistency ? verifyDefinitionIntent(ctx, config.intentConsistency) : void 0;
+      const intentMeta = evidence ? { intent_consistency: evidence } : void 0;
+      announceDispatch(config.capabilityId, input);
+      const result = await executeCapabilityWithEnvelope(requestHost, gatewayDomain, config.capabilityId, input);
+      const data = config.postProcess ? await config.postProcess(result.data, input, ctx) : result.data;
+      return withOutputMetadata(data, { ...result.meta, ...intentMeta });
+    }
+  };
+}
+function withLifecycleRequestId(config, input) {
+  if (!config.flags.some((flag) => flag.name === "request-id")) {
+    return input;
+  }
+  const supplied = input.request_id;
+  const requestId = typeof supplied === "string" && supplied.length > 0 ? supplied : `cli_${randomBytes(16).toString("hex")}`;
+  return { ...input, request_id: requestId };
+}
+function announceDispatch(capabilityId, input) {
+  if (typeof input.request_id !== "string") {
+    return;
+  }
+  process.stderr.write(
+    `[ae-cli] dispatching capability=${capabilityId} request_id=${input.request_id}
+`
+  );
+}
+
+export {
+  definitionIntentSnapshotFlag,
+  modelDefinitionIntentSnapshotFlag,
+  createCapabilityCommand
+};

package/dist/{chunk-4P355ZWB.js → chunk-MAPZ7VB6.js}

@@ -11,8 +11,24 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
 var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -30,6 +46,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/core/logger.ts
 import fs from "fs";
@@ -180,8 +197,11 @@ var LocalDataUploadError = class extends Error {
 
 export {
   __require,
+  __esm,
   __commonJS,
+  __export,
   __toESM,
+  __toCommonJS,
   logger,
   PermissionError,
   CliValidationError,

package/dist/chunk-V2NUHPXF.js

@@ -0,0 +1,196 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require
+} from "./chunk-MAPZ7VB6.js";
+
+// node_modules/process-nextick-args/index.js
+var require_process_nextick_args = __commonJS({
+  "node_modules/process-nextick-args/index.js"(exports, module) {
+    "use strict";
+    if (typeof process === "undefined" || !process.version || process.version.indexOf("v0.") === 0 || process.version.indexOf("v1.") === 0 && process.version.indexOf("v1.8.") !== 0) {
+      module.exports = { nextTick };
+    } else {
+      module.exports = process;
+    }
+    function nextTick(fn, arg1, arg2, arg3) {
+      if (typeof fn !== "function") {
+        throw new TypeError('"callback" argument must be a function');
+      }
+      var len = arguments.length;
+      var args, i;
+      switch (len) {
+        case 0:
+        case 1:
+          return process.nextTick(fn);
+        case 2:
+          return process.nextTick(function afterTickOne() {
+            fn.call(null, arg1);
+          });
+        case 3:
+          return process.nextTick(function afterTickTwo() {
+            fn.call(null, arg1, arg2);
+          });
+        case 4:
+          return process.nextTick(function afterTickThree() {
+            fn.call(null, arg1, arg2, arg3);
+          });
+        default:
+          args = new Array(len - 1);
+          i = 0;
+          while (i < args.length) {
+            args[i++] = arguments[i];
+          }
+          return process.nextTick(function afterTick() {
+            fn.apply(null, args);
+          });
+      }
+    }
+  }
+});
+
+// node_modules/isarray/index.js
+var require_isarray = __commonJS({
+  "node_modules/isarray/index.js"(exports, module) {
+    "use strict";
+    var toString = {}.toString;
+    module.exports = Array.isArray || function(arr) {
+      return toString.call(arr) == "[object Array]";
+    };
+  }
+});
+
+// node_modules/core-util-is/lib/util.js
+var require_util = __commonJS({
+  "node_modules/core-util-is/lib/util.js"(exports) {
+    "use strict";
+    function isArray(arg) {
+      if (Array.isArray) {
+        return Array.isArray(arg);
+      }
+      return objectToString(arg) === "[object Array]";
+    }
+    exports.isArray = isArray;
+    function isBoolean(arg) {
+      return typeof arg === "boolean";
+    }
+    exports.isBoolean = isBoolean;
+    function isNull(arg) {
+      return arg === null;
+    }
+    exports.isNull = isNull;
+    function isNullOrUndefined(arg) {
+      return arg == null;
+    }
+    exports.isNullOrUndefined = isNullOrUndefined;
+    function isNumber(arg) {
+      return typeof arg === "number";
+    }
+    exports.isNumber = isNumber;
+    function isString(arg) {
+      return typeof arg === "string";
+    }
+    exports.isString = isString;
+    function isSymbol(arg) {
+      return typeof arg === "symbol";
+    }
+    exports.isSymbol = isSymbol;
+    function isUndefined(arg) {
+      return arg === void 0;
+    }
+    exports.isUndefined = isUndefined;
+    function isRegExp(re) {
+      return objectToString(re) === "[object RegExp]";
+    }
+    exports.isRegExp = isRegExp;
+    function isObject(arg) {
+      return typeof arg === "object" && arg !== null;
+    }
+    exports.isObject = isObject;
+    function isDate(d) {
+      return objectToString(d) === "[object Date]";
+    }
+    exports.isDate = isDate;
+    function isError(e) {
+      return objectToString(e) === "[object Error]" || e instanceof Error;
+    }
+    exports.isError = isError;
+    function isFunction(arg) {
+      return typeof arg === "function";
+    }
+    exports.isFunction = isFunction;
+    function isPrimitive(arg) {
+      return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
+      typeof arg === "undefined";
+    }
+    exports.isPrimitive = isPrimitive;
+    exports.isBuffer = __require("buffer").Buffer.isBuffer;
+    function objectToString(o) {
+      return Object.prototype.toString.call(o);
+    }
+  }
+});
+
+// node_modules/inherits/inherits_browser.js
+var require_inherits_browser = __commonJS({
+  "node_modules/inherits/inherits_browser.js"(exports, module) {
+    "use strict";
+    if (typeof Object.create === "function") {
+      module.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          ctor.prototype = Object.create(superCtor.prototype, {
+            constructor: {
+              value: ctor,
+              enumerable: false,
+              writable: true,
+              configurable: true
+            }
+          });
+        }
+      };
+    } else {
+      module.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          var TempCtor = function() {
+          };
+          TempCtor.prototype = superCtor.prototype;
+          ctor.prototype = new TempCtor();
+          ctor.prototype.constructor = ctor;
+        }
+      };
+    }
+  }
+});
+
+// node_modules/inherits/inherits.js
+var require_inherits = __commonJS({
+  "node_modules/inherits/inherits.js"(exports, module) {
+    "use strict";
+    try {
+      util = __require("util");
+      if (typeof util.inherits !== "function") throw "";
+      module.exports = util.inherits;
+    } catch (e) {
+      module.exports = require_inherits_browser();
+    }
+    var util;
+  }
+});
+
+// node_modules/util-deprecate/node.js
+var require_node = __commonJS({
+  "node_modules/util-deprecate/node.js"(exports, module) {
+    "use strict";
+    module.exports = __require("util").deprecate;
+  }
+});
+
+export {
+  require_process_nextick_args,
+  require_isarray,
+  require_util,
+  require_inherits,
+  require_node
+};

package/dist/{chunk-HPLNYQPM.js → chunk-WEPZ5M3Z.js}

@@ -1,20 +1,20 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   resolveGatewayDomain
-} from "./chunk-TKHSULJT.js";
+} from "./chunk-KPQY44JQ.js";
 import {
   CapabilityGatewayError,
   fetchCapabilityGateway,
   requestCapabilityGateway
-} from "./chunk-QJQZH5GQ.js";
+} from "./chunk-HFGZGYCG.js";
 import {
   readOutputMetadata,
   unwrapOutputData,
   withOutputMetadata
-} from "./chunk-CZU3V3DQ.js";
+} from "./chunk-DX5CDO34.js";
 import {
   PermissionError
-} from "./chunk-4P355ZWB.js";
+} from "./chunk-MAPZ7VB6.js";
 
 // src/core/analysis-async-artifact.ts
 import { randomBytes } from "crypto";
@@ -263,7 +263,7 @@ async function downloadAnalysisArtifact(host, runId, artifactId, output, options
     }
     tempPresent = true;
     const source = Readable.fromWeb(response.body);
-    await pipeline(source, createWriteStream(tempPath, { flags: "wx" }), {
+    await pipeline(source, createWriteStream(tempPath, { flags: "wx", mode: options.mode }), {
       signal: options.signal
     });
     const file = await stat(tempPath);

package/dist/{community-report-client-XXWGSBSD.js → community-report-client-CU22W53K.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from 'node:module'; const require =
 import {
   CommunityReportError,
   logger
-} from "./chunk-4P355ZWB.js";
+} from "./chunk-MAPZ7VB6.js";
 
 // src/core/community-report-client.ts
 var DEFAULT_TIMEOUT_MS = 3e4;

package/dist/{config-EXUGQN5T.js → config-XO3LI3SA.js}

@@ -10,8 +10,8 @@ import {
 import {
   printError,
   printOutput
-} from "./chunk-CZU3V3DQ.js";
-import "./chunk-ATSM5XAW.js";
+} from "./chunk-DX5CDO34.js";
+import "./chunk-7XGFSUOM.js";
 import {
   addHost,
   listHosts,
@@ -21,8 +21,8 @@ import {
   resolveHostSelector,
   setActiveHost,
   updateHostLabel
-} from "./chunk-WZ6YVQSF.js";
-import "./chunk-4P355ZWB.js";
+} from "./chunk-7FTTULED.js";
+import "./chunk-MAPZ7VB6.js";
 
 // src/commands/config.ts
 import * as readline2 from "readline";

package/dist/context-IFJI3LIT.js

@@ -0,0 +1,46 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  getFromMainApp
+} from "./chunk-HBGADCKA.js";
+import "./chunk-Y74WTIKJ.js";
+import "./chunk-7XGFSUOM.js";
+import "./chunk-7FTTULED.js";
+import {
+  CliValidationError
+} from "./chunk-MAPZ7VB6.js";
+
+// src/commands/context/current.ts
+var CURRENT_PAGE_CONTEXT_PATH = "/api/sandbox/agent/context/current";
+function createCurrentPageContextCommand(read = getFromMainApp, readConversationId = () => process.env.TE_AGENT_CONVERSATION_ID) {
+  return {
+    service: "context",
+    command: "+current",
+    description: "Read the current page context bound to the active Agent Run",
+    flags: [],
+    risk: "read",
+    usesAeHost: false,
+    execute: async () => {
+      const conversationId = readConversationId()?.trim();
+      if (!conversationId) {
+        throw new CliValidationError(
+          "Current page context is available only inside an active Agent Run.",
+          {
+            code: "CURRENT_PAGE_CONTEXT_RUN_REQUIRED",
+            hint: "Open AE Agent from a supported product page and ask about the current page."
+          }
+        );
+      }
+      const query = new URLSearchParams({ conversationId });
+      return read(`${CURRENT_PAGE_CONTEXT_PATH}?${query.toString()}`);
+    }
+  };
+}
+var currentPageContext = createCurrentPageContextCommand();
+
+// src/commands/context/index.ts
+var commands = [currentPageContext];
+var context_default = commands;
+export {
+  currentPageContext,
+  context_default as default
+};