bloby-bot 0.17.2

package/worker/claude-auth.ts

@@ -0,0 +1,282 @@
+/**
+ * Claude OAuth PKCE flow for Anthropic subscription authentication.
+ * Adapted from CodeDeck's ClaudeOAuthService for server-side Node.js.
+ *
+ * User signs in at claude.ai, receives a code, pastes it back.
+ * Credentials stored in ~/.claude/.credentials.json + macOS Keychain.
+ */
+
+import crypto from 'crypto';
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { log } from '../shared/logger.js';
+
+const OAUTH_CONFIG = {
+  AUTHORIZE_URL: 'https://claude.ai/oauth/authorize',
+  TOKEN_URL: 'https://console.anthropic.com/v1/oauth/token',
+  REDIRECT_URI: 'https://console.anthropic.com/oauth/code/callback',
+  CLIENT_ID: '9d1c250a-e61b-44d9-88ed-5944d1962f5e',
+  SCOPES: 'org:create_api_key user:profile user:inference',
+};
+
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const CREDENTIALS_FILE = path.join(CLAUDE_DIR, '.credentials.json');
+
+let codeVerifier: string | null = null;
+
+/* ── Public API ── */
+
+export function startClaudeOAuth(): { success: boolean; authUrl?: string; error?: string } {
+  // Generate PKCE
+  codeVerifier = crypto.randomBytes(32).toString('base64url');
+  const codeChallenge = crypto.createHash('sha256').update(codeVerifier).digest('base64url');
+
+  const params = new URLSearchParams({
+    code: 'true',
+    client_id: OAUTH_CONFIG.CLIENT_ID,
+    response_type: 'code',
+    redirect_uri: OAUTH_CONFIG.REDIRECT_URI,
+    scope: OAUTH_CONFIG.SCOPES,
+    code_challenge: codeChallenge,
+    code_challenge_method: 'S256',
+    state: codeVerifier, // state = verifier (OpenClaw legacy flow)
+  });
+
+  const authUrl = `${OAUTH_CONFIG.AUTHORIZE_URL}?${params.toString()}`;
+  log.ok('Claude OAuth flow started');
+  return { success: true, authUrl };
+}
+
+export async function exchangeClaudeCode(codeInput: string): Promise<{ success: boolean; error?: string }> {
+  if (!codeVerifier) {
+    return { success: false, error: 'OAuth flow not started. Click "Authenticate" first.' };
+  }
+
+  // Parse code — might be "code#state" or just "code"
+  const parts = codeInput.trim().split('#');
+  const code = parts[0].trim();
+  const state = parts[1]?.trim() || codeVerifier;
+
+  if (!code) {
+    return { success: false, error: 'Invalid code. Please copy the full code from the page.' };
+  }
+
+  try {
+    // Token exchange uses JSON body (not form-urlencoded)
+    const payload = {
+      grant_type: 'authorization_code',
+      client_id: OAUTH_CONFIG.CLIENT_ID,
+      code,
+      state,
+      redirect_uri: OAUTH_CONFIG.REDIRECT_URI,
+      code_verifier: codeVerifier,
+    };
+
+    const response = await fetch(OAUTH_CONFIG.TOKEN_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      return { success: false, error: `Authentication failed (${response.status}). Please try again.` };
+    }
+
+    const tokens = await response.json();
+    storeCredentials(tokens);
+    codeVerifier = null;
+    return { success: true };
+  } catch (err: any) {
+    return { success: false, error: err.message };
+  }
+}
+
+export async function getClaudeAuthStatus(): Promise<{ authenticated: boolean; error?: string }> {
+  const oauth = readOAuthBlock();
+  if (!oauth) return { authenticated: false };
+
+  if (oauth.accessToken && oauth.expiresAt && Date.now() < oauth.expiresAt) {
+    return { authenticated: true };
+  }
+
+  // Token expired or missing — try refresh
+  if (oauth.refreshToken) {
+    const refreshed = await refreshClaudeToken(oauth.refreshToken);
+    if (refreshed) return { authenticated: true };
+  }
+
+  return { authenticated: false, error: 'Token expired' };
+}
+
+export function readClaudeAccessToken(): string | null {
+  const oauth = readOAuthBlock();
+  if (!oauth?.accessToken) return null;
+  if (oauth.expiresAt && Date.now() >= oauth.expiresAt) return null;
+  return oauth.accessToken;
+}
+
+/** Read a valid access token, refreshing if expired. Returns null if unavailable. */
+export async function getClaudeAccessToken(): Promise<string | null> {
+  const oauth = readOAuthBlock();
+  if (!oauth?.accessToken) return null;
+
+  // Token still valid
+  if (oauth.expiresAt && Date.now() < oauth.expiresAt) {
+    return oauth.accessToken;
+  }
+
+  // Try refresh
+  if (oauth.refreshToken) {
+    const refreshed = await refreshClaudeToken(oauth.refreshToken);
+    if (refreshed) {
+      // Re-read after refresh
+      const fresh = readOAuthBlock();
+      return fresh?.accessToken || null;
+    }
+  }
+
+  return null;
+}
+
+/* ── Helpers ── */
+
+/**
+ * Read the OAuth block from the most reliable source.
+ * On macOS: Keychain is the source of truth (Claude Code reads/writes there on refresh).
+ *           If Keychain has no valid entry, stale files are not trusted.
+ * On Linux/Windows: credentials file is the source of truth.
+ * Handles both formats:
+ *   - Claude Code format: { claudeAiOauth: { accessToken, refreshToken, expiresAt, ... } }
+ *   - Legacy flat format:  { accessToken, refreshToken, expiresAt }
+ */
+function readOAuthBlock(): { accessToken?: string; refreshToken?: string; expiresAt?: number } | null {
+  // macOS: Keychain is the source of truth
+  if (process.platform === 'darwin') {
+    try {
+      const result = execFileSync('security', [
+        'find-generic-password', '-s', 'Claude Code-credentials', '-w',
+      ], { stdio: ['pipe', 'pipe', 'pipe'] }).toString().trim();
+      const parsed = JSON.parse(result);
+      const oauth = parsed.claudeAiOauth || parsed;
+      if (oauth.accessToken) {
+        log.ok('Read credentials from macOS Keychain');
+        return oauth;
+      }
+    } catch {}
+    // On macOS, if Keychain has no valid entry, don't trust stale files
+    log.warn('No valid credentials in macOS Keychain');
+    return null;
+  }
+
+  // Linux/Windows: credentials file
+  try {
+    if (fs.existsSync(CREDENTIALS_FILE)) {
+      const creds = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, 'utf-8'));
+      const oauth = creds.claudeAiOauth || creds;
+      if (oauth.accessToken) return oauth;
+    }
+  } catch {}
+
+  return null;
+}
+
+/**
+ * Refresh an expired token using the refresh_token grant.
+ * Returns true if refresh succeeded and new credentials were stored.
+ */
+async function refreshClaudeToken(refreshToken: string): Promise<boolean> {
+  try {
+    log.ok('Attempting Claude token refresh...');
+    const response = await fetch(OAUTH_CONFIG.TOKEN_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        grant_type: 'refresh_token',
+        client_id: OAUTH_CONFIG.CLIENT_ID,
+        refresh_token: refreshToken,
+      }),
+    });
+
+    if (!response.ok) {
+      log.warn(`Claude token refresh failed: ${response.status}`);
+      return false;
+    }
+
+    const tokens = await response.json();
+    storeCredentials(tokens);
+    log.ok('Claude token refreshed successfully');
+    return true;
+  } catch (err: any) {
+    log.warn(`Claude token refresh error: ${err.message}`);
+    return false;
+  }
+}
+
+function storeCredentials(tokens: any): void {
+  if (!fs.existsSync(CLAUDE_DIR)) {
+    fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+  }
+
+  // Read existing file to preserve other fields
+  let fileData: Record<string, any> = {};
+  try {
+    if (fs.existsSync(CREDENTIALS_FILE)) {
+      fileData = JSON.parse(fs.readFileSync(CREDENTIALS_FILE, 'utf-8'));
+    }
+  } catch {}
+
+  // Build oauth block — merge with existing claudeAiOauth to preserve scopes etc.
+  const existing = fileData.claudeAiOauth || {};
+  const oauth: Record<string, any> = { ...existing };
+  oauth.accessToken = tokens.access_token;
+  if (tokens.refresh_token) oauth.refreshToken = tokens.refresh_token;
+  if (tokens.expires_in) {
+    oauth.expiresAt = Date.now() + (tokens.expires_in - 300) * 1000;
+  }
+
+  // Write in Claude Code's format
+  fileData.claudeAiOauth = oauth;
+  // Remove legacy flat keys if they exist
+  delete fileData.accessToken;
+  delete fileData.refreshToken;
+  delete fileData.expiresAt;
+
+  fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(fileData, null, 2), 'utf-8');
+  try { fs.chmodSync(CREDENTIALS_FILE, 0o600); } catch {}
+  log.ok('Claude credentials stored');
+
+  // macOS: also write to Keychain
+  if (process.platform === 'darwin') {
+    try {
+      const keychainValue = JSON.stringify({ claudeAiOauth: oauth });
+      try {
+        execFileSync('security', ['delete-generic-password', '-s', 'Claude Code-credentials'], {
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+      } catch {} // OK if entry doesn't exist
+      execFileSync('security', [
+        'add-generic-password',
+        '-s', 'Claude Code-credentials',
+        '-a', os.userInfo().username,
+        '-w', keychainValue,
+      ], { stdio: ['pipe', 'pipe', 'pipe'] });
+    } catch {}
+  }
+
+  // Legacy fallback (~/.claude.json)
+  try {
+    const legacyPath = path.join(os.homedir(), '.claude.json');
+    let legacyConfig: Record<string, any> = {};
+    try {
+      if (fs.existsSync(legacyPath)) {
+        legacyConfig = JSON.parse(fs.readFileSync(legacyPath, 'utf-8'));
+      }
+    } catch {}
+    legacyConfig.oauthAccessToken = tokens.access_token;
+    legacyConfig.hasCompletedOnboarding = true;
+    fs.writeFileSync(legacyPath, JSON.stringify(legacyConfig, null, 2), 'utf-8');
+    try { fs.chmodSync(legacyPath, 0o600); } catch {}
+  } catch {}
+}

package/worker/codex-auth.ts

@@ -0,0 +1,199 @@
+/**
+ * Codex OAuth PKCE flow for ChatGPT Plus/Pro subscription authentication.
+ * Adapted from CodeDeck's CodexOAuthService for server-side Node.js.
+ *
+ * Spins up a temporary HTTP server on port 1455 to capture the OAuth callback.
+ * Credentials are stored in ~/.codex/codedeck-auth.json.
+ */
+
+import crypto from 'crypto';
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { log } from '../shared/logger.js';
+
+const OAUTH_CONFIG = {
+  AUTHORIZE_URL: 'https://auth.openai.com/oauth/authorize',
+  TOKEN_URL: 'https://auth.openai.com/oauth/token',
+  REDIRECT_URI: 'http://localhost:1455/auth/callback',
+  CLIENT_ID: 'app_EMoamEEZ73f0CkXaXp7hrann',
+  SCOPES: 'openid profile email offline_access',
+  PORT: 1455,
+};
+
+const AUTH_DIR = path.join(os.homedir(), '.codex');
+const AUTH_FILE = path.join(AUTH_DIR, 'codedeck-auth.json');
+
+let codeVerifier: string | null = null;
+let oauthState: string | null = null;
+let callbackServer: http.Server | null = null;
+
+/* ── Helpers ── */
+
+function stopCallbackServer(): void {
+  if (callbackServer) {
+    try { callbackServer.close(); } catch {}
+    callbackServer = null;
+  }
+}
+
+function storeCredentials(tokens: any): void {
+  if (!fs.existsSync(AUTH_DIR)) {
+    fs.mkdirSync(AUTH_DIR, { recursive: true });
+  }
+
+  const credentials: Record<string, any> = {
+    access_token: tokens.access_token,
+    token_type: tokens.token_type || 'Bearer',
+  };
+
+  if (tokens.refresh_token) credentials.refresh_token = tokens.refresh_token;
+  if (tokens.id_token) credentials.id_token = tokens.id_token;
+  if (tokens.expires_in) {
+    credentials.expires_at = Date.now() + (tokens.expires_in - 300) * 1000;
+  }
+
+  // Decode JWT claims for account info
+  try {
+    const payload = JSON.parse(Buffer.from(tokens.access_token.split('.')[1], 'base64url').toString());
+    const authClaims = payload['https://api.openai.com/auth'] || {};
+    if (authClaims.chatgpt_account_id) credentials.chatgpt_account_id = authClaims.chatgpt_account_id;
+    if (authClaims.chatgpt_plan_type) credentials.chatgpt_plan_type = authClaims.chatgpt_plan_type;
+  } catch {
+    log.warn('Codex: failed to decode JWT claims');
+  }
+
+  fs.writeFileSync(AUTH_FILE, JSON.stringify(credentials, null, 2), 'utf-8');
+  try { fs.chmodSync(AUTH_FILE, 0o600); } catch {}
+  log.ok('Codex credentials stored');
+}
+
+async function exchangeCode(code: string): Promise<{ success: boolean; error?: string }> {
+  if (!codeVerifier) {
+    return { success: false, error: 'No code verifier — OAuth flow was not started.' };
+  }
+
+  try {
+    const payload = new URLSearchParams({
+      grant_type: 'authorization_code',
+      client_id: OAUTH_CONFIG.CLIENT_ID,
+      code,
+      redirect_uri: OAUTH_CONFIG.REDIRECT_URI,
+      code_verifier: codeVerifier,
+    });
+
+    const response = await fetch(OAUTH_CONFIG.TOKEN_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: payload.toString(),
+    });
+
+    if (!response.ok) {
+      return { success: false, error: `Authentication failed (${response.status}). Please try again.` };
+    }
+
+    const tokens = await response.json();
+    storeCredentials(tokens);
+    codeVerifier = null;
+    oauthState = null;
+    return { success: true };
+  } catch (err: any) {
+    return { success: false, error: err.message };
+  }
+}
+
+/* ── Public API ── */
+
+export function startCodexOAuth(): Promise<{ success: boolean; authUrl?: string; error?: string }> {
+  return new Promise((resolve) => {
+    stopCallbackServer();
+
+    // Generate PKCE
+    codeVerifier = crypto.randomBytes(32).toString('base64url');
+    const codeChallenge = crypto.createHash('sha256').update(codeVerifier).digest('base64url');
+    oauthState = crypto.randomUUID();
+
+    // Start local callback server
+    callbackServer = http.createServer((req, res) => {
+      if (!req.url?.startsWith('/auth/callback')) {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+
+      const url = new URL(req.url, `http://localhost:${OAUTH_CONFIG.PORT}`);
+      const code = url.searchParams.get('code');
+      const returnedState = url.searchParams.get('state');
+      const error = url.searchParams.get('error');
+
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      res.end(`<html><body style="font-family:sans-serif;text-align:center;padding:60px;background:#0a0a0a;color:#fff">
+        <h2>${error ? 'Authentication Failed' : 'Authenticated!'}</h2>
+        <p style="color:#888">${error || 'You can close this tab and return to Bloby.'}</p>
+      </body></html>`);
+
+      stopCallbackServer();
+
+      if (error || !code || returnedState !== oauthState) return;
+      exchangeCode(code);
+    });
+
+    callbackServer.listen(OAUTH_CONFIG.PORT, '127.0.0.1', () => {
+      log.ok(`Codex OAuth callback server on port ${OAUTH_CONFIG.PORT}`);
+
+      const params = new URLSearchParams({
+        response_type: 'code',
+        client_id: OAUTH_CONFIG.CLIENT_ID,
+        redirect_uri: OAUTH_CONFIG.REDIRECT_URI,
+        scope: OAUTH_CONFIG.SCOPES,
+        code_challenge: codeChallenge,
+        code_challenge_method: 'S256',
+        state: oauthState!,
+        id_token_add_organizations: 'true',
+        codex_cli_simplified_flow: 'true',
+      });
+
+      resolve({ success: true, authUrl: `${OAUTH_CONFIG.AUTHORIZE_URL}?${params.toString()}` });
+    });
+
+    callbackServer.on('error', (err: any) => {
+      const error = err.code === 'EADDRINUSE'
+        ? `Port ${OAUTH_CONFIG.PORT} is busy. Close other Codex instances.`
+        : err.message;
+      resolve({ success: false, error });
+    });
+  });
+}
+
+export function cancelCodexOAuth(): void {
+  stopCallbackServer();
+  codeVerifier = null;
+  oauthState = null;
+}
+
+export function getCodexAuthStatus(): { authenticated: boolean; plan?: string; error?: string } {
+  try {
+    if (!fs.existsSync(AUTH_FILE)) return { authenticated: false };
+    const creds = JSON.parse(fs.readFileSync(AUTH_FILE, 'utf-8'));
+    if (!creds.access_token) return { authenticated: false };
+    if (creds.expires_at && Date.now() >= creds.expires_at) {
+      return { authenticated: false, error: 'Token expired' };
+    }
+    return { authenticated: true, plan: creds.chatgpt_plan_type || 'plus' };
+  } catch (err: any) {
+    return { authenticated: false, error: err.message };
+  }
+}
+
+export function readCodexAccessToken(): string | null {
+  try {
+    if (!fs.existsSync(AUTH_FILE)) return null;
+    const creds = JSON.parse(fs.readFileSync(AUTH_FILE, 'utf-8'));
+    if (!creds.access_token) return null;
+    if (creds.expires_at && Date.now() >= creds.expires_at) return null;
+    return creds.access_token;
+  } catch {
+    return null;
+  }
+}

package/worker/db.ts

@@ -0,0 +1,198 @@
+import Database from 'better-sqlite3';
+import fs from 'fs';
+import { paths, DATA_DIR } from '../shared/paths.js';
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS conversations (
+  id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+  title TEXT,
+  model TEXT,
+  session_id TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+CREATE TABLE IF NOT EXISTS messages (
+  id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+  conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+  role TEXT NOT NULL CHECK (role IN ('user', 'assistant', 'system')),
+  content TEXT NOT NULL,
+  tokens_in INTEGER,
+  tokens_out INTEGER,
+  model TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+CREATE INDEX IF NOT EXISTS idx_msg_conv ON messages(conversation_id, created_at);
+CREATE TABLE IF NOT EXISTS settings (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+CREATE TABLE IF NOT EXISTS sessions (
+  token TEXT PRIMARY KEY,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  expires_at DATETIME NOT NULL
+);
+CREATE TABLE IF NOT EXISTS push_subscriptions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  endpoint TEXT NOT NULL UNIQUE,
+  keys_p256dh TEXT NOT NULL,
+  keys_auth TEXT NOT NULL,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+CREATE TABLE IF NOT EXISTS trusted_devices (
+  id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+  token TEXT NOT NULL UNIQUE,
+  label TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  expires_at DATETIME NOT NULL,
+  last_seen DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+CREATE INDEX IF NOT EXISTS idx_td_token ON trusted_devices(token);
+`;
+
+let db: Database.Database;
+
+export function initDb(): void {
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  db = new Database(paths.db);
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+  db.exec(SCHEMA);
+
+  // Migration: add session_id column if missing (existing DBs)
+  const cols = db.prepare("PRAGMA table_info(conversations)").all() as { name: string }[];
+  if (!cols.some((c) => c.name === 'session_id')) {
+    db.exec('ALTER TABLE conversations ADD COLUMN session_id TEXT');
+  }
+
+  // Migration: add audio_data column if missing (voice messages)
+  const msgCols = db.prepare("PRAGMA table_info(messages)").all() as { name: string }[];
+  if (!msgCols.some((c) => c.name === 'audio_data')) {
+    db.exec('ALTER TABLE messages ADD COLUMN audio_data TEXT');
+  }
+
+  // Migration: add attachments column if missing (persistent file attachments)
+  const msgCols2 = db.prepare("PRAGMA table_info(messages)").all() as { name: string }[];
+  if (!msgCols2.some((c) => c.name === 'attachments')) {
+    db.exec('ALTER TABLE messages ADD COLUMN attachments TEXT');
+  }
+}
+
+export function closeDb(): void { db?.close(); }
+
+// Conversations
+export function createConversation(title?: string, model?: string) {
+  return db.prepare('INSERT INTO conversations (title, model) VALUES (?, ?) RETURNING *').get(title ?? null, model ?? null) as any;
+}
+export function listConversations(limit = 50) {
+  return db.prepare('SELECT * FROM conversations ORDER BY updated_at DESC LIMIT ?').all(limit);
+}
+export function deleteConversation(id: string) {
+  db.prepare('DELETE FROM conversations WHERE id = ?').run(id);
+}
+
+// Messages
+export function addMessage(convId: string, role: string, content: string, meta?: { tokens_in?: number; tokens_out?: number; model?: string; audio_data?: string; attachments?: string }) {
+  const msg = db.prepare('INSERT INTO messages (conversation_id, role, content, tokens_in, tokens_out, model, audio_data, attachments) VALUES (?, ?, ?, ?, ?, ?, ?, ?) RETURNING *')
+    .get(convId, role, content, meta?.tokens_in ?? null, meta?.tokens_out ?? null, meta?.model ?? null, meta?.audio_data ?? null, meta?.attachments ?? null);
+  db.prepare('UPDATE conversations SET updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(convId);
+  return msg as any;
+}
+export function getMessages(convId: string) {
+  return db.prepare('SELECT * FROM messages WHERE conversation_id = ? ORDER BY created_at ASC').all(convId);
+}
+
+// Settings
+export function getSetting(key: string): string | undefined {
+  return (db.prepare('SELECT value FROM settings WHERE key = ?').get(key) as any)?.value;
+}
+export function setSetting(key: string, value: string) {
+  db.prepare('INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = CURRENT_TIMESTAMP').run(key, value);
+}
+export function getAllSettings() {
+  const rows = db.prepare('SELECT key, value FROM settings').all() as { key: string; value: string }[];
+  return Object.fromEntries(rows.map((r) => [r.key, r.value]));
+}
+
+// Auth sessions
+export function createSession(token: string, expiresAt: string) {
+  db.prepare('INSERT INTO sessions (token, expires_at) VALUES (?, ?)').run(token, expiresAt);
+}
+export function getSession(token: string): { token: string; created_at: string; expires_at: string } | undefined {
+  return db.prepare('SELECT * FROM sessions WHERE token = ? AND expires_at > datetime(\'now\')').get(token) as any;
+}
+export function deleteSession(token: string) {
+  db.prepare('DELETE FROM sessions WHERE token = ?').run(token);
+}
+export function deleteExpiredSessions() {
+  db.prepare('DELETE FROM sessions WHERE expires_at <= datetime(\'now\')').run();
+}
+
+// Session ID (Agent SDK)
+export function getSessionId(convId: string): string | null {
+  const row = db.prepare('SELECT session_id FROM conversations WHERE id = ?').get(convId) as any;
+  return row?.session_id ?? null;
+}
+export function saveSessionId(convId: string, sessionId: string): void {
+  db.prepare('UPDATE conversations SET session_id = ? WHERE id = ?').run(sessionId, convId);
+}
+
+// Push subscriptions
+export function addPushSubscription(endpoint: string, p256dh: string, auth: string) {
+  db.prepare(
+    `INSERT INTO push_subscriptions (endpoint, keys_p256dh, keys_auth) VALUES (?, ?, ?)
+     ON CONFLICT(endpoint) DO UPDATE SET keys_p256dh = excluded.keys_p256dh, keys_auth = excluded.keys_auth`
+  ).run(endpoint, p256dh, auth);
+}
+export function removePushSubscription(endpoint: string) {
+  db.prepare('DELETE FROM push_subscriptions WHERE endpoint = ?').run(endpoint);
+}
+export function getAllPushSubscriptions() {
+  return db.prepare('SELECT * FROM push_subscriptions').all() as { id: number; endpoint: string; keys_p256dh: string; keys_auth: string }[];
+}
+export function getPushSubscriptionByEndpoint(endpoint: string) {
+  return db.prepare('SELECT * FROM push_subscriptions WHERE endpoint = ?').get(endpoint) as { id: number; endpoint: string; keys_p256dh: string; keys_auth: string } | undefined;
+}
+
+// Trusted devices (2FA)
+export function createTrustedDevice(token: string, label: string, expiresAt: string) {
+  return db.prepare('INSERT INTO trusted_devices (token, label, expires_at) VALUES (?, ?, ?) RETURNING *').get(token, label, expiresAt) as any;
+}
+export function getTrustedDevice(token: string): { id: string; token: string; label: string; created_at: string; expires_at: string; last_seen: string } | undefined {
+  return db.prepare("SELECT * FROM trusted_devices WHERE token = ? AND expires_at > datetime('now')").get(token) as any;
+}
+export function updateDeviceLastSeen(token: string) {
+  db.prepare("UPDATE trusted_devices SET last_seen = CURRENT_TIMESTAMP WHERE token = ?").run(token);
+}
+export function listTrustedDevices() {
+  return db.prepare("SELECT id, label, last_seen, created_at FROM trusted_devices WHERE expires_at > datetime('now') ORDER BY last_seen DESC").all() as { id: string; label: string; last_seen: string; created_at: string }[];
+}
+export function deleteTrustedDevice(id: string) {
+  db.prepare('DELETE FROM trusted_devices WHERE id = ?').run(id);
+}
+export function deleteExpiredDevices() {
+  db.prepare("DELETE FROM trusted_devices WHERE expires_at <= datetime('now')").run();
+}
+export function deleteAllTrustedDevices() {
+  db.prepare('DELETE FROM trusted_devices').run();
+}
+
+// Recent messages (for context injection)
+export function getRecentMessages(convId: string, limit = 20) {
+  return db.prepare(`
+    SELECT * FROM (
+      SELECT * FROM messages WHERE conversation_id = ? ORDER BY created_at DESC LIMIT ?
+    ) sub ORDER BY created_at ASC
+  `).all(convId, limit);
+}
+
+// Cursor-based pagination: messages before a given ID
+export function getMessagesBefore(convId: string, beforeId: string, limit = 20) {
+  return db.prepare(`
+    SELECT * FROM (
+      SELECT * FROM messages
+      WHERE conversation_id = ? AND id < ?
+      ORDER BY id DESC LIMIT ?
+    ) sub ORDER BY id ASC
+  `).all(convId, beforeId, limit);
+}