@hasna/domains 0.0.28 → 0.0.31

package/dist/storage.js

@@ -1,825 +0,0 @@
-// @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// src/db/pg-migrations.ts
-var PG_MIGRATIONS = [
-  `CREATE TABLE IF NOT EXISTS domains (
-    id TEXT PRIMARY KEY,
-    name TEXT NOT NULL UNIQUE,
-    registrar TEXT,
-    status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('discovered', 'researching', 'offered', 'negotiating', 'purchased', 'active', 'not_available', 'premium_only', 'declined', 'expired', 'transferring', 'redemption')),
-    registered_at TEXT,
-    expires_at TEXT,
-    auto_renew BOOLEAN NOT NULL DEFAULT TRUE,
-    is_premium BOOLEAN NOT NULL DEFAULT FALSE,
-    premium_price DOUBLE PRECISION,
-    standard_price DOUBLE PRECISION,
-    purchase_price DOUBLE PRECISION,
-    purchase_date TEXT,
-    nameservers TEXT NOT NULL DEFAULT '[]',
-    whois TEXT NOT NULL DEFAULT '{}',
-    ssl_expires_at TEXT,
-    ssl_issuer TEXT,
-    notes TEXT,
-    metadata TEXT NOT NULL DEFAULT '{}',
-    created_at TEXT NOT NULL DEFAULT NOW()::text,
-    updated_at TEXT NOT NULL DEFAULT NOW()::text
-  )`,
-  `CREATE TABLE IF NOT EXISTS dns_records (
-    id TEXT PRIMARY KEY,
-    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-    type TEXT NOT NULL CHECK (type IN ('A', 'AAAA', 'CNAME', 'MX', 'TXT', 'NS', 'SRV')),
-    name TEXT NOT NULL,
-    value TEXT NOT NULL,
-    ttl INTEGER NOT NULL DEFAULT 3600,
-    priority INTEGER,
-    created_at TEXT NOT NULL DEFAULT NOW()::text
-  )`,
-  `CREATE TABLE IF NOT EXISTS alerts (
-    id TEXT PRIMARY KEY,
-    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-    type TEXT NOT NULL CHECK (type IN ('expiry', 'ssl_expiry', 'dns_change')),
-    trigger_days_before INTEGER,
-    sent_at TEXT,
-    created_at TEXT NOT NULL DEFAULT NOW()::text
-  )`,
-  `CREATE TABLE IF NOT EXISTS domain_offers (
-    id TEXT PRIMARY KEY,
-    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-    our_offer DOUBLE PRECISION,
-    their_ask DOUBLE PRECISION,
-    status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'accepted', 'rejected', 'countered')),
-    notes TEXT,
-    created_at TEXT NOT NULL DEFAULT NOW()::text,
-    owner_contact_id TEXT
-  )`,
-  `CREATE TABLE IF NOT EXISTS domain_emails (
-    id TEXT PRIMARY KEY,
-    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-    email_id TEXT NOT NULL,
-    thread_id TEXT,
-    type TEXT NOT NULL CHECK (type IN ('inquiry', 'offer', 'counter_offer', 'confirmation', 'renewal_notice', 'transfer')),
-    created_at TEXT NOT NULL DEFAULT NOW()::text,
-    UNIQUE(domain_id, email_id)
-  )`,
-  `CREATE TABLE IF NOT EXISTS domain_owners (
-    id TEXT PRIMARY KEY,
-    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-    contact_id TEXT,
-    owner_name TEXT,
-    owner_email TEXT,
-    owner_phone TEXT,
-    owner_organization TEXT,
-    source TEXT NOT NULL DEFAULT 'manual' CHECK (source IN ('whois', 'manual', 'brandsight', 'import')),
-    verified BOOLEAN NOT NULL DEFAULT FALSE,
-    notes TEXT,
-    created_at TEXT NOT NULL DEFAULT NOW()::text,
-    updated_at TEXT NOT NULL DEFAULT NOW()::text
-  )`,
-  `CREATE TABLE IF NOT EXISTS domain_history (
-    id TEXT PRIMARY KEY,
-    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-    snapshot_type TEXT NOT NULL CHECK (snapshot_type IN ('whois', 'rdap', 'dns', 'ssl', 'reputation', 'exa_research', 'purchase', 'renewal')),
-    raw_data TEXT NOT NULL DEFAULT '{}',
-    registrant_name TEXT,
-    registrant_email TEXT,
-    registrant_org TEXT,
-    nameservers TEXT NOT NULL DEFAULT '[]',
-    registrar TEXT,
-    status TEXT,
-    notes TEXT,
-    created_at TEXT NOT NULL DEFAULT NOW()::text
-  )`,
-  `CREATE TABLE IF NOT EXISTS domain_reputation (
-    id TEXT PRIMARY KEY,
-    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-    is_blacklisted BOOLEAN NOT NULL DEFAULT FALSE,
-    blacklist_sources TEXT NOT NULL DEFAULT '[]',
-    threat_score INTEGER,
-    spam_score INTEGER,
-    malware_detected BOOLEAN NOT NULL DEFAULT FALSE,
-    phishing_detected BOOLEAN NOT NULL DEFAULT FALSE,
-    reputation_sources TEXT NOT NULL DEFAULT '[]',
-    last_checked_at TEXT,
-    notes TEXT,
-    created_at TEXT NOT NULL DEFAULT NOW()::text,
-    updated_at TEXT NOT NULL DEFAULT NOW()::text
-  )`,
-  `CREATE INDEX IF NOT EXISTS idx_domains_name ON domains(name)`,
-  `CREATE INDEX IF NOT EXISTS idx_domains_registrar ON domains(registrar)`,
-  `CREATE INDEX IF NOT EXISTS idx_domains_status ON domains(status)`,
-  `CREATE INDEX IF NOT EXISTS idx_domains_expires_at ON domains(expires_at)`,
-  `CREATE INDEX IF NOT EXISTS idx_domains_is_premium ON domains(is_premium)`,
-  `CREATE INDEX IF NOT EXISTS idx_dns_records_domain ON dns_records(domain_id)`,
-  `CREATE INDEX IF NOT EXISTS idx_dns_records_type ON dns_records(type)`,
-  `CREATE INDEX IF NOT EXISTS idx_alerts_domain ON alerts(domain_id)`,
-  `CREATE INDEX IF NOT EXISTS idx_alerts_type ON alerts(type)`,
-  `CREATE INDEX IF NOT EXISTS idx_domain_offers_domain ON domain_offers(domain_id)`,
-  `CREATE INDEX IF NOT EXISTS idx_domain_offers_owner ON domain_offers(owner_contact_id)`,
-  `CREATE INDEX IF NOT EXISTS idx_domain_emails_domain ON domain_emails(domain_id)`,
-  `CREATE UNIQUE INDEX IF NOT EXISTS idx_domain_emails_unique ON domain_emails(domain_id, email_id)`,
-  `CREATE INDEX IF NOT EXISTS idx_domain_owners_domain ON domain_owners(domain_id)`,
-  `CREATE INDEX IF NOT EXISTS idx_domain_owners_contact ON domain_owners(contact_id)`,
-  `CREATE INDEX IF NOT EXISTS idx_domain_owners_email ON domain_owners(owner_email)`,
-  `CREATE INDEX IF NOT EXISTS idx_domain_history_domain ON domain_history(domain_id)`,
-  `CREATE INDEX IF NOT EXISTS idx_domain_history_type ON domain_history(snapshot_type)`,
-  `CREATE INDEX IF NOT EXISTS idx_domain_history_created ON domain_history(created_at)`,
-  `CREATE INDEX IF NOT EXISTS idx_domain_history_email ON domain_history(registrant_email)`,
-  `CREATE INDEX IF NOT EXISTS idx_domain_reputation_domain ON domain_reputation(domain_id)`,
-  `CREATE INDEX IF NOT EXISTS idx_domain_reputation_blacklisted ON domain_reputation(is_blacklisted)`
-];
-// src/db/remote-storage.ts
-import pg from "pg";
-function translatePlaceholders(sql) {
-  let index = 0;
-  return sql.replace(/\?/g, () => `$${++index}`);
-}
-function normalizeParams(params) {
-  const flat = params.length === 1 && Array.isArray(params[0]) ? params[0] : params;
-  return flat.map((value) => value === undefined ? null : value);
-}
-function sslConfigFor(connectionString) {
-  return connectionString.includes("sslmode=require") || connectionString.includes("ssl=true") ? { rejectUnauthorized: false } : undefined;
-}
-
-class PgAdapterAsync {
-  pool;
-  constructor(connectionString) {
-    this.pool = new pg.Pool({ connectionString, ssl: sslConfigFor(connectionString) });
-  }
-  async run(sql, ...params) {
-    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
-    return { changes: result.rowCount ?? 0 };
-  }
-  async all(sql, ...params) {
-    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
-    return result.rows;
-  }
-  async close() {
-    await this.pool.end();
-  }
-}
-// src/db/database.ts
-import { Database } from "bun:sqlite";
-import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
-import { dirname, join, resolve } from "path";
-import { homedir } from "os";
-
-// src/db/migrations.ts
-var MIGRATIONS = [
-  {
-    id: 1,
-    name: "initial_schema",
-    sql: `
-      CREATE TABLE IF NOT EXISTS domains (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL UNIQUE,
-        registrar TEXT,
-        status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'expired', 'transferring', 'redemption')),
-        registered_at TEXT,
-        expires_at TEXT,
-        auto_renew INTEGER NOT NULL DEFAULT 1,
-        nameservers TEXT NOT NULL DEFAULT '[]',
-        whois TEXT NOT NULL DEFAULT '{}',
-        ssl_expires_at TEXT,
-        ssl_issuer TEXT,
-        notes TEXT,
-        metadata TEXT NOT NULL DEFAULT '{}',
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE TABLE IF NOT EXISTS dns_records (
-        id TEXT PRIMARY KEY,
-        domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-        type TEXT NOT NULL CHECK (type IN ('A', 'AAAA', 'CNAME', 'MX', 'TXT', 'NS', 'SRV')),
-        name TEXT NOT NULL,
-        value TEXT NOT NULL,
-        ttl INTEGER NOT NULL DEFAULT 3600,
-        priority INTEGER,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE TABLE IF NOT EXISTS alerts (
-        id TEXT PRIMARY KEY,
-        domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-        type TEXT NOT NULL CHECK (type IN ('expiry', 'ssl_expiry', 'dns_change')),
-        trigger_days_before INTEGER,
-        sent_at TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_domains_name ON domains(name);
-      CREATE INDEX IF NOT EXISTS idx_domains_registrar ON domains(registrar);
-      CREATE INDEX IF NOT EXISTS idx_domains_status ON domains(status);
-      CREATE INDEX IF NOT EXISTS idx_domains_expires_at ON domains(expires_at);
-      CREATE INDEX IF NOT EXISTS idx_dns_records_domain ON dns_records(domain_id);
-      CREATE INDEX IF NOT EXISTS idx_dns_records_type ON dns_records(type);
-      CREATE INDEX IF NOT EXISTS idx_alerts_domain ON alerts(domain_id);
-      CREATE INDEX IF NOT EXISTS idx_alerts_type ON alerts(type);
-    `
-  },
-  {
-    id: 2,
-    name: "domain_purchase_tracking",
-    sql: `
-      PRAGMA foreign_keys=OFF;
-
-      ALTER TABLE dns_records RENAME TO dns_records_old;
-      ALTER TABLE alerts RENAME TO alerts_old;
-      ALTER TABLE domains RENAME TO domains_old;
-
-      CREATE TABLE domains (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL UNIQUE,
-        registrar TEXT,
-        status TEXT NOT NULL DEFAULT 'active' CHECK (
-          status IN (
-            'discovered',
-            'researching',
-            'offered',
-            'negotiating',
-            'purchased',
-            'active',
-            'not_available',
-            'premium_only',
-            'declined',
-            'expired',
-            'transferring',
-            'redemption'
-          )
-        ),
-        registered_at TEXT,
-        expires_at TEXT,
-        auto_renew INTEGER NOT NULL DEFAULT 1,
-        is_premium INTEGER NOT NULL DEFAULT 0,
-        premium_price REAL,
-        standard_price REAL,
-        purchase_price REAL,
-        purchase_date TEXT,
-        nameservers TEXT NOT NULL DEFAULT '[]',
-        whois TEXT NOT NULL DEFAULT '{}',
-        ssl_expires_at TEXT,
-        ssl_issuer TEXT,
-        notes TEXT,
-        metadata TEXT NOT NULL DEFAULT '{}',
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE TABLE dns_records (
-        id TEXT PRIMARY KEY,
-        domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-        type TEXT NOT NULL CHECK (type IN ('A', 'AAAA', 'CNAME', 'MX', 'TXT', 'NS', 'SRV')),
-        name TEXT NOT NULL,
-        value TEXT NOT NULL,
-        ttl INTEGER NOT NULL DEFAULT 3600,
-        priority INTEGER,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE TABLE alerts (
-        id TEXT PRIMARY KEY,
-        domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-        type TEXT NOT NULL CHECK (type IN ('expiry', 'ssl_expiry', 'dns_change')),
-        trigger_days_before INTEGER,
-        sent_at TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      INSERT INTO domains (
-        id, name, registrar, status, registered_at, expires_at, auto_renew,
-        is_premium, premium_price, standard_price, purchase_price, purchase_date,
-        nameservers, whois, ssl_expires_at, ssl_issuer, notes, metadata, created_at, updated_at
-      )
-      SELECT
-        id, name, registrar, status, registered_at, expires_at, auto_renew,
-        0, NULL, NULL, NULL, NULL,
-        nameservers, whois, ssl_expires_at, ssl_issuer, notes, metadata, created_at, updated_at
-      FROM domains_old;
-
-      INSERT INTO dns_records (id, domain_id, type, name, value, ttl, priority, created_at)
-      SELECT id, domain_id, type, name, value, ttl, priority, created_at
-      FROM dns_records_old;
-
-      INSERT INTO alerts (id, domain_id, type, trigger_days_before, sent_at, created_at)
-      SELECT id, domain_id, type, trigger_days_before, sent_at, created_at
-      FROM alerts_old;
-
-      DROP TABLE domains_old;
-      DROP TABLE dns_records_old;
-      DROP TABLE alerts_old;
-
-      CREATE TABLE domain_offers (
-        id TEXT PRIMARY KEY,
-        domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-        our_offer REAL,
-        their_ask REAL,
-        status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'accepted', 'rejected', 'countered')),
-        notes TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE TABLE domain_emails (
-        id TEXT PRIMARY KEY,
-        domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-        email_id TEXT NOT NULL,
-        thread_id TEXT,
-        type TEXT NOT NULL CHECK (type IN ('inquiry', 'offer', 'counter_offer', 'confirmation', 'renewal_notice', 'transfer')),
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE INDEX idx_domains_name ON domains(name);
-      CREATE INDEX idx_domains_registrar ON domains(registrar);
-      CREATE INDEX idx_domains_status ON domains(status);
-      CREATE INDEX idx_domains_expires_at ON domains(expires_at);
-      CREATE INDEX idx_domains_is_premium ON domains(is_premium);
-      CREATE INDEX idx_dns_records_domain ON dns_records(domain_id);
-      CREATE INDEX idx_dns_records_type ON dns_records(type);
-      CREATE INDEX idx_alerts_domain ON alerts(domain_id);
-      CREATE INDEX idx_alerts_type ON alerts(type);
-      CREATE INDEX idx_domain_offers_domain ON domain_offers(domain_id);
-      CREATE INDEX idx_domain_emails_domain ON domain_emails(domain_id);
-      CREATE UNIQUE INDEX idx_domain_emails_unique ON domain_emails(domain_id, email_id);
-
-      PRAGMA foreign_keys=ON;
-    `
-  },
-  {
-    id: 3,
-    name: "domain_owner_tracking",
-    sql: `
-      CREATE TABLE IF NOT EXISTS domain_owners (
-        id TEXT PRIMARY KEY,
-        domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-        contact_id TEXT,
-        owner_name TEXT,
-        owner_email TEXT,
-        owner_phone TEXT,
-        owner_organization TEXT,
-        source TEXT NOT NULL DEFAULT 'manual' CHECK (source IN ('whois', 'manual', 'brandsight', 'import')),
-        verified INTEGER NOT NULL DEFAULT 0,
-        notes TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      ALTER TABLE domain_offers ADD COLUMN owner_contact_id TEXT REFERENCES domain_owners(id);
-
-      CREATE INDEX idx_domain_owners_domain ON domain_owners(domain_id);
-      CREATE INDEX idx_domain_owners_contact ON domain_owners(contact_id);
-      CREATE INDEX idx_domain_owners_email ON domain_owners(owner_email);
-      CREATE INDEX idx_domain_offers_owner ON domain_offers(owner_contact_id);
-    `
-  },
-  {
-    id: 4,
-    name: "domain_history_tracking",
-    sql: `
-      CREATE TABLE IF NOT EXISTS domain_history (
-        id TEXT PRIMARY KEY,
-        domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-        snapshot_type TEXT NOT NULL CHECK (snapshot_type IN ('whois', 'rdap', 'dns', 'ssl', 'reputation', 'exa_research')),
-        raw_data TEXT NOT NULL DEFAULT '{}',
-        registrant_name TEXT,
-        registrant_email TEXT,
-        registrant_org TEXT,
-        nameservers TEXT NOT NULL DEFAULT '[]',
-        registrar TEXT,
-        status TEXT,
-        notes TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE INDEX idx_domain_history_domain ON domain_history(domain_id);
-      CREATE INDEX idx_domain_history_type ON domain_history(snapshot_type);
-      CREATE INDEX idx_domain_history_created ON domain_history(created_at);
-      CREATE INDEX idx_domain_history_email ON domain_history(registrant_email);
-    `
-  },
-  {
-    id: 5,
-    name: "domain_reputation_tracking",
-    sql: `
-      CREATE TABLE IF NOT EXISTS domain_reputation (
-        id TEXT PRIMARY KEY,
-        domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-        is_blacklisted INTEGER NOT NULL DEFAULT 0,
-        blacklist_sources TEXT NOT NULL DEFAULT '[]',
-        threat_score INTEGER,
-        spam_score INTEGER,
-        malware_detected INTEGER NOT NULL DEFAULT 0,
-        phishing_detected INTEGER NOT NULL DEFAULT 0,
-        reputation_sources TEXT NOT NULL DEFAULT '[]',
-        last_checked_at TEXT,
-        notes TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE INDEX idx_domain_reputation_domain ON domain_reputation(domain_id);
-      CREATE INDEX idx_domain_reputation_blacklisted ON domain_reputation(is_blacklisted);
-    `
-  }
-];
-
-// src/db/database.ts
-var _db = null;
-function getDbPath() {
-  if (process.env["DOMAINS_DB_PATH"])
-    return process.env["DOMAINS_DB_PATH"];
-  if (process.env["HASNA_DOMAINS_DB_PATH"])
-    return process.env["HASNA_DOMAINS_DB_PATH"];
-  const explicit = process.env["DOMAINS_DIR"] ?? process.env["HASNA_DOMAINS_DIR"];
-  if (explicit) {
-    return join(explicit, "domains.db");
-  }
-  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir();
-  const legacyDir = join(home, ".hasna", "domains");
-  if (existsSync(legacyDir))
-    return join(legacyDir, "domains.db");
-  const xdgData = process.env["XDG_DATA_HOME"] || join(home, ".local", "share");
-  const newDir = join(xdgData, "open-domains");
-  migrateDotfile("domains", newDir);
-  return join(newDir, "domains.db");
-}
-function migrateDotfile(name, newDir) {
-  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir();
-  const oldDir = join(home, `.${name}`);
-  if (!existsSync(oldDir) || existsSync(newDir))
-    return;
-  mkdirSync(newDir, { recursive: true });
-  for (const file of readdirSync(oldDir)) {
-    const oldPath = join(oldDir, file);
-    if (statSync(oldPath).isFile())
-      copyFileSync(oldPath, join(newDir, file));
-  }
-}
-function getDatabase() {
-  if (_db)
-    return _db;
-  const dbPath = getDbPath();
-  if (dbPath !== ":memory:") {
-    const dir = dirname(resolve(dbPath));
-    mkdirSync(dir, { recursive: true });
-  }
-  _db = new Database(dbPath);
-  _db.exec("PRAGMA journal_mode = WAL");
-  _db.exec("PRAGMA foreign_keys = ON");
-  _db.exec(`
-    CREATE TABLE IF NOT EXISTS _migrations (
-      id INTEGER PRIMARY KEY,
-      name TEXT NOT NULL,
-      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
-    )
-  `);
-  const applied = _db.query("SELECT id FROM _migrations ORDER BY id").all();
-  const appliedIds = new Set(applied.map((r) => r.id));
-  for (const migration of MIGRATIONS) {
-    if (appliedIds.has(migration.id))
-      continue;
-    _db.exec("BEGIN");
-    try {
-      _db.exec(migration.sql);
-      _db.prepare("INSERT INTO _migrations (id, name) VALUES (?, ?)").run(migration.id, migration.name);
-      _db.exec("COMMIT");
-    } catch (error) {
-      _db.exec("ROLLBACK");
-      throw new Error(`Migration ${migration.id} (${migration.name}) failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  return _db;
-}
-function closeDatabase() {
-  if (_db) {
-    _db.close();
-    _db = null;
-  }
-}
-
-// src/db/storage-sync.ts
-var STORAGE_TABLES = [
-  "domains",
-  "dns_records",
-  "alerts",
-  "domain_offers",
-  "domain_emails",
-  "domain_owners",
-  "domain_history",
-  "domain_reputation"
-];
-var DOMAINS_STORAGE_TABLES = STORAGE_TABLES;
-var PRIMARY_KEYS = {
-  domains: ["id"],
-  dns_records: ["id"],
-  alerts: ["id"],
-  domain_offers: ["id"],
-  domain_emails: ["id"],
-  domain_owners: ["id"],
-  domain_history: ["id"],
-  domain_reputation: ["id"]
-};
-var DOMAINS_STORAGE_ENV = "DOMAINS_DATABASE_URL";
-var DOMAINS_STORAGE_FALLBACK_ENV = "HASNA_DOMAINS_DATABASE_URL";
-var DOMAINS_STORAGE_MODE_ENV = "DOMAINS_STORAGE_MODE";
-var DOMAINS_STORAGE_MODE_FALLBACK_ENV = "HASNA_DOMAINS_STORAGE_MODE";
-var STORAGE_DATABASE_ENV = [DOMAINS_STORAGE_ENV, DOMAINS_STORAGE_FALLBACK_ENV];
-var STORAGE_MODE_ENV = [DOMAINS_STORAGE_MODE_ENV, DOMAINS_STORAGE_MODE_FALLBACK_ENV];
-function firstEnv(names) {
-  for (const name of names) {
-    const value = process.env[name];
-    if (value)
-      return value;
-  }
-  return null;
-}
-function normalizeStorageMode(value) {
-  if (!value)
-    return null;
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "local" || normalized === "remote" || normalized === "hybrid")
-    return normalized;
-  return null;
-}
-function getStorageDatabaseUrl() {
-  return firstEnv(STORAGE_DATABASE_ENV);
-}
-function getStorageDatabaseEnvName() {
-  for (const name of STORAGE_DATABASE_ENV) {
-    if (process.env[name])
-      return name;
-  }
-  return null;
-}
-function getStorageMode() {
-  return normalizeStorageMode(firstEnv(STORAGE_MODE_ENV)) ?? (getStorageDatabaseUrl() ? "remote" : "local");
-}
-async function getStoragePg() {
-  const url = getStorageDatabaseUrl();
-  if (!url) {
-    throw new Error("Missing DOMAINS_DATABASE_URL or HASNA_DOMAINS_DATABASE_URL");
-  }
-  return new PgAdapterAsync(url);
-}
-async function runStorageMigrations(remote) {
-  for (const sql of PG_MIGRATIONS)
-    await remote.run(sql);
-}
-async function storagePush(options) {
-  const remote = await getStoragePg();
-  const db = getDatabase();
-  try {
-    await runStorageMigrations(remote);
-    const results = [];
-    for (const table of resolveTables(options?.tables))
-      results.push(await pushTable(db, remote, table));
-    recordSyncMeta(db, "push", results);
-    return results;
-  } finally {
-    await remote.close();
-  }
-}
-async function storagePull(options) {
-  const remote = await getStoragePg();
-  const db = getDatabase();
-  try {
-    await runStorageMigrations(remote);
-    const results = [];
-    for (const table of resolveTables(options?.tables))
-      results.push(await pullTable(remote, db, table));
-    recordSyncMeta(db, "pull", results);
-    return results;
-  } finally {
-    await remote.close();
-  }
-}
-async function storageSync(options) {
-  const pull = await storagePull(options);
-  const push = await storagePush(options);
-  return { pull, push };
-}
-function getStorageSyncMetaAll() {
-  const db = getDatabase();
-  ensureSyncMetaTable(db);
-  return db.query("SELECT table_name, last_synced_at, direction FROM _domains_sync_meta ORDER BY table_name, direction").all();
-}
-function getStorageStatus() {
-  return {
-    configured: Boolean(getStorageDatabaseUrl()),
-    env: STORAGE_DATABASE_ENV,
-    mode: getStorageMode(),
-    service: "domains",
-    tables: STORAGE_TABLES,
-    sync: getStorageSyncMetaAll()
-  };
-}
-function getSyncMetaAll() {
-  return getStorageSyncMetaAll();
-}
-function resolveTables(tables) {
-  if (!tables || tables.length === 0)
-    return [...STORAGE_TABLES];
-  const allowed = new Set(STORAGE_TABLES);
-  const requested = tables.map((table) => table.trim()).filter(Boolean);
-  const invalid = requested.filter((table) => !allowed.has(table));
-  if (invalid.length > 0)
-    throw new Error(`Unknown domains sync table(s): ${invalid.join(", ")}`);
-  return requested;
-}
-async function pushTable(db, remote, table) {
-  const result = { table, rowsRead: 0, rowsWritten: 0, errors: [] };
-  try {
-    if (!sqliteTableExists(db, table))
-      return result;
-    const rows = db.query(`SELECT * FROM ${quoteIdent(table)}`).all();
-    result.rowsRead = rows.length;
-    if (rows.length === 0)
-      return result;
-    const remoteColumns = await getRemoteColumns(remote, table);
-    const columns = filterRemoteColumns(remoteColumns, Object.keys(rows[0]));
-    result.rowsWritten = await upsertPg(remote, table, columns, rows, remoteColumns);
-  } catch (error) {
-    result.errors.push(error instanceof Error ? error.message : String(error));
-  }
-  return result;
-}
-async function pullTable(remote, db, table) {
-  const result = { table, rowsRead: 0, rowsWritten: 0, errors: [] };
-  try {
-    if (!sqliteTableExists(db, table))
-      return result;
-    const rows = await remote.all(`SELECT * FROM ${quoteIdent(table)}`);
-    result.rowsRead = rows.length;
-    if (rows.length === 0)
-      return result;
-    const columns = filterLocalColumns(db, table, Object.keys(rows[0]));
-    result.rowsWritten = upsertSqlite(db, table, columns, rows);
-  } catch (error) {
-    result.errors.push(error instanceof Error ? error.message : String(error));
-  }
-  return result;
-}
-async function getRemoteColumns(remote, table) {
-  const rows = await remote.all("SELECT column_name, data_type FROM information_schema.columns WHERE table_schema = 'public' AND table_name = ?", table);
-  return new Map(rows.map((row) => [row.column_name, row.data_type]));
-}
-function filterRemoteColumns(remoteColumns, columns) {
-  if (remoteColumns.size === 0)
-    return columns;
-  return columns.filter((column) => remoteColumns.has(column));
-}
-function filterLocalColumns(db, table, columns) {
-  const rows = db.query(`PRAGMA table_info(${quoteIdent(table)})`).all();
-  const allowed = new Set(rows.map((row) => row.name));
-  return columns.filter((column) => allowed.has(column));
-}
-async function upsertPg(remote, table, columns, rows, remoteColumns) {
-  if (columns.length === 0)
-    return 0;
-  const primaryKeys = PRIMARY_KEYS[table];
-  const columnList = columns.map(quoteIdent).join(", ");
-  const placeholders = columns.map(() => "?").join(", ");
-  const keyList = primaryKeys.map(quoteIdent).join(", ");
-  const updateColumns = columns.filter((column) => !primaryKeys.includes(column));
-  const fallbackKey = primaryKeys[0];
-  const setClause = updateColumns.length > 0 ? updateColumns.map((column) => `${quoteIdent(column)} = EXCLUDED.${quoteIdent(column)}`).join(", ") : `${quoteIdent(fallbackKey)} = EXCLUDED.${quoteIdent(fallbackKey)}`;
-  for (const row of rows) {
-    await remote.run(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders}) ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}`, ...columns.map((column) => coerceForPg(row[column], remoteColumns.get(column))));
-  }
-  return rows.length;
-}
-function upsertSqlite(db, table, columns, rows) {
-  if (columns.length === 0)
-    return 0;
-  const primaryKeys = PRIMARY_KEYS[table];
-  const columnList = columns.map(quoteIdent).join(", ");
-  const placeholders = columns.map(() => "?").join(", ");
-  const keyList = primaryKeys.map(quoteIdent).join(", ");
-  const updateColumns = columns.filter((column) => !primaryKeys.includes(column));
-  const fallbackKey = primaryKeys[0];
-  const setClause = updateColumns.length > 0 ? updateColumns.map((column) => `${quoteIdent(column)} = excluded.${quoteIdent(column)}`).join(", ") : `${quoteIdent(fallbackKey)} = excluded.${quoteIdent(fallbackKey)}`;
-  const statement = db.prepare(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders}) ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}`);
-  for (const row of rows)
-    statement.run(...columns.map((column) => coerceForSqlite(row[column])));
-  return rows.length;
-}
-function recordSyncMeta(db, direction, results) {
-  ensureSyncMetaTable(db);
-  const timestamp = new Date().toISOString();
-  const statement = db.prepare("INSERT INTO _domains_sync_meta (table_name, last_synced_at, direction) VALUES (?, ?, ?) ON CONFLICT(table_name, direction) DO UPDATE SET last_synced_at = excluded.last_synced_at");
-  for (const result of results) {
-    if (result.errors.length > 0)
-      continue;
-    statement.run(result.table, timestamp, direction);
-  }
-}
-function ensureSyncMetaTable(db) {
-  db.exec("CREATE TABLE IF NOT EXISTS _domains_sync_meta (table_name TEXT NOT NULL, last_synced_at TEXT, direction TEXT NOT NULL CHECK(direction IN ('push', 'pull')), PRIMARY KEY (table_name, direction))");
-}
-function sqliteTableExists(db, table) {
-  return Boolean(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(table));
-}
-function quoteIdent(identifier) {
-  return `"${identifier.replace(/"/g, '""')}"`;
-}
-function coerceForPg(value, dataType) {
-  if (value === undefined || value === null)
-    return null;
-  if (dataType === "boolean") {
-    if (typeof value === "boolean")
-      return value;
-    if (typeof value === "number")
-      return value !== 0;
-    if (typeof value === "string")
-      return value === "1" || value.toLowerCase() === "true";
-  }
-  if (value instanceof Date)
-    return value.toISOString();
-  if (Buffer.isBuffer(value) || value instanceof Uint8Array)
-    return value;
-  if (typeof value === "object")
-    return JSON.stringify(value);
-  return value;
-}
-function coerceForSqlite(value) {
-  if (value === undefined || value === null)
-    return null;
-  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean")
-    return value;
-  if (value instanceof Date)
-    return value.toISOString();
-  if (Buffer.isBuffer(value) || value instanceof Uint8Array)
-    return value;
-  if (typeof value === "object")
-    return JSON.stringify(value);
-  return String(value);
-}
-export {
-  storageSync,
-  storagePush,
-  storagePull,
-  runStorageMigrations,
-  resolveTables,
-  getSyncMetaAll,
-  getStorageSyncMetaAll,
-  getStorageStatus,
-  getStoragePg,
-  getStorageMode,
-  getStorageDatabaseUrl,
-  getStorageDatabaseEnvName,
-  STORAGE_TABLES,
-  STORAGE_MODE_ENV,
-  STORAGE_DATABASE_ENV,
-  PgAdapterAsync,
-  PG_MIGRATIONS,
-  DOMAINS_STORAGE_TABLES,
-  DOMAINS_STORAGE_MODE_FALLBACK_ENV,
-  DOMAINS_STORAGE_MODE_ENV,
-  DOMAINS_STORAGE_FALLBACK_ENV,
-  DOMAINS_STORAGE_ENV
-};