@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/dist/cli-0x01kwrd.js

@@ -0,0 +1,491 @@
+import {
+  require_proper_lockfile
+} from "./cli-447dt1h3.js";
+import {
+  CONFIG_DIR_NAME,
+  canonicalizePath,
+  resolvePath,
+  stripBom
+} from "./cli-d5czme6m.js";
+import {
+  __toESM
+} from "./cli-bc05qbss.js";
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/mcp-servers.js
+var MCP_EXPOSURES = ["codemode", "deferred", "direct", "hidden"];
+var MCP_EXPOSURE_ALIASES = { "codemode-deferred": "codemode" };
+var LOOPBACK_HOSTS = ["localhost", "127.0.0.1", "[::1]"];
+function isLoopbackRedirectUri(value) {
+  if (!URL.canParse(value))
+    return false;
+  const url = new URL(value);
+  return url.protocol === "http:" && LOOPBACK_HOSTS.includes(url.hostname) && url.search === "" && url.hash === "";
+}
+var SERVER_NAME = /^[A-Za-z0-9_-]+$/;
+function mcpNamespace(server) {
+  return `mcp__${server.replace(/-/g, "_")}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringRecord(value) {
+  return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function validateOAuth(value) {
+  if (value === undefined)
+    return;
+  if (!isRecord(value))
+    return "oauth must be an object";
+  if (value.clientId !== undefined && typeof value.clientId !== "string")
+    return "oauth.clientId must be a string";
+  if (value.clientSecret !== undefined && typeof value.clientSecret !== "string") {
+    return "oauth.clientSecret must be a string";
+  }
+  const port = value.callbackPort;
+  if (port !== undefined && (typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535)) {
+    return "oauth.callbackPort must be a port number";
+  }
+  if (value.callbackUrl !== undefined) {
+    if (typeof value.callbackUrl !== "string" || !isLoopbackRedirectUri(value.callbackUrl)) {
+      return "oauth.callbackUrl must be an http URI on localhost, 127.0.0.1, or [::1] without query or fragment";
+    }
+    const urlPort = new URL(value.callbackUrl).port;
+    if (urlPort && port !== undefined && Number(urlPort) !== port) {
+      return "oauth.callbackUrl and oauth.callbackPort name different ports";
+    }
+  }
+  if (value.scope !== undefined && typeof value.scope !== "string")
+    return "oauth.scope must be a string";
+  if (value.clientName !== undefined && (typeof value.clientName !== "string" || !value.clientName.trim())) {
+    return "oauth.clientName must be a non-empty string";
+  }
+  return;
+}
+function isExposure(value) {
+  return typeof value === "string" && MCP_EXPOSURES.includes(value);
+}
+function resolveExposureAlias(value) {
+  return typeof value === "string" ? MCP_EXPOSURE_ALIASES[value] ?? value : value;
+}
+function resolveExposureAliases(value) {
+  const { exposure, toolExposure } = value;
+  const resolved = { ...value };
+  if (exposure !== undefined)
+    resolved.exposure = resolveExposureAlias(exposure);
+  if (isRecord(toolExposure)) {
+    resolved.toolExposure = Object.fromEntries(Object.entries(toolExposure).map(([tool, entry]) => [tool, resolveExposureAlias(entry)]));
+  }
+  return resolved;
+}
+function toolPatternRegExp(pattern) {
+  const source = pattern.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${source}$`);
+}
+function getMcpToolExposure(config, toolName) {
+  const overrides = config.toolExposure ?? {};
+  const exact = overrides[toolName];
+  if (exact !== undefined)
+    return exact;
+  for (const [pattern, exposure] of Object.entries(overrides)) {
+    if (pattern.includes("*") && toolPatternRegExp(pattern).test(toolName))
+      return exposure;
+  }
+  return config.exposure ?? "codemode";
+}
+function validateMcpServerConfig(name, raw) {
+  if (!SERVER_NAME.test(name))
+    return `invalid server name "${name}" (use letters, digits, "_" and "-")`;
+  if (!isRecord(raw))
+    return `server "${name}" must be an object`;
+  const value = resolveExposureAliases(raw);
+  const { type, exposure, enabled, timeout, toolExposure, description } = value;
+  const exposures = MCP_EXPOSURES.map((value2) => `"${value2}"`).join(", ");
+  if (exposure !== undefined && !isExposure(exposure)) {
+    return `server "${name}": exposure must be one of ${exposures}`;
+  }
+  if (toolExposure !== undefined) {
+    if (!isRecord(toolExposure))
+      return `server "${name}": toolExposure must map tool names to exposures`;
+    for (const [tool, value2] of Object.entries(toolExposure)) {
+      if (!isExposure(value2))
+        return `server "${name}": toolExposure "${tool}" must be one of ${exposures}`;
+    }
+  }
+  if (enabled !== undefined && typeof enabled !== "boolean")
+    return `server "${name}": enabled must be a boolean`;
+  if (description !== undefined && typeof description !== "string") {
+    return `server "${name}": description must be a string`;
+  }
+  if (timeout !== undefined && (typeof timeout !== "number" || !(timeout > 0))) {
+    return `server "${name}": timeout must be a positive number of seconds`;
+  }
+  if (type === "sse")
+    return `server "${name}": legacy SSE transport is not supported; use the streamable HTTP URL`;
+  if (typeof value.url === "string" && (type === undefined || type === "http" || type === "streamable-http")) {
+    if (!URL.canParse(value.url) || !/^https?:$/.test(new URL(value.url).protocol)) {
+      return `server "${name}": url must be an http or https URL`;
+    }
+    if (value.headers !== undefined && !isStringRecord(value.headers)) {
+      return `server "${name}": headers must map names to strings`;
+    }
+    const oauthError = validateOAuth(value.oauth);
+    if (oauthError)
+      return `server "${name}": ${oauthError}`;
+    if (value.auth !== undefined) {
+      if (!isRecord(value.auth) || typeof value.auth.provider !== "string" || !value.auth.provider) {
+        return `server "${name}": auth.provider must be a provider name`;
+      }
+      const url = new URL(value.url);
+      if (url.protocol !== "https:" && !LOOPBACK_HOSTS.includes(url.hostname)) {
+        return `server "${name}": auth requires an https URL, or http on localhost, 127.0.0.1, or [::1]`;
+      }
+    }
+    return value;
+  }
+  if (typeof value.command === "string" && (type === undefined || type === "stdio")) {
+    if (value.args !== undefined && !(Array.isArray(value.args) && value.args.every((arg) => typeof arg === "string"))) {
+      return `server "${name}": args must be an array of strings`;
+    }
+    if (value.env !== undefined && !isStringRecord(value.env))
+      return `server "${name}": env must map names to strings`;
+    if (value.cwd !== undefined && typeof value.cwd !== "string")
+      return `server "${name}": cwd must be a string`;
+    return value;
+  }
+  return `server "${name}" needs either "command" (stdio) or "url" (streamable HTTP)`;
+}
+
+class McpServerRegistry {
+  servers = new Map;
+  changeListener;
+  register(server) {
+    this.servers.set(server.name, server);
+    this.changeListener?.();
+  }
+  unregister(name, extensionPath) {
+    if (this.servers.get(name)?.extensionPath !== extensionPath)
+      return;
+    this.servers.delete(name);
+    this.changeListener?.();
+  }
+  get(name) {
+    return this.servers.get(name);
+  }
+  list() {
+    return [...this.servers.values()].map((server) => ({ ...server, config: structuredClone(server.config) }));
+  }
+  setChangeListener(listener) {
+    this.changeListener = listener;
+  }
+}
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/trust-manager.js
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES = [
+  "settings.json",
+  "mcp.json",
+  "extensions",
+  "skills",
+  "prompts",
+  "themes",
+  "SYSTEM.md",
+  "APPEND_SYSTEM.md"
+];
+function normalizeCwd(cwd) {
+  return canonicalizePath(resolvePath(cwd));
+}
+function findNearestTrustEntry(data, cwd) {
+  let currentDir = normalizeCwd(cwd);
+  while (true) {
+    const value = data[currentDir];
+    if (value === true || value === false) {
+      return { path: currentDir, decision: value };
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function getProjectTrustParentPath(cwd) {
+  const trustPath = normalizeCwd(cwd);
+  const parentDir = dirname(trustPath);
+  return parentDir === trustPath ? undefined : parentDir;
+}
+function getProjectTrustOptions(cwd, options) {
+  const trustPath = normalizeCwd(cwd);
+  const trustOptions = [
+    { label: "Trust", trusted: true, updates: [{ path: trustPath, decision: true }], savedPath: trustPath }
+  ];
+  const parentPath = getProjectTrustParentPath(cwd);
+  if (parentPath !== undefined) {
+    trustOptions.push({
+      label: `Trust parent folder (${parentPath})`,
+      trusted: true,
+      updates: [
+        { path: parentPath, decision: true },
+        { path: trustPath, decision: null }
+      ],
+      savedPath: parentPath
+    });
+  }
+  if (options?.includeSessionOnly) {
+    trustOptions.push({ label: "Trust (this session only)", trusted: true, updates: [] });
+  }
+  trustOptions.push({
+    label: "Do not trust",
+    trusted: false,
+    updates: [{ path: trustPath, decision: false }],
+    savedPath: trustPath
+  });
+  if (options?.includeSessionOnly) {
+    trustOptions.push({ label: "Do not trust (this session only)", trusted: false, updates: [] });
+  }
+  return trustOptions;
+}
+function readTrustFile(path) {
+  if (!existsSync(path)) {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stripBom(readFileSync(path, "utf-8")));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read trust store ${path}: ${message}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Invalid trust store ${path}: expected an object`);
+  }
+  const data = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (value !== true && value !== false && value !== null) {
+      throw new Error(`Invalid trust store ${path}: value for ${JSON.stringify(key)} must be true, false, or null`);
+    }
+    data[key] = value;
+  }
+  return data;
+}
+function writeTrustFile(path, data) {
+  const sorted = {};
+  for (const key of Object.keys(data).sort()) {
+    const value = data[key];
+    if (value === true || value === false || value === null) {
+      sorted[key] = value;
+    }
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(sorted, null, 2)}
+`, "utf-8");
+}
+function acquireTrustLockSync(path) {
+  const trustDir = dirname(path);
+  mkdirSync(trustDir, { recursive: true });
+  const maxAttempts = 10;
+  const delayMs = 20;
+  let lastError;
+  for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+    try {
+      return import_proper_lockfile.default.lockSync(trustDir, { realpath: false, lockfilePath: `${path}.lock` });
+    } catch (error) {
+      const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : undefined;
+      if (code !== "ELOCKED" || attempt === maxAttempts) {
+        throw error;
+      }
+      lastError = error;
+      const start = Date.now();
+      while (Date.now() - start < delayMs) {}
+    }
+  }
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  throw new Error("Failed to acquire trust store lock");
+}
+function withTrustFileLock(path, fn) {
+  const release = acquireTrustLockSync(path);
+  try {
+    return fn();
+  } finally {
+    release();
+  }
+}
+function hasTrustRequiringProjectResources(cwd) {
+  const homeDir = canonicalizePath(resolvePath(process.env.HOME || homedir()));
+  const userAgentsSkillsDir = join(homeDir, ".agents", "skills");
+  let currentDir = canonicalizePath(resolvePath(cwd));
+  const configDir = join(currentDir, CONFIG_DIR_NAME);
+  if (TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES.some((entry) => existsSync(join(configDir, entry)))) {
+    return true;
+  }
+  while (true) {
+    const agentsSkillsDir = join(currentDir, ".agents", "skills");
+    if (agentsSkillsDir !== userAgentsSkillsDir && existsSync(agentsSkillsDir)) {
+      return true;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return false;
+    }
+    currentDir = parentDir;
+  }
+}
+
+class ProjectTrustStore {
+  trustPath;
+  constructor(agentDir) {
+    this.trustPath = join(resolvePath(agentDir), "trust.json");
+  }
+  get(cwd) {
+    return this.getEntry(cwd)?.decision ?? null;
+  }
+  getEntry(cwd) {
+    return withTrustFileLock(this.trustPath, () => {
+      const data = readTrustFile(this.trustPath);
+      return findNearestTrustEntry(data, cwd);
+    });
+  }
+  set(cwd, decision) {
+    this.setMany([{ path: cwd, decision }]);
+  }
+  setMany(decisions) {
+    withTrustFileLock(this.trustPath, () => {
+      const data = readTrustFile(this.trustPath);
+      for (const { path, decision } of decisions) {
+        const key = normalizeCwd(path);
+        if (decision === null) {
+          delete data[key];
+        } else {
+          data[key] = decision;
+        }
+      }
+      writeTrustFile(this.trustPath, data);
+    });
+  }
+}
+
+// node_modules/@earendil-works/pi-coding-agent/dist/utils/open-browser.js
+import { spawn } from "node:child_process";
+function openBrowser(target) {
+  const [cmd, args] = process.platform === "darwin" ? ["open", [target]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", target]] : ["xdg-open", [target]];
+  spawn(cmd, args, { stdio: "ignore", detached: true }).on("error", () => {}).unref();
+}
+
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/mcp/config.js
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readConfigFile(path, scope, state) {
+  const { servers, errors } = state;
+  if (!existsSync2(path))
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
+  } catch (error) {
+    errors.push(`${path}: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+  if (!isRecord2(parsed) || parsed.mcpServers !== undefined && !isRecord2(parsed.mcpServers)) {
+    errors.push(`${path}: expected an object with an "mcpServers" object`);
+    return;
+  }
+  if (typeof parsed.autoEnableCodemode === "boolean")
+    state.autoEnableCodemode = parsed.autoEnableCodemode;
+  else if (parsed.autoEnableCodemode !== undefined)
+    errors.push(`${path}: autoEnableCodemode must be a boolean`);
+  for (const [name, value] of Object.entries(parsed.mcpServers ?? {})) {
+    const config = validateMcpServerConfig(name, value);
+    if (typeof config === "string") {
+      errors.push(`${path}: ${config}`);
+      continue;
+    }
+    const clash = [...servers.keys()].find((other) => other !== name && mcpNamespace(other) === mcpNamespace(name));
+    if (clash) {
+      errors.push(`${path}: server "${name}" conflicts with "${clash}"`);
+      continue;
+    }
+    if (scope === "project" && "url" in config && config.auth) {
+      errors.push(`${path}: server "${name}": auth is only allowed in the global mcp.json`);
+      continue;
+    }
+    servers.set(name, { name, config, source: path, scope });
+  }
+}
+function loadMcpConfig(options) {
+  const state = { servers: new Map, errors: [] };
+  readConfigFile(join2(options.agentDir, "mcp.json"), "global", state);
+  if (options.projectTrusted)
+    readConfigFile(join2(options.cwd, CONFIG_DIR_NAME, "mcp.json"), "project", state);
+  return {
+    servers: [...state.servers.values()],
+    ...state.autoEnableCodemode === undefined ? {} : { autoEnableCodemode: state.autoEnableCodemode },
+    errors: state.errors
+  };
+}
+function updateMcpServerConfig(path, name, patch) {
+  editMcpServers(path, (servers) => {
+    const server = servers?.[name];
+    if (!isRecord2(server))
+      throw new Error(`${path} does not define MCP server "${name}"`);
+    if (patch.enabled !== undefined) {
+      if (patch.enabled)
+        delete server.enabled;
+      else
+        server.enabled = false;
+    }
+    if (patch.exposure !== undefined) {
+      if (patch.exposure === "codemode")
+        delete server.exposure;
+      else
+        server.exposure = patch.exposure;
+    }
+    return true;
+  });
+}
+function addMcpServerConfig(path, name, config) {
+  let replaced = false;
+  editMcpServers(path, (servers, parsed) => {
+    const target = servers ?? {};
+    replaced = target[name] !== undefined;
+    target[name] = config;
+    parsed.mcpServers = target;
+    return true;
+  });
+  return replaced;
+}
+function removeMcpServerConfig(path, name) {
+  if (!existsSync2(path))
+    return false;
+  let removed = false;
+  editMcpServers(path, (servers) => {
+    if (!servers || servers[name] === undefined)
+      return false;
+    delete servers[name];
+    removed = true;
+    return true;
+  });
+  return removed;
+}
+function editMcpServers(path, edit) {
+  const text = existsSync2(path) ? readFileSync2(path, "utf8") : undefined;
+  const parsed = text === undefined ? {} : JSON.parse(text);
+  if (!isRecord2(parsed) || parsed.mcpServers !== undefined && !isRecord2(parsed.mcpServers)) {
+    throw new Error(`${path}: expected an object with an "mcpServers" object`);
+  }
+  const servers = isRecord2(parsed.mcpServers) ? parsed.mcpServers : undefined;
+  if (!edit(servers, parsed))
+    return;
+  const indent = text && /^([ \t]+)\S/m.exec(text)?.[1] || "  ";
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify(parsed, null, indent)}
+`);
+}
+
+export { mcpNamespace, getMcpToolExposure, validateMcpServerConfig, McpServerRegistry, getProjectTrustOptions, hasTrustRequiringProjectResources, ProjectTrustStore, openBrowser, loadMcpConfig, updateMcpServerConfig, addMcpServerConfig, removeMcpServerConfig };

package/dist/cli-0xqde53b.js

@@ -0,0 +1,176 @@
+import {
+  __commonJS,
+  __require
+} from "./cli-bc05qbss.js";
+
+// node_modules/signal-exit/signals.js
+var require_signals = __commonJS(function(exports, module) {
+  module.exports = [
+    "SIGABRT",
+    "SIGALRM",
+    "SIGHUP",
+    "SIGINT",
+    "SIGTERM"
+  ];
+  if (process.platform !== "win32") {
+    module.exports.push("SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+  }
+  if (process.platform === "linux") {
+    module.exports.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
+  }
+});
+
+// node_modules/signal-exit/index.js
+var require_signal_exit = __commonJS(function(exports, module) {
+  var process2 = global.process;
+  var processOk = function(process3) {
+    return process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
+  };
+  if (!processOk(process2)) {
+    module.exports = function() {
+      return function() {};
+    };
+  } else {
+    assert = __require("assert");
+    signals = require_signals();
+    isWin = /^win/i.test(process2.platform);
+    EE = __require("events");
+    if (typeof EE !== "function") {
+      EE = EE.EventEmitter;
+    }
+    if (process2.__signal_exit_emitter__) {
+      emitter = process2.__signal_exit_emitter__;
+    } else {
+      emitter = process2.__signal_exit_emitter__ = new EE;
+      emitter.count = 0;
+      emitter.emitted = {};
+    }
+    if (!emitter.infinite) {
+      emitter.setMaxListeners(Infinity);
+      emitter.infinite = true;
+    }
+    module.exports = function(cb, opts) {
+      if (!processOk(global.process)) {
+        return function() {};
+      }
+      assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
+      if (loaded === false) {
+        load();
+      }
+      var ev = "exit";
+      if (opts && opts.alwaysLast) {
+        ev = "afterexit";
+      }
+      var remove = function() {
+        emitter.removeListener(ev, cb);
+        if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
+          unload();
+        }
+      };
+      emitter.on(ev, cb);
+      return remove;
+    };
+    unload = function unload2() {
+      if (!loaded || !processOk(global.process)) {
+        return;
+      }
+      loaded = false;
+      signals.forEach(function(sig) {
+        try {
+          process2.removeListener(sig, sigListeners[sig]);
+        } catch (er) {}
+      });
+      process2.emit = originalProcessEmit;
+      process2.reallyExit = originalProcessReallyExit;
+      emitter.count -= 1;
+    };
+    module.exports.unload = unload;
+    emit = function emit2(event, code, signal) {
+      if (emitter.emitted[event]) {
+        return;
+      }
+      emitter.emitted[event] = true;
+      emitter.emit(event, code, signal);
+    };
+    sigListeners = {};
+    signals.forEach(function(sig) {
+      sigListeners[sig] = function listener() {
+        if (!processOk(global.process)) {
+          return;
+        }
+        var listeners = process2.listeners(sig);
+        if (listeners.length === emitter.count) {
+          unload();
+          emit("exit", null, sig);
+          emit("afterexit", null, sig);
+          if (isWin && sig === "SIGHUP") {
+            sig = "SIGINT";
+          }
+          process2.kill(process2.pid, sig);
+        }
+      };
+    });
+    module.exports.signals = function() {
+      return signals;
+    };
+    loaded = false;
+    load = function load2() {
+      if (loaded || !processOk(global.process)) {
+        return;
+      }
+      loaded = true;
+      emitter.count += 1;
+      signals = signals.filter(function(sig) {
+        try {
+          process2.on(sig, sigListeners[sig]);
+          return true;
+        } catch (er) {
+          return false;
+        }
+      });
+      process2.emit = processEmit;
+      process2.reallyExit = processReallyExit;
+    };
+    module.exports.load = load;
+    originalProcessReallyExit = process2.reallyExit;
+    processReallyExit = function processReallyExit2(code) {
+      if (!processOk(global.process)) {
+        return;
+      }
+      process2.exitCode = code || 0;
+      emit("exit", process2.exitCode, null);
+      emit("afterexit", process2.exitCode, null);
+      originalProcessReallyExit.call(process2, process2.exitCode);
+    };
+    originalProcessEmit = process2.emit;
+    processEmit = function processEmit2(ev, arg) {
+      if (ev === "exit" && processOk(global.process)) {
+        if (arg !== undefined) {
+          process2.exitCode = arg;
+        }
+        var ret = originalProcessEmit.apply(this, arguments);
+        emit("exit", process2.exitCode, null);
+        emit("afterexit", process2.exitCode, null);
+        return ret;
+      } else {
+        return originalProcessEmit.apply(this, arguments);
+      }
+    };
+  }
+  var assert;
+  var signals;
+  var isWin;
+  var EE;
+  var emitter;
+  var unload;
+  var emit;
+  var sigListeners;
+  var loaded;
+  var load;
+  var originalProcessReallyExit;
+  var processReallyExit;
+  var originalProcessEmit;
+  var processEmit;
+});
+
+export { require_signal_exit };