@agenticmail/enterprise 0.5.493 → 0.5.495

package/dist/cli-serve-2YBQNL75.js

@@ -0,0 +1,322 @@
+import "./chunk-KFQGP6VL.js";
+
+// src/cli-serve.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function loadEnvFile() {
+  const candidates = [
+    join(process.cwd(), ".env"),
+    join(homedir(), ".agenticmail", ".env")
+  ];
+  for (const envPath of candidates) {
+    if (!existsSync(envPath)) continue;
+    try {
+      const content = readFileSync(envPath, "utf8");
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eq = trimmed.indexOf("=");
+        if (eq < 0) continue;
+        const key = trimmed.slice(0, eq).trim();
+        let val = trimmed.slice(eq + 1).trim();
+        if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+          val = val.slice(1, -1);
+        }
+        if (!process.env[key]) process.env[key] = val;
+      }
+      console.log(`Loaded config from ${envPath}`);
+      return;
+    } catch {
+    }
+  }
+}
+async function ensureSecrets() {
+  const { randomUUID } = await import("crypto");
+  const envDir = join(homedir(), ".agenticmail");
+  const envPath = join(envDir, ".env");
+  let dirty = false;
+  if (!process.env.JWT_SECRET) {
+    process.env.JWT_SECRET = randomUUID() + randomUUID();
+    dirty = true;
+    console.log("[startup] Generated new JWT_SECRET (existing sessions will need to re-login)");
+  }
+  if (!process.env.AGENTICMAIL_VAULT_KEY) {
+    process.env.AGENTICMAIL_VAULT_KEY = randomUUID() + randomUUID();
+    dirty = true;
+    console.log("[startup] Generated new AGENTICMAIL_VAULT_KEY");
+    console.log("[startup] \u26A0\uFE0F  Previously encrypted credentials will need to be re-entered in the dashboard");
+  }
+  if (dirty) {
+    try {
+      if (!existsSync(envDir)) {
+        const { mkdirSync } = await import("fs");
+        mkdirSync(envDir, { recursive: true });
+      }
+      const { appendFileSync } = await import("fs");
+      const lines = [];
+      let existing = "";
+      if (existsSync(envPath)) {
+        existing = readFileSync(envPath, "utf8");
+      }
+      if (!existing.includes("JWT_SECRET=")) {
+        lines.push(`JWT_SECRET=${process.env.JWT_SECRET}`);
+      }
+      if (!existing.includes("AGENTICMAIL_VAULT_KEY=")) {
+        lines.push(`AGENTICMAIL_VAULT_KEY=${process.env.AGENTICMAIL_VAULT_KEY}`);
+      }
+      if (lines.length) {
+        appendFileSync(envPath, "\n" + lines.join("\n") + "\n", { mode: 384 });
+        console.log(`[startup] Saved secrets to ${envPath}`);
+      }
+    } catch (e) {
+      console.warn(`[startup] Could not save secrets to ${envPath}: ${e.message}`);
+    }
+  }
+}
+async function runServe(_args) {
+  loadEnvFile();
+  const DATABASE_URL = process.env.DATABASE_URL;
+  const PORT = parseInt(process.env.PORT || "8080", 10);
+  await ensureSecrets();
+  const JWT_SECRET = process.env.JWT_SECRET;
+  const _VAULT_KEY = process.env.AGENTICMAIL_VAULT_KEY;
+  if (!DATABASE_URL) {
+    console.error("ERROR: DATABASE_URL is required.");
+    console.error("");
+    console.error("Set it via environment variable or .env file:");
+    console.error("  DATABASE_URL=postgresql://user:pass@host:5432/db npx @agenticmail/enterprise start");
+    console.error("");
+    console.error("Or create a .env file (in cwd or ~/.agenticmail/.env):");
+    console.error("  DATABASE_URL=postgresql://user:pass@host:5432/db");
+    console.error("  JWT_SECRET=your-secret-here");
+    console.error("  PORT=3200");
+    process.exit(1);
+  }
+  const { createAdapter, smartDbConfig } = await import("./factory-R6MMSC2X.js");
+  const { createServer } = await import("./server-ZIX4WYJ6.js");
+  const db = await createAdapter(smartDbConfig(DATABASE_URL));
+  await db.migrate();
+  const server = createServer({
+    port: PORT,
+    db,
+    jwtSecret: JWT_SECRET,
+    corsOrigins: ["*"]
+  });
+  await server.start();
+  console.log(`AgenticMail Enterprise server running on :${PORT}`);
+  try {
+    const { startWatcherEngine, initWatcherTables, setWatcherRuntime } = await import("./polymarket-watcher-QD65QLZQ.js");
+    const edb = db.getEngineDB?.();
+    if (edb) {
+      await initWatcherTables(edb);
+      startWatcherEngine(db, {
+        log: (...args) => console.log(...args),
+        onEvent: (agentId, event) => {
+          if (event.severity === "critical") {
+            console.log(`[poly-watcher] CRITICAL signal for agent ${agentId}: ${event.title}`);
+          }
+        }
+      });
+      setTimeout(async () => {
+        try {
+          const routes = await import("./routes-OSTTX7K7.js");
+          setWatcherRuntime(
+            () => routes.getRuntime?.() || null
+          );
+        } catch (e) {
+          console.warn("[poly-watcher] Could not inject runtime:", e.message);
+        }
+      }, 5e3);
+      console.log("[startup] Polymarket watcher engine started");
+    }
+    setTimeout(async () => {
+      try {
+        const { autoConnectProxy } = await import("./polymarket-runtime-E7YDVOJD.js");
+        const pdb = db.getEngineDB?.();
+        if (pdb) await autoConnectProxy(pdb);
+      } catch {
+      }
+    }, 8e3);
+  } catch (e) {
+    console.warn("[startup] Polymarket watcher engine skipped:", e.message);
+  }
+  try {
+    const { startBackgroundUpdateCheck } = await import("./cli-update-SX7GACL3.js");
+    startBackgroundUpdateCheck();
+  } catch {
+  }
+  try {
+    const { startPreventSleep } = await import("./screen-unlock-4RPZBHOI.js");
+    const adminDb = server.getAdminDb?.() || server.adminDb;
+    if (adminDb) {
+      const settings = await adminDb.getSettings?.().catch(() => null);
+      const screenAccess = settings?.securityConfig?.screenAccess;
+      if (screenAccess?.enabled && screenAccess?.preventSleep) {
+        startPreventSleep();
+        console.log("[startup] Prevent-sleep enabled \u2014 system will stay awake while agents are active");
+      }
+    }
+  } catch {
+  }
+  try {
+    await setupSystemPersistence();
+  } catch (e) {
+    console.warn("[startup] System persistence setup skipped: " + e.message);
+  }
+  const tunnelToken = process.env.CLOUDFLARED_TOKEN;
+  if (tunnelToken) {
+    try {
+      const { execSync, spawn } = await import("child_process");
+      try {
+        execSync(process.platform === "win32" ? "where cloudflared" : "which cloudflared", { timeout: 3e3 });
+      } catch {
+        console.log("[startup] cloudflared not found \u2014 skipping tunnel auto-start");
+        console.log("[startup] Install cloudflared to enable tunnel: https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/");
+        return;
+      }
+      try {
+        if (process.platform === "win32") {
+          const tasklist = execSync('tasklist /FI "IMAGENAME eq cloudflared.exe" /NH', { encoding: "utf8", timeout: 5e3 });
+          if (tasklist.includes("cloudflared.exe")) {
+            console.log("[startup] cloudflared tunnel already running");
+            return;
+          }
+        } else {
+          execSync('pgrep -f "cloudflared.*tunnel.*run"', { timeout: 3e3 });
+          console.log("[startup] cloudflared tunnel already running");
+          return;
+        }
+      } catch {
+      }
+      const subdomain = process.env.AGENTICMAIL_SUBDOMAIN || process.env.AGENTICMAIL_DOMAIN || "";
+      console.log(`[startup] Starting cloudflared tunnel${subdomain ? ` for ${subdomain}.agenticmail.io` : ""}...`);
+      let cfBin = "cloudflared";
+      if (process.platform === "win32") {
+        try {
+          cfBin = execSync("where cloudflared", { encoding: "utf8", timeout: 3e3 }).trim().split("\n")[0].trim();
+        } catch {
+          const candidate = `${process.env.LOCALAPPDATA || ""}\\cloudflared\\cloudflared.exe`;
+          try {
+            (await import("fs")).statSync(candidate);
+            cfBin = candidate;
+          } catch {
+          }
+        }
+      }
+      const child = spawn(cfBin, ["tunnel", "--no-autoupdate", "run", "--token", tunnelToken], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+      console.log("[startup] cloudflared tunnel started (pid " + child.pid + ")");
+    } catch (e) {
+      console.warn("[startup] Could not auto-start cloudflared: " + e.message);
+    }
+  }
+}
+async function setupSystemPersistence() {
+  const { execSync, spawnSync } = await import("child_process");
+  const { existsSync: exists, writeFileSync, mkdirSync } = await import("fs");
+  const { join: pathJoin } = await import("path");
+  const platform = process.platform;
+  if (!process.env.PM2_HOME && !process.env.pm_id) {
+    return;
+  }
+  const markerDir = pathJoin(homedir(), ".agenticmail");
+  const markerFile = pathJoin(markerDir, ".persistence-configured");
+  if (exists(markerFile)) {
+    try {
+      execSync("pm2 save --silent", { timeout: 1e4, stdio: "ignore" });
+    } catch {
+    }
+    return;
+  }
+  console.log("[startup] Configuring system persistence (one-time setup)...");
+  try {
+    if (platform === "darwin") {
+      const result = spawnSync("pm2", ["startup", "launchd", "--silent"], {
+        timeout: 15e3,
+        stdio: "pipe",
+        encoding: "utf-8"
+      });
+      const output = (result.stdout || "") + (result.stderr || "");
+      const sudoMatch = output.match(/sudo\s+env\s+.*pm2\s+startup.*/);
+      if (sudoMatch) {
+        console.log("[startup] PM2 startup requires sudo. Run this once:");
+        console.log("  " + sudoMatch[0]);
+      } else {
+        console.log("[startup] PM2 startup configured (launchd)");
+      }
+      const plistPath = pathJoin(homedir(), "Library", "LaunchAgents", `pm2.${process.env.USER || "user"}.plist`);
+      if (exists(plistPath)) {
+        try {
+          execSync(`launchctl load -w "${plistPath}"`, { timeout: 5e3, stdio: "ignore" });
+        } catch {
+        }
+      }
+    } else if (platform === "linux") {
+      const result = spawnSync("pm2", ["startup", "systemd", "--silent"], {
+        timeout: 15e3,
+        stdio: "pipe",
+        encoding: "utf-8"
+      });
+      const output = (result.stdout || "") + (result.stderr || "");
+      const sudoMatch = output.match(/sudo\s+env\s+.*pm2\s+startup.*/);
+      if (sudoMatch) {
+        try {
+          execSync(sudoMatch[0], { timeout: 15e3, stdio: "ignore" });
+          console.log("[startup] PM2 startup configured (systemd)");
+        } catch {
+          console.log("[startup] PM2 startup requires root. Run this once:");
+          console.log("  " + sudoMatch[0]);
+        }
+      } else {
+        console.log("[startup] PM2 startup configured (systemd)");
+      }
+    } else if (platform === "win32") {
+      try {
+        execSync("npm list -g pm2-windows-startup", { timeout: 1e4, stdio: "ignore" });
+      } catch {
+        console.log("[startup] Installing pm2-windows-startup...");
+        try {
+          execSync("npm install -g pm2-windows-startup", { timeout: 6e4, stdio: "ignore" });
+          execSync("pm2-startup install", { timeout: 15e3, stdio: "ignore" });
+          console.log("[startup] PM2 startup configured (Windows Service)");
+        } catch (e) {
+          console.warn("[startup] Could not install pm2-windows-startup: " + e.message);
+        }
+      }
+    }
+  } catch (e) {
+    console.warn("[startup] PM2 startup setup: " + e.message);
+  }
+  try {
+    const moduleList = execSync("pm2 ls --silent 2>/dev/null || true", { timeout: 1e4, encoding: "utf-8" });
+    if (!moduleList.includes("pm2-logrotate")) {
+      console.log("[startup] Installing pm2-logrotate...");
+      execSync("pm2 install pm2-logrotate --silent", { timeout: 6e4, stdio: "ignore" });
+      execSync("pm2 set pm2-logrotate:max_size 10M --silent", { timeout: 5e3, stdio: "ignore" });
+      execSync("pm2 set pm2-logrotate:retain 5 --silent", { timeout: 5e3, stdio: "ignore" });
+      execSync("pm2 set pm2-logrotate:compress true --silent", { timeout: 5e3, stdio: "ignore" });
+      console.log("[startup] Log rotation configured (10MB, 5 files)");
+    }
+  } catch {
+  }
+  try {
+    execSync("pm2 save --silent", { timeout: 1e4, stdio: "ignore" });
+    console.log("[startup] Process list saved");
+  } catch {
+  }
+  try {
+    if (!exists(markerDir)) mkdirSync(markerDir, { recursive: true });
+    writeFileSync(markerFile, (/* @__PURE__ */ new Date()).toISOString() + `
+platform=${platform}
+`, { mode: 384 });
+    console.log("[startup] System persistence configured successfully");
+  } catch {
+  }
+}
+export {
+  runServe
+};

package/dist/cli.js

@@ -65,14 +65,14 @@ Skill Development:
     break;
   case "serve":
   case "start":
-    import("./cli-serve-VVEAJWDJ.js").then((m) => m.runServe(args.slice(1))).catch(fatal);
+    import("./cli-serve-2YBQNL75.js").then((m) => m.runServe(args.slice(1))).catch(fatal);
     break;
   case "agent":
-    import("./cli-agent-APILWIJS.js").then((m) => m.runAgent(args.slice(1))).catch(fatal);
+    import("./cli-agent-3WPXYJ3H.js").then((m) => m.runAgent(args.slice(1))).catch(fatal);
     break;
   case "setup":
   default:
-    import("./setup-BXECF4TV.js").then((m) => m.runSetupWizard()).catch(fatal);
+    import("./setup-7PR7RNNN.js").then((m) => m.runSetupWizard()).catch(fatal);
     break;
 }
 function fatal(err) {

package/dist/dashboard/components/login-animations.js

@@ -0,0 +1,203 @@
+import { h, useState, useEffect, useCallback } from './utils.js';
+
+// ─── Three animated canvas backgrounds for the login page ───
+// Randomly picks one on each page load. Only shown when no custom company background.
+
+var CHARS_BLOCK = '\u2591\u2592\u2593\u2588\u2580\u2584\u258C\u2590\u2502\u2500\u2524\u251C\u2534\u252C\u256D\u256E\u2570\u256F';
+var CHARS_DOT = '\u00B7\u2218\u25CB\u25EF\u25CC\u25CF\u25C9';
+
+function renderSphere(ctx, rect, time) {
+  var centerX = rect.width / 2;
+  var centerY = rect.height / 2;
+  var radius = Math.min(rect.width, rect.height) * 0.525;
+
+  ctx.font = '12px monospace';
+  ctx.textAlign = 'center';
+  ctx.textBaseline = 'middle';
+
+  var points = [];
+
+  for (var phi = 0; phi < Math.PI * 2; phi += 0.15) {
+    for (var theta = 0; theta < Math.PI; theta += 0.15) {
+      var x = Math.sin(theta) * Math.cos(phi + time * 0.5);
+      var y = Math.sin(theta) * Math.sin(phi + time * 0.5);
+      var z = Math.cos(theta);
+
+      var rotY = time * 0.3;
+      var newX = x * Math.cos(rotY) - z * Math.sin(rotY);
+      var newZ = x * Math.sin(rotY) + z * Math.cos(rotY);
+
+      var rotX = time * 0.2;
+      var newY = y * Math.cos(rotX) - newZ * Math.sin(rotX);
+      var finalZ = y * Math.sin(rotX) + newZ * Math.cos(rotX);
+
+      var depth = (finalZ + 1) / 2;
+      var charIndex = Math.floor(depth * (CHARS_BLOCK.length - 1));
+
+      points.push({ x: centerX + newX * radius, y: centerY + newY * radius, z: finalZ, ch: CHARS_BLOCK[charIndex] });
+    }
+  }
+
+  points.sort(function(a, b) { return a.z - b.z; });
+  points.forEach(function(p) {
+    var alpha = 0.15 + (p.z + 1) * 0.3;
+    ctx.fillStyle = 'rgba(120, 120, 140, ' + alpha + ')';
+    ctx.fillText(p.ch, p.x, p.y);
+  });
+}
+
+function renderTetrahedron(ctx, rect, time) {
+  var centerX = rect.width / 2;
+  var centerY = rect.height / 2;
+  var scale = Math.min(rect.width, rect.height) * 0.7;
+
+  ctx.font = '18px monospace';
+  ctx.textAlign = 'center';
+  ctx.textBaseline = 'middle';
+
+  var verts = [
+    { x: 0, y: 1, z: 0 },
+    { x: -0.943, y: -0.333, z: -0.5 },
+    { x: 0.943, y: -0.333, z: -0.5 },
+    { x: 0, y: -0.333, z: 1 },
+  ];
+
+  var edges = [[0,1],[0,2],[0,3],[1,2],[2,3],[3,1]];
+  var faces = [[0,1,2],[0,2,3],[0,3,1],[1,3,2]];
+
+  function rotY(p, a) { return { x: p.x * Math.cos(a) - p.z * Math.sin(a), y: p.y, z: p.x * Math.sin(a) + p.z * Math.cos(a) }; }
+  function rotX(p, a) { return { x: p.x, y: p.y * Math.cos(a) - p.z * Math.sin(a), z: p.y * Math.sin(a) + p.z * Math.cos(a) }; }
+  function rotZ(p, a) { return { x: p.x * Math.cos(a) - p.y * Math.sin(a), y: p.x * Math.sin(a) + p.y * Math.cos(a), z: p.z }; }
+
+  var points = [];
+
+  edges.forEach(function(e) {
+    var v1 = verts[e[0]], v2 = verts[e[1]];
+    for (var t = 0; t <= 1; t += 0.05) {
+      var pt = { x: v1.x + (v2.x - v1.x) * t, y: v1.y + (v2.y - v1.y) * t, z: v1.z + (v2.z - v1.z) * t };
+      pt = rotY(pt, time * 0.4); pt = rotX(pt, time * 0.3); pt = rotZ(pt, time * 0.2);
+      var d = (pt.z + 1.5) / 3;
+      var ci = Math.min(Math.floor(d * (CHARS_BLOCK.length - 1)), CHARS_BLOCK.length - 1);
+      points.push({ x: centerX + pt.x * scale, y: centerY - pt.y * scale, z: pt.z, ch: CHARS_BLOCK[ci] });
+    }
+  });
+
+  faces.forEach(function(f) {
+    var v1 = verts[f[0]], v2 = verts[f[1]], v3 = verts[f[2]];
+    for (var u = 0; u <= 1; u += 0.12) {
+      for (var v = 0; v <= 1 - u; v += 0.12) {
+        var w = 1 - u - v;
+        var pt = { x: v1.x * u + v2.x * v + v3.x * w, y: v1.y * u + v2.y * v + v3.y * w, z: v1.z * u + v2.z * v + v3.z * w };
+        pt = rotY(pt, time * 0.4); pt = rotX(pt, time * 0.3); pt = rotZ(pt, time * 0.2);
+        var d = (pt.z + 1.5) / 3;
+        var ci = Math.min(Math.floor(d * (CHARS_BLOCK.length - 1)), CHARS_BLOCK.length - 1);
+        points.push({ x: centerX + pt.x * scale, y: centerY - pt.y * scale, z: pt.z, ch: CHARS_BLOCK[ci] });
+      }
+    }
+  });
+
+  points.sort(function(a, b) { return a.z - b.z; });
+  points.forEach(function(p) {
+    var alpha = 0.1 + (p.z + 1.5) * 0.2;
+    ctx.fillStyle = 'rgba(120, 120, 140, ' + Math.min(alpha, 0.7) + ')';
+    ctx.fillText(p.ch, p.x, p.y);
+  });
+}
+
+function renderWave(ctx, rect, time) {
+  ctx.font = '14px monospace';
+  ctx.textAlign = 'center';
+  ctx.textBaseline = 'middle';
+
+  var cols = Math.floor(rect.width / 20);
+  var rows = Math.floor(rect.height / 20);
+
+  for (var y = 0; y < rows; y++) {
+    for (var x = 0; x < cols; x++) {
+      var px = (x + 0.5) * (rect.width / cols);
+      var py = (y + 0.5) * (rect.height / rows);
+
+      var wave1 = Math.sin(x * 0.2 + time * 2) * Math.cos(y * 0.15 + time);
+      var wave2 = Math.sin((x + y) * 0.1 + time * 1.5);
+      var wave3 = Math.cos(x * 0.1 - y * 0.1 + time * 0.8);
+
+      var combined = (wave1 + wave2 + wave3) / 3;
+      var normalized = (combined + 1) / 2;
+
+      var charIndex = Math.floor(normalized * (CHARS_DOT.length - 1));
+      var alpha = 0.1 + normalized * 0.4;
+
+      ctx.fillStyle = 'rgba(120, 120, 140, ' + alpha + ')';
+      ctx.fillText(CHARS_DOT[charIndex], px, py);
+    }
+  }
+}
+
+var RENDERERS = [
+  { fn: renderSphere, speed: 0.02 },
+  { fn: renderTetrahedron, speed: 0.015 },
+  { fn: renderWave, speed: 0.03 },
+];
+
+export function LoginAnimation() {
+  var _choice = useState(function() { return Math.floor(Math.random() * RENDERERS.length); });
+  var choice = _choice[0];
+
+  var canvasRef = useCallback(function(canvas) {
+    if (!canvas) return;
+    var ctx = canvas.getContext('2d');
+    if (!ctx) return;
+
+    var renderer = RENDERERS[choice];
+    var time = 0;
+    var frameId = 0;
+
+    function resize() {
+      var dpr = window.devicePixelRatio || 1;
+      var rect = canvas.getBoundingClientRect();
+      canvas.width = rect.width * dpr;
+      canvas.height = rect.height * dpr;
+      ctx.scale(dpr, dpr);
+    }
+
+    resize();
+    window.addEventListener('resize', resize);
+
+    function render() {
+      var rect = canvas.getBoundingClientRect();
+      ctx.clearRect(0, 0, rect.width, rect.height);
+      renderer.fn(ctx, rect, time);
+      time += renderer.speed;
+      frameId = requestAnimationFrame(render);
+    }
+
+    render();
+
+    canvas._cleanup = function() {
+      window.removeEventListener('resize', resize);
+      cancelAnimationFrame(frameId);
+    };
+  }, [choice]);
+
+  useEffect(function() {
+    return function() {
+      // Cleanup on unmount — find canvas and call cleanup
+      var c = document.getElementById('login-anim-canvas');
+      if (c && c._cleanup) c._cleanup();
+    };
+  }, []);
+
+  return h('canvas', {
+    id: 'login-anim-canvas',
+    ref: canvasRef,
+    style: {
+      position: 'absolute',
+      top: 0,
+      left: 0,
+      width: '100%',
+      height: '100%',
+      zIndex: 0,
+      pointerEvents: 'none',
+    }
+  });
+}

package/dist/dashboard/pages/login.js

@@ -2,6 +2,7 @@ import { h, useState, useEffect, useCallback, Fragment } from '../components/uti
 import { apiCall, authCall, engineCall } from '../components/utils.js';
 import { I } from '../components/icons.js';
 import { E } from '../assets/icons/emoji-icons.js';
+import { LoginAnimation } from '../components/login-animations.js';
 
 var _b = typeof window !== 'undefined' && window.__EM_BRANDING__ || {};
 var _brandLogo = _b.login_logo || _b.logo || _brandLogo;
@@ -128,8 +129,9 @@ export function LoginPage({ onLogin }) {
   // ─── 2FA Verification Screen ──────────────────────────
 
   if (needs2fa) {
-    return h('div', { className: 'login-page', style: _brandBg ? { backgroundImage: 'url(' + _brandBg + ')', backgroundSize: 'cover', backgroundPosition: 'center' } : {} },
-      h('div', { className: 'login-card' },
+    return h('div', { className: 'login-page', style: Object.assign({ position: 'relative', overflow: 'hidden' }, _brandBg ? { backgroundImage: 'url(' + _brandBg + ')', backgroundSize: 'cover', backgroundPosition: 'center' } : {}) },
+      !_brandBg && h(LoginAnimation),
+      h('div', { className: 'login-card', style: { position: 'relative', zIndex: 1 } },
         h('div', { className: 'login-logo' },
           h('img', { src: _brandLogo, alt: 'AgenticMail', style: { width: 48, height: 48, objectFit: 'contain' } }),
           h('h1', null, 'Two-Factor Authentication'),
@@ -161,8 +163,9 @@ export function LoginPage({ onLogin }) {
   // ─── Forgot Password Screen ──────────────────────────
 
   if (forgotMode) {
-    return h('div', { className: 'login-page', style: _brandBg ? { backgroundImage: 'url(' + _brandBg + ')', backgroundSize: 'cover', backgroundPosition: 'center' } : {} },
-      h('div', { className: 'login-card' },
+    return h('div', { className: 'login-page', style: Object.assign({ position: 'relative', overflow: 'hidden' }, _brandBg ? { backgroundImage: 'url(' + _brandBg + ')', backgroundSize: 'cover', backgroundPosition: 'center' } : {}) },
+      !_brandBg && h(LoginAnimation),
+      h('div', { className: 'login-card', style: { position: 'relative', zIndex: 1 } },
         h('div', { className: 'login-logo' },
           h('img', { src: _brandLogo, alt: 'AgenticMail', style: { width: 48, height: 48, objectFit: 'contain' } }),
           h('h1', null, 'Reset Password'),
@@ -257,8 +260,9 @@ export function LoginPage({ onLogin }) {
 
   // ─── Main Login Screen ────────────────────────────────
 
-  return h('div', { className: 'login-page', style: _brandBg ? { backgroundImage: 'url(' + _brandBg + ')', backgroundSize: 'cover', backgroundPosition: 'center' } : {} },
-    h('div', { className: 'login-card' },
+  return h('div', { className: 'login-page', style: Object.assign({ position: 'relative', overflow: 'hidden' }, _brandBg ? { backgroundImage: 'url(' + _brandBg + ')', backgroundSize: 'cover', backgroundPosition: 'center' } : {}) },
+    !_brandBg && h(LoginAnimation),
+    h('div', { className: 'login-card', style: { position: 'relative', zIndex: 1 } },
       h('div', { className: 'login-logo' },
         h('img', { src: _brandLogo, alt: 'AgenticMail', style: { width: 48, height: 48, objectFit: 'contain' } }),
         h('h1', null, 'AgenticMail Enterprise'),

package/dist/index.js

@@ -7,7 +7,7 @@ import {
 import {
   provision,
   runSetupWizard
-} from "./chunk-QURJZ7YA.js";
+} from "./chunk-3JBINCUY.js";
 import {
   AgenticMailManager,
   GoogleEmailProvider,
@@ -28,7 +28,7 @@ import {
   executeTool,
   runAgentLoop,
   toolsToDefinitions
-} from "./chunk-6CKKEJ2Z.js";
+} from "./chunk-IKZCLQLH.js";
 import "./chunk-UBXXLAND.js";
 import {
   ValidationError,
@@ -43,7 +43,7 @@ import {
   requireRole,
   securityHeaders,
   validate
-} from "./chunk-YY545PSF.js";
+} from "./chunk-MR5OF4WY.js";
 import "./chunk-DJBCRQTD.js";
 import {
   PROVIDER_REGISTRY,
@@ -117,18 +117,18 @@ import {
   init_agent_config,
   init_deployer
 } from "./chunk-PSZU6FMQ.js";
-import "./chunk-IHBZGGCE.js";
+import "./chunk-FU64VLD6.js";
 import "./chunk-X5IZUXDC.js";
 import "./chunk-I5IGHBXW.js";
-import "./chunk-35O7J5FW.js";
+import "./chunk-EOVUE6WA.js";
 import {
   SecureVault,
   init_vault
 } from "./chunk-WUAWWKTN.js";
-import "./chunk-TXZWO3T4.js";
-import "./chunk-FDOK2L5M.js";
-import "./chunk-CVFIM72Q.js";
-import "./chunk-5SRN7SQF.js";
+import "./chunk-2CDGYMJK.js";
+import "./chunk-V3LPIDTL.js";
+import "./chunk-A4CX3XQS.js";
+import "./chunk-5UQD5G7D.js";
 import {
   CircuitBreaker,
   CircuitOpenError,

package/dist/pipeline-FMNDX5HQ.js

@@ -0,0 +1,15 @@
+import {
+  batchScreen,
+  fullAnalysis,
+  portfolioReview,
+  quickAnalysis
+} from "./chunk-2CDGYMJK.js";
+import "./chunk-V3LPIDTL.js";
+import "./chunk-A4CX3XQS.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  batchScreen,
+  fullAnalysis,
+  portfolioReview,
+  quickAnalysis
+};

package/dist/polymarket-24T5IXH4.js

@@ -0,0 +1,17 @@
+import {
+  createPolymarketTools,
+  executeOrder
+} from "./chunk-FU64VLD6.js";
+import "./chunk-X5IZUXDC.js";
+import "./chunk-I5IGHBXW.js";
+import "./chunk-EOVUE6WA.js";
+import "./chunk-WUAWWKTN.js";
+import "./chunk-2CDGYMJK.js";
+import "./chunk-V3LPIDTL.js";
+import "./chunk-A4CX3XQS.js";
+import "./chunk-5UQD5G7D.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  createPolymarketTools,
+  executeOrder
+};