@xylabs/aries 0.1.1

package/dist/commands/clampRunCommand.mjs

@@ -0,0 +1,2137 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// ../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/utils.js
+var require_utils = __commonJS({
+  "../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadNativeModule = exports.assign = void 0;
+    function assign(target) {
+      var sources = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+      }
+      sources.forEach(function(source) {
+        return Object.keys(source).forEach(function(key) {
+          return target[key] = source[key];
+        });
+      });
+      return target;
+    }
+    exports.assign = assign;
+    function loadNativeModule(name) {
+      var dirs = ["build/Release", "build/Debug", "prebuilds/" + process.platform + "-" + process.arch];
+      var relative = ["..", "."];
+      var lastError;
+      for (var _i = 0, dirs_1 = dirs; _i < dirs_1.length; _i++) {
+        var d = dirs_1[_i];
+        for (var _a = 0, relative_1 = relative; _a < relative_1.length; _a++) {
+          var r = relative_1[_a];
+          var dir = r + "/" + d + "/";
+          try {
+            return { dir, module: __require(dir + "/" + name + ".node") };
+          } catch (e) {
+            lastError = e;
+          }
+        }
+      }
+      throw new Error("Failed to load native module: " + name + ".node, checked: " + dirs.join(", ") + ": " + lastError);
+    }
+    exports.loadNativeModule = loadNativeModule;
+  }
+});
+
+// ../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/eventEmitter2.js
+var require_eventEmitter2 = __commonJS({
+  "../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/eventEmitter2.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EventEmitter2 = void 0;
+    var EventEmitter2 = (
+      /** @class */
+      (function() {
+        function EventEmitter22() {
+          this._listeners = [];
+        }
+        Object.defineProperty(EventEmitter22.prototype, "event", {
+          get: function() {
+            var _this = this;
+            if (!this._event) {
+              this._event = function(listener) {
+                _this._listeners.push(listener);
+                var disposable = {
+                  dispose: function() {
+                    for (var i = 0; i < _this._listeners.length; i++) {
+                      if (_this._listeners[i] === listener) {
+                        _this._listeners.splice(i, 1);
+                        return;
+                      }
+                    }
+                  }
+                };
+                return disposable;
+              };
+            }
+            return this._event;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        EventEmitter22.prototype.fire = function(data) {
+          var queue = [];
+          for (var i = 0; i < this._listeners.length; i++) {
+            queue.push(this._listeners[i]);
+          }
+          for (var i = 0; i < queue.length; i++) {
+            queue[i].call(void 0, data);
+          }
+        };
+        return EventEmitter22;
+      })()
+    );
+    exports.EventEmitter2 = EventEmitter2;
+  }
+});
+
+// ../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/terminal.js
+var require_terminal = __commonJS({
+  "../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/terminal.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Terminal = exports.DEFAULT_ROWS = exports.DEFAULT_COLS = void 0;
+    var events_1 = __require("events");
+    var eventEmitter2_1 = require_eventEmitter2();
+    exports.DEFAULT_COLS = 80;
+    exports.DEFAULT_ROWS = 24;
+    var FLOW_CONTROL_PAUSE = "";
+    var FLOW_CONTROL_RESUME = "";
+    var Terminal2 = (
+      /** @class */
+      (function() {
+        function Terminal3(opt) {
+          this._pid = 0;
+          this._fd = 0;
+          this._cols = 0;
+          this._rows = 0;
+          this._readable = false;
+          this._writable = false;
+          this._onData = new eventEmitter2_1.EventEmitter2();
+          this._onExit = new eventEmitter2_1.EventEmitter2();
+          this._internalee = new events_1.EventEmitter();
+          this.handleFlowControl = !!(opt === null || opt === void 0 ? void 0 : opt.handleFlowControl);
+          this._flowControlPause = (opt === null || opt === void 0 ? void 0 : opt.flowControlPause) || FLOW_CONTROL_PAUSE;
+          this._flowControlResume = (opt === null || opt === void 0 ? void 0 : opt.flowControlResume) || FLOW_CONTROL_RESUME;
+          if (!opt) {
+            return;
+          }
+          this._checkType("name", opt.name ? opt.name : void 0, "string");
+          this._checkType("cols", opt.cols ? opt.cols : void 0, "number");
+          this._checkType("rows", opt.rows ? opt.rows : void 0, "number");
+          this._checkType("cwd", opt.cwd ? opt.cwd : void 0, "string");
+          this._checkType("env", opt.env ? opt.env : void 0, "object");
+          this._checkType("uid", opt.uid ? opt.uid : void 0, "number");
+          this._checkType("gid", opt.gid ? opt.gid : void 0, "number");
+          this._checkType("encoding", opt.encoding ? opt.encoding : void 0, "string");
+        }
+        Object.defineProperty(Terminal3.prototype, "onData", {
+          get: function() {
+            return this._onData.event;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(Terminal3.prototype, "onExit", {
+          get: function() {
+            return this._onExit.event;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(Terminal3.prototype, "pid", {
+          get: function() {
+            return this._pid;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(Terminal3.prototype, "cols", {
+          get: function() {
+            return this._cols;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(Terminal3.prototype, "rows", {
+          get: function() {
+            return this._rows;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Terminal3.prototype.write = function(data) {
+          if (this.handleFlowControl) {
+            if (data === this._flowControlPause) {
+              this.pause();
+              return;
+            }
+            if (data === this._flowControlResume) {
+              this.resume();
+              return;
+            }
+          }
+          this._write(data);
+        };
+        Terminal3.prototype._forwardEvents = function() {
+          var _this = this;
+          this.on("data", function(e) {
+            return _this._onData.fire(e);
+          });
+          this.on("exit", function(exitCode, signal) {
+            return _this._onExit.fire({ exitCode, signal });
+          });
+        };
+        Terminal3.prototype._checkType = function(name, value, type, allowArray) {
+          if (allowArray === void 0) {
+            allowArray = false;
+          }
+          if (value === void 0) {
+            return;
+          }
+          if (allowArray) {
+            if (Array.isArray(value)) {
+              value.forEach(function(v, i) {
+                if (typeof v !== type) {
+                  throw new Error(name + "[" + i + "] must be a " + type + " (not a " + typeof v[i] + ")");
+                }
+              });
+              return;
+            }
+          }
+          if (typeof value !== type) {
+            throw new Error(name + " must be a " + type + " (not a " + typeof value + ")");
+          }
+        };
+        Terminal3.prototype.end = function(data) {
+          this._socket.end(data);
+        };
+        Terminal3.prototype.pipe = function(dest, options) {
+          return this._socket.pipe(dest, options);
+        };
+        Terminal3.prototype.pause = function() {
+          return this._socket.pause();
+        };
+        Terminal3.prototype.resume = function() {
+          return this._socket.resume();
+        };
+        Terminal3.prototype.setEncoding = function(encoding) {
+          if (this._socket._decoder) {
+            delete this._socket._decoder;
+          }
+          if (encoding) {
+            this._socket.setEncoding(encoding);
+          }
+        };
+        Terminal3.prototype.addListener = function(eventName, listener) {
+          this.on(eventName, listener);
+        };
+        Terminal3.prototype.on = function(eventName, listener) {
+          if (eventName === "close") {
+            this._internalee.on("close", listener);
+            return;
+          }
+          this._socket.on(eventName, listener);
+        };
+        Terminal3.prototype.emit = function(eventName) {
+          var args = [];
+          for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+          }
+          if (eventName === "close") {
+            return this._internalee.emit.apply(this._internalee, arguments);
+          }
+          return this._socket.emit.apply(this._socket, arguments);
+        };
+        Terminal3.prototype.listeners = function(eventName) {
+          return this._socket.listeners(eventName);
+        };
+        Terminal3.prototype.removeListener = function(eventName, listener) {
+          this._socket.removeListener(eventName, listener);
+        };
+        Terminal3.prototype.removeAllListeners = function(eventName) {
+          this._socket.removeAllListeners(eventName);
+        };
+        Terminal3.prototype.once = function(eventName, listener) {
+          this._socket.once(eventName, listener);
+        };
+        Terminal3.prototype._close = function() {
+          this._socket.readable = false;
+          this.write = function() {
+          };
+          this.end = function() {
+          };
+          this._writable = false;
+          this._readable = false;
+        };
+        Terminal3.prototype._parseEnv = function(env) {
+          var keys = Object.keys(env || {});
+          var pairs = [];
+          for (var i = 0; i < keys.length; i++) {
+            if (keys[i] === void 0) {
+              continue;
+            }
+            pairs.push(keys[i] + "=" + env[keys[i]]);
+          }
+          return pairs;
+        };
+        return Terminal3;
+      })()
+    );
+    exports.Terminal = Terminal2;
+  }
+});
+
+// ../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/shared/conout.js
+var require_conout = __commonJS({
+  "../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/shared/conout.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getWorkerPipeName = void 0;
+    function getWorkerPipeName(conoutPipeName) {
+      return conoutPipeName + "-worker";
+    }
+    exports.getWorkerPipeName = getWorkerPipeName;
+  }
+});
+
+// ../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/windowsConoutConnection.js
+var require_windowsConoutConnection = __commonJS({
+  "../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/windowsConoutConnection.js"(exports) {
+    "use strict";
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ConoutConnection = void 0;
+    var worker_threads_1 = __require("worker_threads");
+    var conout_1 = require_conout();
+    var path_1 = __require("path");
+    var eventEmitter2_1 = require_eventEmitter2();
+    var FLUSH_DATA_INTERVAL = 1e3;
+    var ConoutConnection = (
+      /** @class */
+      (function() {
+        function ConoutConnection2(_conoutPipeName, _useConptyDll) {
+          var _this = this;
+          this._conoutPipeName = _conoutPipeName;
+          this._useConptyDll = _useConptyDll;
+          this._isDisposed = false;
+          this._onReady = new eventEmitter2_1.EventEmitter2();
+          var workerData = {
+            conoutPipeName: _conoutPipeName
+          };
+          var scriptPath = __dirname.replace("node_modules.asar", "node_modules.asar.unpacked");
+          this._worker = new worker_threads_1.Worker(path_1.join(scriptPath, "worker/conoutSocketWorker.js"), { workerData });
+          this._worker.on("message", function(message) {
+            switch (message) {
+              case 1:
+                _this._onReady.fire();
+                return;
+              default:
+                console.warn("Unexpected ConoutWorkerMessage", message);
+            }
+          });
+        }
+        Object.defineProperty(ConoutConnection2.prototype, "onReady", {
+          get: function() {
+            return this._onReady.event;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        ConoutConnection2.prototype.dispose = function() {
+          if (!this._useConptyDll && this._isDisposed) {
+            return;
+          }
+          this._isDisposed = true;
+          this._drainDataAndClose();
+        };
+        ConoutConnection2.prototype.connectSocket = function(socket) {
+          socket.connect(conout_1.getWorkerPipeName(this._conoutPipeName));
+        };
+        ConoutConnection2.prototype._drainDataAndClose = function() {
+          var _this = this;
+          if (this._drainTimeout) {
+            clearTimeout(this._drainTimeout);
+          }
+          this._drainTimeout = setTimeout(function() {
+            return _this._destroySocket();
+          }, FLUSH_DATA_INTERVAL);
+        };
+        ConoutConnection2.prototype._destroySocket = function() {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              switch (_a.label) {
+                case 0:
+                  return [4, this._worker.terminate()];
+                case 1:
+                  _a.sent();
+                  return [
+                    2
+                    /*return*/
+                  ];
+              }
+            });
+          });
+        };
+        return ConoutConnection2;
+      })()
+    );
+    exports.ConoutConnection = ConoutConnection;
+  }
+});
+
+// ../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/windowsPtyAgent.js
+var require_windowsPtyAgent = __commonJS({
+  "../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/windowsPtyAgent.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.argsToCommandLine = exports.WindowsPtyAgent = void 0;
+    var fs = __require("fs");
+    var os = __require("os");
+    var path5 = __require("path");
+    var child_process_1 = __require("child_process");
+    var net_1 = __require("net");
+    var windowsConoutConnection_1 = require_windowsConoutConnection();
+    var utils_1 = require_utils();
+    var conptyNative;
+    var winptyNative;
+    var FLUSH_DATA_INTERVAL = 1e3;
+    var WindowsPtyAgent = (
+      /** @class */
+      (function() {
+        function WindowsPtyAgent2(file, args, env, cwd, cols, rows, debug, _useConpty, _useConptyDll, conptyInheritCursor) {
+          var _this = this;
+          if (_useConptyDll === void 0) {
+            _useConptyDll = false;
+          }
+          if (conptyInheritCursor === void 0) {
+            conptyInheritCursor = false;
+          }
+          this._useConpty = _useConpty;
+          this._useConptyDll = _useConptyDll;
+          this._pid = 0;
+          this._innerPid = 0;
+          if (this._useConpty === void 0 || this._useConpty === true) {
+            this._useConpty = this._getWindowsBuildNumber() >= 18309;
+          }
+          if (this._useConpty) {
+            if (!conptyNative) {
+              conptyNative = utils_1.loadNativeModule("conpty").module;
+            }
+          } else {
+            if (!winptyNative) {
+              winptyNative = utils_1.loadNativeModule("pty").module;
+            }
+          }
+          this._ptyNative = this._useConpty ? conptyNative : winptyNative;
+          cwd = path5.resolve(cwd);
+          var commandLine = argsToCommandLine(file, args);
+          var term;
+          if (this._useConpty) {
+            term = this._ptyNative.startProcess(file, cols, rows, debug, this._generatePipeName(), conptyInheritCursor, this._useConptyDll);
+          } else {
+            term = this._ptyNative.startProcess(file, commandLine, env, cwd, cols, rows, debug);
+            this._pid = term.pid;
+            this._innerPid = term.innerPid;
+          }
+          this._fd = term.fd;
+          this._pty = term.pty;
+          this._outSocket = new net_1.Socket();
+          this._outSocket.setEncoding("utf8");
+          this._conoutSocketWorker = new windowsConoutConnection_1.ConoutConnection(term.conout, this._useConptyDll);
+          this._conoutSocketWorker.onReady(function() {
+            _this._conoutSocketWorker.connectSocket(_this._outSocket);
+          });
+          this._outSocket.on("connect", function() {
+            _this._outSocket.emit("ready_datapipe");
+          });
+          var inSocketFD = fs.openSync(term.conin, "w");
+          this._inSocket = new net_1.Socket({
+            fd: inSocketFD,
+            readable: false,
+            writable: true
+          });
+          this._inSocket.setEncoding("utf8");
+          if (this._useConpty) {
+            var connect = this._ptyNative.connect(this._pty, commandLine, cwd, env, this._useConptyDll, function(c) {
+              return _this._$onProcessExit(c);
+            });
+            this._innerPid = connect.pid;
+          }
+        }
+        Object.defineProperty(WindowsPtyAgent2.prototype, "inSocket", {
+          get: function() {
+            return this._inSocket;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(WindowsPtyAgent2.prototype, "outSocket", {
+          get: function() {
+            return this._outSocket;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(WindowsPtyAgent2.prototype, "fd", {
+          get: function() {
+            return this._fd;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(WindowsPtyAgent2.prototype, "innerPid", {
+          get: function() {
+            return this._innerPid;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(WindowsPtyAgent2.prototype, "pty", {
+          get: function() {
+            return this._pty;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        WindowsPtyAgent2.prototype.resize = function(cols, rows) {
+          if (this._useConpty) {
+            if (this._exitCode !== void 0) {
+              throw new Error("Cannot resize a pty that has already exited");
+            }
+            this._ptyNative.resize(this._pty, cols, rows, this._useConptyDll);
+            return;
+          }
+          this._ptyNative.resize(this._pid, cols, rows);
+        };
+        WindowsPtyAgent2.prototype.clear = function() {
+          if (this._useConpty) {
+            this._ptyNative.clear(this._pty, this._useConptyDll);
+          }
+        };
+        WindowsPtyAgent2.prototype.kill = function() {
+          var _this = this;
+          if (this._useConpty) {
+            if (!this._useConptyDll) {
+              this._inSocket.readable = false;
+              this._outSocket.readable = false;
+              this._getConsoleProcessList().then(function(consoleProcessList) {
+                consoleProcessList.forEach(function(pid) {
+                  try {
+                    process.kill(pid);
+                  } catch (e) {
+                  }
+                });
+              });
+              this._ptyNative.kill(this._pty, this._useConptyDll);
+              this._conoutSocketWorker.dispose();
+            } else {
+              this._inSocket.destroy();
+              this._ptyNative.kill(this._pty, this._useConptyDll);
+              this._outSocket.on("data", function() {
+                _this._conoutSocketWorker.dispose();
+              });
+            }
+          } else {
+            var processList = this._ptyNative.getProcessList(this._pid);
+            this._ptyNative.kill(this._pid, this._innerPid);
+            processList.forEach(function(pid) {
+              try {
+                process.kill(pid);
+              } catch (e) {
+              }
+            });
+          }
+        };
+        WindowsPtyAgent2.prototype._getConsoleProcessList = function() {
+          var _this = this;
+          return new Promise(function(resolve) {
+            var agent = child_process_1.fork(path5.join(__dirname, "conpty_console_list_agent"), [_this._innerPid.toString()]);
+            agent.on("message", function(message) {
+              clearTimeout(timeout);
+              resolve(message.consoleProcessList);
+            });
+            var timeout = setTimeout(function() {
+              agent.kill();
+              resolve([_this._innerPid]);
+            }, 5e3);
+          });
+        };
+        Object.defineProperty(WindowsPtyAgent2.prototype, "exitCode", {
+          get: function() {
+            if (this._useConpty) {
+              return this._exitCode;
+            }
+            var winptyExitCode = this._ptyNative.getExitCode(this._innerPid);
+            return winptyExitCode === -1 ? void 0 : winptyExitCode;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        WindowsPtyAgent2.prototype._getWindowsBuildNumber = function() {
+          var osVersion = /(\d+)\.(\d+)\.(\d+)/g.exec(os.release());
+          var buildNumber = 0;
+          if (osVersion && osVersion.length === 4) {
+            buildNumber = parseInt(osVersion[3]);
+          }
+          return buildNumber;
+        };
+        WindowsPtyAgent2.prototype._generatePipeName = function() {
+          return "conpty-" + Math.random() * 1e7;
+        };
+        WindowsPtyAgent2.prototype._$onProcessExit = function(exitCode) {
+          var _this = this;
+          this._exitCode = exitCode;
+          if (!this._useConptyDll) {
+            this._flushDataAndCleanUp();
+            this._outSocket.on("data", function() {
+              return _this._flushDataAndCleanUp();
+            });
+          }
+        };
+        WindowsPtyAgent2.prototype._flushDataAndCleanUp = function() {
+          var _this = this;
+          if (this._useConptyDll) {
+            return;
+          }
+          if (this._closeTimeout) {
+            clearTimeout(this._closeTimeout);
+          }
+          this._closeTimeout = setTimeout(function() {
+            return _this._cleanUpProcess();
+          }, FLUSH_DATA_INTERVAL);
+        };
+        WindowsPtyAgent2.prototype._cleanUpProcess = function() {
+          if (this._useConptyDll) {
+            return;
+          }
+          this._inSocket.readable = false;
+          this._outSocket.readable = false;
+          this._outSocket.destroy();
+        };
+        return WindowsPtyAgent2;
+      })()
+    );
+    exports.WindowsPtyAgent = WindowsPtyAgent;
+    function argsToCommandLine(file, args) {
+      if (isCommandLine(args)) {
+        if (args.length === 0) {
+          return file;
+        }
+        return argsToCommandLine(file, []) + " " + args;
+      }
+      var argv = [file];
+      Array.prototype.push.apply(argv, args);
+      var result = "";
+      for (var argIndex = 0; argIndex < argv.length; argIndex++) {
+        if (argIndex > 0) {
+          result += " ";
+        }
+        var arg = argv[argIndex];
+        var hasLopsidedEnclosingQuote = xOr(arg[0] !== '"', arg[arg.length - 1] !== '"');
+        var hasNoEnclosingQuotes = arg[0] !== '"' && arg[arg.length - 1] !== '"';
+        var quote = arg === "" || (arg.indexOf(" ") !== -1 || arg.indexOf("	") !== -1) && (arg.length > 1 && (hasLopsidedEnclosingQuote || hasNoEnclosingQuotes));
+        if (quote) {
+          result += '"';
+        }
+        var bsCount = 0;
+        for (var i = 0; i < arg.length; i++) {
+          var p = arg[i];
+          if (p === "\\") {
+            bsCount++;
+          } else if (p === '"') {
+            result += repeatText("\\", bsCount * 2 + 1);
+            result += '"';
+            bsCount = 0;
+          } else {
+            result += repeatText("\\", bsCount);
+            bsCount = 0;
+            result += p;
+          }
+        }
+        if (quote) {
+          result += repeatText("\\", bsCount * 2);
+          result += '"';
+        } else {
+          result += repeatText("\\", bsCount);
+        }
+      }
+      return result;
+    }
+    exports.argsToCommandLine = argsToCommandLine;
+    function isCommandLine(args) {
+      return typeof args === "string";
+    }
+    function repeatText(text, count) {
+      var result = "";
+      for (var i = 0; i < count; i++) {
+        result += text;
+      }
+      return result;
+    }
+    function xOr(arg1, arg2) {
+      return arg1 && !arg2 || !arg1 && arg2;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/windowsTerminal.js
+var require_windowsTerminal = __commonJS({
+  "../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/windowsTerminal.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.WindowsTerminal = void 0;
+    var terminal_1 = require_terminal();
+    var windowsPtyAgent_1 = require_windowsPtyAgent();
+    var utils_1 = require_utils();
+    var DEFAULT_FILE = "cmd.exe";
+    var DEFAULT_NAME = "Windows Shell";
+    var WindowsTerminal = (
+      /** @class */
+      (function(_super) {
+        __extends(WindowsTerminal2, _super);
+        function WindowsTerminal2(file, args, opt) {
+          var _this = _super.call(this, opt) || this;
+          _this._checkType("args", args, "string", true);
+          args = args || [];
+          file = file || DEFAULT_FILE;
+          opt = opt || {};
+          opt.env = opt.env || process.env;
+          if (opt.encoding) {
+            console.warn("Setting encoding on Windows is not supported");
+          }
+          var env = utils_1.assign({}, opt.env);
+          _this._cols = opt.cols || terminal_1.DEFAULT_COLS;
+          _this._rows = opt.rows || terminal_1.DEFAULT_ROWS;
+          var cwd = opt.cwd || process.cwd();
+          var name = opt.name || env.TERM || DEFAULT_NAME;
+          var parsedEnv = _this._parseEnv(env);
+          _this._isReady = false;
+          _this._deferreds = [];
+          _this._agent = new windowsPtyAgent_1.WindowsPtyAgent(file, args, parsedEnv, cwd, _this._cols, _this._rows, false, opt.useConpty, opt.useConptyDll, opt.conptyInheritCursor);
+          _this._socket = _this._agent.outSocket;
+          _this._pid = _this._agent.innerPid;
+          _this._fd = _this._agent.fd;
+          _this._pty = _this._agent.pty;
+          _this._socket.on("ready_datapipe", function() {
+            _this._socket.once("data", function() {
+              if (!_this._isReady) {
+                _this._isReady = true;
+                _this._deferreds.forEach(function(fn) {
+                  fn.run();
+                });
+                _this._deferreds = [];
+              }
+            });
+            _this._socket.on("error", function(err) {
+              _this._close();
+              if (err.code) {
+                if (~err.code.indexOf("errno 5") || ~err.code.indexOf("EIO"))
+                  return;
+              }
+              if (_this.listeners("error").length < 2) {
+                throw err;
+              }
+            });
+            _this._socket.on("close", function() {
+              _this.emit("exit", _this._agent.exitCode);
+              _this._close();
+            });
+          });
+          _this._file = file;
+          _this._name = name;
+          _this._readable = true;
+          _this._writable = true;
+          _this._forwardEvents();
+          return _this;
+        }
+        WindowsTerminal2.prototype._write = function(data) {
+          this._defer(this._doWrite, data);
+        };
+        WindowsTerminal2.prototype._doWrite = function(data) {
+          this._agent.inSocket.write(data);
+        };
+        WindowsTerminal2.open = function(options) {
+          throw new Error("open() not supported on windows, use Fork() instead.");
+        };
+        WindowsTerminal2.prototype.resize = function(cols, rows) {
+          var _this = this;
+          if (cols <= 0 || rows <= 0 || isNaN(cols) || isNaN(rows) || cols === Infinity || rows === Infinity) {
+            throw new Error("resizing must be done using positive cols and rows");
+          }
+          this._deferNoArgs(function() {
+            _this._agent.resize(cols, rows);
+            _this._cols = cols;
+            _this._rows = rows;
+          });
+        };
+        WindowsTerminal2.prototype.clear = function() {
+          var _this = this;
+          this._deferNoArgs(function() {
+            _this._agent.clear();
+          });
+        };
+        WindowsTerminal2.prototype.destroy = function() {
+          var _this = this;
+          this._deferNoArgs(function() {
+            _this.kill();
+          });
+        };
+        WindowsTerminal2.prototype.kill = function(signal) {
+          var _this = this;
+          this._deferNoArgs(function() {
+            if (signal) {
+              throw new Error("Signals not supported on windows.");
+            }
+            _this._close();
+            _this._agent.kill();
+          });
+        };
+        WindowsTerminal2.prototype._deferNoArgs = function(deferredFn) {
+          var _this = this;
+          if (this._isReady) {
+            deferredFn.call(this);
+            return;
+          }
+          this._deferreds.push({
+            run: function() {
+              return deferredFn.call(_this);
+            }
+          });
+        };
+        WindowsTerminal2.prototype._defer = function(deferredFn, arg) {
+          var _this = this;
+          if (this._isReady) {
+            deferredFn.call(this, arg);
+            return;
+          }
+          this._deferreds.push({
+            run: function() {
+              return deferredFn.call(_this, arg);
+            }
+          });
+        };
+        Object.defineProperty(WindowsTerminal2.prototype, "process", {
+          get: function() {
+            return this._name;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(WindowsTerminal2.prototype, "master", {
+          get: function() {
+            throw new Error("master is not supported on Windows");
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(WindowsTerminal2.prototype, "slave", {
+          get: function() {
+            throw new Error("slave is not supported on Windows");
+          },
+          enumerable: false,
+          configurable: true
+        });
+        return WindowsTerminal2;
+      })(terminal_1.Terminal)
+    );
+    exports.WindowsTerminal = WindowsTerminal;
+  }
+});
+
+// ../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/unixTerminal.js
+var require_unixTerminal = __commonJS({
+  "../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/unixTerminal.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.UnixTerminal = void 0;
+    var fs = __require("fs");
+    var path5 = __require("path");
+    var tty = __require("tty");
+    var terminal_1 = require_terminal();
+    var utils_1 = require_utils();
+    var native = utils_1.loadNativeModule("pty");
+    var pty = native.module;
+    var helperPath = native.dir + "/spawn-helper";
+    helperPath = path5.resolve(__dirname, helperPath);
+    helperPath = helperPath.replace("app.asar", "app.asar.unpacked");
+    helperPath = helperPath.replace("node_modules.asar", "node_modules.asar.unpacked");
+    var DEFAULT_FILE = "sh";
+    var DEFAULT_NAME = "xterm";
+    var DESTROY_SOCKET_TIMEOUT_MS = 200;
+    var UnixTerminal = (
+      /** @class */
+      (function(_super) {
+        __extends(UnixTerminal2, _super);
+        function UnixTerminal2(file, args, opt) {
+          var _a, _b;
+          var _this = _super.call(this, opt) || this;
+          _this._boundClose = false;
+          _this._emittedClose = false;
+          if (typeof args === "string") {
+            throw new Error("args as a string is not supported on unix.");
+          }
+          args = args || [];
+          file = file || DEFAULT_FILE;
+          opt = opt || {};
+          opt.env = opt.env || process.env;
+          _this._cols = opt.cols || terminal_1.DEFAULT_COLS;
+          _this._rows = opt.rows || terminal_1.DEFAULT_ROWS;
+          var uid = (_a = opt.uid) !== null && _a !== void 0 ? _a : -1;
+          var gid = (_b = opt.gid) !== null && _b !== void 0 ? _b : -1;
+          var env = utils_1.assign({}, opt.env);
+          if (opt.env === process.env) {
+            _this._sanitizeEnv(env);
+          }
+          var cwd = opt.cwd || process.cwd();
+          env.PWD = cwd;
+          var name = opt.name || env.TERM || DEFAULT_NAME;
+          env.TERM = name;
+          var parsedEnv = _this._parseEnv(env);
+          var encoding = opt.encoding === void 0 ? "utf8" : opt.encoding;
+          var onexit = function(code, signal) {
+            if (!_this._emittedClose) {
+              if (_this._boundClose) {
+                return;
+              }
+              _this._boundClose = true;
+              var timeout_1 = setTimeout(function() {
+                timeout_1 = null;
+                _this._socket.destroy();
+              }, DESTROY_SOCKET_TIMEOUT_MS);
+              _this.once("close", function() {
+                if (timeout_1 !== null) {
+                  clearTimeout(timeout_1);
+                }
+                _this.emit("exit", code, signal);
+              });
+              return;
+            }
+            _this.emit("exit", code, signal);
+          };
+          var term = pty.fork(file, args, parsedEnv, cwd, _this._cols, _this._rows, uid, gid, encoding === "utf8", helperPath, onexit);
+          _this._socket = new tty.ReadStream(term.fd);
+          if (encoding !== null) {
+            _this._socket.setEncoding(encoding);
+          }
+          _this._writeStream = new CustomWriteStream(term.fd, encoding || void 0);
+          _this._socket.on("error", function(err) {
+            if (err.code) {
+              if (~err.code.indexOf("EAGAIN")) {
+                return;
+              }
+            }
+            _this._close();
+            if (!_this._emittedClose) {
+              _this._emittedClose = true;
+              _this.emit("close");
+            }
+            if (err.code) {
+              if (~err.code.indexOf("errno 5") || ~err.code.indexOf("EIO")) {
+                return;
+              }
+            }
+            if (_this.listeners("error").length < 2) {
+              throw err;
+            }
+          });
+          _this._pid = term.pid;
+          _this._fd = term.fd;
+          _this._pty = term.pty;
+          _this._file = file;
+          _this._name = name;
+          _this._readable = true;
+          _this._writable = true;
+          _this._socket.on("close", function() {
+            if (_this._emittedClose) {
+              return;
+            }
+            _this._emittedClose = true;
+            _this._close();
+            _this.emit("close");
+          });
+          _this._forwardEvents();
+          return _this;
+        }
+        Object.defineProperty(UnixTerminal2.prototype, "master", {
+          get: function() {
+            return this._master;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(UnixTerminal2.prototype, "slave", {
+          get: function() {
+            return this._slave;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        UnixTerminal2.prototype._write = function(data) {
+          this._writeStream.write(data);
+        };
+        Object.defineProperty(UnixTerminal2.prototype, "fd", {
+          /* Accessors */
+          get: function() {
+            return this._fd;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(UnixTerminal2.prototype, "ptsName", {
+          get: function() {
+            return this._pty;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        UnixTerminal2.open = function(opt) {
+          var self = Object.create(UnixTerminal2.prototype);
+          opt = opt || {};
+          if (arguments.length > 1) {
+            opt = {
+              cols: arguments[1],
+              rows: arguments[2]
+            };
+          }
+          var cols = opt.cols || terminal_1.DEFAULT_COLS;
+          var rows = opt.rows || terminal_1.DEFAULT_ROWS;
+          var encoding = opt.encoding === void 0 ? "utf8" : opt.encoding;
+          var term = pty.open(cols, rows);
+          self._master = new tty.ReadStream(term.master);
+          if (encoding !== null) {
+            self._master.setEncoding(encoding);
+          }
+          self._master.resume();
+          self._slave = new tty.ReadStream(term.slave);
+          if (encoding !== null) {
+            self._slave.setEncoding(encoding);
+          }
+          self._slave.resume();
+          self._socket = self._master;
+          self._pid = -1;
+          self._fd = term.master;
+          self._pty = term.pty;
+          self._file = process.argv[0] || "node";
+          self._name = process.env.TERM || "";
+          self._readable = true;
+          self._writable = true;
+          self._socket.on("error", function(err) {
+            self._close();
+            if (self.listeners("error").length < 2) {
+              throw err;
+            }
+          });
+          self._socket.on("close", function() {
+            self._close();
+          });
+          return self;
+        };
+        UnixTerminal2.prototype.destroy = function() {
+          var _this = this;
+          this._close();
+          this._socket.once("close", function() {
+            _this.kill("SIGHUP");
+          });
+          this._socket.destroy();
+          this._writeStream.dispose();
+        };
+        UnixTerminal2.prototype.kill = function(signal) {
+          try {
+            process.kill(this.pid, signal || "SIGHUP");
+          } catch (e) {
+          }
+        };
+        Object.defineProperty(UnixTerminal2.prototype, "process", {
+          /**
+           * Gets the name of the process.
+           */
+          get: function() {
+            if (process.platform === "darwin") {
+              var title = pty.process(this._fd);
+              return title !== "kernel_task" ? title : this._file;
+            }
+            return pty.process(this._fd, this._pty) || this._file;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        UnixTerminal2.prototype.resize = function(cols, rows) {
+          if (cols <= 0 || rows <= 0 || isNaN(cols) || isNaN(rows) || cols === Infinity || rows === Infinity) {
+            throw new Error("resizing must be done using positive cols and rows");
+          }
+          pty.resize(this._fd, cols, rows);
+          this._cols = cols;
+          this._rows = rows;
+        };
+        UnixTerminal2.prototype.clear = function() {
+        };
+        UnixTerminal2.prototype._sanitizeEnv = function(env) {
+          delete env["TMUX"];
+          delete env["TMUX_PANE"];
+          delete env["STY"];
+          delete env["WINDOW"];
+          delete env["WINDOWID"];
+          delete env["TERMCAP"];
+          delete env["COLUMNS"];
+          delete env["LINES"];
+        };
+        return UnixTerminal2;
+      })(terminal_1.Terminal)
+    );
+    exports.UnixTerminal = UnixTerminal;
+    var CustomWriteStream = (
+      /** @class */
+      (function() {
+        function CustomWriteStream2(_fd, _encoding) {
+          this._fd = _fd;
+          this._encoding = _encoding;
+          this._writeQueue = [];
+        }
+        CustomWriteStream2.prototype.dispose = function() {
+          clearImmediate(this._writeImmediate);
+          this._writeImmediate = void 0;
+        };
+        CustomWriteStream2.prototype.write = function(data) {
+          var buffer = typeof data === "string" ? Buffer.from(data, this._encoding) : Buffer.from(data);
+          if (buffer.byteLength !== 0) {
+            this._writeQueue.push({ buffer, offset: 0 });
+            if (this._writeQueue.length === 1) {
+              this._processWriteQueue();
+            }
+          }
+        };
+        CustomWriteStream2.prototype._processWriteQueue = function() {
+          var _this = this;
+          this._writeImmediate = void 0;
+          if (this._writeQueue.length === 0) {
+            return;
+          }
+          var task = this._writeQueue[0];
+          fs.write(this._fd, task.buffer, task.offset, function(err, written) {
+            if (err) {
+              if ("code" in err && err.code === "EAGAIN") {
+                _this._writeImmediate = setImmediate(function() {
+                  return _this._processWriteQueue();
+                });
+              } else {
+                _this._writeQueue.length = 0;
+                console.error("Unhandled pty write error", err);
+              }
+              return;
+            }
+            task.offset += written;
+            if (task.offset >= task.buffer.byteLength) {
+              _this._writeQueue.shift();
+            }
+            _this._processWriteQueue();
+          });
+        };
+        return CustomWriteStream2;
+      })()
+    );
+  }
+});
+
+// ../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.native = exports.open = exports.createTerminal = exports.fork = exports.spawn = void 0;
+    var utils_1 = require_utils();
+    var terminalCtor;
+    if (process.platform === "win32") {
+      terminalCtor = require_windowsTerminal().WindowsTerminal;
+    } else {
+      terminalCtor = require_unixTerminal().UnixTerminal;
+    }
+    function spawn2(file, args, opt) {
+      return new terminalCtor(file, args, opt);
+    }
+    exports.spawn = spawn2;
+    function fork(file, args, opt) {
+      return new terminalCtor(file, args, opt);
+    }
+    exports.fork = fork;
+    function createTerminal(file, args, opt) {
+      return new terminalCtor(file, args, opt);
+    }
+    exports.createTerminal = createTerminal;
+    function open(options) {
+      return terminalCtor.open(options);
+    }
+    exports.open = open;
+    exports.native = process.platform !== "win32" ? utils_1.loadNativeModule("pty").module : null;
+  }
+});
+
+// src/actions/clamp/clampAudit.ts
+import { writeAuditEntry } from "@xylabs/aries-audit-core";
+import { CLAMP_AUDIT_SCHEMA } from "@xylabs/aries-clamp-core";
+function logClampPermission(options) {
+  writeAuditEntry({
+    ai: { product: "clamp", provider: "aries" },
+    client: { name: "@xylabs/aries", version: "0.1.0" },
+    cwd: process.cwd(),
+    data: {
+      args: options.args,
+      command: options.command,
+      decision: options.decision,
+      policy: options.policy.name
+    },
+    event: "ClampPermission",
+    schema: CLAMP_AUDIT_SCHEMA,
+    sessionId: options.sessionId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function logClampStart(options) {
+  writeAuditEntry({
+    ai: { product: "clamp", provider: "aries" },
+    client: { name: "@xylabs/aries", version: "0.1.0" },
+    cwd: process.cwd(),
+    data: {
+      command: options.command,
+      policy: options.policy.name
+    },
+    event: "ClampStart",
+    schema: CLAMP_AUDIT_SCHEMA,
+    sessionId: options.sessionId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function logClampStop(options) {
+  writeAuditEntry({
+    ai: { product: "clamp", provider: "aries" },
+    client: { name: "@xylabs/aries", version: "0.1.0" },
+    cwd: process.cwd(),
+    data: { exitCode: options.exitCode },
+    event: "ClampStop",
+    schema: CLAMP_AUDIT_SCHEMA,
+    sessionId: options.sessionId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+
+// src/actions/clamp/ipcServer.ts
+import {
+  createServer
+} from "net";
+function createIpcServer(options) {
+  const { socketPath, onPermissionRequest } = options;
+  const server = createServer((socket) => {
+    let data = "";
+    socket.on("data", (chunk) => {
+      data += chunk.toString();
+      const newlineIdx = data.indexOf("\n");
+      if (newlineIdx === -1) return;
+      const line = data.slice(0, newlineIdx);
+      data = data.slice(newlineIdx + 1);
+      let request;
+      try {
+        request = JSON.parse(line);
+      } catch {
+        socket.end(JSON.stringify({
+          allowed: false,
+          reason: "Invalid request",
+          requestId: "unknown",
+          type: "permission-response"
+        }) + "\n");
+        return;
+      }
+      onPermissionRequest(request).then((response) => {
+        socket.end(JSON.stringify(response) + "\n");
+      }).catch(() => {
+        const errorResponse = {
+          allowed: false,
+          reason: "Internal error",
+          requestId: request.requestId,
+          type: "permission-response"
+        };
+        socket.end(JSON.stringify(errorResponse) + "\n");
+      });
+    });
+    socket.on("error", () => {
+    });
+  });
+  const listening = new Promise((resolve, reject) => {
+    server.listen(socketPath, () => resolve());
+    server.on("error", reject);
+  });
+  return {
+    close: () => server.close(),
+    listening,
+    server
+  };
+}
+
+// src/actions/clamp/promptUser.ts
+import {
+  closeSync,
+  openSync,
+  writeSync
+} from "fs";
+import { createInterface } from "readline";
+import { ReadStream } from "tty";
+function parseAnswer(answer) {
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === "y" || trimmed === "yes") return "allow-once";
+  if (trimmed === "a" || trimmed === "always") return "allow-always";
+  return "deny";
+}
+function promptViaTty(fullCommand) {
+  let readFd;
+  let writeFd;
+  try {
+    readFd = openSync("/dev/tty", "r");
+    writeFd = openSync("/dev/tty", "w");
+  } catch {
+    return Promise.resolve("deny");
+  }
+  const ttyIn = new ReadStream(readFd);
+  writeSync(writeFd, `
+[clamp] "${fullCommand}" \u2014 Allow? [y/N/a(lways)] `);
+  const rl = createInterface({ input: ttyIn, terminal: false });
+  return new Promise((resolve) => {
+    const cleanup = () => {
+      rl.close();
+      ttyIn.destroy();
+      try {
+        closeSync(writeFd);
+      } catch {
+      }
+    };
+    rl.once("line", (answer) => {
+      cleanup();
+      resolve(parseAnswer(answer));
+    });
+    rl.once("close", () => resolve("deny"));
+    ttyIn.on("error", () => {
+      cleanup();
+      resolve("deny");
+    });
+  });
+}
+function promptViaRenderer(fullCommand, renderer) {
+  const promptText = `[clamp] "${fullCommand}" \u2014 Allow? [y/N/a(lways)] `;
+  renderer.setStatusLine(promptText);
+  let readFd;
+  try {
+    readFd = openSync("/dev/tty", "r");
+  } catch {
+    renderer.setStatusLine("[clamp] No TTY \u2014 denied");
+    return Promise.resolve("deny");
+  }
+  const ttyIn = new ReadStream(readFd);
+  const rl = createInterface({ input: ttyIn, terminal: false });
+  return new Promise((resolve) => {
+    const cleanup = () => {
+      rl.close();
+      ttyIn.destroy();
+      renderer.setStatusLine("[clamp] Ready");
+    };
+    rl.once("line", (answer) => {
+      const decision = parseAnswer(answer);
+      cleanup();
+      resolve(decision);
+    });
+    rl.once("close", () => {
+      cleanup();
+      resolve("deny");
+    });
+    ttyIn.on("error", () => {
+      cleanup();
+      resolve("deny");
+    });
+  });
+}
+async function promptUser(command, args, renderer) {
+  const fullCommand = [command, ...args].join(" ");
+  if (renderer) {
+    return promptViaRenderer(fullCommand, renderer);
+  }
+  return promptViaTty(fullCommand);
+}
+
+// src/actions/clamp/runClamped.ts
+import { randomUUID } from "crypto";
+import { rmSync as rmSync3, unlinkSync } from "fs";
+import { tmpdir as tmpdir4 } from "os";
+import path4 from "path";
+import {
+  CLAMP_IPC_ENV,
+  CLAMP_ORIGINAL_PATH_ENV,
+  CLAMP_SESSION_ENV,
+  loadPolicy,
+  matchProcess
+} from "@xylabs/aries-clamp-core";
+import chalk2 from "chalk";
+
+// src/actions/clamp/sandboxExec.ts
+import { spawn } from "child_process";
+import {
+  mkdtempSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import path from "path";
+import { detectPlatform, generateMacOSProfile } from "@xylabs/aries-clamp-core";
+import chalk from "chalk";
+
+// src/actions/clamp/terminalRenderer.ts
+import pkg from "@xterm/headless";
+var { Terminal } = pkg;
+var STATUS_BAR_HEIGHT = 2;
+var ESC = "\x1B[";
+var moveTo = (row, col) => `${ESC}${row};${col}H`;
+var resetStyle = `${ESC}0m`;
+var hideCursor = `${ESC}?25l`;
+var showCursor = `${ESC}?25h`;
+var clearScreen = `${ESC}2J`;
+var setBg = (r, g, b) => `${ESC}48;2;${r};${g};${b}m`;
+var setFg = (r, g, b) => `${ESC}38;2;${r};${g};${b}m`;
+var fgPalette = (n) => `${ESC}38;5;${n}m`;
+var bgPalette = (n) => `${ESC}48;5;${n}m`;
+var bold = `${ESC}1m`;
+var dim = `${ESC}2m`;
+var italic = `${ESC}3m`;
+var underline = `${ESC}4m`;
+var inverse = `${ESC}7m`;
+var strikethrough = `${ESC}9m`;
+function getCellStyle(cell) {
+  if (!cell) return {
+    attrs: "",
+    bg: "",
+    fg: ""
+  };
+  let fg = "";
+  let bg = "";
+  let attrs = "";
+  if (cell.isFgRGB()) {
+    const color = cell.getFgColor();
+    fg = setFg(color >> 16 & 255, color >> 8 & 255, color & 255);
+  } else if (cell.getFgColorMode() !== 0) {
+    fg = fgPalette(cell.getFgColor());
+  }
+  if (cell.isBgRGB()) {
+    const color = cell.getBgColor();
+    bg = setBg(color >> 16 & 255, color >> 8 & 255, color & 255);
+  } else if (cell.getBgColorMode() !== 0) {
+    bg = bgPalette(cell.getBgColor());
+  }
+  if (cell.isBold()) attrs += bold;
+  if (cell.isDim()) attrs += dim;
+  if (cell.isItalic()) attrs += italic;
+  if (cell.isUnderline()) attrs += underline;
+  if (cell.isInverse()) attrs += inverse;
+  if (cell.isStrikethrough()) attrs += strikethrough;
+  return {
+    attrs,
+    bg,
+    fg
+  };
+}
+function createTerminalRenderer() {
+  const realCols = process.stdout.columns ?? 80;
+  const realRows = process.stdout.rows ?? 24;
+  const innerRows = realRows - STATUS_BAR_HEIGHT;
+  const terminal = new Terminal({
+    cols: realCols,
+    rows: innerRows
+  });
+  let statusLine = "";
+  let renderScheduled = false;
+  function renderBuffer() {
+    const buf = terminal.buffer.active;
+    const cols = terminal.cols;
+    const rows = terminal.rows;
+    const output = [hideCursor];
+    for (let y = 0; y < rows; y++) {
+      const line = buf.getLine(y);
+      output.push(moveTo(y + 1, 1));
+      if (!line) {
+        output.push(resetStyle + " ".repeat(cols));
+        continue;
+      }
+      let lineStr = "";
+      let lastStyle = "";
+      for (let x = 0; x < cols; x++) {
+        const cell = line.getCell(x);
+        if (!cell || cell.getWidth() === 0) continue;
+        const style = getCellStyle(cell);
+        const styleStr = resetStyle + style.fg + style.bg + style.attrs;
+        if (styleStr !== lastStyle) {
+          lineStr += styleStr;
+          lastStyle = styleStr;
+        }
+        const ch = cell.getChars();
+        lineStr += ch || " ";
+      }
+      output.push(lineStr + resetStyle);
+    }
+    const statusRow = realRows - 1;
+    output.push(
+      moveTo(statusRow, 1),
+      resetStyle + dim + "\u2500".repeat(realCols) + resetStyle,
+      moveTo(statusRow + 1, 1),
+      resetStyle,
+      statusLine.padEnd(realCols).slice(0, realCols),
+      resetStyle
+    );
+    const cursorY = buf.cursorY + 1;
+    const cursorX = buf.cursorX + 1;
+    output.push(moveTo(cursorY, cursorX), showCursor);
+    process.stdout.write(output.join(""));
+  }
+  function scheduleRender() {
+    if (renderScheduled) return;
+    renderScheduled = true;
+    setImmediate(() => {
+      renderScheduled = false;
+      renderBuffer();
+    });
+  }
+  function handleResize() {
+    const newCols = process.stdout.columns ?? 80;
+    const newRows = process.stdout.rows ?? 24;
+    const newInnerRows = newRows - STATUS_BAR_HEIGHT;
+    terminal.resize(newCols, newInnerRows);
+    process.stdout.write(clearScreen);
+    scheduleRender();
+  }
+  process.stdout.on("resize", handleResize);
+  process.stdout.write(clearScreen + moveTo(1, 1));
+  return {
+    destroy: () => {
+      process.stdout.removeListener("resize", handleResize);
+      process.stdout.write(clearScreen + moveTo(1, 1) + showCursor + resetStyle);
+      terminal.dispose();
+    },
+    render: scheduleRender,
+    setStatusLine: (line) => {
+      statusLine = line;
+      scheduleRender();
+    },
+    terminal,
+    write: (data) => {
+      terminal.write(data);
+      scheduleRender();
+    }
+  };
+}
+
+// src/actions/clamp/sandboxExec.ts
+function createMacOSSandbox(policy) {
+  const profileContent = generateMacOSProfile(policy, process.cwd());
+  const profileDir = mkdtempSync(path.join(tmpdir(), "aries-clamp-sb-"));
+  const profilePath = path.join(profileDir, "sandbox.sb");
+  writeFileSync(profilePath, profileContent, "utf8");
+  console.error(chalk.gray("[clamp] macOS sandbox enabled"));
+  return {
+    args: ["-f", profilePath],
+    cleanup: () => {
+      try {
+        rmSync(profileDir, { force: true, recursive: true });
+      } catch {
+      }
+    }
+  };
+}
+function resolveSpawnCommand(command, args, policy) {
+  const platform = detectPlatform();
+  const cleanupFns = [];
+  if (platform === "darwin" && policy.filesystem) {
+    const sandbox = createMacOSSandbox(policy);
+    cleanupFns.push(sandbox.cleanup);
+    return {
+      cleanupFns,
+      spawnArgs: [...sandbox.args, command, ...args],
+      spawnCommand: "sandbox-exec"
+    };
+  }
+  if (platform === "linux" && policy.filesystem) {
+    console.error(chalk.yellow("[clamp] Linux filesystem sandbox: Landlock integration pending"));
+  } else if (policy.filesystem) {
+    console.error(chalk.yellow(`[clamp] OS filesystem sandbox not available on ${platform}`));
+  }
+  return {
+    cleanupFns,
+    spawnArgs: args,
+    spawnCommand: command
+  };
+}
+function cleanEnvRecord(env) {
+  const clean = {};
+  for (const [k, v] of Object.entries(env)) {
+    if (v !== void 0) clean[k] = v;
+  }
+  return clean;
+}
+function spawnWithRenderedPty(spawnCommand, spawnArgs, env) {
+  try {
+    const pty = require_lib();
+    const renderer = createTerminalRenderer();
+    const innerRows = (process.stdout.rows ?? 24) - 2;
+    const ptyProcess = pty.spawn(spawnCommand, spawnArgs, {
+      cols: process.stdout.columns ?? 80,
+      cwd: process.cwd(),
+      env,
+      name: process.env.TERM ?? "xterm-256color",
+      rows: innerRows
+    });
+    let paused = false;
+    ptyProcess.onData((data) => {
+      if (!paused) {
+        renderer.write(data);
+      }
+    });
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    const onStdin = (data) => {
+      ptyProcess.write(data.toString());
+    };
+    process.stdin.on("data", onStdin);
+    const onResize = () => {
+      const newInnerRows = (process.stdout.rows ?? 24) - 2;
+      ptyProcess.resize(process.stdout.columns ?? 80, newInnerRows);
+    };
+    process.stdout.on("resize", onResize);
+    const exitCode = new Promise((resolve) => {
+      ptyProcess.onExit(({ exitCode: code }) => {
+        process.stdin.removeListener("data", onStdin);
+        process.stdout.removeListener("resize", onResize);
+        if (process.stdin.isTTY) process.stdin.setRawMode(false);
+        process.stdin.pause();
+        renderer.destroy();
+        resolve(code);
+      });
+    });
+    return {
+      cleanup: () => {
+      },
+      exitCode,
+      ok: true,
+      pause: () => {
+        paused = true;
+      },
+      renderer,
+      resume: () => {
+        paused = false;
+        renderer.render();
+      }
+    };
+  } catch {
+    return { ok: false };
+  }
+}
+function spawnFallback(spawnCommand, spawnArgs, env) {
+  console.error(chalk.yellow("[clamp] PTY unavailable, falling back to basic stdio passthrough"));
+  const child = spawn(spawnCommand, spawnArgs, { env, stdio: "inherit" });
+  const exitCode = new Promise((resolve) => {
+    child.on("close", (code) => resolve(code));
+    child.on("error", () => resolve(1));
+  });
+  const noop = () => {
+  };
+  return {
+    cleanup: noop,
+    exitCode,
+    pause: noop,
+    renderer: void 0,
+    resume: noop
+  };
+}
+function spawnSandboxed(options) {
+  const { env, policy } = options;
+  const {
+    spawnCommand,
+    spawnArgs,
+    cleanupFns
+  } = resolveSpawnCommand(options.command, options.args, policy);
+  const cleanEnv = cleanEnvRecord(env);
+  const ptyResult = spawnWithRenderedPty(spawnCommand, spawnArgs, cleanEnv);
+  const result = ptyResult.ok ? ptyResult : spawnFallback(spawnCommand, spawnArgs, env);
+  const originalCleanup = result.cleanup;
+  return {
+    ...result,
+    cleanup: () => {
+      originalCleanup();
+      for (const fn of cleanupFns) fn();
+    }
+  };
+}
+
+// src/actions/clamp/shellEnvSetup.ts
+import {
+  mkdtempSync as mkdtempSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir, tmpdir as tmpdir2 } from "os";
+import path2 from "path";
+function createShellEnvOverrides(shimDir) {
+  const tmpDir = mkdtempSync2(path2.join(tmpdir2(), "aries-clamp-env-"));
+  const home = homedir();
+  const zshenv = [
+    "# Aries Clamp: source real .zshenv then re-prepend shim dir",
+    `[ -f "${home}/.zshenv" ] && ZDOTDIR="${home}" source "${home}/.zshenv"`,
+    `export PATH="${shimDir}:\${PATH}"`
+  ].join("\n") + "\n";
+  writeFileSync2(path2.join(tmpDir, ".zshenv"), zshenv, "utf8");
+  const zshrc = [
+    "# Aries Clamp: source real .zshrc then re-prepend shim dir",
+    `[ -f "${home}/.zshrc" ] && ZDOTDIR="${home}" source "${home}/.zshrc"`,
+    `export PATH="${shimDir}:\${PATH}"`
+  ].join("\n") + "\n";
+  writeFileSync2(path2.join(tmpDir, ".zshrc"), zshrc, "utf8");
+  const zprofile = [
+    "# Aries Clamp: source real .zprofile then re-prepend shim dir",
+    `[ -f "${home}/.zprofile" ] && ZDOTDIR="${home}" source "${home}/.zprofile"`,
+    `export PATH="${shimDir}:\${PATH}"`
+  ].join("\n") + "\n";
+  writeFileSync2(path2.join(tmpDir, ".zprofile"), zprofile, "utf8");
+  const bashEnv = [
+    "# Aries Clamp: prepend shim dir to PATH",
+    `export PATH="${shimDir}:\${PATH}"`
+  ].join("\n") + "\n";
+  const bashEnvPath = path2.join(tmpDir, "bash_env.sh");
+  writeFileSync2(bashEnvPath, bashEnv, "utf8");
+  const bashrc = [
+    "# Aries Clamp: source real .bashrc then re-prepend shim dir",
+    `[ -f "${home}/.bashrc" ] && source "${home}/.bashrc"`,
+    `export PATH="${shimDir}:\${PATH}"`
+  ].join("\n") + "\n";
+  writeFileSync2(path2.join(tmpDir, ".bashrc"), bashrc, "utf8");
+  return {
+    cleanup: () => {
+      try {
+        rmSync2(tmpDir, { force: true, recursive: true });
+      } catch {
+      }
+    },
+    env: {
+      BASH_ENV: bashEnvPath,
+      ENV: bashEnvPath,
+      ZDOTDIR: tmpDir
+    }
+  };
+}
+
+// src/actions/clamp/shimGenerator.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdtempSync as mkdtempSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { createRequire } from "module";
+import { tmpdir as tmpdir3 } from "os";
+import path3 from "path";
+var DANGEROUS_COMMANDS = [
+  "chmod",
+  "chown",
+  "curl",
+  "docker",
+  "kill",
+  "killall",
+  "mv",
+  "pkill",
+  "rm",
+  "rmdir",
+  "sudo",
+  "wget"
+];
+function getGatekeeperPath() {
+  const require2 = createRequire(import.meta.url);
+  try {
+    const pluginPkg = require2.resolve("@xylabs/aries-clamp-plugin/package.json");
+    return path3.join(path3.dirname(pluginPkg), "dist", "shim", "gatekeeper.mjs");
+  } catch {
+    const candidates = [
+      path3.resolve("packages", "clamp-plugin", "dist", "shim", "gatekeeper.mjs"),
+      path3.resolve("node_modules", "@xylabs", "aries-clamp-plugin", "dist", "shim", "gatekeeper.mjs")
+    ];
+    for (const candidate of candidates) {
+      if (existsSync(candidate)) return candidate;
+    }
+    throw new Error("Could not find gatekeeper.mjs \u2014 is @xylabs/aries-clamp-plugin built?");
+  }
+}
+async function generateShimDirectory(policy) {
+  const shimDir = mkdtempSync3(path3.join(tmpdir3(), "aries-clamp-"));
+  const gatekeeperPath = getGatekeeperPath();
+  const nodePath = process.execPath;
+  const commands = /* @__PURE__ */ new Set();
+  const processRules = policy.process;
+  if (processRules) {
+    for (const cmd of processRules.allow ?? []) commands.add(cmd);
+    for (const cmd of processRules.prompt ?? []) commands.add(cmd);
+    for (const cmd of processRules.deny ?? []) commands.add(cmd);
+  }
+  for (const cmd of DANGEROUS_COMMANDS) {
+    commands.add(cmd);
+  }
+  for (const cmd of commands) {
+    const shimPath = path3.join(shimDir, cmd);
+    const script = `#!/bin/sh
+exec "${nodePath}" "${gatekeeperPath}" "${cmd}" "$@"
+`;
+    writeFileSync3(shimPath, script, "utf8");
+    chmodSync(shimPath, 493);
+  }
+  return shimDir;
+}
+
+// src/actions/clamp/runClamped.ts
+function printDryRun(command, args, policy, auditEnabled) {
+  console.log(chalk2.cyan("\n[clamp] Dry run \u2014 would sandbox with:\n"));
+  console.log(chalk2.white(`  Command: ${command} ${args.join(" ")}`));
+  console.log(chalk2.white(`  Policy: ${policy.name}`));
+  console.log(chalk2.white(`  Default action: ${policy.defaultAction ?? "prompt"}`));
+  console.log(chalk2.white(`  Audit: ${auditEnabled ? "enabled" : "disabled"}`));
+  if (policy.process) {
+    console.log(chalk2.green(`  Allowed: ${policy.process.allow?.join(", ") ?? "(none)"}`));
+    console.log(chalk2.yellow(`  Prompted: ${policy.process.prompt?.join(", ") ?? "(none)"}`));
+    console.log(chalk2.red(`  Denied: ${policy.process.deny?.join(", ") ?? "(none)"}`));
+  }
+  if (policy.filesystem) {
+    console.log(chalk2.white("  Filesystem sandbox: enabled"));
+  }
+  console.log("");
+}
+async function resolveDecision(command, args, alwaysAllow, renderer) {
+  const answer = await promptUser(command, args, renderer);
+  if (answer === "allow-always") {
+    alwaysAllow.add(command);
+    return "prompted-allow";
+  }
+  return answer === "allow-once" ? "prompted-allow" : "prompted-deny";
+}
+function createPermissionHandler(policy, sessionId, auditEnabled, alwaysAllow, sandboxRef) {
+  const defaultAction = policy.defaultAction ?? "prompt";
+  return async (request) => {
+    const {
+      command: reqCommand,
+      args: reqArgs,
+      requestId
+    } = request;
+    if (alwaysAllow.has(reqCommand)) {
+      if (auditEnabled) {
+        logClampPermission({
+          args: reqArgs,
+          command: reqCommand,
+          decision: "allowed",
+          policy,
+          sessionId
+        });
+      }
+      return {
+        allowed: true,
+        requestId,
+        type: "permission-response"
+      };
+    }
+    const level = matchProcess(reqCommand, policy.process, defaultAction);
+    if (level === "allow" || level === "deny") {
+      const decision2 = level === "allow" ? "allowed" : "denied";
+      if (auditEnabled) {
+        logClampPermission({
+          args: reqArgs,
+          command: reqCommand,
+          decision: decision2,
+          policy,
+          sessionId
+        });
+      }
+      return {
+        allowed: level === "allow",
+        reason: level === "deny" ? `Policy "${policy.name}": deny` : void 0,
+        requestId,
+        type: "permission-response"
+      };
+    }
+    sandboxRef.sandbox?.pause();
+    const decision = await resolveDecision(reqCommand, reqArgs, alwaysAllow, sandboxRef.sandbox?.renderer);
+    sandboxRef.sandbox?.resume();
+    if (auditEnabled) {
+      logClampPermission({
+        args: reqArgs,
+        command: reqCommand,
+        decision,
+        policy,
+        sessionId
+      });
+    }
+    const allowed = decision === "prompted-allow";
+    return {
+      allowed,
+      reason: allowed ? void 0 : `Policy "${policy.name}": denied by user`,
+      requestId,
+      type: "permission-response"
+    };
+  };
+}
+function buildChildEnv(shimDir, socketPath, sessionId, shellEnv) {
+  const originalPath = process.env.PATH ?? "";
+  return {
+    ...process.env,
+    ...shellEnv,
+    PATH: `${shimDir}${path4.delimiter}${originalPath}`,
+    [CLAMP_IPC_ENV]: socketPath,
+    [CLAMP_ORIGINAL_PATH_ENV]: originalPath,
+    [CLAMP_SESSION_ENV]: sessionId
+  };
+}
+function cleanupResources(socketPath, shimDir) {
+  try {
+    unlinkSync(socketPath);
+  } catch {
+  }
+  try {
+    rmSync3(shimDir, { force: true, recursive: true });
+  } catch {
+  }
+}
+function parseArgs(argv) {
+  return {
+    args: argv.args ?? [],
+    auditEnabled: argv.audit !== false,
+    command: argv.command,
+    dryRun: argv["dry-run"] ?? false,
+    policyOption: argv.policy
+  };
+}
+async function runClamped(argv) {
+  const {
+    command,
+    args,
+    policyOption,
+    auditEnabled,
+    dryRun
+  } = parseArgs(argv);
+  let policy;
+  try {
+    policy = loadPolicy({ path: policyOption });
+  } catch (err) {
+    console.error(chalk2.red(`Failed to load policy: ${String(err)}`));
+    process.exit(1);
+  }
+  if (dryRun) {
+    printDryRun(command, args, policy, auditEnabled);
+    return;
+  }
+  const sessionId = randomUUID();
+  const shimDir = await generateShimDirectory(policy);
+  const shellOverrides = createShellEnvOverrides(shimDir);
+  const socketPath = path4.join(tmpdir4(), `aries-clamp-${process.pid}-${randomUUID().slice(0, 8)}.sock`);
+  const sandboxRef = {};
+  const handler = createPermissionHandler(policy, sessionId, auditEnabled, /* @__PURE__ */ new Set(), sandboxRef);
+  const ipcHandle = createIpcServer({ onPermissionRequest: handler, socketPath });
+  await ipcHandle.listening;
+  if (auditEnabled) logClampStart({
+    command,
+    policy,
+    sessionId
+  });
+  console.error(chalk2.cyan(`[clamp] Session ${sessionId.slice(0, 8)} \u2014 policy: ${policy.name}`));
+  const childEnv = buildChildEnv(shimDir, socketPath, sessionId, shellOverrides.env);
+  const sandbox = spawnSandboxed({
+    args,
+    command,
+    env: childEnv,
+    policy
+  });
+  sandboxRef.sandbox = sandbox;
+  sandbox.renderer?.setStatusLine(`[clamp] policy: ${policy.name} | allowed: 0 | denied: 0`);
+  const exitCode = await sandbox.exitCode;
+  sandbox.cleanup();
+  shellOverrides.cleanup();
+  ipcHandle.close();
+  cleanupResources(socketPath, shimDir);
+  if (auditEnabled) logClampStop({ exitCode, sessionId });
+  console.error(chalk2.gray(`
+[clamp] Session ended (exit code: ${exitCode})`));
+  process.exit(exitCode ?? 1);
+}
+
+// src/commands/clampRunCommand.ts
+var clampRunCommand = {
+  builder: (yargs) => yargs.positional("command", {
+    demandOption: true,
+    describe: "Command to run inside the sandbox",
+    type: "string"
+  }).positional("args", {
+    array: true,
+    describe: "Arguments for the command",
+    type: "string"
+  }).option("policy", {
+    alias: "p",
+    describe: "Policy file path or name",
+    type: "string"
+  }).option("audit", {
+    default: true,
+    describe: "Enable audit logging",
+    type: "boolean"
+  }).option("dry-run", {
+    default: false,
+    describe: "Show what would be sandboxed without running",
+    type: "boolean"
+  }),
+  command: "run <command> [args..]",
+  describe: "Run a command inside the clamp sandbox",
+  handler: async (argv) => {
+    await runClamped(argv);
+  }
+};
+export {
+  clampRunCommand
+};
+//# sourceMappingURL=clampRunCommand.mjs.map