@agenticmail/enterprise 0.2.1

package/dist/chunk-O462UJBH.js

@@ -0,0 +1,363 @@
+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" }
+  ];
+}
+
+// src/deploy/fly.ts
+var FLY_API = "https://api.machines.dev";
+var DEFAULT_IMAGE = "agenticmail/enterprise:latest";
+async function flyRequest(path, opts) {
+  const resp = await fetch(`${FLY_API}${path}`, {
+    method: opts.method || "GET",
+    headers: {
+      Authorization: `Bearer ${opts.apiToken}`,
+      "Content-Type": "application/json"
+    },
+    body: opts.body ? JSON.stringify(opts.body) : void 0,
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => "Unknown error");
+    throw new Error(`Fly.io API error (${resp.status}): ${text}`);
+  }
+  return resp.json();
+}
+async function createApp(name, fly) {
+  await flyRequest("/v1/apps", {
+    method: "POST",
+    apiToken: fly.apiToken,
+    body: {
+      app_name: name,
+      org_slug: fly.org || "personal"
+    }
+  });
+}
+async function createMachine(appName, config, fly) {
+  const region = fly.regions?.[0] || "iad";
+  const env = {
+    PORT: "3000",
+    NODE_ENV: "production",
+    DATABASE_TYPE: config.dbType,
+    DATABASE_URL: config.dbConnectionString,
+    JWT_SECRET: config.jwtSecret
+  };
+  if (config.smtpHost) env.SMTP_HOST = config.smtpHost;
+  if (config.smtpPort) env.SMTP_PORT = String(config.smtpPort);
+  if (config.smtpUser) env.SMTP_USER = config.smtpUser;
+  if (config.smtpPass) env.SMTP_PASS = config.smtpPass;
+  const result = await flyRequest(`/v1/apps/${appName}/machines`, {
+    method: "POST",
+    apiToken: fly.apiToken,
+    body: {
+      name: `${appName}-web`,
+      region,
+      config: {
+        image: fly.image || DEFAULT_IMAGE,
+        env,
+        services: [
+          {
+            ports: [
+              { port: 443, handlers: ["tls", "http"] },
+              { port: 80, handlers: ["http"] }
+            ],
+            protocol: "tcp",
+            internal_port: 3e3,
+            concurrency: {
+              type: "connections",
+              hard_limit: 100,
+              soft_limit: 80
+            }
+          }
+        ],
+        checks: {
+          health: {
+            type: "http",
+            port: 3e3,
+            path: "/health",
+            interval: "30s",
+            timeout: "5s",
+            grace_period: "10s"
+          }
+        },
+        guest: {
+          cpu_kind: config.cpuKind || "shared",
+          cpus: config.cpus || 1,
+          memory_mb: config.memoryMb || 256
+        },
+        auto_destroy: false,
+        restart: {
+          policy: "always",
+          max_retries: 5
+        }
+      }
+    }
+  });
+  return { id: result.id, region: result.region || region };
+}
+async function allocateIp(appName, fly) {
+  try {
+    const resp = await fetch("https://api.fly.io/graphql", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${fly.apiToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        query: `mutation($input: AllocateIPAddressInput!) {
+          allocateIpAddress(input: $input) {
+            ipAddress { id address type region createdAt }
+          }
+        }`,
+        variables: {
+          input: { appId: appName, type: "v4", region: "" }
+        }
+      }),
+      signal: AbortSignal.timeout(15e3)
+    });
+    const data = await resp.json();
+    const v4 = data?.data?.allocateIpAddress?.ipAddress?.address;
+    return { v4 };
+  } catch {
+    return {};
+  }
+}
+async function addCertificate(appName, hostname, fly) {
+  await fetch("https://api.fly.io/graphql", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${fly.apiToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      query: `mutation($appId: ID!, $hostname: String!) {
+        addCertificate(appId: $appId, hostname: $hostname) {
+          certificate { hostname configured }
+        }
+      }`,
+      variables: { appId: appName, hostname }
+    }),
+    signal: AbortSignal.timeout(15e3)
+  });
+}
+async function deployToFly(config, fly) {
+  const appName = `am-${config.subdomain}`;
+  const domain = `${config.subdomain}.agenticmail.cloud`;
+  try {
+    console.log(`  Creating app: ${appName}...`);
+    await withRetry(() => createApp(appName, fly), {
+      maxAttempts: 2,
+      retryableErrors: (err) => !err.message.includes("already exists")
+    });
+    console.log(`  Deploying machine...`);
+    const machine = await withRetry(() => createMachine(appName, config, fly), {
+      maxAttempts: 3,
+      baseDelayMs: 2e3
+    });
+    console.log(`  Allocating IP address...`);
+    const ips = await allocateIp(appName, fly);
+    console.log(`  Setting up TLS for ${domain}...`);
+    await addCertificate(appName, domain, fly).catch(() => {
+    });
+    return {
+      appName,
+      url: `https://${domain}`,
+      ipv4: ips.v4,
+      ipv6: ips.v6,
+      region: machine.region,
+      machineId: machine.id,
+      status: "started"
+    };
+  } catch (err) {
+    return {
+      appName,
+      url: `https://${domain}`,
+      region: fly.regions?.[0] || "iad",
+      machineId: "",
+      status: "error",
+      error: err.message
+    };
+  }
+}
+
+// src/deploy/managed.ts
+async function deployToCloud(config, flyToken) {
+  const token = flyToken || process.env.FLY_API_TOKEN;
+  if (!token) {
+    return {
+      url: `https://${config.subdomain}.agenticmail.cloud`,
+      appName: `am-${config.subdomain}`,
+      region: config.region || "iad",
+      status: "pending",
+      error: "FLY_API_TOKEN not set. Set it to enable cloud deployment."
+    };
+  }
+  const flyConfig = {
+    apiToken: token,
+    org: process.env.FLY_ORG || "agenticmail",
+    regions: [config.region || "iad"]
+  };
+  const appConfig = {
+    subdomain: config.subdomain,
+    dbType: config.dbType,
+    dbConnectionString: config.dbConnectionString,
+    jwtSecret: config.jwtSecret,
+    memoryMb: config.plan === "free" ? 256 : config.plan === "team" ? 512 : 1024,
+    cpuKind: config.plan === "enterprise" ? "performance" : "shared",
+    cpus: config.plan === "enterprise" ? 2 : 1
+  };
+  const result = await deployToFly(appConfig, flyConfig);
+  return {
+    url: result.url,
+    appName: result.appName,
+    region: result.region,
+    status: result.status === "error" ? "error" : "deployed",
+    error: result.error
+  };
+}
+function generateDockerCompose(opts) {
+  const env = [
+    `      - NODE_ENV=production`,
+    `      - DATABASE_TYPE=${opts.dbType}`,
+    `      - DATABASE_URL=${opts.dbConnectionString}`,
+    `      - JWT_SECRET=${opts.jwtSecret}`,
+    `      - PORT=3000`
+  ];
+  if (opts.smtpHost) {
+    env.push(`      - SMTP_HOST=${opts.smtpHost}`);
+    env.push(`      - SMTP_PORT=${opts.smtpPort || 587}`);
+    if (opts.smtpUser) env.push(`      - SMTP_USER=${opts.smtpUser}`);
+    if (opts.smtpPass) env.push(`      - SMTP_PASS=${opts.smtpPass}`);
+  }
+  return `# AgenticMail Enterprise \u2014 Docker Compose
+# Generated at ${(/* @__PURE__ */ new Date()).toISOString()}
+#
+# Usage:
+#   docker compose up -d
+#   open http://localhost:${opts.port}
+
+version: "3.8"
+
+services:
+  agenticmail:
+    image: agenticmail/enterprise:latest
+    ports:
+      - "${opts.port}:3000"
+    environment:
+${env.join("\n")}
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "wget", "--spider", "-q", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 15s
+    deploy:
+      resources:
+        limits:
+          memory: 512M
+          cpus: '1.0'
+        reservations:
+          memory: 128M
+    logging:
+      driver: json-file
+      options:
+        max-size: "10m"
+        max-file: "3"
+`;
+}
+function generateFlyToml(appName, region) {
+  return `# AgenticMail Enterprise \u2014 Fly.io Config
+# Generated at ${(/* @__PURE__ */ new Date()).toISOString()}
+#
+# Deploy:
+#   fly launch --copy-config
+#   fly secrets set DATABASE_URL="..." JWT_SECRET="..."
+#   fly deploy
+
+app = "${appName}"
+primary_region = "${region}"
+
+[build]
+  image = "agenticmail/enterprise:latest"
+
+[env]
+  PORT = "3000"
+  NODE_ENV = "production"
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = "stop"
+  auto_start_machines = true
+  min_machines_running = 1
+
+  [http_service.concurrency]
+    type = "connections"
+    hard_limit = 100
+    soft_limit = 80
+
+[checks]
+  [checks.health]
+    type = "http"
+    port = 3000
+    path = "/health"
+    interval = "30s"
+    timeout = "5s"
+    grace_period = "10s"
+
+[[vm]]
+  size = "shared-cpu-1x"
+  memory = "256mb"
+`;
+}
+
+export {
+  createAdapter,
+  getSupportedDatabases,
+  deployToCloud,
+  generateDockerCompose,
+  generateFlyToml
+};

package/dist/chunk-PNKVD2UK.js

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __esm,
+  __export,
+  __toCommonJS
+};

package/dist/cli.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import {
+  createAdapter,
+  createServer,
+  deployToCloud,
+  generateDockerCompose,
+  generateFlyToml,
+  getSupportedDatabases
+} from "./chunk-DXNKR3TG.js";
+import "./chunk-PNKVD2UK.js";
+
+// src/cli.ts
+import { randomUUID } from "crypto";
+async function main() {
+  const { default: inquirer } = await import("inquirer");
+  const { default: ora } = await import("ora");
+  const { default: chalk } = await import("chalk");
+  console.log("");
+  console.log(chalk.bold("\u{1F3E2} AgenticMail Enterprise"));
+  console.log(chalk.dim("   AI Agent Identity & Email for Organizations"));
+  console.log("");
+  const { companyName, adminEmail, adminPassword } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "companyName",
+      message: "Company name:",
+      validate: (v) => v.length > 0 || "Required"
+    },
+    {
+      type: "input",
+      name: "adminEmail",
+      message: "Admin email:",
+      validate: (v) => v.includes("@") || "Must be a valid email"
+    },
+    {
+      type: "password",
+      name: "adminPassword",
+      message: "Admin password:",
+      mask: "*",
+      validate: (v) => v.length >= 8 || "Must be at least 8 characters"
+    }
+  ]);
+  const databases = getSupportedDatabases();
+  const { dbType } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "dbType",
+      message: "Database:",
+      choices: databases.map((d) => ({
+        name: `${d.label}  ${chalk.dim(`(${d.group})`)}`,
+        value: d.type
+      }))
+    }
+  ]);
+  let dbConfig = { type: dbType };
+  if (dbType === "sqlite") {
+    const { dbPath } = await inquirer.prompt([{
+      type: "input",
+      name: "dbPath",
+      message: "Database file path:",
+      default: "./agenticmail-enterprise.db"
+    }]);
+    dbConfig.connectionString = dbPath;
+  } else if (dbType === "dynamodb") {
+    const { region, accessKeyId, secretAccessKey } = await inquirer.prompt([
+      { type: "input", name: "region", message: "AWS Region:", default: "us-east-1" },
+      { type: "input", name: "accessKeyId", message: "AWS Access Key ID:" },
+      { type: "password", name: "secretAccessKey", message: "AWS Secret Access Key:", mask: "*" }
+    ]);
+    dbConfig = { ...dbConfig, region, accessKeyId, secretAccessKey };
+  } else if (dbType === "turso") {
+    const { connectionString, authToken } = await inquirer.prompt([
+      { type: "input", name: "connectionString", message: "Turso database URL:", placeholder: "libsql://..." },
+      { type: "password", name: "authToken", message: "Turso auth token:", mask: "*" }
+    ]);
+    dbConfig = { ...dbConfig, connectionString, authToken };
+  } else {
+    const hints = {
+      postgres: "postgresql://user:pass@host:5432/dbname",
+      mysql: "mysql://user:pass@host:3306/dbname",
+      mongodb: "mongodb+srv://user:pass@cluster.mongodb.net/dbname",
+      supabase: "postgresql://postgres:pass@db.xxxx.supabase.co:5432/postgres",
+      neon: "postgresql://user:pass@ep-xxx.us-east-1.aws.neon.tech/dbname?sslmode=require",
+      planetscale: 'mysql://user:pass@aws.connect.psdb.cloud/dbname?ssl={"rejectUnauthorized":true}',
+      cockroachdb: "postgresql://user:pass@cluster.cockroachlabs.cloud:26257/dbname?sslmode=verify-full"
+    };
+    const { connectionString } = await inquirer.prompt([{
+      type: "input",
+      name: "connectionString",
+      message: "Connection string:",
+      suffix: chalk.dim(`  (e.g. ${hints[dbType] || ""})`)
+    }]);
+    dbConfig.connectionString = connectionString;
+  }
+  const { deployTarget } = await inquirer.prompt([{
+    type: "list",
+    name: "deployTarget",
+    message: "Deploy to:",
+    choices: [
+      { name: `AgenticMail Cloud  ${chalk.dim("(managed, instant URL)")}`, value: "cloud" },
+      { name: `Fly.io  ${chalk.dim("(your account)")}`, value: "fly" },
+      { name: `Railway  ${chalk.dim("(your account)")}`, value: "railway" },
+      { name: `Docker  ${chalk.dim("(self-hosted)")}`, value: "docker" },
+      { name: `Local  ${chalk.dim("(dev/testing, runs here)")}`, value: "local" }
+    ]
+  }]);
+  const subdomain = companyName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  let customDomain;
+  if (deployTarget !== "local") {
+    const { wantsDomain } = await inquirer.prompt([{
+      type: "confirm",
+      name: "wantsDomain",
+      message: "Add a custom domain? (can do later)",
+      default: false
+    }]);
+    if (wantsDomain) {
+      const { domain } = await inquirer.prompt([{
+        type: "input",
+        name: "domain",
+        message: "Custom domain:",
+        suffix: chalk.dim("  (e.g. agents.acme.com)")
+      }]);
+      customDomain = domain;
+    }
+  }
+  console.log("");
+  const spinner = ora("Connecting to database...").start();
+  try {
+    const db = await createAdapter(dbConfig);
+    spinner.text = "Running migrations...";
+    await db.migrate();
+    spinner.succeed("Database ready");
+    spinner.start("Creating company...");
+    const settings = await db.updateSettings({
+      name: companyName,
+      subdomain,
+      domain: customDomain
+    });
+    spinner.succeed("Company created");
+    spinner.start("Creating admin account...");
+    const admin = await db.createUser({
+      email: adminEmail,
+      name: "Admin",
+      role: "owner",
+      password: adminPassword
+    });
+    await db.logEvent({
+      actor: admin.id,
+      actorType: "system",
+      action: "setup.complete",
+      resource: `company:${subdomain}`,
+      details: { dbType, deployTarget, companyName }
+    });
+    spinner.succeed("Admin account created");
+    const jwtSecret = randomUUID() + randomUUID();
+    if (deployTarget === "cloud") {
+      spinner.start("Deploying to AgenticMail Cloud...");
+      const result = await deployToCloud({ subdomain, plan: "free" });
+      spinner.succeed(`Deployed to ${result.url}`);
+      console.log("");
+      console.log(chalk.green.bold("\u{1F389} Your dashboard is live!"));
+      console.log("");
+      console.log(`   ${chalk.bold("URL:")}      ${result.url}`);
+      console.log(`   ${chalk.bold("Admin:")}    ${adminEmail}`);
+      console.log(`   ${chalk.bold("Password:")} (the one you just set)`);
+      if (customDomain) {
+        console.log("");
+        console.log(chalk.dim(`   To use ${customDomain}:`));
+        console.log(chalk.dim(`   Add CNAME: ${customDomain} \u2192 ${subdomain}.agenticmail.cloud`));
+      }
+    } else if (deployTarget === "docker") {
+      const compose = generateDockerCompose({
+        dbType,
+        dbConnectionString: dbConfig.connectionString || "",
+        port: 3e3,
+        jwtSecret
+      });
+      const { writeFileSync } = await import("fs");
+      writeFileSync("docker-compose.yml", compose);
+      spinner.succeed("docker-compose.yml generated");
+      console.log("");
+      console.log(chalk.green.bold("\u{1F433} Docker deployment ready!"));
+      console.log("");
+      console.log("   Run: docker compose up -d");
+      console.log("   Dashboard: http://localhost:3000");
+    } else if (deployTarget === "fly") {
+      const flyToml = generateFlyToml(`am-${subdomain}`, "iad");
+      const { writeFileSync } = await import("fs");
+      writeFileSync("fly.toml", flyToml);
+      spinner.succeed("fly.toml generated");
+      console.log("");
+      console.log(chalk.green.bold("\u{1FAB0} Fly.io deployment ready!"));
+      console.log("");
+      console.log("   Run: fly launch --copy-config");
+      console.log(`   Then: fly secrets set DATABASE_URL="${dbConfig.connectionString}" JWT_SECRET="${jwtSecret}"`);
+    } else if (deployTarget === "local") {
+      spinner.start("Starting local server...");
+      const server = createServer({ port: 3e3, db, jwtSecret });
+      server.start();
+      spinner.succeed("Server running");
+      console.log("");
+      console.log(chalk.green.bold("\u{1F389} AgenticMail Enterprise is running!"));
+      console.log("");
+      console.log(`   ${chalk.bold("Dashboard:")}  http://localhost:3000`);
+      console.log(`   ${chalk.bold("API:")}        http://localhost:3000/api`);
+      console.log(`   ${chalk.bold("Admin:")}      ${adminEmail}`);
+      console.log("");
+      console.log(chalk.dim("   Press Ctrl+C to stop"));
+    }
+    console.log("");
+  } catch (err) {
+    spinner.fail(`Setup failed: ${err.message}`);
+    console.error("");
+    console.error(chalk.dim(err.stack));
+    process.exit(1);
+  }
+}
+main().catch(console.error);