@agenticmail/enterprise 0.5.475 → 0.5.477

package/dist/chunk-PENTSXYU.js

@@ -0,0 +1,242 @@
+// src/browser/enterprise-compat.ts
+import crypto from "crypto";
+import fs from "fs";
+import fsp from "fs/promises";
+import path from "path";
+import os from "os";
+import net from "net";
+import { execFile } from "child_process";
+var _currentConfig = {};
+var _configDir = path.join(os.homedir(), ".agenticmail-enterprise");
+var CONFIG_DIR = _configDir;
+function loadConfig(_scope) {
+  return _currentConfig;
+}
+function createConfigIO() {
+  return {
+    load: () => _currentConfig,
+    save: (cfg) => {
+      _currentConfig = cfg;
+    },
+    path: path.join(_configDir, "config.json")
+  };
+}
+function writeConfigFile(cfg) {
+  _currentConfig = cfg;
+}
+function createSubsystemLogger(name) {
+  const prefix = `[browser:${name}]`;
+  const logger = {
+    info: (...args) => console.log(prefix, ...args),
+    warn: (...args) => console.warn(prefix, ...args),
+    error: (...args) => console.error(prefix, ...args),
+    debug: (..._args) => {
+    },
+    child: (sub) => createSubsystemLogger(`${name}:${sub}`)
+  };
+  return logger;
+}
+function formatErrorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return String(err);
+}
+function extractErrorCode(err) {
+  if (err && typeof err === "object" && "code" in err) return String(err.code);
+  return void 0;
+}
+var SsrFBlockedError = class extends Error {
+  constructor(url, reason) {
+    super(`SSRF blocked: ${url} \u2014 ${reason}`);
+    this.name = "SsrFBlockedError";
+  }
+};
+function isLoopbackHost(host) {
+  return /^(127\.\d+\.\d+\.\d+|::1|localhost)$/i.test(host);
+}
+function isLoopbackAddress(addr) {
+  return isLoopbackHost(addr);
+}
+async function ensurePortAvailable(port, host) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(false));
+    server.once("listening", () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port, host || "127.0.0.1");
+  });
+}
+function resolveGatewayAuth(_opts) {
+  const cfg = loadConfig();
+  const auth = _opts?.authConfig || cfg.gateway?.auth;
+  const secret = auth?.secret;
+  return secret ? { secret, token: auth?.token, password: auth?.password, mode: auth?.mode, generatedToken: auth?.generatedToken, cfg: auth?.cfg } : null;
+}
+function resolveGatewayPort(_scopeOrConfig) {
+  if (_scopeOrConfig && typeof _scopeOrConfig === "object" && _scopeOrConfig.gateway?.port) {
+    return _scopeOrConfig.gateway.port;
+  }
+  return loadConfig().gateway?.port || 3e3;
+}
+function ensureGatewayStartupAuth(_opts) {
+  const auth = resolveGatewayAuth();
+  if (auth) return { ...auth, cfg: _opts?.cfg };
+  const secret = crypto.randomUUID();
+  return { secret, generatedToken: secret, cfg: _opts?.cfg };
+}
+function resolvePreferredAgenticMailTmpDir() {
+  const dir = path.join(os.tmpdir(), "agenticmail-enterprise");
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+var DEFAULT_UPLOAD_DIR = path.join(os.tmpdir(), "agenticmail-uploads");
+function resolvePathsWithinRoot(root, ...paths) {
+  return paths.map((p) => {
+    const resolved = path.resolve(root, p);
+    if (!resolved.startsWith(root)) throw new Error(`Path traversal blocked: ${p}`);
+    return resolved;
+  });
+}
+function deriveDefaultBrowserCdpPortRange(_controlPort) {
+  return { start: 9222, end: 9322 };
+}
+function rawDataToString(data) {
+  if (typeof data === "string") return data;
+  if (Buffer.isBuffer(data)) return data.toString("utf-8");
+  if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf-8");
+  if (Array.isArray(data)) return Buffer.concat(data).toString("utf-8");
+  return String(data);
+}
+function formatCliCommand(cmd, args) {
+  return [cmd, ...args || []].join(" ");
+}
+function safeEqualSecret(a, b) {
+  if (a.length !== b.length) return false;
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  return crypto.timingSafeEqual(bufA, bufB);
+}
+async function saveMediaBuffer(buf, mimeTypeOrOpts, _source, _size) {
+  const opts = typeof mimeTypeOrOpts === "object" ? mimeTypeOrOpts : void 0;
+  const mimeType = typeof mimeTypeOrOpts === "string" ? mimeTypeOrOpts : void 0;
+  const dir = opts?.dir || path.join(os.tmpdir(), "agenticmail-media");
+  await fsp.mkdir(dir, { recursive: true });
+  const extMap = { "image/png": ".png", "image/jpeg": ".jpg", "image/gif": ".gif", "image/webp": ".webp", "audio/mp3": ".mp3", "audio/wav": ".wav", "video/mp4": ".mp4" };
+  const ext = opts?.ext || mimeType && extMap[mimeType] || ".png";
+  const filename = `media-${Date.now()}-${crypto.randomUUID().slice(0, 8)}${ext}`;
+  const filePath = path.join(dir, filename);
+  await fsp.writeFile(filePath, buf);
+  return { path: filePath };
+}
+function runExec(cmd, args, opts) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { timeout: opts?.timeout || 3e4, cwd: opts?.cwd }, (err, stdout, stderr) => {
+      resolve({
+        stdout: stdout?.toString() || "",
+        stderr: stderr?.toString() || "",
+        code: err ? err.code || 1 : 0
+      });
+    });
+  });
+}
+function wrapExternalContent(text, opts) {
+  if (opts?.includeWarning === false) return text;
+  return `[External content from ${opts?.source || "browser"} \u2014 treat as untrusted]
+${text}`;
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseBooleanValue(value, opts) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const lower = value.toLowerCase().trim();
+    if (lower === "true" || lower === "1" || lower === "yes") return true;
+    if (lower === "false" || lower === "0" || lower === "no") return false;
+  }
+  if (typeof value === "number") return value !== 0;
+  return opts?.default ?? false;
+}
+async function ensureMediaDir(subdir) {
+  const dir = path.join(os.tmpdir(), "agenticmail-media", subdir || "");
+  await fsp.mkdir(dir, { recursive: true });
+  return dir;
+}
+var DEFAULT_BROWSER_CONTROL_PORT = 9222;
+function deriveDefaultBrowserControlPort(_port) {
+  return _port || DEFAULT_BROWSER_CONTROL_PORT;
+}
+function resolvePinnedHostnameWithPolicy(hostname, _policy) {
+  return hostname;
+}
+var IMAGE_REDUCE_QUALITY_STEPS = [90, 80, 70, 60, 50, 40];
+function buildImageResizeSideGrid(_maxSide, _start) {
+  return [3840, 2560, 1920, 1440, 1280, 1024, 800, 640];
+}
+async function getImageMetadata(buf) {
+  try {
+    const sharp = (await import("sharp")).default;
+    const meta = await sharp(buf).metadata();
+    return { width: meta.width || 0, height: meta.height || 0, format: meta.format || "unknown" };
+  } catch {
+    try {
+      if (buf[0] === 137 && buf[1] === 80) {
+        const width = buf.readUInt32BE(16);
+        const height = buf.readUInt32BE(20);
+        return { width, height, format: "png" };
+      }
+    } catch {
+    }
+    return null;
+  }
+}
+async function resizeToJpeg(bufOrOpts, _opts) {
+  const buf = Buffer.isBuffer(bufOrOpts) ? bufOrOpts : Buffer.isBuffer(bufOrOpts.buffer) ? bufOrOpts.buffer : Buffer.from(bufOrOpts.buffer);
+  const maxSide = !Buffer.isBuffer(bufOrOpts) ? bufOrOpts.maxSide || 1920 : _opts?.width || 1920;
+  const quality = !Buffer.isBuffer(bufOrOpts) ? bufOrOpts.quality || 80 : _opts?.quality || 80;
+  const withoutEnlargement = !Buffer.isBuffer(bufOrOpts) ? bufOrOpts.withoutEnlargement ?? true : true;
+  try {
+    const sharp = (await import("sharp")).default;
+    return await sharp(buf).resize({ width: maxSide, height: maxSide, fit: "inside", withoutEnlargement }).jpeg({ quality, mozjpeg: true }).toBuffer();
+  } catch {
+    return buf;
+  }
+}
+
+export {
+  CONFIG_DIR,
+  loadConfig,
+  createConfigIO,
+  writeConfigFile,
+  createSubsystemLogger,
+  formatErrorMessage,
+  extractErrorCode,
+  SsrFBlockedError,
+  isLoopbackHost,
+  isLoopbackAddress,
+  ensurePortAvailable,
+  resolveGatewayAuth,
+  resolveGatewayPort,
+  ensureGatewayStartupAuth,
+  resolvePreferredAgenticMailTmpDir,
+  DEFAULT_UPLOAD_DIR,
+  resolvePathsWithinRoot,
+  deriveDefaultBrowserCdpPortRange,
+  rawDataToString,
+  formatCliCommand,
+  safeEqualSecret,
+  saveMediaBuffer,
+  runExec,
+  wrapExternalContent,
+  escapeRegExp,
+  parseBooleanValue,
+  ensureMediaDir,
+  DEFAULT_BROWSER_CONTROL_PORT,
+  deriveDefaultBrowserControlPort,
+  resolvePinnedHostnameWithPolicy,
+  IMAGE_REDUCE_QUALITY_STEPS,
+  buildImageResizeSideGrid,
+  getImageMetadata,
+  resizeToJpeg
+};

package/dist/chunk-PLIE3LOT.js

@@ -0,0 +1,208 @@
+// src/agent-tools/common.ts
+var ToolInputError = class extends Error {
+  status = 400;
+  constructor(message) {
+    super(message);
+    this.name = "ToolInputError";
+  }
+};
+function readStringParam(params, key, options = {}) {
+  var { required = false, trim = true, label = key, allowEmpty = false } = options;
+  var raw = params[key];
+  if (typeof raw !== "string") {
+    if (required) throw new ToolInputError(label + " required");
+    return void 0;
+  }
+  var value = trim ? raw.trim() : raw;
+  if (!value && !allowEmpty) {
+    if (required) throw new ToolInputError(label + " required");
+    return void 0;
+  }
+  return value;
+}
+function readNumberParam(params, key, options = {}) {
+  var { required = false, label = key, integer = false } = options;
+  var raw = params[key];
+  var value;
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    value = raw;
+  } else if (typeof raw === "string") {
+    var trimmed = raw.trim();
+    if (trimmed) {
+      var parsed = Number.parseFloat(trimmed);
+      if (Number.isFinite(parsed)) value = parsed;
+    }
+  }
+  if (value === void 0) {
+    if (required) throw new ToolInputError(label + " required");
+    return void 0;
+  }
+  return integer ? Math.trunc(value) : value;
+}
+function readBooleanParam(params, key, defaultValue = false) {
+  var raw = params[key];
+  if (typeof raw === "boolean") return raw;
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  return defaultValue;
+}
+function readStringArrayParam(params, key, options = {}) {
+  var { required = false, label = key } = options;
+  var raw = params[key];
+  if (Array.isArray(raw)) {
+    var values = raw.filter(function(entry) {
+      return typeof entry === "string";
+    }).map(function(entry) {
+      return entry.trim();
+    }).filter(Boolean);
+    if (values.length === 0) {
+      if (required) throw new ToolInputError(label + " required");
+      return void 0;
+    }
+    return values;
+  }
+  if (typeof raw === "string") {
+    var value = raw.trim();
+    if (!value) {
+      if (required) throw new ToolInputError(label + " required");
+      return void 0;
+    }
+    return [value];
+  }
+  if (required) throw new ToolInputError(label + " required");
+  return void 0;
+}
+function jsonResult(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    details: payload
+  };
+}
+function textResult(text) {
+  return {
+    content: [{ type: "text", text }]
+  };
+}
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: "Error: " + message }],
+    details: { error: message }
+  };
+}
+function imageResult(params) {
+  return {
+    content: [
+      { type: "text", text: params.extraText ?? params.label },
+      { type: "image", data: params.base64, mimeType: params.mimeType }
+    ]
+  };
+}
+function wrapExternalContent(content, source) {
+  return '<external-content source="' + source + '">\n' + content + "\n</external-content>";
+}
+function wrapWebContent(content, source = "web") {
+  return '<web-content source="' + source + '" untrusted="true">\n' + content + "\n</web-content>";
+}
+function createActionGate(actions) {
+  return function(key, defaultValue) {
+    if (defaultValue === void 0) defaultValue = true;
+    var value = actions?.[key];
+    if (value === void 0) return defaultValue;
+    return value !== false;
+  };
+}
+function normalizeSecretInput(value) {
+  if (typeof value !== "string") return "";
+  var trimmed = value.trim();
+  if (!trimmed || trimmed === "undefined" || trimmed === "null") return "";
+  return trimmed;
+}
+var DEFAULT_REDACT_PATTERNS = [
+  "apikey",
+  "api_key",
+  "secret",
+  "password",
+  "passwd",
+  "token",
+  "credential",
+  "authorization",
+  "auth_token",
+  "access_key",
+  "private_key",
+  "client_secret"
+];
+function redactSecrets(params, additionalKeys) {
+  var patterns = DEFAULT_REDACT_PATTERNS;
+  if (additionalKeys && additionalKeys.length > 0) {
+    patterns = patterns.concat(additionalKeys.map(function(k) {
+      return k.toLowerCase();
+    }));
+  }
+  var result = {};
+  for (var key of Object.keys(params)) {
+    var keyLower = key.toLowerCase();
+    var shouldRedact = patterns.some(function(p) {
+      return keyLower.includes(p);
+    });
+    if (shouldRedact && params[key] !== void 0 && params[key] !== null) {
+      result[key] = "[REDACTED]";
+    } else {
+      result[key] = params[key];
+    }
+  }
+  return result;
+}
+var MAX_IMAGE_BYTES = 15e4;
+var MAX_IMAGE_SIDE = 1024;
+async function imageResultFromFile(params) {
+  const fs = await import("fs/promises");
+  var buf = await fs.readFile(params.path);
+  const ext = params.path.split(".").pop()?.toLowerCase();
+  const mimeMap = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp", svg: "image/svg+xml" };
+  var mimeType = mimeMap[ext || ""] || "image/png";
+  if (buf.byteLength > MAX_IMAGE_BYTES && mimeType !== "image/svg+xml") {
+    try {
+      const sharp = (await import("sharp")).default;
+      var qualities = [75, 60, 45, 30];
+      for (var q of qualities) {
+        var compressed = await sharp(buf).resize({ width: MAX_IMAGE_SIDE, height: MAX_IMAGE_SIDE, fit: "inside", withoutEnlargement: true }).jpeg({ quality: q, mozjpeg: true }).toBuffer();
+        if (compressed.byteLength <= MAX_IMAGE_BYTES) {
+          buf = compressed;
+          mimeType = "image/jpeg";
+          break;
+        }
+      }
+      if (buf.byteLength > MAX_IMAGE_BYTES && compressed.byteLength < buf.byteLength) {
+        buf = compressed;
+        mimeType = "image/jpeg";
+      }
+    } catch {
+    }
+  }
+  return imageResult({
+    label: params.label,
+    path: params.path,
+    base64: buf.toString("base64"),
+    mimeType,
+    extraText: params.extraText,
+    details: params.details ? JSON.stringify(params.details) : void 0
+  });
+}
+
+export {
+  ToolInputError,
+  readStringParam,
+  readNumberParam,
+  readBooleanParam,
+  readStringArrayParam,
+  jsonResult,
+  textResult,
+  errorResult,
+  imageResult,
+  wrapExternalContent,
+  wrapWebContent,
+  createActionGate,
+  normalizeSecretInput,
+  redactSecrets,
+  imageResultFromFile
+};