@dam-agents/cli 0.2.6-rc1 → 0.2.7-rc1

package/dist/bin.js

@@ -7204,6 +7204,1261 @@ var require_websocket_server = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js
+var require_ms = __commonJS({
+  "../../node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js"(exports, module) {
+    "use strict";
+    var s = 1e3;
+    var m = s * 60;
+    var h2 = m * 60;
+    var d2 = h2 * 24;
+    var w3 = d2 * 7;
+    var y = d2 * 365.25;
+    module.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse4(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse4(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w3;
+        case "days":
+        case "day":
+        case "d":
+          return n * d2;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h2;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d2) {
+        return Math.round(ms / d2) + "d";
+      }
+      if (msAbs >= h2) {
+        return Math.round(ms / h2) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms / s) + "s";
+      }
+      return ms + "ms";
+    }
+    function fmtLong(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d2) {
+        return plural(ms, msAbs, d2, "day");
+      }
+      if (msAbs >= h2) {
+        return plural(ms, msAbs, h2, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms, msAbs, s, "second");
+      }
+      return ms + " ms";
+    }
+    function plural(ms, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js
+var require_common = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js"(exports, module) {
+    "use strict";
+    function setup(env) {
+      createDebug.debug = createDebug;
+      createDebug.default = createDebug;
+      createDebug.coerce = coerce;
+      createDebug.disable = disable;
+      createDebug.enable = enable;
+      createDebug.enabled = enabled;
+      createDebug.humanize = require_ms();
+      createDebug.destroy = destroy;
+      Object.keys(env).forEach((key) => {
+        createDebug[key] = env[key];
+      });
+      createDebug.names = [];
+      createDebug.skips = [];
+      createDebug.formatters = {};
+      function selectColor(namespace) {
+        let hash2 = 0;
+        for (let i = 0; i < namespace.length; i++) {
+          hash2 = (hash2 << 5) - hash2 + namespace.charCodeAt(i);
+          hash2 |= 0;
+        }
+        return createDebug.colors[Math.abs(hash2) % createDebug.colors.length];
+      }
+      createDebug.selectColor = selectColor;
+      function createDebug(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug(...args) {
+          if (!debug.enabled) {
+            return;
+          }
+          const self = debug;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self.diff = ms;
+          self.prev = prevTime;
+          self.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug.coerce(args[0]);
+          if (typeof args[0] !== "string") {
+            args.unshift("%O");
+          }
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%") {
+              return "%";
+            }
+            index++;
+            const formatter = createDebug.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug.formatArgs.call(self, args);
+          const logFn = self.log || createDebug.log;
+          logFn.apply(self, args);
+        }
+        debug.namespace = namespace;
+        debug.useColors = createDebug.useColors();
+        debug.color = createDebug.selectColor(namespace);
+        debug.extend = extend2;
+        debug.destroy = createDebug.destroy;
+        Object.defineProperty(debug, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug.namespaces) {
+              namespacesCache = createDebug.namespaces;
+              enabledCache = createDebug.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v2) => {
+            enableOverride = v2;
+          }
+        });
+        if (typeof createDebug.init === "function") {
+          createDebug.init(debug);
+        }
+        return debug;
+      }
+      function extend2(namespace, delimiter) {
+        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      function enable(namespaces) {
+        createDebug.save(namespaces);
+        createDebug.namespaces = namespaces;
+        createDebug.names = [];
+        createDebug.skips = [];
+        const split2 = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+        for (const ns of split2) {
+          if (ns[0] === "-") {
+            createDebug.skips.push(ns.slice(1));
+          } else {
+            createDebug.names.push(ns);
+          }
+        }
+      }
+      function matchesTemplate(search, template) {
+        let searchIndex = 0;
+        let templateIndex = 0;
+        let starIndex = -1;
+        let matchIndex = 0;
+        while (searchIndex < search.length) {
+          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+            if (template[templateIndex] === "*") {
+              starIndex = templateIndex;
+              matchIndex = searchIndex;
+              templateIndex++;
+            } else {
+              searchIndex++;
+              templateIndex++;
+            }
+          } else if (starIndex !== -1) {
+            templateIndex = starIndex + 1;
+            matchIndex++;
+            searchIndex = matchIndex;
+          } else {
+            return false;
+          }
+        }
+        while (templateIndex < template.length && template[templateIndex] === "*") {
+          templateIndex++;
+        }
+        return templateIndex === template.length;
+      }
+      function disable() {
+        const namespaces = [
+          ...createDebug.names,
+          ...createDebug.skips.map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug.enable("");
+        return namespaces;
+      }
+      function enabled(name) {
+        for (const skip of createDebug.skips) {
+          if (matchesTemplate(name, skip)) {
+            return false;
+          }
+        }
+        for (const ns of createDebug.names) {
+          if (matchesTemplate(name, ns)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function coerce(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
+        }
+        return val;
+      }
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+      createDebug.enable(createDebug.load());
+      return createDebug;
+    }
+    module.exports = setup;
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js"(exports, module) {
+    "use strict";
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      let m;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c2 = "color: " + this.color;
+      args.splice(1, 0, c2, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c2);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error51) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+      } catch (error51) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error51) {
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.j = function(v2) {
+      try {
+        return JSON.stringify(v2);
+      } catch (error51) {
+        return "[UnexpectedJSONParseError]: " + error51.message;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/node.js
+var require_node = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/node.js"(exports, module) {
+    "use strict";
+    var tty = __require("tty");
+    var util = __require("util");
+    exports.init = init;
+    exports.log = log;
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.destroy = util.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+    exports.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      const supportsColor = __require("supports-color");
+      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+        exports.colors = [
+          20,
+          21,
+          26,
+          27,
+          32,
+          33,
+          38,
+          39,
+          40,
+          41,
+          42,
+          43,
+          44,
+          45,
+          56,
+          57,
+          62,
+          63,
+          68,
+          69,
+          74,
+          75,
+          76,
+          77,
+          78,
+          79,
+          80,
+          81,
+          92,
+          93,
+          98,
+          99,
+          112,
+          113,
+          128,
+          129,
+          134,
+          135,
+          148,
+          149,
+          160,
+          161,
+          162,
+          163,
+          164,
+          165,
+          166,
+          167,
+          168,
+          169,
+          170,
+          171,
+          172,
+          173,
+          178,
+          179,
+          184,
+          185,
+          196,
+          197,
+          198,
+          199,
+          200,
+          201,
+          202,
+          203,
+          204,
+          205,
+          206,
+          207,
+          208,
+          209,
+          214,
+          215,
+          220,
+          221
+        ];
+      }
+    } catch (error51) {
+    }
+    exports.inspectOpts = Object.keys(process.env).filter((key) => {
+      return /^debug_/i.test(key);
+    }).reduce((obj, key) => {
+      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k2) => {
+        return k2.toUpperCase();
+      });
+      let val = process.env[key];
+      if (/^(yes|on|true|enabled)$/i.test(val)) {
+        val = true;
+      } else if (/^(no|off|false|disabled)$/i.test(val)) {
+        val = false;
+      } else if (val === "null") {
+        val = null;
+      } else {
+        val = Number(val);
+      }
+      obj[prop] = val;
+      return obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      const { namespace: name, useColors: useColors2 } = this;
+      if (useColors2) {
+        const c2 = this.color;
+        const colorCode = "\x1B[3" + (c2 < 8 ? c2 : "8;5;" + c2);
+        const prefix = `  ${colorCode};1m${name} \x1B[0m`;
+        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+        args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+      } else {
+        args[0] = getDate() + name + " " + args[0];
+      }
+    }
+    function getDate() {
+      if (exports.inspectOpts.hideDate) {
+        return "";
+      }
+      return (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
+    }
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        delete process.env.DEBUG;
+      }
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug) {
+      debug.inspectOpts = {};
+      const keys = Object.keys(exports.inspectOpts);
+      for (let i = 0; i < keys.length; i++) {
+        debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.o = function(v2) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v2, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+    };
+    formatters.O = function(v2) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v2, this.inspectOpts);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js
+var require_src2 = __commonJS({
+  "../../node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js"(exports, module) {
+    "use strict";
+    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+      module.exports = require_browser();
+    } else {
+      module.exports = require_node();
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/agent-base@7.1.4/node_modules/agent-base/dist/helpers.js
+var require_helpers = __commonJS({
+  "../../node_modules/.pnpm/agent-base@7.1.4/node_modules/agent-base/dist/helpers.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k2, k22) {
+      if (k22 === void 0) k22 = k2;
+      var desc = Object.getOwnPropertyDescriptor(m, k2);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k2];
+        } };
+      }
+      Object.defineProperty(o, k22, desc);
+    }) : (function(o, m, k2, k22) {
+      if (k22 === void 0) k22 = k2;
+      o[k22] = m[k2];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v2) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v2 });
+    }) : function(o, v2) {
+      o["default"] = v2;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k2 in mod) if (k2 !== "default" && Object.prototype.hasOwnProperty.call(mod, k2)) __createBinding(result, mod, k2);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.req = exports.json = exports.toBuffer = void 0;
+    var http = __importStar(__require("http"));
+    var https = __importStar(__require("https"));
+    async function toBuffer(stream) {
+      let length = 0;
+      const chunks = [];
+      for await (const chunk of stream) {
+        length += chunk.length;
+        chunks.push(chunk);
+      }
+      return Buffer.concat(chunks, length);
+    }
+    exports.toBuffer = toBuffer;
+    async function json2(stream) {
+      const buf = await toBuffer(stream);
+      const str = buf.toString("utf8");
+      try {
+        return JSON.parse(str);
+      } catch (_err) {
+        const err3 = _err;
+        err3.message += ` (input: ${str})`;
+        throw err3;
+      }
+    }
+    exports.json = json2;
+    function req(url2, opts = {}) {
+      const href = typeof url2 === "string" ? url2 : url2.href;
+      const req2 = (href.startsWith("https:") ? https : http).request(url2, opts);
+      const promise2 = new Promise((resolve4, reject) => {
+        req2.once("response", resolve4).once("error", reject).end();
+      });
+      req2.then = promise2.then.bind(promise2);
+      return req2;
+    }
+    exports.req = req;
+  }
+});
+
+// ../../node_modules/.pnpm/agent-base@7.1.4/node_modules/agent-base/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/.pnpm/agent-base@7.1.4/node_modules/agent-base/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k2, k22) {
+      if (k22 === void 0) k22 = k2;
+      var desc = Object.getOwnPropertyDescriptor(m, k2);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k2];
+        } };
+      }
+      Object.defineProperty(o, k22, desc);
+    }) : (function(o, m, k2, k22) {
+      if (k22 === void 0) k22 = k2;
+      o[k22] = m[k2];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v2) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v2 });
+    }) : function(o, v2) {
+      o["default"] = v2;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k2 in mod) if (k2 !== "default" && Object.prototype.hasOwnProperty.call(mod, k2)) __createBinding(result, mod, k2);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p2 in m) if (p2 !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p2)) __createBinding(exports2, m, p2);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Agent = void 0;
+    var net = __importStar(__require("net"));
+    var http = __importStar(__require("http"));
+    var https_1 = __require("https");
+    __exportStar(require_helpers(), exports);
+    var INTERNAL = /* @__PURE__ */ Symbol("AgentBaseInternalState");
+    var Agent = class extends http.Agent {
+      constructor(opts) {
+        super(opts);
+        this[INTERNAL] = {};
+      }
+      /**
+       * Determine whether this is an `http` or `https` request.
+       */
+      isSecureEndpoint(options) {
+        if (options) {
+          if (typeof options.secureEndpoint === "boolean") {
+            return options.secureEndpoint;
+          }
+          if (typeof options.protocol === "string") {
+            return options.protocol === "https:";
+          }
+        }
+        const { stack } = new Error();
+        if (typeof stack !== "string")
+          return false;
+        return stack.split("\n").some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
+      }
+      // In order to support async signatures in `connect()` and Node's native
+      // connection pooling in `http.Agent`, the array of sockets for each origin
+      // has to be updated synchronously. This is so the length of the array is
+      // accurate when `addRequest()` is next called. We achieve this by creating a
+      // fake socket and adding it to `sockets[origin]` and incrementing
+      // `totalSocketCount`.
+      incrementSockets(name) {
+        if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) {
+          return null;
+        }
+        if (!this.sockets[name]) {
+          this.sockets[name] = [];
+        }
+        const fakeSocket = new net.Socket({ writable: false });
+        this.sockets[name].push(fakeSocket);
+        this.totalSocketCount++;
+        return fakeSocket;
+      }
+      decrementSockets(name, socket) {
+        if (!this.sockets[name] || socket === null) {
+          return;
+        }
+        const sockets = this.sockets[name];
+        const index = sockets.indexOf(socket);
+        if (index !== -1) {
+          sockets.splice(index, 1);
+          this.totalSocketCount--;
+          if (sockets.length === 0) {
+            delete this.sockets[name];
+          }
+        }
+      }
+      // In order to properly update the socket pool, we need to call `getName()` on
+      // the core `https.Agent` if it is a secureEndpoint.
+      getName(options) {
+        const secureEndpoint = this.isSecureEndpoint(options);
+        if (secureEndpoint) {
+          return https_1.Agent.prototype.getName.call(this, options);
+        }
+        return super.getName(options);
+      }
+      createSocket(req, options, cb) {
+        const connectOpts = {
+          ...options,
+          secureEndpoint: this.isSecureEndpoint(options)
+        };
+        const name = this.getName(connectOpts);
+        const fakeSocket = this.incrementSockets(name);
+        Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
+          this.decrementSockets(name, fakeSocket);
+          if (socket instanceof http.Agent) {
+            try {
+              return socket.addRequest(req, connectOpts);
+            } catch (err3) {
+              return cb(err3);
+            }
+          }
+          this[INTERNAL].currentSocket = socket;
+          super.createSocket(req, options, cb);
+        }, (err3) => {
+          this.decrementSockets(name, fakeSocket);
+          cb(err3);
+        });
+      }
+      createConnection() {
+        const socket = this[INTERNAL].currentSocket;
+        this[INTERNAL].currentSocket = void 0;
+        if (!socket) {
+          throw new Error("No socket was returned in the `connect()` function");
+        }
+        return socket;
+      }
+      get defaultPort() {
+        return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
+      }
+      set defaultPort(v2) {
+        if (this[INTERNAL]) {
+          this[INTERNAL].defaultPort = v2;
+        }
+      }
+      get protocol() {
+        return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
+      }
+      set protocol(v2) {
+        if (this[INTERNAL]) {
+          this[INTERNAL].protocol = v2;
+        }
+      }
+    };
+    exports.Agent = Agent;
+  }
+});
+
+// ../../node_modules/.pnpm/http-proxy-agent@7.0.2/node_modules/http-proxy-agent/dist/index.js
+var require_dist2 = __commonJS({
+  "../../node_modules/.pnpm/http-proxy-agent@7.0.2/node_modules/http-proxy-agent/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k2, k22) {
+      if (k22 === void 0) k22 = k2;
+      var desc = Object.getOwnPropertyDescriptor(m, k2);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k2];
+        } };
+      }
+      Object.defineProperty(o, k22, desc);
+    }) : (function(o, m, k2, k22) {
+      if (k22 === void 0) k22 = k2;
+      o[k22] = m[k2];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v2) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v2 });
+    }) : function(o, v2) {
+      o["default"] = v2;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k2 in mod) if (k2 !== "default" && Object.prototype.hasOwnProperty.call(mod, k2)) __createBinding(result, mod, k2);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.HttpProxyAgent = void 0;
+    var net = __importStar(__require("net"));
+    var tls = __importStar(__require("tls"));
+    var debug_1 = __importDefault(require_src2());
+    var events_1 = __require("events");
+    var agent_base_1 = require_dist();
+    var url_1 = __require("url");
+    var debug = (0, debug_1.default)("http-proxy-agent");
+    var HttpProxyAgent2 = class extends agent_base_1.Agent {
+      constructor(proxy, opts) {
+        super(opts);
+        this.proxy = typeof proxy === "string" ? new url_1.URL(proxy) : proxy;
+        this.proxyHeaders = opts?.headers ?? {};
+        debug("Creating new HttpProxyAgent instance: %o", this.proxy.href);
+        const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
+        const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
+        this.connectOpts = {
+          ...opts ? omit2(opts, "headers") : null,
+          host,
+          port
+        };
+      }
+      addRequest(req, opts) {
+        req._header = null;
+        this.setRequestProps(req, opts);
+        super.addRequest(req, opts);
+      }
+      setRequestProps(req, opts) {
+        const { proxy } = this;
+        const protocol = opts.secureEndpoint ? "https:" : "http:";
+        const hostname3 = req.getHeader("host") || "localhost";
+        const base = `${protocol}//${hostname3}`;
+        const url2 = new url_1.URL(req.path, base);
+        if (opts.port !== 80) {
+          url2.port = String(opts.port);
+        }
+        req.path = String(url2);
+        const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+        if (proxy.username || proxy.password) {
+          const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+          headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+        }
+        if (!headers["Proxy-Connection"]) {
+          headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+        }
+        for (const name of Object.keys(headers)) {
+          const value = headers[name];
+          if (value) {
+            req.setHeader(name, value);
+          }
+        }
+      }
+      async connect(req, opts) {
+        req._header = null;
+        if (!req.path.includes("://")) {
+          this.setRequestProps(req, opts);
+        }
+        let first;
+        let endOfHeaders;
+        debug("Regenerating stored HTTP header string for request");
+        req._implicitHeader();
+        if (req.outputData && req.outputData.length > 0) {
+          debug("Patching connection write() output buffer with updated header");
+          first = req.outputData[0].data;
+          endOfHeaders = first.indexOf("\r\n\r\n") + 4;
+          req.outputData[0].data = req._header + first.substring(endOfHeaders);
+          debug("Output buffer: %o", req.outputData[0].data);
+        }
+        let socket;
+        if (this.proxy.protocol === "https:") {
+          debug("Creating `tls.Socket`: %o", this.connectOpts);
+          socket = tls.connect(this.connectOpts);
+        } else {
+          debug("Creating `net.Socket`: %o", this.connectOpts);
+          socket = net.connect(this.connectOpts);
+        }
+        await (0, events_1.once)(socket, "connect");
+        return socket;
+      }
+    };
+    HttpProxyAgent2.protocols = ["http", "https"];
+    exports.HttpProxyAgent = HttpProxyAgent2;
+    function omit2(obj, ...keys) {
+      const ret = {};
+      let key;
+      for (key in obj) {
+        if (!keys.includes(key)) {
+          ret[key] = obj[key];
+        }
+      }
+      return ret;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/https-proxy-agent@7.0.6/node_modules/https-proxy-agent/dist/parse-proxy-response.js
+var require_parse_proxy_response = __commonJS({
+  "../../node_modules/.pnpm/https-proxy-agent@7.0.6/node_modules/https-proxy-agent/dist/parse-proxy-response.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.parseProxyResponse = void 0;
+    var debug_1 = __importDefault(require_src2());
+    var debug = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
+    function parseProxyResponse(socket) {
+      return new Promise((resolve4, reject) => {
+        let buffersLength = 0;
+        const buffers = [];
+        function read() {
+          const b2 = socket.read();
+          if (b2)
+            ondata(b2);
+          else
+            socket.once("readable", read);
+        }
+        function cleanup() {
+          socket.removeListener("end", onend);
+          socket.removeListener("error", onerror);
+          socket.removeListener("readable", read);
+        }
+        function onend() {
+          cleanup();
+          debug("onend");
+          reject(new Error("Proxy connection ended before receiving CONNECT response"));
+        }
+        function onerror(err3) {
+          cleanup();
+          debug("onerror %o", err3);
+          reject(err3);
+        }
+        function ondata(b2) {
+          buffers.push(b2);
+          buffersLength += b2.length;
+          const buffered = Buffer.concat(buffers, buffersLength);
+          const endOfHeaders = buffered.indexOf("\r\n\r\n");
+          if (endOfHeaders === -1) {
+            debug("have not received end of HTTP headers yet...");
+            read();
+            return;
+          }
+          const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split("\r\n");
+          const firstLine = headerParts.shift();
+          if (!firstLine) {
+            socket.destroy();
+            return reject(new Error("No header received from proxy CONNECT response"));
+          }
+          const firstLineParts = firstLine.split(" ");
+          const statusCode = +firstLineParts[1];
+          const statusText = firstLineParts.slice(2).join(" ");
+          const headers = {};
+          for (const header of headerParts) {
+            if (!header)
+              continue;
+            const firstColon = header.indexOf(":");
+            if (firstColon === -1) {
+              socket.destroy();
+              return reject(new Error(`Invalid header from proxy CONNECT response: "${header}"`));
+            }
+            const key = header.slice(0, firstColon).toLowerCase();
+            const value = header.slice(firstColon + 1).trimStart();
+            const current = headers[key];
+            if (typeof current === "string") {
+              headers[key] = [current, value];
+            } else if (Array.isArray(current)) {
+              current.push(value);
+            } else {
+              headers[key] = value;
+            }
+          }
+          debug("got proxy server response: %o %o", firstLine, headers);
+          cleanup();
+          resolve4({
+            connect: {
+              statusCode,
+              statusText,
+              headers
+            },
+            buffered
+          });
+        }
+        socket.on("error", onerror);
+        socket.on("end", onend);
+        read();
+      });
+    }
+    exports.parseProxyResponse = parseProxyResponse;
+  }
+});
+
+// ../../node_modules/.pnpm/https-proxy-agent@7.0.6/node_modules/https-proxy-agent/dist/index.js
+var require_dist3 = __commonJS({
+  "../../node_modules/.pnpm/https-proxy-agent@7.0.6/node_modules/https-proxy-agent/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k2, k22) {
+      if (k22 === void 0) k22 = k2;
+      var desc = Object.getOwnPropertyDescriptor(m, k2);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k2];
+        } };
+      }
+      Object.defineProperty(o, k22, desc);
+    }) : (function(o, m, k2, k22) {
+      if (k22 === void 0) k22 = k2;
+      o[k22] = m[k2];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v2) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v2 });
+    }) : function(o, v2) {
+      o["default"] = v2;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k2 in mod) if (k2 !== "default" && Object.prototype.hasOwnProperty.call(mod, k2)) __createBinding(result, mod, k2);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.HttpsProxyAgent = void 0;
+    var net = __importStar(__require("net"));
+    var tls = __importStar(__require("tls"));
+    var assert_1 = __importDefault(__require("assert"));
+    var debug_1 = __importDefault(require_src2());
+    var agent_base_1 = require_dist();
+    var url_1 = __require("url");
+    var parse_proxy_response_1 = require_parse_proxy_response();
+    var debug = (0, debug_1.default)("https-proxy-agent");
+    var setServernameFromNonIpHost = (options) => {
+      if (options.servername === void 0 && options.host && !net.isIP(options.host)) {
+        return {
+          ...options,
+          servername: options.host
+        };
+      }
+      return options;
+    };
+    var HttpsProxyAgent2 = class extends agent_base_1.Agent {
+      constructor(proxy, opts) {
+        super(opts);
+        this.options = { path: void 0 };
+        this.proxy = typeof proxy === "string" ? new url_1.URL(proxy) : proxy;
+        this.proxyHeaders = opts?.headers ?? {};
+        debug("Creating new HttpsProxyAgent instance: %o", this.proxy.href);
+        const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
+        const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
+        this.connectOpts = {
+          // Attempt to negotiate http/1.1 for proxy servers that support http/2
+          ALPNProtocols: ["http/1.1"],
+          ...opts ? omit2(opts, "headers") : null,
+          host,
+          port
+        };
+      }
+      /**
+       * Called when the node-core HTTP client library is creating a
+       * new HTTP request.
+       */
+      async connect(req, opts) {
+        const { proxy } = this;
+        if (!opts.host) {
+          throw new TypeError('No "host" provided');
+        }
+        let socket;
+        if (proxy.protocol === "https:") {
+          debug("Creating `tls.Socket`: %o", this.connectOpts);
+          socket = tls.connect(setServernameFromNonIpHost(this.connectOpts));
+        } else {
+          debug("Creating `net.Socket`: %o", this.connectOpts);
+          socket = net.connect(this.connectOpts);
+        }
+        const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+        const host = net.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
+        let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r
+`;
+        if (proxy.username || proxy.password) {
+          const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+          headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+        }
+        headers.Host = `${host}:${opts.port}`;
+        if (!headers["Proxy-Connection"]) {
+          headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+        }
+        for (const name of Object.keys(headers)) {
+          payload += `${name}: ${headers[name]}\r
+`;
+        }
+        const proxyResponsePromise = (0, parse_proxy_response_1.parseProxyResponse)(socket);
+        socket.write(`${payload}\r
+`);
+        const { connect, buffered } = await proxyResponsePromise;
+        req.emit("proxyConnect", connect);
+        this.emit("proxyConnect", connect, req);
+        if (connect.statusCode === 200) {
+          req.once("socket", resume);
+          if (opts.secureEndpoint) {
+            debug("Upgrading socket connection to TLS");
+            return tls.connect({
+              ...omit2(setServernameFromNonIpHost(opts), "host", "path", "port"),
+              socket
+            });
+          }
+          return socket;
+        }
+        socket.destroy();
+        const fakeSocket = new net.Socket({ writable: false });
+        fakeSocket.readable = true;
+        req.once("socket", (s) => {
+          debug("Replaying proxy buffer for failed request");
+          (0, assert_1.default)(s.listenerCount("data") > 0);
+          s.push(buffered);
+          s.push(null);
+        });
+        return fakeSocket;
+      }
+    };
+    HttpsProxyAgent2.protocols = ["http", "https"];
+    exports.HttpsProxyAgent = HttpsProxyAgent2;
+    function resume(socket) {
+      socket.resume();
+    }
+    function omit2(obj, ...keys) {
+      const ret = {};
+      let key;
+      for (key in obj) {
+        if (!keys.includes(key)) {
+          ret[key] = obj[key];
+        }
+      }
+      return ret;
+    }
+  }
+});
+
 // ../../node_modules/.pnpm/events-universal@1.0.1/node_modules/events-universal/default.js
 var require_default = __commonJS({
   "../../node_modules/.pnpm/events-universal@1.0.1/node_modules/events-universal/default.js"(exports, module) {
@@ -25596,8 +26851,12 @@ var templateCategorySchema = external_exports.enum(["harness", "preconfigured"])
 var templateSpecSchema = external_exports.object({
   version: external_exports.string(),
   image: external_exports.string(),
+  name: external_exports.string().optional(),
   description: external_exports.string().optional(),
   category: templateCategorySchema,
+  tags: external_exports.array(external_exports.string()).optional(),
+  docsUrl: external_exports.string().optional(),
+  setupNote: external_exports.object({ title: external_exports.string(), body: external_exports.string() }).optional(),
   experimental: external_exports.boolean().optional(),
   mounts: external_exports.array(mountSchema).optional(),
   init: external_exports.string().optional(),
@@ -25609,6 +26868,10 @@ var templateSpecSchema = external_exports.object({
   // (e.g. experimental external agents). Carried onto the agent spec so the
   // pod can pull the image without the user entering registry credentials.
   imagePullSecretRef: external_exports.string().optional(),
+  // Seeds the created agent's per-agent hibernation override (Go duration):
+  // "0s" never hibernates, omitted inherits the chart-wide default. A user's
+  // explicit choice at create time still wins over this.
+  hibernationTimeout: external_exports.string().optional(),
   storageSize: external_exports.string().optional(),
   runtimeClassName: external_exports.string().optional(),
   nodeSelector: external_exports.record(external_exports.string(), external_exports.string()).optional(),
@@ -25731,9 +26994,11 @@ var envContribution = external_exports.object({
   name: external_exports.string().min(1),
   placeholder: external_exports.string()
 });
+var egressPort = external_exports.number().int().min(1).max(65535).optional();
 var egressAllowContribution = external_exports.object({
   kind: external_exports.literal("egress-allow"),
   host: external_exports.string().min(1),
+  port: egressPort,
   pathPattern: external_exports.string().optional()
 });
 var egressInjectContribution = external_exports.object({
@@ -25748,7 +27013,13 @@ var egressInjectContribution = external_exports.object({
   // Terminate this host's gateway chain as HTTP/2 so injection lands on a gRPC
   // stream (e.g. Modal's x-modal-token-* metadata). Flows to the injection-hosts
   // annotation the controller reads. Omit for HTTP/1.1 REST hosts.
-  http2: external_exports.boolean().optional()
+  http2: external_exports.boolean().optional(),
+  port: egressPort,
+  // Tunnel WebSocket/SPDY upgrades (kubectl streaming); keeps the chain h1.
+  upgrades: external_exports.boolean().optional(),
+  // Validate the upstream against the CA in the connection Secret, not the
+  // system store (self-signed cluster CAs).
+  upstreamCa: external_exports.boolean().optional()
 });
 var fileContribution = external_exports.object({
   kind: external_exports.literal("file"),
@@ -25948,6 +27219,8 @@ var egressRuleCurrentPresetInputSchema = external_exports.object({
 var egressRuleCreateInputSchema = external_exports.object({
   agentId: external_exports.string().min(1),
   host: external_exports.string().min(1),
+  // Upstream port; omit for 443. Promotes the host onto the L7 chain.
+  port: external_exports.number().int().min(1).max(65535).optional(),
   method: external_exports.string().min(1).default("*"),
   pathPattern: external_exports.string().min(1).default("*"),
   verdict: ruleVerdictSchema
@@ -25968,6 +27241,22 @@ var egressRuleApplyPresetInputSchema = external_exports.object({
 
 // ../api-server-api/src/modules/agents/schemas.ts
 var idSchema = external_exports.object({ id: external_exports.string().min(1) });
+var cpuQuantitySchema = external_exports.string().regex(/^\d+(\.\d+)?m?$/, "CPU must look like '2', '0.5' or '500m'").refine((v2) => toCpuMilli(v2) >= 100, {
+  message: "CPU must be at least 100m"
+});
+var memoryQuantitySchema = external_exports.string().regex(/^\d+(Mi|Gi)$/, "memory must look like '512Mi' or '2Gi'").refine((v2) => toMemoryMi(v2) >= 128, {
+  message: "memory must be at least 128Mi"
+});
+function toCpuMilli(v2) {
+  return v2.endsWith("m") ? Number(v2.slice(0, -1)) : Number(v2) * 1e3;
+}
+function toMemoryMi(v2) {
+  return v2.endsWith("Gi") ? Number(v2.slice(0, -2)) * 1024 : Number(v2.slice(0, -2));
+}
+var agentSizeSchema = external_exports.object({
+  cpu: cpuQuantitySchema.optional(),
+  memory: memoryQuantitySchema.optional()
+});
 var agentCreateInputSchema = external_exports.object({
   name: external_exports.string().min(1).refine((n) => !n.startsWith("agent-"), {
     message: "agent name cannot start with 'agent-' (reserved for IDs)"
@@ -25995,7 +27284,13 @@ var agentCreateInputSchema = external_exports.object({
   // Initial connection grants, settled into the spec at create so credentials
   // ride the first snapshot and the gateway renders its chains once (no
   // readiness flap).
-  connectionIds: external_exports.array(external_exports.string()).optional()
+  connectionIds: external_exports.array(external_exports.string()).optional(),
+  // The agent's size (#1900): CPU/memory limits, the user-facing "power"
+  // knob the Budget bounds (the UI renders it as sliders). Omitted
+  // dimensions inherit the template's limits, else the chart default.
+  // Requests are derived server-side — never a user concept. Floors match
+  // the chart's derivation floors; the budget gate is the only ceiling.
+  size: agentSizeSchema.optional()
 }).refine((d2) => d2.templateId !== void 0 || d2.image !== void 0, {
   message: "Either templateId or image is required"
 });
@@ -26007,7 +27302,11 @@ var agentUpdateInputSchema = external_exports.object({
   secretRef: external_exports.string().optional(),
   allowedUserEmails: external_exports.array(external_exports.email()).optional(),
   // Per-agent idle timeout override in minutes (0 = never hibernate); null clears it back to the global default.
-  hibernationTimeoutMin: external_exports.number().int().min(0).nullable().optional()
+  hibernationTimeoutMin: external_exports.number().int().min(0).nullable().optional(),
+  // Resize (#1900). On a sleeping sandbox the new Size rides the next start
+  // through the budget gate; on a running one the increase is gated
+  // server-side and the pod restarts to apply it.
+  size: agentSizeSchema.optional()
 });
 var agentConnectSlackInputSchema = external_exports.object({
   id: external_exports.string().min(1),
@@ -29335,6 +30634,20 @@ var oauthAuth = external_exports.object({
   host: external_exports.string().min(1).optional(),
   appSlug: external_exports.string().min(1).optional()
 });
+var clientCredentialsAuth = external_exports.object({
+  kind: external_exports.literal("client-credentials"),
+  clientId: external_exports.string(),
+  clientSecretRef: secretRef,
+  accessTokenRef: secretRef,
+  issuerUrl: external_exports.string().url(),
+  tokenUrl: external_exports.string().url(),
+  scopes: external_exports.array(external_exports.string()).default([]),
+  audience: external_exports.string().min(1).optional(),
+  expiresAt: external_exports.number().int().optional(),
+  connectedAt: external_exports.number().int().optional(),
+  tokenEndpointAcceptJson: external_exports.boolean().optional(),
+  host: external_exports.string().min(1).optional()
+});
 var headerAuth = external_exports.object({
   kind: external_exports.literal("header"),
   valueRef: secretRef,
@@ -29346,6 +30659,7 @@ var noneAuth = external_exports.object({
 });
 var authConfig = external_exports.discriminatedUnion("kind", [
   oauthAuth,
+  clientCredentialsAuth,
   headerAuth,
   noneAuth
 ]);
@@ -29364,6 +30678,12 @@ var connectionStatus = external_exports.enum([
   "pending",
   "disconnected"
 ]);
+var authKind = external_exports.enum([
+  "oauth",
+  "client-credentials",
+  "header",
+  "none"
+]);
 var connectionView = external_exports.object({
   id: external_exports.string(),
   ownerId: external_exports.string(),
@@ -29371,14 +30691,13 @@ var connectionView = external_exports.object({
   category: connectionCategory,
   name: external_exports.string(),
   status: connectionStatus,
-  authKind: external_exports.enum(["oauth", "header", "none"]),
+  authKind,
   contributions: external_exports.array(contribution),
   connectedAt: external_exports.string().optional(),
   hosts: external_exports.array(external_exports.string()),
   host: external_exports.string().min(1).optional(),
   appSlug: external_exports.string().min(1).optional()
 });
-var authKind = external_exports.enum(["oauth", "header", "none"]);
 var templateInputState = external_exports.enum([
   "required",
   "overridable",
@@ -29440,6 +30759,9 @@ var connectionStartOAuthInputSchema = external_exports.object({
 var connectionDiscoverMcpInputSchema = external_exports.object({
   url: external_exports.string().url()
 });
+var connectionProbeClusterCaInputSchema = external_exports.object({
+  host: external_exports.string().min(1)
+});
 var connectionGetAgentConnectionsInputSchema = external_exports.object({
   agentId: external_exports.string().min(1)
 });
@@ -29476,7 +30798,30 @@ var headerCreateInput = external_exports.object({
   ).optional(),
   // Values for the template's declared config inputs, keyed by input name.
   configInputs: external_exports.record(external_exports.string(), external_exports.string()).optional(),
-  value: external_exports.string().min(1)
+  value: external_exports.string().min(1),
+  // Upstream CA bundle for hosts whose TLS cert a public root can't verify
+  // (self-signed cluster CAs). PEM, or base64 of PEM (kubeconfig
+  // `certificate-authority-data`).
+  caData: external_exports.string().optional()
+});
+var clientCredentialsCreateInput = external_exports.object({
+  ...commonFields,
+  authKind: external_exports.literal("client-credentials"),
+  host: external_exports.string().min(1).optional(),
+  // The token endpoint is discovered from the issuer's OAuth metadata.
+  issuerUrl: external_exports.string().url().optional(),
+  clientId: external_exports.string().min(1).optional(),
+  clientSecret: external_exports.string().min(1).optional(),
+  // Space- or comma-separated; the server splits. A single string keeps the
+  // schema-driven forms all-string.
+  scopes: external_exports.string().optional(),
+  audience: external_exports.string().min(1).optional(),
+  headerName: external_exports.string().min(1).optional(),
+  valueFormat: external_exports.string().min(1).optional(),
+  envName: external_exports.string().regex(
+    /^[A-Za-z_][A-Za-z0-9_]*$/,
+    "env var name must be letters, digits, and underscores (not starting with a digit)"
+  ).optional()
 });
 var noneCreateInput = external_exports.object({
   ...commonFields,
@@ -29485,6 +30830,7 @@ var noneCreateInput = external_exports.object({
 });
 var connectionCreateInputSchema = external_exports.discriminatedUnion("authKind", [
   oauthCreateInput,
+  clientCredentialsCreateInput,
   headerCreateInput,
   noneCreateInput
 ]);
@@ -29609,15 +30955,20 @@ function formatEgressRuleSource(source) {
 function formatEgressRuleInline(rule) {
   const parts = [rule.verdict];
   if (rule.method !== "*") parts.push(rule.method);
-  parts.push(joinHostPath(rule.host, rule.pathPattern));
+  parts.push(joinHostPath(rule.host, rule.pathPattern, rule.port));
   return parts.join(" ");
 }
-function joinHostPath(host, pathPattern) {
-  const normalizedHost = host.replace(/\/+$/, "");
+function joinHostPath(host, pathPattern, port) {
+  const normalizedHost = stripTrailingSlashes(host) + (port ? `:${port}` : "");
   if (pathPattern === "*") return normalizedHost;
   const normalizedPath = pathPattern.startsWith("/") ? pathPattern : `/${pathPattern}`;
   return `${normalizedHost}${normalizedPath}`;
 }
+function stripTrailingSlashes(s) {
+  let end = s.length;
+  while (end > 0 && s[end - 1] === "/") end--;
+  return s.slice(0, end);
+}
 
 // ../api-server-api/src/modules/acp/types.ts
 var platformTurnEndedParamsSchema = external_exports.object({
@@ -31302,6 +32653,11 @@ function createConnectionService(deps) {
     async discoverMcp(url2) {
       return trpcCall(() => deps.trpc.connections.discoverMcp.mutate({ url: url2 }));
     },
+    async probeClusterCa(host) {
+      return trpcCall(
+        () => deps.trpc.connections.probeClusterCa.mutate({ host })
+      );
+    },
     async getConnection(id) {
       return trpcCall(() => deps.trpc.connections.get.query({ id }));
     },
@@ -38114,11 +39470,40 @@ var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
+// src/modules/shared/ws-proxy.ts
+var import_http_proxy_agent = __toESM(require_dist2(), 1);
+var import_https_proxy_agent = __toESM(require_dist3(), 1);
+function proxyAgentForUrl(url2, env = process.env) {
+  let target;
+  try {
+    target = new URL(url2);
+  } catch {
+    return void 0;
+  }
+  const secure = target.protocol === "wss:" || target.protocol === "https:";
+  const proxy = secure ? env.HTTPS_PROXY ?? env.https_proxy : env.HTTP_PROXY ?? env.http_proxy;
+  if (!proxy) return void 0;
+  if (isNoProxy(target.hostname, env.NO_PROXY ?? env.no_proxy))
+    return void 0;
+  return secure ? new import_https_proxy_agent.HttpsProxyAgent(proxy) : new import_http_proxy_agent.HttpProxyAgent(proxy);
+}
+function isNoProxy(host, noProxy) {
+  if (!noProxy) return false;
+  for (const raw of noProxy.split(",")) {
+    const entry = raw.trim();
+    if (entry === "") continue;
+    if (entry === "*") return true;
+    const bare = (entry.startsWith(".") ? entry.slice(1) : entry).toLowerCase();
+    if (host === bare || host.endsWith(`.${bare}`)) return true;
+  }
+  return false;
+}
+
 // src/modules/chat/infrastructure/acp-session-client.ts
 var TIMEOUT_MS = 12e4;
 function wsStream(url2) {
   return new Promise((resolve4, reject) => {
-    const ws = new import_websocket.default(url2);
+    const ws = new import_websocket.default(url2, { agent: proxyAgentForUrl(url2) });
     ws.on("open", () => {
       const readable = new ReadableStream({
         start(controller) {
@@ -38274,9 +39659,8 @@ function connectTerminalBridge({
     const proto = host.startsWith("https://") ? "wss:" : "ws:";
     const base = host.replace(/^https?:\/\//, "").replace(/\/+$/, "");
     const sep = terminalPath.includes("?") ? "&" : "?";
-    const ws = new wrapper_default(
-      `${proto}//${base}${terminalPath}${sep}token=${encodeURIComponent(token)}`
-    );
+    const url2 = `${proto}//${base}${terminalPath}${sep}token=${encodeURIComponent(token)}`;
+    const ws = new wrapper_default(url2, { agent: proxyAgentForUrl(url2) });
     const onData = (chunk) => {
       if (ws.readyState === wrapper_default.OPEN)
         ws.send(encodeDataFrame(OP_INPUT, new Uint8Array(chunk)));
@@ -38496,13 +39880,13 @@ function createSessionsPort(deps) {
 }
 
 // src/modules/chat/compose.ts
+var buildSessionsPort = (host, token) => createSessionsPort({ acp: createAcpSessionClient({ host, token }) });
 function composeChatModule({
   compatService,
   configService,
   tokenProvider,
   createAgentService: createAgentService2
 }) {
-  const buildSessionsPort = (host, token) => createSessionsPort({ acp: createAcpSessionClient({ host, token }) });
   const chatService = createChatService({
     compatService,
     configService,
@@ -38790,7 +40174,7 @@ function createProcessEnvReader() {
 
 // src/modules/cli/infrastructure/package-version.ts
 function readPackageVersion() {
-  return true ? "0.2.6-rc1" : DEV_VERSION;
+  return true ? "0.2.7-rc1" : DEV_VERSION;
 }
 
 // src/modules/cli/infrastructure/version-probe.ts
@@ -39017,10 +40401,22 @@ function buildConnectCommand(deps) {
   ).option(
     "--auth <mode>",
     "MCP auth mode: oauth | none (default: auto-detect from the server)"
-  ).option("--url <url>", "input: url").option("--host <host>", "input: host").option("--client-id <id>", "input: OAuth client id").option("--client-secret <secret>", "input: OAuth client secret").option("--app-slug <slug>", "input: GitHub App slug").option("--header-name <name>", "input: header name").option("--value-format <format>", "input: header value format").option(
+  ).option("--url <url>", "input: url").option("--host <host>", "input: host").option("--client-id <id>", "input: OAuth client id").option("--client-secret <secret>", "input: OAuth client secret").option(
+    "--issuer-url <url>",
+    "input: OAuth issuer URL \u2014 the token endpoint is discovered from its metadata (client credentials)"
+  ).option(
+    "--scopes <scopes>",
+    "input: OAuth scopes, space- or comma-separated (client credentials)"
+  ).option(
+    "--audience <audience>",
+    "input: OAuth audience (client credentials)"
+  ).option("--app-slug <slug>", "input: GitHub App slug").option("--header-name <name>", "input: header name").option("--value-format <format>", "input: header value format").option(
     "--env-name <name>",
     "input: expose the credential to the agent as this env var (custom header credentials)"
   ).option("--value <value>", "input: header secret value").option(
+    "--ca-data <data>",
+    "input: upstream CA certificate \u2014 PEM or base64 (a kubeconfig's certificate-authority-data)"
+  ).option(
     "-c, --config <key=value>",
     "set an optional template config input (e.g. -c model=premium-shell), repeatable",
     (val, prev) => [...prev, val],
@@ -39037,7 +40433,7 @@ function buildConnectCommand(deps) {
     String(DEFAULT_TIMEOUT_SECONDS3)
   ).addHelpText(
     "after",
-    "\nExamples:\n  dam connection connect github\n  dam connection connect github --client-id Iv1.\u2026 --client-secret \u2026  # use your own OAuth app\n  dam connection connect github --no-browser\n  dam connection connect my-api --header-name X-API-Key --value sk-\u2026\n  dam connection connect bob --value sk-\u2026 --config model=premium-shell --config chatMode=code\n  dam connection connect https://mcp.example.com\n  dam connection connect https://mcp.example.com --auth none\n"
+    "\nExamples:\n  dam connection connect github\n  dam connection connect github --client-id Iv1.\u2026 --client-secret \u2026  # use your own OAuth app\n  dam connection connect github --no-browser\n  dam connection connect my-api --header-name X-API-Key --value sk-\u2026\n  dam connection connect custom-client-credentials --host api.example.com \\\n      --issuer-url https://auth.example.com/realms/main --client-id \u2026 --client-secret \u2026\n  dam connection connect bob --value sk-\u2026 --config model=premium-shell --config chatMode=code\n  dam connection connect https://mcp.example.com\n  dam connection connect https://mcp.example.com --auth none\n"
   ).action(async (providerOrUrl, opts) => {
     const json2 = opts.json ?? false;
     const timeoutSeconds = parseTimeout2(opts.timeout);
@@ -39093,6 +40489,9 @@ function buildConnectCommand(deps) {
 `);
       process.exit(EXIT_INVALID_INPUT);
     }
+    if (template.id === "kubernetes" && payload.authKind === "header" && !payload.caData && values.host && !checkClusterTrust(await svc.probeClusterCa(values.host), values.host)) {
+      process.exit(EXIT_INVALID_INPUT);
+    }
     const createRes = await svc.createConnection(payload);
     if (!createRes.ok) {
       printServiceError(createRes.error, host);
@@ -39282,6 +40681,20 @@ function buildPayload(template, name, values) {
         ...v2("clientSecret") ? { clientSecret: v2("clientSecret") } : {},
         ...v2("appSlug") ? { appSlug: v2("appSlug") } : {}
       };
+    case "client-credentials":
+      return {
+        ...common2,
+        authKind: "client-credentials",
+        ...v2("host") ? { host: v2("host") } : {},
+        ...v2("issuerUrl") ? { issuerUrl: v2("issuerUrl") } : {},
+        ...v2("clientId") ? { clientId: v2("clientId") } : {},
+        ...v2("clientSecret") ? { clientSecret: v2("clientSecret") } : {},
+        ...v2("scopes") ? { scopes: v2("scopes") } : {},
+        ...v2("audience") ? { audience: v2("audience") } : {},
+        ...v2("headerName") ? { headerName: v2("headerName") } : {},
+        ...v2("valueFormat") ? { valueFormat: v2("valueFormat") } : {},
+        ...v2("envName") ? { envName: v2("envName") } : {}
+      };
     case "header": {
       const value = v2("value");
       if (!value) return { error: "the secret value is required (--value)" };
@@ -39298,6 +40711,7 @@ function buildPayload(template, name, values) {
         ...v2("headerName") ? { headerName: v2("headerName") } : {},
         ...v2("valueFormat") ? { valueFormat: v2("valueFormat") } : {},
         ...v2("envName") ? { envName: v2("envName") } : {},
+        ...v2("caData") ? { caData: v2("caData") } : {},
         ...Object.keys(configInputs).length > 0 ? { configInputs } : {},
         value
       };
@@ -39310,6 +40724,24 @@ function buildPayload(template, name, values) {
       };
   }
 }
+function checkClusterTrust(probeRes, host) {
+  if (!probeRes.ok) return true;
+  const probe = probeRes.value;
+  if (probe.trusted) return true;
+  if (probe.reachable) {
+    process.stderr.write(
+      `error: the API server at ${host} presents a certificate that isn't publicly trusted${probe.error ? ` (${probe.error})` : ""}.
+  Pass --ca-data with the cluster CA \u2014 the certificate-authority-data value from your kubeconfig (base64 or PEM).
+`
+    );
+    return false;
+  }
+  process.stderr.write(
+    `warning: couldn't reach ${host} to check its certificate${probe.error ? ` (${probe.error})` : ""}; continuing.
+`
+  );
+  return true;
+}
 async function pollUntilActive(svc, id, timeoutSeconds) {
   const deadline = Date.now() + timeoutSeconds * 1e3;
   while (true) {
@@ -39376,13 +40808,17 @@ function flagListFor(inputs) {
 var FIELD_LABELS = {
   url: "URL",
   host: "Host",
+  issuerUrl: "Issuer URL",
   headerName: "Header name",
   valueFormat: "Value format",
   value: "Secret value",
   clientId: "Client ID",
   clientSecret: "Client secret",
+  scopes: "Scopes (space-separated)",
+  audience: "Audience",
   appSlug: "GitHub App slug",
-  envName: "Env var name"
+  envName: "Env var name",
+  caData: "Cluster CA certificate"
 };
 function labelFor(key) {
   return FIELD_LABELS[key] ?? key;
@@ -42876,9 +44312,8 @@ function connectRawBridge({
     let settled = false;
     const proto = host.startsWith("https://") ? "wss:" : "ws:";
     const base = host.replace(/^https?:\/\//, "").replace(/\/+$/, "");
-    const ws = new wrapper_default(
-      `${proto}//${base}/api/agents/${encodeURIComponent(agentId)}/ssh?token=${encodeURIComponent(token)}`
-    );
+    const url2 = `${proto}//${base}/api/agents/${encodeURIComponent(agentId)}/ssh?token=${encodeURIComponent(token)}`;
+    const ws = new wrapper_default(url2, { agent: proxyAgentForUrl(url2) });
     ws.binaryType = "nodebuffer";
     const onStdin = (chunk) => {
       if (ws.readyState === wrapper_default.OPEN) ws.send(chunk, { binary: true });
@@ -43417,6 +44852,213 @@ function composeSshModule(opts) {
   return { commands: [buildSshCommand(opts)] };
 }
 
+// src/modules/metrics/commands/show.ts
+var secs = (ms) => `${(ms / 1e3).toFixed(1)}s`;
+function buildMetricsCommand(deps) {
+  return new Command("metrics").description(
+    "Show an Agent's run metrics \u2014 token spend, runtime, and context usage"
+  ).argument("<agent>", "Agent Ref \u2014 name or 'agent-\u2026' ID").option(
+    "--since <hours>",
+    "lookback window in hours (max 720; default: all time)"
+  ).option("--session <id>", "narrow to one session").option(
+    "--limit <n>",
+    "max recent calls to include (default 100, max 1000)"
+  ).option(
+    "--server <url>",
+    "override the configured server URL for this call"
+  ).option("--json", "emit raw JSON instead of the default report").addHelpText(
+    "after",
+    "\nExamples:\n  dam metrics my-agent\n  dam metrics my-agent --session sess-abc123\n  dam metrics agent-abc123 --since 168 --json\n"
+  ).action(
+    async (ref, opts) => {
+      const host = await resolveActiveHost(deps, {
+        flag: opts.server ? { server: opts.server } : void 0,
+        exitCodes: {
+          runtimeFailure: EXIT_RUNTIME_FAILURE,
+          belowFloor: EXIT_BELOW_FLOOR
+        }
+      });
+      const resolved = await createAgentResolver({
+        agentService: deps.createAgentService(host)
+      }).resolve(ref);
+      if (!resolved.ok) {
+        printResolveError(resolved.error, host);
+        process.exit(exitCodeForResolveError(resolved.error));
+      }
+      const agent = resolved.value;
+      const fetchTitles = async () => {
+        const tok = await deps.tokenProvider.getValidAccessToken(host);
+        if (!tok.ok) return /* @__PURE__ */ new Map();
+        const sessions = await deps.createSessionsPort(host, tok.value).list(agent.id);
+        if (!sessions.ok) return /* @__PURE__ */ new Map();
+        return new Map(
+          sessions.value.filter((s) => s.title).map((s) => [s.sessionId, s.title])
+        );
+      };
+      const sinceHours = opts.since ? Number(opts.since) : void 0;
+      const [result, titles] = await Promise.all([
+        deps.createMetricsService(host).overview({
+          agentId: agent.id,
+          sessionId: opts.session,
+          sinceHours,
+          limit: opts.limit ? Number(opts.limit) : 100
+        }),
+        fetchTitles().catch(() => /* @__PURE__ */ new Map())
+      ]);
+      if (!result.ok) {
+        printServiceError(result.error, host);
+        process.exit(EXIT_RUNTIME_FAILURE);
+      }
+      const { tokenSpendByModel, contextPerCall } = result.value;
+      const runtimeBySession = result.value.runtimeBySession.map((r) => ({
+        ...r,
+        title: titles.get(r.sessionId) ?? null
+      }));
+      const windowLabel = [
+        opts.session && `session ${opts.session}`,
+        sinceHours !== void 0 && `last ${sinceHours}h`
+      ].filter(Boolean).join(" \xB7 ") || "all time";
+      if (opts.json) {
+        return writeStdoutAndExit(
+          `${JSON.stringify({
+            agentId: agent.id,
+            sessionId: opts.session,
+            sinceHours,
+            tokenSpendByModel,
+            runtimeBySession,
+            contextPerCall
+          })}
+`,
+          EXIT_SUCCESS
+        );
+      }
+      if (tokenSpendByModel.length === 0) {
+        process.stderr.write(
+          `No metrics for ${agent.name} in ${windowLabel}.
+`
+        );
+        process.exit(EXIT_SUCCESS);
+      }
+      const totalCalls = tokenSpendByModel.reduce((n, r) => n + r.calls, 0);
+      const totalCost = tokenSpendByModel.reduce((n, r) => n + r.costUsd, 0);
+      const totalApiMs = runtimeBySession.reduce(
+        (n, r) => n + r.totalDurationMs,
+        0
+      );
+      const summary = renderTable([
+        ["AGENT", `${agent.name} (${agent.id})`],
+        ["WINDOW", windowLabel],
+        ["API CALLS", String(totalCalls)],
+        ["SESSIONS", String(runtimeBySession.length)],
+        ["API TIME", secs(totalApiMs)],
+        ["COST USD", totalCost.toFixed(4)]
+      ]);
+      const byModel = renderTable([
+        [
+          "MODEL",
+          "CALLS",
+          "INPUT",
+          "OUTPUT",
+          "CACHE R",
+          "CACHE W",
+          "COST USD"
+        ],
+        ...tokenSpendByModel.map((r) => [
+          r.model,
+          String(r.calls),
+          r.inputTokens.toLocaleString(),
+          r.outputTokens.toLocaleString(),
+          r.cacheReadTokens.toLocaleString(),
+          r.cacheCreationTokens.toLocaleString(),
+          r.costUsd.toFixed(4)
+        ])
+      ]);
+      const bySession = renderFittedTable(
+        [
+          "SESSION",
+          "CALLS",
+          "API TIME",
+          "INPUT",
+          "OUTPUT",
+          "CACHE R",
+          "CACHE W",
+          "COST USD",
+          "LAST"
+        ],
+        runtimeBySession.map((r) => [
+          r.title ?? r.sessionId,
+          String(r.calls),
+          secs(r.totalDurationMs),
+          r.inputTokens.toLocaleString(),
+          r.outputTokens.toLocaleString(),
+          r.cacheReadTokens.toLocaleString(),
+          r.cacheCreationTokens.toLocaleString(),
+          r.costUsd.toFixed(4),
+          r.lastAt
+        ]),
+        0
+      );
+      const recent = renderTable([
+        [
+          "TIME",
+          "MODEL",
+          "CONTEXT",
+          "INPUT",
+          "CACHE R",
+          "OUTPUT",
+          "COST USD"
+        ],
+        ...contextPerCall.map((r) => [
+          r.at,
+          r.model,
+          r.contextTokens.toLocaleString(),
+          r.inputTokens.toLocaleString(),
+          r.cacheReadTokens.toLocaleString(),
+          r.outputTokens.toLocaleString(),
+          r.costUsd.toFixed(4)
+        ])
+      ]);
+      return writeStdoutAndExit(
+        `${summary}
+TOKEN SPEND BY MODEL
+${byModel}
+SESSIONS
+${bySession}
+RECENT CALLS (context per call)
+${recent}`,
+        EXIT_SUCCESS
+      );
+    }
+  );
+}
+
+// src/modules/metrics/services/metrics-service.ts
+function createMetricsService(deps) {
+  return {
+    async overview(query) {
+      return trpcCall(() => deps.trpc.metrics.overview.query(query));
+    }
+  };
+}
+
+// src/modules/metrics/compose.ts
+function composeMetricsModule(opts) {
+  return {
+    commands: [
+      buildMetricsCommand({
+        compatService: opts.compatService,
+        configService: opts.configService,
+        tokenProvider: opts.tokenProvider,
+        createAgentService: opts.createAgentService,
+        createSessionsPort: buildSessionsPort,
+        createMetricsService: (host) => createMetricsService({
+          trpc: createTrpcClient({ host, tokenProvider: opts.tokenProvider })
+        })
+      })
+    ]
+  };
+}
+
 // src/modules/template/commands/list.ts
 var DESCRIPTION_MAX = 60;
 function buildListCommand8(deps) {
@@ -43603,6 +45245,12 @@ function compose(opts = {}) {
     compatService: cli.services.compatService,
     createAgentService: agent.exports.createService
   });
+  const metrics = composeMetricsModule({
+    tokenProvider: auth.exports.tokenProvider,
+    configService: cli.services.configService,
+    compatService: cli.services.compatService,
+    createAgentService: agent.exports.createService
+  });
   const program3 = new Command();
   program3.name("dam").description("Command-line client for a Platform deployment").version(cli.cliVersion);
   for (const command of cli.commands) program3.addCommand(command);
@@ -43619,6 +45267,7 @@ function compose(opts = {}) {
   for (const command of skill.commands) program3.addCommand(command);
   for (const command of ssh.commands) program3.addCommand(command);
   for (const command of channel.commands) program3.addCommand(command);
+  for (const command of metrics.commands) program3.addCommand(command);
   return program3;
 }