@telepath-computer/television 0.1.103 → 0.1.105

package/dist/cli.cjs

@@ -6173,9 +6173,8 @@ var require_side_channel_list = __commonJS({
           }
         },
         "delete": function(key) {
-          var root = $o && $o.next;
           var deletedNode = listDelete($o, key);
-          if (deletedNode && root && root === deletedNode) {
+          if (deletedNode && $o && !$o.next) {
             $o = void 0;
           }
           return !!deletedNode;
@@ -21706,10 +21705,7 @@ var require_json = __commonJS({
       var index = str.indexOf(char);
       var partial2 = "";
       if (index !== -1) {
-        partial2 = str.substring(0, index) + JSON_SYNTAX_CHAR;
-        for (var i = index + 1; i < str.length; i++) {
-          partial2 += JSON_SYNTAX_CHAR;
-        }
+        partial2 = str.substring(0, index) + new Array(str.length - index + 1).join(JSON_SYNTAX_CHAR);
       }
       try {
         JSON.parse(partial2);
@@ -21876,9 +21872,9 @@ var require_text = __commonJS({
   }
 });
 
-// ../../node_modules/qs/lib/formats.js
+// ../../node_modules/body-parser/node_modules/qs/lib/formats.js
 var require_formats = __commonJS({
-  "../../node_modules/qs/lib/formats.js"(exports2, module2) {
+  "../../node_modules/body-parser/node_modules/qs/lib/formats.js"(exports2, module2) {
     "use strict";
     var replace = String.prototype.replace;
     var percentTwenties = /%20/g;
@@ -21902,9 +21898,9 @@ var require_formats = __commonJS({
   }
 });
 
-// ../../node_modules/qs/lib/utils.js
+// ../../node_modules/body-parser/node_modules/qs/lib/utils.js
 var require_utils = __commonJS({
-  "../../node_modules/qs/lib/utils.js"(exports2, module2) {
+  "../../node_modules/body-parser/node_modules/qs/lib/utils.js"(exports2, module2) {
     "use strict";
     var formats = require_formats();
     var getSideChannel = require_side_channel();
@@ -21971,6 +21967,8 @@ var require_utils = __commonJS({
             var newIndex = getMaxIndex(target) + 1;
             target[newIndex] = source;
             setMaxIndex(target, newIndex);
+          } else if (options && options.strictMerge) {
+            return [target, source];
           } else if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) {
             target[source] = true;
           }
@@ -22164,9 +22162,9 @@ var require_utils = __commonJS({
   }
 });
 
-// ../../node_modules/qs/lib/stringify.js
+// ../../node_modules/body-parser/node_modules/qs/lib/stringify.js
 var require_stringify = __commonJS({
-  "../../node_modules/qs/lib/stringify.js"(exports2, module2) {
+  "../../node_modules/body-parser/node_modules/qs/lib/stringify.js"(exports2, module2) {
     "use strict";
     var getSideChannel = require_side_channel();
     var utils = require_utils();
@@ -22447,9 +22445,9 @@ var require_stringify = __commonJS({
   }
 });
 
-// ../../node_modules/qs/lib/parse.js
+// ../../node_modules/body-parser/node_modules/qs/lib/parse.js
 var require_parse = __commonJS({
-  "../../node_modules/qs/lib/parse.js"(exports2, module2) {
+  "../../node_modules/body-parser/node_modules/qs/lib/parse.js"(exports2, module2) {
     "use strict";
     var utils = require_utils();
     var has = Object.prototype.hasOwnProperty;
@@ -22474,6 +22472,7 @@ var require_parse = __commonJS({
       parseArrays: true,
       plainObjects: false,
       strictDepth: false,
+      strictMerge: true,
       strictNullHandling: false,
       throwOnLimitExceeded: false
     };
@@ -22500,9 +22499,9 @@ var require_parse = __commonJS({
       var limit = options.parameterLimit === Infinity ? void 0 : options.parameterLimit;
       var parts = cleanStr.split(
         options.delimiter,
-        options.throwOnLimitExceeded ? limit + 1 : limit
+        options.throwOnLimitExceeded && typeof limit !== "undefined" ? limit + 1 : limit
       );
-      if (options.throwOnLimitExceeded && parts.length > limit) {
+      if (options.throwOnLimitExceeded && typeof limit !== "undefined" && parts.length > limit) {
         throw new RangeError("Parameter limit exceeded. Only " + limit + " parameter" + (limit === 1 ? "" : "s") + " allowed.");
       }
       var skipIndex = -1;
@@ -22562,7 +22561,7 @@ var require_parse = __commonJS({
         }
         if (key !== null) {
           var existing = has.call(obj, key);
-          if (existing && options.duplicates === "combine") {
+          if (existing && (options.duplicates === "combine" || part.indexOf("[]=") > -1)) {
             obj[key] = utils.combine(
               obj[key],
               val,
@@ -22719,6 +22718,7 @@ var require_parse = __commonJS({
         parseArrays: opts.parseArrays !== false,
         plainObjects: typeof opts.plainObjects === "boolean" ? opts.plainObjects : defaults.plainObjects,
         strictDepth: typeof opts.strictDepth === "boolean" ? !!opts.strictDepth : defaults.strictDepth,
+        strictMerge: typeof opts.strictMerge === "boolean" ? !!opts.strictMerge : defaults.strictMerge,
         strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling,
         throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === "boolean" ? opts.throwOnLimitExceeded : false
       };
@@ -22744,9 +22744,9 @@ var require_parse = __commonJS({
   }
 });
 
-// ../../node_modules/qs/lib/index.js
+// ../../node_modules/body-parser/node_modules/qs/lib/index.js
 var require_lib2 = __commonJS({
-  "../../node_modules/qs/lib/index.js"(exports2, module2) {
+  "../../node_modules/body-parser/node_modules/qs/lib/index.js"(exports2, module2) {
     "use strict";
     var stringify = require_stringify();
     var parse3 = require_parse();
@@ -22877,14 +22877,14 @@ var require_urlencoded = __commonJS({
     }
     function parameterCount(body, limit) {
       var count = 0;
-      var index = 0;
-      while ((index = body.indexOf("&", index)) !== -1) {
+      var index = -1;
+      do {
         count++;
-        index++;
-        if (count === limit) {
+        if (count > limit) {
           return void 0;
         }
-      }
+        index = body.indexOf("&", index + 1);
+      } while (index !== -1);
       return count;
     }
     function parser(name) {
@@ -24993,13 +24993,896 @@ var require_init = __commonJS({
   }
 });
 
+// ../../node_modules/qs/lib/formats.js
+var require_formats2 = __commonJS({
+  "../../node_modules/qs/lib/formats.js"(exports2, module2) {
+    "use strict";
+    var replace = String.prototype.replace;
+    var percentTwenties = /%20/g;
+    var Format = {
+      RFC1738: "RFC1738",
+      RFC3986: "RFC3986"
+    };
+    module2.exports = {
+      "default": Format.RFC3986,
+      formatters: {
+        RFC1738: function(value) {
+          return replace.call(value, percentTwenties, "+");
+        },
+        RFC3986: function(value) {
+          return String(value);
+        }
+      },
+      RFC1738: Format.RFC1738,
+      RFC3986: Format.RFC3986
+    };
+  }
+});
+
+// ../../node_modules/qs/lib/utils.js
+var require_utils2 = __commonJS({
+  "../../node_modules/qs/lib/utils.js"(exports2, module2) {
+    "use strict";
+    var formats = require_formats2();
+    var getSideChannel = require_side_channel();
+    var has = Object.prototype.hasOwnProperty;
+    var isArray = Array.isArray;
+    var overflowChannel = getSideChannel();
+    var markOverflow = function markOverflow2(obj, maxIndex) {
+      overflowChannel.set(obj, maxIndex);
+      return obj;
+    };
+    var isOverflow = function isOverflow2(obj) {
+      return overflowChannel.has(obj);
+    };
+    var getMaxIndex = function getMaxIndex2(obj) {
+      return overflowChannel.get(obj);
+    };
+    var setMaxIndex = function setMaxIndex2(obj, maxIndex) {
+      overflowChannel.set(obj, maxIndex);
+    };
+    var hexTable = function() {
+      var array2 = [];
+      for (var i = 0; i < 256; ++i) {
+        array2[array2.length] = "%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase();
+      }
+      return array2;
+    }();
+    var compactQueue = function compactQueue2(queue) {
+      while (queue.length > 1) {
+        var item = queue.pop();
+        var obj = item.obj[item.prop];
+        if (isArray(obj)) {
+          var compacted = [];
+          for (var j = 0; j < obj.length; ++j) {
+            if (typeof obj[j] !== "undefined") {
+              compacted[compacted.length] = obj[j];
+            }
+          }
+          item.obj[item.prop] = compacted;
+        }
+      }
+    };
+    var arrayToObject = function arrayToObject2(source, options) {
+      var obj = options && options.plainObjects ? { __proto__: null } : {};
+      for (var i = 0; i < source.length; ++i) {
+        if (typeof source[i] !== "undefined") {
+          obj[i] = source[i];
+        }
+      }
+      return obj;
+    };
+    var merge2 = function merge3(target, source, options) {
+      if (!source) {
+        return target;
+      }
+      if (typeof source !== "object" && typeof source !== "function") {
+        if (isArray(target)) {
+          var nextIndex = target.length;
+          if (options && typeof options.arrayLimit === "number" && nextIndex > options.arrayLimit) {
+            return markOverflow(arrayToObject(target.concat(source), options), nextIndex);
+          }
+          target[nextIndex] = source;
+        } else if (target && typeof target === "object") {
+          if (isOverflow(target)) {
+            var newIndex = getMaxIndex(target) + 1;
+            target[newIndex] = source;
+            setMaxIndex(target, newIndex);
+          } else if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) {
+            target[source] = true;
+          }
+        } else {
+          return [target, source];
+        }
+        return target;
+      }
+      if (!target || typeof target !== "object") {
+        if (isOverflow(source)) {
+          var sourceKeys = Object.keys(source);
+          var result = options && options.plainObjects ? { __proto__: null, 0: target } : { 0: target };
+          for (var m = 0; m < sourceKeys.length; m++) {
+            var oldKey = parseInt(sourceKeys[m], 10);
+            result[oldKey + 1] = source[sourceKeys[m]];
+          }
+          return markOverflow(result, getMaxIndex(source) + 1);
+        }
+        var combined = [target].concat(source);
+        if (options && typeof options.arrayLimit === "number" && combined.length > options.arrayLimit) {
+          return markOverflow(arrayToObject(combined, options), combined.length - 1);
+        }
+        return combined;
+      }
+      var mergeTarget = target;
+      if (isArray(target) && !isArray(source)) {
+        mergeTarget = arrayToObject(target, options);
+      }
+      if (isArray(target) && isArray(source)) {
+        source.forEach(function(item, i) {
+          if (has.call(target, i)) {
+            var targetItem = target[i];
+            if (targetItem && typeof targetItem === "object" && item && typeof item === "object") {
+              target[i] = merge3(targetItem, item, options);
+            } else {
+              target[target.length] = item;
+            }
+          } else {
+            target[i] = item;
+          }
+        });
+        return target;
+      }
+      return Object.keys(source).reduce(function(acc, key) {
+        var value = source[key];
+        if (has.call(acc, key)) {
+          acc[key] = merge3(acc[key], value, options);
+        } else {
+          acc[key] = value;
+        }
+        if (isOverflow(source) && !isOverflow(acc)) {
+          markOverflow(acc, getMaxIndex(source));
+        }
+        if (isOverflow(acc)) {
+          var keyNum = parseInt(key, 10);
+          if (String(keyNum) === key && keyNum >= 0 && keyNum > getMaxIndex(acc)) {
+            setMaxIndex(acc, keyNum);
+          }
+        }
+        return acc;
+      }, mergeTarget);
+    };
+    var assign = function assignSingleSource(target, source) {
+      return Object.keys(source).reduce(function(acc, key) {
+        acc[key] = source[key];
+        return acc;
+      }, target);
+    };
+    var decode3 = function(str, defaultDecoder, charset) {
+      var strWithoutPlus = str.replace(/\+/g, " ");
+      if (charset === "iso-8859-1") {
+        return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+      }
+      try {
+        return decodeURIComponent(strWithoutPlus);
+      } catch (e) {
+        return strWithoutPlus;
+      }
+    };
+    var limit = 1024;
+    var encode3 = function encode4(str, defaultEncoder, charset, kind, format) {
+      if (str.length === 0) {
+        return str;
+      }
+      var string4 = str;
+      if (typeof str === "symbol") {
+        string4 = Symbol.prototype.toString.call(str);
+      } else if (typeof str !== "string") {
+        string4 = String(str);
+      }
+      if (charset === "iso-8859-1") {
+        return escape(string4).replace(/%u[0-9a-f]{4}/gi, function($0) {
+          return "%26%23" + parseInt($0.slice(2), 16) + "%3B";
+        });
+      }
+      var out = "";
+      for (var j = 0; j < string4.length; j += limit) {
+        var segment = string4.length >= limit ? string4.slice(j, j + limit) : string4;
+        var arr = [];
+        for (var i = 0; i < segment.length; ++i) {
+          var c = segment.charCodeAt(i);
+          if (c === 45 || c === 46 || c === 95 || c === 126 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || format === formats.RFC1738 && (c === 40 || c === 41)) {
+            arr[arr.length] = segment.charAt(i);
+            continue;
+          }
+          if (c < 128) {
+            arr[arr.length] = hexTable[c];
+            continue;
+          }
+          if (c < 2048) {
+            arr[arr.length] = hexTable[192 | c >> 6] + hexTable[128 | c & 63];
+            continue;
+          }
+          if (c < 55296 || c >= 57344) {
+            arr[arr.length] = hexTable[224 | c >> 12] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
+            continue;
+          }
+          i += 1;
+          c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023);
+          arr[arr.length] = hexTable[240 | c >> 18] + hexTable[128 | c >> 12 & 63] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
+        }
+        out += arr.join("");
+      }
+      return out;
+    };
+    var compact = function compact2(value) {
+      var queue = [{ obj: { o: value }, prop: "o" }];
+      var refs = [];
+      for (var i = 0; i < queue.length; ++i) {
+        var item = queue[i];
+        var obj = item.obj[item.prop];
+        var keys = Object.keys(obj);
+        for (var j = 0; j < keys.length; ++j) {
+          var key = keys[j];
+          var val = obj[key];
+          if (typeof val === "object" && val !== null && refs.indexOf(val) === -1) {
+            queue[queue.length] = { obj, prop: key };
+            refs[refs.length] = val;
+          }
+        }
+      }
+      compactQueue(queue);
+      return value;
+    };
+    var isRegExp = function isRegExp2(obj) {
+      return Object.prototype.toString.call(obj) === "[object RegExp]";
+    };
+    var isBuffer = function isBuffer2(obj) {
+      if (!obj || typeof obj !== "object") {
+        return false;
+      }
+      return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+    };
+    var combine = function combine2(a, b, arrayLimit, plainObjects) {
+      if (isOverflow(a)) {
+        var newIndex = getMaxIndex(a) + 1;
+        a[newIndex] = b;
+        setMaxIndex(a, newIndex);
+        return a;
+      }
+      var result = [].concat(a, b);
+      if (result.length > arrayLimit) {
+        return markOverflow(arrayToObject(result, { plainObjects }), result.length - 1);
+      }
+      return result;
+    };
+    var maybeMap = function maybeMap2(val, fn) {
+      if (isArray(val)) {
+        var mapped = [];
+        for (var i = 0; i < val.length; i += 1) {
+          mapped[mapped.length] = fn(val[i]);
+        }
+        return mapped;
+      }
+      return fn(val);
+    };
+    module2.exports = {
+      arrayToObject,
+      assign,
+      combine,
+      compact,
+      decode: decode3,
+      encode: encode3,
+      isBuffer,
+      isOverflow,
+      isRegExp,
+      markOverflow,
+      maybeMap,
+      merge: merge2
+    };
+  }
+});
+
+// ../../node_modules/qs/lib/stringify.js
+var require_stringify2 = __commonJS({
+  "../../node_modules/qs/lib/stringify.js"(exports2, module2) {
+    "use strict";
+    var getSideChannel = require_side_channel();
+    var utils = require_utils2();
+    var formats = require_formats2();
+    var has = Object.prototype.hasOwnProperty;
+    var arrayPrefixGenerators = {
+      brackets: function brackets(prefix) {
+        return prefix + "[]";
+      },
+      comma: "comma",
+      indices: function indices(prefix, key) {
+        return prefix + "[" + key + "]";
+      },
+      repeat: function repeat(prefix) {
+        return prefix;
+      }
+    };
+    var isArray = Array.isArray;
+    var push = Array.prototype.push;
+    var pushToArray = function(arr, valueOrArray) {
+      push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
+    };
+    var toISO = Date.prototype.toISOString;
+    var defaultFormat = formats["default"];
+    var defaults = {
+      addQueryPrefix: false,
+      allowDots: false,
+      allowEmptyArrays: false,
+      arrayFormat: "indices",
+      charset: "utf-8",
+      charsetSentinel: false,
+      commaRoundTrip: false,
+      delimiter: "&",
+      encode: true,
+      encodeDotInKeys: false,
+      encoder: utils.encode,
+      encodeValuesOnly: false,
+      filter: void 0,
+      format: defaultFormat,
+      formatter: formats.formatters[defaultFormat],
+      // deprecated
+      indices: false,
+      serializeDate: function serializeDate(date5) {
+        return toISO.call(date5);
+      },
+      skipNulls: false,
+      strictNullHandling: false
+    };
+    var isNonNullishPrimitive = function isNonNullishPrimitive2(v) {
+      return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint";
+    };
+    var sentinel = {};
+    var stringify = function stringify2(object2, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) {
+      var obj = object2;
+      var tmpSc = sideChannel;
+      var step = 0;
+      var findFlag = false;
+      while ((tmpSc = tmpSc.get(sentinel)) !== void 0 && !findFlag) {
+        var pos = tmpSc.get(object2);
+        step += 1;
+        if (typeof pos !== "undefined") {
+          if (pos === step) {
+            throw new RangeError("Cyclic object value");
+          } else {
+            findFlag = true;
+          }
+        }
+        if (typeof tmpSc.get(sentinel) === "undefined") {
+          step = 0;
+        }
+      }
+      if (typeof filter === "function") {
+        obj = filter(prefix, obj);
+      } else if (obj instanceof Date) {
+        obj = serializeDate(obj);
+      } else if (generateArrayPrefix === "comma" && isArray(obj)) {
+        obj = utils.maybeMap(obj, function(value2) {
+          if (value2 instanceof Date) {
+            return serializeDate(value2);
+          }
+          return value2;
+        });
+      }
+      if (obj === null) {
+        if (strictNullHandling) {
+          return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, "key", format) : prefix;
+        }
+        obj = "";
+      }
+      if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {
+        if (encoder) {
+          var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format);
+          return [formatter(keyValue) + "=" + formatter(encoder(obj, defaults.encoder, charset, "value", format))];
+        }
+        return [formatter(prefix) + "=" + formatter(String(obj))];
+      }
+      var values = [];
+      if (typeof obj === "undefined") {
+        return values;
+      }
+      var objKeys;
+      if (generateArrayPrefix === "comma" && isArray(obj)) {
+        if (encodeValuesOnly && encoder) {
+          obj = utils.maybeMap(obj, encoder);
+        }
+        objKeys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }];
+      } else if (isArray(filter)) {
+        objKeys = filter;
+      } else {
+        var keys = Object.keys(obj);
+        objKeys = sort ? keys.sort(sort) : keys;
+      }
+      var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix);
+      var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + "[]" : encodedPrefix;
+      if (allowEmptyArrays && isArray(obj) && obj.length === 0) {
+        return adjustedPrefix + "[]";
+      }
+      for (var j = 0; j < objKeys.length; ++j) {
+        var key = objKeys[j];
+        var value = typeof key === "object" && key && typeof key.value !== "undefined" ? key.value : obj[key];
+        if (skipNulls && value === null) {
+          continue;
+        }
+        var encodedKey = allowDots && encodeDotInKeys ? String(key).replace(/\./g, "%2E") : String(key);
+        var keyPrefix = isArray(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix : adjustedPrefix + (allowDots ? "." + encodedKey : "[" + encodedKey + "]");
+        sideChannel.set(object2, step);
+        var valueSideChannel = getSideChannel();
+        valueSideChannel.set(sentinel, sideChannel);
+        pushToArray(values, stringify2(
+          value,
+          keyPrefix,
+          generateArrayPrefix,
+          commaRoundTrip,
+          allowEmptyArrays,
+          strictNullHandling,
+          skipNulls,
+          encodeDotInKeys,
+          generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder,
+          filter,
+          sort,
+          allowDots,
+          serializeDate,
+          format,
+          formatter,
+          encodeValuesOnly,
+          charset,
+          valueSideChannel
+        ));
+      }
+      return values;
+    };
+    var normalizeStringifyOptions = function normalizeStringifyOptions2(opts) {
+      if (!opts) {
+        return defaults;
+      }
+      if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") {
+        throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
+      }
+      if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") {
+        throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided");
+      }
+      if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") {
+        throw new TypeError("Encoder has to be a function.");
+      }
+      var charset = opts.charset || defaults.charset;
+      if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
+        throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
+      }
+      var format = formats["default"];
+      if (typeof opts.format !== "undefined") {
+        if (!has.call(formats.formatters, opts.format)) {
+          throw new TypeError("Unknown format option provided.");
+        }
+        format = opts.format;
+      }
+      var formatter = formats.formatters[format];
+      var filter = defaults.filter;
+      if (typeof opts.filter === "function" || isArray(opts.filter)) {
+        filter = opts.filter;
+      }
+      var arrayFormat;
+      if (opts.arrayFormat in arrayPrefixGenerators) {
+        arrayFormat = opts.arrayFormat;
+      } else if ("indices" in opts) {
+        arrayFormat = opts.indices ? "indices" : "repeat";
+      } else {
+        arrayFormat = defaults.arrayFormat;
+      }
+      if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") {
+        throw new TypeError("`commaRoundTrip` must be a boolean, or absent");
+      }
+      var allowDots = typeof opts.allowDots === "undefined" ? opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;
+      return {
+        addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix,
+        allowDots,
+        allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
+        arrayFormat,
+        charset,
+        charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
+        commaRoundTrip: !!opts.commaRoundTrip,
+        delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter,
+        encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode,
+        encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
+        encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder,
+        encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
+        filter,
+        format,
+        formatter,
+        serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults.serializeDate,
+        skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults.skipNulls,
+        sort: typeof opts.sort === "function" ? opts.sort : null,
+        strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling
+      };
+    };
+    module2.exports = function(object2, opts) {
+      var obj = object2;
+      var options = normalizeStringifyOptions(opts);
+      var objKeys;
+      var filter;
+      if (typeof options.filter === "function") {
+        filter = options.filter;
+        obj = filter("", obj);
+      } else if (isArray(options.filter)) {
+        filter = options.filter;
+        objKeys = filter;
+      }
+      var keys = [];
+      if (typeof obj !== "object" || obj === null) {
+        return "";
+      }
+      var generateArrayPrefix = arrayPrefixGenerators[options.arrayFormat];
+      var commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip;
+      if (!objKeys) {
+        objKeys = Object.keys(obj);
+      }
+      if (options.sort) {
+        objKeys.sort(options.sort);
+      }
+      var sideChannel = getSideChannel();
+      for (var i = 0; i < objKeys.length; ++i) {
+        var key = objKeys[i];
+        var value = obj[key];
+        if (options.skipNulls && value === null) {
+          continue;
+        }
+        pushToArray(keys, stringify(
+          value,
+          key,
+          generateArrayPrefix,
+          commaRoundTrip,
+          options.allowEmptyArrays,
+          options.strictNullHandling,
+          options.skipNulls,
+          options.encodeDotInKeys,
+          options.encode ? options.encoder : null,
+          options.filter,
+          options.sort,
+          options.allowDots,
+          options.serializeDate,
+          options.format,
+          options.formatter,
+          options.encodeValuesOnly,
+          options.charset,
+          sideChannel
+        ));
+      }
+      var joined = keys.join(options.delimiter);
+      var prefix = options.addQueryPrefix === true ? "?" : "";
+      if (options.charsetSentinel) {
+        if (options.charset === "iso-8859-1") {
+          prefix += "utf8=%26%2310003%3B&";
+        } else {
+          prefix += "utf8=%E2%9C%93&";
+        }
+      }
+      return joined.length > 0 ? prefix + joined : "";
+    };
+  }
+});
+
+// ../../node_modules/qs/lib/parse.js
+var require_parse2 = __commonJS({
+  "../../node_modules/qs/lib/parse.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils2();
+    var has = Object.prototype.hasOwnProperty;
+    var isArray = Array.isArray;
+    var defaults = {
+      allowDots: false,
+      allowEmptyArrays: false,
+      allowPrototypes: false,
+      allowSparse: false,
+      arrayLimit: 20,
+      charset: "utf-8",
+      charsetSentinel: false,
+      comma: false,
+      decodeDotInKeys: false,
+      decoder: utils.decode,
+      delimiter: "&",
+      depth: 5,
+      duplicates: "combine",
+      ignoreQueryPrefix: false,
+      interpretNumericEntities: false,
+      parameterLimit: 1e3,
+      parseArrays: true,
+      plainObjects: false,
+      strictDepth: false,
+      strictNullHandling: false,
+      throwOnLimitExceeded: false
+    };
+    var interpretNumericEntities = function(str) {
+      return str.replace(/&#(\d+);/g, function($0, numberStr) {
+        return String.fromCharCode(parseInt(numberStr, 10));
+      });
+    };
+    var parseArrayValue = function(val, options, currentArrayLength) {
+      if (val && typeof val === "string" && options.comma && val.indexOf(",") > -1) {
+        return val.split(",");
+      }
+      if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) {
+        throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+      }
+      return val;
+    };
+    var isoSentinel = "utf8=%26%2310003%3B";
+    var charsetSentinel = "utf8=%E2%9C%93";
+    var parseValues = function parseQueryStringValues(str, options) {
+      var obj = { __proto__: null };
+      var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, "") : str;
+      cleanStr = cleanStr.replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+      var limit = options.parameterLimit === Infinity ? void 0 : options.parameterLimit;
+      var parts = cleanStr.split(
+        options.delimiter,
+        options.throwOnLimitExceeded ? limit + 1 : limit
+      );
+      if (options.throwOnLimitExceeded && parts.length > limit) {
+        throw new RangeError("Parameter limit exceeded. Only " + limit + " parameter" + (limit === 1 ? "" : "s") + " allowed.");
+      }
+      var skipIndex = -1;
+      var i;
+      var charset = options.charset;
+      if (options.charsetSentinel) {
+        for (i = 0; i < parts.length; ++i) {
+          if (parts[i].indexOf("utf8=") === 0) {
+            if (parts[i] === charsetSentinel) {
+              charset = "utf-8";
+            } else if (parts[i] === isoSentinel) {
+              charset = "iso-8859-1";
+            }
+            skipIndex = i;
+            i = parts.length;
+          }
+        }
+      }
+      for (i = 0; i < parts.length; ++i) {
+        if (i === skipIndex) {
+          continue;
+        }
+        var part = parts[i];
+        var bracketEqualsPos = part.indexOf("]=");
+        var pos = bracketEqualsPos === -1 ? part.indexOf("=") : bracketEqualsPos + 1;
+        var key;
+        var val;
+        if (pos === -1) {
+          key = options.decoder(part, defaults.decoder, charset, "key");
+          val = options.strictNullHandling ? null : "";
+        } else {
+          key = options.decoder(part.slice(0, pos), defaults.decoder, charset, "key");
+          if (key !== null) {
+            val = utils.maybeMap(
+              parseArrayValue(
+                part.slice(pos + 1),
+                options,
+                isArray(obj[key]) ? obj[key].length : 0
+              ),
+              function(encodedVal) {
+                return options.decoder(encodedVal, defaults.decoder, charset, "value");
+              }
+            );
+          }
+        }
+        if (val && options.interpretNumericEntities && charset === "iso-8859-1") {
+          val = interpretNumericEntities(String(val));
+        }
+        if (part.indexOf("[]=") > -1) {
+          val = isArray(val) ? [val] : val;
+        }
+        if (options.comma && isArray(val) && val.length > options.arrayLimit) {
+          if (options.throwOnLimitExceeded) {
+            throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+          }
+          val = utils.combine([], val, options.arrayLimit, options.plainObjects);
+        }
+        if (key !== null) {
+          var existing = has.call(obj, key);
+          if (existing && options.duplicates === "combine") {
+            obj[key] = utils.combine(
+              obj[key],
+              val,
+              options.arrayLimit,
+              options.plainObjects
+            );
+          } else if (!existing || options.duplicates === "last") {
+            obj[key] = val;
+          }
+        }
+      }
+      return obj;
+    };
+    var parseObject = function(chain, val, options, valuesParsed) {
+      var currentArrayLength = 0;
+      if (chain.length > 0 && chain[chain.length - 1] === "[]") {
+        var parentKey = chain.slice(0, -1).join("");
+        currentArrayLength = Array.isArray(val) && val[parentKey] ? val[parentKey].length : 0;
+      }
+      var leaf = valuesParsed ? val : parseArrayValue(val, options, currentArrayLength);
+      for (var i = chain.length - 1; i >= 0; --i) {
+        var obj;
+        var root = chain[i];
+        if (root === "[]" && options.parseArrays) {
+          if (utils.isOverflow(leaf)) {
+            obj = leaf;
+          } else {
+            obj = options.allowEmptyArrays && (leaf === "" || options.strictNullHandling && leaf === null) ? [] : utils.combine(
+              [],
+              leaf,
+              options.arrayLimit,
+              options.plainObjects
+            );
+          }
+        } else {
+          obj = options.plainObjects ? { __proto__: null } : {};
+          var cleanRoot = root.charAt(0) === "[" && root.charAt(root.length - 1) === "]" ? root.slice(1, -1) : root;
+          var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, ".") : cleanRoot;
+          var index = parseInt(decodedRoot, 10);
+          var isValidArrayIndex = !isNaN(index) && root !== decodedRoot && String(index) === decodedRoot && index >= 0 && options.parseArrays;
+          if (!options.parseArrays && decodedRoot === "") {
+            obj = { 0: leaf };
+          } else if (isValidArrayIndex && index < options.arrayLimit) {
+            obj = [];
+            obj[index] = leaf;
+          } else if (isValidArrayIndex && options.throwOnLimitExceeded) {
+            throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+          } else if (isValidArrayIndex) {
+            obj[index] = leaf;
+            utils.markOverflow(obj, index);
+          } else if (decodedRoot !== "__proto__") {
+            obj[decodedRoot] = leaf;
+          }
+        }
+        leaf = obj;
+      }
+      return leaf;
+    };
+    var splitKeyIntoSegments = function splitKeyIntoSegments2(givenKey, options) {
+      var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, "[$1]") : givenKey;
+      if (options.depth <= 0) {
+        if (!options.plainObjects && has.call(Object.prototype, key)) {
+          if (!options.allowPrototypes) {
+            return;
+          }
+        }
+        return [key];
+      }
+      var brackets = /(\[[^[\]]*])/;
+      var child = /(\[[^[\]]*])/g;
+      var segment = brackets.exec(key);
+      var parent = segment ? key.slice(0, segment.index) : key;
+      var keys = [];
+      if (parent) {
+        if (!options.plainObjects && has.call(Object.prototype, parent)) {
+          if (!options.allowPrototypes) {
+            return;
+          }
+        }
+        keys[keys.length] = parent;
+      }
+      var i = 0;
+      while ((segment = child.exec(key)) !== null && i < options.depth) {
+        i += 1;
+        var segmentContent = segment[1].slice(1, -1);
+        if (!options.plainObjects && has.call(Object.prototype, segmentContent)) {
+          if (!options.allowPrototypes) {
+            return;
+          }
+        }
+        keys[keys.length] = segment[1];
+      }
+      if (segment) {
+        if (options.strictDepth === true) {
+          throw new RangeError("Input depth exceeded depth option of " + options.depth + " and strictDepth is true");
+        }
+        keys[keys.length] = "[" + key.slice(segment.index) + "]";
+      }
+      return keys;
+    };
+    var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
+      if (!givenKey) {
+        return;
+      }
+      var keys = splitKeyIntoSegments(givenKey, options);
+      if (!keys) {
+        return;
+      }
+      return parseObject(keys, val, options, valuesParsed);
+    };
+    var normalizeParseOptions = function normalizeParseOptions2(opts) {
+      if (!opts) {
+        return defaults;
+      }
+      if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") {
+        throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
+      }
+      if (typeof opts.decodeDotInKeys !== "undefined" && typeof opts.decodeDotInKeys !== "boolean") {
+        throw new TypeError("`decodeDotInKeys` option can only be `true` or `false`, when provided");
+      }
+      if (opts.decoder !== null && typeof opts.decoder !== "undefined" && typeof opts.decoder !== "function") {
+        throw new TypeError("Decoder has to be a function.");
+      }
+      if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
+        throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
+      }
+      if (typeof opts.throwOnLimitExceeded !== "undefined" && typeof opts.throwOnLimitExceeded !== "boolean") {
+        throw new TypeError("`throwOnLimitExceeded` option must be a boolean");
+      }
+      var charset = typeof opts.charset === "undefined" ? defaults.charset : opts.charset;
+      var duplicates = typeof opts.duplicates === "undefined" ? defaults.duplicates : opts.duplicates;
+      if (duplicates !== "combine" && duplicates !== "first" && duplicates !== "last") {
+        throw new TypeError("The duplicates option must be either combine, first, or last");
+      }
+      var allowDots = typeof opts.allowDots === "undefined" ? opts.decodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;
+      return {
+        allowDots,
+        allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
+        allowPrototypes: typeof opts.allowPrototypes === "boolean" ? opts.allowPrototypes : defaults.allowPrototypes,
+        allowSparse: typeof opts.allowSparse === "boolean" ? opts.allowSparse : defaults.allowSparse,
+        arrayLimit: typeof opts.arrayLimit === "number" ? opts.arrayLimit : defaults.arrayLimit,
+        charset,
+        charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
+        comma: typeof opts.comma === "boolean" ? opts.comma : defaults.comma,
+        decodeDotInKeys: typeof opts.decodeDotInKeys === "boolean" ? opts.decodeDotInKeys : defaults.decodeDotInKeys,
+        decoder: typeof opts.decoder === "function" ? opts.decoder : defaults.decoder,
+        delimiter: typeof opts.delimiter === "string" || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,
+        // eslint-disable-next-line no-implicit-coercion, no-extra-parens
+        depth: typeof opts.depth === "number" || opts.depth === false ? +opts.depth : defaults.depth,
+        duplicates,
+        ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
+        interpretNumericEntities: typeof opts.interpretNumericEntities === "boolean" ? opts.interpretNumericEntities : defaults.interpretNumericEntities,
+        parameterLimit: typeof opts.parameterLimit === "number" ? opts.parameterLimit : defaults.parameterLimit,
+        parseArrays: opts.parseArrays !== false,
+        plainObjects: typeof opts.plainObjects === "boolean" ? opts.plainObjects : defaults.plainObjects,
+        strictDepth: typeof opts.strictDepth === "boolean" ? !!opts.strictDepth : defaults.strictDepth,
+        strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling,
+        throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === "boolean" ? opts.throwOnLimitExceeded : false
+      };
+    };
+    module2.exports = function(str, opts) {
+      var options = normalizeParseOptions(opts);
+      if (str === "" || str === null || typeof str === "undefined") {
+        return options.plainObjects ? { __proto__: null } : {};
+      }
+      var tempObj = typeof str === "string" ? parseValues(str, options) : str;
+      var obj = options.plainObjects ? { __proto__: null } : {};
+      var keys = Object.keys(tempObj);
+      for (var i = 0; i < keys.length; ++i) {
+        var key = keys[i];
+        var newObj = parseKeys(key, tempObj[key], options, typeof str === "string");
+        obj = utils.merge(obj, newObj, options);
+      }
+      if (options.allowSparse === true) {
+        return obj;
+      }
+      return utils.compact(obj);
+    };
+  }
+});
+
+// ../../node_modules/qs/lib/index.js
+var require_lib3 = __commonJS({
+  "../../node_modules/qs/lib/index.js"(exports2, module2) {
+    "use strict";
+    var stringify = require_stringify2();
+    var parse3 = require_parse2();
+    var formats = require_formats2();
+    module2.exports = {
+      formats,
+      parse: parse3,
+      stringify
+    };
+  }
+});
+
 // ../../node_modules/express/lib/middleware/query.js
 var require_query = __commonJS({
   "../../node_modules/express/lib/middleware/query.js"(exports2, module2) {
     "use strict";
     var merge2 = require_utils_merge();
     var parseUrl = require_parseurl();
-    var qs = require_lib2();
+    var qs = require_lib3();
     module2.exports = function query(options) {
       var opts = merge2({}, options);
       var queryparse = qs.parse;
@@ -27493,7 +28376,7 @@ var require_proxy_addr = __commonJS({
 });
 
 // ../../node_modules/express/lib/utils.js
-var require_utils2 = __commonJS({
+var require_utils3 = __commonJS({
   "../../node_modules/express/lib/utils.js"(exports2) {
     "use strict";
     var Buffer2 = require_safe_buffer().Buffer;
@@ -27504,7 +28387,7 @@ var require_utils2 = __commonJS({
     var mime = require_send().mime;
     var etag = require_etag();
     var proxyaddr = require_proxy_addr();
-    var qs = require_lib2();
+    var qs = require_lib3();
     var querystring = require("querystring");
     exports2.etag = createETagGenerator({ weak: false });
     exports2.wetag = createETagGenerator({ weak: true });
@@ -27641,9 +28524,9 @@ var require_application = __commonJS({
     var debug = require_src3()("express:application");
     var View = require_view();
     var http2 = require("http");
-    var compileETag = require_utils2().compileETag;
-    var compileQueryParser = require_utils2().compileQueryParser;
-    var compileTrust = require_utils2().compileTrust;
+    var compileETag = require_utils3().compileETag;
+    var compileQueryParser = require_utils3().compileQueryParser;
+    var compileTrust = require_utils3().compileTrust;
     var deprecate = require_depd()("express");
     var flatten = require_array_flatten();
     var merge2 = require_utils_merge();
@@ -28918,15 +29801,15 @@ var require_response = __commonJS({
     var encodeUrl = require_encodeurl();
     var escapeHtml = require_escape_html();
     var http2 = require("http");
-    var isAbsolute = require_utils2().isAbsolute;
+    var isAbsolute = require_utils3().isAbsolute;
     var onFinished = require_on_finished();
     var path10 = require("path");
     var statuses = require_statuses();
     var merge2 = require_utils_merge();
     var sign = require_cookie_signature().sign;
-    var normalizeType = require_utils2().normalizeType;
-    var normalizeTypes = require_utils2().normalizeTypes;
-    var setCharset = require_utils2().setCharset;
+    var normalizeType = require_utils3().normalizeType;
+    var normalizeTypes = require_utils3().normalizeTypes;
+    var setCharset = require_utils3().setCharset;
     var cookie = require_cookie();
     var send = require_send();
     var extname = path10.extname;
@@ -33259,7 +34142,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_node_child_process3 = require("node:child_process");
-var import_node_fs6 = require("node:fs");
+var import_node_fs7 = require("node:fs");
 var import_node_os4 = __toESM(require("node:os"), 1);
 var import_node_path10 = __toESM(require("node:path"), 1);
 var import_node_module = require("node:module");
@@ -33296,12 +34179,45 @@ function plistPath(home, name) {
 function unitPath(home, name) {
   return (0, import_node_path.join)(home, ".config", "systemd", "user", `${name}.service`);
 }
+var invalidXmlCharPattern = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]/;
+var envKeyPattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var safeSystemdEnvValuePattern = /^[A-Za-z0-9_./:@,=+-]*$/;
+function xmlEscape(s) {
+  return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function validateXmlString(s) {
+  if (invalidXmlCharPattern.test(s)) {
+    throw new Error("string contains characters that are not allowed in XML 1.0");
+  }
+}
+function validateEnvKey(k) {
+  if (!envKeyPattern.test(k)) {
+    throw new Error(`invalid environment variable key: ${k}`);
+  }
+}
+function formatSystemdEnvValue(v) {
+  if (v.includes("\0") || v.includes("\n")) {
+    throw new Error("systemd environment values cannot contain NUL or newline characters");
+  }
+  if (safeSystemdEnvValuePattern.test(v))
+    return v;
+  return `"${v.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
 function renderPlist(name, programArgs, env) {
-  const entries = programArgs.map((arg) => `    <string>${arg}</string>`).join("\n");
+  validateXmlString(name);
+  const entries = programArgs.map((arg) => {
+    validateXmlString(arg);
+    return `    <string>${xmlEscape(arg)}</string>`;
+  }).join("\n");
   let envBlock = "";
   if (env && Object.keys(env).length > 0) {
-    const envEntries = Object.entries(env).map(([k, v]) => `    <key>${k}</key>
-    <string>${v}</string>`).join("\n");
+    const envEntries = Object.entries(env).map(([k, v]) => {
+      validateXmlString(k);
+      validateEnvKey(k);
+      validateXmlString(v);
+      return `    <key>${xmlEscape(k)}</key>
+    <string>${xmlEscape(v)}</string>`;
+    }).join("\n");
     envBlock = `
   <key>EnvironmentVariables</key>
   <dict>
@@ -33313,7 +34229,7 @@ ${envEntries}
 <plist version="1.0">
 <dict>
   <key>Label</key>
-  <string>${name}</string>
+  <string>${xmlEscape(name)}</string>
   <key>ProgramArguments</key>
   <array>
 ${entries}
@@ -33321,7 +34237,9 @@ ${entries}
   <key>RunAtLoad</key>
   <true/>
   <key>KeepAlive</key>
-  <true/>${envBlock}
+  <true/>
+  <key>ProcessType</key>
+  <string>Background</string>${envBlock}
 </dict>
 </plist>
 `;
@@ -33333,7 +34251,10 @@ function quoteSystemdArg(arg) {
 }
 function renderUnit(description, programArgs, env) {
   const execStart = programArgs.map(quoteSystemdArg).join(" ");
-  const envLines = env ? Object.entries(env).map(([k, v]) => `Environment=${k}=${v}`).join("\n") : "";
+  const envLines = env ? Object.entries(env).map(([k, v]) => {
+    validateEnvKey(k);
+    return `Environment=${k}=${formatSystemdEnvValue(v)}`;
+  }).join("\n") : "";
   return `[Unit]
 Description=${description}
 
@@ -34130,6 +35051,7 @@ var import_express2 = __toESM(require_express2(), 1);
 var import_node_http = __toESM(require("node:http"), 1);
 
 // ../server/src/config.ts
+var import_node_fs2 = require("node:fs");
 var import_node_os2 = __toESM(require("node:os"), 1);
 var import_node_path2 = __toESM(require("node:path"), 1);
 var TRUE_ENV_VALUE = "true";
@@ -34141,12 +35063,14 @@ var ACP_AGENT_PROFILES = {
     agent: "openclaw",
     command: "openclaw",
     args: ["acp"],
+    envPrefix: "OPENCLAW_",
     sessionIdStrategy: "deterministic"
   },
   hermes: {
     agent: "hermes",
     command: "hermes",
     args: ["acp"],
+    envPrefix: "HERMES_",
     sessionIdStrategy: "mapped"
   }
 };
@@ -34174,13 +35098,47 @@ function resolveACPAgentProfile(env = process.env) {
     `Unsupported TELEVISION_ACP_AGENT "${rawAgent}". Supported values: openclaw, hermes.`
   );
 }
+function buildPersistedACPEnvironment(env) {
+  const profile = resolveACPAgentProfile(env);
+  const pathValue = env.PATH;
+  if (pathValue === void 0) {
+    throw new Error("PATH is required to build the persisted ACP environment.");
+  }
+  const snapshot = {
+    PATH: pathValue,
+    [TELEVISION_ACP_AGENT_ENV]: profile.agent
+  };
+  for (const [key, value] of Object.entries(env)) {
+    if (key.startsWith(profile.envPrefix) && value !== void 0) {
+      snapshot[key] = value;
+    }
+  }
+  return snapshot;
+}
+function canExecuteFile(filePath) {
+  try {
+    return (0, import_node_fs2.statSync)(filePath).isFile() && (0, import_node_fs2.accessSync)(filePath, import_node_fs2.constants.X_OK) === void 0;
+  } catch {
+    return false;
+  }
+}
+function isACPCommandResolvable(command, envSnapshot) {
+  if (command.includes(import_node_path2.default.sep)) {
+    return canExecuteFile(command);
+  }
+  const pathValue = envSnapshot.PATH;
+  if (!pathValue) {
+    return false;
+  }
+  return pathValue.split(import_node_path2.default.delimiter).filter((entry) => entry.length > 0).some((entry) => canExecuteFile(import_node_path2.default.join(entry, command)));
+}
 function isVitestRuntime() {
   return process.env.VITEST === TRUE_ENV_VALUE;
 }
 
 // ../server/src/routes.ts
 var import_express = __toESM(require_express2(), 1);
-var import_node_fs3 = require("node:fs");
+var import_node_fs4 = require("node:fs");
 var import_node_path5 = __toESM(require("node:path"), 1);
 
 // ../../node_modules/zod/v4/classic/external.js
@@ -48109,7 +49067,7 @@ function getArtifactEntryFilePath(storagePath, artifactID, kind, state) {
 }
 
 // ../server/src/themes.ts
-var import_node_fs2 = require("node:fs");
+var import_node_fs3 = require("node:fs");
 var import_node_path4 = __toESM(require("node:path"), 1);
 var HTTP_NOT_FOUND_STATUS = 404;
 var THEME_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
@@ -48138,7 +49096,7 @@ function themeExists(storagePath, name) {
     return false;
   }
   try {
-    return (0, import_node_fs2.statSync)(getThemeEntryPath(storagePath, name)).isFile();
+    return (0, import_node_fs3.statSync)(getThemeEntryPath(storagePath, name)).isFile();
   } catch {
     return false;
   }
@@ -48160,7 +49118,7 @@ function serveThemeCSS(storagePath) {
       return;
     }
     try {
-      const css = (0, import_node_fs2.readFileSync)(getThemeEntryPath(storagePath, name), "utf8");
+      const css = (0, import_node_fs3.readFileSync)(getThemeEntryPath(storagePath, name), "utf8");
       res.type("text/css").setHeader("Cache-Control", "no-cache").send(rewriteThemeURLs(css, name));
     } catch (error48) {
       if (error48.code === "ENOENT") {
@@ -48562,8 +49520,8 @@ function registerRoutes(app, store, options) {
     let realPublicDir;
     let realRequestedPath;
     try {
-      realPublicDir = (0, import_node_fs3.realpathSync)(publicDir);
-      realRequestedPath = (0, import_node_fs3.realpathSync)(requestedPath);
+      realPublicDir = (0, import_node_fs4.realpathSync)(publicDir);
+      realRequestedPath = (0, import_node_fs4.realpathSync)(requestedPath);
     } catch {
       sendError(res, HTTP_NOT_FOUND, "Not found");
       return;
@@ -49041,7 +49999,7 @@ var ACPServer = class extends withDisposable(class {
     super();
     this.authToken = options.authToken;
     this.publicServer = options.publicServer;
-    this.profile = options.profile ?? resolveACPAgentProfile();
+    this.profile = options.profile;
     this.wsServer = new import_websocket_server.default({ noServer: true });
     this.wsServer.on("connection", (socket, request) => {
       if (!this.publicServer && !isAuthorizedQueryToken(request.url, this.authToken)) {
@@ -49100,7 +50058,7 @@ var ACPServer = class extends withDisposable(class {
 
 // ../server/src/canonical.ts
 var import_node_crypto3 = require("node:crypto");
-var import_node_fs4 = require("node:fs");
+var import_node_fs5 = require("node:fs");
 var import_node_path7 = __toESM(require("node:path"), 1);
 var CACHE_CONTROL_NO_CACHE = "no-cache";
 var HTTP_NOT_MODIFIED_STATUS = 304;
@@ -49126,7 +50084,7 @@ function serveCanonicalStyles(options) {
   };
 }
 function loadCanonicalBundle(canonicalDir) {
-  const css = (0, import_node_fs4.readFileSync)(import_node_path7.default.join(canonicalDir, CANONICAL_STYLESHEET), "utf8");
+  const css = (0, import_node_fs5.readFileSync)(import_node_path7.default.join(canonicalDir, CANONICAL_STYLESHEET), "utf8");
   return { css, hash: hashContent(css) };
 }
 function buildCanonicalResponse(bundle, store) {
@@ -49139,7 +50097,7 @@ function buildCanonicalResponse(bundle, store) {
     return { body: bundle.css, etag: buildETag(bundle.hash, NO_THEME_HASH) };
   }
   try {
-    const themeCSS = (0, import_node_fs4.readFileSync)(getThemeEntryPath(store.storagePath, activeThemeName), "utf8");
+    const themeCSS = (0, import_node_fs5.readFileSync)(getThemeEntryPath(store.storagePath, activeThemeName), "utf8");
     return {
       body: `${bundle.css}
 
@@ -49291,7 +50249,7 @@ var Server = class {
 };
 
 // ../server/src/server-store.ts
-var import_node_fs5 = require("node:fs");
+var import_node_fs6 = require("node:fs");
 var import_node_path9 = __toESM(require("node:path"), 1);
 
 // ../server/src/file-watcher.ts
@@ -49331,7 +50289,7 @@ var ServerStore = class extends EventTarget {
     super();
     this.storagePath = options.storagePath;
     this.watchContentFile = options.watchContentFile ?? defaultWatchContentFile;
-    this.bundledViewsPath = options.bundledViewsPath && (0, import_node_fs5.existsSync)(options.bundledViewsPath) ? options.bundledViewsPath : null;
+    this.bundledViewsPath = options.bundledViewsPath && (0, import_node_fs6.existsSync)(options.bundledViewsPath) ? options.bundledViewsPath : null;
     this.ensureDirectories();
     this.views = this.scanViewRegistry();
     this.authToken = this.loadOrCreateAuthToken();
@@ -49386,7 +50344,7 @@ var ServerStore = class extends EventTarget {
     return this._artifacts.get(id);
   }
   hasTrashedArtifact(id) {
-    return (0, import_node_fs5.existsSync)(getArtifactTrashMetadataPath(this.storagePath, id));
+    return (0, import_node_fs6.existsSync)(getArtifactTrashMetadataPath(this.storagePath, id));
   }
   /**
    * Resolve the absolute filesystem path where an artifact's primary content
@@ -49425,11 +50383,11 @@ var ServerStore = class extends EventTarget {
       throw new NotFoundError(`Artifact not found: ${id}`, { entityType: "artifact", entityID: id });
     }
     try {
-      (0, import_node_fs5.accessSync)(contentPath, import_node_fs5.constants.R_OK);
+      (0, import_node_fs6.accessSync)(contentPath, import_node_fs6.constants.R_OK);
     } catch {
       throw new NotFoundError(`Artifact content not readable: ${id}`, { entityType: "artifact content", entityID: id });
     }
-    return (0, import_node_fs5.readFileSync)(contentPath);
+    return (0, import_node_fs6.readFileSync)(contentPath);
   }
   /**
    * Replace an artifact's content at the resolved content path.
@@ -49455,10 +50413,10 @@ var ServerStore = class extends EventTarget {
         `Artifact ${id} has no committed content yet. Use commit or abandon after writing the pending bundle`
       );
     }
-    if (!(0, import_node_fs5.existsSync)(import_node_path9.default.dirname(contentPath))) {
+    if (!(0, import_node_fs6.existsSync)(import_node_path9.default.dirname(contentPath))) {
       throw new NotFoundError(`Artifact content not readable: ${id}`, { entityType: "artifact content", entityID: id });
     }
-    (0, import_node_fs5.writeFileSync)(contentPath, content);
+    (0, import_node_fs6.writeFileSync)(contentPath, content);
   }
   listScreens() {
     return [...this.screens.values()];
@@ -49525,8 +50483,8 @@ var ServerStore = class extends EventTarget {
       throw new InvalidRequestError(`Artifact ${artifactID} already has pending work. Use commit or abandon before editing again`);
     }
     const pendingPath = getArtifactPendingBundlePath(this.storagePath, artifactID);
-    (0, import_node_fs5.rmSync)(pendingPath, { recursive: true, force: true });
-    (0, import_node_fs5.cpSync)(
+    (0, import_node_fs6.rmSync)(pendingPath, { recursive: true, force: true });
+    (0, import_node_fs6.cpSync)(
       getArtifactCommittedBundlePath(this.storagePath, artifactID),
       pendingPath,
       { recursive: true }
@@ -49550,8 +50508,8 @@ var ServerStore = class extends EventTarget {
     const pendingPath = getArtifactPendingBundlePath(this.storagePath, artifactID);
     const committedPath = getArtifactCommittedBundlePath(this.storagePath, artifactID);
     this.stopWatchingArtifactContent(artifactID);
-    (0, import_node_fs5.rmSync)(committedPath, { recursive: true, force: true });
-    (0, import_node_fs5.renameSync)(pendingPath, committedPath);
+    (0, import_node_fs6.rmSync)(committedPath, { recursive: true, force: true });
+    (0, import_node_fs6.renameSync)(pendingPath, committedPath);
     artifact.status = "committed";
     this.writeArtifact(artifact);
     this._artifacts.set(artifactID, artifact);
@@ -49571,7 +50529,7 @@ var ServerStore = class extends EventTarget {
     if (artifact.status !== "pending") {
       throw new InvalidRequestError(`Artifact ${artifactID} has no pending work to abandon`);
     }
-    (0, import_node_fs5.rmSync)(getArtifactPendingBundlePath(this.storagePath, artifactID), { recursive: true, force: true });
+    (0, import_node_fs6.rmSync)(getArtifactPendingBundlePath(this.storagePath, artifactID), { recursive: true, force: true });
     if (!this.hasCommittedBundle(artifactID)) {
       this.cascadeArtifactRemoval(artifactID);
       return;
@@ -49847,13 +50805,13 @@ var ServerStore = class extends EventTarget {
     this.dispose();
   }
   load() {
-    if ((0, import_node_fs5.existsSync)(this.screensDir)) {
-      for (const file2 of (0, import_node_fs5.readdirSync)(this.screensDir)) {
+    if ((0, import_node_fs6.existsSync)(this.screensDir)) {
+      for (const file2 of (0, import_node_fs6.readdirSync)(this.screensDir)) {
         if (!file2.endsWith(JSON_FILE_SUFFIX)) continue;
         const filePath = import_node_path9.default.join(this.screensDir, file2);
         let raw;
         try {
-          raw = JSON.parse((0, import_node_fs5.readFileSync)(filePath, "utf8"));
+          raw = JSON.parse((0, import_node_fs6.readFileSync)(filePath, "utf8"));
         } catch (error48) {
           console.warn(`Skipping malformed JSON file: ${filePath}`, error48);
           continue;
@@ -49869,10 +50827,10 @@ var ServerStore = class extends EventTarget {
         });
       }
     }
-    if (!(0, import_node_fs5.existsSync)(this.artifactsDir)) {
+    if (!(0, import_node_fs6.existsSync)(this.artifactsDir)) {
       return;
     }
-    for (const file2 of (0, import_node_fs5.readdirSync)(this.artifactsDir)) {
+    for (const file2 of (0, import_node_fs6.readdirSync)(this.artifactsDir)) {
       if (!file2.endsWith(JSON_FILE_SUFFIX)) {
         continue;
       }
@@ -49905,7 +50863,7 @@ var ServerStore = class extends EventTarget {
       return;
     }
     try {
-      (0, import_node_fs5.accessSync)(contentPath, import_node_fs5.constants.R_OK);
+      (0, import_node_fs6.accessSync)(contentPath, import_node_fs6.constants.R_OK);
       const watcher = this.watchContentFile(contentPath, () => {
         this.scheduleArtifactContentChangedEvent(artifactID);
       });
@@ -50024,7 +50982,7 @@ var ServerStore = class extends EventTarget {
    * metadata field.
    */
   hasCommittedBundle(artifactID) {
-    return (0, import_node_fs5.existsSync)(getArtifactCommittedBundlePath(this.storagePath, artifactID));
+    return (0, import_node_fs6.existsSync)(getArtifactCommittedBundlePath(this.storagePath, artifactID));
   }
   createKindArtifact(input) {
     const kind = input.kind;
@@ -50094,9 +51052,9 @@ var ServerStore = class extends EventTarget {
     this.persistDisplayState();
   }
   ensureDirectories() {
-    (0, import_node_fs5.mkdirSync)(this.screensDir, { recursive: true });
-    (0, import_node_fs5.mkdirSync)(this.artifactsDir, { recursive: true });
-    (0, import_node_fs5.mkdirSync)(getThemesDir(this.storagePath), { recursive: true });
+    (0, import_node_fs6.mkdirSync)(this.screensDir, { recursive: true });
+    (0, import_node_fs6.mkdirSync)(this.artifactsDir, { recursive: true });
+    (0, import_node_fs6.mkdirSync)(getThemesDir(this.storagePath), { recursive: true });
   }
   /**
    * Cascade the last-reference removal of `artifactID`: move the bundle to
@@ -50113,12 +51071,12 @@ var ServerStore = class extends EventTarget {
     }
     const affectedScreenIDs = this.collectReferencingScreenIDs(artifactID);
     if (artifact.kind === "web-bundle") {
-      (0, import_node_fs5.rmSync)(getArtifactPendingBundlePath(this.storagePath, artifactID), { recursive: true, force: true });
+      (0, import_node_fs6.rmSync)(getArtifactPendingBundlePath(this.storagePath, artifactID), { recursive: true, force: true });
     }
     this.stopWatchingArtifactContent(artifactID);
     if (artifact.kind === "web-bundle" && artifact.status === "pending" && !this.hasCommittedBundle(artifactID)) {
       this._artifacts.delete(artifactID);
-      (0, import_node_fs5.rmSync)(getArtifactLiveMetadataPath(this.storagePath, artifactID), { force: true });
+      (0, import_node_fs6.rmSync)(getArtifactLiveMetadataPath(this.storagePath, artifactID), { force: true });
       this.stripArtifactFromScreens(artifactID, affectedScreenIDs);
       this.emitArtifactRemovedEvents(artifactID, affectedScreenIDs);
       return {
@@ -50132,7 +51090,7 @@ var ServerStore = class extends EventTarget {
       status: "committed"
     });
     this._artifacts.delete(artifactID);
-    (0, import_node_fs5.rmSync)(getArtifactLiveMetadataPath(this.storagePath, artifactID), { force: true });
+    (0, import_node_fs6.rmSync)(getArtifactLiveMetadataPath(this.storagePath, artifactID), { force: true });
     this.stripArtifactFromScreens(artifactID, affectedScreenIDs);
     this.emitArtifactRemovedEvents(artifactID, affectedScreenIDs);
     return result;
@@ -50157,8 +51115,8 @@ var ServerStore = class extends EventTarget {
   }
   trashArtifact(artifact) {
     const metadataPath = getArtifactTrashMetadataPath(this.storagePath, artifact.id);
-    (0, import_node_fs5.mkdirSync)(import_node_path9.default.dirname(metadataPath), { recursive: true });
-    (0, import_node_fs5.writeFileSync)(metadataPath, JSON.stringify(artifact, null, JSON_INDENT_SPACES));
+    (0, import_node_fs6.mkdirSync)(import_node_path9.default.dirname(metadataPath), { recursive: true });
+    (0, import_node_fs6.writeFileSync)(metadataPath, JSON.stringify(artifact, null, JSON_INDENT_SPACES));
     switch (artifact.kind) {
       case "url": {
         const externalURL = artifact.externalURL;
@@ -50189,9 +51147,9 @@ var ServerStore = class extends EventTarget {
       case "web-bundle": {
         const committedBundlePath = getArtifactCommittedBundlePath(this.storagePath, artifact.id);
         const bundlePath = getArtifactTrashBundlePath(this.storagePath, artifact.id);
-        (0, import_node_fs5.rmSync)(bundlePath, { recursive: true, force: true });
-        if ((0, import_node_fs5.existsSync)(committedBundlePath)) {
-          (0, import_node_fs5.renameSync)(committedBundlePath, bundlePath);
+        (0, import_node_fs6.rmSync)(bundlePath, { recursive: true, force: true });
+        if ((0, import_node_fs6.existsSync)(committedBundlePath)) {
+          (0, import_node_fs6.renameSync)(committedBundlePath, bundlePath);
         }
         return {
           outcome: "trashed",
@@ -50205,9 +51163,9 @@ var ServerStore = class extends EventTarget {
   }
   trashScreen(screen) {
     const metadataPath = getTrashedScreenMetadataPath(this.storagePath, screen.id);
-    (0, import_node_fs5.mkdirSync)(import_node_path9.default.dirname(metadataPath), { recursive: true });
-    (0, import_node_fs5.writeFileSync)(metadataPath, JSON.stringify(screen, null, JSON_INDENT_SPACES));
-    (0, import_node_fs5.rmSync)(import_node_path9.default.join(this.screensDir, `${screen.id}.json`), { force: true });
+    (0, import_node_fs6.mkdirSync)(import_node_path9.default.dirname(metadataPath), { recursive: true });
+    (0, import_node_fs6.writeFileSync)(metadataPath, JSON.stringify(screen, null, JSON_INDENT_SPACES));
+    (0, import_node_fs6.rmSync)(import_node_path9.default.join(this.screensDir, `${screen.id}.json`), { force: true });
     this.screens.delete(screen.id);
     return metadataPath;
   }
@@ -50225,7 +51183,7 @@ var ServerStore = class extends EventTarget {
     }
     let entries;
     try {
-      entries = (0, import_node_fs5.readdirSync)(this.bundledViewsPath);
+      entries = (0, import_node_fs6.readdirSync)(this.bundledViewsPath);
     } catch (error48) {
       console.warn(`Failed to read bundled views directory: ${this.bundledViewsPath}`, error48);
       return [];
@@ -50234,7 +51192,7 @@ var ServerStore = class extends EventTarget {
     for (const id of entries) {
       const viewDir = import_node_path9.default.join(this.bundledViewsPath, id);
       try {
-        if (!(0, import_node_fs5.statSync)(viewDir).isDirectory()) {
+        if (!(0, import_node_fs6.statSync)(viewDir).isDirectory()) {
           continue;
         }
       } catch {
@@ -50243,7 +51201,7 @@ var ServerStore = class extends EventTarget {
       const manifestPath = import_node_path9.default.join(viewDir, "manifest.json");
       let raw;
       try {
-        raw = (0, import_node_fs5.readFileSync)(manifestPath, "utf8");
+        raw = (0, import_node_fs6.readFileSync)(manifestPath, "utf8");
       } catch {
         console.warn(`Skipping view "${id}": cannot read manifest at ${manifestPath}`);
         continue;
@@ -50266,12 +51224,12 @@ var ServerStore = class extends EventTarget {
     return registry2;
   }
   loadDisplayState() {
-    if (!(0, import_node_fs5.existsSync)(this.displayStatePath)) {
+    if (!(0, import_node_fs6.existsSync)(this.displayStatePath)) {
       return false;
     }
     let raw;
     try {
-      raw = (0, import_node_fs5.readFileSync)(this.displayStatePath, "utf8");
+      raw = (0, import_node_fs6.readFileSync)(this.displayStatePath, "utf8");
     } catch {
       return false;
     }
@@ -50289,7 +51247,7 @@ var ServerStore = class extends EventTarget {
     return false;
   }
   persistDisplayState() {
-    (0, import_node_fs5.writeFileSync)(
+    (0, import_node_fs6.writeFileSync)(
       this.displayStatePath,
       JSON.stringify(this.getDisplayState(), null, JSON_INDENT_SPACES)
     );
@@ -50311,11 +51269,11 @@ var ServerStore = class extends EventTarget {
     return firstScreen.id;
   }
   loadOrCreateAuthToken() {
-    if ((0, import_node_fs5.existsSync)(this.tokenPath)) {
-      return (0, import_node_fs5.readFileSync)(this.tokenPath, "utf8").trim();
+    if ((0, import_node_fs6.existsSync)(this.tokenPath)) {
+      return (0, import_node_fs6.readFileSync)(this.tokenPath, "utf8").trim();
     }
     const token = createToken();
-    (0, import_node_fs5.writeFileSync)(this.tokenPath, `${token}
+    (0, import_node_fs6.writeFileSync)(this.tokenPath, `${token}
 `);
     return token;
   }
@@ -50323,12 +51281,12 @@ var ServerStore = class extends EventTarget {
     if (!this.screens.has(screen.id)) {
       throw new Error(`Cannot persist screen ${screen.id}: not in live map`);
     }
-    (0, import_node_fs5.writeFileSync)(import_node_path9.default.join(this.screensDir, `${screen.id}.json`), JSON.stringify(screen, null, JSON_INDENT_SPACES));
+    (0, import_node_fs6.writeFileSync)(import_node_path9.default.join(this.screensDir, `${screen.id}.json`), JSON.stringify(screen, null, JSON_INDENT_SPACES));
   }
   readArtifactFile(filePath, expectedID) {
     let raw;
     try {
-      raw = (0, import_node_fs5.readFileSync)(filePath, "utf8");
+      raw = (0, import_node_fs6.readFileSync)(filePath, "utf8");
     } catch (error48) {
       throw this.invalidMetadataFile(filePath, "unreadable", error48);
     }
@@ -50367,16 +51325,16 @@ Review docs/storage.md for the current schema, and either update the file to mat
     return cause !== void 0 ? new Error(message, { cause }) : new Error(message);
   }
   writeArtifact(artifact) {
-    (0, import_node_fs5.writeFileSync)(getArtifactLiveMetadataPath(this.storagePath, artifact.id), JSON.stringify(artifact, null, JSON_INDENT_SPACES));
+    (0, import_node_fs6.writeFileSync)(getArtifactLiveMetadataPath(this.storagePath, artifact.id), JSON.stringify(artifact, null, JSON_INDENT_SPACES));
   }
   scaffoldPendingBundle(artifactID) {
     const publicDir = getArtifactPublicDirPath(this.storagePath, artifactID, "pending");
-    (0, import_node_fs5.mkdirSync)(publicDir, { recursive: true });
+    (0, import_node_fs6.mkdirSync)(publicDir, { recursive: true });
   }
   scaffoldCommittedBundle(artifactID) {
     const publicDir = getArtifactPublicDirPath(this.storagePath, artifactID, "committed");
-    (0, import_node_fs5.mkdirSync)(publicDir, { recursive: true });
-    (0, import_node_fs5.writeFileSync)(getArtifactEntryFilePath(this.storagePath, artifactID, "web-bundle", "committed"), "");
+    (0, import_node_fs6.mkdirSync)(publicDir, { recursive: true });
+    (0, import_node_fs6.writeFileSync)(getArtifactEntryFilePath(this.storagePath, artifactID, "web-bundle", "committed"), "");
   }
   get screensDir() {
     return import_node_path9.default.join(this.storagePath, "screens");
@@ -50397,7 +51355,7 @@ Review docs/storage.md for the current schema, and either update the file to mat
       throw new InvalidRequestError("externalFilePath must be normalized and must not contain traversal segments");
     }
     try {
-      (0, import_node_fs5.accessSync)(sourcePath, import_node_fs5.constants.R_OK);
+      (0, import_node_fs6.accessSync)(sourcePath, import_node_fs6.constants.R_OK);
     } catch {
       throw new InvalidRequestError(`externalFilePath does not exist or is not readable: ${sourcePath}`);
     }
@@ -50476,14 +51434,14 @@ function resolveVercelSkillsInstallerBin() {
   return localRequire.resolve("skills/bin/cli.mjs");
 }
 function readCLIVersion() {
-  if ("0.1.103".length > 0) {
-    return "0.1.103";
+  if ("0.1.105".length > 0) {
+    return "0.1.105";
   }
   const devPackageJsonPath = import_node_path10.default.join(getDevPackageDir(), "package.json");
-  if (!(0, import_node_fs6.existsSync)(devPackageJsonPath)) {
+  if (!(0, import_node_fs7.existsSync)(devPackageJsonPath)) {
     throw new Error("Could not resolve package.json for repo-local CLI version.");
   }
-  return JSON.parse((0, import_node_fs6.readFileSync)(devPackageJsonPath, "utf8")).version;
+  return JSON.parse((0, import_node_fs7.readFileSync)(devPackageJsonPath, "utf8")).version;
 }
 var FRONTMATTER_DELIMITER = "---\n";
 var FRONTMATTER_DELIMITER_LENGTH = FRONTMATTER_DELIMITER.length;
@@ -50540,59 +51498,59 @@ function resolveStaticDir() {
   if (!process.argv[1]) {
     return void 0;
   }
-  const entryDir = import_node_path10.default.dirname((0, import_node_fs6.realpathSync)(process.argv[1]));
+  const entryDir = import_node_path10.default.dirname((0, import_node_fs7.realpathSync)(process.argv[1]));
   const resolved = import_node_path10.default.resolve(entryDir, "./web");
-  return (0, import_node_fs6.existsSync)(import_node_path10.default.join(resolved, "index.html")) ? resolved : void 0;
+  return (0, import_node_fs7.existsSync)(import_node_path10.default.join(resolved, "index.html")) ? resolved : void 0;
 }
 function resolveBundledViewsPath() {
   if (process.argv[1]) {
-    const entryDir = import_node_path10.default.dirname((0, import_node_fs6.realpathSync)(process.argv[1]));
+    const entryDir = import_node_path10.default.dirname((0, import_node_fs7.realpathSync)(process.argv[1]));
     const resolved = import_node_path10.default.resolve(entryDir, "./views");
-    return (0, import_node_fs6.existsSync)(resolved) ? resolved : void 0;
+    return (0, import_node_fs7.existsSync)(resolved) ? resolved : void 0;
   }
   const devViewsPath = import_node_path10.default.join(getDevPackageDir(), "dist/views");
-  return (0, import_node_fs6.existsSync)(devViewsPath) ? devViewsPath : void 0;
+  return (0, import_node_fs7.existsSync)(devViewsPath) ? devViewsPath : void 0;
 }
 function resolveCanonicalDir() {
   if (process.argv[1]) {
-    const entryDir = import_node_path10.default.dirname((0, import_node_fs6.realpathSync)(process.argv[1]));
+    const entryDir = import_node_path10.default.dirname((0, import_node_fs7.realpathSync)(process.argv[1]));
     const resolved = import_node_path10.default.resolve(entryDir, "./canonical/v1");
-    return (0, import_node_fs6.existsSync)(resolved) ? resolved : void 0;
+    return (0, import_node_fs7.existsSync)(resolved) ? resolved : void 0;
   }
   const devCanonicalPath = import_node_path10.default.resolve(
     getDevPackageDir(),
     "../server/dist/canonical/v1"
   );
-  return (0, import_node_fs6.existsSync)(devCanonicalPath) ? devCanonicalPath : void 0;
+  return (0, import_node_fs7.existsSync)(devCanonicalPath) ? devCanonicalPath : void 0;
 }
 function resolveBundledSkillsRoot() {
-  const builtPath = typeof process.argv[1] === "string" ? import_node_path10.default.resolve(import_node_path10.default.dirname((0, import_node_fs6.realpathSync)(process.argv[1])), "./skills") : void 0;
-  if (builtPath && (0, import_node_fs6.existsSync)(builtPath)) {
+  const builtPath = typeof process.argv[1] === "string" ? import_node_path10.default.resolve(import_node_path10.default.dirname((0, import_node_fs7.realpathSync)(process.argv[1])), "./skills") : void 0;
+  if (builtPath && (0, import_node_fs7.existsSync)(builtPath)) {
     return builtPath;
   }
   const devPath = import_node_path10.default.resolve(getDevPackageDir(), "../skills/dist");
-  return (0, import_node_fs6.existsSync)(devPath) ? devPath : void 0;
+  return (0, import_node_fs7.existsSync)(devPath) ? devPath : void 0;
 }
 function copyBundledSkillsToDestination(bundledSkillsRoot, destinationRoot) {
-  if ((0, import_node_fs6.existsSync)(destinationRoot) && !(0, import_node_fs6.statSync)(destinationRoot).isDirectory()) {
+  if ((0, import_node_fs7.existsSync)(destinationRoot) && !(0, import_node_fs7.statSync)(destinationRoot).isDirectory()) {
     throw new Error(`Skills destination is not a directory: ${destinationRoot}`);
   }
-  (0, import_node_fs6.mkdirSync)(destinationRoot, { recursive: true });
+  (0, import_node_fs7.mkdirSync)(destinationRoot, { recursive: true });
   const copied = [];
-  const entries = (0, import_node_fs6.readdirSync)(bundledSkillsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+  const entries = (0, import_node_fs7.readdirSync)(bundledSkillsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
     const sourcePath = import_node_path10.default.join(bundledSkillsRoot, entry.name);
     const destinationPath = import_node_path10.default.join(destinationRoot, entry.name);
-    (0, import_node_fs6.rmSync)(destinationPath, { recursive: true, force: true });
-    (0, import_node_fs6.cpSync)(sourcePath, destinationPath, { recursive: true });
+    (0, import_node_fs7.rmSync)(destinationPath, { recursive: true, force: true });
+    (0, import_node_fs7.cpSync)(sourcePath, destinationPath, { recursive: true });
     copied.push({ name: entry.name, sourcePath, destinationPath });
   }
   return copied;
 }
 function isInTempDirectory(inputPath) {
   try {
-    const realTmp = (0, import_node_fs6.realpathSync)(import_node_os4.default.tmpdir());
-    const realInput = (0, import_node_fs6.existsSync)(inputPath) ? (0, import_node_fs6.realpathSync)(inputPath) : import_node_path10.default.resolve(inputPath);
+    const realTmp = (0, import_node_fs7.realpathSync)(import_node_os4.default.tmpdir());
+    const realInput = (0, import_node_fs7.existsSync)(inputPath) ? (0, import_node_fs7.realpathSync)(inputPath) : import_node_path10.default.resolve(inputPath);
     const relative = import_node_path10.default.relative(realTmp, realInput);
     return relative !== "" && !relative.startsWith("..") && !import_node_path10.default.isAbsolute(relative);
   } catch {
@@ -50604,7 +51562,7 @@ function validateExternalArtifactPath(commandName, inputPath) {
     throw createDirectiveError(`tv ${commandName} requires --path to be an absolute path.`);
   }
   try {
-    (0, import_node_fs6.accessSync)(inputPath, import_node_fs6.constants.R_OK);
+    (0, import_node_fs7.accessSync)(inputPath, import_node_fs7.constants.R_OK);
   } catch {
     throw createDirectiveError(`tv ${commandName} could not read --path ${inputPath}.`);
   }
@@ -50736,10 +51694,10 @@ function formatCommanderError(argv, error48) {
 }
 function readAuthToken(storagePath) {
   const tokenPath = import_node_path10.default.join(storagePath, "token");
-  if (!(0, import_node_fs6.existsSync)(tokenPath)) {
+  if (!(0, import_node_fs7.existsSync)(tokenPath)) {
     return void 0;
   }
-  const token = (0, import_node_fs6.readFileSync)(tokenPath, "utf8").trim();
+  const token = (0, import_node_fs7.readFileSync)(tokenPath, "utf8").trim();
   return token.length > 0 ? token : void 0;
 }
 function readOrCreateAuthToken(storagePath) {
@@ -50750,7 +51708,7 @@ function createEnvironment(environment) {
     stdout: environment.stdout ?? process.stdout,
     stderr: environment.stderr ?? process.stderr,
     createClient: environment.createClient ?? ((serverURL, token) => new TelevisionClient(serverURL, { token })),
-    createServer: environment.createServer ?? ((options = {}) => new Server({
+    createServer: environment.createServer ?? ((options) => new Server({
       store: new ServerStore({
         storagePath: options.storagePath ?? getTelevisionStoragePath(),
         ...options.bundledViewsPath ? { bundledViewsPath: options.bundledViewsPath } : {}
@@ -50760,7 +51718,7 @@ function createEnvironment(environment) {
       staticDir: options.staticDir,
       canonicalDir: options.canonicalDir,
       public: options.public,
-      acpProfile: resolveACPAgentProfile(process.env)
+      acpProfile: options.acpProfile
     })),
     createDaemon: environment.createDaemon ?? ((options = {}) => {
       const args = [process.argv[1], "serve"];
@@ -50772,7 +51730,8 @@ function createEnvironment(environment) {
         name: DAEMON_NAME,
         description: "Television server \u2014 virtual display for agents",
         command: process.execPath,
-        args
+        args,
+        env: options.env
       });
     }),
     resolveStaticDir: environment.resolveStaticDir ?? (() => resolveStaticDir()),
@@ -50794,21 +51753,45 @@ function createProgram(env, argv = []) {
   const createAuthenticatedClient = (serverURL) => {
     return env.createClient(serverURL, readAuthToken(getTelevisionStoragePath()));
   };
+  const uninstallPersistedService = async () => {
+    const daemon = env.createDaemon();
+    await daemon.uninstall();
+    writeJSON(env.stdout, { status: "stopped" });
+  };
   program2.name("tv").description("Television \u2014 virtual display for agents").version(readCLIVersion()).showSuggestionAfterError(false).addHelpText("after", buildAgentHelpNote()).configureOutput({
     writeOut: (str) => env.stdout.write(str),
     writeErr: (str) => env.stderr.write(str),
     outputError: () => {
     }
   }).exitOverride();
-  program2.command("serve").description("Start the Television server").option("--host <address>", "Address to bind to").option("--port <number>", "Port to listen on", parsePortOption).option("--storage-path <path>", "Directory for persisted screen data").option("--public", "Serve without auth").option("--persist", "Install as a persistent system service").action(async (opts) => {
+  program2.command("serve").description("Start the Television server").option("--host <address>", "Address to bind to").option("--port <number>", "Port to listen on", parsePortOption).option("--storage-path <path>", "Directory for persisted screen data").option("--public", "Serve without auth").option("--persist", "Install as a persistent system service").option("--persist-uninstall", "Uninstall the persistent system service").action(async (opts) => {
+    if (opts.persist && opts.persistUninstall) {
+      throw createDirectiveError("Use either `--persist` or `--persist-uninstall`, not both.");
+    }
+    if (opts.persistUninstall) {
+      await uninstallPersistedService();
+      return;
+    }
     if (opts.persist) {
       const storagePath = opts.storagePath ?? getTelevisionStoragePath();
+      const profile2 = resolveACPAgentProfile(process.env);
+      const daemonEnv = buildPersistedACPEnvironment(process.env);
+      if (!isACPCommandResolvable(profile2.command, daemonEnv)) {
+        throw createDirectiveError(
+          `Could not find ACP agent command \`${profile2.command}\` for \`TELEVISION_ACP_AGENT=${profile2.agent}\` on the persisted PATH. Set TELEVISION_ACP_AGENT to \`openclaw\` or \`hermes\`, and ensure the selected agent binary is available on PATH before running \`tv serve --persist\`.`
+        );
+      }
       const daemon = env.createDaemon({
         host: opts.host,
         port: opts.port,
         storagePath,
-        public: opts.public
+        public: opts.public,
+        env: daemonEnv
       });
+      const daemonStatus = await daemon.status();
+      if (daemonStatus.installed || daemonStatus.running) {
+        await daemon.uninstall();
+      }
       await daemon.install();
       writeJSON(
         env.stdout,
@@ -50820,6 +51803,12 @@ function createProgram(env, argv = []) {
       );
       return;
     }
+    const profile = resolveACPAgentProfile(process.env);
+    if (!isACPCommandResolvable(profile.command, process.env)) {
+      throw createDirectiveError(
+        `Could not find ACP agent command \`${profile.command}\` for \`TELEVISION_ACP_AGENT=${profile.agent}\` on PATH. Set TELEVISION_ACP_AGENT to \`openclaw\` or \`hermes\`, and ensure the selected agent binary is available on PATH before running \`tv serve\`.`
+      );
+    }
     const server = env.createServer({
       host: opts.host,
       port: opts.port,
@@ -50827,7 +51816,8 @@ function createProgram(env, argv = []) {
       staticDir: env.resolveStaticDir(),
       canonicalDir: env.resolveCanonicalDir(),
       bundledViewsPath: env.resolveBundledViewsPath(),
-      public: opts.public
+      public: opts.public,
+      acpProfile: profile
     });
     await server.start();
     writeJSON(env.stdout, opts.public ? { serverURL: server.getBaseURL() } : { serverURL: server.getBaseURL(), token: server.getAuthToken() });
@@ -51104,9 +52094,7 @@ If you wish to display temporary content to the user, use a web bundle artifact
     }
   });
   program2.command("stop").description("Stop the Television system service").action(async () => {
-    const daemon = env.createDaemon();
-    await daemon.uninstall();
-    writeJSON(env.stdout, { status: "stopped" });
+    await uninstallPersistedService();
   });
   program2.command("status").description("Check Television server and service status").option("--server <url>", "Server URL", DEFAULT_SERVER_URL).action(async (opts) => {
     const result = {