@promptowl/contextnest-community 1.8.0 → 1.10.0

package/dist/{chunk-PLAHCDQG.js → chunk-BC6KFUZH.js}

@@ -2,6 +2,11 @@ import {
   ANON_USER_ID
 } from "./chunk-SLTQACJW.js";
 
+// src/db/client.ts
+import Database from "better-sqlite3";
+import { mkdirSync, readFileSync } from "fs";
+import { dirname as dirname2 } from "path";
+
 // src/config.ts
 import { join, dirname } from "path";
 import { existsSync } from "fs";
@@ -21,6 +26,14 @@ if (envFileLoaded && !isTestRun) {
 var canonicalEnvFile = process.env.ENV_FILE_PATH || join(dataRoot(), ".env");
 var canonicalEnvLoaded = null;
 var slackUrlWarned = false;
+var emailFromWarned = false;
+var emailToWarned = false;
+function isEmailish(v) {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v) && !/[\r\n]/.test(v);
+}
+function isEmailListish(v) {
+  return v.split(",").every((e) => isEmailish(e.trim()));
+}
 if (!isTestRun && canonicalEnvFile !== envFileLoaded && existsSync(canonicalEnvFile)) {
   dotenv.config({ path: canonicalEnvFile, override: true });
   canonicalEnvLoaded = canonicalEnvFile;
@@ -111,6 +124,18 @@ var config = {
   get PROMPTOWL_KEY() {
     return process.env.PROMPTOWL_KEY || "";
   },
+  /** Vercel automation-bypass secret for PO calls; unset = no bypass. */
+  get PROMPTOWL_BYPASS_SECRET() {
+    return process.env.PROMPTOWL_BYPASS_SECRET || "";
+  },
+  /** Outbound headers for PO fetches; bypass header only when secret set. */
+  get PROMPTOWL_FETCH_HEADERS() {
+    const h = { "Content-Type": "application/json" };
+    if (this.PROMPTOWL_BYPASS_SECRET) {
+      h["x-vercel-protection-bypass"] = this.PROMPTOWL_BYPASS_SECRET;
+    }
+    return h;
+  },
   /**
    * Shared secret for one-click SSO auto-login from PromptOwl (PO).
    *
@@ -151,6 +176,24 @@ var config = {
     const v = (process.env.PROMPTOWL_SIGN_IN_GATE || "open").trim().toLowerCase();
     return v === "admin-only" || v === "disabled" ? v : "open";
   },
+  /**
+   * Manual (email + password) sign-in. Three modes, independent of
+   * `PROMPTOWL_SIGN_IN_GATE` (the two methods are controlled separately):
+   *   "open"        — anyone may log in and self-register (default).
+   *   "invite-only" — existing + admin-invited users may log in and an invited
+   *                   placeholder may set its password ("claim"), but brand-new
+   *                   self-registration is refused. Use this when the admin
+   *                   provisions accounts (invite / share / steward) and users
+   *                   shouldn't be able to create their own.
+   *   "disabled"    — no email/password sign-in at all (PromptOwl only).
+   * Enforced at POST /auth/login and POST /auth/register. The /admin/settings
+   * validator refuses "disabled" while PromptOwl is also disabled, so a server
+   * can never be left with no way to sign in.
+   */
+  get MANUAL_SIGN_IN() {
+    const v = (process.env.MANUAL_SIGN_IN || "open").trim().toLowerCase();
+    return v === "invite-only" || v === "disabled" ? v : "open";
+  },
   /**
    * Path to the .env file the server reads its config from and the license
    * install flow persists PROMPTOWL_KEY into. Defaults UNDER DATA_ROOT (not
@@ -168,6 +211,18 @@ var config = {
   get TELEMETRY_INTERVAL_MS() {
     return parseInt(process.env.TELEMETRY_INTERVAL_MS || "3600000", 10);
   },
+  /**
+   * Activity-trace retention window in days (the api_events table behind
+   * GET /admin/trace and GET /nests/:id/trace). 0 = keep forever (pruning is
+   * skipped entirely). Invalid / negative → default 14; capped at 3650 (ten
+   * years) so a typo can't schedule a prune cutoff in the distant past.
+   * Editable at runtime from the admin Settings page (/admin/settings).
+   */
+  get TRACE_RETENTION_DAYS() {
+    const n = parseInt(process.env.TRACE_RETENTION_DAYS || "14", 10);
+    if (!Number.isFinite(n) || n < 0) return 14;
+    return Math.min(n, 3650);
+  },
   /**
    * Optional custom logo URL shown in UI header + login screen.
    * Must be an absolute https://, http://, or data:image/… URL. Other
@@ -187,14 +242,17 @@ var config = {
     }
     return raw;
   },
-  get AUTH_MODE() {
-    return process.env.AUTH_MODE || "key";
-  },
+  /**
+   * Workflow plane ("turing" track): typed edges, edge-type registry, runs.
+   * OFF by default — an optional feature an admin turns on (env or Settings).
+   * This flag is also the future license-tier hook: gating a paid tier here
+   * is a one-line change because every plane route checks it per request.
+   */
   /**
    * Optional Slack incoming-webhook URL for team notifications (review
-   * submitted/approved/rejected, nest shared). Empty/unset = connector off.
-   * https only — a webhook carries an implicit secret in its path, so it
-   * never travels plaintext.
+   * submitted/approved/rejected). Empty/unset = connector off. https only —
+   * a webhook carries an implicit secret in its path, so it never travels
+   * plaintext. (Ported from development PR #105.)
    */
   get SLACK_WEBHOOK_URL() {
     const raw = process.env.SLACK_WEBHOOK_URL?.trim();
@@ -210,6 +268,114 @@ var config = {
     }
     return raw;
   },
+  get FEATURE_WORKFLOW_PLANE() {
+    return process.env.FEATURE_WORKFLOW_PLANE === "true";
+  },
+  /**
+   * Sub-agent runs: lets a run spawn nested runs (an external runner calling
+   * back into POST /run for a child agent). Gated SEPARATELY from the base
+   * plane because recursion is the risky surface — unbounded fan-out,
+   * re-entrancy, resource exhaustion. Off by default; must clear a security
+   * review before an operator turns it on. Requires FEATURE_WORKFLOW_PLANE too.
+   */
+  get FEATURE_SUBAGENT_RUNS() {
+    return process.env.FEATURE_SUBAGENT_RUNS === "true";
+  },
+  /** Hard ceiling on sub-agent nesting depth — keeps the call tree finite
+   *  (haltable / statically bounded). Clamped to [1, 32]. */
+  get SUBAGENT_MAX_DEPTH() {
+    const n = parseInt(process.env.SUBAGENT_MAX_DEPTH || "8", 10);
+    return Number.isFinite(n) ? Math.min(32, Math.max(1, n)) : 8;
+  },
+  /** Max direct children a single run may spawn. Depth bounds the tree's
+   *  height; this bounds its width — together they cap total size so a
+   *  runner can't fork-bomb the DB. Clamped to [1, 128]. */
+  get SUBAGENT_MAX_CHILDREN() {
+    const n = parseInt(process.env.SUBAGENT_MAX_CHILDREN || "16", 10);
+    return Number.isFinite(n) ? Math.min(128, Math.max(1, n)) : 16;
+  },
+  /** Max steps a single run may accumulate — bounds a runaway/hostile
+   *  runner's step log. Clamped to [10, 100000]. */
+  get RUN_MAX_STEPS() {
+    const n = parseInt(process.env.RUN_MAX_STEPS || "10000", 10);
+    return Number.isFinite(n) ? Math.min(1e5, Math.max(10, n)) : 1e4;
+  },
+  /** Max concurrently-RUNNING root (depth-0) runs per nest. The subagent
+   *  depth/fan-out caps bound a single tree; this bounds how many trees a
+   *  caller can start at once, so root triggers can't flood the nest. */
+  get RUN_MAX_CONCURRENT_ROOTS() {
+    const n = parseInt(process.env.RUN_MAX_CONCURRENT_ROOTS || "50", 10);
+    return Number.isFinite(n) ? Math.min(1e3, Math.max(1, n)) : 50;
+  },
+  get AUTH_MODE() {
+    return process.env.AUTH_MODE || "key";
+  },
+  /**
+   * Optional SMTP connection URL for email notifications, e.g.
+   * smtps://user:pass@smtp.example.com:465. smtp:// or smtps:// only.
+   * Empty/unset = email connector off. Requires NOTIFY_EMAIL_FROM/_TO.
+   */
+  get SMTP_URL() {
+    const raw = process.env.SMTP_URL?.trim();
+    if (!raw) return null;
+    if (!/^smtps?:\/\//i.test(raw)) {
+      console.warn(
+        "[config] SMTP_URL rejected: must be an smtp:// or smtps:// URL. Email notifications disabled."
+      );
+      return null;
+    }
+    return raw;
+  },
+  /**
+   * From address for notification emails. Shape-validated here (not only in
+   * the /admin/settings PATCH) so a value set directly via env/Docker can't
+   * reach nodemailer's envelope unchecked. Invalid = connector off.
+   */
+  get NOTIFY_EMAIL_FROM() {
+    const raw = process.env.NOTIFY_EMAIL_FROM?.trim();
+    if (!raw) return null;
+    if (!isEmailish(raw)) {
+      if (!emailFromWarned) {
+        emailFromWarned = true;
+        console.warn(
+          "[config] NOTIFY_EMAIL_FROM rejected: must be a plain email address. Email notifications disabled."
+        );
+      }
+      return null;
+    }
+    return raw;
+  },
+  /**
+   * Comma-separated recipient list for notification emails. Shape-validated
+   * here for the same env-bypass reason as NOTIFY_EMAIL_FROM. Invalid (any
+   * entry malformed) = connector off.
+   */
+  get NOTIFY_EMAIL_TO() {
+    const raw = process.env.NOTIFY_EMAIL_TO?.trim();
+    if (!raw) return null;
+    if (!isEmailListish(raw)) {
+      if (!emailToWarned) {
+        emailToWarned = true;
+        console.warn(
+          "[config] NOTIFY_EMAIL_TO rejected: must be a comma-separated list of email addresses. Email notifications disabled."
+        );
+      }
+      return null;
+    }
+    return raw;
+  },
+  /**
+   * Per-nest notification digest window in milliseconds. A burst of governance
+   * events on one nest inside this window collapses into a single digest
+   * message instead of one post per event. Empty / non-numeric / negative /
+   * unset → 15000 (15s).
+   */
+  get NOTIFY_DEBOUNCE_MS() {
+    const raw = process.env.NOTIFY_DEBOUNCE_MS?.trim();
+    if (!raw) return 15e3;
+    const n = Number(raw);
+    return Number.isFinite(n) && n >= 0 ? n : 15e3;
+  },
   /**
    * CORS origin allowlist. Comma-separated list of origins or "*".
    * Defaults to "*" in open mode (read-heavy, no credentials to steal)
@@ -231,11 +397,6 @@ var config = {
   }
 };
 
-// src/db/client.ts
-import Database from "better-sqlite3";
-import { mkdirSync, readFileSync } from "fs";
-import { dirname as dirname2 } from "path";
-
 // src/db/migrations.ts
 function runMigrations(db) {
   db.exec(`
@@ -802,6 +963,27 @@ function runMigrations(db) {
     })();
     recordMigration("012_merge_case_colliding_users");
   }
+  if (!hasMigration("019_grants")) {
+    db.transaction(() => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS grants (
+          id TEXT PRIMARY KEY,
+          nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
+          target_type TEXT NOT NULL CHECK(target_type IN ('document', 'folder')),
+          target TEXT NOT NULL,        -- node id (document) or path prefix (folder)
+          user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+          role TEXT NOT NULL CHECK(role IN ('read', 'write')),
+          granted_by TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_grants_unique
+          ON grants(nest_id, target_type, target, user_id);
+        CREATE INDEX IF NOT EXISTS idx_grants_user ON grants(nest_id, user_id);
+      `);
+    })();
+    recordMigration("019_grants");
+  }
   if (!hasMigration("013_node_deletion_tombstones")) {
     db.transaction(() => {
       db.exec(`
@@ -839,6 +1021,246 @@ function runMigrations(db) {
     })();
     recordMigration("014_api_events");
   }
+  if (!hasMigration("015_definitions")) {
+    db.transaction(() => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS definitions (
+          id TEXT PRIMARY KEY,
+          nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
+          term TEXT NOT NULL,
+          definition TEXT NOT NULL,
+          linked_tag TEXT,               -- optional #tag this term maps to
+          defined_by TEXT NOT NULL,      -- email
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_definitions_term
+          ON definitions(nest_id, term COLLATE NOCASE);
+      `);
+    })();
+    recordMigration("015_definitions");
+  }
+  if (!hasMigration("016_workflow_edges")) {
+    db.transaction(() => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS edge_types (
+          id TEXT PRIMARY KEY,
+          nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
+          name TEXT NOT NULL,
+          description TEXT NOT NULL,
+          direction TEXT NOT NULL DEFAULT 'directed'
+            CHECK(direction IN ('directed', 'undirected')),
+          is_flow INTEGER NOT NULL DEFAULT 0,   -- flow types form the DAG
+          condition_schema TEXT,                -- JSON template | NULL
+          color TEXT,
+          created_by TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_edge_types_name
+          ON edge_types(nest_id, LOWER(name));
+
+        CREATE TABLE IF NOT EXISTS edges (
+          id TEXT PRIMARY KEY,
+          nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
+          from_node TEXT NOT NULL,
+          to_node TEXT NOT NULL,
+          -- RESTRICT (not CASCADE): the app refuses to delete an edge type
+          -- while edges reference it; the DB backs that invariant instead of
+          -- silently cascade-deleting live edges if the app check is bypassed.
+          type_id TEXT NOT NULL REFERENCES edge_types(id) ON DELETE RESTRICT,
+          condition_mode TEXT
+            CHECK(condition_mode IN ('structured', 'nl', 'open')),
+          condition TEXT,
+          metadata TEXT,
+          created_by TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(nest_id, from_node);
+        CREATE INDEX IF NOT EXISTS idx_edges_to   ON edges(nest_id, to_node);
+        CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(nest_id, type_id);
+      `);
+    })();
+    recordMigration("016_workflow_edges");
+  }
+  if (!hasMigration("017_workflow_runs")) {
+    db.transaction(() => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS runs (
+          id TEXT PRIMARY KEY,
+          nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
+          agent_node TEXT NOT NULL,
+          triggered_by TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'running'
+            CHECK(status IN ('running', 'succeeded', 'failed', 'cancelled')),
+          inputs TEXT,
+          trace TEXT,
+          started_at TEXT NOT NULL,
+          finished_at TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_runs_nest ON runs(nest_id, started_at);
+        CREATE INDEX IF NOT EXISTS idx_runs_agent ON runs(nest_id, agent_node);
+
+        CREATE TABLE IF NOT EXISTS run_steps (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+          seq INTEGER NOT NULL,
+          node_id TEXT,
+          edge_id TEXT,
+          action TEXT NOT NULL,
+          detail TEXT,
+          at TEXT NOT NULL
+        );
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_run_steps ON run_steps(run_id, seq);
+      `);
+    })();
+    recordMigration("017_workflow_runs");
+  }
+  if (!hasMigration("018_subagent_runs")) {
+    db.transaction(() => {
+      db.exec(`
+        ALTER TABLE runs ADD COLUMN parent_run_id TEXT;
+        ALTER TABLE runs ADD COLUMN depth INTEGER NOT NULL DEFAULT 0;
+        CREATE INDEX IF NOT EXISTS idx_runs_parent ON runs(parent_run_id);
+      `);
+    })();
+    recordMigration("018_subagent_runs");
+  }
+  if (!hasMigration("020_server_settings")) {
+    db.transaction(() => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS server_settings (
+          key TEXT PRIMARY KEY,
+          value TEXT,
+          env_at_write TEXT,
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+      `);
+      recordMigration("020_server_settings");
+    })();
+  }
+  if (!hasMigration("020_schedules")) {
+    db.transaction(() => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS schedules (
+          id TEXT PRIMARY KEY,
+          nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
+          agent_node TEXT NOT NULL,
+          every_minutes INTEGER NOT NULL CHECK(every_minutes >= 5),
+          enabled INTEGER NOT NULL DEFAULT 1,
+          last_run_at TEXT,
+          created_by TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_schedules_agent
+          ON schedules(nest_id, agent_node);
+      `);
+    })();
+    recordMigration("020_schedules");
+  }
+  if (!hasMigration("021_schedule_bounds")) {
+    db.transaction(() => {
+      db.exec(`
+        ALTER TABLE schedules ADD COLUMN max_runs INTEGER;
+        ALTER TABLE schedules ADD COLUMN runs_created INTEGER NOT NULL DEFAULT 0;
+      `);
+    })();
+    recordMigration("021_schedule_bounds");
+  }
+  if (!hasMigration("022_tools_and_watchers")) {
+    db.transaction(() => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS nest_env (
+          nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
+          key TEXT NOT NULL,
+          value TEXT NOT NULL,
+          updated_by TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          PRIMARY KEY (nest_id, key)
+        );
+        CREATE TABLE IF NOT EXISTS watchers (
+          id TEXT PRIMARY KEY,
+          nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
+          node_id TEXT NOT NULL,
+          user_email TEXT NOT NULL,
+          created_by TEXT NOT NULL,
+          created_at TEXT NOT NULL
+        );
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_watchers_unique
+          ON watchers(nest_id, node_id, user_email);
+        CREATE TABLE IF NOT EXISTS notifications (
+          id TEXT PRIMARY KEY,
+          nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
+          user_email TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          subject_id TEXT,
+          message TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          read_at TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_notifications_user
+          ON notifications(user_email, read_at, created_at);
+      `);
+    })();
+    recordMigration("022_tools_and_watchers");
+  }
+  if (!hasMigration("023_connectors")) {
+    db.transaction(() => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS connectors (
+          id TEXT PRIMARY KEY,
+          nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
+          channel TEXT NOT NULL CHECK(channel IN ('slack', 'teams', 'webhook')),
+          url TEXT NOT NULL,               -- https://\u2026 or env:KEY
+          events TEXT NOT NULL,            -- JSON array of kinds, or ["*"]
+          enabled INTEGER NOT NULL DEFAULT 1,
+          created_by TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_connectors_nest ON connectors(nest_id);
+      `);
+    })();
+    recordMigration("023_connectors");
+  }
+  if (!hasMigration("024_trigger_hooks")) {
+    db.transaction(() => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS trigger_hooks (
+          id TEXT PRIMARY KEY,               -- the token (hk_\u2026), capability auth
+          nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
+          agent_node TEXT NOT NULL,
+          preset TEXT NOT NULL CHECK(preset IN ('slack', 'teams', 'webhook')),
+          enabled INTEGER NOT NULL DEFAULT 1,
+          fire_count INTEGER NOT NULL DEFAULT 0,
+          last_fired_at TEXT,
+          created_by TEXT NOT NULL,
+          created_at TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_hooks_nest ON trigger_hooks(nest_id);
+      `);
+    })();
+    recordMigration("024_trigger_hooks");
+  }
+  if (!hasMigration("025_run_claims")) {
+    db.transaction(() => {
+      db.exec(`
+        ALTER TABLE runs ADD COLUMN claimed_by TEXT;
+        ALTER TABLE runs ADD COLUMN claimed_at TEXT;
+      `);
+    })();
+    recordMigration("025_run_claims");
+  }
+  if (!hasMigration("026_api_events_nest_index")) {
+    db.transaction(() => {
+      db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_api_events_nest_ts ON api_events(nest_id, id);
+      `);
+    })();
+    recordMigration("026_api_events_nest_index");
+  }
 }
 function mergeCaseCollidingUsers(db) {
   const groups = db.prepare(
@@ -1056,7 +1478,7 @@ async function initDb() {
   if (config.DB_DRIVER === "postgres") {
     const { Pool } = await import("pg");
     const { PostgresAdapter } = await import("./adapter.postgres-YOODX2BI.js");
-    const { runPostgresMigrations } = await import("./migrations.postgres-VCG45LMK.js");
+    const { runPostgresMigrations } = await import("./migrations.postgres-4XYY3CTF.js");
     const pool = new Pool(buildPgConfig());
     adapter = new PostgresAdapter(pool);
     await runPostgresMigrations(adapter);
@@ -1076,23 +1498,18 @@ function getDb() {
   }
   return adapter;
 }
-
-// src/db/sql.ts
-function nowExpr(db) {
-  return db.dialect === "sqlite" ? "datetime('now')" : "to_char((now() AT TIME ZONE 'utc'), 'YYYY-MM-DD HH24:MI:SS')";
-}
-function insertOrIgnore(db, insertSql) {
-  return db.dialect === "sqlite" ? insertSql.replace(/^\s*INSERT\s+INTO/i, "INSERT OR IGNORE INTO") : `${insertSql} ON CONFLICT DO NOTHING`;
-}
-function insertOrReplace(db, insertSql, conflictCols, set) {
-  return db.dialect === "sqlite" ? insertSql.replace(/^\s*INSERT\s+INTO/i, "INSERT OR REPLACE INTO") : `${insertSql} ON CONFLICT (${conflictCols.join(", ")}) DO UPDATE SET ${set}`;
+async function resetDb() {
+  if (adapter) {
+    await adapter.close();
+    adapter = null;
+  }
 }
 
 export {
+  isEmailish,
+  isEmailListish,
   config,
   initDb,
   getDb,
-  nowExpr,
-  insertOrIgnore,
-  insertOrReplace
+  resetDb
 };

package/dist/chunk-FRQJWGN3.js

@@ -0,0 +1,8 @@
+// src/shared/email.ts
+function normalizeEmail(email) {
+  return email.trim().toLowerCase();
+}
+
+export {
+  normalizeEmail
+};