@axhub/genie 0.1.8 → 0.2.0

package/server/database/db.js

@@ -1,469 +1,535 @@
-import Database from 'better-sqlite3';
+import crypto from 'crypto';
 import path from 'path';
 import fs from 'fs';
-import crypto from 'crypto';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-// ANSI color codes for terminal output
 const colors = {
-    reset: '\x1b[0m',
-    bright: '\x1b[1m',
-    cyan: '\x1b[36m',
-    dim: '\x1b[2m',
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  cyan: '\x1b[36m',
+  dim: '\x1b[2m',
 };
 
 const c = {
-    info: (text) => `${colors.cyan}${text}${colors.reset}`,
-    bright: (text) => `${colors.bright}${text}${colors.reset}`,
-    dim: (text) => `${colors.dim}${text}${colors.reset}`,
+  info: (text) => `${colors.cyan}${text}${colors.reset}`,
+  bright: (text) => `${colors.bright}${text}${colors.reset}`,
+  dim: (text) => `${colors.dim}${text}${colors.reset}`,
 };
 
-// Use DATABASE_PATH environment variable if set, otherwise use default location
-const DB_PATH = process.env.DATABASE_PATH || path.join(__dirname, 'auth.db');
-const INIT_SQL_PATH = path.join(__dirname, 'init.sql');
-
-// Ensure database directory exists if custom path is provided
-if (process.env.DATABASE_PATH) {
-  const dbDir = path.dirname(DB_PATH);
-  try {
-    if (!fs.existsSync(dbDir)) {
-      fs.mkdirSync(dbDir, { recursive: true });
-      console.log(`Created database directory: ${dbDir}`);
-    }
-  } catch (error) {
-    console.error(`Failed to create database directory ${dbDir}:`, error.message);
-    throw error;
-  }
-}
-
-// Create database connection
-const db = new Database(DB_PATH);
-
-// Show app installation path prominently
+const DATA_FILE_PATH = process.env.DATA_FILE_PATH || path.join(__dirname, 'state.json');
 const appInstallPath = path.join(__dirname, '../..');
-console.log('');
-console.log(c.dim('═'.repeat(60)));
-console.log(`${c.info('[INFO]')} App Installation: ${c.bright(appInstallPath)}`);
-console.log(`${c.info('[INFO]')} Database: ${c.dim(path.relative(appInstallPath, DB_PATH))}`);
-if (process.env.DATABASE_PATH) {
-  console.log(`       ${c.dim('(Using custom DATABASE_PATH from environment)')}`);
+
+const DEFAULT_STATE = Object.freeze({
+  meta: {
+    version: 1,
+    counters: {
+      userId: 0,
+      apiKeyId: 0,
+      credentialId: 0,
+      allowedUserId: 0,
+    },
+  },
+  users: [],
+  apiKeys: [],
+  credentials: [],
+  channelPlugins: [],
+  channelAllowedUsers: [],
+  channelSessions: [],
+});
+
+let stateCache = null;
+
+function cloneDefaultState() {
+  return JSON.parse(JSON.stringify(DEFAULT_STATE));
 }
-console.log(c.dim('═'.repeat(60)));
-console.log('');
-
-const tableExists = (tableName) => {
-  const row = db
-    .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
-    .get(tableName);
-  return !!row;
-};
 
-const getTableColumns = (tableName) => {
-  if (!tableExists(tableName)) {
-    return [];
+function ensureDataDirectory() {
+  const dataDir = path.dirname(DATA_FILE_PATH);
+  if (!fs.existsSync(dataDir)) {
+    fs.mkdirSync(dataDir, { recursive: true });
+    console.log(`Created data directory: ${dataDir}`);
   }
-  return db.prepare(`PRAGMA table_info(${tableName})`).all().map((col) => col.name);
-};
+}
 
-const hasIndex = (indexName) => {
-  const row = db
-    .prepare("SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?")
-    .get(indexName);
-  return !!row;
-};
+function normalizeState(rawState) {
+  const nextState = cloneDefaultState();
+  const source = rawState && typeof rawState === 'object' ? rawState : {};
+  const meta = source.meta && typeof source.meta === 'object' ? source.meta : {};
+  const counters = meta.counters && typeof meta.counters === 'object' ? meta.counters : {};
+
+  nextState.meta.version = Number.isFinite(Number(meta.version)) ? Number(meta.version) : 1;
+  nextState.meta.counters.userId = Number.isFinite(Number(counters.userId)) ? Number(counters.userId) : 0;
+  nextState.meta.counters.apiKeyId = Number.isFinite(Number(counters.apiKeyId)) ? Number(counters.apiKeyId) : 0;
+  nextState.meta.counters.credentialId = Number.isFinite(Number(counters.credentialId)) ? Number(counters.credentialId) : 0;
+  nextState.meta.counters.allowedUserId = Number.isFinite(Number(counters.allowedUserId)) ? Number(counters.allowedUserId) : 0;
+
+  nextState.users = Array.isArray(source.users) ? source.users : [];
+  nextState.apiKeys = Array.isArray(source.apiKeys) ? source.apiKeys : [];
+  nextState.credentials = Array.isArray(source.credentials) ? source.credentials : [];
+  nextState.channelPlugins = Array.isArray(source.channelPlugins) ? source.channelPlugins : [];
+  nextState.channelAllowedUsers = Array.isArray(source.channelAllowedUsers) ? source.channelAllowedUsers : [];
+  nextState.channelSessions = Array.isArray(source.channelSessions) ? source.channelSessions : [];
+
+  return nextState;
+}
 
-const ensureChannelAllowedUsersSchema = () => {
-  if (!tableExists('channel_allowed_users')) {
-    return;
-  }
+function persistStateSync(nextState) {
+  ensureDataDirectory();
+  const tempPath = `${DATA_FILE_PATH}.tmp`;
+  fs.writeFileSync(tempPath, `${JSON.stringify(nextState, null, 2)}\n`, 'utf8');
+  fs.renameSync(tempPath, DATA_FILE_PATH);
+  stateCache = nextState;
+}
 
-  const columns = getTableColumns('channel_allowed_users');
-  const tableSqlRow = db
-    .prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'channel_allowed_users'")
-    .get();
-  const tableSql = String(tableSqlRow?.sql || '');
-  const hasLegacyUserIdUnique = /user_id\s+TEXT\s+UNIQUE/i.test(tableSql);
-  const needsRebuild = !columns.includes('platform_type') || hasLegacyUserIdUnique;
-
-  if (needsRebuild) {
-    console.log('Running migration: Rebuilding channel_allowed_users with platform isolation');
-    const beforeCount = db.prepare('SELECT COUNT(*) AS count FROM channel_allowed_users').get()?.count || 0;
-
-    db.transaction(() => {
-      db.exec('ALTER TABLE channel_allowed_users RENAME TO channel_allowed_users_old');
-      db.exec(`
-        CREATE TABLE channel_allowed_users (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          platform_type TEXT NOT NULL DEFAULT 'lark',
-          user_id TEXT NOT NULL,
-          display_name TEXT,
-          note TEXT,
-          is_active BOOLEAN DEFAULT 1,
-          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-          updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-        )
-      `);
-
-      const oldColumns = getTableColumns('channel_allowed_users_old');
-      const hasOldPlatformType = oldColumns.includes('platform_type');
-
-      if (hasOldPlatformType) {
-        db.exec(`
-          INSERT INTO channel_allowed_users (id, platform_type, user_id, display_name, note, is_active, created_at, updated_at)
-          SELECT id, COALESCE(platform_type, 'lark'), user_id, display_name, note, is_active, created_at, updated_at
-          FROM channel_allowed_users_old
-        `);
-      } else {
-        db.exec(`
-          INSERT INTO channel_allowed_users (id, platform_type, user_id, display_name, note, is_active, created_at, updated_at)
-          SELECT id, 'lark', user_id, display_name, note, is_active, created_at, updated_at
-          FROM channel_allowed_users_old
-        `);
-      }
+function loadStateSync() {
+  ensureDataDirectory();
 
-      db.exec('DROP TABLE channel_allowed_users_old');
-    })();
+  if (stateCache) {
+    return stateCache;
+  }
 
-    const afterCount = db.prepare('SELECT COUNT(*) AS count FROM channel_allowed_users').get()?.count || 0;
-    console.log(`channel_allowed_users rows migrated: ${beforeCount} -> ${afterCount}`);
+  if (!fs.existsSync(DATA_FILE_PATH)) {
+    const initialState = cloneDefaultState();
+    persistStateSync(initialState);
+    return initialState;
   }
 
-  db.exec("UPDATE channel_allowed_users SET platform_type = 'lark' WHERE platform_type IS NULL OR TRIM(platform_type) = ''");
-  db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_channel_allowed_users_platform_user ON channel_allowed_users(platform_type, user_id)');
-  db.exec('CREATE INDEX IF NOT EXISTS idx_channel_allowed_users_user_id ON channel_allowed_users(user_id)');
-  db.exec('CREATE INDEX IF NOT EXISTS idx_channel_allowed_users_platform_type ON channel_allowed_users(platform_type)');
-  db.exec('CREATE INDEX IF NOT EXISTS idx_channel_allowed_users_active ON channel_allowed_users(is_active)');
-};
+  const raw = fs.readFileSync(DATA_FILE_PATH, 'utf8').trim();
+  const parsed = raw ? JSON.parse(raw) : {};
+  const normalized = normalizeState(parsed);
 
-const ensureChannelSessionsSchema = () => {
-  if (!tableExists('channel_sessions')) {
-    return;
+  if (JSON.stringify(parsed || {}) !== JSON.stringify(normalized)) {
+    persistStateSync(normalized);
+    return normalized;
   }
 
-  const columns = getTableColumns('channel_sessions');
-  if (!columns.includes('platform_type')) {
-    console.log('Running migration: Adding platform_type to channel_sessions');
-    db.exec("ALTER TABLE channel_sessions ADD COLUMN platform_type TEXT NOT NULL DEFAULT 'lark'");
-  }
+  stateCache = normalized;
+  return normalized;
+}
 
-  db.exec("UPDATE channel_sessions SET platform_type = 'lark' WHERE platform_type IS NULL OR TRIM(platform_type) = ''");
+function getStateSnapshot() {
+  return loadStateSync();
+}
 
-  if (hasIndex('idx_channel_sessions_unique')) {
-    db.exec('DROP INDEX IF EXISTS idx_channel_sessions_unique');
-  }
-  db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_channel_sessions_unique ON channel_sessions(platform_type, user_id, chat_id, backend)');
-  db.exec('CREATE INDEX IF NOT EXISTS idx_channel_sessions_platform_type ON channel_sessions(platform_type)');
-  db.exec('CREATE INDEX IF NOT EXISTS idx_channel_sessions_user_id ON channel_sessions(user_id)');
-};
+function updateStateSync(mutator) {
+  const currentState = getStateSnapshot();
+  const workingCopy = JSON.parse(JSON.stringify(currentState));
+  const result = mutator(workingCopy);
+  persistStateSync(workingCopy);
+  return result;
+}
 
-const runMigrations = () => {
-  try {
-    const tableInfo = db.prepare("PRAGMA table_info(users)").all();
-    const columnNames = tableInfo.map(col => col.name);
+function nextCounter(state, key) {
+  state.meta.counters[key] = Number(state.meta.counters[key] || 0) + 1;
+  return state.meta.counters[key];
+}
 
-    if (!columnNames.includes('git_name')) {
-      console.log('Running migration: Adding git_name column');
-      db.exec('ALTER TABLE users ADD COLUMN git_name TEXT');
-    }
+function nowIso() {
+  return new Date().toISOString();
+}
 
-    if (!columnNames.includes('git_email')) {
-      console.log('Running migration: Adding git_email column');
-      db.exec('ALTER TABLE users ADD COLUMN git_email TEXT');
-    }
+function sanitizeActiveUser(user) {
+  if (!user || user.is_active === false) {
+    return null;
+  }
 
-    if (!columnNames.includes('has_completed_onboarding')) {
-      console.log('Running migration: Adding has_completed_onboarding column');
-      db.exec('ALTER TABLE users ADD COLUMN has_completed_onboarding BOOLEAN DEFAULT 0');
-    }
+  return user;
+}
 
-    ensureChannelAllowedUsersSchema();
-    ensureChannelSessionsSchema();
+function toUserPublic(user) {
+  const activeUser = sanitizeActiveUser(user);
+  if (!activeUser) return null;
+  return {
+    id: activeUser.id,
+    username: activeUser.username,
+    created_at: activeUser.created_at,
+    last_login: activeUser.last_login,
+  };
+}
 
-    console.log('Database migrations completed successfully');
-  } catch (error) {
-    console.error('Error running migrations:', error.message);
-    throw error;
-  }
-};
+function findActiveUserById(state, userId) {
+  return sanitizeActiveUser(state.users.find((user) => user.id === userId));
+}
 
-// Initialize database with schema
-const initializeDatabase = async () => {
-  try {
-    const initSQL = fs.readFileSync(INIT_SQL_PATH, 'utf8');
-    db.exec(initSQL);
-    console.log('Database initialized successfully');
-    runMigrations();
-  } catch (error) {
-    console.error('Error initializing database:', error.message);
-    throw error;
-  }
-};
+function findActiveUserByUsername(state, username) {
+  return sanitizeActiveUser(state.users.find((user) => user.username === username));
+}
 
-// User database operations
 const userDb = {
-  // Check if any users exist
-  hasUsers: () => {
-    try {
-      const row = db.prepare('SELECT COUNT(*) as count FROM users').get();
-      return row.count > 0;
-    } catch (err) {
-      throw err;
-    }
-  },
+  hasUsers: () => getStateSnapshot().users.some((user) => user.is_active !== false),
 
-  // Create a new user
-  createUser: (username, passwordHash) => {
-    try {
-      const stmt = db.prepare('INSERT INTO users (username, password_hash) VALUES (?, ?)');
-      const result = stmt.run(username, passwordHash);
-      return { id: result.lastInsertRowid, username };
-    } catch (err) {
-      throw err;
+  registerUser: (username, passwordHash) => updateStateSync((state) => {
+    if (state.users.some((user) => user.is_active !== false)) {
+      const error = new Error('User already exists. This is a single-user system.');
+      error.code = 'USER_EXISTS';
+      throw error;
     }
-  },
 
-  // Get user by username
-  getUserByUsername: (username) => {
-    try {
-      const row = db.prepare('SELECT * FROM users WHERE username = ? AND is_active = 1').get(username);
-      return row;
-    } catch (err) {
-      throw err;
+    if (state.users.some((user) => user.username === username)) {
+      const error = new Error('Username already exists');
+      error.code = 'USERNAME_EXISTS';
+      throw error;
     }
-  },
 
-  // Update last login time
-  updateLastLogin: (userId) => {
-    try {
-      db.prepare('UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE id = ?').run(userId);
-    } catch (err) {
-      throw err;
+    const timestamp = nowIso();
+    const user = {
+      id: nextCounter(state, 'userId'),
+      username,
+      password_hash: passwordHash,
+      created_at: timestamp,
+      last_login: timestamp,
+      is_active: true,
+      git_name: null,
+      git_email: null,
+      has_completed_onboarding: false,
+    };
+
+    state.users.push(user);
+    return { id: user.id, username: user.username };
+  }),
+
+  createUser: (username, passwordHash) => updateStateSync((state) => {
+    if (state.users.some((user) => user.username === username)) {
+      const error = new Error('Username already exists');
+      error.code = 'USERNAME_EXISTS';
+      throw error;
     }
-  },
 
-  // Get user by ID
-  getUserById: (userId) => {
-    try {
-      const row = db.prepare('SELECT id, username, created_at, last_login FROM users WHERE id = ? AND is_active = 1').get(userId);
-      return row;
-    } catch (err) {
-      throw err;
+    const user = {
+      id: nextCounter(state, 'userId'),
+      username,
+      password_hash: passwordHash,
+      created_at: nowIso(),
+      last_login: null,
+      is_active: true,
+      git_name: null,
+      git_email: null,
+      has_completed_onboarding: false,
+    };
+    state.users.push(user);
+    return { id: user.id, username: user.username };
+  }),
+
+  getUserByUsername: (username) => findActiveUserByUsername(getStateSnapshot(), username) || null,
+
+  updateLastLogin: (userId) => updateStateSync((state) => {
+    const user = findActiveUserById(state, userId);
+    if (user) {
+      user.last_login = nowIso();
     }
-  },
+  }),
+
+  getUserById: (userId) => toUserPublic(findActiveUserById(getStateSnapshot(), userId)),
 
   getFirstUser: () => {
-    try {
-      const row = db.prepare('SELECT id, username, created_at, last_login FROM users WHERE is_active = 1 LIMIT 1').get();
-      return row;
-    } catch (err) {
-      throw err;
-    }
+    const user = getStateSnapshot().users.find((entry) => entry.is_active !== false);
+    return toUserPublic(user);
   },
 
-  updateGitConfig: (userId, gitName, gitEmail) => {
-    try {
-      const stmt = db.prepare('UPDATE users SET git_name = ?, git_email = ? WHERE id = ?');
-      stmt.run(gitName, gitEmail, userId);
-    } catch (err) {
-      throw err;
-    }
-  },
+  updateGitConfig: (userId, gitName, gitEmail) => updateStateSync((state) => {
+    const user = findActiveUserById(state, userId);
+    if (!user) return;
+    user.git_name = gitName || null;
+    user.git_email = gitEmail || null;
+  }),
 
   getGitConfig: (userId) => {
-    try {
-      const row = db.prepare('SELECT git_name, git_email FROM users WHERE id = ?').get(userId);
-      return row;
-    } catch (err) {
-      throw err;
+    const user = findActiveUserById(getStateSnapshot(), userId);
+    if (!user) {
+      return null;
     }
+    return {
+      git_name: user.git_name || null,
+      git_email: user.git_email || null,
+    };
   },
 
-  completeOnboarding: (userId) => {
-    try {
-      const stmt = db.prepare('UPDATE users SET has_completed_onboarding = 1 WHERE id = ?');
-      stmt.run(userId);
-    } catch (err) {
-      throw err;
+  completeOnboarding: (userId) => updateStateSync((state) => {
+    const user = findActiveUserById(state, userId);
+    if (user) {
+      user.has_completed_onboarding = true;
     }
-  },
+  }),
 
   hasCompletedOnboarding: (userId) => {
-    try {
-      const row = db.prepare('SELECT has_completed_onboarding FROM users WHERE id = ?').get(userId);
-      return row?.has_completed_onboarding === 1;
-    } catch (err) {
-      throw err;
-    }
-  }
+    const user = findActiveUserById(getStateSnapshot(), userId);
+    return !!user?.has_completed_onboarding;
+  },
 };
 
-// API Keys database operations
 const apiKeysDb = {
-  // Generate a new API key
-  generateApiKey: () => {
-    return 'ck_' + crypto.randomBytes(32).toString('hex');
-  },
-
-  // Create a new API key
-  createApiKey: (userId, keyName) => {
-    try {
-      const apiKey = apiKeysDb.generateApiKey();
-      const stmt = db.prepare('INSERT INTO api_keys (user_id, key_name, api_key) VALUES (?, ?, ?)');
-      const result = stmt.run(userId, keyName, apiKey);
-      return { id: result.lastInsertRowid, keyName, apiKey };
-    } catch (err) {
-      throw err;
+  generateApiKey: () => `ck_${crypto.randomBytes(32).toString('hex')}`,
+
+  createApiKey: (userId, keyName) => updateStateSync((state) => {
+    const timestamp = nowIso();
+    const entry = {
+      id: nextCounter(state, 'apiKeyId'),
+      user_id: userId,
+      key_name: keyName,
+      api_key: apiKeysDb.generateApiKey(),
+      created_at: timestamp,
+      last_used: null,
+      is_active: true,
+    };
+    state.apiKeys.push(entry);
+    return { id: entry.id, keyName: entry.key_name, apiKey: entry.api_key };
+  }),
+
+  getApiKeys: (userId) => getStateSnapshot().apiKeys
+    .filter((entry) => entry.user_id === userId)
+    .sort((left, right) => String(right.created_at).localeCompare(String(left.created_at)))
+    .map((entry) => ({ ...entry })),
+
+  validateApiKey: (apiKey) => updateStateSync((state) => {
+    const entry = state.apiKeys.find((item) => item.api_key === apiKey && item.is_active !== false);
+    if (!entry) {
+      return null;
     }
-  },
 
-  // Get all API keys for a user
-  getApiKeys: (userId) => {
-    try {
-      const rows = db.prepare('SELECT id, key_name, api_key, created_at, last_used, is_active FROM api_keys WHERE user_id = ? ORDER BY created_at DESC').all(userId);
-      return rows;
-    } catch (err) {
-      throw err;
+    const user = findActiveUserById(state, entry.user_id);
+    if (!user) {
+      return null;
     }
-  },
 
-  // Validate API key and get user
-  validateApiKey: (apiKey) => {
-    try {
-      const row = db.prepare(`
-        SELECT u.id, u.username, ak.id as api_key_id
-        FROM api_keys ak
-        JOIN users u ON ak.user_id = u.id
-        WHERE ak.api_key = ? AND ak.is_active = 1 AND u.is_active = 1
-      `).get(apiKey);
-
-      if (row) {
-        // Update last_used timestamp
-        db.prepare('UPDATE api_keys SET last_used = CURRENT_TIMESTAMP WHERE id = ?').run(row.api_key_id);
-      }
+    entry.last_used = nowIso();
 
-      return row;
-    } catch (err) {
-      throw err;
-    }
-  },
+    return {
+      id: user.id,
+      username: user.username,
+      api_key_id: entry.id,
+    };
+  }),
 
-  // Delete an API key
-  deleteApiKey: (userId, apiKeyId) => {
-    try {
-      const stmt = db.prepare('DELETE FROM api_keys WHERE id = ? AND user_id = ?');
-      const result = stmt.run(apiKeyId, userId);
-      return result.changes > 0;
-    } catch (err) {
-      throw err;
+  deleteApiKey: (userId, apiKeyId) => updateStateSync((state) => {
+    const index = state.apiKeys.findIndex((entry) => entry.id === apiKeyId && entry.user_id === userId);
+    if (index < 0) {
+      return false;
     }
-  },
-
-  // Toggle API key active status
-  toggleApiKey: (userId, apiKeyId, isActive) => {
-    try {
-      const stmt = db.prepare('UPDATE api_keys SET is_active = ? WHERE id = ? AND user_id = ?');
-      const result = stmt.run(isActive ? 1 : 0, apiKeyId, userId);
-      return result.changes > 0;
-    } catch (err) {
-      throw err;
+    state.apiKeys.splice(index, 1);
+    return true;
+  }),
+
+  toggleApiKey: (userId, apiKeyId, isActive) => updateStateSync((state) => {
+    const entry = state.apiKeys.find((item) => item.id === apiKeyId && item.user_id === userId);
+    if (!entry) {
+      return false;
     }
-  }
+    entry.is_active = !!isActive;
+    return true;
+  }),
 };
 
-// User credentials database operations (for GitHub tokens, GitLab tokens, etc.)
 const credentialsDb = {
-  // Create a new credential
-  createCredential: (userId, credentialName, credentialType, credentialValue, description = null) => {
-    try {
-      const stmt = db.prepare('INSERT INTO user_credentials (user_id, credential_name, credential_type, credential_value, description) VALUES (?, ?, ?, ?, ?)');
-      const result = stmt.run(userId, credentialName, credentialType, credentialValue, description);
-      return { id: result.lastInsertRowid, credentialName, credentialType };
-    } catch (err) {
-      throw err;
-    }
+  createCredential: (userId, credentialName, credentialType, credentialValue, description = null) => updateStateSync((state) => {
+    const entry = {
+      id: nextCounter(state, 'credentialId'),
+      user_id: userId,
+      credential_name: credentialName,
+      credential_type: credentialType,
+      credential_value: credentialValue,
+      description,
+      created_at: nowIso(),
+      is_active: true,
+    };
+    state.credentials.push(entry);
+    return { id: entry.id, credentialName: entry.credential_name, credentialType: entry.credential_type };
+  }),
+
+  getCredentials: (userId, credentialType = null) => getStateSnapshot().credentials
+    .filter((entry) => entry.user_id === userId && (!credentialType || entry.credential_type === credentialType))
+    .sort((left, right) => String(right.created_at).localeCompare(String(left.created_at)))
+    .map(({ credential_value, ...rest }) => ({ ...rest })),
+
+  getActiveCredential: (userId, credentialType) => {
+    const match = getStateSnapshot().credentials
+      .filter((entry) => entry.user_id === userId && entry.credential_type === credentialType && entry.is_active !== false)
+      .sort((left, right) => String(right.created_at).localeCompare(String(left.created_at)))[0];
+    return match?.credential_value || null;
   },
 
-  // Get all credentials for a user, optionally filtered by type
-  getCredentials: (userId, credentialType = null) => {
-    try {
-      let query = 'SELECT id, credential_name, credential_type, description, created_at, is_active FROM user_credentials WHERE user_id = ?';
-      const params = [userId];
+  getCredentialById: (userId, credentialId, credentialType = null) => {
+    const entry = getStateSnapshot().credentials.find((item) => (
+      item.id === credentialId
+      && item.user_id === userId
+      && item.is_active !== false
+      && (!credentialType || item.credential_type === credentialType)
+    ));
+    return entry ? { ...entry } : null;
+  },
 
-      if (credentialType) {
-        query += ' AND credential_type = ?';
-        params.push(credentialType);
-      }
+  deleteCredential: (userId, credentialId) => updateStateSync((state) => {
+    const index = state.credentials.findIndex((entry) => entry.id === credentialId && entry.user_id === userId);
+    if (index < 0) {
+      return false;
+    }
+    state.credentials.splice(index, 1);
+    return true;
+  }),
+
+  toggleCredential: (userId, credentialId, isActive) => updateStateSync((state) => {
+    const entry = state.credentials.find((item) => item.id === credentialId && item.user_id === userId);
+    if (!entry) {
+      return false;
+    }
+    entry.is_active = !!isActive;
+    return true;
+  }),
+};
 
-      query += ' ORDER BY created_at DESC';
+const githubTokensDb = {
+  createGithubToken: (userId, tokenName, githubToken, description = null) => credentialsDb.createCredential(userId, tokenName, 'github_token', githubToken, description),
+  getGithubTokens: (userId) => credentialsDb.getCredentials(userId, 'github_token'),
+  getActiveGithubToken: (userId) => credentialsDb.getActiveCredential(userId, 'github_token'),
+  getGithubTokenById: (userId, tokenId) => credentialsDb.getCredentialById(userId, tokenId, 'github_token'),
+  deleteGithubToken: (userId, tokenId) => credentialsDb.deleteCredential(userId, tokenId),
+  toggleGithubToken: (userId, tokenId, isActive) => credentialsDb.toggleCredential(userId, tokenId, isActive),
+};
 
-      const rows = db.prepare(query).all(...params);
-      return rows;
-    } catch (err) {
-      throw err;
-    }
+const channelDb = {
+  getPlugin(pluginId) {
+    return getStateSnapshot().channelPlugins.find((entry) => entry.id === pluginId) || null;
   },
 
-  // Get active credential value for a user by type (returns most recent active)
-  getActiveCredential: (userId, credentialType) => {
-    try {
-      const row = db.prepare('SELECT credential_value FROM user_credentials WHERE user_id = ? AND credential_type = ? AND is_active = 1 ORDER BY created_at DESC LIMIT 1').get(userId, credentialType);
-      return row?.credential_value || null;
-    } catch (err) {
-      throw err;
-    }
+  upsertPlugin(plugin) {
+    return updateStateSync((state) => {
+      const index = state.channelPlugins.findIndex((entry) => entry.id === plugin.id);
+      if (index >= 0) {
+        state.channelPlugins[index] = { ...state.channelPlugins[index], ...plugin };
+      } else {
+        state.channelPlugins.push({ ...plugin });
+      }
+      return { ...state.channelPlugins.find((entry) => entry.id === plugin.id) };
+    });
   },
 
-  // Delete a credential
-  deleteCredential: (userId, credentialId) => {
-    try {
-      const stmt = db.prepare('DELETE FROM user_credentials WHERE id = ? AND user_id = ?');
-      const result = stmt.run(credentialId, userId);
-      return result.changes > 0;
-    } catch (err) {
-      throw err;
-    }
+  listAllowedUsers(platform) {
+    return getStateSnapshot().channelAllowedUsers
+      .filter((entry) => entry.platform_type === platform)
+      .sort((left, right) => String(right.created_at).localeCompare(String(left.created_at)))
+      .map((entry) => ({ ...entry }));
   },
 
-  // Toggle credential active status
-  toggleCredential: (userId, credentialId, isActive) => {
-    try {
-      const stmt = db.prepare('UPDATE user_credentials SET is_active = ? WHERE id = ? AND user_id = ?');
-      const result = stmt.run(isActive ? 1 : 0, credentialId, userId);
-      return result.changes > 0;
-    } catch (err) {
-      throw err;
-    }
-  }
-};
+  addAllowedUser(platform, { userId, displayName = null, note = null }) {
+    return updateStateSync((state) => {
+      const duplicate = state.channelAllowedUsers.find((entry) => entry.platform_type === platform && entry.user_id === userId);
+      if (duplicate) {
+        const error = new Error('Allowed user already exists');
+        error.code = 'CHANNEL_ALLOWED_USER_EXISTS';
+        throw error;
+      }
 
-// Backward compatibility - keep old names pointing to new system
-const githubTokensDb = {
-  createGithubToken: (userId, tokenName, githubToken, description = null) => {
-    return credentialsDb.createCredential(userId, tokenName, 'github_token', githubToken, description);
+      const timestamp = nowIso();
+      const entry = {
+        id: nextCounter(state, 'allowedUserId'),
+        platform_type: platform,
+        user_id: userId,
+        display_name: displayName,
+        note,
+        is_active: true,
+        created_at: timestamp,
+        updated_at: timestamp,
+      };
+      state.channelAllowedUsers.push(entry);
+      return { ...entry };
+    });
   },
-  getGithubTokens: (userId) => {
-    return credentialsDb.getCredentials(userId, 'github_token');
+
+  removeAllowedUser(platform, id) {
+    return updateStateSync((state) => {
+      const index = state.channelAllowedUsers.findIndex((entry) => entry.platform_type === platform && entry.id === id);
+      if (index < 0) return false;
+      state.channelAllowedUsers.splice(index, 1);
+      return true;
+    });
   },
-  getActiveGithubToken: (userId) => {
-    return credentialsDb.getActiveCredential(userId, 'github_token');
+
+  toggleAllowedUser(platform, id, isActive) {
+    return updateStateSync((state) => {
+      const entry = state.channelAllowedUsers.find((item) => item.platform_type === platform && item.id === id);
+      if (!entry) return false;
+      entry.is_active = !!isActive;
+      entry.updated_at = nowIso();
+      return true;
+    });
   },
-  deleteGithubToken: (userId, tokenId) => {
-    return credentialsDb.deleteCredential(userId, tokenId);
+
+  isAllowedUser(platform, userId) {
+    return !!getStateSnapshot().channelAllowedUsers.find((entry) => entry.platform_type === platform && entry.user_id === userId && entry.is_active !== false);
+  },
+
+  getChannelSession({ platform, userId, chatId, backend }) {
+    const entry = getStateSnapshot().channelSessions.find((item) => (
+      item.platform_type === platform
+      && item.user_id === userId
+      && item.chat_id === chatId
+      && item.backend === backend
+    ));
+    return entry ? { ...entry } : null;
+  },
+
+  upsertChannelSession({ platform, userId, chatId, backend, providerSessionId, projectPath }) {
+    return updateStateSync((state) => {
+      const timestamp = nowIso();
+      const existing = state.channelSessions.find((item) => (
+        item.platform_type === platform
+        && item.user_id === userId
+        && item.chat_id === chatId
+        && item.backend === backend
+      ));
+
+      if (existing) {
+        existing.provider_session_id = providerSessionId || null;
+        existing.project_path = projectPath || null;
+        existing.updated_at = timestamp;
+        return { ...existing };
+      }
+
+      const entry = {
+        id: crypto.randomUUID(),
+        platform_type: platform,
+        user_id: userId,
+        chat_id: chatId,
+        backend,
+        provider_session_id: providerSessionId || null,
+        project_path: projectPath || null,
+        updated_at: timestamp,
+      };
+      state.channelSessions.push(entry);
+      return { ...entry };
+    });
   },
-  toggleGithubToken: (userId, tokenId, isActive) => {
-    return credentialsDb.toggleCredential(userId, tokenId, isActive);
-  }
 };
 
+async function initializeDatabase() {
+  const state = getStateSnapshot();
+
+  console.log('');
+  console.log(c.dim('═'.repeat(60)));
+  console.log(`${c.info('[INFO]')} App Installation: ${c.bright(appInstallPath)}`);
+  console.log(`${c.info('[INFO]')} Data File: ${c.dim(path.relative(appInstallPath, DATA_FILE_PATH))}`);
+  if (process.env.DATA_FILE_PATH) {
+    console.log(`       ${c.dim('(Using custom DATA_FILE_PATH from environment)')}`);
+  }
+  console.log(c.dim('═'.repeat(60)));
+  console.log('');
+  console.log('Data file initialized successfully');
+  return state;
+}
+
+function getDataFilePath() {
+  return DATA_FILE_PATH;
+}
+
 export {
-  db,
   initializeDatabase,
+  getDataFilePath,
   userDb,
   apiKeysDb,
   credentialsDb,
-  githubTokensDb // Backward compatibility
+  githubTokensDb,
+  channelDb,
 };