terminal-commands 0.1.2 → 0.2.0

package/dist/index.js

@@ -15237,11 +15237,11 @@ var require_mime_types = __commonJS({
       }
       return exts[0];
     }
-    function lookup(path2) {
-      if (!path2 || typeof path2 !== "string") {
+    function lookup(path4) {
+      if (!path4 || typeof path4 !== "string") {
         return false;
       }
-      var extension2 = extname("x." + path2).toLowerCase().slice(1);
+      var extension2 = extname("x." + path4).toLowerCase().slice(1);
       if (!extension2) {
         return false;
       }
@@ -18390,11 +18390,11 @@ var require_parse = __commonJS({
         segments[segments.length] = parent;
       }
       var n = key.length;
-      var open3 = first;
+      var open2 = first;
       var collected = 0;
-      while (open3 >= 0 && collected < options.depth) {
+      while (open2 >= 0 && collected < options.depth) {
         var level = 1;
-        var i = open3 + 1;
+        var i = open2 + 1;
         var close = -1;
         while (i < n && close < 0) {
           var cu = key.charCodeAt(i);
@@ -18409,23 +18409,23 @@ var require_parse = __commonJS({
           i += 1;
         }
         if (close < 0) {
-          segments[segments.length] = "[" + key.slice(open3) + "]";
+          segments[segments.length] = "[" + key.slice(open2) + "]";
           return segments;
         }
-        var seg = key.slice(open3, close + 1);
+        var seg = key.slice(open2, close + 1);
         var content = seg.slice(1, -1);
         if (!options.plainObjects && has.call(Object.prototype, content) && !options.allowPrototypes) {
           return;
         }
         segments[segments.length] = seg;
         collected += 1;
-        open3 = key.indexOf("[", close + 1);
+        open2 = key.indexOf("[", close + 1);
       }
-      if (open3 >= 0) {
+      if (open2 >= 0) {
         if (options.strictDepth === true) {
           throw new RangeError("Input depth exceeded depth option of " + options.depth + " and strictDepth is true");
         }
-        segments[segments.length] = "[" + key.slice(open3) + "]";
+        segments[segments.length] = "[" + key.slice(open2) + "]";
       }
       return segments;
     };
@@ -18928,13 +18928,13 @@ var require_view = __commonJS({
   "node_modules/express/lib/view.js"(exports, module) {
     "use strict";
     var debug = require_src()("express:view");
-    var path2 = __require("node:path");
+    var path4 = __require("node:path");
     var fs = __require("node:fs");
-    var dirname = path2.dirname;
-    var basename = path2.basename;
-    var extname = path2.extname;
-    var join = path2.join;
-    var resolve = path2.resolve;
+    var dirname = path4.dirname;
+    var basename = path4.basename;
+    var extname = path4.extname;
+    var join = path4.join;
+    var resolve = path4.resolve;
     module.exports = View;
     function View(name, options) {
       var opts = options || {};
@@ -18963,17 +18963,17 @@ var require_view = __commonJS({
       this.path = this.lookup(fileName);
     }
     View.prototype.lookup = function lookup(name) {
-      var path3;
+      var path5;
       var roots2 = [].concat(this.root);
       debug('lookup "%s"', name);
-      for (var i = 0; i < roots2.length && !path3; i++) {
+      for (var i = 0; i < roots2.length && !path5; i++) {
         var root = roots2[i];
         var loc = resolve(root, name);
         var dir = dirname(loc);
         var file2 = basename(loc);
-        path3 = this.resolve(dir, file2);
+        path5 = this.resolve(dir, file2);
       }
-      return path3;
+      return path5;
     };
     View.prototype.render = function render(options, callback) {
       var sync = true;
@@ -18995,21 +18995,21 @@ var require_view = __commonJS({
     };
     View.prototype.resolve = function resolve2(dir, file2) {
       var ext = this.ext;
-      var path3 = join(dir, file2);
-      var stat = tryStat(path3);
+      var path5 = join(dir, file2);
+      var stat = tryStat(path5);
       if (stat && stat.isFile()) {
-        return path3;
+        return path5;
       }
-      path3 = join(dir, basename(file2, ext), "index" + ext);
-      stat = tryStat(path3);
+      path5 = join(dir, basename(file2, ext), "index" + ext);
+      stat = tryStat(path5);
       if (stat && stat.isFile()) {
-        return path3;
+        return path5;
       }
     };
-    function tryStat(path3) {
-      debug('stat "%s"', path3);
+    function tryStat(path5) {
+      debug('stat "%s"', path5);
       try {
-        return fs.statSync(path3);
+        return fs.statSync(path5);
       } catch (e) {
         return void 0;
       }
@@ -19946,6 +19946,9 @@ var require_proxy_addr = __commonJS({
       return function trust(addr) {
         if (!isip(addr)) return false;
         var ip = parseip(addr);
+        if (ip.kind() === "ipv6" && ip.isIPv4MappedAddress()) {
+          ip = ip.toIPv4Address();
+        }
         var ipconv;
         var kind = ip.kind();
         for (var i = 0; i < subnets.length; i++) {
@@ -19958,10 +19961,15 @@ var require_proxy_addr = __commonJS({
             if (subnetkind === "ipv4" && !ip.isIPv4MappedAddress()) {
               continue;
             }
+            if (subnetkind !== "ipv4" && !(subnetrange >= 96 && subnetip.isIPv4MappedAddress())) {
+              continue;
+            }
             if (!ipconv) {
               ipconv = subnetkind === "ipv4" ? ip.toIPv4Address() : ip.toIPv4MappedAddress();
             }
             trusted = ipconv;
+          } else if (kind === "ipv6" && subnetip.isIPv4MappedAddress()) {
+            continue;
           }
           if (trusted.match(subnetip, subnetrange)) {
             return true;
@@ -19978,12 +19986,20 @@ var require_proxy_addr = __commonJS({
       return function trust(addr) {
         if (!isip(addr)) return false;
         var ip = parseip(addr);
+        if (ip.kind() === "ipv6" && ip.isIPv4MappedAddress()) {
+          ip = ip.toIPv4Address();
+        }
         var kind = ip.kind();
         if (kind !== subnetkind) {
           if (subnetisipv4 && !ip.isIPv4MappedAddress()) {
             return false;
           }
+          if (!subnetisipv4 && !(subnetrange >= 96 && subnetip.isIPv4MappedAddress())) {
+            return false;
+          }
           ip = subnetisipv4 ? ip.toIPv4Address() : ip.toIPv4MappedAddress();
+        } else if (kind === "ipv6" && subnetip.isIPv4MappedAddress()) {
+          return false;
         }
         return ip.match(subnetip, subnetrange);
       };
@@ -20249,15 +20265,15 @@ var require_dist3 = __commonJS({
       let index = 0;
       function consumeUntil(end) {
         const output2 = [];
-        let path2 = "";
+        let path4 = "";
         function writePath() {
-          if (!path2)
+          if (!path4)
             return;
           output2.push({
             type: "text",
-            value: encodePath(path2)
+            value: encodePath(path4)
           });
-          path2 = "";
+          path4 = "";
         }
         while (index < chars.length) {
           const value = chars[index++];
@@ -20269,7 +20285,7 @@ var require_dist3 = __commonJS({
             if (index === chars.length) {
               throw new PathError(`Unexpected end after \\ at index ${index}`, str);
             }
-            path2 += chars[index++];
+            path4 += chars[index++];
             continue;
           }
           if (value === ":" || value === "*") {
@@ -20313,7 +20329,7 @@ var require_dist3 = __commonJS({
           if (value === "}" || value === "(" || value === ")" || value === "[" || value === "]" || value === "+" || value === "?" || value === "!") {
             throw new PathError(`Unexpected ${value} at index ${index - 1}`, str);
           }
-          path2 += value;
+          path4 += value;
         }
         if (end) {
           throw new PathError(`Unexpected end at index ${index}, expected ${end}`, str);
@@ -20323,17 +20339,17 @@ var require_dist3 = __commonJS({
       }
       return new TokenData(consumeUntil(""), str);
     }
-    function compile2(path2, options = {}) {
+    function compile2(path4, options = {}) {
       const { encode: encode3 = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
-      const data = typeof path2 === "object" ? path2 : parse3(path2, options);
+      const data = typeof path4 === "object" ? path4 : parse3(path4, options);
       const fn = tokensToFunction(data.tokens, delimiter, encode3);
-      return function path3(params = {}) {
+      return function path5(params = {}) {
         const missing = [];
-        const path4 = fn(params, missing);
+        const path6 = fn(params, missing);
         if (missing.length) {
           throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
         }
-        return path4;
+        return path6;
       };
     }
     function tokensToFunction(tokens, delimiter, encode3) {
@@ -20395,9 +20411,9 @@ var require_dist3 = __commonJS({
         return encodeValue(value);
       };
     }
-    function match(path2, options = {}) {
+    function match(path4, options = {}) {
       const { decode: decode3 = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
-      const { regexp, keys } = pathToRegexp(path2, options);
+      const { regexp, keys } = pathToRegexp(path4, options);
       const decoders = keys.map((key) => {
         if (decode3 === false)
           return NOOP_VALUE;
@@ -20409,7 +20425,7 @@ var require_dist3 = __commonJS({
         const m = regexp.exec(input2);
         if (!m)
           return false;
-        const path3 = m[0];
+        const path5 = m[0];
         const params = /* @__PURE__ */ Object.create(null);
         for (let i = 1; i < m.length; i++) {
           if (m[i] === void 0)
@@ -20418,21 +20434,21 @@ var require_dist3 = __commonJS({
           const decoder = decoders[i - 1];
           params[key.name] = decoder(m[i]);
         }
-        return { path: path3, params };
+        return { path: path5, params };
       };
     }
-    function pathToRegexp(path2, options = {}) {
+    function pathToRegexp(path4, options = {}) {
       const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
       const keys = [];
       let source = "";
       let combinations = 0;
-      function process2(path3) {
-        if (Array.isArray(path3)) {
-          for (const p of path3)
+      function process2(path5) {
+        if (Array.isArray(path5)) {
+          for (const p of path5)
             process2(p);
           return;
         }
-        const data = typeof path3 === "object" ? path3 : parse3(path3, options);
+        const data = typeof path5 === "object" ? path5 : parse3(path5, options);
         flatten(data.tokens, 0, [], (tokens) => {
           if (combinations >= 256) {
             throw new PathError("Too many path combinations", data.originalPath);
@@ -20443,7 +20459,7 @@ var require_dist3 = __commonJS({
           combinations++;
         });
       }
-      process2(path2);
+      process2(path4);
       let pattern = `^(?:${source})`;
       if (trailing)
         pattern += "(?:" + escape2(delimiter) + "$)?";
@@ -20583,18 +20599,18 @@ var require_layer = __commonJS({
     var TRAILING_SLASH_REGEXP = /\/+$/;
     var MATCHING_GROUP_REGEXP = /\((?:\?<(.*?)>)?(?!\?)/g;
     module.exports = Layer;
-    function Layer(path2, options, fn) {
+    function Layer(path4, options, fn) {
       if (!(this instanceof Layer)) {
-        return new Layer(path2, options, fn);
+        return new Layer(path4, options, fn);
       }
-      debug("new %o", path2);
+      debug("new %o", path4);
       const opts = options || {};
       this.handle = fn;
       this.keys = [];
       this.name = fn.name || "<anonymous>";
       this.params = void 0;
       this.path = void 0;
-      this.slash = path2 === "/" && opts.end === false;
+      this.slash = path4 === "/" && opts.end === false;
       function matcher(_path) {
         if (_path instanceof RegExp) {
           const keys = [];
@@ -20633,7 +20649,7 @@ var require_layer = __commonJS({
           decode: decodeParam
         });
       }
-      this.matchers = Array.isArray(path2) ? path2.map(matcher) : [matcher(path2)];
+      this.matchers = Array.isArray(path4) ? path4.map(matcher) : [matcher(path4)];
     }
     Layer.prototype.handleError = function handleError(error62, req, res, next) {
       const fn = this.handle;
@@ -20673,9 +20689,9 @@ var require_layer = __commonJS({
         next(err);
       }
     };
-    Layer.prototype.match = function match(path2) {
+    Layer.prototype.match = function match(path4) {
       let match2;
-      if (path2 != null) {
+      if (path4 != null) {
         if (this.slash) {
           this.params = {};
           this.path = "";
@@ -20683,7 +20699,7 @@ var require_layer = __commonJS({
         }
         let i = 0;
         while (!match2 && i < this.matchers.length) {
-          match2 = this.matchers[i](path2);
+          match2 = this.matchers[i](path4);
           i++;
         }
       }
@@ -20711,13 +20727,13 @@ var require_layer = __commonJS({
         throw err;
       }
     }
-    function loosen(path2) {
-      if (path2 instanceof RegExp || path2 === "/") {
-        return path2;
+    function loosen(path4) {
+      if (path4 instanceof RegExp || path4 === "/") {
+        return path4;
       }
-      return Array.isArray(path2) ? path2.map(function(p) {
+      return Array.isArray(path4) ? path4.map(function(p) {
         return loosen(p);
-      }) : String(path2).replace(TRAILING_SLASH_REGEXP, "");
+      }) : String(path4).replace(TRAILING_SLASH_REGEXP, "");
     }
   }
 });
@@ -20733,9 +20749,9 @@ var require_route = __commonJS({
     var flatten = Array.prototype.flat;
     var methods = METHODS.map((method) => method.toLowerCase());
     module.exports = Route;
-    function Route(path2) {
-      debug("new %o", path2);
-      this.path = path2;
+    function Route(path4) {
+      debug("new %o", path4);
+      this.path = path4;
       this.stack = [];
       this.methods = /* @__PURE__ */ Object.create(null);
     }
@@ -20943,8 +20959,8 @@ var require_router = __commonJS({
         if (++sync > 100) {
           return setImmediate(next, err);
         }
-        const path2 = getPathname(req);
-        if (path2 == null) {
+        const path4 = getPathname(req);
+        if (path4 == null) {
           return done(layerError);
         }
         let layer;
@@ -20952,7 +20968,7 @@ var require_router = __commonJS({
         let route;
         while (match !== true && idx < stack.length) {
           layer = stack[idx++];
-          match = matchLayer(layer, path2);
+          match = matchLayer(layer, path4);
           route = layer.route;
           if (typeof match !== "boolean") {
             layerError = layerError || match;
@@ -20990,18 +21006,18 @@ var require_router = __commonJS({
           } else if (route) {
             layer.handleRequest(req, res, next);
           } else {
-            trimPrefix(layer, layerError, layerPath, path2);
+            trimPrefix(layer, layerError, layerPath, path4);
           }
           sync = 0;
         });
       }
-      function trimPrefix(layer, layerError, layerPath, path2) {
+      function trimPrefix(layer, layerError, layerPath, path4) {
         if (layerPath.length !== 0) {
-          if (layerPath !== path2.substring(0, layerPath.length)) {
+          if (layerPath !== path4.substring(0, layerPath.length)) {
             next(layerError);
             return;
           }
-          const c = path2[layerPath.length];
+          const c = path4[layerPath.length];
           if (c && c !== "/") {
             next(layerError);
             return;
@@ -21025,7 +21041,7 @@ var require_router = __commonJS({
     };
     Router.prototype.use = function use(handler) {
       let offset = 0;
-      let path2 = "/";
+      let path4 = "/";
       if (typeof handler !== "function") {
         let arg = handler;
         while (Array.isArray(arg) && arg.length !== 0) {
@@ -21033,7 +21049,7 @@ var require_router = __commonJS({
         }
         if (typeof arg !== "function") {
           offset = 1;
-          path2 = handler;
+          path4 = handler;
         }
       }
       const callbacks = flatten.call(slice.call(arguments, offset), Infinity);
@@ -21045,8 +21061,8 @@ var require_router = __commonJS({
         if (typeof fn !== "function") {
           throw new TypeError("argument handler must be a function");
         }
-        debug("use %o %s", path2, fn.name || "<anonymous>");
-        const layer = new Layer(path2, {
+        debug("use %o %s", path4, fn.name || "<anonymous>");
+        const layer = new Layer(path4, {
           sensitive: this.caseSensitive,
           strict: false,
           end: false
@@ -21056,9 +21072,9 @@ var require_router = __commonJS({
       }
       return this;
     };
-    Router.prototype.route = function route(path2) {
-      const route2 = new Route(path2);
-      const layer = new Layer(path2, {
+    Router.prototype.route = function route(path4) {
+      const route2 = new Route(path4);
+      const layer = new Layer(path4, {
         sensitive: this.caseSensitive,
         strict: this.strict,
         end: true
@@ -21071,8 +21087,8 @@ var require_router = __commonJS({
       return route2;
     };
     methods.concat("all").forEach(function(method) {
-      Router.prototype[method] = function(path2) {
-        const route = this.route(path2);
+      Router.prototype[method] = function(path4) {
+        const route = this.route(path4);
         route[method].apply(route, slice.call(arguments, 1));
         return this;
       };
@@ -21101,9 +21117,9 @@ var require_router = __commonJS({
       const fqdnIndex = url2.substring(0, pathLength).indexOf("://");
       return fqdnIndex !== -1 ? url2.substring(0, url2.indexOf("/", 3 + fqdnIndex)) : void 0;
     }
-    function matchLayer(layer, path2) {
+    function matchLayer(layer, path4) {
       try {
-        return layer.match(path2);
+        return layer.match(path4);
       } catch (err) {
         return err;
       }
@@ -21331,7 +21347,7 @@ var require_application = __commonJS({
     };
     app2.use = function use(fn) {
       var offset = 0;
-      var path2 = "/";
+      var path4 = "/";
       if (typeof fn !== "function") {
         var arg = fn;
         while (Array.isArray(arg) && arg.length !== 0) {
@@ -21339,7 +21355,7 @@ var require_application = __commonJS({
         }
         if (typeof arg !== "function") {
           offset = 1;
-          path2 = fn;
+          path4 = fn;
         }
       }
       var fns = flatten.call(slice.call(arguments, offset), Infinity);
@@ -21349,12 +21365,12 @@ var require_application = __commonJS({
       var router = this.router;
       fns.forEach(function(fn2) {
         if (!fn2 || !fn2.handle || !fn2.set) {
-          return router.use(path2, fn2);
+          return router.use(path4, fn2);
         }
-        debug(".use app under %s", path2);
-        fn2.mountpath = path2;
+        debug(".use app under %s", path4);
+        fn2.mountpath = path4;
         fn2.parent = this;
-        router.use(path2, function mounted_app(req, res, next) {
+        router.use(path4, function mounted_app(req, res, next) {
           var orig = req.app;
           fn2.handle(req, res, function(err) {
             Object.setPrototypeOf(req, orig.request);
@@ -21366,8 +21382,8 @@ var require_application = __commonJS({
       }, this);
       return this;
     };
-    app2.route = function route(path2) {
-      return this.router.route(path2);
+    app2.route = function route(path4) {
+      return this.router.route(path4);
     };
     app2.engine = function engine(ext, fn) {
       if (typeof fn !== "function") {
@@ -21410,7 +21426,7 @@ var require_application = __commonJS({
       }
       return this;
     };
-    app2.path = function path2() {
+    app2.path = function path4() {
       return this.parent ? this.parent.path() + this.mountpath : "";
     };
     app2.enabled = function enabled(setting) {
@@ -21426,17 +21442,17 @@ var require_application = __commonJS({
       return this.set(setting, false);
     };
     methods.forEach(function(method) {
-      app2[method] = function(path2) {
+      app2[method] = function(path4) {
         if (method === "get" && arguments.length === 1) {
-          return this.set(path2);
+          return this.set(path4);
         }
-        var route = this.route(path2);
+        var route = this.route(path4);
         route[method].apply(route, slice.call(arguments, 1));
         return this;
       };
     });
-    app2.all = function all(path2) {
-      var route = this.route(path2);
+    app2.all = function all(path4) {
+      var route = this.route(path4);
       var args = slice.call(arguments, 1);
       for (var i = 0; i < methods.length; i++) {
         route[methods[i]].apply(route, args);
@@ -22421,7 +22437,7 @@ var require_request = __commonJS({
       var subdomains2 = !isIP(hostname3) ? hostname3.split(".").reverse() : [hostname3];
       return subdomains2.slice(offset);
     });
-    defineGetter(req, "path", function path2() {
+    defineGetter(req, "path", function path4() {
       return parse3(this).pathname;
     });
     defineGetter(req, "host", function host2() {
@@ -22632,8 +22648,8 @@ var require_content_disposition = __commonJS({
       this.type = type;
       this.parameters = parameters;
     }
-    function basename(path2) {
-      const normalized = path2.replaceAll("\\", "/");
+    function basename(path4) {
+      const normalized = path4.replaceAll("\\", "/");
       let end = normalized.length;
       while (end > 0 && normalized[end - 1] === "/") {
         end--;
@@ -22879,27 +22895,27 @@ var require_send = __commonJS({
     var ms = require_ms();
     var onFinished = require_on_finished();
     var parseRange = require_range_parser();
-    var path2 = __require("path");
+    var path4 = __require("path");
     var statuses = require_statuses();
     var Stream = __require("stream");
     var util2 = __require("util");
-    var extname = path2.extname;
-    var join = path2.join;
-    var normalize = path2.normalize;
-    var resolve = path2.resolve;
-    var sep = path2.sep;
+    var extname = path4.extname;
+    var join = path4.join;
+    var normalize = path4.normalize;
+    var resolve = path4.resolve;
+    var sep = path4.sep;
     var BYTES_RANGE_REGEXP = /^ *bytes=/;
     var MAX_MAXAGE = 60 * 60 * 24 * 365 * 1e3;
     var UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
     module.exports = send;
-    function send(req, path3, options) {
-      return new SendStream(req, path3, options);
+    function send(req, path5, options) {
+      return new SendStream(req, path5, options);
     }
-    function SendStream(req, path3, options) {
+    function SendStream(req, path5, options) {
       Stream.call(this);
       var opts = options || {};
       this.options = opts;
-      this.path = path3;
+      this.path = path5;
       this.req = req;
       this._acceptRanges = opts.acceptRanges !== void 0 ? Boolean(opts.acceptRanges) : true;
       this._cacheControl = opts.cacheControl !== void 0 ? Boolean(opts.cacheControl) : true;
@@ -23013,10 +23029,10 @@ var require_send = __commonJS({
       var lastModified = this.res.getHeader("Last-Modified");
       return parseHttpDate(lastModified) <= parseHttpDate(ifRange);
     };
-    SendStream.prototype.redirect = function redirect2(path3) {
+    SendStream.prototype.redirect = function redirect2(path5) {
       var res = this.res;
       if (hasListeners(this, "directory")) {
-        this.emit("directory", res, path3);
+        this.emit("directory", res, path5);
         return;
       }
       if (this.hasTrailingSlash()) {
@@ -23036,38 +23052,38 @@ var require_send = __commonJS({
     SendStream.prototype.pipe = function pipe2(res) {
       var root = this._root;
       this.res = res;
-      var path3 = decode3(this.path);
-      if (path3 === -1) {
+      var path5 = decode3(this.path);
+      if (path5 === -1) {
         this.error(400);
         return res;
       }
-      if (~path3.indexOf("\0")) {
+      if (~path5.indexOf("\0")) {
         this.error(400);
         return res;
       }
       var parts;
       if (root !== null) {
-        if (path3) {
-          path3 = normalize("." + sep + path3);
+        if (path5) {
+          path5 = normalize("." + sep + path5);
         }
-        if (UP_PATH_REGEXP.test(path3)) {
-          debug('malicious path "%s"', path3);
+        if (UP_PATH_REGEXP.test(path5)) {
+          debug('malicious path "%s"', path5);
           this.error(403);
           return res;
         }
-        parts = path3.split(sep);
-        path3 = normalize(join(root, path3));
+        parts = path5.split(sep);
+        path5 = normalize(join(root, path5));
       } else {
-        if (UP_PATH_REGEXP.test(path3)) {
-          debug('malicious path "%s"', path3);
+        if (UP_PATH_REGEXP.test(path5)) {
+          debug('malicious path "%s"', path5);
           this.error(403);
           return res;
         }
-        parts = normalize(path3).split(sep);
-        path3 = resolve(path3);
+        parts = normalize(path5).split(sep);
+        path5 = resolve(path5);
       }
       if (containsDotFile(parts)) {
-        debug('%s dotfile "%s"', this._dotfiles, path3);
+        debug('%s dotfile "%s"', this._dotfiles, path5);
         switch (this._dotfiles) {
           case "allow":
             break;
@@ -23081,13 +23097,13 @@ var require_send = __commonJS({
         }
       }
       if (this._index.length && this.hasTrailingSlash()) {
-        this.sendIndex(path3);
+        this.sendIndex(path5);
         return res;
       }
-      this.sendFile(path3);
+      this.sendFile(path5);
       return res;
     };
-    SendStream.prototype.send = function send2(path3, stat) {
+    SendStream.prototype.send = function send2(path5, stat) {
       var len = stat.size;
       var options = this.options;
       var opts = {};
@@ -23099,9 +23115,9 @@ var require_send = __commonJS({
         this.headersAlreadySent();
         return;
       }
-      debug('pipe "%s"', path3);
-      this.setHeader(path3, stat);
-      this.type(path3);
+      debug('pipe "%s"', path5);
+      this.setHeader(path5, stat);
+      this.type(path5);
       if (this.isConditionalGET()) {
         if (this.isPreconditionFailure()) {
           this.error(412);
@@ -23150,28 +23166,28 @@ var require_send = __commonJS({
         res.end();
         return;
       }
-      this.stream(path3, opts);
+      this.stream(path5, opts);
     };
-    SendStream.prototype.sendFile = function sendFile(path3) {
+    SendStream.prototype.sendFile = function sendFile(path5) {
       var i = 0;
       var self = this;
-      debug('stat "%s"', path3);
-      fs.stat(path3, function onstat(err, stat) {
-        var pathEndsWithSep = path3[path3.length - 1] === sep;
-        if (err && err.code === "ENOENT" && !extname(path3) && !pathEndsWithSep) {
+      debug('stat "%s"', path5);
+      fs.stat(path5, function onstat(err, stat) {
+        var pathEndsWithSep = path5[path5.length - 1] === sep;
+        if (err && err.code === "ENOENT" && !extname(path5) && !pathEndsWithSep) {
           return next(err);
         }
         if (err) return self.onStatError(err);
-        if (stat.isDirectory()) return self.redirect(path3);
+        if (stat.isDirectory()) return self.redirect(path5);
         if (pathEndsWithSep) return self.error(404);
-        self.emit("file", path3, stat);
-        self.send(path3, stat);
+        self.emit("file", path5, stat);
+        self.send(path5, stat);
       });
       function next(err) {
         if (self._extensions.length <= i) {
           return err ? self.onStatError(err) : self.error(404);
         }
-        var p = path3 + "." + self._extensions[i++];
+        var p = path5 + "." + self._extensions[i++];
         debug('stat "%s"', p);
         fs.stat(p, function(err2, stat) {
           if (err2) return next(err2);
@@ -23181,7 +23197,7 @@ var require_send = __commonJS({
         });
       }
     };
-    SendStream.prototype.sendIndex = function sendIndex(path3) {
+    SendStream.prototype.sendIndex = function sendIndex(path5) {
       var i = -1;
       var self = this;
       function next(err) {
@@ -23189,7 +23205,7 @@ var require_send = __commonJS({
           if (err) return self.onStatError(err);
           return self.error(404);
         }
-        var p = join(path3, self._index[i]);
+        var p = join(path5, self._index[i]);
         debug('stat "%s"', p);
         fs.stat(p, function(err2, stat) {
           if (err2) return next(err2);
@@ -23200,10 +23216,10 @@ var require_send = __commonJS({
       }
       next();
     };
-    SendStream.prototype.stream = function stream(path3, options) {
+    SendStream.prototype.stream = function stream(path5, options) {
       var self = this;
       var res = this.res;
-      var stream2 = fs.createReadStream(path3, options);
+      var stream2 = fs.createReadStream(path5, options);
       this.emit("stream", stream2);
       stream2.pipe(res);
       function cleanup() {
@@ -23218,17 +23234,17 @@ var require_send = __commonJS({
         self.emit("end");
       });
     };
-    SendStream.prototype.type = function type(path3) {
+    SendStream.prototype.type = function type(path5) {
       var res = this.res;
       if (res.getHeader("Content-Type")) return;
-      var ext = extname(path3);
+      var ext = extname(path5);
       var type2 = mime.contentType(ext) || "application/octet-stream";
       debug("content-type %s", type2);
       res.setHeader("Content-Type", type2);
     };
-    SendStream.prototype.setHeader = function setHeader(path3, stat) {
+    SendStream.prototype.setHeader = function setHeader(path5, stat) {
       var res = this.res;
-      this.emit("headers", res, path3, stat);
+      this.emit("headers", res, path5, stat);
       if (this._acceptRanges && !res.getHeader("Accept-Ranges")) {
         debug("accept ranges");
         res.setHeader("Accept-Ranges", "bytes");
@@ -23286,9 +23302,9 @@ var require_send = __commonJS({
       }
       return err instanceof Error ? createError(status, err, { expose: false }) : createError(status, err);
     }
-    function decode3(path3) {
+    function decode3(path5) {
       try {
-        return decodeURIComponent(path3);
+        return decodeURIComponent(path5);
       } catch (err) {
         return -1;
       }
@@ -23432,7 +23448,7 @@ var require_response = __commonJS({
     var http = __require("node:http");
     var onFinished = require_on_finished();
     var mime = require_mime_types();
-    var path2 = __require("node:path");
+    var path4 = __require("node:path");
     var pathIsAbsolute = __require("node:path").isAbsolute;
     var statuses = require_statuses();
     var sign = require_cookie_signature().sign;
@@ -23441,8 +23457,8 @@ var require_response = __commonJS({
     var setCharset = require_utils3().setCharset;
     var cookie = require_cookie();
     var send = require_send();
-    var extname = path2.extname;
-    var resolve = path2.resolve;
+    var extname = path4.extname;
+    var resolve = path4.resolve;
     var vary = require_vary();
     var { Buffer: Buffer2 } = __require("node:buffer");
     var res = Object.create(http.ServerResponse.prototype);
@@ -23588,26 +23604,26 @@ var require_response = __commonJS({
       this.type("txt");
       return this.send(body);
     };
-    res.sendFile = function sendFile(path3, options, callback) {
+    res.sendFile = function sendFile(path5, options, callback) {
       var done = callback;
       var req = this.req;
       var res2 = this;
       var next = req.next;
       var opts = options || {};
-      if (!path3) {
+      if (!path5) {
         throw new TypeError("path argument is required to res.sendFile");
       }
-      if (typeof path3 !== "string") {
+      if (typeof path5 !== "string") {
         throw new TypeError("path must be a string to res.sendFile");
       }
       if (typeof options === "function") {
         done = options;
         opts = {};
       }
-      if (!opts.root && !pathIsAbsolute(path3)) {
+      if (!opts.root && !pathIsAbsolute(path5)) {
         throw new TypeError("path must be absolute or specify root to res.sendFile");
       }
-      var pathname = encodeURI(path3);
+      var pathname = encodeURI(path5);
       opts.etag = this.app.enabled("etag");
       var file2 = send(req, pathname, opts);
       sendfile(res2, file2, opts, function(err) {
@@ -23618,7 +23634,7 @@ var require_response = __commonJS({
         }
       });
     };
-    res.download = function download(path3, filename, options, callback) {
+    res.download = function download(path5, filename, options, callback) {
       var done = callback;
       var name = filename;
       var opts = options || null;
@@ -23635,7 +23651,7 @@ var require_response = __commonJS({
         opts = filename;
       }
       var headers = {
-        "Content-Disposition": contentDisposition(name || path3)
+        "Content-Disposition": contentDisposition(name || path5)
       };
       if (opts && opts.headers) {
         var keys = Object.keys(opts.headers);
@@ -23648,7 +23664,7 @@ var require_response = __commonJS({
       }
       opts = Object.create(opts);
       opts.headers = headers;
-      var fullPath = !opts.root ? resolve(path3) : path3;
+      var fullPath = !opts.root ? resolve(path5) : path5;
       return this.sendFile(fullPath, opts, done);
     };
     res.contentType = res.type = function contentType3(type) {
@@ -23931,11 +23947,11 @@ var require_serve_static = __commonJS({
         }
         var forwardError = !fallthrough;
         var originalUrl = parseUrl.original(req);
-        var path2 = parseUrl(req).pathname;
-        if (path2 === "/" && originalUrl.pathname.substr(-1) !== "/") {
-          path2 = "";
+        var path4 = parseUrl(req).pathname;
+        if (path4 === "/" && originalUrl.pathname.substr(-1) !== "/") {
+          path4 = "";
         }
-        var stream = send(req, path2, opts);
+        var stream = send(req, path4, opts);
         stream.on("directory", onDirectory);
         if (setHeaders) {
           stream.on("headers", setHeaders);
@@ -24419,11 +24435,11 @@ var require_codegen = __commonJS({
         const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
         return `${varKind} ${this.name}${rhs};` + _n;
       }
-      optimizeNames(names, constants3) {
+      optimizeNames(names, constants2) {
         if (!names[this.name.str])
           return;
         if (this.rhs)
-          this.rhs = optimizeExpr(this.rhs, names, constants3);
+          this.rhs = optimizeExpr(this.rhs, names, constants2);
         return this;
       }
       get names() {
@@ -24440,10 +24456,10 @@ var require_codegen = __commonJS({
       render({ _n }) {
         return `${this.lhs} = ${this.rhs};` + _n;
       }
-      optimizeNames(names, constants3) {
+      optimizeNames(names, constants2) {
         if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
           return;
-        this.rhs = optimizeExpr(this.rhs, names, constants3);
+        this.rhs = optimizeExpr(this.rhs, names, constants2);
         return this;
       }
       get names() {
@@ -24504,8 +24520,8 @@ var require_codegen = __commonJS({
       optimizeNodes() {
         return `${this.code}` ? this : void 0;
       }
-      optimizeNames(names, constants3) {
-        this.code = optimizeExpr(this.code, names, constants3);
+      optimizeNames(names, constants2) {
+        this.code = optimizeExpr(this.code, names, constants2);
         return this;
       }
       get names() {
@@ -24534,12 +24550,12 @@ var require_codegen = __commonJS({
         }
         return nodes.length > 0 ? this : void 0;
       }
-      optimizeNames(names, constants3) {
+      optimizeNames(names, constants2) {
         const { nodes } = this;
         let i = nodes.length;
         while (i--) {
           const n = nodes[i];
-          if (n.optimizeNames(names, constants3))
+          if (n.optimizeNames(names, constants2))
             continue;
           subtractNames(names, n.names);
           nodes.splice(i, 1);
@@ -24592,12 +24608,12 @@ var require_codegen = __commonJS({
           return void 0;
         return this;
       }
-      optimizeNames(names, constants3) {
+      optimizeNames(names, constants2) {
         var _a3;
-        this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants3);
-        if (!(super.optimizeNames(names, constants3) || this.else))
+        this.else = (_a3 = this.else) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants2);
+        if (!(super.optimizeNames(names, constants2) || this.else))
           return;
-        this.condition = optimizeExpr(this.condition, names, constants3);
+        this.condition = optimizeExpr(this.condition, names, constants2);
         return this;
       }
       get names() {
@@ -24620,10 +24636,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.iteration})` + super.render(opts);
       }
-      optimizeNames(names, constants3) {
-        if (!super.optimizeNames(names, constants3))
+      optimizeNames(names, constants2) {
+        if (!super.optimizeNames(names, constants2))
           return;
-        this.iteration = optimizeExpr(this.iteration, names, constants3);
+        this.iteration = optimizeExpr(this.iteration, names, constants2);
         return this;
       }
       get names() {
@@ -24659,10 +24675,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
       }
-      optimizeNames(names, constants3) {
-        if (!super.optimizeNames(names, constants3))
+      optimizeNames(names, constants2) {
+        if (!super.optimizeNames(names, constants2))
           return;
-        this.iterable = optimizeExpr(this.iterable, names, constants3);
+        this.iterable = optimizeExpr(this.iterable, names, constants2);
         return this;
       }
       get names() {
@@ -24704,11 +24720,11 @@ var require_codegen = __commonJS({
         (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
         return this;
       }
-      optimizeNames(names, constants3) {
+      optimizeNames(names, constants2) {
         var _a3, _b;
-        super.optimizeNames(names, constants3);
-        (_a3 = this.catch) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants3);
-        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants3);
+        super.optimizeNames(names, constants2);
+        (_a3 = this.catch) === null || _a3 === void 0 ? void 0 : _a3.optimizeNames(names, constants2);
+        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants2);
         return this;
       }
       get names() {
@@ -25009,7 +25025,7 @@ var require_codegen = __commonJS({
     function addExprNames(names, from) {
       return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
     }
-    function optimizeExpr(expr, names, constants3) {
+    function optimizeExpr(expr, names, constants2) {
       if (expr instanceof code_1.Name)
         return replaceName(expr);
       if (!canOptimize(expr))
@@ -25024,14 +25040,14 @@ var require_codegen = __commonJS({
         return items;
       }, []));
       function replaceName(n) {
-        const c = constants3[n.str];
+        const c = constants2[n.str];
         if (c === void 0 || names[n.str] !== 1)
           return n;
         delete names[n.str];
         return c;
       }
       function canOptimize(e) {
-        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants3[c.str] !== void 0);
+        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants2[c.str] !== void 0);
       }
     }
     function subtractNames(names, from) {
@@ -27271,8 +27287,8 @@ var require_utils4 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path2) {
-      let input2 = path2;
+    function removeDotSegments(path4) {
+      let input2 = path4;
       const output2 = [];
       let nextSlash = -1;
       let len = 0;
@@ -27681,8 +27697,8 @@ var require_schemes = __commonJS({
       }
       if (wsComponent.resourceName) {
         const queryIndex = wsComponent.resourceName.indexOf("?");
-        const path2 = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
-        wsComponent.path = path2 && path2 !== "/" ? path2 : void 0;
+        const path4 = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
+        wsComponent.path = path4 && path4 !== "/" ? path4 : void 0;
         wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
         wsComponent.resourceName = void 0;
       }
@@ -28157,13 +28173,14 @@ var require_fast_uri = __commonJS({
         if (!malformedIPLiteral) {
           malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
         }
-        if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-          if (uri.indexOf("%") !== -1) {
-            if (parsed.host !== void 0 && !malformedIPLiteral) {
-              const host2 = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
-              parsed.host = reescapeHostDelimiters(host2, isIP);
-            }
+        if (uri.indexOf("%") !== -1 && parsed.host !== void 0 && !malformedIPLiteral) {
+          let host2 = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+          if (!isIP) {
+            host2 = normalizePercentEncoding(host2.toLowerCase());
           }
+          parsed.host = reescapeHostDelimiters(host2, isIP);
+        }
+        if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
           if (parsed.path) {
             parsed.path = normalizePathEncoding(parsed.path);
           }
@@ -31261,7 +31278,6 @@ function localhostHostValidation() {
 function createMcpExpressApp(options = {}) {
   const { host: host2 = "127.0.0.1", allowedHosts } = options;
   const app2 = (0, import_express.default)();
-  app2.use(import_express.default.json());
   if (allowedHosts) {
     app2.use(hostHeaderValidation(allowedHosts));
   } else {
@@ -31272,6 +31288,7 @@ function createMcpExpressApp(options = {}) {
       console.warn(`Warning: Server is binding to ${host2} without DNS rebinding protection. Consider using the allowedHosts option to restrict allowed hosts, or use authentication to protect your server.`);
     }
   }
+  app2.use(import_express.default.json());
   return app2;
 }
 
@@ -32476,6 +32493,50 @@ function isJsonContentType(header) {
   return mediaTypeEssence(header) === "application/json";
 }
 
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/requestBody.js
+var DEFAULT_MAX_REQUEST_BODY_SIZE = 4 * 1024 * 1024;
+var MAX_BATCH_SIZE = 100;
+function requestBodyTooLargeMessage(maxBytes) {
+  return `Payload Too Large: Request body must not exceed ${maxBytes} bytes`;
+}
+function resolveMaxRequestBodySize(value) {
+  if (value === void 0) {
+    return DEFAULT_MAX_REQUEST_BODY_SIZE;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new RangeError(`maxRequestBodySize must be a positive number of bytes, got ${String(value)}`);
+  }
+  return value;
+}
+async function readRequestBody(request, maxBytes = DEFAULT_MAX_REQUEST_BODY_SIZE) {
+  if (Number(request.headers.get("content-length")) > maxBytes) {
+    return { tooLarge: true };
+  }
+  if (request.body === null) {
+    return { tooLarge: false, text: "" };
+  }
+  const reader = request.body.getReader();
+  const decoder = new TextDecoder();
+  let received = 0;
+  let text = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      received += value.byteLength;
+      if (received > maxBytes) {
+        return { tooLarge: true };
+      }
+      text += decoder.decode(value, { stream: true });
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return { tooLarge: false, text: text + decoder.decode() };
+}
+
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/sseKeepAlive.js
 var DEFAULT_SSE_KEEP_ALIVE_MS = 15e3;
 var MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
@@ -33304,10 +33365,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path2) {
-  if (!path2)
+function getElementAtPath(obj, path4) {
+  if (!path4)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path4.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -33647,11 +33708,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path2, issues) {
+function prefixIssues(path4, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path4);
     return iss;
   });
 }
@@ -34101,16 +34162,16 @@ function flattenError(error62, mapper = (issue2) => issue2.message) {
 }
 function formatError(error62, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error63, path2 = []) => {
+  const processError = (error63, path4 = []) => {
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path2, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path4, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path4, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -34149,17 +34210,17 @@ function formatError(error62, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error62, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error63, path2 = []) => {
+  const processError = (error63, path4 = []) => {
     var _a3;
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path2, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path4, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path4, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -34198,8 +34259,8 @@ function treeifyError(error62, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path2) {
+  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path4) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -51301,13 +51362,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path2 = ref.slice(1).split("/").filter(Boolean);
-  if (path2.length === 0) {
+  const path4 = ref.slice(1).split("/").filter(Boolean);
+  if (path4.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path2[0] === defsKey) {
-    const key = path2[1] === void 0 ? void 0 : decodeJSONPointerSegment(path2[1]);
+  if (path4[0] === defsKey) {
+    const key = path4[1] === void 0 ? void 0 : decodeJSONPointerSegment(path4[1]);
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -53712,6 +53773,7 @@ var WebStandardStreamableHTTPServerTransport = class {
     this._enableDnsRebindingProtection = options.enableDnsRebindingProtection ?? false;
     this._retryInterval = options.retryInterval;
     this._keepAliveMs = options.keepAliveMs ?? DEFAULT_SSE_KEEP_ALIVE_MS;
+    this._maxRequestBodySize = resolveMaxRequestBodySize(options.maxRequestBodySize);
   }
   /**
    * Arms a keep-alive interval for an SSE stream that periodically writes an SSE
@@ -54073,12 +54135,22 @@ data:
         rawMessage = options.parsedBody;
       } else {
         try {
-          rawMessage = await req.json();
+          const body = await readRequestBody(req, this._maxRequestBodySize);
+          if (body.tooLarge) {
+            const message = requestBodyTooLargeMessage(this._maxRequestBodySize);
+            this.onerror?.(new Error(message));
+            return this.createJsonErrorResponse(413, -32e3, message);
+          }
+          rawMessage = JSON.parse(body.text);
         } catch {
           this.onerror?.(new Error("Parse error: Invalid JSON"));
           return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
         }
       }
+      if (Array.isArray(rawMessage) && rawMessage.length > MAX_BATCH_SIZE) {
+        this.onerror?.(new Error(`Invalid Request: Batch must not exceed ${MAX_BATCH_SIZE} messages`));
+        return this.createJsonErrorResponse(400, -32600, `Invalid Request: Batch must not exceed ${MAX_BATCH_SIZE} messages`);
+      }
       let messages;
       try {
         if (Array.isArray(rawMessage)) {
@@ -54523,9 +54595,6 @@ var StreamableHTTPServerTransport = class {
   }
 };
 
-// src/server.ts
-import { readdir, writeFile } from "node:fs/promises";
-
 // node_modules/zod/v3/helpers/util.js
 var util;
 (function(util2) {
@@ -54900,8 +54969,8 @@ function getErrorMap2() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path2, errorMaps, issueData } = params;
-  const fullPath = [...path2, ...issueData.path || []];
+  const { data, path: path4, errorMaps, issueData } = params;
+  const fullPath = [...path4, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -55016,11 +55085,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path2, key) {
+  constructor(parent, value, path4, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path2;
+    this._path = path4;
     this._key = key;
   }
   get path() {
@@ -58571,11 +58640,11 @@ function normalizeObjectSchema(schema) {
   }
   return void 0;
 }
-function getDotPath(path2) {
-  if (path2.length === 0) {
+function getDotPath(path4) {
+  if (path4.length === 0) {
     return "object root";
   }
-  return path2.reduce((acc, seg, index) => {
+  return path4.reduce((acc, seg, index) => {
     if (index === 0) {
       return String(seg);
     }
@@ -60019,6 +60088,9 @@ var Protocol = class {
       this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
         const handleTaskResult = async () => {
           const taskId = request.params.taskId;
+          if (!await this._taskStore.getTask(taskId, extra.sessionId)) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+          }
           if (this._taskMessageQueue) {
             let queuedMessage;
             while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
@@ -60049,12 +60121,12 @@ var Protocol = class {
             throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
           }
           if (!isTerminal(task.status)) {
-            await this._waitForTaskUpdate(taskId, extra.signal);
+            await this._waitForTaskUpdate(taskId, extra.signal, extra.sessionId);
             return await handleTaskResult();
           }
           if (isTerminal(task.status)) {
             const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
-            this._clearTaskQueue(taskId);
+            this._clearTaskQueue(taskId, extra.sessionId);
             return {
               ...result,
               _meta: {
@@ -60091,7 +60163,7 @@ var Protocol = class {
             throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
           }
           await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
-          this._clearTaskQueue(request.params.taskId);
+          this._clearTaskQueue(request.params.taskId, extra.sessionId);
           const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
           if (!cancelledTask) {
             throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
@@ -60219,6 +60291,19 @@ var Protocol = class {
     const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
     const capturedTransport = this._transport;
     const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
+    const sessionId = capturedTransport?.sessionId;
+    const store = this._taskStore;
+    let relatedTaskFound = true;
+    let relatedTaskLookup;
+    if (relatedTaskId && store && this._taskMessageQueue && sessionId !== void 0) {
+      relatedTaskFound = false;
+      relatedTaskLookup = (async () => {
+        if (!await store.getTask(relatedTaskId, sessionId)) {
+          throw new McpError(ErrorCode.InvalidParams, `Task not found: ${relatedTaskId}`);
+        }
+        relatedTaskFound = true;
+      })();
+    }
     if (handler === void 0) {
       const errorResponse = {
         jsonrpc: "2.0",
@@ -60228,7 +60313,10 @@ var Protocol = class {
           message: "Method not found"
         }
       };
-      if (relatedTaskId && this._taskMessageQueue) {
+      if (relatedTaskId && relatedTaskLookup) {
+        const queuedError = { type: "error", message: errorResponse, timestamp: Date.now() };
+        relatedTaskLookup.then(() => this._enqueueTaskMessage(relatedTaskId, queuedError, sessionId), () => capturedTransport?.send(errorResponse)).catch((error62) => this._onerror(new Error(`Failed to send an error response: ${error62}`)));
+      } else if (relatedTaskId && this._taskMessageQueue) {
         this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
           message: errorResponse,
@@ -60279,7 +60367,10 @@ var Protocol = class {
       closeSSEStream: extra?.closeSSEStream,
       closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
     };
-    Promise.resolve().then(() => {
+    (relatedTaskLookup ?? Promise.resolve()).then(() => {
+      if (relatedTaskLookup && abortController.signal.aborted) {
+        throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
+      }
       if (taskCreationParams) {
         this.assertTaskHandlerCapability(request.method);
       }
@@ -60314,7 +60405,7 @@ var Protocol = class {
           ...error62["data"] !== void 0 && { data: error62["data"] }
         }
       };
-      if (relatedTaskId && this._taskMessageQueue) {
+      if (relatedTaskId && this._taskMessageQueue && relatedTaskFound) {
         await this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
           message: errorResponse,
@@ -60794,7 +60885,7 @@ var Protocol = class {
       throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
     }
     const maxQueueSize = this._options?.maxTaskQueueSize;
-    await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+    await this._taskMessageQueue.enqueue(taskId, message, sessionId ?? this._transport?.sessionId, maxQueueSize);
   }
   /**
    * Clears the message queue for a task and rejects any pending request resolvers.
@@ -60823,12 +60914,13 @@ var Protocol = class {
    * Uses polling to check for updates at the task's configured poll interval.
    * @param taskId The task ID to wait for
    * @param signal Abort signal to cancel the wait
+   * @param sessionId Session of the request that waits, passed to the task store
    * @returns Promise that resolves when an update occurs or rejects if aborted
    */
-  async _waitForTaskUpdate(taskId, signal) {
+  async _waitForTaskUpdate(taskId, signal, sessionId) {
     let interval = this._options?.defaultTaskPollInterval ?? 1e3;
     try {
-      const task = await this._taskStore?.getTask(taskId);
+      const task = await this._taskStore?.getTask(taskId, sessionId);
       if (task?.pollInterval) {
         interval = task.pollInterval;
       }
@@ -61707,6 +61799,42 @@ var ExperimentalMcpServerTasks = class {
 };
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
+function toolInputElementCount(value, max) {
+  let count = 0;
+  const stack = [value];
+  while (stack.length > 0) {
+    const node2 = stack.pop();
+    if (node2 === null || typeof node2 !== "object")
+      continue;
+    if (Array.isArray(node2)) {
+      for (const child of node2) {
+        if (++count > max)
+          return count;
+        if (child !== null && typeof child === "object")
+          stack.push(child);
+      }
+    } else {
+      for (const key in node2) {
+        if (!Object.prototype.hasOwnProperty.call(node2, key))
+          continue;
+        if (++count > max)
+          return count;
+        const child = node2[key];
+        if (child !== null && typeof child === "object")
+          stack.push(child);
+      }
+    }
+  }
+  return count;
+}
+function resolveMaxToolInputElements(value) {
+  if (value === void 0 || value === Infinity)
+    return void 0;
+  if (typeof value !== "number" || Number.isNaN(value) || value < 1) {
+    throw new RangeError(`maxToolInputElements must be a number of at least 1, or Infinity, got ${String(value)}`);
+  }
+  return value;
+}
 var McpServer = class {
   constructor(serverInfo, options) {
     this._registeredResources = {};
@@ -61718,6 +61846,7 @@ var McpServer = class {
     this._resourceHandlersInitialized = false;
     this._promptHandlersInitialized = false;
     this.server = new Server(serverInfo, options);
+    this._maxToolInputElements = resolveMaxToolInputElements(options?.maxToolInputElements);
   }
   /**
    * Access experimental features.
@@ -61848,12 +61977,15 @@ var McpServer = class {
    * Validates tool input arguments against the tool's input schema.
    */
   async validateToolInput(tool, args, toolName) {
+    if (this._maxToolInputElements !== void 0 && toolInputElementCount(args, this._maxToolInputElements) > this._maxToolInputElements) {
+      throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${toolName}: arguments contain more than the maximum of ${this._maxToolInputElements} elements`);
+    }
     if (!tool.inputSchema) {
       return void 0;
     }
     const inputObj = normalizeObjectSchema(tool.inputSchema);
     const schemaToParse = inputObj ?? tool.inputSchema;
-    const parseResult = await safeParseAsync3(schemaToParse, args);
+    const parseResult = await safeParseAsync3(schemaToParse, args ?? {});
     if (!parseResult.success) {
       const error62 = "error" in parseResult ? parseResult.error : "Unknown error";
       const errorMessage = getParseErrorMessage(error62);
@@ -62091,7 +62223,7 @@ var McpServer = class {
       }
       if (prompt.argsSchema) {
         const argsObj = normalizeObjectSchema(prompt.argsSchema);
-        const parseResult = await safeParseAsync3(argsObj, request.params.arguments);
+        const parseResult = await safeParseAsync3(argsObj, request.params.arguments ?? {});
         if (!parseResult.success) {
           const error62 = "error" in parseResult ? parseResult.error : "Unknown error";
           const errorMessage = getParseErrorMessage(error62);
@@ -62498,14 +62630,28 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
-// src/runner.ts
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
+// src/process-manager.ts
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import path3 from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+
+// src/rooted-filesystem.ts
+import { spawn } from "node:child_process";
+import { realpathSync, statSync } from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
 
 // src/security.ts
-import { constants as constants2 } from "node:fs";
-import { access, lstat, realpath } from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 var DEFAULT_ENVIRONMENT_KEYS = [
   "LANG",
@@ -62538,34 +62684,7 @@ function configuredRoots(raw = process.env.MACHINE_TERMINAL_ROOTS) {
 }
 function isWithinRoot(candidate, root) {
   const relative = path.relative(root, candidate);
-  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== "..";
-}
-async function resolveReadablePath(requestedPath, roots2, cwd = roots2[0] ?? os.homedir()) {
-  const resolvedRoots = await Promise.all(roots2.map((root) => realpath(root)));
-  const candidate = await realpath(path.resolve(cwd, requestedPath));
-  if (!resolvedRoots.some((root) => isWithinRoot(candidate, root))) {
-    throw new Error("Path is outside MACHINE_TERMINAL_ROOTS.");
-  }
-  await access(candidate, constants2.R_OK);
-  return candidate;
-}
-async function resolveWritablePath(requestedPath, roots2, cwd = roots2[0] ?? os.homedir()) {
-  const absolute = path.resolve(cwd, requestedPath);
-  const resolvedParent = await realpath(path.dirname(absolute));
-  const resolvedRoots = await Promise.all(roots2.map((root) => realpath(root)));
-  const candidate = path.join(resolvedParent, path.basename(absolute));
-  if (!resolvedRoots.some((root) => isWithinRoot(candidate, root))) {
-    throw new Error("Path is outside MACHINE_TERMINAL_ROOTS.");
-  }
-  try {
-    const stats = await lstat(candidate);
-    if (stats.isSymbolicLink()) {
-      throw new Error("Writing through symbolic links is not allowed.");
-    }
-  } catch (error62) {
-    if (error62.code !== "ENOENT") throw error62;
-  }
-  return candidate;
+  return relative === "" || !path.isAbsolute(relative) && !relative.startsWith(`..${path.sep}`) && relative !== "..";
 }
 function safeEnvironment(source = process.env) {
   return Object.fromEntries(
@@ -62590,68 +62709,671 @@ function assertProgramAllowed(program) {
   }
 }
 
-// src/runner.ts
-var execFileAsync = promisify(execFile);
-async function runProgram(options) {
-  assertProgramAllowed(options.program);
-  try {
-    const { stdout, stderr } = await execFileAsync(
-      options.program,
-      options.args,
-      {
-        cwd: options.cwd,
-        env: safeEnvironment(),
-        encoding: "utf8",
-        maxBuffer: options.maxOutputChars,
-        timeout: options.timeoutMs,
-        windowsHide: true
+// src/rooted-filesystem.ts
+var filesystemHelperPath = fileURLToPath(
+  new URL(
+    `../dist/native/${process.platform}-${process.arch}/fs-helper${process.platform === "win32" ? ".exe" : ""}`,
+    import.meta.url
+  )
+);
+var RootedFilesystem = class {
+  roots;
+  #specs;
+  #aliases;
+  #child;
+  #pending = /* @__PURE__ */ new Map();
+  #nextID = 0;
+  #buffer = "";
+  #failure;
+  #initialized = false;
+  ready;
+  constructor(roots2) {
+    if (!roots2.length || roots2.length > 128)
+      throw new Error("ROOTED_FILESYSTEM_ROOT_LIMIT");
+    this.#aliases = roots2.map((root) => path2.resolve(root));
+    this.#specs = roots2.map((root) => {
+      const name = realpathSync(root);
+      const info = statSync(name, { bigint: true });
+      if (!info.isDirectory())
+        throw new Error("ROOTED_FILESYSTEM_EXPECTED_DIRECTORY");
+      return { path: name, dev: info.dev.toString(), ino: info.ino.toString() };
+    });
+    this.roots = this.#specs.map((root) => root.path);
+    this.#child = spawn(filesystemHelperPath, [], {
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+      env: safeEnvironment()
+    });
+    this.#child.stderr.resume();
+    this.#child.on(
+      "error",
+      () => this.#fail(new Error("ROOTED_FILESYSTEM_HELPER_UNAVAILABLE"))
+    );
+    this.#child.on(
+      "close",
+      () => this.#fail(new Error("ROOTED_FILESYSTEM_HELPER_CLOSED"))
+    );
+    this.#child.stdin.on(
+      "error",
+      () => this.#fail(new Error("ROOTED_FILESYSTEM_HELPER_CLOSED"))
+    );
+    this.#child.stdout.on(
+      "error",
+      () => this.#fail(new Error("ROOTED_FILESYSTEM_HELPER_CLOSED"))
+    );
+    this.#child.stderr.on(
+      "error",
+      () => this.#fail(new Error("ROOTED_FILESYSTEM_HELPER_CLOSED"))
+    );
+    this.#child.stdout.setEncoding("utf8");
+    this.#child.stdout.on("data", (data) => {
+      this.#buffer += data;
+      if (Buffer.byteLength(this.#buffer) > 4 * 1024 * 1024) {
+        this.#fail(new Error("ROOTED_FILESYSTEM_REPLY_LIMIT"));
+        return;
+      }
+      let newline;
+      while ((newline = this.#buffer.indexOf("\n")) !== -1) {
+        const line = this.#buffer.slice(0, newline);
+        this.#buffer = this.#buffer.slice(newline + 1);
+        try {
+          const reply = JSON.parse(line);
+          const waiting = this.#pending.get(reply.id);
+          if (!waiting) continue;
+          this.#pending.delete(reply.id);
+          clearTimeout(waiting.timer);
+          if (reply.error) waiting.reject(new Error(reply.error));
+          else waiting.resolve(reply);
+        } catch {
+          this.#fail(new Error("ROOTED_FILESYSTEM_INVALID_REPLY"));
+          return;
+        }
       }
+      this.#referenceWork();
+    });
+    this.ready = this.#request("init", { roots: this.#specs }).then(() => {
+      this.#initialized = true;
+    });
+    void this.ready.catch(() => void 0);
+  }
+  #referenceWork() {
+    const method = this.#pending.size ? "ref" : "unref";
+    this.#child[method]();
+    for (const stream of [
+      this.#child.stdin,
+      this.#child.stdout,
+      this.#child.stderr
+    ])
+      stream[method]();
+  }
+  #fail(error62) {
+    this.#failure ??= error62;
+    for (const waiting of this.#pending.values()) {
+      clearTimeout(waiting.timer);
+      waiting.reject(this.#failure);
+    }
+    this.#pending.clear();
+    this.#child.kill();
+    this.#referenceWork();
+  }
+  #request(operation, values) {
+    if (this.#failure) return Promise.reject(this.#failure);
+    if (this.#pending.size >= 16)
+      return Promise.reject(new Error("ROOTED_FILESYSTEM_PENDING_LIMIT"));
+    const id = ++this.#nextID;
+    const message = JSON.stringify({ id, operation, ...values }) + "\n";
+    if (Buffer.byteLength(message) >= 4 * 1024 * 1024)
+      return Promise.reject(new Error("ROOTED_FILESYSTEM_INPUT_LIMIT"));
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => this.#fail(new Error("ROOTED_FILESYSTEM_TIMEOUT")),
+        1e4
+      );
+      this.#pending.set(id, { resolve, reject, timer });
+      this.#referenceWork();
+      this.#child.stdin.write(message);
+    });
+  }
+  resolve(requestedPath) {
+    const candidate = path2.resolve(this.#aliases[0], requestedPath);
+    const index = this.roots.findIndex(
+      (root, i) => isWithinRoot(candidate, root) || isWithinRoot(candidate, this.#aliases[i])
     );
-    return { exitCode: 0, signal: null, stdout, stderr, timedOut: false };
-  } catch (error62) {
-    const failure2 = error62;
+    if (index === -1)
+      throw new Error("Path is outside MACHINE_TERMINAL_ROOTS.");
+    const base = isWithinRoot(candidate, this.roots[index]) ? this.roots[index] : this.#aliases[index];
+    const relative = path2.relative(base, candidate) || ".";
+    if (relative.length > 4096) throw new Error("ROOTED_FILESYSTEM_PATH_LIMIT");
     return {
-      exitCode: typeof failure2.code === "number" ? failure2.code : null,
-      signal: failure2.signal ?? null,
-      stdout: failure2.stdout ?? "",
-      stderr: failure2.stderr ?? failure2.message,
-      timedOut: failure2.killed === true && failure2.signal === "SIGTERM"
+      root: index,
+      path: relative,
+      displayPath: path2.join(this.roots[index], relative)
     };
   }
-}
-
-// src/file-reader.ts
-import { open as open2 } from "node:fs/promises";
-async function readBoundedTextFile(filename, maxCharacters) {
-  const handle = await open2(filename, "r");
-  try {
-    const stats = await handle.stat();
-    const buffer = Buffer.allocUnsafe(maxCharacters * 4 + 4);
-    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-    const hasUnreadBytes = bytesRead < stats.size;
-    const decoded = new TextDecoder().decode(buffer.subarray(0, bytesRead), {
-      stream: hasUnreadBytes
-    });
+  async read(target, maxCharacters) {
+    await this.ready;
+    const reply = await this.#request("read", { ...target, maxCharacters });
+    const decoded = new TextDecoder().decode(
+      Buffer.from(reply.bytes ?? "", "base64"),
+      { stream: reply.hasUnread }
+    );
     return {
       contents: decoded.slice(0, maxCharacters),
-      truncated: hasUnreadBytes || decoded.length > maxCharacters
+      truncated: reply.hasUnread || decoded.length > maxCharacters
     };
-  } finally {
-    await handle.close();
   }
+  async write(target, contents, overwrite) {
+    await this.ready;
+    return (await this.#request("write", { ...target, contents, overwrite })).bytesWritten;
+  }
+  async list(target) {
+    await this.ready;
+    const reply = await this.#request("list", { ...target });
+    return { entries: reply.entries ?? [], truncated: reply.truncated };
+  }
+  async execution(requestedPath, program, args) {
+    await this.ready;
+    const target = this.resolve(requestedPath);
+    return {
+      roots: [this.#specs[target.root]],
+      path: target.path,
+      program,
+      args
+    };
+  }
+  async close() {
+    if (this.#child.exitCode !== null || this.#child.signalCode !== null)
+      return;
+    const exited = new Promise(
+      (resolve) => this.#child.once("close", () => resolve())
+    );
+    this.#fail(new Error("ROOTED_FILESYSTEM_CLOSED"));
+    await exited;
+  }
+  get available() {
+    return this.#initialized && !this.#failure;
+  }
+};
+
+// src/process-manager.ts
+var MAX_EVENT_CHARACTERS = 4096;
+var MAX_RETAINED_EVENTS = 128;
+var MAX_RETAINED_EVENT_CHARACTERS = 64e3;
+var LOCAL_SESSION_RETENTION_MS = 60 * 6e4;
+var MAX_TASK_TOMBSTONES = 2e4;
+var TASK_RECEIPT_RETENTION_MS = 30 * 24 * 60 * 6e4;
+var TERMINATION_GRACE_MS = 1500;
+function appendBounded(current, value, limit) {
+  if (current.length >= limit) return current;
+  return `${current}${value.toString("utf8")}`.slice(0, limit);
 }
+function snapshot(session) {
+  return {
+    sessionId: session.sessionId,
+    ...session.taskId ? { taskId: session.taskId } : {},
+    program: session.program,
+    args: session.args,
+    cwd: session.cwd,
+    pid: session.child.pid ?? null,
+    running: session.running,
+    exitCode: session.exitCode,
+    signal: session.signal,
+    stdout: session.stdout,
+    stderr: session.stderr,
+    timedOut: session.timedOut
+  };
+}
+var ProcessManager = class {
+  constructor(limits = {
+    maxRunning: 32,
+    maxRetained: 512
+  }, receiptFile = process.env.MACHINE_TERMINAL_TASK_RECEIPTS_FILE) {
+    this.limits = limits;
+    this.receiptFile = receiptFile;
+    if (!Number.isInteger(limits.maxRunning) || limits.maxRunning < 1 || !Number.isInteger(limits.maxRetained) || limits.maxRetained < limits.maxRunning) {
+      throw new Error("INVALID_PROCESS_LIMITS: Invalid local process limits.");
+    }
+    this.#loadReceipts();
+  }
+  limits;
+  receiptFile;
+  #sessions = /* @__PURE__ */ new Map();
+  #taskSessions = /* @__PURE__ */ new Map();
+  #taskReceipts = /* @__PURE__ */ new Map();
+  #loadReceipts() {
+    if (!this.receiptFile) return;
+    let raw;
+    try {
+      raw = readFileSync(this.receiptFile, "utf8");
+    } catch (error62) {
+      if (error62.code === "ENOENT") return;
+      throw error62;
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1 || !Array.isArray(parsed.receipts)) {
+      throw new Error(
+        "INVALID_TASK_RECEIPTS: Refusing to drop existing replay receipts."
+      );
+    }
+    for (const receipt of parsed.receipts) {
+      if (typeof receipt.taskId !== "string" || !Number.isSafeInteger(receipt.createdAt)) {
+        throw new Error("INVALID_TASK_RECEIPTS: Corrupt task-receipt record.");
+      }
+      this.#taskReceipts.set(receipt.taskId, receipt.createdAt);
+    }
+    this.#pruneReceipts();
+  }
+  #persistReceipts() {
+    if (!this.receiptFile) return;
+    mkdirSync(path3.dirname(this.receiptFile), { recursive: true, mode: 448 });
+    const temporary = this.receiptFile + "." + process.pid + "." + randomUUID() + ".tmp";
+    try {
+      writeFileSync(
+        temporary,
+        JSON.stringify({
+          version: 1,
+          receipts: [...this.#taskReceipts].map(([taskId, createdAt]) => ({
+            taskId,
+            createdAt
+          }))
+        }),
+        { mode: 384, flag: "wx", flush: true }
+      );
+      renameSync(temporary, this.receiptFile);
+      if (process.platform !== "win32") {
+        const directory = openSync(path3.dirname(this.receiptFile), "r");
+        try {
+          fsyncSync(directory);
+        } finally {
+          closeSync(directory);
+        }
+      }
+    } finally {
+      rmSync(temporary, { force: true });
+    }
+  }
+  #pruneReceipts() {
+    const cutoff = Date.now() - TASK_RECEIPT_RETENTION_MS;
+    let dirty = false;
+    for (const [taskId, createdAt] of this.#taskReceipts) {
+      if (createdAt < cutoff && !this.#taskSessions.has(taskId)) {
+        this.#taskReceipts.delete(taskId);
+        dirty = true;
+      }
+    }
+    if (dirty) this.#persistReceipts();
+  }
+  #recordTaskReceipt(taskId) {
+    this.#taskReceipts.set(taskId, Date.now());
+    try {
+      this.#persistReceipts();
+    } catch (error62) {
+      this.#taskReceipts.delete(taskId);
+      throw error62;
+    }
+  }
+  #signalProcessTree(session, signal) {
+    const pid = session.child.pid;
+    if (!pid || pid < 1) return;
+    if (process.platform === "win32") {
+      const killer = spawn2("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
+        windowsHide: true,
+        stdio: "ignore"
+      });
+      killer.on("error", () => session.child.kill("SIGKILL"));
+      killer.on("close", (code) => {
+        if (code !== 0 && session.running) session.child.kill("SIGKILL");
+      });
+      return;
+    }
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch (error62) {
+      if (error62.code === "ESRCH") return;
+    }
+    session.child.kill(signal);
+  }
+  #unixProcessGroupExists(session) {
+    if (process.platform === "win32") return false;
+    const pid = session.child.pid;
+    if (!pid || pid < 1) return false;
+    try {
+      process.kill(-pid, 0);
+      return true;
+    } catch (error62) {
+      return error62.code !== "ESRCH";
+    }
+  }
+  #finishSession(session, exitCode, signal) {
+    if (session.finishedRecorded) return;
+    session.finishedRecorded = true;
+    session.running = false;
+    session.finishedAt = Date.now();
+    session.exitCode = exitCode;
+    session.signal = signal;
+    if (session.timeout) clearTimeout(session.timeout);
+    if (session.forceKillTimer) {
+      clearTimeout(session.forceKillTimer);
+      session.forceKillTimer = void 0;
+    }
+    this.#record(session, "finished", {
+      exitCode,
+      signal,
+      timedOut: session.timedOut
+    });
+  }
+  #requestTermination(session) {
+    if (!session.running) return;
+    session.terminationRequested = true;
+    this.#signalProcessTree(session, "SIGTERM");
+    if (!session.forceKillTimer) {
+      session.forceKillTimer = setTimeout(() => {
+        session.forceKillTimer = void 0;
+        if (process.platform !== "win32" || session.running) {
+          this.#signalProcessTree(session, "SIGKILL");
+        }
+        const pending = session.pendingTerminationClose;
+        if (pending) {
+          session.pendingTerminationClose = void 0;
+          this.#finishSession(session, pending.exitCode, pending.signal);
+        }
+      }, TERMINATION_GRACE_MS);
+    }
+  }
+  #pruneFinished() {
+    const cutoff = Date.now() - LOCAL_SESSION_RETENTION_MS;
+    for (const [sessionId, session] of this.#sessions) {
+      if (session.finishedAt !== void 0 && session.finishedAt < cutoff && session.watchers.size === 0) {
+        this.#sessions.delete(sessionId);
+        if (session.taskId) this.#taskSessions.delete(session.taskId);
+      }
+    }
+  }
+  #record(session, kind, details = {}) {
+    const event = {
+      sessionId: session.sessionId,
+      ...session.taskId ? { taskId: session.taskId } : {},
+      sequence: ++session.nextSequence,
+      kind,
+      ...details
+    };
+    session.events.push(event);
+    session.retainedEventCharacters += event.data?.length ?? 0;
+    while (session.events.length > MAX_RETAINED_EVENTS || session.retainedEventCharacters > MAX_RETAINED_EVENT_CHARACTERS) {
+      const removed = session.events.shift();
+      session.retainedEventCharacters -= removed.data?.length ?? 0;
+    }
+    for (const wake of session.watchers) wake();
+  }
+  #output(session, stream, chunk) {
+    const before = session[stream].length;
+    const next = appendBounded(
+      session[stream],
+      chunk,
+      session.maxOutputCharacters
+    );
+    session[stream] = next;
+    const appended = next.slice(before);
+    for (let i = 0; i < appended.length; i += MAX_EVENT_CHARACTERS) {
+      this.#record(session, stream, {
+        offset: before + i,
+        data: appended.slice(i, i + MAX_EVENT_CHARACTERS)
+      });
+    }
+  }
+  async watch(sessionId, afterSequence, timeoutMs = 15e3, maxEvents = 32) {
+    this.#pruneFinished();
+    const session = this.#sessions.get(sessionId);
+    if (!session)
+      throw new Error("The requested process session was not found.");
+    if (!Number.isSafeInteger(afterSequence) || afterSequence < 0) {
+      throw new Error("afterSequence must be a non-negative integer.");
+    }
+    if (!Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 2e4) {
+      throw new Error("timeoutMs must be between 100 and 20000.");
+    }
+    if (!Number.isInteger(maxEvents) || maxEvents < 1 || maxEvents > 32) {
+      throw new Error("maxEvents must be between 1 and 32.");
+    }
+    const collect = () => {
+      const first = session.events[0]?.sequence ?? session.nextSequence + 1;
+      const missedEvents = afterSequence + 1 < first;
+      const events = session.events.filter((event) => event.sequence > afterSequence).slice(0, maxEvents);
+      return {
+        sessionId,
+        events,
+        nextSequence: events.at(-1)?.sequence ?? Math.max(afterSequence, session.nextSequence),
+        missedEvents,
+        finished: !session.running
+      };
+    };
+    const initial = collect();
+    if (initial.events.length || initial.finished || initial.missedEvents) {
+      return initial;
+    }
+    return new Promise((resolve) => {
+      let timer;
+      const finish = () => {
+        clearTimeout(timer);
+        session.watchers.delete(finish);
+        resolve(collect());
+      };
+      session.watchers.add(finish);
+      timer = setTimeout(finish, timeoutMs);
+      if (session.nextSequence > afterSequence || !session.running) finish();
+    });
+  }
+  start(options) {
+    this.#pruneReceipts();
+    if (options.taskId) {
+      const existingSession = this.#taskSessions.get(options.taskId);
+      if (existingSession) {
+        const existing = this.#sessions.get(existingSession);
+        if (!existing) throw new Error("PROCESS_TASK_SESSION_LOST");
+        if (existing.program !== options.program || existing.cwd !== options.cwd || existing.args.join("\0") !== options.args.join("\0")) {
+          throw new Error(
+            "PROCESS_TASK_CONFLICT: Task ID already started with different arguments."
+          );
+        }
+        const result2 = snapshot(existing);
+        return {
+          ...result2,
+          nextStdoutOffset: result2.stdout.length,
+          nextStderrOffset: result2.stderr.length
+        };
+      }
+      if (this.#taskReceipts.has(options.taskId)) {
+        throw new Error(
+          "PROCESS_TASK_SESSION_LOST: Task already ran; will not execute again."
+        );
+      }
+    }
+    this.#pruneFinished();
+    if (this.#sessions.size >= this.limits.maxRetained) {
+      throw new Error("PROCESS_LIMIT_REACHED: Local process history is full.");
+    }
+    const running = [...this.#sessions.values()].filter(
+      (session2) => session2.running
+    ).length;
+    if (running >= this.limits.maxRunning) {
+      throw new Error(
+        "PROCESS_LIMIT_REACHED: Too many concurrent local processes."
+      );
+    }
+    if (options.taskId && this.#taskReceipts.size >= MAX_TASK_TOMBSTONES) {
+      throw new Error(
+        "PROCESS_LIMIT_REACHED: Local task receipt capacity reached."
+      );
+    }
+    assertProgramAllowed(options.program);
+    if (options.rootedExecution && (options.rootedExecution.program !== options.program || options.rootedExecution.args.join("\0") !== options.args.join("\0")))
+      throw new Error("ROOTED_EXECUTION_MISMATCH");
+    const rootedPayload = options.rootedExecution ? JSON.stringify(options.rootedExecution) : void 0;
+    if (rootedPayload && Buffer.byteLength(rootedPayload) >= 4 * 1024 * 1024)
+      throw new Error("ROOTED_EXECUTION_INPUT_LIMIT");
+    if (options.taskId) this.#recordTaskReceipt(options.taskId);
+    const child = spawn2(
+      options.rootedExecution ? filesystemHelperPath : options.program,
+      options.rootedExecution ? ["--exec"] : options.args,
+      {
+        cwd: options.rootedExecution ? void 0 : options.cwd,
+        env: safeEnvironment(),
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+        // A separate Unix process group lets us terminate descendants too.
+        detached: process.platform !== "win32"
+      }
+    );
+    child.stdin.on("error", () => void 0);
+    child.stdin.end(rootedPayload);
+    const session = {
+      sessionId: randomUUID(),
+      ...options.taskId ? { taskId: options.taskId } : {},
+      program: options.program,
+      args: [...options.args],
+      cwd: options.cwd,
+      child,
+      maxOutputCharacters: options.maxOutputCharacters,
+      stdout: "",
+      stderr: "",
+      running: true,
+      exitCode: null,
+      signal: null,
+      timedOut: false,
+      nextSequence: 0,
+      events: [],
+      retainedEventCharacters: 0,
+      watchers: /* @__PURE__ */ new Set()
+    };
+    this.#sessions.set(session.sessionId, session);
+    if (session.taskId)
+      this.#taskSessions.set(session.taskId, session.sessionId);
+    this.#record(session, "started");
+    child.stdout.on("data", (chunk) => {
+      this.#output(session, "stdout", chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      this.#output(session, "stderr", chunk);
+    });
+    child.once("error", (error62) => {
+      session.stderr = appendBounded(
+        session.stderr,
+        error62.message,
+        session.maxOutputCharacters
+      );
+      session.running = false;
+      session.exitCode = null;
+      session.signal = null;
+      if (session.timeout) clearTimeout(session.timeout);
+    });
+    child.once("close", (exitCode, signal) => {
+      if (session.terminationRequested && session.forceKillTimer && this.#unixProcessGroupExists(session)) {
+        session.pendingTerminationClose = { exitCode, signal };
+        if (session.timeout) clearTimeout(session.timeout);
+        return;
+      }
+      this.#finishSession(session, exitCode, signal);
+    });
+    session.timeout = setTimeout(() => {
+      if (!session.running) return;
+      session.timedOut = true;
+      this.#requestTermination(session);
+    }, options.timeoutMs);
+    const result = snapshot(session);
+    return {
+      ...result,
+      nextStdoutOffset: result.stdout.length,
+      nextStderrOffset: result.stderr.length
+    };
+  }
+  read(sessionId, stdoutOffset, stderrOffset, maxOutputCharacters) {
+    this.#pruneFinished();
+    const session = this.#sessions.get(sessionId);
+    if (!session)
+      throw new Error("The requested process session was not found.");
+    const safeStdoutOffset = Math.max(
+      0,
+      Math.min(stdoutOffset, session.stdout.length)
+    );
+    const safeStderrOffset = Math.max(
+      0,
+      Math.min(stderrOffset, session.stderr.length)
+    );
+    const stdout = session.stdout.slice(
+      safeStdoutOffset,
+      safeStdoutOffset + maxOutputCharacters
+    );
+    const stderr = session.stderr.slice(
+      safeStderrOffset,
+      safeStderrOffset + maxOutputCharacters
+    );
+    return {
+      ...snapshot(session),
+      stdout,
+      stderr,
+      nextStdoutOffset: safeStdoutOffset + stdout.length,
+      nextStderrOffset: safeStderrOffset + stderr.length
+    };
+  }
+  terminate(sessionId) {
+    this.#pruneFinished();
+    const session = this.#sessions.get(sessionId);
+    if (!session)
+      throw new Error("The requested process session was not found.");
+    this.#requestTermination(session);
+    return snapshot(session);
+  }
+  list() {
+    this.#pruneFinished();
+    return [...this.#sessions.values()].map(snapshot);
+  }
+  close() {
+    for (const session of this.#sessions.values()) {
+      if (session.timeout) clearTimeout(session.timeout);
+      this.#requestTermination(session);
+    }
+    for (const session of this.#sessions.values()) {
+      for (const wake of session.watchers) wake();
+    }
+    this.#sessions.clear();
+    this.#taskSessions.clear();
+  }
+};
 
 // src/server.ts
 var roots = configuredRoots();
+var processManager = new ProcessManager();
+var sharedFilesystem;
+function defaultFilesystem() {
+  return sharedFilesystem ??= new RootedFilesystem(roots);
+}
+async function initializeFilesystemBoundary() {
+  await defaultFilesystem().ready;
+}
+function filesystemBoundaryAvailable() {
+  return sharedFilesystem?.available === true;
+}
+async function closeFilesystemBoundary() {
+  await sharedFilesystem?.close();
+}
 function textResult(value) {
   return {
     content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
     structuredContent: value
   };
 }
-function createServer() {
+function createServer(options = {}) {
+  const filesystem = options.filesystem ?? defaultFilesystem();
+  const requireAuthorizedAgent = () => {
+    if (!options.allowDestructive) {
+      throw new Error(
+        "LOCAL_APPROVAL_REQUIRED: Connect through the approved Terminal Commands agent."
+      );
+    }
+  };
   const server = new McpServer(
-    { name: "terminal-commands", version: "0.1.0" },
+    { name: "terminal-commands", version: "0.2.0" },
     {
       instructions: "This server controls the user's machine. Prefer dedicated file tools over commands. Every command and write can modify or expose local data and must receive user approval. Never request secrets or bypass configured roots and safety controls."
     }
@@ -62704,15 +63426,12 @@ function createServer() {
       }
     },
     async ({ path: requestedPath }) => {
-      const directory = await resolveReadablePath(requestedPath, roots);
-      const entries = await readdir(directory, { withFileTypes: true });
+      const directory = filesystem.resolve(requestedPath);
+      const { entries, truncated } = await filesystem.list(directory);
       return textResult({
-        path: directory,
-        entries: entries.slice(0, 1e3).map((entry) => ({
-          name: entry.name,
-          type: entry.isDirectory() ? "directory" : entry.isFile() ? "file" : "other"
-        })),
-        truncated: entries.length > 1e3
+        path: directory.displayPath,
+        entries,
+        truncated
       });
     }
   );
@@ -62737,13 +63456,13 @@ function createServer() {
       }
     },
     async ({ path: requestedPath, maxCharacters }) => {
-      const filename = await resolveReadablePath(requestedPath, roots);
-      const { contents, truncated } = await readBoundedTextFile(
+      const filename = filesystem.resolve(requestedPath);
+      const { contents, truncated } = await filesystem.read(
         filename,
         maxCharacters
       );
       return textResult({
-        path: filename,
+        path: filename.displayPath,
         contents,
         truncated
       });
@@ -62770,23 +63489,26 @@ function createServer() {
       }
     },
     async ({ path: requestedPath, contents, overwrite }) => {
-      const filename = await resolveWritablePath(requestedPath, roots);
-      await writeFile(filename, contents, {
-        encoding: "utf8",
-        flag: overwrite ? "w" : "wx"
-      });
+      requireAuthorizedAgent();
+      const filename = filesystem.resolve(requestedPath);
+      const bytesWritten = await filesystem.write(
+        filename,
+        contents,
+        overwrite
+      );
       return textResult({
-        path: filename,
-        bytesWritten: Buffer.byteLength(contents)
+        path: filename.displayPath,
+        bytesWritten
       });
     }
   );
   server.registerTool(
-    "run_program",
+    "start_process",
     {
-      title: "Run a local program",
-      description: "Run one executable without a shell. Shells and privilege-elevation programs are blocked unless explicitly enabled by local configuration.",
+      title: "Start a process",
+      description: "Start one approved executable without a shell on this machine and return a session ID for reading its output.",
       inputSchema: {
+        taskId: external_exports.string().uuid().optional(),
         program: external_exports.string().min(1),
         args: external_exports.array(external_exports.string()).max(100).default([]),
         cwd: external_exports.string().min(1).optional(),
@@ -62794,14 +63516,20 @@ function createServer() {
         maxOutputCharacters: external_exports.number().int().min(1e3).max(2e5).default(5e4)
       },
       outputSchema: {
+        sessionId: external_exports.string(),
+        taskId: external_exports.string().uuid().optional(),
         program: external_exports.string(),
         args: external_exports.array(external_exports.string()),
         cwd: external_exports.string(),
+        pid: external_exports.number().int().nullable(),
+        running: external_exports.boolean(),
         exitCode: external_exports.number().int().nullable(),
         signal: external_exports.string().nullable(),
         stdout: external_exports.string(),
         stderr: external_exports.string(),
-        timedOut: external_exports.boolean()
+        timedOut: external_exports.boolean(),
+        nextStdoutOffset: external_exports.number().int().nonnegative(),
+        nextStderrOffset: external_exports.number().int().nonnegative()
       },
       annotations: {
         readOnlyHint: false,
@@ -62809,24 +63537,196 @@ function createServer() {
         openWorldHint: true
       }
     },
-    async ({ program, args, cwd, timeoutMs, maxOutputCharacters }) => {
-      const workingDirectory = await resolveReadablePath(
+    async ({ taskId, program, args, cwd, timeoutMs, maxOutputCharacters }) => {
+      requireAuthorizedAgent();
+      const workingDirectory = filesystem.resolve(cwd ?? roots[0]);
+      const rootedExecution = await filesystem.execution(
         cwd ?? roots[0],
-        roots
-      );
-      const result = await runProgram({
         program,
-        args,
-        cwd: workingDirectory,
+        args
+      );
+      return textResult(
+        processManager.start({
+          taskId,
+          program,
+          args,
+          cwd: workingDirectory.displayPath,
+          rootedExecution,
+          timeoutMs,
+          maxOutputCharacters
+        })
+      );
+    }
+  );
+  server.registerTool(
+    "read_process_output",
+    {
+      title: "Read process output",
+      description: "Read new stdout and stderr from a previously started process session.",
+      inputSchema: {
+        sessionId: external_exports.string().uuid(),
+        stdoutOffset: external_exports.number().int().min(0).default(0),
+        stderrOffset: external_exports.number().int().min(0).default(0),
+        maxOutputCharacters: external_exports.number().int().min(1e3).max(2e5).default(5e4)
+      },
+      outputSchema: {
+        sessionId: external_exports.string(),
+        taskId: external_exports.string().uuid().optional(),
+        program: external_exports.string(),
+        args: external_exports.array(external_exports.string()),
+        cwd: external_exports.string(),
+        pid: external_exports.number().int().nullable(),
+        running: external_exports.boolean(),
+        exitCode: external_exports.number().int().nullable(),
+        signal: external_exports.string().nullable(),
+        stdout: external_exports.string(),
+        stderr: external_exports.string(),
+        timedOut: external_exports.boolean(),
+        nextStdoutOffset: external_exports.number().int().nonnegative(),
+        nextStderrOffset: external_exports.number().int().nonnegative()
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({ sessionId, stdoutOffset, stderrOffset, maxOutputCharacters }) => textResult(
+      processManager.read(
+        sessionId,
+        stdoutOffset,
+        stderrOffset,
+        maxOutputCharacters
+      )
+    )
+  );
+  server.registerTool(
+    "watch_process_events",
+    {
+      title: "Watch local process events",
+      description: "Wait for sequenced, bounded process events after a cursor. Used internally by the companion to push progress over WebSocket.",
+      inputSchema: {
+        sessionId: external_exports.string().uuid(),
+        afterSequence: external_exports.number().int().nonnegative().default(0),
+        timeoutMs: external_exports.number().int().min(100).max(2e4).default(1e4),
+        maxEvents: external_exports.number().int().min(1).max(32).default(32)
+      },
+      outputSchema: {
+        sessionId: external_exports.string().uuid(),
+        events: external_exports.array(
+          external_exports.object({
+            sessionId: external_exports.string().uuid(),
+            taskId: external_exports.string().uuid().optional(),
+            sequence: external_exports.number().int().positive(),
+            kind: external_exports.enum(["started", "stdout", "stderr", "finished"]),
+            offset: external_exports.number().int().nonnegative().optional(),
+            data: external_exports.string().max(4096).optional(),
+            exitCode: external_exports.number().int().nullable().optional(),
+            signal: external_exports.string().nullable().optional(),
+            timedOut: external_exports.boolean().optional()
+          })
+        ).max(32),
+        nextSequence: external_exports.number().int().nonnegative(),
+        missedEvents: external_exports.boolean(),
+        finished: external_exports.boolean()
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({ sessionId, afterSequence, timeoutMs, maxEvents }) => textResult(
+      await processManager.watch(
+        sessionId,
+        afterSequence,
         timeoutMs,
-        maxOutputChars: maxOutputCharacters
-      });
-      return textResult({ program, args, cwd: workingDirectory, ...result });
+        maxEvents
+      )
+    )
+  );
+  server.registerTool(
+    "terminate_process",
+    {
+      title: "Terminate a process",
+      description: "Stop a previously started process session on this machine.",
+      inputSchema: { sessionId: external_exports.string().uuid() },
+      outputSchema: {
+        sessionId: external_exports.string(),
+        taskId: external_exports.string().uuid().optional(),
+        program: external_exports.string(),
+        args: external_exports.array(external_exports.string()),
+        cwd: external_exports.string(),
+        pid: external_exports.number().int().nullable(),
+        running: external_exports.boolean(),
+        exitCode: external_exports.number().int().nullable(),
+        signal: external_exports.string().nullable(),
+        stdout: external_exports.string(),
+        stderr: external_exports.string(),
+        timedOut: external_exports.boolean()
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({ sessionId }) => {
+      requireAuthorizedAgent();
+      return textResult(processManager.terminate(sessionId));
     }
   );
+  server.registerTool(
+    "list_processes",
+    {
+      title: "List process sessions",
+      description: "List process sessions started through Terminal Commands.",
+      inputSchema: {},
+      outputSchema: {
+        processes: external_exports.array(
+          external_exports.object({
+            sessionId: external_exports.string(),
+            taskId: external_exports.string().uuid().optional(),
+            program: external_exports.string(),
+            args: external_exports.array(external_exports.string()),
+            cwd: external_exports.string(),
+            pid: external_exports.number().int().nullable(),
+            running: external_exports.boolean(),
+            exitCode: external_exports.number().int().nullable(),
+            signal: external_exports.string().nullable(),
+            stdout: external_exports.string(),
+            stderr: external_exports.string(),
+            timedOut: external_exports.boolean()
+          })
+        )
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async () => textResult({ processes: processManager.list() })
+  );
   return server;
 }
 
+// src/local-agent-auth.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+function isTrustedLocalAgent(presented, expected) {
+  if (!presented || !expected || !/^[a-f0-9]{64}$/i.test(expected))
+    return false;
+  if (!/^[a-f0-9]{64}$/i.test(presented)) return false;
+  const left = Buffer.from(presented, "hex");
+  const right = Buffer.from(expected, "hex");
+  return left.length === right.length && timingSafeEqual(left, right);
+}
+function localHealthProof(secret, challenge) {
+  if (!secret || !/^[a-f0-9]{64}$/i.test(secret)) return null;
+  if (!challenge || !/^[a-f0-9]{64}$/i.test(challenge)) return null;
+  return createHmac("sha256", Buffer.from(secret, "hex")).update(challenge, "ascii").digest("hex");
+}
+
 // src/index.ts
 var host = process.env.MACHINE_TERMINAL_HOST ?? "127.0.0.1";
 var port = Number.parseInt(process.env.MACHINE_TERMINAL_PORT ?? "3333", 10);
@@ -62840,15 +63740,29 @@ if (!localHosts.has(host) && process.env.MACHINE_TERMINAL_ALLOW_PUBLIC_BIND !==
   );
 }
 var app = createMcpExpressApp({ host });
-app.get("/health", (_request, response) => {
-  response.json({
-    status: "ok",
+app.get("/health", (request, response) => {
+  const proof = localHealthProof(
+    process.env.MACHINE_TERMINAL_LOCAL_AGENT_TOKEN,
+    request.header("x-terminal-commands-health-challenge")
+  );
+  const available = filesystemBoundaryAvailable();
+  response.status(available ? 200 : 503).json({
+    status: available ? "ok" : "filesystem_unavailable",
     server: "terminal-commands",
-    version: "0.1.0"
+    version: "0.2.0",
+    ...proof ? { agentProof: proof } : {}
   });
 });
 app.post("/mcp", async (request, response) => {
-  const server = createServer();
+  const authorized = isTrustedLocalAgent(
+    request.header("x-terminal-commands-agent-token"),
+    process.env.MACHINE_TERMINAL_LOCAL_AGENT_TOKEN
+  );
+  if (!authorized) {
+    response.status(401).json({ error: "local_agent_authentication_required" });
+    return;
+  }
+  const server = createServer({ allowDestructive: true });
   const transport = new StreamableHTTPServerTransport({
     sessionIdGenerator: void 0
   });
@@ -62879,11 +63793,14 @@ for (const method of ["get", "delete"]) {
     });
   });
 }
+await initializeFilesystemBoundary();
 var listener = app.listen(port, host, () => {
   console.log(`Terminal Commands MCP listening at http://${host}:${port}/mcp`);
 });
-function shutdown(signal) {
+async function shutdown(signal) {
   console.log(`Received ${signal}; shutting down.`);
+  processManager.close();
+  await closeFilesystemBoundary();
   listener.close((error62) => {
     if (error62) {
       console.error(error62);
@@ -62891,8 +63808,8 @@ function shutdown(signal) {
     }
   });
 }
-process.on("SIGINT", () => shutdown("SIGINT"));
-process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => void shutdown("SIGINT"));
+process.on("SIGTERM", () => void shutdown("SIGTERM"));
 /*! Bundled license information:
 
 depd/index.js: