@promptowl/contextnest-community 1.5.0 → 1.6.0

package/dist/{chunk-RMU3LOPH.js → chunk-7V33Z6CS.js}

@@ -1,3 +1,7 @@
+import {
+  ANON_USER_ID
+} from "./chunk-SLTQACJW.js";
+
 // src/config.ts
 import { join, dirname } from "path";
 import { existsSync } from "fs";
@@ -38,6 +42,68 @@ var config = {
   get DATABASE_PATH() {
     return process.env.DATABASE_PATH || join(dataRoot(), "community.db");
   },
+  /**
+   * Root directory for nest vault files. Defaults to `<DATA_ROOT>/nests`.
+   * Override (e.g. a GCS volume mount on Cloud Run) to store nest files
+   * separately from the SQLite DB. See `src/shared/paths.ts`.
+   */
+  get NEST_STORAGE_ROOT() {
+    return process.env.NEST_STORAGE_ROOT || join(dataRoot(), "nests");
+  },
+  /**
+   * Which database backend to use.
+   *   "sqlite"   — default; the on-disk file at DATABASE_PATH (existing behaviour).
+   *   "postgres" — Cloud SQL / PostgreSQL, for durable Cloud Run deployments.
+   * Explicit DB_DRIVER wins; otherwise we infer "postgres" when a connection
+   * is configured (DATABASE_URL or CLOUD_SQL_CONNECTION_NAME), else "sqlite".
+   * So existing deployments with no new env vars keep using SQLite untouched.
+   */
+  get DB_DRIVER() {
+    const v = (process.env.DB_DRIVER || "").trim().toLowerCase();
+    if (v === "postgres" || v === "postgresql" || v === "pg") return "postgres";
+    if (v === "sqlite") return "sqlite";
+    return process.env.DATABASE_URL || process.env.CLOUD_SQL_CONNECTION_NAME ? "postgres" : "sqlite";
+  },
+  /** Postgres connection string, e.g. postgres://user:pass@host:5432/db (TCP). */
+  get DATABASE_URL() {
+    return process.env.DATABASE_URL || "";
+  },
+  /**
+   * Cloud SQL instance connection name (project:region:instance). When set,
+   * the server connects over the unix socket at /cloudsql/<name> created by
+   * the Cloud SQL Auth Proxy (the recommended Cloud Run setup). Combine with
+   * DB_USER / DB_PASSWORD / DB_NAME.
+   */
+  get CLOUD_SQL_CONNECTION_NAME() {
+    return process.env.CLOUD_SQL_CONNECTION_NAME || "";
+  },
+  get DB_HOST() {
+    return process.env.DB_HOST || "";
+  },
+  get DB_PORT() {
+    return parseInt(process.env.DB_PORT || "5432", 10);
+  },
+  get DB_USER() {
+    return process.env.DB_USER || "";
+  },
+  get DB_PASSWORD() {
+    return process.env.DB_PASSWORD || "";
+  },
+  get DB_NAME() {
+    return process.env.DB_NAME || "";
+  },
+  /** Max Postgres pool connections. Keep modest — Cloud SQL tiers cap connections. */
+  get DB_POOL_MAX() {
+    return parseInt(process.env.DB_POOL_MAX || "10", 10);
+  },
+  /** Enable TLS for Postgres TCP connections (not needed over the unix socket). */
+  get DB_SSL() {
+    return process.env.DB_SSL === "true";
+  },
+  /** Optional path to a CA cert (PEM) for verify-ca/verify-full TLS. */
+  get DB_SSL_CA() {
+    return process.env.DB_SSL_CA || "";
+  },
   get PROMPTOWL_API_URL() {
     return process.env.PROMPTOWL_API_URL || "https://app.promptowl.ai";
   },
@@ -146,16 +212,12 @@ var config = {
 
 // src/db/client.ts
 import Database from "better-sqlite3";
-import { mkdirSync } from "fs";
+import { mkdirSync, readFileSync } from "fs";
 import { dirname as dirname2 } from "path";
 
-// src/shared/constants.ts
-var ANON_USER_ID = "00000000-0000-0000-0000-000000000000";
-var ANON_EMAIL = "admin@localhost";
-
 // src/db/migrations.ts
-function runMigrations(db2) {
-  db2.exec(`
+function runMigrations(db) {
+  db.exec(`
     CREATE TABLE IF NOT EXISTS users (
       id TEXT PRIMARY KEY,
       email TEXT UNIQUE NOT NULL,
@@ -249,7 +311,7 @@ function runMigrations(db2) {
       sent INTEGER NOT NULL DEFAULT 0
     );
   `);
-  db2.exec(`
+  db.exec(`
     -- Steward assignments (mirrors PromptOwl ContextSteward model)
     -- scope+target combination determines what the steward governs
     -- Resolution priority: document(1) > tag(2) > nest(3)
@@ -322,47 +384,47 @@ function runMigrations(db2) {
       PRIMARY KEY (nest_id, node_id)
     );
   `);
-  const nestCols = db2.prepare("PRAGMA table_info(nests)").all().map((c) => c.name);
+  const nestCols = db.prepare("PRAGMA table_info(nests)").all().map((c) => c.name);
   if (!nestCols.includes("stewardship_enabled")) {
-    db2.exec("ALTER TABLE nests ADD COLUMN stewardship_enabled INTEGER NOT NULL DEFAULT 0");
+    db.exec("ALTER TABLE nests ADD COLUMN stewardship_enabled INTEGER NOT NULL DEFAULT 0");
   }
   if (!nestCols.includes("is_imported")) {
-    db2.exec("ALTER TABLE nests ADD COLUMN is_imported INTEGER NOT NULL DEFAULT 0");
+    db.exec("ALTER TABLE nests ADD COLUMN is_imported INTEGER NOT NULL DEFAULT 0");
   }
   if (!nestCols.includes("allow_self_approve")) {
-    db2.exec("ALTER TABLE nests ADD COLUMN allow_self_approve INTEGER NOT NULL DEFAULT 0");
+    db.exec("ALTER TABLE nests ADD COLUMN allow_self_approve INTEGER NOT NULL DEFAULT 0");
   }
-  const userCols = db2.prepare("PRAGMA table_info(users)").all().map((c) => c.name);
+  const userCols = db.prepare("PRAGMA table_info(users)").all().map((c) => c.name);
   if (!userCols.includes("is_admin")) {
-    db2.exec("ALTER TABLE users ADD COLUMN is_admin INTEGER NOT NULL DEFAULT 0");
+    db.exec("ALTER TABLE users ADD COLUMN is_admin INTEGER NOT NULL DEFAULT 0");
   }
   if (!userCols.includes("is_invited")) {
-    db2.exec("ALTER TABLE users ADD COLUMN is_invited INTEGER NOT NULL DEFAULT 0");
+    db.exec("ALTER TABLE users ADD COLUMN is_invited INTEGER NOT NULL DEFAULT 0");
   }
-  const stewardCols = db2.prepare("PRAGMA table_info(stewards)").all().map((c) => c.name);
+  const stewardCols = db.prepare("PRAGMA table_info(stewards)").all().map((c) => c.name);
   if (stewardCols.length > 0) {
     if (!stewardCols.includes("can_approve")) {
-      db2.exec(
+      db.exec(
         "ALTER TABLE stewards ADD COLUMN can_approve INTEGER NOT NULL DEFAULT 1"
       );
     }
     if (!stewardCols.includes("can_reject")) {
-      db2.exec(
+      db.exec(
         "ALTER TABLE stewards ADD COLUMN can_reject INTEGER NOT NULL DEFAULT 1"
       );
     }
   }
-  db2.exec(`
+  db.exec(`
     CREATE TABLE IF NOT EXISTS schema_migrations (
       id TEXT PRIMARY KEY,
       applied_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
   `);
-  const hasMigration = (id) => !!db2.prepare("SELECT id FROM schema_migrations WHERE id = ?").get(id);
-  const recordMigration = (id) => db2.prepare("INSERT OR IGNORE INTO schema_migrations (id) VALUES (?)").run(id);
+  const hasMigration = (id) => !!db.prepare("SELECT id FROM schema_migrations WHERE id = ?").get(id);
+  const recordMigration = (id) => db.prepare("INSERT OR IGNORE INTO schema_migrations (id) VALUES (?)").run(id);
   if (!hasMigration("002_steward_parity")) {
-    db2.transaction(() => {
-      db2.exec(`
+    db.transaction(() => {
+      db.exec(`
         CREATE TABLE stewards_new (
           id TEXT PRIMARY KEY,
           nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
@@ -402,7 +464,7 @@ function runMigrations(db2) {
         CREATE INDEX idx_stewards_email ON stewards(user_email);
         CREATE INDEX idx_stewards_scope ON stewards(nest_id, scope);
       `);
-      db2.exec(`
+      db.exec(`
         CREATE UNIQUE INDEX idx_stewards_uniq_nest
           ON stewards(nest_id, user_email)
           WHERE scope = 'nest' AND is_active = 1;
@@ -423,7 +485,7 @@ function runMigrations(db2) {
           ON stewards(nest_id, node_pattern)
           WHERE scope = 'document' AND is_active = 1;
       `);
-      db2.exec(`
+      db.exec(`
         CREATE TABLE IF NOT EXISTS node_tag_index (
           nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
           node_id TEXT NOT NULL,
@@ -433,7 +495,7 @@ function runMigrations(db2) {
         CREATE INDEX IF NOT EXISTS idx_node_tag_by_tag
           ON node_tag_index(nest_id, tag_name);
       `);
-      const rows = db2.prepare(
+      const rows = db.prepare(
         `SELECT nv.nest_id, nv.node_id, nv.tags_json
            FROM node_versions nv
            JOIN (
@@ -445,7 +507,7 @@ function runMigrations(db2) {
             AND latest.node_id = nv.node_id
             AND latest.v = nv.version`
       ).all();
-      const insertTag = db2.prepare(
+      const insertTag = db.prepare(
         "INSERT OR IGNORE INTO node_tag_index (nest_id, node_id, tag_name) VALUES (?, ?, ?)"
       );
       for (const row of rows) {
@@ -467,8 +529,8 @@ function runMigrations(db2) {
     })();
   }
   if (!hasMigration("003_sessions_and_single_api_key")) {
-    db2.transaction(() => {
-      db2.exec(`
+    db.transaction(() => {
+      db.exec(`
         CREATE TABLE IF NOT EXISTS sessions (
           id TEXT PRIMARY KEY,
           user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
@@ -480,7 +542,7 @@ function runMigrations(db2) {
         CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions(user_id);
         CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions(expires_at);
       `);
-      db2.exec(`
+      db.exec(`
         DELETE FROM api_keys
         WHERE id IN (
           SELECT id FROM (
@@ -498,7 +560,7 @@ function runMigrations(db2) {
           WHERE rn > 1
         );
       `);
-      db2.exec(`
+      db.exec(`
         CREATE UNIQUE INDEX IF NOT EXISTS idx_api_keys_user_unique
           ON api_keys(user_id);
       `);
@@ -506,25 +568,25 @@ function runMigrations(db2) {
     })();
   }
   if (!hasMigration("004_license_cache_owner_email")) {
-    db2.transaction(() => {
-      const cols = db2.prepare("PRAGMA table_info(license_cache)").all().map((c) => c.name);
+    db.transaction(() => {
+      const cols = db.prepare("PRAGMA table_info(license_cache)").all().map((c) => c.name);
       if (!cols.includes("owner_email")) {
-        db2.exec("ALTER TABLE license_cache ADD COLUMN owner_email TEXT");
+        db.exec("ALTER TABLE license_cache ADD COLUMN owner_email TEXT");
       }
       recordMigration("004_license_cache_owner_email");
     })();
   }
   if (!hasMigration("005_anon_nest_public_default")) {
-    db2.transaction(() => {
-      db2.prepare(
+    db.transaction(() => {
+      db.prepare(
         "UPDATE nests SET visibility = 'public' WHERE user_id = ? AND visibility = 'private'"
       ).run(ANON_USER_ID);
       recordMigration("005_anon_nest_public_default");
     })();
   }
   if (!hasMigration("006_node_versions_published_status")) {
-    db2.transaction(() => {
-      db2.exec(`
+    db.transaction(() => {
+      db.exec(`
         CREATE TABLE node_versions_new (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
           nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
@@ -552,15 +614,15 @@ function runMigrations(db2) {
     })();
   }
   if (!hasMigration("007_drop_steward_capability_flags")) {
-    const stewardCols2 = db2.prepare("PRAGMA table_info(stewards)").all().map((c) => c.name);
+    const stewardCols2 = db.prepare("PRAGMA table_info(stewards)").all().map((c) => c.name);
     const hasLegacyCols = stewardCols2.includes("can_approve") || stewardCols2.includes("can_reject");
     if (hasLegacyCols) {
-      db2.transaction(() => {
+      db.transaction(() => {
         if (stewardCols2.includes("can_approve")) {
-          db2.exec("ALTER TABLE stewards DROP COLUMN can_approve");
+          db.exec("ALTER TABLE stewards DROP COLUMN can_approve");
         }
         if (stewardCols2.includes("can_reject")) {
-          db2.exec("ALTER TABLE stewards DROP COLUMN can_reject");
+          db.exec("ALTER TABLE stewards DROP COLUMN can_reject");
         }
         recordMigration("007_drop_steward_capability_flags");
       })();
@@ -569,13 +631,13 @@ function runMigrations(db2) {
     }
   }
   if (!hasMigration("008_drop_steward_folder_scope")) {
-    db2.transaction(() => {
-      db2.exec("DELETE FROM stewards WHERE scope = 'folder'");
-      db2.exec("DROP INDEX IF EXISTS idx_stewards_uniq_folder");
-      db2.exec("DROP INDEX IF EXISTS idx_stewards_folder_lookup");
-      const tbl = db2.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='stewards'").get();
+    db.transaction(() => {
+      db.exec("DELETE FROM stewards WHERE scope = 'folder'");
+      db.exec("DROP INDEX IF EXISTS idx_stewards_uniq_folder");
+      db.exec("DROP INDEX IF EXISTS idx_stewards_folder_lookup");
+      const tbl = db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='stewards'").get();
       if (tbl?.sql && tbl.sql.includes("'folder'")) {
-        db2.exec(`
+        db.exec(`
           CREATE TABLE stewards_new (
             id TEXT PRIMARY KEY,
             nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
@@ -624,8 +686,8 @@ function runMigrations(db2) {
     })();
   }
   if (!hasMigration("009_lowercase_emails")) {
-    db2.transaction(() => {
-      const collisions = db2.prepare(
+    db.transaction(() => {
+      const collisions = db.prepare(
         `SELECT GROUP_CONCAT(email, ', ') AS emails
              FROM users GROUP BY LOWER(email) HAVING COUNT(*) > 1`
       ).all();
@@ -634,20 +696,20 @@ function runMigrations(db2) {
           `[migration 009] case-collision user rows NOT auto-merged: ${c.emails} \u2014 reconcile manually (pick the row the person logs into; reset its password; ensure collaborator/steward grants point at that user_id).`
         );
       }
-      db2.exec(
+      db.exec(
         `UPDATE users SET email = LOWER(email)
            WHERE email <> LOWER(email)
              AND LOWER(email) NOT IN (
                SELECT LOWER(email) FROM users GROUP BY LOWER(email) HAVING COUNT(*) > 1
              )`
       );
-      const remaining = db2.prepare(
+      const remaining = db.prepare(
         `SELECT COUNT(*) AS c FROM (
                SELECT 1 FROM users GROUP BY LOWER(email) HAVING COUNT(*) > 1
              )`
       ).get().c;
       if (remaining === 0) {
-        db2.exec(
+        db.exec(
           "CREATE UNIQUE INDEX IF NOT EXISTS idx_users_email_nocase ON users(email COLLATE NOCASE)"
         );
       } else {
@@ -659,8 +721,8 @@ function runMigrations(db2) {
     recordMigration("009_lowercase_emails");
   }
   if (!hasMigration("010_sso_used_jti")) {
-    db2.transaction(() => {
-      db2.exec(`
+    db.transaction(() => {
+      db.exec(`
         CREATE TABLE IF NOT EXISTS sso_used_jti (
           jti TEXT PRIMARY KEY,
           used_at TEXT NOT NULL DEFAULT (datetime('now')),
@@ -673,8 +735,8 @@ function runMigrations(db2) {
     recordMigration("010_sso_used_jti");
   }
   if (!hasMigration("011_comments")) {
-    db2.transaction(() => {
-      db2.exec(`
+    db.transaction(() => {
+      db.exec(`
         CREATE TABLE IF NOT EXISTS comments (
           id TEXT PRIMARY KEY,
           nest_id TEXT NOT NULL REFERENCES nests(id) ON DELETE CASCADE,
@@ -704,23 +766,150 @@ function runMigrations(db2) {
   }
 }
 
+// src/db/adapter.sqlite.ts
+var SqliteAdapter = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  dialect = "sqlite";
+  // better-sqlite3 is one synchronous connection. Once transaction bodies are
+  // async (they may `await` between statements), two concurrent bodies could
+  // interleave their BEGIN/COMMIT on the shared connection and corrupt
+  // atomicity. This promise chain serialises transactions in-process,
+  // restoring the run-to-completion guarantee better-sqlite3's own
+  // `.transaction()` gave us synchronously.
+  txChain = Promise.resolve();
+  async get(sql, params = []) {
+    return this.db.prepare(sql).get(...params);
+  }
+  async all(sql, params = []) {
+    return this.db.prepare(sql).all(...params);
+  }
+  async run(sql, params = []) {
+    const info = this.db.prepare(sql).run(...params);
+    return { changes: info.changes };
+  }
+  async exec(sql) {
+    this.db.exec(sql);
+  }
+  async transaction(fn) {
+    const run = async () => {
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        const result2 = await fn(this);
+        this.db.exec("COMMIT");
+        return result2;
+      } catch (err) {
+        try {
+          this.db.exec("ROLLBACK");
+        } catch {
+        }
+        throw err;
+      }
+    };
+    const result = this.txChain.then(run, run);
+    this.txChain = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  async close() {
+    this.db.close();
+  }
+};
+
 // src/db/client.ts
-var db = null;
+var adapter = null;
+function buildPgConfig() {
+  const base = {
+    max: config.DB_POOL_MAX,
+    idleTimeoutMillis: 3e4,
+    connectionTimeoutMillis: 1e4,
+    keepAlive: true
+  };
+  if (config.CLOUD_SQL_CONNECTION_NAME) {
+    return {
+      ...base,
+      host: `/cloudsql/${config.CLOUD_SQL_CONNECTION_NAME}`,
+      user: config.DB_USER || void 0,
+      password: config.DB_PASSWORD || void 0,
+      database: config.DB_NAME || void 0
+    };
+  }
+  if (config.DATABASE_URL) {
+    return { ...base, connectionString: config.DATABASE_URL, ssl: pgSsl() };
+  }
+  return {
+    ...base,
+    host: config.DB_HOST || "localhost",
+    port: config.DB_PORT,
+    user: config.DB_USER || void 0,
+    password: config.DB_PASSWORD || void 0,
+    database: config.DB_NAME || void 0,
+    ssl: pgSsl()
+  };
+}
+function pgSsl() {
+  if (!config.DB_SSL) return false;
+  const ssl = {
+    rejectUnauthorized: true
+  };
+  if (config.DB_SSL_CA) ssl.ca = readFileSync(config.DB_SSL_CA, "utf8");
+  return ssl;
+}
+function openSqlite() {
+  mkdirSync(dirname2(config.DATABASE_PATH), { recursive: true });
+  const raw = new Database(config.DATABASE_PATH);
+  raw.pragma("journal_mode = WAL");
+  raw.pragma("foreign_keys = ON");
+  raw.pragma("busy_timeout = 5000");
+  runMigrations(raw);
+  return new SqliteAdapter(raw);
+}
+async function initDb() {
+  if (adapter) return adapter;
+  if (config.DB_DRIVER === "postgres") {
+    const { Pool } = await import("pg");
+    const { PostgresAdapter } = await import("./adapter.postgres-YOODX2BI.js");
+    const { runPostgresMigrations } = await import("./migrations.postgres-NVJAGBSF.js");
+    const pool = new Pool(buildPgConfig());
+    adapter = new PostgresAdapter(pool);
+    await runPostgresMigrations(adapter);
+  } else {
+    adapter = openSqlite();
+  }
+  return adapter;
+}
 function getDb() {
-  if (!db) {
-    mkdirSync(dirname2(config.DATABASE_PATH), { recursive: true });
-    db = new Database(config.DATABASE_PATH);
-    db.pragma("journal_mode = WAL");
-    db.pragma("foreign_keys = ON");
-    db.pragma("busy_timeout = 5000");
-    runMigrations(db);
+  if (!adapter) {
+    if (config.DB_DRIVER === "postgres") {
+      throw new Error(
+        "Postgres backend not initialised \u2014 call (and await) initDb() at startup before getDb()."
+      );
+    }
+    adapter = openSqlite();
   }
-  return db;
+  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}`;
 }
 
 export {
   config,
-  ANON_USER_ID,
-  ANON_EMAIL,
-  getDb
+  initDb,
+  getDb,
+  nowExpr,
+  insertOrIgnore,
+  insertOrReplace
 };