1477 lines
47 KiB
TypeScript
1477 lines
47 KiB
TypeScript
import { Database } from "bun:sqlite";
|
|
import { resolve } from "path";
|
|
import { logger } from "./logger";
|
|
import { ensureDataDir } from "./paths";
|
|
import { getConfig } from "./config";
|
|
|
|
const dataDir = ensureDataDir();
|
|
const dbPath = resolve(dataDir, "overlord.db");
|
|
const db = new Database(dbPath);
|
|
|
|
export type UserRole = "admin" | "operator" | "viewer";
|
|
export type ClientAccessScope = "none" | "allowlist" | "denylist" | "all";
|
|
export type ClientAccessRuleKind = "allow" | "deny";
|
|
export type PluginAccessScope = "none" | "allowlist" | "all";
|
|
|
|
export interface User {
|
|
id: number;
|
|
username: string;
|
|
password_hash: string;
|
|
role: UserRole;
|
|
created_at: number;
|
|
last_login: number | null;
|
|
created_by: string | null;
|
|
must_change_password: number;
|
|
client_scope: ClientAccessScope;
|
|
plugin_scope: PluginAccessScope;
|
|
can_build: number;
|
|
can_upload_files: number;
|
|
telegram_chat_id: string | null;
|
|
}
|
|
|
|
export interface UserInfo {
|
|
id: number;
|
|
username: string;
|
|
role: UserRole;
|
|
created_at: number;
|
|
last_login: number | null;
|
|
created_by: string | null;
|
|
client_scope: ClientAccessScope;
|
|
plugin_scope: PluginAccessScope;
|
|
can_build: number;
|
|
can_upload_files: number;
|
|
telegram_chat_id: string | null;
|
|
}
|
|
|
|
export interface UserClientAccessRule {
|
|
userId: number;
|
|
clientId: string;
|
|
access: ClientAccessRuleKind;
|
|
}
|
|
|
|
export interface UserPluginAccessRule {
|
|
userId: number;
|
|
pluginId: string;
|
|
}
|
|
|
|
type UserAccessCacheEntry = {
|
|
scope: ClientAccessScope;
|
|
allow: Set<string>;
|
|
deny: Set<string>;
|
|
};
|
|
|
|
const userAccessCache = new Map<number, UserAccessCacheEntry>();
|
|
let notificationDeliveryCache: UserDeliveryRow[] | null = null;
|
|
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS users (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
username TEXT UNIQUE NOT NULL,
|
|
password_hash TEXT NOT NULL,
|
|
role TEXT NOT NULL CHECK(role IN ('admin', 'operator', 'viewer')),
|
|
created_at INTEGER NOT NULL,
|
|
last_login INTEGER,
|
|
created_by TEXT,
|
|
must_change_password INTEGER DEFAULT 0,
|
|
client_scope TEXT NOT NULL DEFAULT 'none' CHECK(client_scope IN ('none', 'allowlist', 'denylist', 'all'))
|
|
)
|
|
`);
|
|
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS user_client_access_rules (
|
|
user_id INTEGER NOT NULL,
|
|
client_id TEXT NOT NULL,
|
|
access TEXT NOT NULL CHECK(access IN ('allow', 'deny')),
|
|
created_at INTEGER NOT NULL,
|
|
PRIMARY KEY (user_id, client_id),
|
|
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
|
)
|
|
`);
|
|
|
|
db.exec(
|
|
`CREATE INDEX IF NOT EXISTS idx_user_client_access_rules_user ON user_client_access_rules(user_id)`,
|
|
);
|
|
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS user_feature_permissions (
|
|
user_id INTEGER NOT NULL,
|
|
feature TEXT NOT NULL,
|
|
allowed INTEGER NOT NULL DEFAULT 1,
|
|
PRIMARY KEY (user_id, feature),
|
|
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
|
)
|
|
`);
|
|
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS user_plugin_access_rules (
|
|
user_id INTEGER NOT NULL,
|
|
plugin_id TEXT NOT NULL,
|
|
created_at INTEGER NOT NULL,
|
|
PRIMARY KEY (user_id, plugin_id),
|
|
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
|
)
|
|
`);
|
|
db.exec(
|
|
`CREATE INDEX IF NOT EXISTS idx_user_plugin_access_rules_user ON user_plugin_access_rules(user_id)`,
|
|
);
|
|
|
|
try {
|
|
db.exec(
|
|
`ALTER TABLE users ADD COLUMN must_change_password INTEGER DEFAULT 0`,
|
|
);
|
|
logger.info("[users] Added must_change_password column to existing database");
|
|
} catch (err: any) {
|
|
if (!err.message?.includes("duplicate column name")) {
|
|
logger.error("[users] Migration error:", err);
|
|
}
|
|
}
|
|
|
|
try {
|
|
db.exec(
|
|
`ALTER TABLE users ADD COLUMN client_scope TEXT NOT NULL DEFAULT 'none' CHECK(client_scope IN ('none', 'allowlist', 'denylist', 'all'))`,
|
|
);
|
|
logger.info("[users] Added client_scope column to existing database");
|
|
} catch (err: any) {
|
|
if (!err.message?.includes("duplicate column name")) {
|
|
logger.error("[users] Migration error:", err);
|
|
}
|
|
}
|
|
|
|
try {
|
|
db.exec(`UPDATE users SET client_scope='all' WHERE role='admin'`);
|
|
} catch (err: any) {
|
|
logger.error("[users] Failed to normalize admin client_scope:", err);
|
|
}
|
|
|
|
try {
|
|
db.exec(
|
|
`ALTER TABLE users ADD COLUMN can_build INTEGER NOT NULL DEFAULT 0`,
|
|
);
|
|
logger.info("[users] Added can_build column to existing database");
|
|
|
|
try {
|
|
db.exec(`UPDATE users SET can_build=1 WHERE role='admin' OR role='operator'`);
|
|
} catch (err: any) {
|
|
logger.error("[users] Failed to backfill admin/operator can_build:", err);
|
|
}
|
|
} catch (err: any) {
|
|
if (!err.message?.includes("duplicate column name")) {
|
|
logger.error("[users] Migration error:", err);
|
|
}
|
|
}
|
|
|
|
try {
|
|
db.exec(
|
|
`ALTER TABLE users ADD COLUMN telegram_chat_id TEXT DEFAULT NULL`,
|
|
);
|
|
logger.info("[users] Added telegram_chat_id column to existing database");
|
|
} catch (err: any) {
|
|
if (!err.message?.includes("duplicate column name")) {
|
|
logger.error("[users] Migration error:", err);
|
|
}
|
|
}
|
|
|
|
const notificationColumns: Array<{ sql: string; label: string }> = [
|
|
{ sql: `ALTER TABLE users ADD COLUMN webhook_enabled INTEGER DEFAULT 0`, label: "webhook_enabled" },
|
|
{ sql: `ALTER TABLE users ADD COLUMN webhook_url TEXT DEFAULT NULL`, label: "webhook_url" },
|
|
{ sql: `ALTER TABLE users ADD COLUMN webhook_template TEXT DEFAULT NULL`, label: "webhook_template" },
|
|
{ sql: `ALTER TABLE users ADD COLUMN telegram_enabled INTEGER DEFAULT 0`, label: "telegram_enabled" },
|
|
{ sql: `ALTER TABLE users ADD COLUMN telegram_bot_token TEXT DEFAULT NULL`, label: "telegram_bot_token" },
|
|
{ sql: `ALTER TABLE users ADD COLUMN telegram_template TEXT DEFAULT NULL`, label: "telegram_template" },
|
|
];
|
|
for (const col of notificationColumns) {
|
|
try {
|
|
db.exec(col.sql);
|
|
logger.info(`[users] Added ${col.label} column to existing database`);
|
|
} catch (err: any) {
|
|
if (!err.message?.includes("duplicate column name")) {
|
|
logger.error("[users] Migration error:", err);
|
|
}
|
|
}
|
|
}
|
|
|
|
try {
|
|
db.exec(
|
|
`ALTER TABLE users ADD COLUMN can_upload_files INTEGER NOT NULL DEFAULT 0`,
|
|
);
|
|
logger.info("[users] Added can_upload_files column to existing database");
|
|
|
|
try {
|
|
db.exec(`UPDATE users SET can_upload_files=1 WHERE role='admin'`);
|
|
} catch (err: any) {
|
|
logger.error("[users] Failed to backfill admin can_upload_files:", err);
|
|
}
|
|
} catch (err: any) {
|
|
if (!err.message?.includes("duplicate column name")) {
|
|
logger.error("[users] Migration error:", err);
|
|
}
|
|
}
|
|
|
|
const clientEventColumns: Array<{ sql: string; label: string }> = [
|
|
{ sql: `ALTER TABLE users ADD COLUMN client_event_webhook INTEGER DEFAULT 1`, label: "client_event_webhook" },
|
|
{ sql: `ALTER TABLE users ADD COLUMN client_event_telegram INTEGER DEFAULT 1`, label: "client_event_telegram" },
|
|
{ sql: `ALTER TABLE users ADD COLUMN client_event_push INTEGER DEFAULT 1`, label: "client_event_push" },
|
|
];
|
|
for (const col of clientEventColumns) {
|
|
try {
|
|
db.exec(col.sql);
|
|
logger.info(`[users] Added ${col.label} column to existing database`);
|
|
} catch (err: any) {
|
|
if (!err.message?.includes("duplicate column name")) {
|
|
logger.error("[users] Migration error:", err);
|
|
}
|
|
}
|
|
}
|
|
|
|
try {
|
|
db.exec(`ALTER TABLE users ADD COLUMN chat_write INTEGER DEFAULT NULL`);
|
|
logger.info("[users] Added chat_write column to existing database");
|
|
} catch (err: any) {
|
|
if (!err.message?.includes("duplicate column name")) {
|
|
logger.error("[users] Migration error:", err);
|
|
}
|
|
}
|
|
|
|
try {
|
|
db.exec(`ALTER TABLE users ADD COLUMN registered_via TEXT DEFAULT NULL`);
|
|
logger.info("[users] Added registered_via column to existing database");
|
|
} catch (err: any) {
|
|
if (!err.message?.includes("duplicate column name")) {
|
|
logger.error("[users] Migration error:", err);
|
|
}
|
|
}
|
|
|
|
try {
|
|
db.exec(
|
|
`ALTER TABLE users ADD COLUMN plugin_scope TEXT NOT NULL DEFAULT 'none' CHECK(plugin_scope IN ('none', 'allowlist', 'all'))`,
|
|
);
|
|
logger.info("[users] Added plugin_scope column to existing database");
|
|
try {
|
|
db.exec(`UPDATE users SET plugin_scope='all' WHERE role='admin'`);
|
|
} catch (err: any) {
|
|
logger.error("[users] Failed to backfill admin plugin_scope:", err);
|
|
}
|
|
} catch (err: any) {
|
|
if (!err.message?.includes("duplicate column name")) {
|
|
logger.error("[users] Migration error:", err);
|
|
}
|
|
}
|
|
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS registration_keys (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
key TEXT UNIQUE NOT NULL,
|
|
label TEXT,
|
|
created_by INTEGER NOT NULL,
|
|
created_at INTEGER NOT NULL,
|
|
expires_at INTEGER,
|
|
used_by INTEGER,
|
|
used_at INTEGER,
|
|
FOREIGN KEY (created_by) REFERENCES users(id) ON DELETE CASCADE
|
|
)
|
|
`);
|
|
db.exec(`CREATE INDEX IF NOT EXISTS idx_registration_keys_key ON registration_keys("key")`);
|
|
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS pending_registrations (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
username TEXT NOT NULL,
|
|
password_hash TEXT NOT NULL,
|
|
requested_at INTEGER NOT NULL,
|
|
status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'approved', 'denied')),
|
|
reviewed_by INTEGER,
|
|
reviewed_at INTEGER,
|
|
key_used INTEGER,
|
|
FOREIGN KEY (key_used) REFERENCES registration_keys(id)
|
|
)
|
|
`);
|
|
db.exec(`CREATE INDEX IF NOT EXISTS idx_pending_registrations_status ON pending_registrations(status)`);
|
|
db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_pending_registrations_username_pending ON pending_registrations(username) WHERE status = 'pending'`);
|
|
|
|
|
|
const userCount = db.prepare("SELECT COUNT(*) as count FROM users").get() as {
|
|
count: number;
|
|
};
|
|
if (userCount.count === 0) {
|
|
const config = getConfig();
|
|
const initialUsername = (config.auth.username || "admin").trim() || "admin";
|
|
const initialPassword = config.auth.password;
|
|
|
|
logger.info("[users] No users found, creating default admin account");
|
|
const defaultPassword = await Bun.password.hash(initialPassword, {
|
|
algorithm: "bcrypt",
|
|
cost: 10,
|
|
});
|
|
|
|
db.prepare(
|
|
"INSERT INTO users (username, password_hash, role, created_at, created_by, must_change_password, client_scope, plugin_scope, can_build, can_upload_files) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
|
).run(initialUsername, defaultPassword, "admin", Date.now(), "system", 1, "all", "all", 1, 1);
|
|
|
|
const createdUser = db
|
|
.prepare("SELECT * FROM users WHERE username = ?")
|
|
.get(initialUsername) as User | undefined;
|
|
logger.info(
|
|
"[users] Default admin created with must_change_password =",
|
|
createdUser?.must_change_password,
|
|
);
|
|
|
|
logger.info(`[users] Initial admin account created (username: ${initialUsername})`);
|
|
logger.warn(
|
|
"[users] SECURITY WARNING: A default admin account has been created. Sign in and rotate the password immediately. Bootstrap credentials default to admin/admin unless overridden by configuration; the password is not logged.",
|
|
);
|
|
}
|
|
|
|
export function getUserById(id: number): User | null {
|
|
const user = db.prepare("SELECT * FROM users WHERE id = ?").get(id) as
|
|
| User
|
|
| undefined;
|
|
return user || null;
|
|
}
|
|
|
|
export function getUserByUsername(username: string): User | null {
|
|
const user = db
|
|
.prepare("SELECT * FROM users WHERE username = ?")
|
|
.get(username) as User | undefined;
|
|
return user || null;
|
|
}
|
|
|
|
export function listUsers(): UserInfo[] {
|
|
const users = db
|
|
.prepare(
|
|
"SELECT id, username, role, created_at, last_login, created_by, client_scope, plugin_scope, can_build, can_upload_files, telegram_chat_id FROM users ORDER BY created_at DESC",
|
|
)
|
|
.all() as UserInfo[];
|
|
return users;
|
|
}
|
|
|
|
export function getUserClientAccessScope(userId: number): ClientAccessScope {
|
|
return getUserAccessCacheEntry(userId).scope;
|
|
}
|
|
|
|
export function listUserClientAccessRules(userId: number): UserClientAccessRule[] {
|
|
return db
|
|
.prepare(
|
|
"SELECT user_id as userId, client_id as clientId, access FROM user_client_access_rules WHERE user_id = ? ORDER BY client_id ASC",
|
|
)
|
|
.all(userId) as UserClientAccessRule[];
|
|
}
|
|
|
|
export function listUserClientRuleIdsByAccess(
|
|
userId: number,
|
|
access: ClientAccessRuleKind,
|
|
): string[] {
|
|
const entry = getUserAccessCacheEntry(userId);
|
|
const values = access === "allow" ? entry.allow : entry.deny;
|
|
return Array.from(values).sort((left, right) => left.localeCompare(right));
|
|
}
|
|
|
|
function invalidateUserAccessCache(userId?: number): void {
|
|
if (userId === undefined) {
|
|
userAccessCache.clear();
|
|
return;
|
|
}
|
|
userAccessCache.delete(userId);
|
|
}
|
|
|
|
function invalidateNotificationDeliveryCache(): void {
|
|
notificationDeliveryCache = null;
|
|
}
|
|
|
|
function getUserAccessCacheEntry(userId: number): UserAccessCacheEntry {
|
|
const cached = userAccessCache.get(userId);
|
|
if (cached) {
|
|
return cached;
|
|
}
|
|
|
|
const row = db
|
|
.prepare("SELECT client_scope FROM users WHERE id = ?")
|
|
.get(userId) as { client_scope?: ClientAccessScope } | undefined;
|
|
const rules = db
|
|
.prepare(
|
|
"SELECT client_id as clientId, access FROM user_client_access_rules WHERE user_id = ?",
|
|
)
|
|
.all(userId) as Array<{ clientId: string; access: ClientAccessRuleKind }>;
|
|
|
|
const entry: UserAccessCacheEntry = {
|
|
scope: row?.client_scope || "none",
|
|
allow: new Set<string>(),
|
|
deny: new Set<string>(),
|
|
};
|
|
|
|
for (const rule of rules) {
|
|
if (rule.access === "allow") {
|
|
entry.allow.add(rule.clientId);
|
|
} else if (rule.access === "deny") {
|
|
entry.deny.add(rule.clientId);
|
|
}
|
|
}
|
|
|
|
userAccessCache.set(userId, entry);
|
|
return entry;
|
|
}
|
|
|
|
export function setUserClientAccessScope(
|
|
userId: number,
|
|
scope: ClientAccessScope,
|
|
): { success: boolean; error?: string } {
|
|
if (!["none", "allowlist", "denylist", "all"].includes(scope)) {
|
|
return { success: false, error: "Invalid client access scope" };
|
|
}
|
|
|
|
try {
|
|
db.prepare("UPDATE users SET client_scope = ? WHERE id = ?").run(scope, userId);
|
|
invalidateUserAccessCache(userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] setUserClientAccessScope error:", err);
|
|
return { success: false, error: err.message || "Failed to update client access scope" };
|
|
}
|
|
}
|
|
|
|
export function setUserClientAccessRule(
|
|
userId: number,
|
|
clientId: string,
|
|
access: ClientAccessRuleKind,
|
|
): { success: boolean; error?: string } {
|
|
const normalizedClientId = (clientId || "").trim();
|
|
if (!normalizedClientId) {
|
|
return { success: false, error: "clientId is required" };
|
|
}
|
|
if (!["allow", "deny"].includes(access)) {
|
|
return { success: false, error: "Invalid client access rule" };
|
|
}
|
|
|
|
try {
|
|
db.prepare(
|
|
"INSERT OR REPLACE INTO user_client_access_rules (user_id, client_id, access, created_at) VALUES (?, ?, ?, ?)",
|
|
).run(userId, normalizedClientId, access, Date.now());
|
|
invalidateUserAccessCache(userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] setUserClientAccessRule error:", err);
|
|
return { success: false, error: err.message || "Failed to update client access rule" };
|
|
}
|
|
}
|
|
|
|
export function removeUserClientAccessRule(
|
|
userId: number,
|
|
clientId: string,
|
|
): { success: boolean; error?: string } {
|
|
try {
|
|
db.prepare("DELETE FROM user_client_access_rules WHERE user_id = ? AND client_id = ?").run(
|
|
userId,
|
|
clientId,
|
|
);
|
|
invalidateUserAccessCache(userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] removeUserClientAccessRule error:", err);
|
|
return { success: false, error: err.message || "Failed to remove client access rule" };
|
|
}
|
|
}
|
|
|
|
export function canUserAccessClient(
|
|
userId: number,
|
|
role: UserRole,
|
|
clientId: string,
|
|
): boolean {
|
|
if (role === "admin") return true;
|
|
|
|
const access = getUserAccessCacheEntry(userId);
|
|
const scope = access.scope;
|
|
if (scope === "none") return false;
|
|
if (scope === "all") return true;
|
|
|
|
if (scope === "allowlist") {
|
|
return access.allow.has(clientId);
|
|
}
|
|
if (scope === "denylist") {
|
|
return !access.deny.has(clientId);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
type PluginAccessCacheEntry = {
|
|
scope: PluginAccessScope;
|
|
allowed: Set<string>;
|
|
};
|
|
|
|
const pluginAccessCache = new Map<number, PluginAccessCacheEntry>();
|
|
|
|
function invalidatePluginAccessCache(userId?: number): void {
|
|
if (userId === undefined) {
|
|
pluginAccessCache.clear();
|
|
return;
|
|
}
|
|
pluginAccessCache.delete(userId);
|
|
}
|
|
|
|
function getPluginAccessCacheEntry(userId: number): PluginAccessCacheEntry {
|
|
const cached = pluginAccessCache.get(userId);
|
|
if (cached) return cached;
|
|
|
|
const row = db
|
|
.prepare("SELECT plugin_scope FROM users WHERE id = ?")
|
|
.get(userId) as { plugin_scope?: PluginAccessScope } | undefined;
|
|
const rules = db
|
|
.prepare("SELECT plugin_id as pluginId FROM user_plugin_access_rules WHERE user_id = ?")
|
|
.all(userId) as Array<{ pluginId: string }>;
|
|
|
|
const entry: PluginAccessCacheEntry = {
|
|
scope: row?.plugin_scope || "none",
|
|
allowed: new Set<string>(),
|
|
};
|
|
|
|
for (const rule of rules) {
|
|
entry.allowed.add(rule.pluginId);
|
|
}
|
|
|
|
pluginAccessCache.set(userId, entry);
|
|
return entry;
|
|
}
|
|
|
|
export function getUserPluginAccessScope(userId: number): PluginAccessScope {
|
|
return getPluginAccessCacheEntry(userId).scope;
|
|
}
|
|
|
|
export function listUserPluginAccessRules(userId: number): UserPluginAccessRule[] {
|
|
return db
|
|
.prepare(
|
|
"SELECT user_id as userId, plugin_id as pluginId FROM user_plugin_access_rules WHERE user_id = ? ORDER BY plugin_id ASC",
|
|
)
|
|
.all(userId) as UserPluginAccessRule[];
|
|
}
|
|
|
|
export function canUserAccessPlugin(
|
|
userId: number,
|
|
role: UserRole,
|
|
pluginId: string,
|
|
): boolean {
|
|
if (role === "admin") return true;
|
|
|
|
const access = getPluginAccessCacheEntry(userId);
|
|
if (access.scope === "none") return false;
|
|
if (access.scope === "all") return true;
|
|
if (access.scope === "allowlist") return access.allowed.has(pluginId);
|
|
return false;
|
|
}
|
|
|
|
export function setUserPluginAccessScope(
|
|
userId: number,
|
|
scope: PluginAccessScope,
|
|
): { success: boolean; error?: string } {
|
|
if (!["none", "allowlist", "all"].includes(scope)) {
|
|
return { success: false, error: "Invalid plugin access scope" };
|
|
}
|
|
|
|
try {
|
|
db.prepare("UPDATE users SET plugin_scope = ? WHERE id = ?").run(scope, userId);
|
|
invalidatePluginAccessCache(userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] setUserPluginAccessScope error:", err);
|
|
return { success: false, error: err.message || "Failed to update plugin access scope" };
|
|
}
|
|
}
|
|
|
|
export function setUserPluginAccessRule(
|
|
userId: number,
|
|
pluginId: string,
|
|
): { success: boolean; error?: string } {
|
|
const normalizedPluginId = (pluginId || "").trim();
|
|
if (!normalizedPluginId) {
|
|
return { success: false, error: "pluginId is required" };
|
|
}
|
|
|
|
try {
|
|
db.prepare(
|
|
"INSERT OR REPLACE INTO user_plugin_access_rules (user_id, plugin_id, created_at) VALUES (?, ?, ?)",
|
|
).run(userId, normalizedPluginId, Date.now());
|
|
invalidatePluginAccessCache(userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] setUserPluginAccessRule error:", err);
|
|
return { success: false, error: err.message || "Failed to update plugin access rule" };
|
|
}
|
|
}
|
|
|
|
export function removeUserPluginAccessRule(
|
|
userId: number,
|
|
pluginId: string,
|
|
): { success: boolean; error?: string } {
|
|
try {
|
|
db.prepare("DELETE FROM user_plugin_access_rules WHERE user_id = ? AND plugin_id = ?").run(
|
|
userId,
|
|
pluginId,
|
|
);
|
|
invalidatePluginAccessCache(userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] removeUserPluginAccessRule error:", err);
|
|
return { success: false, error: err.message || "Failed to remove plugin access rule" };
|
|
}
|
|
}
|
|
|
|
export function setUserPluginAccessRulesBulk(
|
|
userId: number,
|
|
pluginIds: string[],
|
|
): { success: boolean; error?: string } {
|
|
try {
|
|
const tx = db.transaction(() => {
|
|
db.prepare("DELETE FROM user_plugin_access_rules WHERE user_id = ?").run(userId);
|
|
const stmt = db.prepare(
|
|
"INSERT INTO user_plugin_access_rules (user_id, plugin_id, created_at) VALUES (?, ?, ?)",
|
|
);
|
|
const now = Date.now();
|
|
for (const pid of pluginIds) {
|
|
const normalized = (pid || "").trim();
|
|
if (normalized) stmt.run(userId, normalized, now);
|
|
}
|
|
});
|
|
tx();
|
|
invalidatePluginAccessCache(userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] setUserPluginAccessRulesBulk error:", err);
|
|
return { success: false, error: err.message || "Failed to update plugin access rules" };
|
|
}
|
|
}
|
|
|
|
export type FeatureName =
|
|
| "console"
|
|
| "remote_desktop"
|
|
| "hvnc"
|
|
| "webcam"
|
|
| "file_browser"
|
|
| "processes"
|
|
| "keylogger"
|
|
| "voice";
|
|
|
|
export const ALL_FEATURES: FeatureName[] = [
|
|
"console",
|
|
"remote_desktop",
|
|
"hvnc",
|
|
"webcam",
|
|
"file_browser",
|
|
"processes",
|
|
"keylogger",
|
|
"voice",
|
|
];
|
|
|
|
const featurePermCache = new Map<number, Map<string, boolean>>();
|
|
|
|
function getFeaturePermCacheEntry(userId: number): Map<string, boolean> {
|
|
const cached = featurePermCache.get(userId);
|
|
if (cached) return cached;
|
|
|
|
const rows = db
|
|
.prepare("SELECT feature, allowed FROM user_feature_permissions WHERE user_id = ?")
|
|
.all(userId) as Array<{ feature: string; allowed: number }>;
|
|
|
|
const map = new Map<string, boolean>();
|
|
for (const row of rows) {
|
|
map.set(row.feature, row.allowed === 1);
|
|
}
|
|
featurePermCache.set(userId, map);
|
|
return map;
|
|
}
|
|
|
|
function invalidateFeaturePermCache(userId: number): void {
|
|
featurePermCache.delete(userId);
|
|
}
|
|
|
|
export function canUserAccessFeature(
|
|
userId: number,
|
|
role: UserRole,
|
|
feature: FeatureName,
|
|
): boolean {
|
|
if (role === "admin") return true;
|
|
if (role === "viewer") return false;
|
|
|
|
const perms = getFeaturePermCacheEntry(userId);
|
|
const entry = perms.get(feature);
|
|
if (entry === undefined) return true;
|
|
return entry;
|
|
}
|
|
|
|
export function getUserFeaturePermissions(
|
|
userId: number,
|
|
): Record<FeatureName, boolean> {
|
|
const user = getUserById(userId);
|
|
if (!user) {
|
|
const result = {} as Record<FeatureName, boolean>;
|
|
for (const f of ALL_FEATURES) result[f] = false;
|
|
return result;
|
|
}
|
|
|
|
const result = {} as Record<FeatureName, boolean>;
|
|
for (const f of ALL_FEATURES) {
|
|
result[f] = canUserAccessFeature(userId, user.role, f);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
export function setUserFeaturePermission(
|
|
userId: number,
|
|
feature: FeatureName,
|
|
allowed: boolean,
|
|
): { success: boolean; error?: string } {
|
|
if (!ALL_FEATURES.includes(feature)) {
|
|
return { success: false, error: `Invalid feature: ${feature}` };
|
|
}
|
|
try {
|
|
db.prepare(
|
|
"INSERT OR REPLACE INTO user_feature_permissions (user_id, feature, allowed) VALUES (?, ?, ?)",
|
|
).run(userId, feature, allowed ? 1 : 0);
|
|
invalidateFeaturePermCache(userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] setUserFeaturePermission error:", err);
|
|
return { success: false, error: err.message || "Failed to update feature permission" };
|
|
}
|
|
}
|
|
|
|
export function setUserFeaturePermissions(
|
|
userId: number,
|
|
permissions: Partial<Record<FeatureName, boolean>>,
|
|
): { success: boolean; error?: string } {
|
|
const stmt = db.prepare(
|
|
"INSERT OR REPLACE INTO user_feature_permissions (user_id, feature, allowed) VALUES (?, ?, ?)",
|
|
);
|
|
try {
|
|
const tx = db.transaction(() => {
|
|
for (const [feature, allowed] of Object.entries(permissions)) {
|
|
if (!ALL_FEATURES.includes(feature as FeatureName)) continue;
|
|
stmt.run(userId, feature, allowed ? 1 : 0);
|
|
}
|
|
});
|
|
tx();
|
|
invalidateFeaturePermCache(userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] setUserFeaturePermissions error:", err);
|
|
return { success: false, error: err.message || "Failed to update feature permissions" };
|
|
}
|
|
}
|
|
|
|
export function resetUserFeaturePermissions(
|
|
userId: number,
|
|
): { success: boolean; error?: string } {
|
|
try {
|
|
db.prepare("DELETE FROM user_feature_permissions WHERE user_id = ?").run(userId);
|
|
invalidateFeaturePermCache(userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] resetUserFeaturePermissions error:", err);
|
|
return { success: false, error: err.message || "Failed to reset feature permissions" };
|
|
}
|
|
}
|
|
|
|
export function validatePasswordPolicy(password: string): string | null {
|
|
const security = getConfig().security;
|
|
const minLength = Math.min(128, Math.max(6, Number(security.passwordMinLength) || 6));
|
|
|
|
if (!password || password.length < minLength) {
|
|
return `Password must be at least ${minLength} characters`;
|
|
}
|
|
|
|
if (security.passwordRequireUppercase && !/[A-Z]/.test(password)) {
|
|
return "Password must include at least one uppercase letter";
|
|
}
|
|
if (security.passwordRequireLowercase && !/[a-z]/.test(password)) {
|
|
return "Password must include at least one lowercase letter";
|
|
}
|
|
if (security.passwordRequireNumber && !/[0-9]/.test(password)) {
|
|
return "Password must include at least one number";
|
|
}
|
|
if (security.passwordRequireSymbol && !/[^A-Za-z0-9]/.test(password)) {
|
|
return "Password must include at least one symbol";
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
export async function createUser(
|
|
username: string,
|
|
password: string,
|
|
role: UserRole,
|
|
createdBy: string,
|
|
): Promise<{ success: boolean; error?: string; userId?: number }> {
|
|
if (!username || username.length < 3 || username.length > 32) {
|
|
return {
|
|
success: false,
|
|
error: "Username must be between 3 and 32 characters",
|
|
};
|
|
}
|
|
|
|
if (!/^[a-zA-Z0-9_-]+$/.test(username)) {
|
|
return {
|
|
success: false,
|
|
error:
|
|
"Username can only contain letters, numbers, hyphens, and underscores",
|
|
};
|
|
}
|
|
|
|
const policyError = validatePasswordPolicy(password);
|
|
if (policyError) {
|
|
return { success: false, error: policyError };
|
|
}
|
|
|
|
const existing = getUserByUsername(username);
|
|
if (existing) {
|
|
return { success: false, error: "Username already exists" };
|
|
}
|
|
|
|
try {
|
|
const passwordHash = await Bun.password.hash(password, {
|
|
algorithm: "bcrypt",
|
|
cost: 10,
|
|
});
|
|
|
|
const result = db
|
|
.prepare(
|
|
"INSERT INTO users (username, password_hash, role, created_at, created_by, client_scope, plugin_scope, can_build, can_upload_files) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
|
)
|
|
.run(username, passwordHash, role, Date.now(), createdBy, role === "admin" ? "all" : "none", role === "admin" ? "all" : "none", role === "admin" || role === "operator" ? 1 : 0, role === "admin" ? 1 : 0);
|
|
|
|
invalidateNotificationDeliveryCache();
|
|
|
|
return { success: true, userId: result.lastInsertRowid as number };
|
|
} catch (err: any) {
|
|
logger.error("[users] Create user error:", err);
|
|
return { success: false, error: err.message || "Failed to create user" };
|
|
}
|
|
}
|
|
|
|
export async function updateUserPassword(
|
|
userId: number,
|
|
newPassword: string,
|
|
): Promise<{ success: boolean; error?: string }> {
|
|
const policyError = validatePasswordPolicy(newPassword);
|
|
if (policyError) {
|
|
return { success: false, error: policyError };
|
|
}
|
|
|
|
try {
|
|
const passwordHash = await Bun.password.hash(newPassword, {
|
|
algorithm: "bcrypt",
|
|
cost: 10,
|
|
});
|
|
|
|
db.prepare(
|
|
"UPDATE users SET password_hash = ?, must_change_password = 0 WHERE id = ?",
|
|
).run(passwordHash, userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
console.error("[users] Update password error:", err);
|
|
return {
|
|
success: false,
|
|
error: err.message || "Failed to update password",
|
|
};
|
|
}
|
|
}
|
|
|
|
export function updateUserRole(
|
|
userId: number,
|
|
newRole: UserRole,
|
|
): { success: boolean; error?: string } {
|
|
try {
|
|
const nextScope: ClientAccessScope = newRole === "admin" ? "all" : "none";
|
|
const nextPluginScope: PluginAccessScope = newRole === "admin" ? "all" : "none";
|
|
db.prepare("UPDATE users SET role = ?, client_scope = ?, plugin_scope = ? WHERE id = ?").run(
|
|
newRole,
|
|
nextScope,
|
|
nextPluginScope,
|
|
userId,
|
|
);
|
|
invalidateUserAccessCache(userId);
|
|
invalidatePluginAccessCache(userId);
|
|
invalidateNotificationDeliveryCache();
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
console.error("[users] Update role error:", err);
|
|
return { success: false, error: err.message || "Failed to update role" };
|
|
}
|
|
}
|
|
|
|
export function deleteUser(userId: number): {
|
|
success: boolean;
|
|
error?: string;
|
|
} {
|
|
const admins = db
|
|
.prepare("SELECT COUNT(*) as count FROM users WHERE role = 'admin'")
|
|
.get() as { count: number };
|
|
const user = getUserById(userId);
|
|
|
|
if (user?.role === "admin" && admins.count <= 1) {
|
|
return { success: false, error: "Cannot delete the last admin user" };
|
|
}
|
|
|
|
try {
|
|
db.prepare("DELETE FROM users WHERE id = ?").run(userId);
|
|
invalidateUserAccessCache(userId);
|
|
invalidatePluginAccessCache(userId);
|
|
invalidateNotificationDeliveryCache();
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
console.error("[users] Delete user error:", err);
|
|
return { success: false, error: err.message || "Failed to delete user" };
|
|
}
|
|
}
|
|
|
|
export function updateLastLogin(userId: number): void {
|
|
db.prepare("UPDATE users SET last_login = ? WHERE id = ?").run(
|
|
Date.now(),
|
|
userId,
|
|
);
|
|
}
|
|
|
|
let _dummyHashPromise: Promise<string> | null = null;
|
|
function getDummyPasswordHash(): Promise<string> {
|
|
if (!_dummyHashPromise) {
|
|
_dummyHashPromise = Bun.password.hash("__overlord_dummy_hash_for_timing__", {
|
|
algorithm: "bcrypt",
|
|
cost: 10,
|
|
});
|
|
}
|
|
return _dummyHashPromise;
|
|
}
|
|
|
|
export async function verifyPassword(
|
|
username: string,
|
|
password: string,
|
|
): Promise<User | null> {
|
|
const user = getUserByUsername(username);
|
|
if (!user) {
|
|
try {
|
|
const dummy = await getDummyPasswordHash();
|
|
await Bun.password.verify(password, dummy);
|
|
} catch {
|
|
}
|
|
return null;
|
|
}
|
|
|
|
const isValid = await Bun.password.verify(password, user.password_hash);
|
|
if (!isValid) return null;
|
|
|
|
updateLastLogin(user.id);
|
|
return user;
|
|
}
|
|
|
|
export function canManageUsers(role: UserRole): boolean {
|
|
return role === "admin";
|
|
}
|
|
|
|
export function canControlClients(role: UserRole): boolean {
|
|
return role === "admin" || role === "operator";
|
|
}
|
|
|
|
export function canViewClients(role: UserRole): boolean {
|
|
return role === "admin";
|
|
}
|
|
|
|
export function canBuildClients(userId: number, role: UserRole): boolean {
|
|
if (role === "admin") return true;
|
|
const user = getUserById(userId);
|
|
return user ? user.can_build === 1 : false;
|
|
}
|
|
|
|
export function canViewAuditLogs(role: UserRole): boolean {
|
|
return role === "admin" || role === "operator";
|
|
}
|
|
|
|
export function canManageEnrollment(role: UserRole): boolean {
|
|
return role === "admin" || role === "operator";
|
|
}
|
|
|
|
export function hasPermission(role: UserRole, permission: string, userId?: number): boolean {
|
|
switch (permission) {
|
|
case "users:manage":
|
|
return canManageUsers(role);
|
|
case "clients:control":
|
|
return canControlClients(role);
|
|
case "clients:view":
|
|
return canViewClients(role);
|
|
case "clients:build":
|
|
if (userId !== undefined) return canBuildClients(userId, role);
|
|
return role === "admin" || role === "operator";
|
|
case "clients:enroll":
|
|
return canManageEnrollment(role);
|
|
case "audit:view":
|
|
return canViewAuditLogs(role);
|
|
case "chat:write":
|
|
if (userId !== undefined) return canChatWrite(userId, role);
|
|
return role === "admin" || role === "operator";
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
export function setUserCanBuild(
|
|
userId: number,
|
|
canBuild: boolean,
|
|
): { success: boolean; error?: string } {
|
|
try {
|
|
db.prepare("UPDATE users SET can_build = ? WHERE id = ?").run(canBuild ? 1 : 0, userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] setUserCanBuild error:", err);
|
|
return { success: false, error: err.message || "Failed to update build permission" };
|
|
}
|
|
}
|
|
|
|
export function canUploadFiles(userId: number, role: UserRole): boolean {
|
|
if (role === "admin") return true;
|
|
const user = getUserById(userId);
|
|
return user ? user.can_upload_files === 1 : false;
|
|
}
|
|
|
|
export function setUserCanUploadFiles(
|
|
userId: number,
|
|
canUpload: boolean,
|
|
): { success: boolean; error?: string } {
|
|
try {
|
|
db.prepare("UPDATE users SET can_upload_files = ? WHERE id = ?").run(canUpload ? 1 : 0, userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] setUserCanUploadFiles error:", err);
|
|
return { success: false, error: err.message || "Failed to update upload permission" };
|
|
}
|
|
}
|
|
|
|
export function canChatWrite(userId: number, role: UserRole): boolean {
|
|
if (role === "admin") return true;
|
|
const user = getUserById(userId);
|
|
if (!user) return false;
|
|
const chatWrite = (user as any).chat_write;
|
|
if (chatWrite === null || chatWrite === undefined) {
|
|
return role === "operator";
|
|
}
|
|
return chatWrite === 1;
|
|
}
|
|
|
|
export function setUserChatWrite(
|
|
userId: number,
|
|
canWrite: boolean | null,
|
|
): { success: boolean; error?: string } {
|
|
try {
|
|
db.prepare("UPDATE users SET chat_write = ? WHERE id = ?").run(canWrite === null ? null : (canWrite ? 1 : 0), userId);
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] setUserChatWrite error:", err);
|
|
return { success: false, error: err.message || "Failed to update chat write permission" };
|
|
}
|
|
}
|
|
|
|
export function setUserTelegramChatId(
|
|
userId: number,
|
|
chatId: string | null,
|
|
): { success: boolean; error?: string } {
|
|
try {
|
|
db.prepare("UPDATE users SET telegram_chat_id = ? WHERE id = ?").run(chatId, userId);
|
|
invalidateNotificationDeliveryCache();
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] setUserTelegramChatId error:", err);
|
|
return { success: false, error: err.message || "Failed to update Telegram chat ID" };
|
|
}
|
|
}
|
|
|
|
export function getUserTelegramChatId(userId: number): string | null {
|
|
const row = db
|
|
.prepare("SELECT telegram_chat_id FROM users WHERE id = ?")
|
|
.get(userId) as { telegram_chat_id?: string | null } | undefined;
|
|
return row?.telegram_chat_id || null;
|
|
}
|
|
|
|
export function getUsersWithTelegramChatId(): Array<{ id: number; username: string; role: UserRole; client_scope: ClientAccessScope; telegram_chat_id: string }> {
|
|
return db
|
|
.prepare(
|
|
"SELECT id, username, role, client_scope, telegram_chat_id FROM users WHERE telegram_chat_id IS NOT NULL AND telegram_chat_id != ''",
|
|
)
|
|
.all() as any[];
|
|
}
|
|
|
|
// ─── Per-user notification delivery settings ─────────────────────────────────
|
|
|
|
export interface UserNotificationSettings {
|
|
webhook_enabled: number;
|
|
webhook_url: string | null;
|
|
webhook_template: string | null;
|
|
telegram_enabled: number;
|
|
telegram_bot_token: string | null;
|
|
telegram_chat_id: string | null;
|
|
telegram_template: string | null;
|
|
client_event_webhook: number;
|
|
client_event_telegram: number;
|
|
client_event_push: number;
|
|
}
|
|
|
|
export function getUserNotificationSettings(userId: number): UserNotificationSettings | null {
|
|
const row = db
|
|
.prepare(
|
|
"SELECT webhook_enabled, webhook_url, webhook_template, telegram_enabled, telegram_bot_token, telegram_chat_id, telegram_template, client_event_webhook, client_event_telegram, client_event_push FROM users WHERE id = ?",
|
|
)
|
|
.get(userId) as UserNotificationSettings | undefined;
|
|
return row ?? null;
|
|
}
|
|
|
|
export function updateUserNotificationSettings(
|
|
userId: number,
|
|
settings: Partial<UserNotificationSettings>,
|
|
): { success: boolean; error?: string } {
|
|
const fields: string[] = [];
|
|
const values: any[] = [];
|
|
|
|
if ("webhook_enabled" in settings) {
|
|
fields.push("webhook_enabled = ?");
|
|
values.push(settings.webhook_enabled ? 1 : 0);
|
|
}
|
|
if ("webhook_url" in settings) {
|
|
fields.push("webhook_url = ?");
|
|
values.push(settings.webhook_url || null);
|
|
}
|
|
if ("webhook_template" in settings) {
|
|
fields.push("webhook_template = ?");
|
|
values.push(settings.webhook_template || null);
|
|
}
|
|
if ("telegram_enabled" in settings) {
|
|
fields.push("telegram_enabled = ?");
|
|
values.push(settings.telegram_enabled ? 1 : 0);
|
|
}
|
|
if ("telegram_bot_token" in settings) {
|
|
fields.push("telegram_bot_token = ?");
|
|
values.push(settings.telegram_bot_token || null);
|
|
}
|
|
if ("telegram_chat_id" in settings) {
|
|
fields.push("telegram_chat_id = ?");
|
|
values.push(settings.telegram_chat_id || null);
|
|
}
|
|
if ("telegram_template" in settings) {
|
|
fields.push("telegram_template = ?");
|
|
values.push(settings.telegram_template || null);
|
|
}
|
|
if ("client_event_webhook" in settings) {
|
|
fields.push("client_event_webhook = ?");
|
|
values.push(settings.client_event_webhook ? 1 : 0);
|
|
}
|
|
if ("client_event_telegram" in settings) {
|
|
fields.push("client_event_telegram = ?");
|
|
values.push(settings.client_event_telegram ? 1 : 0);
|
|
}
|
|
if ("client_event_push" in settings) {
|
|
fields.push("client_event_push = ?");
|
|
values.push(settings.client_event_push ? 1 : 0);
|
|
}
|
|
|
|
if (fields.length === 0) return { success: true };
|
|
|
|
try {
|
|
values.push(userId);
|
|
db.prepare(`UPDATE users SET ${fields.join(", ")} WHERE id = ?`).run(...values);
|
|
invalidateNotificationDeliveryCache();
|
|
return { success: true };
|
|
} catch (err: any) {
|
|
logger.error("[users] updateUserNotificationSettings error:", err);
|
|
return { success: false, error: err.message || "Failed to update notification settings" };
|
|
}
|
|
}
|
|
|
|
export interface UserDeliveryRow {
|
|
id: number;
|
|
username: string;
|
|
role: UserRole;
|
|
client_scope: ClientAccessScope;
|
|
webhook_enabled: number;
|
|
webhook_url: string | null;
|
|
webhook_template: string | null;
|
|
telegram_enabled: number;
|
|
telegram_bot_token: string | null;
|
|
telegram_chat_id: string | null;
|
|
telegram_template: string | null;
|
|
client_event_webhook: number;
|
|
client_event_telegram: number;
|
|
client_event_push: number;
|
|
}
|
|
|
|
export function getUsersForNotificationDelivery(): UserDeliveryRow[] {
|
|
if (notificationDeliveryCache) {
|
|
return notificationDeliveryCache;
|
|
}
|
|
|
|
notificationDeliveryCache = db
|
|
.prepare(
|
|
`SELECT id, username, role, client_scope,
|
|
webhook_enabled, webhook_url, webhook_template,
|
|
telegram_enabled, telegram_bot_token, telegram_chat_id, telegram_template,
|
|
client_event_webhook, client_event_telegram, client_event_push
|
|
FROM users
|
|
WHERE (webhook_enabled = 1 AND webhook_url IS NOT NULL AND webhook_url != '')
|
|
OR (telegram_enabled = 1 AND telegram_bot_token IS NOT NULL AND telegram_bot_token != ''
|
|
AND telegram_chat_id IS NOT NULL AND telegram_chat_id != '')`,
|
|
)
|
|
.all() as UserDeliveryRow[];
|
|
|
|
return notificationDeliveryCache;
|
|
}
|
|
|
|
export function getUsersForNotificationDeliveryByClient(clientId: string): UserDeliveryRow[] {
|
|
return getUsersForNotificationDelivery().filter((user) =>
|
|
canUserAccessClient(user.id, user.role, clientId),
|
|
);
|
|
}
|
|
|
|
|
|
export interface RegistrationKey {
|
|
id: number;
|
|
key: string;
|
|
label: string | null;
|
|
created_by: number;
|
|
created_at: number;
|
|
expires_at: number | null;
|
|
used_by: number | null;
|
|
used_at: number | null;
|
|
}
|
|
|
|
export interface PendingRegistration {
|
|
id: number;
|
|
username: string;
|
|
password_hash: string;
|
|
requested_at: number;
|
|
status: "pending" | "approved" | "denied";
|
|
reviewed_by: number | null;
|
|
reviewed_at: number | null;
|
|
key_used: number | null;
|
|
}
|
|
|
|
export function generateRegistrationKey(): string {
|
|
const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
|
|
const segments = 4;
|
|
const segmentLen = 5;
|
|
const parts: string[] = [];
|
|
for (let s = 0; s < segments; s++) {
|
|
let seg = "";
|
|
const bytes = new Uint8Array(segmentLen);
|
|
crypto.getRandomValues(bytes);
|
|
for (let i = 0; i < segmentLen; i++) {
|
|
seg += chars[bytes[i] % chars.length];
|
|
}
|
|
parts.push(seg);
|
|
}
|
|
return parts.join("-");
|
|
}
|
|
|
|
export function createRegistrationKeys(
|
|
count: number,
|
|
createdBy: number,
|
|
label?: string,
|
|
expiresInHours?: number,
|
|
): RegistrationKey[] {
|
|
const safeCount = Math.min(100, Math.max(1, count));
|
|
const now = Date.now();
|
|
const expiresAt = expiresInHours && expiresInHours > 0
|
|
? now + expiresInHours * 60 * 60 * 1000
|
|
: null;
|
|
const safeLabel = label ? String(label).slice(0, 128).trim() : null;
|
|
|
|
const stmt = db.prepare(
|
|
`INSERT INTO registration_keys ("key", label, created_by, created_at, expires_at) VALUES (?, ?, ?, ?, ?)`,
|
|
);
|
|
|
|
const keys: RegistrationKey[] = [];
|
|
const tx = db.transaction(() => {
|
|
for (let i = 0; i < safeCount; i++) {
|
|
const key = generateRegistrationKey();
|
|
const result = stmt.run(key, safeLabel, createdBy, now, expiresAt);
|
|
keys.push({
|
|
id: result.lastInsertRowid as number,
|
|
key,
|
|
label: safeLabel,
|
|
created_by: createdBy,
|
|
created_at: now,
|
|
expires_at: expiresAt,
|
|
used_by: null,
|
|
used_at: null,
|
|
});
|
|
}
|
|
});
|
|
tx();
|
|
return keys;
|
|
}
|
|
|
|
export function listRegistrationKeys(): RegistrationKey[] {
|
|
return db.prepare(
|
|
`SELECT id, "key", label, created_by, created_at, expires_at, used_by, used_at FROM registration_keys ORDER BY created_at DESC`,
|
|
).all() as RegistrationKey[];
|
|
}
|
|
|
|
export function getRegistrationKeyByValue(keyValue: string): RegistrationKey | null {
|
|
const row = db.prepare(
|
|
`SELECT id, "key", label, created_by, created_at, expires_at, used_by, used_at FROM registration_keys WHERE "key" = ?`,
|
|
).get(keyValue) as RegistrationKey | undefined;
|
|
return row || null;
|
|
}
|
|
|
|
export function markRegistrationKeyUsed(keyId: number, usedByUserId: number): void {
|
|
db.prepare(`UPDATE registration_keys SET used_by = ?, used_at = ? WHERE id = ?`).run(
|
|
usedByUserId, Date.now(), keyId,
|
|
);
|
|
}
|
|
|
|
|
|
export function claimRegistrationKey(
|
|
keyValue: string,
|
|
usedByUserId: number,
|
|
): { success: true; key: RegistrationKey } | { success: false; error: string } {
|
|
const tx = db.transaction(() => {
|
|
const row = db.prepare(
|
|
`SELECT id, "key", label, created_by, created_at, expires_at, used_by, used_at FROM registration_keys WHERE "key" = ?`,
|
|
).get(keyValue) as RegistrationKey | undefined;
|
|
|
|
if (!row) return { success: false as const, error: "Invalid registration key" };
|
|
if (row.used_by !== null) return { success: false as const, error: "This registration key has already been used" };
|
|
if (row.expires_at && row.expires_at < Date.now()) return { success: false as const, error: "This registration key has expired" };
|
|
|
|
db.prepare(`UPDATE registration_keys SET used_by = ?, used_at = ? WHERE id = ? AND used_by IS NULL`).run(
|
|
usedByUserId, Date.now(), row.id,
|
|
);
|
|
|
|
return { success: true as const, key: row };
|
|
});
|
|
return tx();
|
|
}
|
|
|
|
export function deleteRegistrationKey(keyId: number): boolean {
|
|
const result = db.prepare(`DELETE FROM registration_keys WHERE id = ?`).run(keyId);
|
|
return (result.changes as number) > 0;
|
|
}
|
|
|
|
export function createPendingRegistration(
|
|
username: string,
|
|
passwordHash: string,
|
|
keyUsed?: number,
|
|
): { success: boolean; id?: number; error?: string } {
|
|
try {
|
|
const result = db.prepare(
|
|
`INSERT INTO pending_registrations (username, password_hash, requested_at, status, key_used) VALUES (?, ?, ?, 'pending', ?)`,
|
|
).run(username, passwordHash, Date.now(), keyUsed || null);
|
|
return { success: true, id: result.lastInsertRowid as number };
|
|
} catch (err: any) {
|
|
if (err.message?.includes("UNIQUE constraint")) {
|
|
return { success: false, error: "A registration with this username is already pending" };
|
|
}
|
|
return { success: false, error: err.message || "Failed to create pending registration" };
|
|
}
|
|
}
|
|
|
|
export function listPendingRegistrations(): PendingRegistration[] {
|
|
return db.prepare(
|
|
`SELECT id, username, requested_at, status, reviewed_by, reviewed_at, key_used FROM pending_registrations WHERE status = 'pending' ORDER BY requested_at ASC`,
|
|
).all() as PendingRegistration[];
|
|
}
|
|
|
|
export function getPendingRegistration(id: number): PendingRegistration | null {
|
|
const row = db.prepare(
|
|
`SELECT * FROM pending_registrations WHERE id = ?`,
|
|
).get(id) as PendingRegistration | undefined;
|
|
return row || null;
|
|
}
|
|
|
|
export async function approvePendingRegistration(
|
|
pendingId: number,
|
|
reviewedBy: number,
|
|
defaultRole: UserRole,
|
|
): Promise<{ success: boolean; userId?: number; error?: string }> {
|
|
const pending = getPendingRegistration(pendingId);
|
|
if (!pending) return { success: false, error: "Pending registration not found" };
|
|
if (pending.status !== "pending") return { success: false, error: "Registration already reviewed" };
|
|
|
|
const existing = getUserByUsername(pending.username);
|
|
if (existing) return { success: false, error: "Username already exists" };
|
|
|
|
try {
|
|
const role = defaultRole === "viewer" ? "viewer" : "operator";
|
|
const result = db.prepare(
|
|
`INSERT INTO users (username, password_hash, role, created_at, created_by, client_scope, can_build, can_upload_files, registered_via) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
).run(
|
|
pending.username, pending.password_hash, role, Date.now(), "registration",
|
|
"allowlist", role === "operator" ? 1 : 0, 0, "approval",
|
|
);
|
|
|
|
db.prepare(
|
|
`UPDATE pending_registrations SET status = 'approved', reviewed_by = ?, reviewed_at = ? WHERE id = ?`,
|
|
).run(reviewedBy, Date.now(), pendingId);
|
|
|
|
invalidateNotificationDeliveryCache();
|
|
return { success: true, userId: result.lastInsertRowid as number };
|
|
} catch (err: any) {
|
|
logger.error("[users] approvePendingRegistration error:", err);
|
|
return { success: false, error: err.message || "Failed to approve registration" };
|
|
}
|
|
}
|
|
|
|
export function denyPendingRegistration(
|
|
pendingId: number,
|
|
reviewedBy: number,
|
|
): { success: boolean; error?: string } {
|
|
const pending = getPendingRegistration(pendingId);
|
|
if (!pending) return { success: false, error: "Pending registration not found" };
|
|
if (pending.status !== "pending") return { success: false, error: "Registration already reviewed" };
|
|
|
|
db.prepare(
|
|
`UPDATE pending_registrations SET status = 'denied', reviewed_by = ?, reviewed_at = ? WHERE id = ?`,
|
|
).run(reviewedBy, Date.now(), pendingId);
|
|
|
|
return { success: true };
|
|
}
|
|
|
|
export async function registerUser(
|
|
username: string,
|
|
password: string,
|
|
registeredVia: "open" | "key",
|
|
defaultRole: UserRole,
|
|
): Promise<{ success: boolean; error?: string; userId?: number }> {
|
|
if (!username || username.length < 3 || username.length > 32) {
|
|
return { success: false, error: "Username must be between 3 and 32 characters" };
|
|
}
|
|
if (!/^[a-zA-Z0-9_-]+$/.test(username)) {
|
|
return { success: false, error: "Username can only contain letters, numbers, hyphens, and underscores" };
|
|
}
|
|
|
|
const policyError = validatePasswordPolicy(password);
|
|
if (policyError) return { success: false, error: policyError };
|
|
|
|
const existing = getUserByUsername(username);
|
|
if (existing) return { success: false, error: "Username already exists" };
|
|
|
|
const pendingExisting = db.prepare(
|
|
`SELECT id FROM pending_registrations WHERE username = ? AND status = 'pending'`,
|
|
).get(username);
|
|
if (pendingExisting) return { success: false, error: "A registration with this username is already pending" };
|
|
|
|
try {
|
|
const passwordHash = await Bun.password.hash(password, { algorithm: "bcrypt", cost: 10 });
|
|
const role = defaultRole === "viewer" ? "viewer" : "operator";
|
|
const result = db.prepare(
|
|
`INSERT INTO users (username, password_hash, role, created_at, created_by, client_scope, can_build, can_upload_files, registered_via) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
).run(
|
|
username, passwordHash, role, Date.now(), "registration",
|
|
"allowlist", role === "operator" ? 1 : 0, 0, registeredVia,
|
|
);
|
|
|
|
invalidateNotificationDeliveryCache();
|
|
return { success: true, userId: result.lastInsertRowid as number };
|
|
} catch (err: any) {
|
|
if (err.message?.includes("UNIQUE constraint")) {
|
|
return { success: false, error: "Username already exists" };
|
|
}
|
|
logger.error("[users] registerUser error:", err);
|
|
return { success: false, error: err.message || "Failed to register user" };
|
|
}
|
|
}
|
|
|
|
export function getTotalUserCount(): number {
|
|
const row = db.prepare("SELECT COUNT(*) as count FROM users").get() as { count: number };
|
|
return row.count;
|
|
}
|