@tonyclaw/agent-inspector 2.0.0

package/.output/server/_libs/stubborn-fs.mjs

@@ -0,0 +1,91 @@
+import fs from "node:fs";
+import { promisify } from "node:util";
+import { r as retryifySync, a as retryifyAsync, b as attemptifySync, c as attemptifyAsync } from "./stubborn-utils.mjs";
+import process from "node:process";
+const Handlers = {
+  /* API */
+  isChangeErrorOk: (error) => {
+    if (!Handlers.isNodeError(error))
+      return false;
+    const { code } = error;
+    if (code === "ENOSYS")
+      return true;
+    if (!IS_USER_ROOT && (code === "EINVAL" || code === "EPERM"))
+      return true;
+    return false;
+  },
+  isNodeError: (error) => {
+    return error instanceof Error;
+  },
+  isRetriableError: (error) => {
+    if (!Handlers.isNodeError(error))
+      return false;
+    const { code } = error;
+    if (code === "EMFILE" || code === "ENFILE" || code === "EAGAIN" || code === "EBUSY" || code === "EACCESS" || code === "EACCES" || code === "EACCS" || code === "EPERM")
+      return true;
+    return false;
+  },
+  onChangeError: (error) => {
+    if (!Handlers.isNodeError(error))
+      throw error;
+    if (Handlers.isChangeErrorOk(error))
+      return;
+    throw error;
+  }
+};
+const ATTEMPTIFY_CHANGE_ERROR_OPTIONS = {
+  onError: Handlers.onChangeError
+};
+const ATTEMPTIFY_NOOP_OPTIONS = {
+  onError: () => void 0
+};
+const IS_USER_ROOT = process.getuid ? !process.getuid() : false;
+const RETRYIFY_OPTIONS = {
+  isRetriable: Handlers.isRetriableError
+};
+const FS = {
+  attempt: {
+    /* ASYNC */
+    chmod: attemptifyAsync(promisify(fs.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chown: attemptifyAsync(promisify(fs.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    close: attemptifyAsync(promisify(fs.close), ATTEMPTIFY_NOOP_OPTIONS),
+    fsync: attemptifyAsync(promisify(fs.fsync), ATTEMPTIFY_NOOP_OPTIONS),
+    mkdir: attemptifyAsync(promisify(fs.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
+    realpath: attemptifyAsync(promisify(fs.realpath), ATTEMPTIFY_NOOP_OPTIONS),
+    stat: attemptifyAsync(promisify(fs.stat), ATTEMPTIFY_NOOP_OPTIONS),
+    unlink: attemptifyAsync(promisify(fs.unlink), ATTEMPTIFY_NOOP_OPTIONS),
+    /* SYNC */
+    chmodSync: attemptifySync(fs.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chownSync: attemptifySync(fs.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    closeSync: attemptifySync(fs.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
+    existsSync: attemptifySync(fs.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
+    fsyncSync: attemptifySync(fs.fsync, ATTEMPTIFY_NOOP_OPTIONS),
+    mkdirSync: attemptifySync(fs.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
+    realpathSync: attemptifySync(fs.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
+    statSync: attemptifySync(fs.statSync, ATTEMPTIFY_NOOP_OPTIONS),
+    unlinkSync: attemptifySync(fs.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
+  },
+  retry: {
+    /* ASYNC */
+    close: retryifyAsync(promisify(fs.close), RETRYIFY_OPTIONS),
+    fsync: retryifyAsync(promisify(fs.fsync), RETRYIFY_OPTIONS),
+    open: retryifyAsync(promisify(fs.open), RETRYIFY_OPTIONS),
+    readFile: retryifyAsync(promisify(fs.readFile), RETRYIFY_OPTIONS),
+    rename: retryifyAsync(promisify(fs.rename), RETRYIFY_OPTIONS),
+    stat: retryifyAsync(promisify(fs.stat), RETRYIFY_OPTIONS),
+    write: retryifyAsync(promisify(fs.write), RETRYIFY_OPTIONS),
+    writeFile: retryifyAsync(promisify(fs.writeFile), RETRYIFY_OPTIONS),
+    /* SYNC */
+    closeSync: retryifySync(fs.closeSync, RETRYIFY_OPTIONS),
+    fsyncSync: retryifySync(fs.fsyncSync, RETRYIFY_OPTIONS),
+    openSync: retryifySync(fs.openSync, RETRYIFY_OPTIONS),
+    readFileSync: retryifySync(fs.readFileSync, RETRYIFY_OPTIONS),
+    renameSync: retryifySync(fs.renameSync, RETRYIFY_OPTIONS),
+    statSync: retryifySync(fs.statSync, RETRYIFY_OPTIONS),
+    writeSync: retryifySync(fs.writeSync, RETRYIFY_OPTIONS),
+    writeFileSync: retryifySync(fs.writeFileSync, RETRYIFY_OPTIONS)
+  }
+};
+export {
+  FS as F
+};

package/.output/server/_libs/stubborn-utils.mjs

@@ -0,0 +1,66 @@
+const attemptifyAsync = (fn, options) => {
+  const { onError } = options;
+  return function attemptified(...args) {
+    return fn.apply(void 0, args).catch(onError);
+  };
+};
+const attemptifySync = (fn, options) => {
+  const { onError } = options;
+  return function attemptified(...args) {
+    try {
+      return fn.apply(void 0, args);
+    } catch (error) {
+      return onError(error);
+    }
+  };
+};
+const RETRY_INTERVAL = 250;
+const retryifyAsync = (fn, options) => {
+  const { isRetriable } = options;
+  return function retryified(options2) {
+    const { timeout } = options2;
+    const interval = options2.interval ?? RETRY_INTERVAL;
+    const timestamp = Date.now() + timeout;
+    return function attempt(...args) {
+      return fn.apply(void 0, args).catch((error) => {
+        if (!isRetriable(error))
+          throw error;
+        if (Date.now() >= timestamp)
+          throw error;
+        const delay = Math.round(interval * Math.random());
+        if (delay > 0) {
+          const delayPromise = new Promise((resolve) => setTimeout(resolve, delay));
+          return delayPromise.then(() => attempt.apply(void 0, args));
+        } else {
+          return attempt.apply(void 0, args);
+        }
+      });
+    };
+  };
+};
+const retryifySync = (fn, options) => {
+  const { isRetriable } = options;
+  return function retryified(options2) {
+    const { timeout } = options2;
+    const timestamp = Date.now() + timeout;
+    return function attempt(...args) {
+      while (true) {
+        try {
+          return fn.apply(void 0, args);
+        } catch (error) {
+          if (!isRetriable(error))
+            throw error;
+          if (Date.now() >= timestamp)
+            throw error;
+          continue;
+        }
+      }
+    };
+  };
+};
+export {
+  retryifyAsync as a,
+  attemptifySync as b,
+  attemptifyAsync as c,
+  retryifySync as r
+};

package/.output/server/_libs/style-to-js.mjs

@@ -0,0 +1,72 @@
+import { g as getDefaultExportFromCjs } from "./react.mjs";
+import { r as requireCjs$1 } from "./style-to-object.mjs";
+var utilities = {};
+var hasRequiredUtilities;
+function requireUtilities() {
+  if (hasRequiredUtilities) return utilities;
+  hasRequiredUtilities = 1;
+  Object.defineProperty(utilities, "__esModule", { value: true });
+  utilities.camelCase = void 0;
+  var CUSTOM_PROPERTY_REGEX = /^--[a-zA-Z0-9_-]+$/;
+  var HYPHEN_REGEX = /-([a-z])/g;
+  var NO_HYPHEN_REGEX = /^[^-]+$/;
+  var VENDOR_PREFIX_REGEX = /^-(webkit|moz|ms|o|khtml)-/;
+  var MS_VENDOR_PREFIX_REGEX = /^-(ms)-/;
+  var skipCamelCase = function(property) {
+    return !property || NO_HYPHEN_REGEX.test(property) || CUSTOM_PROPERTY_REGEX.test(property);
+  };
+  var capitalize = function(match, character) {
+    return character.toUpperCase();
+  };
+  var trimHyphen = function(match, prefix) {
+    return "".concat(prefix, "-");
+  };
+  var camelCase = function(property, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    if (skipCamelCase(property)) {
+      return property;
+    }
+    property = property.toLowerCase();
+    if (options.reactCompat) {
+      property = property.replace(MS_VENDOR_PREFIX_REGEX, trimHyphen);
+    } else {
+      property = property.replace(VENDOR_PREFIX_REGEX, trimHyphen);
+    }
+    return property.replace(HYPHEN_REGEX, capitalize);
+  };
+  utilities.camelCase = camelCase;
+  return utilities;
+}
+var cjs;
+var hasRequiredCjs;
+function requireCjs() {
+  if (hasRequiredCjs) return cjs;
+  hasRequiredCjs = 1;
+  var __importDefault = cjs && cjs.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  var style_to_object_1 = __importDefault(requireCjs$1());
+  var utilities_1 = requireUtilities();
+  function StyleToJS(style, options) {
+    var output = {};
+    if (!style || typeof style !== "string") {
+      return output;
+    }
+    (0, style_to_object_1.default)(style, function(property, value) {
+      if (property && value) {
+        output[(0, utilities_1.camelCase)(property, options)] = value;
+      }
+    });
+    return output;
+  }
+  StyleToJS.default = StyleToJS;
+  cjs = StyleToJS;
+  return cjs;
+}
+var cjsExports = requireCjs();
+const styleToJs = /* @__PURE__ */ getDefaultExportFromCjs(cjsExports);
+export {
+  styleToJs as s
+};

package/.output/server/_libs/style-to-object.mjs

@@ -0,0 +1,38 @@
+import { r as requireCjs$1 } from "./inline-style-parser.mjs";
+var cjs = {};
+var hasRequiredCjs;
+function requireCjs() {
+  if (hasRequiredCjs) return cjs;
+  hasRequiredCjs = 1;
+  var __importDefault = cjs && cjs.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(cjs, "__esModule", { value: true });
+  cjs.default = StyleToObject;
+  const inline_style_parser_1 = __importDefault(requireCjs$1());
+  function StyleToObject(style, iterator) {
+    let styleObject = null;
+    if (!style || typeof style !== "string") {
+      return styleObject;
+    }
+    const declarations = (0, inline_style_parser_1.default)(style);
+    const hasIterator = typeof iterator === "function";
+    declarations.forEach((declaration) => {
+      if (declaration.type !== "declaration") {
+        return;
+      }
+      const { property, value } = declaration;
+      if (hasIterator) {
+        iterator(property, value, declaration);
+      } else if (value) {
+        styleObject = styleObject || {};
+        styleObject[property] = value;
+      }
+    });
+    return styleObject;
+  }
+  return cjs;
+}
+export {
+  requireCjs as r
+};