@agenticmail/enterprise 0.3.2 → 0.4.0

package/dist/{mysql-RM3S2FV5.js → mysql-A2RYNBQG.js}

@@ -1,10 +1,10 @@
 import {
   getAllCreateStatements
-} from "./chunk-7RGCCHIT.js";
+} from "./chunk-XMDE2NGH.js";
 import {
   DatabaseAdapter
-} from "./chunk-77IDQJL3.js";
-import "./chunk-PNKVD2UK.js";
+} from "./chunk-FLRYMSKY.js";
+import "./chunk-KFQGP6VL.js";
 
 // src/db/mysql.ts
 import { randomUUID, createHash } from "crypto";
@@ -67,6 +67,27 @@ var MysqlAdapter = class extends DatabaseAdapter {
       conn.release();
     }
   }
+  // ─── Engine Integration ──────────────────────────────────
+  getEngineDB() {
+    if (!this.pool) return null;
+    const pool = this.pool;
+    return {
+      run: async (sql, params) => {
+        await pool.execute(sql, params || []);
+      },
+      get: async (sql, params) => {
+        const [rows] = await pool.execute(sql, params || []);
+        return rows[0];
+      },
+      all: async (sql, params) => {
+        const [rows] = await pool.execute(sql, params || []);
+        return rows;
+      }
+    };
+  }
+  getDialect() {
+    return "mysql";
+  }
   // ─── Helpers ─────────────────────────────────────────
   async query(sql, params = []) {
     const [rows] = await this.pool.execute(sql, params);
@@ -96,7 +117,13 @@ var MysqlAdapter = class extends DatabaseAdapter {
       dkimPrivateKey: "dkim_private_key",
       logoUrl: "logo_url",
       primaryColor: "primary_color",
-      plan: "plan"
+      plan: "plan",
+      deploymentKeyHash: "deployment_key_hash",
+      domainRegistrationId: "domain_registration_id",
+      domainDnsChallenge: "domain_dns_challenge",
+      domainVerifiedAt: "domain_verified_at",
+      domainRegisteredAt: "domain_registered_at",
+      domainStatus: "domain_status"
     };
     const sets = [];
     const vals = [];
@@ -106,6 +133,22 @@ var MysqlAdapter = class extends DatabaseAdapter {
         vals.push(updates[key]);
       }
     }
+    if (updates.ssoConfig !== void 0) {
+      sets.push("sso_config = ?");
+      vals.push(JSON.stringify(updates.ssoConfig));
+    }
+    if (updates.toolSecurityConfig !== void 0) {
+      sets.push("tool_security_config = ?");
+      vals.push(JSON.stringify(updates.toolSecurityConfig));
+    }
+    if (updates.firewallConfig !== void 0) {
+      sets.push("firewall_config = ?");
+      vals.push(JSON.stringify(updates.firewallConfig));
+    }
+    if (updates.modelPricingConfig !== void 0) {
+      sets.push("model_pricing_config = ?");
+      vals.push(JSON.stringify(updates.modelPricingConfig));
+    }
     if (sets.length === 0) return this.getSettings();
     sets.push("updated_at = NOW()");
     vals.push("default");
@@ -114,7 +157,7 @@ var MysqlAdapter = class extends DatabaseAdapter {
   }
   // ─── Agents ──────────────────────────────────────────
   async createAgent(input) {
-    const id = randomUUID();
+    const id = input.id || randomUUID();
     const email = input.email || `${input.name.toLowerCase().replace(/\s+/g, "-")}@localhost`;
     await this.execute(
       `INSERT INTO agents (id, name, email, role, metadata, created_by) VALUES (?, ?, ?, ?, ?, ?)`,
@@ -510,9 +553,19 @@ var MysqlAdapter = class extends DatabaseAdapter {
       dkimPrivateKey: r.dkim_private_key,
       logoUrl: r.logo_url,
       primaryColor: r.primary_color,
+      ssoConfig: r.sso_config ? typeof r.sso_config === "string" ? JSON.parse(r.sso_config) : r.sso_config : void 0,
+      toolSecurityConfig: r.tool_security_config ? typeof r.tool_security_config === "string" ? JSON.parse(r.tool_security_config) : r.tool_security_config : {},
+      firewallConfig: r.firewall_config ? typeof r.firewall_config === "string" ? JSON.parse(r.firewall_config) : r.firewall_config : {},
+      modelPricingConfig: r.model_pricing_config ? typeof r.model_pricing_config === "string" ? JSON.parse(r.model_pricing_config) : r.model_pricing_config : {},
       plan: r.plan,
       createdAt: new Date(r.created_at),
-      updatedAt: new Date(r.updated_at)
+      updatedAt: new Date(r.updated_at),
+      deploymentKeyHash: r.deployment_key_hash,
+      domainRegistrationId: r.domain_registration_id,
+      domainDnsChallenge: r.domain_dns_challenge,
+      domainVerifiedAt: r.domain_verified_at || void 0,
+      domainRegisteredAt: r.domain_registered_at || void 0,
+      domainStatus: r.domain_status || "unregistered"
     };
   }
 };

package/dist/{postgres-LN7A6MGQ.js → postgres-OE23X46P.js}

@@ -1,10 +1,10 @@
 import {
   getAllCreateStatements
-} from "./chunk-7RGCCHIT.js";
+} from "./chunk-XMDE2NGH.js";
 import {
   DatabaseAdapter
-} from "./chunk-77IDQJL3.js";
-import "./chunk-PNKVD2UK.js";
+} from "./chunk-FLRYMSKY.js";
+import "./chunk-KFQGP6VL.js";
 
 // src/db/postgres.ts
 import { randomUUID, createHash } from "crypto";
@@ -46,6 +46,27 @@ var PostgresAdapter = class extends DatabaseAdapter {
   isConnected() {
     return this.pool !== null;
   }
+  // ─── Engine Integration ──────────────────────────────────
+  getEngineDB() {
+    if (!this.pool) return null;
+    const pool = this.pool;
+    return {
+      run: async (sql, params) => {
+        await pool.query(sql, params);
+      },
+      get: async (sql, params) => {
+        const result = await pool.query(sql, params);
+        return result.rows[0];
+      },
+      all: async (sql, params) => {
+        const result = await pool.query(sql, params);
+        return result.rows;
+      }
+    };
+  }
+  getDialect() {
+    return "postgres";
+  }
   async migrate() {
     const stmts = getAllCreateStatements();
     const client = await this.pool.connect();
@@ -89,7 +110,13 @@ var PostgresAdapter = class extends DatabaseAdapter {
       dkimPrivateKey: "dkim_private_key",
       logoUrl: "logo_url",
       primaryColor: "primary_color",
-      plan: "plan"
+      plan: "plan",
+      deploymentKeyHash: "deployment_key_hash",
+      domainRegistrationId: "domain_registration_id",
+      domainDnsChallenge: "domain_dns_challenge",
+      domainVerifiedAt: "domain_verified_at",
+      domainRegisteredAt: "domain_registered_at",
+      domainStatus: "domain_status"
     };
     for (const [key, col] of Object.entries(map)) {
       if (updates[key] !== void 0) {
@@ -98,6 +125,26 @@ var PostgresAdapter = class extends DatabaseAdapter {
         i++;
       }
     }
+    if (updates.ssoConfig !== void 0) {
+      fields.push(`sso_config = $${i}`);
+      values.push(JSON.stringify(updates.ssoConfig));
+      i++;
+    }
+    if (updates.toolSecurityConfig !== void 0) {
+      fields.push(`tool_security_config = $${i}`);
+      values.push(JSON.stringify(updates.toolSecurityConfig));
+      i++;
+    }
+    if (updates.firewallConfig !== void 0) {
+      fields.push(`firewall_config = $${i}`);
+      values.push(JSON.stringify(updates.firewallConfig));
+      i++;
+    }
+    if (updates.modelPricingConfig !== void 0) {
+      fields.push(`model_pricing_config = $${i}`);
+      values.push(JSON.stringify(updates.modelPricingConfig));
+      i++;
+    }
     fields.push(`updated_at = NOW()`);
     values.push("default");
     const { rows } = await this.pool.query(
@@ -108,7 +155,7 @@ var PostgresAdapter = class extends DatabaseAdapter {
   }
   // ─── Agents ──────────────────────────────────────────────
   async createAgent(input) {
-    const id = randomUUID();
+    const id = input.id || randomUUID();
     const email = input.email || `${input.name.toLowerCase().replace(/\s+/g, "-")}@localhost`;
     const { rows } = await this.pool.query(
       `INSERT INTO agents (id, name, email, role, metadata, created_by)
@@ -507,9 +554,19 @@ var PostgresAdapter = class extends DatabaseAdapter {
       dkimPrivateKey: r.dkim_private_key,
       logoUrl: r.logo_url,
       primaryColor: r.primary_color,
+      ssoConfig: r.sso_config ? typeof r.sso_config === "string" ? JSON.parse(r.sso_config) : r.sso_config : void 0,
+      toolSecurityConfig: r.tool_security_config ? typeof r.tool_security_config === "string" ? JSON.parse(r.tool_security_config) : r.tool_security_config : {},
+      firewallConfig: r.firewall_config ? typeof r.firewall_config === "string" ? JSON.parse(r.firewall_config) : r.firewall_config : {},
+      modelPricingConfig: r.model_pricing_config ? typeof r.model_pricing_config === "string" ? JSON.parse(r.model_pricing_config) : r.model_pricing_config : {},
       plan: r.plan,
       createdAt: new Date(r.created_at),
-      updatedAt: new Date(r.updated_at)
+      updatedAt: new Date(r.updated_at),
+      deploymentKeyHash: r.deployment_key_hash,
+      domainRegistrationId: r.domain_registration_id,
+      domainDnsChallenge: r.domain_dns_challenge,
+      domainVerifiedAt: r.domain_verified_at || void 0,
+      domainRegisteredAt: r.domain_registered_at || void 0,
+      domainStatus: r.domain_status || "unregistered"
     };
   }
 };

package/dist/registry/cli.js

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+import {
+  __require
+} from "../chunk-KFQGP6VL.js";
+
+// src/registry/server.ts
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { randomBytes, randomUUID } from "crypto";
+import { resolve as dnsResolve } from "dns/promises";
+function createSqliteDb(dbPath2) {
+  const Database = __require("better-sqlite3");
+  const db = new Database(dbPath2);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS domain_registrations (
+      domain TEXT PRIMARY KEY,
+      key_hash TEXT NOT NULL,
+      dns_challenge TEXT NOT NULL,
+      registration_id TEXT NOT NULL UNIQUE,
+      org_name TEXT,
+      contact_email TEXT,
+      status TEXT NOT NULL DEFAULT 'pending_dns',
+      verified_at TEXT,
+      registered_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_verify_attempt TEXT,
+      verify_attempts INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_dr_status ON domain_registrations(status);
+    CREATE INDEX IF NOT EXISTS idx_dr_reg_id ON domain_registrations(registration_id);
+  `);
+  return {
+    async getDomain(domain) {
+      return db.prepare("SELECT * FROM domain_registrations WHERE domain = ?").get(domain);
+    },
+    async getDomainStatus(domain) {
+      const row = db.prepare("SELECT status, verified_at FROM domain_registrations WHERE domain = ?").get(domain);
+      return row || null;
+    },
+    async insertDomain(r) {
+      db.prepare(`
+        INSERT INTO domain_registrations (domain, key_hash, dns_challenge, registration_id, org_name, contact_email)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(r.domain, r.keyHash, r.dnsChallenge, r.registrationId, r.orgName, r.contactEmail);
+    },
+    async updateDomainPending(r) {
+      db.prepare(`
+        UPDATE domain_registrations
+        SET key_hash = ?, dns_challenge = ?, registration_id = ?,
+            org_name = ?, contact_email = ?, status = 'pending_dns',
+            registered_at = datetime('now'), verified_at = NULL,
+            verify_attempts = 0
+        WHERE domain = ?
+      `).run(r.keyHash, r.dnsChallenge, r.registrationId, r.orgName, r.contactEmail, r.domain);
+    },
+    async setVerified(domain) {
+      db.prepare(`
+        UPDATE domain_registrations
+        SET status = 'verified', verified_at = datetime('now')
+        WHERE domain = ?
+      `).run(domain);
+    },
+    async updateVerifyAttempt(domain) {
+      db.prepare(`
+        UPDATE domain_registrations
+        SET last_verify_attempt = datetime('now'), verify_attempts = verify_attempts + 1
+        WHERE domain = ?
+      `).run(domain);
+    },
+    async updateRecovery(domain, dnsChallenge, registrationId) {
+      db.prepare(`
+        UPDATE domain_registrations
+        SET dns_challenge = ?, registration_id = ?, status = 'pending_dns',
+            verified_at = NULL, verify_attempts = 0
+        WHERE domain = ?
+      `).run(dnsChallenge, registrationId, domain);
+    },
+    async close() {
+      db.close();
+    }
+  };
+}
+function createPostgresDb(databaseUrl2) {
+  const postgres = __require("postgres");
+  const sql = postgres(databaseUrl2, { max: 10 });
+  let migrated = false;
+  async function ensureMigrated() {
+    if (migrated) return;
+    await sql`
+      CREATE TABLE IF NOT EXISTS domain_registrations (
+        domain TEXT PRIMARY KEY,
+        key_hash TEXT NOT NULL,
+        dns_challenge TEXT NOT NULL,
+        registration_id TEXT NOT NULL UNIQUE,
+        org_name TEXT,
+        contact_email TEXT,
+        status TEXT NOT NULL DEFAULT 'pending_dns',
+        verified_at TIMESTAMPTZ,
+        registered_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        last_verify_attempt TIMESTAMPTZ,
+        verify_attempts INTEGER NOT NULL DEFAULT 0
+      )
+    `;
+    await sql`CREATE INDEX IF NOT EXISTS idx_dr_status ON domain_registrations(status)`;
+    await sql`CREATE INDEX IF NOT EXISTS idx_dr_reg_id ON domain_registrations(registration_id)`;
+    migrated = true;
+  }
+  function mapRow(row) {
+    if (!row) return null;
+    return {
+      domain: row.domain,
+      key_hash: row.key_hash,
+      dns_challenge: row.dns_challenge,
+      registration_id: row.registration_id,
+      org_name: row.org_name,
+      contact_email: row.contact_email,
+      status: row.status,
+      verified_at: row.verified_at ? new Date(row.verified_at).toISOString() : null,
+      registered_at: row.registered_at ? new Date(row.registered_at).toISOString() : "",
+      last_verify_attempt: row.last_verify_attempt ? new Date(row.last_verify_attempt).toISOString() : null,
+      verify_attempts: row.verify_attempts
+    };
+  }
+  return {
+    async getDomain(domain) {
+      await ensureMigrated();
+      const rows = await sql`SELECT * FROM domain_registrations WHERE domain = ${domain}`;
+      return mapRow(rows[0]);
+    },
+    async getDomainStatus(domain) {
+      await ensureMigrated();
+      const rows = await sql`SELECT status, verified_at FROM domain_registrations WHERE domain = ${domain}`;
+      if (!rows[0]) return null;
+      return { status: rows[0].status, verified_at: rows[0].verified_at ? new Date(rows[0].verified_at).toISOString() : null };
+    },
+    async insertDomain(r) {
+      await ensureMigrated();
+      await sql`
+        INSERT INTO domain_registrations (domain, key_hash, dns_challenge, registration_id, org_name, contact_email)
+        VALUES (${r.domain}, ${r.keyHash}, ${r.dnsChallenge}, ${r.registrationId}, ${r.orgName}, ${r.contactEmail})
+      `;
+    },
+    async updateDomainPending(r) {
+      await ensureMigrated();
+      await sql`
+        UPDATE domain_registrations
+        SET key_hash = ${r.keyHash}, dns_challenge = ${r.dnsChallenge}, registration_id = ${r.registrationId},
+            org_name = ${r.orgName}, contact_email = ${r.contactEmail}, status = 'pending_dns',
+            registered_at = NOW(), verified_at = NULL,
+            verify_attempts = 0
+        WHERE domain = ${r.domain}
+      `;
+    },
+    async setVerified(domain) {
+      await ensureMigrated();
+      await sql`
+        UPDATE domain_registrations
+        SET status = 'verified', verified_at = NOW()
+        WHERE domain = ${domain}
+      `;
+    },
+    async updateVerifyAttempt(domain) {
+      await ensureMigrated();
+      await sql`
+        UPDATE domain_registrations
+        SET last_verify_attempt = NOW(), verify_attempts = verify_attempts + 1
+        WHERE domain = ${domain}
+      `;
+    },
+    async updateRecovery(domain, dnsChallenge, registrationId) {
+      await ensureMigrated();
+      await sql`
+        UPDATE domain_registrations
+        SET dns_challenge = ${dnsChallenge}, registration_id = ${registrationId}, status = 'pending_dns',
+            verified_at = NULL, verify_attempts = 0
+        WHERE domain = ${domain}
+      `;
+    },
+    async close() {
+      await sql.end();
+    }
+  };
+}
+var RateLimiter = class {
+  buckets = /* @__PURE__ */ new Map();
+  limit;
+  constructor(limitPerMinute) {
+    this.limit = limitPerMinute;
+  }
+  check(ip) {
+    const now = Date.now();
+    let bucket = this.buckets.get(ip);
+    if (!bucket) {
+      bucket = { tokens: this.limit - 1, lastRefill: now };
+      this.buckets.set(ip, bucket);
+      return true;
+    }
+    const elapsed = (now - bucket.lastRefill) / 6e4;
+    bucket.tokens = Math.min(this.limit, bucket.tokens + elapsed * this.limit);
+    bucket.lastRefill = now;
+    if (bucket.tokens < 1) return false;
+    bucket.tokens -= 1;
+    return true;
+  }
+};
+async function verifyDnsTxt(domain, expectedChallenge) {
+  const hostname = `_agenticmail-verify.${domain}`;
+  try {
+    const records = await dnsResolve(hostname, "TXT");
+    for (const record of records) {
+      const value = record.join("");
+      if (value === expectedChallenge) return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function createRegistryServer(config) {
+  const app = new Hono();
+  const limiter = new RateLimiter(config.rateLimitPerMinute ?? 20);
+  let registryDb = null;
+  function getDb() {
+    if (!registryDb) {
+      registryDb = config.databaseUrl ? createPostgresDb(config.databaseUrl) : createSqliteDb(config.dbPath);
+    }
+    return registryDb;
+  }
+  app.use("*", async (c, next) => {
+    const ip = c.req.header("x-forwarded-for")?.split(",")[0]?.trim() || c.req.header("x-real-ip") || "unknown";
+    if (!limiter.check(ip)) {
+      return c.json({ error: "Rate limit exceeded. Try again later." }, 429);
+    }
+    return next();
+  });
+  app.get("/health", (c) => c.json({
+    status: "ok",
+    service: "agenticmail-registry",
+    backend: config.databaseUrl ? "postgres" : "sqlite"
+  }));
+  app.post("/v1/domains/register", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    if (!body?.domain || !body?.keyHash) {
+      return c.json({ error: "Missing required fields: domain, keyHash" }, 400);
+    }
+    const domain = String(body.domain).toLowerCase().trim();
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(domain)) {
+      return c.json({ error: "Invalid domain format" }, 400);
+    }
+    const d = getDb();
+    const existing = await d.getDomain(domain);
+    if (existing?.status === "verified") {
+      return c.json({
+        error: "Domain is already registered and verified. Use the /recover endpoint if this is your domain."
+      }, 409);
+    }
+    const dnsChallenge = `am-verify=${randomBytes(24).toString("hex")}`;
+    const registrationId = randomUUID();
+    const record = {
+      domain,
+      keyHash: body.keyHash,
+      dnsChallenge,
+      registrationId,
+      orgName: body.orgName || null,
+      contactEmail: body.contactEmail || null
+    };
+    if (existing) {
+      await d.updateDomainPending(record);
+    } else {
+      await d.insertDomain(record);
+    }
+    return c.json({ registrationId, dnsChallenge }, 201);
+  });
+  app.post("/v1/domains/verify", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    if (!body?.domain) {
+      return c.json({ error: "Missing required field: domain" }, 400);
+    }
+    const domain = String(body.domain).toLowerCase().trim();
+    const d = getDb();
+    const record = await d.getDomain(domain);
+    if (!record) {
+      return c.json({ error: "Domain is not registered" }, 404);
+    }
+    if (record.status === "verified") {
+      return c.json({ verified: true, verifiedAt: record.verified_at });
+    }
+    await d.updateVerifyAttempt(domain);
+    const verified = await verifyDnsTxt(domain, record.dns_challenge);
+    if (verified) {
+      await d.setVerified(domain);
+      return c.json({ verified: true });
+    }
+    return c.json({
+      verified: false,
+      error: `DNS TXT record not found. Add: _agenticmail-verify.${domain} TXT "${record.dns_challenge}"`,
+      attempts: record.verify_attempts + 1
+    });
+  });
+  app.post("/v1/domains/recover", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    if (!body?.domain || !body?.deploymentKey) {
+      return c.json({ error: "Missing required fields: domain, deploymentKey" }, 400);
+    }
+    const domain = String(body.domain).toLowerCase().trim();
+    const d = getDb();
+    const record = await d.getDomain(domain);
+    if (!record) {
+      return c.json({ error: "Domain is not registered" }, 404);
+    }
+    const { default: bcrypt } = await import("bcryptjs");
+    const keyMatch = await bcrypt.compare(body.deploymentKey, record.key_hash);
+    if (!keyMatch) {
+      return c.json({ error: "Invalid deployment key" }, 403);
+    }
+    const newChallenge = `am-verify=${randomBytes(24).toString("hex")}`;
+    const newRegId = randomUUID();
+    await d.updateRecovery(domain, newChallenge, newRegId);
+    return c.json({
+      success: true,
+      registrationId: newRegId,
+      dnsChallenge: newChallenge
+    });
+  });
+  app.get("/v1/domains/:domain/status", async (c) => {
+    const domain = c.req.param("domain").toLowerCase().trim();
+    const d = getDb();
+    const record = await d.getDomainStatus(domain);
+    if (!record) {
+      return c.json({ registered: false, verified: false });
+    }
+    return c.json({
+      registered: true,
+      verified: record.status === "verified"
+    });
+  });
+  app.notFound((c) => c.json({ error: "Not found" }, 404));
+  return {
+    app,
+    start: () => {
+      return new Promise((resolve) => {
+        const server2 = serve(
+          { fetch: app.fetch, port: config.port },
+          (info) => {
+            const backend = config.databaseUrl ? "postgres" : `sqlite (${config.dbPath})`;
+            console.log(`
+\u{1F512} AgenticMail Domain Registry`);
+            console.log(`   API:     http://localhost:${info.port}/v1`);
+            console.log(`   Health:  http://localhost:${info.port}/health`);
+            console.log(`   Backend: ${backend}`);
+            console.log("");
+            process.on("SIGINT", async () => {
+              console.log("\n\u23F3 Shutting down registry...");
+              if (registryDb) await registryDb.close();
+              server2.close(() => {
+                console.log("\u2705 Registry shutdown complete");
+                process.exit(0);
+              });
+              setTimeout(() => process.exit(1), 5e3).unref();
+            });
+            process.on("SIGTERM", () => process.emit("SIGINT"));
+            resolve({
+              close: async () => {
+                if (registryDb) await registryDb.close();
+                server2.close();
+              }
+            });
+          }
+        );
+      });
+    }
+  };
+}
+
+// src/registry/cli.ts
+var args = process.argv.slice(2);
+function getFlag(name, fallback) {
+  const idx = args.indexOf(name);
+  if (idx !== -1 && args[idx + 1]) return args[idx + 1];
+  return fallback;
+}
+var port = parseInt(getFlag("--port", "8080"), 10);
+var dbPath = getFlag("--db", "./registry.db");
+var rateLimitPerMinute = parseInt(getFlag("--rate-limit", "20"), 10);
+var databaseUrlFlag = getFlag("--database-url", "");
+var databaseUrl = databaseUrlFlag || process.env.REGISTRY_DATABASE_URL || void 0;
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(`
+AgenticMail Domain Registry Server
+
+Usage:
+  node dist/registry/cli.js [options]
+
+Options:
+  --port <number>         Port to listen on (default: 8080)
+  --db <path>             SQLite database path (default: ./registry.db)
+  --database-url <url>    Postgres connection URL (overrides --db)
+  --rate-limit <number>   Requests per minute per IP (default: 20)
+  --help, -h              Show this help message
+
+Environment Variables:
+  REGISTRY_DATABASE_URL   Postgres connection URL (fallback for --database-url)
+`);
+  process.exit(0);
+}
+var server = createRegistryServer({ port, dbPath, databaseUrl, rateLimitPerMinute });
+server.start().catch((err) => {
+  console.error("Failed to start registry:", err);
+  process.exit(1);
+});