@owloops/browserbird 1.0.2 → 1.0.3

package/dist/db-BsYEYsul.mjs

@@ -0,0 +1,1011 @@
+import { createRequire } from "node:module";
+import { styleText } from "node:util";
+import { mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { randomBytes } from "node:crypto";
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region src/core/logger.ts
+/** @fileoverview Structured logger. Writes to stderr, respects NO_COLOR. */
+function shouldUseColor() {
+	if (process.env["NO_COLOR"] !== void 0) return false;
+	if (process.env["TERM"] === "dumb") return false;
+	if (process.argv.includes("--no-color")) return false;
+	return process.stderr.isTTY === true;
+}
+const useColor = shouldUseColor();
+function style(format, text) {
+	if (!useColor) return text;
+	return styleText(format, text);
+}
+const LOG_LEVELS = {
+	ERROR: 0,
+	WARN: 1,
+	INFO: 2,
+	DEBUG: 3
+};
+let currentLevel = LOG_LEVELS.INFO;
+function timestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+}
+function write(prefix, message) {
+	process.stderr.write(`${style("dim", timestamp())} ${prefix} ${message}\n`);
+}
+const logger = {
+	error(message) {
+		if (currentLevel >= LOG_LEVELS.ERROR) write(style("red", "[error]"), message);
+	},
+	warn(message) {
+		if (currentLevel >= LOG_LEVELS.WARN) write(style("yellow", "[warn]"), message);
+	},
+	info(message) {
+		if (currentLevel >= LOG_LEVELS.INFO) write(style("blue", "[info]"), message);
+	},
+	debug(message) {
+		if (currentLevel >= LOG_LEVELS.DEBUG) write(style("dim", "[debug]"), message);
+	},
+	success(message) {
+		if (currentLevel >= LOG_LEVELS.INFO) write(style("green", "[ok]"), message);
+	},
+	setLevel(level) {
+		currentLevel = {
+			error: LOG_LEVELS.ERROR,
+			warn: LOG_LEVELS.WARN,
+			info: LOG_LEVELS.INFO,
+			debug: LOG_LEVELS.DEBUG
+		}[level] ?? LOG_LEVELS.INFO;
+	}
+};
+
+//#endregion
+//#region src/db/core.ts
+/** @fileoverview SQLite database lifecycle, migrations, and query utilities. */
+const DEFAULT_PER_PAGE = 15;
+const MAX_PER_PAGE = 100;
+/**
+* Parses a sort string into an SQL ORDER BY clause.
+* Each token is a column name optionally prefixed with `-` for DESC.
+* Only columns present in `allowedColumns` are included.
+*/
+function parseSort(raw, allowedColumns, fallback) {
+	if (!raw) return fallback;
+	const parts = [];
+	for (const token of raw.split(",")) {
+		const trimmed = token.trim();
+		if (!trimmed) continue;
+		const desc = trimmed.startsWith("-");
+		const col = desc ? trimmed.slice(1) : trimmed;
+		if (allowedColumns.has(col)) parts.push(`${col} ${desc ? "DESC" : "ASC"}`);
+	}
+	return parts.length > 0 ? parts.join(", ") : fallback;
+}
+/**
+* Builds a parenthesized OR clause for LIKE-based search across columns.
+* Returns empty sql/params when the search term is empty.
+*/
+function buildSearchClause(term, columns) {
+	if (!term || columns.length === 0) return {
+		sql: "",
+		params: []
+	};
+	const like = `%${term}%`;
+	return {
+		sql: `(${columns.map((c) => `${c} LIKE ?`).join(" OR ")})`,
+		params: columns.map(() => like)
+	};
+}
+function paginate(table, page, perPage, whereOrOptions, params, orderBy) {
+	let where;
+	let allParams;
+	let resolvedOrderBy;
+	if (typeof whereOrOptions === "object" && whereOrOptions !== null) {
+		const opts = whereOrOptions;
+		const conditions = [];
+		allParams = [...opts.params ?? []];
+		if (opts.where) conditions.push(opts.where);
+		if (opts.search && opts.searchColumns && opts.searchColumns.length > 0) {
+			const sc = buildSearchClause(opts.search, opts.searchColumns);
+			if (sc.sql) {
+				conditions.push(sc.sql);
+				allParams.push(...sc.params);
+			}
+		}
+		where = conditions.join(" AND ");
+		resolvedOrderBy = parseSort(opts.sort, opts.allowedSortColumns ?? /* @__PURE__ */ new Set(), opts.defaultSort ?? "created_at DESC");
+	} else {
+		where = whereOrOptions ?? "";
+		allParams = params ?? [];
+		resolvedOrderBy = orderBy ?? "created_at DESC";
+	}
+	const pp = Math.min(Math.max(perPage, 1), MAX_PER_PAGE);
+	const p = Math.max(page, 1);
+	const offset = (p - 1) * pp;
+	const countSql = `SELECT COUNT(*) as count FROM ${table}${where ? ` WHERE ${where}` : ""}`;
+	const totalItems = getDb().prepare(countSql).get(...allParams).count;
+	const totalPages = Math.max(Math.ceil(totalItems / pp), 1);
+	const dataSql = `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} ORDER BY ${resolvedOrderBy} LIMIT ? OFFSET ?`;
+	return {
+		items: getDb().prepare(dataSql).all(...allParams, pp, offset),
+		page: p,
+		perPage: pp,
+		totalItems,
+		totalPages
+	};
+}
+/**
+* Versioned migration registry. Each entry runs once, in order.
+* PRAGMA user_version tracks which migrations have been applied.
+* All DDL uses IF NOT EXISTS for idempotency.
+*/
+const MIGRATIONS = [{
+	name: "initial schema",
+	up(d) {
+		d.exec(`
+        CREATE TABLE IF NOT EXISTS users (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          email TEXT UNIQUE NOT NULL COLLATE NOCASE,
+          password_hash TEXT NOT NULL,
+          token_key TEXT NOT NULL,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS settings (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS sessions (
+          uid TEXT PRIMARY KEY,
+          channel_id TEXT NOT NULL,
+          thread_id TEXT,
+          agent_id TEXT NOT NULL DEFAULT 'default',
+          provider_session_id TEXT NOT NULL,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          last_active TEXT NOT NULL DEFAULT (datetime('now')),
+          message_count INTEGER NOT NULL DEFAULT 0,
+          UNIQUE(channel_id, thread_id)
+        );
+
+        CREATE TABLE IF NOT EXISTS cron_jobs (
+          uid TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          agent_id TEXT NOT NULL DEFAULT 'default',
+          schedule TEXT NOT NULL,
+          prompt TEXT NOT NULL,
+          target_channel_id TEXT,
+          active_hours_start TEXT,
+          active_hours_end TEXT,
+          timezone TEXT DEFAULT 'UTC',
+          enabled INTEGER NOT NULL DEFAULT 1,
+          failure_count INTEGER NOT NULL DEFAULT 0,
+          last_run TEXT,
+          last_status TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS cron_runs (
+          uid TEXT PRIMARY KEY,
+          job_uid TEXT NOT NULL REFERENCES cron_jobs(uid),
+          started_at TEXT NOT NULL DEFAULT (datetime('now')),
+          finished_at TEXT,
+          status TEXT NOT NULL DEFAULT 'running',
+          result TEXT,
+          error TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS messages (
+          id INTEGER PRIMARY KEY,
+          channel_id TEXT NOT NULL,
+          thread_id TEXT,
+          user_id TEXT NOT NULL,
+          direction TEXT NOT NULL CHECK(direction IN ('in', 'out')),
+          content TEXT,
+          tokens_in INTEGER,
+          tokens_out INTEGER,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS jobs (
+          id INTEGER PRIMARY KEY,
+          name TEXT NOT NULL,
+          payload TEXT,
+          status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'running', 'completed', 'failed')),
+          priority TEXT NOT NULL DEFAULT 'normal' CHECK(priority IN ('high', 'normal', 'low')),
+          attempts INTEGER NOT NULL DEFAULT 0,
+          max_attempts INTEGER NOT NULL DEFAULT 1,
+          timeout INTEGER NOT NULL DEFAULT 1800,
+          cron_job_uid TEXT REFERENCES cron_jobs(uid),
+          run_at TEXT,
+          started_at TEXT,
+          completed_at TEXT,
+          result TEXT,
+          error TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS logs (
+          id INTEGER PRIMARY KEY,
+          level TEXT NOT NULL DEFAULT 'info' CHECK(level IN ('debug', 'info', 'warn', 'error')),
+          source TEXT NOT NULL,
+          message TEXT NOT NULL,
+          channel_id TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_sessions_channel_thread
+          ON sessions(channel_id, thread_id);
+        CREATE INDEX IF NOT EXISTS idx_sessions_last_active
+          ON sessions(last_active);
+        CREATE INDEX IF NOT EXISTS idx_messages_channel_thread
+          ON messages(channel_id, thread_id);
+        CREATE INDEX IF NOT EXISTS idx_messages_created_at
+          ON messages(created_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_cron_runs_job_uid
+          ON cron_runs(job_uid, started_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled
+          ON cron_jobs(enabled);
+        CREATE INDEX IF NOT EXISTS idx_jobs_poll
+          ON jobs(status, priority, run_at, created_at);
+        CREATE INDEX IF NOT EXISTS idx_jobs_cron_job_uid
+          ON jobs(cron_job_uid);
+        CREATE INDEX IF NOT EXISTS idx_jobs_stale
+          ON jobs(status, started_at);
+        CREATE INDEX IF NOT EXISTS idx_logs_created_at
+          ON logs(created_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_logs_level_source
+          ON logs(level, source, created_at DESC);
+      `);
+	}
+}];
+let db = null;
+function getSchemaVersion(d) {
+	return d.prepare("PRAGMA user_version").get().user_version;
+}
+function setSchemaVersion(d, version) {
+	d.exec(`PRAGMA user_version = ${version}`);
+}
+/**
+* Runs pending migrations inside a transaction.
+* Safe to call on every startup; already-applied migrations are skipped.
+*/
+function migrate(d) {
+	const current = getSchemaVersion(d);
+	const target = MIGRATIONS.length;
+	if (current >= target) return;
+	for (let i = current; i < target; i++) {
+		const migration = MIGRATIONS[i];
+		logger.info(`migration ${i + 1}/${target}: ${migration.name}`);
+		d.exec("BEGIN");
+		try {
+			migration.up(d);
+			setSchemaVersion(d, i + 1);
+			d.exec("COMMIT");
+		} catch (err) {
+			d.exec("ROLLBACK");
+			throw new Error(`migration "${migration.name}" failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+		}
+	}
+}
+/**
+* Opens (or creates) the SQLite database at the given path.
+* Configures WAL mode, runs pending migrations.
+*/
+function openDatabase(dbPath) {
+	mkdirSync(dirname(dbPath), { recursive: true });
+	db = new DatabaseSync(dbPath);
+	db.exec("PRAGMA journal_mode = WAL");
+	db.exec("PRAGMA synchronous = NORMAL");
+	db.exec("PRAGMA foreign_keys = ON");
+	db.exec("PRAGMA busy_timeout = 5000");
+	migrate(db);
+	logger.info(`database opened at ${dbPath}`);
+}
+function closeDatabase() {
+	if (db) {
+		db.close();
+		db = null;
+		logger.info("database closed");
+	}
+}
+function getDb() {
+	if (!db) throw new Error("Database not initialized. Call openDatabase() first.");
+	return db;
+}
+/** Runs WAL checkpoint and query planner optimization. Safe to call periodically. */
+function optimizeDatabase() {
+	const d = getDb();
+	d.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+	d.exec("PRAGMA optimize");
+}
+/**
+* Resolves a row by UID or UID prefix, like git's short SHA resolution.
+* Exact match first (fast path), then prefix scan via LIKE.
+*/
+function resolveByUid(table, uidPrefix) {
+	const input = uidPrefix.toLowerCase();
+	const d = getDb();
+	const exact = d.prepare(`SELECT * FROM ${table} WHERE uid = ?`).get(input);
+	if (exact) return { row: exact };
+	const rows = d.prepare(`SELECT * FROM ${table} WHERE uid LIKE ? LIMIT 2`).all(`${input}%`);
+	if (rows.length === 0) return void 0;
+	if (rows.length > 1) return {
+		ambiguous: true,
+		count: d.prepare(`SELECT COUNT(*) as count FROM ${table} WHERE uid LIKE ?`).get(`${input}%`).count
+	};
+	return { row: rows[0] };
+}
+/** Wraps a function in BEGIN/COMMIT with automatic ROLLBACK on error. */
+function transaction(fn) {
+	const d = getDb();
+	d.exec("BEGIN IMMEDIATE");
+	try {
+		const result = fn();
+		d.exec("COMMIT");
+		return result;
+	} catch (err) {
+		d.exec("ROLLBACK");
+		throw err;
+	}
+}
+
+//#endregion
+//#region src/core/uid.ts
+/** @fileoverview Prefixed short ID generation (PocketBase/Motebase pattern). */
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+const UID_PREFIX = {
+	bird: "br_",
+	flight: "fl_",
+	session: "ss_"
+};
+function generateUid(prefix) {
+	const bytes = randomBytes(15);
+	let id = prefix;
+	for (let i = 0; i < 15; i++) id += ALPHABET[bytes[i] % 36];
+	return id;
+}
+function shortUid(uid) {
+	const i = uid.indexOf("_");
+	if (i === -1) return uid.slice(0, 10);
+	return uid.slice(0, i + 1 + 7);
+}
+
+//#endregion
+//#region src/db/sessions.ts
+function findSession(channelId, threadId) {
+	return getDb().prepare("SELECT * FROM sessions WHERE channel_id = ? AND thread_id IS ?").get(channelId, threadId);
+}
+function createSession(channelId, threadId, agentId, providerSessionId) {
+	const uid = generateUid(UID_PREFIX.session);
+	return getDb().prepare(`INSERT INTO sessions (uid, channel_id, thread_id, agent_id, provider_session_id)
+     VALUES (?, ?, ?, ?, ?)
+     RETURNING *`).get(uid, channelId, threadId, agentId, providerSessionId);
+}
+function touchSession(uid, messageCountDelta = 1) {
+	getDb().prepare(`UPDATE sessions SET last_active = datetime('now'), message_count = message_count + ? WHERE uid = ?`).run(messageCountDelta, uid);
+}
+const SESSION_SORT_COLUMNS = new Set([
+	"uid",
+	"channel_id",
+	"agent_id",
+	"message_count",
+	"last_active",
+	"created_at"
+]);
+const SESSION_SEARCH_COLUMNS = [
+	"channel_id",
+	"thread_id",
+	"agent_id"
+];
+function listSessions(page = 1, perPage = DEFAULT_PER_PAGE, sort, search) {
+	return paginate("sessions", page, perPage, {
+		defaultSort: "last_active DESC",
+		sort,
+		search,
+		allowedSortColumns: SESSION_SORT_COLUMNS,
+		searchColumns: SESSION_SEARCH_COLUMNS
+	});
+}
+function getSession(uid) {
+	return getDb().prepare("SELECT * FROM sessions WHERE uid = ?").get(uid);
+}
+const MESSAGE_SORT_COLUMNS = new Set([
+	"id",
+	"created_at",
+	"direction",
+	"user_id"
+]);
+const MESSAGE_SEARCH_COLUMNS = ["content", "user_id"];
+function getSessionMessages(channelId, threadId, page = 1, perPage = DEFAULT_PER_PAGE, sort, search) {
+	const pp = Math.min(Math.max(perPage, 1), MAX_PER_PAGE);
+	const p = Math.max(page, 1);
+	const offset = (p - 1) * pp;
+	const conditions = ["channel_id = ? AND thread_id IS ?"];
+	const allParams = [channelId, threadId];
+	if (search) {
+		const sc = buildSearchClause(search, MESSAGE_SEARCH_COLUMNS);
+		if (sc.sql) {
+			conditions.push(sc.sql);
+			allParams.push(...sc.params);
+		}
+	}
+	const where = conditions.join(" AND ");
+	const orderBy = parseSort(sort, MESSAGE_SORT_COLUMNS, "created_at ASC, id ASC");
+	const totalItems = getDb().prepare(`SELECT COUNT(*) as count FROM messages WHERE ${where}`).get(...allParams).count;
+	const totalPages = Math.max(Math.ceil(totalItems / pp), 1);
+	return {
+		items: getDb().prepare(`SELECT * FROM messages
+       WHERE ${where}
+       ORDER BY ${orderBy}
+       LIMIT ? OFFSET ?`).all(...allParams, pp, offset),
+		page: p,
+		perPage: pp,
+		totalItems,
+		totalPages
+	};
+}
+function getSessionTokenStats(channelId, threadId) {
+	return getDb().prepare(`SELECT COALESCE(SUM(tokens_in), 0) as totalTokensIn,
+              COALESCE(SUM(tokens_out), 0) as totalTokensOut
+       FROM messages
+       WHERE channel_id = ? AND thread_id IS ?`).get(channelId, threadId);
+}
+function getSessionCount() {
+	return getDb().prepare("SELECT COUNT(*) as count FROM sessions").get().count;
+}
+function deleteStaleSessions(ttlHours) {
+	const result = getDb().prepare(`DELETE FROM sessions WHERE last_active < datetime('now', ? || ' hours')`).run(`-${ttlHours}`);
+	return Number(result.changes);
+}
+function updateSessionProviderId(uid, providerSessionId) {
+	getDb().prepare("UPDATE sessions SET provider_session_id = ? WHERE uid = ?").run(providerSessionId, uid);
+}
+
+//#endregion
+//#region src/db/birds.ts
+const SYSTEM_CRON_PREFIX = "__bb_";
+const CRON_SORT_COLUMNS = new Set([
+	"uid",
+	"name",
+	"schedule",
+	"agent_id",
+	"enabled",
+	"last_run",
+	"created_at"
+]);
+const CRON_SEARCH_COLUMNS = [
+	"uid",
+	"name",
+	"prompt",
+	"schedule"
+];
+function listCronJobs(page = 1, perPage = DEFAULT_PER_PAGE, includeSystem = false, sort, search) {
+	return paginate("cron_jobs", page, perPage, {
+		where: includeSystem ? "" : `name NOT LIKE '${SYSTEM_CRON_PREFIX}%'`,
+		defaultSort: "created_at ASC",
+		sort,
+		search,
+		allowedSortColumns: CRON_SORT_COLUMNS,
+		searchColumns: CRON_SEARCH_COLUMNS
+	});
+}
+function getEnabledCronJobs() {
+	return getDb().prepare("SELECT * FROM cron_jobs WHERE enabled = 1 ORDER BY created_at").all();
+}
+function createCronJob(name, schedule, prompt, targetChannelId, agentId, timezone, activeHoursStart, activeHoursEnd) {
+	const uid = generateUid(UID_PREFIX.bird);
+	return getDb().prepare(`INSERT INTO cron_jobs (uid, name, schedule, prompt, target_channel_id, agent_id, timezone, active_hours_start, active_hours_end)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+     RETURNING *`).get(uid, name, schedule, prompt, targetChannelId ?? null, agentId ?? "default", timezone ?? "UTC", activeHoursStart ?? null, activeHoursEnd ?? null);
+}
+function updateCronJobStatus(jobUid, status, failureCount) {
+	getDb().prepare(`UPDATE cron_jobs SET last_run = datetime('now'), last_status = ?, failure_count = ? WHERE uid = ?`).run(status, failureCount, jobUid);
+}
+function getCronJob(jobUid) {
+	return getDb().prepare("SELECT * FROM cron_jobs WHERE uid = ?").get(jobUid);
+}
+function setCronJobEnabled(jobUid, enabled) {
+	const result = getDb().prepare("UPDATE cron_jobs SET enabled = ? WHERE uid = ?").run(enabled ? 1 : 0, jobUid);
+	return Number(result.changes) > 0;
+}
+function updateCronJob(jobUid, fields) {
+	const sets = [];
+	const params = [];
+	if (fields.name !== void 0) {
+		sets.push("name = ?");
+		params.push(fields.name);
+	}
+	if (fields.schedule !== void 0) {
+		sets.push("schedule = ?");
+		params.push(fields.schedule);
+	}
+	if (fields.prompt !== void 0) {
+		sets.push("prompt = ?");
+		params.push(fields.prompt);
+	}
+	if (fields.targetChannelId !== void 0) {
+		sets.push("target_channel_id = ?");
+		params.push(fields.targetChannelId);
+	}
+	if (fields.agentId !== void 0) {
+		sets.push("agent_id = ?");
+		params.push(fields.agentId);
+	}
+	if (fields.timezone !== void 0) {
+		sets.push("timezone = ?");
+		params.push(fields.timezone);
+	}
+	if (fields.activeHoursStart !== void 0) {
+		sets.push("active_hours_start = ?");
+		params.push(fields.activeHoursStart);
+	}
+	if (fields.activeHoursEnd !== void 0) {
+		sets.push("active_hours_end = ?");
+		params.push(fields.activeHoursEnd);
+	}
+	if (sets.length === 0) return getCronJob(jobUid);
+	params.push(jobUid);
+	return getDb().prepare(`UPDATE cron_jobs SET ${sets.join(", ")} WHERE uid = ? RETURNING *`).get(...params);
+}
+function deleteCronJob(jobUid) {
+	const d = getDb();
+	d.exec("BEGIN");
+	try {
+		d.prepare("DELETE FROM cron_runs WHERE job_uid = ?").run(jobUid);
+		d.prepare("UPDATE jobs SET cron_job_uid = NULL WHERE cron_job_uid = ?").run(jobUid);
+		const result = d.prepare("DELETE FROM cron_jobs WHERE uid = ?").run(jobUid);
+		d.exec("COMMIT");
+		return Number(result.changes) > 0;
+	} catch (err) {
+		d.exec("ROLLBACK");
+		throw err;
+	}
+}
+const FLIGHT_SORT_COLUMNS = new Set([
+	"uid",
+	"started_at",
+	"finished_at",
+	"status",
+	"bird_name"
+]);
+const FLIGHT_SORT_MAP = { bird_name: "j.name" };
+const FLIGHT_SEARCH_COLUMNS = [
+	"r.uid",
+	"r.job_uid",
+	"j.uid",
+	"j.name",
+	"r.error",
+	"r.result"
+];
+function listFlights(page = 1, perPage = DEFAULT_PER_PAGE, filters = {}, sort, search) {
+	const pp = Math.min(Math.max(perPage, 1), MAX_PER_PAGE);
+	const p = Math.max(page, 1);
+	const offset = (p - 1) * pp;
+	const conditions = [];
+	const params = [];
+	if (!filters.system) conditions.push(`j.name NOT LIKE '${SYSTEM_CRON_PREFIX}%'`);
+	if (filters.birdUid != null) {
+		conditions.push("r.job_uid = ?");
+		params.push(filters.birdUid);
+	}
+	if (filters.status) {
+		conditions.push("r.status = ?");
+		params.push(filters.status);
+	}
+	if (search) {
+		const sc = buildSearchClause(search, FLIGHT_SEARCH_COLUMNS);
+		if (sc.sql) {
+			conditions.push(sc.sql);
+			params.push(...sc.params);
+		}
+	}
+	const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+	let orderBy = parseSort(sort, FLIGHT_SORT_COLUMNS, "r.started_at DESC");
+	for (const [key, qualified] of Object.entries(FLIGHT_SORT_MAP)) orderBy = orderBy.replaceAll(key, qualified);
+	orderBy = orderBy.replace(/(?<![a-z.])\b(uid|started_at|finished_at|status)\b/g, "r.$1");
+	const totalItems = getDb().prepare(`SELECT COUNT(*) as count FROM cron_runs r JOIN cron_jobs j ON j.uid = r.job_uid ${where}`).get(...params).count;
+	const totalPages = Math.max(Math.ceil(totalItems / pp), 1);
+	return {
+		items: getDb().prepare(`SELECT r.uid, r.job_uid, j.uid as bird_uid, j.name as bird_name,
+              r.started_at, r.finished_at, r.status, r.result, r.error
+       FROM cron_runs r
+       JOIN cron_jobs j ON j.uid = r.job_uid
+       ${where}
+       ORDER BY ${orderBy}
+       LIMIT ? OFFSET ?`).all(...params, pp, offset),
+		page: p,
+		perPage: pp,
+		totalItems,
+		totalPages
+	};
+}
+function createCronRun(jobUid) {
+	const uid = generateUid(UID_PREFIX.flight);
+	return getDb().prepare("INSERT INTO cron_runs (uid, job_uid) VALUES (?, ?) RETURNING *").get(uid, jobUid);
+}
+function completeCronRun(runUid, status, result, error) {
+	getDb().prepare(`UPDATE cron_runs SET finished_at = datetime('now'), status = ?, result = ?, error = ? WHERE uid = ?`).run(status, result ?? null, error ?? null, runUid);
+}
+function getFlightStats() {
+	const rows = getDb().prepare(`SELECT r.status, COUNT(*) as count
+       FROM cron_runs r
+       JOIN cron_jobs j ON j.uid = r.job_uid
+       WHERE j.name NOT LIKE '${SYSTEM_CRON_PREFIX}%'
+       GROUP BY r.status`).all();
+	const stats = {
+		running: 0,
+		completed: 0,
+		failed: 0,
+		total: 0
+	};
+	for (const row of rows) {
+		if (row.status === "running") stats.running = row.count;
+		else if (row.status === "success") stats.completed = row.count;
+		else if (row.status === "error") stats.failed = row.count;
+		stats.total += row.count;
+	}
+	return stats;
+}
+function deleteOldCronRuns(retentionDays) {
+	const result = getDb().prepare(`DELETE FROM cron_runs WHERE started_at < datetime('now', ? || ' days')`).run(`-${retentionDays}`);
+	return Number(result.changes);
+}
+function ensureSystemCronJob(name, schedule, prompt) {
+	if (getDb().prepare("SELECT uid FROM cron_jobs WHERE name = ?").get(name)) return;
+	const uid = generateUid(UID_PREFIX.bird);
+	getDb().prepare(`INSERT INTO cron_jobs (uid, name, schedule, prompt, agent_id) VALUES (?, ?, ?, ?, 'system')`).run(uid, name, schedule, prompt);
+}
+
+//#endregion
+//#region src/db/jobs.ts
+function createJob(options) {
+	const payload = options.payload != null ? JSON.stringify(options.payload) : null;
+	const priority = options.priority ?? "normal";
+	const maxAttempts = options.maxAttempts ?? 1;
+	const timeout = options.timeout ?? 1800;
+	const cronJobUid = options.cronJobUid ?? null;
+	if (options.delaySeconds) return getDb().prepare(`INSERT INTO jobs (name, payload, priority, max_attempts, timeout, cron_job_uid, run_at)
+         VALUES (?, ?, ?, ?, ?, ?, datetime('now', '+' || ? || ' seconds'))
+         RETURNING *`).get(options.name, payload, priority, maxAttempts, timeout, cronJobUid, options.delaySeconds);
+	return getDb().prepare(`INSERT INTO jobs (name, payload, priority, max_attempts, timeout, cron_job_uid)
+       VALUES (?, ?, ?, ?, ?, ?)
+       RETURNING *`).get(options.name, payload, priority, maxAttempts, timeout, cronJobUid);
+}
+/**
+* Atomically claims the next pending job for processing.
+* Uses IMMEDIATE transaction to prevent race conditions.
+* Priority order: high > normal > low, then by creation time.
+*/
+function claimNextJob() {
+	return transaction(() => {
+		const row = getDb().prepare(`SELECT * FROM jobs
+         WHERE status = 'pending' AND (run_at IS NULL OR run_at <= datetime('now'))
+         ORDER BY CASE priority WHEN 'high' THEN 0 WHEN 'normal' THEN 1 WHEN 'low' THEN 2 END, created_at ASC
+         LIMIT 1`).get();
+		if (!row) return void 0;
+		getDb().prepare(`UPDATE jobs SET status = 'running', started_at = datetime('now'), attempts = attempts + 1
+         WHERE id = ?`).run(row.id);
+		return {
+			...row,
+			status: "running",
+			attempts: row.attempts + 1
+		};
+	});
+}
+function completeJob(jobId, result) {
+	getDb().prepare(`UPDATE jobs SET status = 'completed', completed_at = datetime('now'), result = ?
+       WHERE id = ?`).run(result ?? null, jobId);
+}
+function failJob(jobId, error) {
+	const job = getDb().prepare("SELECT attempts, max_attempts FROM jobs WHERE id = ?").get(jobId);
+	if (!job) return;
+	if (job.attempts < job.max_attempts) {
+		const delaySeconds = job.attempts * job.attempts;
+		getDb().prepare(`UPDATE jobs SET status = 'pending', error = ?,
+         run_at = datetime('now', '+' || ? || ' seconds')
+         WHERE id = ?`).run(error, delaySeconds, jobId);
+	} else getDb().prepare(`UPDATE jobs SET status = 'failed', completed_at = datetime('now'), error = ?
+         WHERE id = ?`).run(error, jobId);
+}
+/** Marks running jobs past their timeout as failed and cascades to linked cron_runs/cron_jobs. */
+function failStaleJobs() {
+	const d = getDb();
+	const staleRows = d.prepare(`SELECT id, cron_job_uid FROM jobs
+       WHERE status = 'running'
+         AND started_at < datetime('now', '-' || timeout || ' seconds')`).all();
+	if (staleRows.length === 0) return 0;
+	const updateJob = d.prepare(`UPDATE jobs SET status = 'failed', error = 'timeout', completed_at = datetime('now')
+     WHERE id = ?`);
+	const updateRun = d.prepare(`UPDATE cron_runs SET status = 'error', error = 'timeout', finished_at = datetime('now')
+     WHERE job_uid = ? AND status = 'running'`);
+	const updateBird = d.prepare(`UPDATE cron_jobs SET last_status = 'failed', failure_count = failure_count + 1
+     WHERE uid = ?`);
+	for (const row of staleRows) {
+		updateJob.run(row.id);
+		if (row.cron_job_uid != null) {
+			updateRun.run(row.cron_job_uid);
+			updateBird.run(row.cron_job_uid);
+		}
+	}
+	return staleRows.length;
+}
+function deleteOldJobs(retentionDays) {
+	const stmt = getDb().prepare(`DELETE FROM jobs WHERE status IN ('completed', 'failed')
+     AND completed_at < datetime('now', ? || ' days')`);
+	return Number(stmt.run(`-${retentionDays}`).changes);
+}
+const JOB_SORT_COLUMNS = new Set([
+	"id",
+	"name",
+	"status",
+	"priority",
+	"created_at",
+	"started_at"
+]);
+const JOB_SEARCH_COLUMNS = ["name", "error"];
+function listJobs(page = 1, perPage = DEFAULT_PER_PAGE, filters = {}, sort, search) {
+	const conditions = [];
+	const params = [];
+	if (filters.status) {
+		conditions.push("status = ?");
+		params.push(filters.status);
+	}
+	if (filters.cronJobUid != null) {
+		conditions.push("cron_job_uid = ?");
+		params.push(filters.cronJobUid);
+	}
+	if (filters.name) {
+		conditions.push("name LIKE ?");
+		params.push(`%${filters.name}%`);
+	}
+	return paginate("jobs", page, perPage, {
+		where: conditions.join(" AND "),
+		params,
+		defaultSort: "created_at DESC",
+		sort,
+		search,
+		allowedSortColumns: JOB_SORT_COLUMNS,
+		searchColumns: JOB_SEARCH_COLUMNS
+	});
+}
+function getJobStats() {
+	const rows = getDb().prepare("SELECT status, COUNT(*) as count FROM jobs GROUP BY status").all();
+	const stats = {
+		pending: 0,
+		running: 0,
+		completed: 0,
+		failed: 0,
+		total: 0
+	};
+	for (const row of rows) {
+		if (row.status in stats) stats[row.status] = row.count;
+		stats.total += row.count;
+	}
+	return stats;
+}
+function retryJob(jobId) {
+	const result = getDb().prepare(`UPDATE jobs SET status = 'pending', attempts = 0, error = NULL, result = NULL,
+       run_at = NULL, started_at = NULL, completed_at = NULL
+       WHERE id = ? AND status = 'failed'`).run(jobId);
+	return Number(result.changes) > 0;
+}
+function retryAllFailedJobs() {
+	const result = getDb().prepare(`UPDATE jobs SET status = 'pending', attempts = 0, error = NULL, result = NULL,
+       run_at = NULL, started_at = NULL, completed_at = NULL
+       WHERE status = 'failed'`).run();
+	return Number(result.changes);
+}
+function deleteJob(jobId) {
+	const result = getDb().prepare("DELETE FROM jobs WHERE id = ?").run(jobId);
+	return Number(result.changes) > 0;
+}
+function clearJobs(status) {
+	const result = getDb().prepare("DELETE FROM jobs WHERE status = ?").run(status);
+	return Number(result.changes);
+}
+/** Returns true if the given cron job has a pending or running job in the queue. */
+function hasPendingCronJob(cronJobUid) {
+	return getDb().prepare(`SELECT 1 FROM jobs WHERE cron_job_uid = ? AND status IN ('pending', 'running') LIMIT 1`).get(cronJobUid) != null;
+}
+
+//#endregion
+//#region src/db/messages.ts
+/** @fileoverview Message logging: message audit trail and token tracking. */
+function logMessage(channelId, threadId, userId, direction, content, tokensIn, tokensOut) {
+	getDb().prepare(`INSERT INTO messages (channel_id, thread_id, user_id, direction, content, tokens_in, tokens_out)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(channelId, threadId ?? null, userId, direction, content ?? null, tokensIn ?? null, tokensOut ?? null);
+}
+function getLastInboundMessage(channelId, threadId) {
+	const row = getDb().prepare(`SELECT content, created_at FROM messages
+       WHERE channel_id = ? AND thread_id IS ? AND direction = 'in' AND content IS NOT NULL
+       ORDER BY created_at DESC LIMIT 1`).get(channelId, threadId);
+	if (!row) return void 0;
+	return {
+		content: row.content,
+		timestamp: row.created_at
+	};
+}
+function deleteOldMessages(retentionDays) {
+	const result = getDb().prepare(`DELETE FROM messages WHERE created_at < datetime('now', ? || ' days')`).run(`-${retentionDays}`);
+	return Number(result.changes);
+}
+function getMessageStats() {
+	return getDb().prepare(`SELECT
+         COUNT(*) as totalMessages,
+         COALESCE(SUM(tokens_in), 0) as totalTokensIn,
+         COALESCE(SUM(tokens_out), 0) as totalTokensOut
+       FROM messages`).get();
+}
+
+//#endregion
+//#region src/db/logs.ts
+function insertLog(level, source, message, channelId) {
+	getDb().prepare(`INSERT INTO logs (level, source, message, channel_id) VALUES (?, ?, ?, ?)`).run(level, source, message, channelId ?? null);
+}
+const LOG_SORT_COLUMNS = new Set([
+	"id",
+	"level",
+	"source",
+	"created_at"
+]);
+const LOG_SEARCH_COLUMNS = ["message", "source"];
+function getRecentLogs(page = 1, perPage = DEFAULT_PER_PAGE, level, source, sort, search) {
+	const conditions = [];
+	const params = [];
+	if (level) {
+		conditions.push("level = ?");
+		params.push(level);
+	}
+	if (source) {
+		conditions.push("source = ?");
+		params.push(source);
+	}
+	return paginate("logs", page, perPage, {
+		where: conditions.join(" AND "),
+		params,
+		defaultSort: "created_at DESC",
+		sort,
+		search,
+		allowedSortColumns: LOG_SORT_COLUMNS,
+		searchColumns: LOG_SEARCH_COLUMNS
+	});
+}
+function deleteOldLogs(retentionDays) {
+	const stmt = getDb().prepare(`DELETE FROM logs WHERE created_at < datetime('now', ? || ' days')`);
+	return Number(stmt.run(`-${retentionDays}`).changes);
+}
+
+//#endregion
+//#region src/db/auth.ts
+/** @fileoverview User and settings persistence for the auth system. */
+function getUserCount() {
+	return getDb().prepare("SELECT COUNT(*) as count FROM users").get().count;
+}
+function getUserByEmail(email) {
+	return getDb().prepare("SELECT * FROM users WHERE email = ?").get(email);
+}
+function getUserById(id) {
+	return getDb().prepare("SELECT * FROM users WHERE id = ?").get(id);
+}
+function createUser(email, passwordHash, tokenKey) {
+	getDb().prepare("INSERT INTO users (email, password_hash, token_key) VALUES (?, ?, ?)").run(email, passwordHash, tokenKey);
+	return getUserByEmail(email);
+}
+function getSetting(key) {
+	return getDb().prepare("SELECT value FROM settings WHERE key = ?").get(key)?.value;
+}
+function setSetting(key, value) {
+	getDb().prepare("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)").run(key, value);
+}
+
+//#endregion
+//#region src/db/path.ts
+/** @fileoverview Database path resolution: CLI flag, env var, or default. */
+const DEFAULT_DB_PATH = resolve(".browserbird", "browserbird.db");
+/**
+* Resolves the database file path.
+* Priority: explicit value > BROWSERBIRD_DB env var > default.
+*/
+function resolveDbPath(explicit) {
+	if (explicit) return resolve(explicit);
+	const envValue = process.env["BROWSERBIRD_DB"];
+	if (envValue) return resolve(envValue);
+	return DEFAULT_DB_PATH;
+}
+/**
+* Extracts --db value from a raw argv array, then resolves.
+* Used by CLI command handlers that receive argv directly.
+*/
+function resolveDbPathFromArgv(argv) {
+	const idx = argv.indexOf("--db");
+	if (idx !== -1 && idx + 1 < argv.length) return resolveDbPath(argv[idx + 1]);
+	return resolveDbPath();
+}
+
+//#endregion
+//#region src/db/index.ts
+var db_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_PER_PAGE: () => DEFAULT_PER_PAGE,
+	MAX_PER_PAGE: () => MAX_PER_PAGE,
+	SYSTEM_CRON_PREFIX: () => SYSTEM_CRON_PREFIX,
+	buildSearchClause: () => buildSearchClause,
+	claimNextJob: () => claimNextJob,
+	clearJobs: () => clearJobs,
+	closeDatabase: () => closeDatabase,
+	completeCronRun: () => completeCronRun,
+	completeJob: () => completeJob,
+	createCronJob: () => createCronJob,
+	createCronRun: () => createCronRun,
+	createJob: () => createJob,
+	createSession: () => createSession,
+	createUser: () => createUser,
+	deleteCronJob: () => deleteCronJob,
+	deleteJob: () => deleteJob,
+	deleteOldCronRuns: () => deleteOldCronRuns,
+	deleteOldJobs: () => deleteOldJobs,
+	deleteOldLogs: () => deleteOldLogs,
+	deleteOldMessages: () => deleteOldMessages,
+	deleteStaleSessions: () => deleteStaleSessions,
+	ensureSystemCronJob: () => ensureSystemCronJob,
+	failJob: () => failJob,
+	failStaleJobs: () => failStaleJobs,
+	findSession: () => findSession,
+	getCronJob: () => getCronJob,
+	getDb: () => getDb,
+	getEnabledCronJobs: () => getEnabledCronJobs,
+	getFlightStats: () => getFlightStats,
+	getJobStats: () => getJobStats,
+	getLastInboundMessage: () => getLastInboundMessage,
+	getMessageStats: () => getMessageStats,
+	getRecentLogs: () => getRecentLogs,
+	getSession: () => getSession,
+	getSessionCount: () => getSessionCount,
+	getSessionMessages: () => getSessionMessages,
+	getSessionTokenStats: () => getSessionTokenStats,
+	getSetting: () => getSetting,
+	getUserByEmail: () => getUserByEmail,
+	getUserById: () => getUserById,
+	getUserCount: () => getUserCount,
+	hasPendingCronJob: () => hasPendingCronJob,
+	insertLog: () => insertLog,
+	listCronJobs: () => listCronJobs,
+	listFlights: () => listFlights,
+	listJobs: () => listJobs,
+	listSessions: () => listSessions,
+	logMessage: () => logMessage,
+	openDatabase: () => openDatabase,
+	optimizeDatabase: () => optimizeDatabase,
+	paginate: () => paginate,
+	parseSort: () => parseSort,
+	resolveByUid: () => resolveByUid,
+	resolveDbPath: () => resolveDbPath,
+	resolveDbPathFromArgv: () => resolveDbPathFromArgv,
+	retryAllFailedJobs: () => retryAllFailedJobs,
+	retryJob: () => retryJob,
+	setCronJobEnabled: () => setCronJobEnabled,
+	setSetting: () => setSetting,
+	touchSession: () => touchSession,
+	transaction: () => transaction,
+	updateCronJob: () => updateCronJob,
+	updateCronJobStatus: () => updateCronJobStatus,
+	updateSessionProviderId: () => updateSessionProviderId
+});
+
+//#endregion
+export { updateSessionProviderId as $, completeCronRun as A, listFlights as B, failStaleJobs as C, retryAllFailedJobs as D, listJobs as E, ensureSystemCronJob as F, deleteStaleSessions as G, updateCronJob as H, getCronJob as I, getSessionCount as J, findSession as K, getEnabledCronJobs as L, createCronRun as M, deleteCronJob as N, retryJob as O, deleteOldCronRuns as P, touchSession as Q, getFlightStats as R, failJob as S, hasPendingCronJob as T, updateCronJobStatus as U, setCronJobEnabled as V, createSession as W, getSessionTokenStats as X, getSessionMessages as Y, listSessions as Z, clearJobs as _, getSetting as a, logger as at, deleteJob as b, getUserCount as c, getRecentLogs as d, shortUid as et, insertLog as f, claimNextJob as g, logMessage as h, createUser as i, resolveByUid as it, createCronJob as j, SYSTEM_CRON_PREFIX as k, setSetting as l, getMessageStats as m, resolveDbPath as n, openDatabase as nt, getUserByEmail as o, deleteOldMessages as p, getSession as q, resolveDbPathFromArgv as r, optimizeDatabase as rt, getUserById as s, db_exports as t, closeDatabase as tt, deleteOldLogs as u, completeJob as v, getJobStats as w, deleteOldJobs as x, createJob as y, listCronJobs as z };