@thinkingai/ae-cli 6.1.20 → 6.1.23

package/dist/{chunk-VXNMYUXU.js → chunk-57RRFUEZ.js}

@@ -1,17 +1,17 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   CapabilityGatewayError
-} from "./chunk-QJQZH5GQ.js";
+} from "./chunk-HFGZGYCG.js";
 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/mcp-access.ts
 function buildUrl(host, path, params = {}) {
@@ -137,6 +137,7 @@ async function fetchWithCliToken(input, init, cliToken, options = {}) {
   const headers = new Headers(init.headers);
   headers.set("cli-token", cliToken);
   const resp = await fetch(input, { ...init, headers });
+  if (options.responseType === "empty" && resp.status === 204) return null;
   if (options.responseType === "bytes" && resp.ok) {
     if (resp.headers.get("content-type")?.includes("application/json")) {
       parseKbResponse(resp, await resp.text(), options);
@@ -147,13 +148,28 @@ async function fetchWithCliToken(input, init, cliToken, options = {}) {
       contentType: resp.headers.get("content-type") ?? "application/octet-stream"
     };
   }
-  return parseKbResponse(resp, await resp.text(), options);
+  const result = parseKbResponse(resp, await resp.text(), options);
+  if (options.responseType === "empty") {
+    throw new Error(`KB API protocol error: expected HTTP 204, received ${resp.status}`);
+  }
+  return result;
 }
 async function requestWithCliToken(host, input, init, options) {
+  const originalToken = await getCliToken(host);
   try {
-    return await fetchWithCliToken(input, init, await getCliToken(host), options);
+    return await fetchWithCliToken(input, init, originalToken, options);
   } catch (error) {
     if (error instanceof KbUnauthorizedError) {
+      if (options.retryUnauthorized === true) {
+        const refreshedToken = await getCliToken(host);
+        if (refreshedToken !== originalToken) {
+          try {
+            return await fetchWithCliToken(input, init, refreshedToken, options);
+          } catch (retryError) {
+            if (!(retryError instanceof KbUnauthorizedError)) throw retryError;
+          }
+        }
+      }
       throw new SecureStoreAuthError(
         `The stored CLI token for ${host} is invalid or expired. Run: ae-cli auth login --host ${host}`
       );
@@ -188,7 +204,7 @@ async function kbUpload(ctx, path, form, params = {}, options = {}) {
     host,
     buildUrl(host, path, params),
     {
-      method: "POST",
+      method: options.method ?? "POST",
       body: form
     },
     uploadOptions

package/dist/{chunk-WZ6YVQSF.js → chunk-7FTTULED.js}

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   logger
-} from "./chunk-4P355ZWB.js";
+} from "./chunk-MAPZ7VB6.js";
 
 // src/core/url-utils.ts
 function normalizeUrl(url) {

package/dist/{chunk-ATSM5XAW.js → chunk-7XGFSUOM.js}

@@ -6,11 +6,11 @@ import {
   normalizeUrl,
   safeJsonParse,
   safeReadJsonFile
-} from "./chunk-WZ6YVQSF.js";
+} from "./chunk-7FTTULED.js";
 import {
   PermissionError,
   logger
-} from "./chunk-4P355ZWB.js";
+} from "./chunk-MAPZ7VB6.js";
 
 // src/core/secure-store.ts
 import crypto from "crypto";

package/dist/chunk-CCS66K4K.js

@@ -0,0 +1,155 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  dryRunCapability,
+  executeCapabilityWithEnvelope,
+  validateCapability
+} from "./chunk-HFGZGYCG.js";
+import {
+  resolveGatewayDomain
+} from "./chunk-KPQY44JQ.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-I4WQAEYB.js → chunk-DVMLWQD4.js}

@@ -1,64 +1,15 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  require_inherits,
+  require_isarray,
+  require_node,
+  require_process_nextick_args,
+  require_util
+} from "./chunk-V2NUHPXF.js";
 import {
   __commonJS,
   __require
-} from "./chunk-4P355ZWB.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]";
-    };
-  }
-});
+} from "./chunk-MAPZ7VB6.js";
 
 // node_modules/jszip/node_modules/readable-stream/lib/internal/streams/stream.js
 var require_stream = __commonJS({
@@ -126,125 +77,6 @@ var require_safe_buffer = __commonJS({
   }
 });
 
-// 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/jszip/node_modules/readable-stream/lib/internal/streams/BufferList.js
 var require_BufferList = __commonJS({
   "node_modules/jszip/node_modules/readable-stream/lib/internal/streams/BufferList.js"(exports, module) {
@@ -392,14 +224,6 @@ var require_destroy = __commonJS({
   }
 });
 
-// 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;
-  }
-});
-
 // node_modules/jszip/node_modules/readable-stream/lib/_stream_writable.js
 var require_stream_writable = __commonJS({
   "node_modules/jszip/node_modules/readable-stream/lib/_stream_writable.js"(exports, module) {
@@ -9746,7 +9570,5 @@ var require_lib3 = __commonJS({
 });
 
 export {
-  require_inherits,
-  require_node,
   require_lib3 as require_lib
 };

package/dist/{chunk-CZU3V3DQ.js → chunk-DX5CDO34.js}

@@ -1,16 +1,16 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   peekCliToken
-} from "./chunk-ATSM5XAW.js";
+} from "./chunk-7XGFSUOM.js";
 import {
   getActiveHost,
   getConfigDir,
   isAeSandboxRuntime,
   normalizeUrl
-} from "./chunk-WZ6YVQSF.js";
+} from "./chunk-7FTTULED.js";
 import {
   logger
-} from "./chunk-4P355ZWB.js";
+} from "./chunk-MAPZ7VB6.js";
 
 // src/core/version-sync.ts
 import { spawnSync } from "child_process";
@@ -893,6 +893,13 @@ var KNOWN_ARRAY_FIELDS = [
 var OUTPUT_METADATA = /* @__PURE__ */ Symbol("ae-cli-output-metadata");
 function withOutputMetadata(data, meta) {
   if (!meta || Object.keys(meta).length === 0) return data;
+  if (isOutputWithMetadata(data)) {
+    return {
+      [OUTPUT_METADATA]: true,
+      data: data.data,
+      meta: { ...data.meta, ...meta }
+    };
+  }
   return {
     [OUTPUT_METADATA]: true,
     data,
@@ -925,7 +932,7 @@ function formatTable(data) {
     const table2 = new Table({ head: headers, wordWrap: true });
     for (const row of data.rows) {
       const values = Array.isArray(row) ? row : [row];
-      table2.push(headers.map((_, index) => {
+      table2.push(headers.map((_header, index) => {
         const value = values[index];
         if (value === void 0 || value === null) return "";
         if (typeof value === "object") return JSON.stringify(value);
@@ -967,7 +974,8 @@ async function applyJq(data, expr) {
     const message = err instanceof JqError ? err.message : err?.message || String(err);
     const error = new Error(`Invalid --jq expression: ${message}`);
     error.type = "validation";
-    error.hint = "Use standard jq syntax, e.g. .status or {status,pendingQuestion}";
+    error.code = "OUTPUT_PROJECTION_FAILED";
+    error.hint = "The command completed. Original data and metadata are preserved in stdout; fix the jq expression locally without executing the command again. --jq applies to the command data before envelope wrapping.";
     throw error;
   }
   if (results.length === 0) return null;
@@ -1015,7 +1023,20 @@ function printError(type, message, hint, code, meta, options = {}) {
   }
 }
 async function printOutput(data, format, jqExpr) {
-  process.stdout.write(await formatOutput(data, format, jqExpr) + "\n");
+  try {
+    process.stdout.write(await formatOutput(data, format, jqExpr) + "\n");
+  } catch (error) {
+    if (error?.code === "OUTPUT_PROJECTION_FAILED") {
+      const recovery = JSON.parse(formatError("validation", error.message, error.hint, error.code, readOutputMetadata(data)));
+      await new Promise((resolve, reject) => {
+        process.stdout.write(
+          JSON.stringify({ ...recovery, data: unwrapOutputData(data) }, null, 2) + "\n",
+          (error2) => error2 ? reject(error2) : resolve()
+        );
+      });
+    }
+    throw error;
+  }
 }
 
 export {