@agenticmail/enterprise 0.2.1 → 0.3.0

package/dist/chunk-GXIEEA2T.js

@@ -0,0 +1,48 @@
+// src/db/factory.ts
+var ADAPTER_MAP = {
+  postgres: () => import("./postgres-LN7A6MGQ.js").then((m) => m.PostgresAdapter),
+  supabase: () => import("./postgres-LN7A6MGQ.js").then((m) => m.PostgresAdapter),
+  // Supabase IS Postgres
+  neon: () => import("./postgres-LN7A6MGQ.js").then((m) => m.PostgresAdapter),
+  // Neon IS Postgres
+  cockroachdb: () => import("./postgres-LN7A6MGQ.js").then((m) => m.PostgresAdapter),
+  // CockroachDB is PG-compatible
+  mysql: () => import("./mysql-RM3S2FV5.js").then((m) => m.MysqlAdapter),
+  planetscale: () => import("./mysql-RM3S2FV5.js").then((m) => m.MysqlAdapter),
+  // PlanetScale IS MySQL
+  mongodb: () => import("./mongodb-ODTXIVPV.js").then((m) => m.MongoAdapter),
+  sqlite: () => import("./sqlite-3K5YOZ4K.js").then((m) => m.SqliteAdapter),
+  turso: () => import("./turso-LDWODSDI.js").then((m) => m.TursoAdapter),
+  dynamodb: () => import("./dynamodb-CCGL2E77.js").then((m) => m.DynamoAdapter)
+};
+async function createAdapter(config) {
+  const loader = ADAPTER_MAP[config.type];
+  if (!loader) {
+    throw new Error(
+      `Unsupported database type: "${config.type}". Supported: ${Object.keys(ADAPTER_MAP).join(", ")}`
+    );
+  }
+  const AdapterClass = await loader();
+  const adapter = new AdapterClass();
+  await adapter.connect(config);
+  return adapter;
+}
+function getSupportedDatabases() {
+  return [
+    { type: "postgres", label: "PostgreSQL", group: "SQL" },
+    { type: "mysql", label: "MySQL / MariaDB", group: "SQL" },
+    { type: "sqlite", label: "SQLite (embedded, dev/small)", group: "SQL" },
+    { type: "mongodb", label: "MongoDB", group: "NoSQL" },
+    { type: "turso", label: "Turso (LibSQL, edge)", group: "Edge" },
+    { type: "dynamodb", label: "DynamoDB (AWS)", group: "Cloud" },
+    { type: "supabase", label: "Supabase (managed Postgres)", group: "Cloud" },
+    { type: "neon", label: "Neon (serverless Postgres)", group: "Cloud" },
+    { type: "planetscale", label: "PlanetScale (managed MySQL)", group: "Cloud" },
+    { type: "cockroachdb", label: "CockroachDB", group: "Distributed" }
+  ];
+}
+
+export {
+  createAdapter,
+  getSupportedDatabases
+};

package/dist/chunk-JLSQOQ5L.js

@@ -0,0 +1,255 @@
+// src/lib/resilience.ts
+var DEFAULT_RETRY = {
+  maxAttempts: 3,
+  baseDelayMs: 500,
+  maxDelayMs: 3e4,
+  backoffMultiplier: 2
+};
+async function withRetry(fn, opts = {}) {
+  const config = { ...DEFAULT_RETRY, ...opts };
+  let lastError = new Error("No attempts made");
+  for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt === config.maxAttempts) break;
+      if (config.retryableErrors && !config.retryableErrors(err)) break;
+      const delay = Math.min(
+        config.baseDelayMs * Math.pow(config.backoffMultiplier, attempt - 1) + Math.random() * 200,
+        config.maxDelayMs
+      );
+      config.onRetry?.(attempt, err, delay);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+var CircuitBreaker = class {
+  state = "closed";
+  failures = 0;
+  successes = 0;
+  lastFailureTime = 0;
+  opts;
+  constructor(opts = {}) {
+    this.opts = {
+      failureThreshold: opts.failureThreshold ?? 5,
+      recoveryTimeMs: opts.recoveryTimeMs ?? 3e4,
+      successThreshold: opts.successThreshold ?? 2,
+      timeout: opts.timeout
+    };
+  }
+  async execute(fn) {
+    if (this.state === "open") {
+      if (Date.now() - this.lastFailureTime >= this.opts.recoveryTimeMs) {
+        this.state = "half-open";
+        this.successes = 0;
+      } else {
+        throw new CircuitOpenError(
+          `Circuit breaker is open. Retry after ${this.opts.recoveryTimeMs}ms`
+        );
+      }
+    }
+    try {
+      const result = this.opts.timeout ? await withTimeout(fn(), this.opts.timeout) : await fn();
+      this.onSuccess();
+      return result;
+    } catch (err) {
+      this.onFailure();
+      throw err;
+    }
+  }
+  onSuccess() {
+    if (this.state === "half-open") {
+      this.successes++;
+      if (this.successes >= this.opts.successThreshold) {
+        this.state = "closed";
+        this.failures = 0;
+      }
+    } else {
+      this.failures = 0;
+    }
+  }
+  onFailure() {
+    this.failures++;
+    this.lastFailureTime = Date.now();
+    if (this.failures >= this.opts.failureThreshold) {
+      this.state = "open";
+    }
+  }
+  getState() {
+    return this.state;
+  }
+  reset() {
+    this.state = "closed";
+    this.failures = 0;
+    this.successes = 0;
+  }
+};
+var CircuitOpenError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CircuitOpenError";
+  }
+};
+var RateLimiter = class {
+  tokens;
+  lastRefill;
+  opts;
+  constructor(opts) {
+    this.opts = {
+      maxTokens: opts.maxTokens,
+      refillRate: opts.refillRate,
+      refillIntervalMs: opts.refillIntervalMs ?? 1e3
+    };
+    this.tokens = this.opts.maxTokens;
+    this.lastRefill = Date.now();
+  }
+  /**
+   * Try to consume a token. Returns true if allowed, false if rate limited.
+   */
+  tryConsume(count = 1) {
+    this.refill();
+    if (this.tokens >= count) {
+      this.tokens -= count;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get time in ms until next token is available.
+   */
+  getRetryAfterMs() {
+    this.refill();
+    if (this.tokens >= 1) return 0;
+    const tokensNeeded = 1 - this.tokens;
+    return Math.ceil(tokensNeeded / this.opts.refillRate * 1e3);
+  }
+  refill() {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    const tokensToAdd = elapsed / 1e3 * this.opts.refillRate;
+    this.tokens = Math.min(this.opts.maxTokens, this.tokens + tokensToAdd);
+    this.lastRefill = now;
+  }
+};
+var KeyedRateLimiter = class {
+  limiters = /* @__PURE__ */ new Map();
+  opts;
+  cleanupTimer = null;
+  constructor(opts) {
+    this.opts = opts;
+    this.cleanupTimer = setInterval(() => this.cleanup(), 5 * 6e4);
+    if (this.cleanupTimer && typeof this.cleanupTimer === "object" && "unref" in this.cleanupTimer) {
+      this.cleanupTimer.unref();
+    }
+  }
+  tryConsume(key, count = 1) {
+    let limiter = this.limiters.get(key);
+    if (!limiter) {
+      limiter = new RateLimiter(this.opts);
+      this.limiters.set(key, limiter);
+    }
+    return limiter.tryConsume(count);
+  }
+  getRetryAfterMs(key) {
+    const limiter = this.limiters.get(key);
+    return limiter ? limiter.getRetryAfterMs() : 0;
+  }
+  cleanup() {
+    for (const [key, limiter] of this.limiters) {
+      if (limiter.getRetryAfterMs() === 0) {
+        this.limiters.delete(key);
+      }
+    }
+  }
+  destroy() {
+    if (this.cleanupTimer) clearInterval(this.cleanupTimer);
+    this.limiters.clear();
+  }
+};
+var HealthMonitor = class {
+  healthy = true;
+  consecutiveFailures = 0;
+  consecutiveSuccesses = 0;
+  timer = null;
+  check;
+  opts;
+  listeners = [];
+  constructor(check, opts = {}) {
+    this.check = check;
+    this.opts = {
+      intervalMs: opts.intervalMs ?? 3e4,
+      timeoutMs: opts.timeoutMs ?? 5e3,
+      unhealthyThreshold: opts.unhealthyThreshold ?? 3,
+      healthyThreshold: opts.healthyThreshold ?? 2
+    };
+  }
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => this.runCheck(), this.opts.intervalMs);
+    if (this.timer && typeof this.timer === "object" && "unref" in this.timer) {
+      this.timer.unref();
+    }
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  isHealthy() {
+    return this.healthy;
+  }
+  onStatusChange(fn) {
+    this.listeners.push(fn);
+  }
+  async runCheck() {
+    try {
+      await withTimeout(this.check(), this.opts.timeoutMs);
+      this.consecutiveFailures = 0;
+      this.consecutiveSuccesses++;
+      if (!this.healthy && this.consecutiveSuccesses >= this.opts.healthyThreshold) {
+        this.healthy = true;
+        this.listeners.forEach((fn) => fn(true));
+      }
+    } catch {
+      this.consecutiveSuccesses = 0;
+      this.consecutiveFailures++;
+      if (this.healthy && this.consecutiveFailures >= this.opts.unhealthyThreshold) {
+        this.healthy = false;
+        this.listeners.forEach((fn) => fn(false));
+      }
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`Operation timed out after ${ms}ms`)), ms);
+    promise.then((v) => {
+      clearTimeout(timer);
+      resolve(v);
+    }).catch((e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+  });
+}
+var counter = 0;
+var prefix = Math.random().toString(36).substring(2, 8);
+function requestId() {
+  return `${prefix}-${(++counter).toString(36)}-${Date.now().toString(36)}`;
+}
+
+export {
+  withRetry,
+  CircuitBreaker,
+  CircuitOpenError,
+  RateLimiter,
+  KeyedRateLimiter,
+  HealthMonitor,
+  requestId
+};

package/dist/{chunk-O462UJBH.js → chunk-TVF23PUW.js}

@@ -1,50 +1,6 @@
 import {
   withRetry
-} from "./chunk-LCUZGIDH.js";
-
-// src/db/factory.ts
-var ADAPTER_MAP = {
-  postgres: () => import("./postgres-LN7A6MGQ.js").then((m) => m.PostgresAdapter),
-  supabase: () => import("./postgres-LN7A6MGQ.js").then((m) => m.PostgresAdapter),
-  // Supabase IS Postgres
-  neon: () => import("./postgres-LN7A6MGQ.js").then((m) => m.PostgresAdapter),
-  // Neon IS Postgres
-  cockroachdb: () => import("./postgres-LN7A6MGQ.js").then((m) => m.PostgresAdapter),
-  // CockroachDB is PG-compatible
-  mysql: () => import("./mysql-RM3S2FV5.js").then((m) => m.MysqlAdapter),
-  planetscale: () => import("./mysql-RM3S2FV5.js").then((m) => m.MysqlAdapter),
-  // PlanetScale IS MySQL
-  mongodb: () => import("./mongodb-ODTXIVPV.js").then((m) => m.MongoAdapter),
-  sqlite: () => import("./sqlite-3K5YOZ4K.js").then((m) => m.SqliteAdapter),
-  turso: () => import("./turso-LDWODSDI.js").then((m) => m.TursoAdapter),
-  dynamodb: () => import("./dynamodb-CCGL2E77.js").then((m) => m.DynamoAdapter)
-};
-async function createAdapter(config) {
-  const loader = ADAPTER_MAP[config.type];
-  if (!loader) {
-    throw new Error(
-      `Unsupported database type: "${config.type}". Supported: ${Object.keys(ADAPTER_MAP).join(", ")}`
-    );
-  }
-  const AdapterClass = await loader();
-  const adapter = new AdapterClass();
-  await adapter.connect(config);
-  return adapter;
-}
-function getSupportedDatabases() {
-  return [
-    { type: "postgres", label: "PostgreSQL", group: "SQL" },
-    { type: "mysql", label: "MySQL / MariaDB", group: "SQL" },
-    { type: "sqlite", label: "SQLite (embedded, dev/small)", group: "SQL" },
-    { type: "mongodb", label: "MongoDB", group: "NoSQL" },
-    { type: "turso", label: "Turso (LibSQL, edge)", group: "Edge" },
-    { type: "dynamodb", label: "DynamoDB (AWS)", group: "Cloud" },
-    { type: "supabase", label: "Supabase (managed Postgres)", group: "Cloud" },
-    { type: "neon", label: "Neon (serverless Postgres)", group: "Cloud" },
-    { type: "planetscale", label: "PlanetScale (managed MySQL)", group: "Cloud" },
-    { type: "cockroachdb", label: "CockroachDB", group: "Distributed" }
-  ];
-}
+} from "./chunk-JLSQOQ5L.js";
 
 // src/deploy/fly.ts
 var FLY_API = "https://api.machines.dev";
@@ -353,11 +309,30 @@ primary_region = "${region}"
   memory = "256mb"
 `;
 }
+function generateRailwayConfig() {
+  return `# AgenticMail Enterprise \u2014 Railway Config
+# Generated at ${(/* @__PURE__ */ new Date()).toISOString()}
+#
+# Deploy:
+#   railway init
+#   railway link
+#   railway up
+
+[build]
+  builder = "DOCKERFILE"
+  dockerfilePath = "Dockerfile"
+
+[deploy]
+  healthcheckPath = "/health"
+  healthcheckTimeout = 10
+  restartPolicyType = "ON_FAILURE"
+  restartPolicyMaxRetries = 3
+`;
+}
 
 export {
-  createAdapter,
-  getSupportedDatabases,
   deployToCloud,
   generateDockerCompose,
-  generateFlyToml
+  generateFlyToml,
+  generateRailwayConfig
 };

package/dist/{chunk-DXNKR3TG.js → chunk-YFDSE4BW.js}

@@ -857,7 +857,7 @@ function createServer(config) {
   }
   app.get("/health", (c) => c.json({
     status: "ok",
-    version: "0.2.0",
+    version: "0.2.2",
     uptime: process.uptime()
   }));
   app.get("/ready", async (c) => {