@solongate/core 0.1.0

package/dist/index.js

@@ -0,0 +1,661 @@
+import { z } from 'zod';
+
+// src/errors.ts
+var SolonGateError = class extends Error {
+  code;
+  timestamp;
+  details;
+  constructor(message, code, details = {}) {
+    super(message);
+    this.name = "SolonGateError";
+    this.code = code;
+    this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    this.details = Object.freeze({ ...details });
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Serializable representation for logging and API responses.
+   * Never includes stack traces (information leakage prevention).
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      timestamp: this.timestamp,
+      details: this.details
+    };
+  }
+};
+var PolicyDeniedError = class extends SolonGateError {
+  constructor(toolName, reason, details = {}) {
+    super(
+      `Policy denied execution of tool "${toolName}": ${reason}`,
+      "POLICY_DENIED",
+      { toolName, reason, ...details }
+    );
+    this.name = "PolicyDeniedError";
+  }
+};
+var TrustEscalationError = class extends SolonGateError {
+  constructor(message) {
+    super(message, "TRUST_ESCALATION");
+    this.name = "TrustEscalationError";
+  }
+};
+var SchemaValidationError = class extends SolonGateError {
+  constructor(toolName, validationErrors) {
+    super(
+      `Schema validation failed for tool "${toolName}": ${validationErrors.join("; ")}`,
+      "SCHEMA_VALIDATION_FAILED",
+      { toolName, validationErrors }
+    );
+    this.name = "SchemaValidationError";
+  }
+};
+var RateLimitError = class extends SolonGateError {
+  constructor(toolName, limitPerMinute) {
+    super(
+      `Rate limit exceeded for tool "${toolName}": max ${limitPerMinute}/min`,
+      "RATE_LIMIT_EXCEEDED",
+      { toolName, limitPerMinute }
+    );
+    this.name = "RateLimitError";
+  }
+};
+var ToolNotFoundError = class extends SolonGateError {
+  constructor(toolName, serverName) {
+    super(
+      `Tool "${toolName}" not found on server "${serverName}"`,
+      "TOOL_NOT_FOUND",
+      { toolName, serverName }
+    );
+    this.name = "ToolNotFoundError";
+  }
+};
+var UnsafeConfigurationError = class extends SolonGateError {
+  constructor(message, field) {
+    super(
+      `Unsafe configuration detected: ${message}`,
+      "UNSAFE_CONFIGURATION",
+      { field }
+    );
+    this.name = "UnsafeConfigurationError";
+  }
+};
+var InputGuardError = class extends SolonGateError {
+  constructor(toolName, threats) {
+    super(
+      `Input guard blocked tool "${toolName}": ${threats.map((t) => t.description).join("; ")}`,
+      "INPUT_GUARD_BLOCKED",
+      { toolName, threatCount: threats.length, threats }
+    );
+    this.name = "InputGuardError";
+  }
+};
+var NetworkError = class extends SolonGateError {
+  constructor(operation, statusCode, details = {}) {
+    super(
+      `Network error during ${operation}${statusCode ? ` (HTTP ${statusCode})` : ""}`,
+      "NETWORK_ERROR",
+      { operation, statusCode, ...details }
+    );
+    this.name = "NetworkError";
+  }
+};
+
+// src/trust.ts
+var TrustLevel = {
+  UNTRUSTED: "UNTRUSTED",
+  VERIFIED: "VERIFIED",
+  TRUSTED: "TRUSTED"
+};
+function isValidTrustLevel(value) {
+  return typeof value === "string" && Object.values(TrustLevel).includes(value);
+}
+function assertValidTransition(from, to) {
+  if (to === TrustLevel.TRUSTED) {
+    throw new TrustEscalationError(
+      "Cannot escalate to TRUSTED level. TRUSTED is reserved for system-internal operations."
+    );
+  }
+  if (from === TrustLevel.VERIFIED && to === TrustLevel.UNTRUSTED) {
+    return;
+  }
+  if (from === TrustLevel.UNTRUSTED && to === TrustLevel.VERIFIED) {
+    return;
+  }
+  if (from === to) {
+    return;
+  }
+  throw new TrustEscalationError(
+    `Invalid trust transition from ${from} to ${to}`
+  );
+}
+var Permission = {
+  READ: "READ",
+  WRITE: "WRITE",
+  EXECUTE: "EXECUTE"
+};
+var PermissionSchema = z.enum(["READ", "WRITE", "EXECUTE"]);
+function createPermissionSet(permissions) {
+  for (const p of permissions) {
+    PermissionSchema.parse(p);
+  }
+  return new Set(permissions);
+}
+var NO_PERMISSIONS = Object.freeze(
+  /* @__PURE__ */ new Set()
+);
+var READ_ONLY = Object.freeze(
+  /* @__PURE__ */ new Set([Permission.READ])
+);
+function hasPermission(permissions, required) {
+  return permissions.has(required);
+}
+function hasAllPermissions(permissions, required) {
+  return required.every((p) => permissions.has(p));
+}
+function permissionForMethod(method) {
+  if (method.startsWith("resources/") || method.startsWith("prompts/") || method === "tools/list") {
+    return Permission.READ;
+  }
+  if (method === "tools/call") {
+    return Permission.EXECUTE;
+  }
+  return Permission.EXECUTE;
+}
+var PolicyEffect = {
+  ALLOW: "ALLOW",
+  DENY: "DENY"
+};
+var PolicyRuleSchema = z.object({
+  id: z.string().min(1).max(256),
+  description: z.string().max(1024),
+  effect: z.enum(["ALLOW", "DENY"]),
+  priority: z.number().int().min(0).max(1e4).default(1e3),
+  toolPattern: z.string().min(1).max(512),
+  permission: z.enum(["READ", "WRITE", "EXECUTE"]),
+  minimumTrustLevel: z.enum(["UNTRUSTED", "VERIFIED", "TRUSTED"]),
+  argumentConstraints: z.record(z.unknown()).optional(),
+  pathConstraints: z.object({
+    allowed: z.array(z.string()).optional(),
+    denied: z.array(z.string()).optional(),
+    rootDirectory: z.string().optional(),
+    allowSymlinks: z.boolean().optional()
+  }).optional(),
+  commandConstraints: z.object({
+    allowed: z.array(z.string()).optional(),
+    denied: z.array(z.string()).optional()
+  }).optional(),
+  enabled: z.boolean().default(true),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime()
+});
+var PolicySetSchema = z.object({
+  id: z.string().min(1).max(256),
+  name: z.string().min(1).max(256),
+  description: z.string().max(2048),
+  version: z.number().int().min(0),
+  rules: z.array(PolicyRuleSchema),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime()
+});
+
+// src/tool.ts
+function createToolCapability(params) {
+  return {
+    maxPermissions: [],
+    defaultPermissions: [],
+    hasSideEffects: true,
+    accessesSensitiveData: true,
+    rateLimitPerMinute: 60,
+    ...params
+  };
+}
+
+// src/context.ts
+function createSecurityContext(params) {
+  return {
+    trustLevel: "UNTRUSTED",
+    grantedPermissions: /* @__PURE__ */ new Set(),
+    sessionId: null,
+    metadata: {},
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...params
+  };
+}
+
+// src/constants.ts
+var DEFAULT_POLICY_EFFECT = "DENY";
+var MAX_RULES_PER_POLICY_SET = 1e3;
+var MAX_ARGUMENT_DEPTH = 10;
+var MAX_ARGUMENTS_SIZE_BYTES = 1048576;
+var MAX_TOOL_NAME_LENGTH = 256;
+var MAX_SERVER_NAME_LENGTH = 256;
+var DEFAULT_RATE_LIMIT_PER_MINUTE = 60;
+var MAX_RATE_LIMIT_PER_MINUTE = 1e4;
+var SECURITY_CONTEXT_TIMEOUT_MS = 5 * 60 * 1e3;
+var POLICY_EVALUATION_TIMEOUT_MS = 100;
+var INPUT_GUARD_MAX_LENGTH = 4096;
+var INPUT_GUARD_ENTROPY_THRESHOLD = 4.5;
+var INPUT_GUARD_MIN_ENTROPY_LENGTH = 32;
+var INPUT_GUARD_MAX_WILDCARDS = 3;
+var TOKEN_DEFAULT_TTL_SECONDS = 30;
+var TOKEN_MIN_SECRET_LENGTH = 32;
+var TOKEN_MAX_AGE_SECONDS = 300;
+var RATE_LIMIT_WINDOW_MS = 6e4;
+var RATE_LIMIT_MAX_ENTRIES = 1e4;
+var UNSAFE_CONFIGURATION_WARNINGS = {
+  WILDCARD_ALLOW: "Wildcard ALLOW rules grant permission to ALL tools. This bypasses the default-deny model.",
+  TRUSTED_LEVEL_EXTERNAL: "Setting trust level to TRUSTED for external requests bypasses all security checks.",
+  WRITE_WITHOUT_READ: "Granting WRITE without READ is unusual and may indicate a misconfiguration.",
+  EXECUTE_WITHOUT_REVIEW: "EXECUTE permission allows tools to perform arbitrary actions. Review carefully.",
+  RATE_LIMIT_ZERO: "A rate limit of 0 means unlimited calls. This removes protection against runaway loops.",
+  DISABLED_VALIDATION: "Disabling schema validation removes input sanitization protections."
+};
+
+// src/mcp-types.ts
+function createDeniedToolResult(reason) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          error: "POLICY_DENIED",
+          message: reason,
+          hint: "This tool call was blocked by SolonGate security policy. Check your policy configuration."
+        })
+      }
+    ],
+    isError: true
+  };
+}
+var DEFAULT_OPTIONS = {
+  maxDepth: MAX_ARGUMENT_DEPTH,
+  maxSizeBytes: MAX_ARGUMENTS_SIZE_BYTES,
+  stripUnknown: false
+};
+function validateToolInput(schema, input, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const errors = [];
+  const sizeError = checkInputSize(input, opts.maxSizeBytes);
+  if (sizeError) {
+    return { valid: false, errors: [sizeError], sanitized: null };
+  }
+  const depthError = checkInputDepth(input, opts.maxDepth);
+  if (depthError) {
+    return { valid: false, errors: [depthError], sanitized: null };
+  }
+  const result = schema.safeParse(input);
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      const path = issue.path.length > 0 ? issue.path.join(".") : "root";
+      errors.push(`${path}: ${issue.message}`);
+    }
+    return { valid: false, errors, sanitized: null };
+  }
+  return {
+    valid: true,
+    errors: [],
+    sanitized: result.data
+  };
+}
+function createStrictSchema(shape) {
+  return z.object(shape).strict();
+}
+function checkInputSize(input, maxBytes) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(input);
+  } catch {
+    return "Input cannot be serialized to JSON";
+  }
+  const sizeBytes = new TextEncoder().encode(serialized).length;
+  if (sizeBytes > maxBytes) {
+    return `Input size ${sizeBytes} bytes exceeds maximum ${maxBytes} bytes`;
+  }
+  return null;
+}
+function checkInputDepth(input, maxDepth) {
+  const depth = measureDepth(input, 0);
+  if (depth > maxDepth) {
+    return `Input depth ${depth} exceeds maximum ${maxDepth}`;
+  }
+  return null;
+}
+function measureDepth(value, currentDepth) {
+  if (currentDepth > MAX_ARGUMENT_DEPTH + 1) {
+    return currentDepth;
+  }
+  if (value === null || value === void 0 || typeof value !== "object") {
+    return currentDepth;
+  }
+  if (Array.isArray(value)) {
+    let maxChildDepth2 = currentDepth + 1;
+    for (const item of value) {
+      const childDepth = measureDepth(item, currentDepth + 1);
+      if (childDepth > maxChildDepth2) maxChildDepth2 = childDepth;
+    }
+    return maxChildDepth2;
+  }
+  let maxChildDepth = currentDepth + 1;
+  for (const key of Object.keys(value)) {
+    const childDepth = measureDepth(
+      value[key],
+      currentDepth + 1
+    );
+    if (childDepth > maxChildDepth) maxChildDepth = childDepth;
+  }
+  return maxChildDepth;
+}
+
+// src/input-guard.ts
+var DEFAULT_INPUT_GUARD_CONFIG = Object.freeze({
+  pathTraversal: true,
+  shellInjection: true,
+  wildcardAbuse: true,
+  lengthLimit: 4096,
+  entropyLimit: true,
+  ssrf: true,
+  sqlInjection: true
+});
+var PATH_TRAVERSAL_PATTERNS = [
+  /\.\.\//,
+  // ../
+  /\.\.\\/,
+  // ..\
+  /%2e%2e/i,
+  // URL-encoded ..
+  /%2e\./i,
+  // partial URL-encoded
+  /\.%2e/i,
+  // partial URL-encoded
+  /%252e%252e/i,
+  // double URL-encoded
+  /\.\.\0/
+  // null byte variant
+];
+var SENSITIVE_PATHS = [
+  /\/etc\/passwd/i,
+  /\/etc\/shadow/i,
+  /\/proc\//i,
+  /\/dev\//i,
+  /c:\\windows\\system32/i,
+  /c:\\windows\\syswow64/i,
+  /\/root\//i,
+  /~\//,
+  /\.env(\.|$)/i,
+  // .env, .env.local, .env.production
+  /\.aws\/credentials/i,
+  // AWS credentials
+  /\.ssh\/id_/i,
+  // SSH keys
+  /\.kube\/config/i,
+  // Kubernetes config
+  /wp-config\.php/i,
+  // WordPress config
+  /\.git\/config/i,
+  // Git config
+  /\.npmrc/i,
+  // npm credentials
+  /\.pypirc/i
+  // PyPI credentials
+];
+function detectPathTraversal(value) {
+  for (const pattern of PATH_TRAVERSAL_PATTERNS) {
+    if (pattern.test(value)) return true;
+  }
+  for (const pattern of SENSITIVE_PATHS) {
+    if (pattern.test(value)) return true;
+  }
+  return false;
+}
+var SHELL_INJECTION_PATTERNS = [
+  /[;|&`]/,
+  // Command separators and backtick execution
+  /\$\(/,
+  // Command substitution $(...)
+  /\$\{/,
+  // Variable expansion ${...}
+  />\s*/,
+  // Output redirect
+  /<\s*/,
+  // Input redirect
+  /&&/,
+  // AND chaining
+  /\|\|/,
+  // OR chaining
+  /\beval\b/i,
+  // eval command
+  /\bexec\b/i,
+  // exec command
+  /\bsystem\b/i,
+  // system call
+  /%0a/i,
+  // URL-encoded newline
+  /%0d/i,
+  // URL-encoded carriage return
+  /%09/i,
+  // URL-encoded tab
+  /\r\n/,
+  // CRLF injection
+  /\n/
+  // Newline (command separator on Unix)
+];
+function detectShellInjection(value) {
+  for (const pattern of SHELL_INJECTION_PATTERNS) {
+    if (pattern.test(value)) return true;
+  }
+  return false;
+}
+var MAX_WILDCARDS_PER_VALUE = 3;
+function detectWildcardAbuse(value) {
+  if (value.includes("**")) return true;
+  const wildcardCount = (value.match(/\*/g) || []).length;
+  if (wildcardCount > MAX_WILDCARDS_PER_VALUE) return true;
+  return false;
+}
+var SSRF_PATTERNS = [
+  /^https?:\/\/localhost\b/i,
+  /^https?:\/\/127\.\d{1,3}\.\d{1,3}\.\d{1,3}/,
+  /^https?:\/\/0\.0\.0\.0/,
+  /^https?:\/\/\[::1\]/,
+  // IPv6 loopback
+  /^https?:\/\/10\.\d{1,3}\.\d{1,3}\.\d{1,3}/,
+  // 10.x.x.x
+  /^https?:\/\/172\.(1[6-9]|2\d|3[01])\./,
+  // 172.16-31.x.x
+  /^https?:\/\/192\.168\./,
+  // 192.168.x.x
+  /^https?:\/\/169\.254\./,
+  // Link-local / AWS metadata
+  /metadata\.google\.internal/i,
+  // GCP metadata
+  /^https?:\/\/metadata\b/i,
+  // Generic metadata endpoint
+  // IPv6 bypass patterns
+  /^https?:\/\/\[fe80:/i,
+  // IPv6 link-local
+  /^https?:\/\/\[fc00:/i,
+  // IPv6 unique local
+  /^https?:\/\/\[fd[0-9a-f]{2}:/i,
+  // IPv6 unique local (fd00::/8)
+  /^https?:\/\/\[::ffff:127\./i,
+  // IPv4-mapped IPv6 loopback
+  /^https?:\/\/\[::ffff:10\./i,
+  // IPv4-mapped IPv6 private
+  /^https?:\/\/\[::ffff:172\.(1[6-9]|2\d|3[01])\./i,
+  // IPv4-mapped IPv6 private
+  /^https?:\/\/\[::ffff:192\.168\./i,
+  // IPv4-mapped IPv6 private
+  /^https?:\/\/\[::ffff:169\.254\./i,
+  // IPv4-mapped IPv6 link-local
+  // Hex IP bypass (e.g., 0x7f000001 = 127.0.0.1)
+  /^https?:\/\/0x[0-9a-f]+\b/i,
+  // Octal IP bypass (e.g., 0177.0.0.1 = 127.0.0.1)
+  /^https?:\/\/0[0-7]{1,3}\./
+];
+function detectDecimalIP(value) {
+  const match = value.match(/^https?:\/\/(\d{8,10})(?:[:/]|$)/);
+  if (!match || !match[1]) return false;
+  const decimal = parseInt(match[1], 10);
+  if (isNaN(decimal) || decimal > 4294967295) return false;
+  return decimal >= 2130706432 && decimal <= 2147483647 || // 127.0.0.0/8
+  decimal >= 167772160 && decimal <= 184549375 || // 10.0.0.0/8
+  decimal >= 2886729728 && decimal <= 2887778303 || // 172.16.0.0/12
+  decimal >= 3232235520 && decimal <= 3232301055 || // 192.168.0.0/16
+  decimal >= 2851995648 && decimal <= 2852061183 || // 169.254.0.0/16
+  decimal === 0;
+}
+function detectSSRF(value) {
+  for (const pattern of SSRF_PATTERNS) {
+    if (pattern.test(value)) return true;
+  }
+  if (detectDecimalIP(value)) return true;
+  return false;
+}
+var SQL_INJECTION_PATTERNS = [
+  /'\s{0,20}(OR|AND)\s{0,20}'.{0,200}'/i,
+  // ' OR '1'='1 — bounded to prevent ReDoS
+  /'\s{0,10};\s{0,10}(DROP|DELETE|UPDATE|INSERT|ALTER|CREATE|EXEC)/i,
+  // '; DROP TABLE
+  /UNION\s+(ALL\s+)?SELECT/i,
+  // UNION SELECT
+  /--\s*$/m,
+  // SQL comment at end of line
+  /\/\*.{0,500}?\*\//,
+  // SQL block comment — bounded + non-greedy
+  /\bSLEEP\s*\(/i,
+  // Time-based injection
+  /\bBENCHMARK\s*\(/i,
+  // MySQL benchmark
+  /\bWAITFOR\s+DELAY/i,
+  // MSSQL delay
+  /\b(LOAD_FILE|INTO\s+OUTFILE|INTO\s+DUMPFILE)\b/i
+  // File operations
+];
+function detectSQLInjection(value) {
+  for (const pattern of SQL_INJECTION_PATTERNS) {
+    if (pattern.test(value)) return true;
+  }
+  return false;
+}
+function checkLengthLimits(value, maxLength = 4096) {
+  return value.length <= maxLength;
+}
+var ENTROPY_THRESHOLD = 4.5;
+var MIN_LENGTH_FOR_ENTROPY_CHECK = 32;
+function checkEntropyLimits(value) {
+  if (value.length < MIN_LENGTH_FOR_ENTROPY_CHECK) return true;
+  const entropy = calculateShannonEntropy(value);
+  return entropy <= ENTROPY_THRESHOLD;
+}
+function calculateShannonEntropy(str) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const char of str) {
+    freq.set(char, (freq.get(char) ?? 0) + 1);
+  }
+  let entropy = 0;
+  const len = str.length;
+  for (const count of freq.values()) {
+    const p = count / len;
+    if (p > 0) {
+      entropy -= p * Math.log2(p);
+    }
+  }
+  return entropy;
+}
+function sanitizeInput(field, value, config = DEFAULT_INPUT_GUARD_CONFIG) {
+  const threats = [];
+  if (typeof value !== "string") {
+    if (typeof value === "object" && value !== null) {
+      return sanitizeObject(field, value, config);
+    }
+    return { safe: true, threats: [] };
+  }
+  if (config.pathTraversal && detectPathTraversal(value)) {
+    threats.push({
+      type: "PATH_TRAVERSAL",
+      field,
+      value: truncate(value, 100),
+      description: "Path traversal pattern detected"
+    });
+  }
+  if (config.shellInjection && detectShellInjection(value)) {
+    threats.push({
+      type: "SHELL_INJECTION",
+      field,
+      value: truncate(value, 100),
+      description: "Shell injection pattern detected"
+    });
+  }
+  if (config.wildcardAbuse && detectWildcardAbuse(value)) {
+    threats.push({
+      type: "WILDCARD_ABUSE",
+      field,
+      value: truncate(value, 100),
+      description: "Wildcard abuse pattern detected"
+    });
+  }
+  if (!checkLengthLimits(value, config.lengthLimit)) {
+    threats.push({
+      type: "LENGTH_EXCEEDED",
+      field,
+      value: `[${value.length} chars]`,
+      description: `Value exceeds maximum length of ${config.lengthLimit}`
+    });
+  }
+  if (config.entropyLimit && !checkEntropyLimits(value)) {
+    threats.push({
+      type: "HIGH_ENTROPY",
+      field,
+      value: truncate(value, 100),
+      description: "High entropy string detected - possible encoded payload"
+    });
+  }
+  if (config.ssrf && detectSSRF(value)) {
+    threats.push({
+      type: "SSRF",
+      field,
+      value: truncate(value, 100),
+      description: "Server-side request forgery pattern detected \u2014 internal/metadata URL blocked"
+    });
+  }
+  if (config.sqlInjection && detectSQLInjection(value)) {
+    threats.push({
+      type: "SQL_INJECTION",
+      field,
+      value: truncate(value, 100),
+      description: "SQL injection pattern detected"
+    });
+  }
+  return { safe: threats.length === 0, threats };
+}
+function sanitizeObject(basePath, obj, config) {
+  const threats = [];
+  if (Array.isArray(obj)) {
+    for (let i = 0; i < obj.length; i++) {
+      const result = sanitizeInput(`${basePath}[${i}]`, obj[i], config);
+      threats.push(...result.threats);
+    }
+  } else {
+    for (const [key, val] of Object.entries(obj)) {
+      const result = sanitizeInput(`${basePath}.${key}`, val, config);
+      threats.push(...result.threats);
+    }
+  }
+  return { safe: threats.length === 0, threats };
+}
+function truncate(str, maxLen) {
+  return str.length > maxLen ? str.slice(0, maxLen) + "..." : str;
+}
+
+// src/capability-token.ts
+var DEFAULT_TOKEN_TTL_SECONDS = 30;
+var TOKEN_ALGORITHM = "HS256";
+var MIN_SECRET_LENGTH = 32;
+
+export { DEFAULT_INPUT_GUARD_CONFIG, DEFAULT_POLICY_EFFECT, DEFAULT_RATE_LIMIT_PER_MINUTE, DEFAULT_TOKEN_TTL_SECONDS, INPUT_GUARD_ENTROPY_THRESHOLD, INPUT_GUARD_MAX_LENGTH, INPUT_GUARD_MAX_WILDCARDS, INPUT_GUARD_MIN_ENTROPY_LENGTH, InputGuardError, MAX_ARGUMENTS_SIZE_BYTES, MAX_ARGUMENT_DEPTH, MAX_RATE_LIMIT_PER_MINUTE, MAX_RULES_PER_POLICY_SET, MAX_SERVER_NAME_LENGTH, MAX_TOOL_NAME_LENGTH, MIN_SECRET_LENGTH, NO_PERMISSIONS, NetworkError, POLICY_EVALUATION_TIMEOUT_MS, Permission, PermissionSchema, PolicyDeniedError, PolicyEffect, PolicyRuleSchema, PolicySetSchema, RATE_LIMIT_MAX_ENTRIES, RATE_LIMIT_WINDOW_MS, READ_ONLY, RateLimitError, SECURITY_CONTEXT_TIMEOUT_MS, SchemaValidationError, SolonGateError, TOKEN_ALGORITHM, TOKEN_DEFAULT_TTL_SECONDS, TOKEN_MAX_AGE_SECONDS, TOKEN_MIN_SECRET_LENGTH, ToolNotFoundError, TrustEscalationError, TrustLevel, UNSAFE_CONFIGURATION_WARNINGS, UnsafeConfigurationError, assertValidTransition, checkEntropyLimits, checkLengthLimits, createDeniedToolResult, createPermissionSet, createSecurityContext, createStrictSchema, createToolCapability, detectPathTraversal, detectSQLInjection, detectSSRF, detectShellInjection, detectWildcardAbuse, hasAllPermissions, hasPermission, isValidTrustLevel, permissionForMethod, sanitizeInput, validateToolInput };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map