kokoirc 0.2.0

package/src/core/storage/db.ts

@@ -0,0 +1,107 @@
+import { Database } from "bun:sqlite"
+import { LOG_DB_PATH } from "@/core/constants"
+import type { LoggingConfig } from "./types"
+
+let db: Database | null = null
+
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS messages (
+    id        INTEGER PRIMARY KEY AUTOINCREMENT,
+    msg_id    TEXT,
+    network   TEXT NOT NULL,
+    buffer    TEXT NOT NULL,
+    timestamp INTEGER NOT NULL,
+    type      TEXT NOT NULL,
+    nick      TEXT,
+    text      TEXT NOT NULL,
+    highlight INTEGER DEFAULT 0,
+    iv        BLOB
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_messages_lookup ON messages(network, buffer, timestamp);
+  CREATE INDEX IF NOT EXISTS idx_messages_time ON messages(timestamp);
+  CREATE INDEX IF NOT EXISTS idx_messages_msg_id ON messages(msg_id);
+
+  CREATE TABLE IF NOT EXISTS read_markers (
+    network    TEXT NOT NULL,
+    buffer     TEXT NOT NULL,
+    client     TEXT NOT NULL,
+    last_read  INTEGER NOT NULL,
+    PRIMARY KEY (network, buffer, client)
+  );
+`
+
+const MIGRATION_ADD_MSG_ID = `
+  ALTER TABLE messages ADD COLUMN msg_id TEXT;
+  CREATE INDEX IF NOT EXISTS idx_messages_msg_id ON messages(msg_id);
+`
+
+const MIGRATION_ADD_READ_MARKERS = `
+  CREATE TABLE IF NOT EXISTS read_markers (
+    network    TEXT NOT NULL,
+    buffer     TEXT NOT NULL,
+    client     TEXT NOT NULL,
+    last_read  INTEGER NOT NULL,
+    PRIMARY KEY (network, buffer, client)
+  );
+`
+
+const FTS_SCHEMA = `
+  CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+    nick, text, content=messages, content_rowid=id
+  );
+`
+
+export function openDatabase(config: LoggingConfig): Database {
+  if (db) return db
+
+  db = new Database(LOG_DB_PATH, { create: true })
+  db.run("PRAGMA journal_mode=WAL")
+  db.run("PRAGMA synchronous=NORMAL")
+  db.exec(SCHEMA)
+
+  // Migrate existing databases: add msg_id column if missing
+  const cols = db.prepare("PRAGMA table_info(messages)").all() as { name: string }[]
+  if (!cols.some((c) => c.name === "msg_id")) {
+    db.exec(MIGRATION_ADD_MSG_ID)
+  }
+
+  // Migrate: add read_markers table if missing
+  const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='read_markers'").all()
+  if (tables.length === 0) {
+    db.exec(MIGRATION_ADD_READ_MARKERS)
+  }
+
+  // FTS5 only in plain text mode (can't index encrypted text)
+  if (!config.encrypt) {
+    db.exec(FTS_SCHEMA)
+  }
+
+  return db
+}
+
+export function getDatabase(): Database | null {
+  return db
+}
+
+export function closeDatabase(): void {
+  if (db) {
+    db.close()
+    db = null
+  }
+}
+
+/** Purge messages older than retention_days. Cleans FTS5 index if it exists. */
+export function purgeOldMessages(retentionDays: number, hasFts: boolean): number {
+  if (!db || retentionDays <= 0) return 0
+  const cutoff = Date.now() - retentionDays * 86400_000
+  // Clean FTS index before deleting rows (external content mode requires manual sync)
+  if (hasFts) {
+    db.run(
+      "DELETE FROM messages_fts WHERE rowid IN (SELECT id FROM messages WHERE timestamp < ?)",
+      [cutoff],
+    )
+  }
+  const result = db.run("DELETE FROM messages WHERE timestamp < ?", [cutoff])
+  return result.changes
+}

package/src/core/storage/index.ts

@@ -0,0 +1,80 @@
+import type { MessageType } from "@/types"
+import type { LoggingConfig, LogRow, MessageListener } from "./types"
+import { openDatabase, closeDatabase, purgeOldMessages } from "./db"
+import { setQueryConfig } from "./query"
+import { LogWriter } from "./writer"
+
+export type { LoggingConfig, LogRow, StoredMessage, ReadMarker, MessageListener } from "./types"
+export { getMessages, searchMessages, getBuffers, getStats } from "./query"
+export { updateReadMarker, getReadMarker, getReadMarkers, getUnreadCount } from "./query"
+
+let writer: LogWriter | null = null
+let loggingConfig: LoggingConfig | null = null
+
+/** Initialize the storage system. Call after config is loaded, before connections. */
+export async function initStorage(config: LoggingConfig): Promise<void> {
+  if (!config.enabled) return
+
+  loggingConfig = config
+  const db = openDatabase(config)
+  setQueryConfig(config)
+
+  // Purge old messages on startup
+  if (config.retention_days > 0) {
+    const purged = purgeOldMessages(config.retention_days, !config.encrypt)
+    if (purged > 0) {
+      console.log(`[storage] purged ${purged} messages older than ${config.retention_days} days`)
+    }
+  }
+
+  writer = new LogWriter(db, config)
+  await writer.init()
+}
+
+/** Log a message. Called from store.addMessage(). */
+export function logMessage(
+  network: string,
+  buffer: string,
+  msgId: string,
+  type: MessageType,
+  text: string,
+  nick: string | null,
+  highlight: boolean,
+  timestamp: Date,
+): void {
+  if (!writer) return
+
+  const row: LogRow = {
+    msg_id: msgId,
+    network,
+    buffer,
+    timestamp: timestamp.getTime(),
+    type,
+    nick,
+    text,
+    highlight: highlight ? 1 : 0,
+  }
+
+  writer.enqueue(row)
+}
+
+/** Subscribe to real-time message events (for WebSocket push). */
+export function onMessage(listener: MessageListener): () => void {
+  if (!writer) return () => {}
+  return writer.onMessage(listener)
+}
+
+/** Flush pending writes and close the database. Call on shutdown. */
+export async function shutdownStorage(): Promise<void> {
+  if (writer) {
+    await writer.shutdown()
+    writer = null
+  }
+  closeDatabase()
+  loggingConfig = null
+}
+
+/** Check if storage is active. */
+export function isStorageActive(): boolean {
+  return writer !== null
+}

package/src/core/storage/query.ts

@@ -0,0 +1,204 @@
+import { getDatabase } from "./db"
+import { LOG_DB_PATH } from "@/core/constants"
+import { decrypt, loadOrCreateKey } from "./crypto"
+import type { StoredMessage, LoggingConfig, ReadMarker } from "./types"
+
+let config: LoggingConfig | null = null
+
+export function setQueryConfig(cfg: LoggingConfig): void {
+  config = cfg
+}
+
+interface RawRow {
+  id: number
+  msg_id: string | null
+  network: string
+  buffer: string
+  timestamp: number
+  type: string
+  nick: string | null
+  text: string
+  highlight: number
+  iv: Uint8Array | null
+}
+
+async function decryptRow(row: RawRow): Promise<StoredMessage> {
+  let text = row.text
+  if (config?.encrypt && row.iv) {
+    const key = await loadOrCreateKey()
+    text = await decrypt(row.text, row.iv, key)
+  }
+  return {
+    id: row.id,
+    msg_id: row.msg_id ?? "",
+    network: row.network,
+    buffer: row.buffer,
+    timestamp: row.timestamp,
+    type: row.type as StoredMessage["type"],
+    nick: row.nick,
+    text,
+    highlight: row.highlight === 1,
+  }
+}
+
+/** Get messages for a buffer, paginated by timestamp (cursor-based). */
+export async function getMessages(
+  network: string,
+  buffer: string,
+  before?: number,
+  limit: number = 100,
+): Promise<StoredMessage[]> {
+  const db = getDatabase()
+  if (!db) return []
+
+  let rows: RawRow[]
+  if (before) {
+    rows = db.prepare(
+      "SELECT * FROM messages WHERE network = ? AND buffer = ? AND timestamp < ? ORDER BY timestamp DESC LIMIT ?"
+    ).all(network, buffer, before, limit) as RawRow[]
+  } else {
+    rows = db.prepare(
+      "SELECT * FROM messages WHERE network = ? AND buffer = ? ORDER BY timestamp DESC LIMIT ?"
+    ).all(network, buffer, limit) as RawRow[]
+  }
+
+  // Reverse to chronological order
+  rows.reverse()
+
+  const messages: StoredMessage[] = []
+  for (const row of rows) {
+    messages.push(await decryptRow(row))
+  }
+  return messages
+}
+
+/** Full-text search (plain mode only). */
+export async function searchMessages(
+  query: string,
+  network?: string,
+  buffer?: string,
+  limit: number = 50,
+): Promise<StoredMessage[]> {
+  const db = getDatabase()
+  if (!db || config?.encrypt) return []
+
+  let sql = `
+    SELECT m.* FROM messages m
+    JOIN messages_fts fts ON m.id = fts.rowid
+    WHERE messages_fts MATCH ?
+  `
+  // Wrap in double quotes for literal phrase match (escape internal quotes)
+  const safeQuery = `"${query.replace(/"/g, '""')}"`
+  const params: any[] = [safeQuery]
+
+  if (network) {
+    sql += " AND m.network = ?"
+    params.push(network)
+  }
+  if (buffer) {
+    sql += " AND m.buffer = ?"
+    params.push(buffer)
+  }
+
+  sql += " ORDER BY m.timestamp DESC LIMIT ?"
+  params.push(limit)
+
+  const rows = db.prepare(sql).all(...params) as RawRow[]
+  rows.reverse()
+
+  return rows.map((row) => ({
+    id: row.id,
+    msg_id: row.msg_id ?? "",
+    network: row.network,
+    buffer: row.buffer,
+    timestamp: row.timestamp,
+    type: row.type as StoredMessage["type"],
+    nick: row.nick,
+    text: row.text,
+    highlight: row.highlight === 1,
+  }))
+}
+
+/** List all buffers that have logged messages for a network. */
+export function getBuffers(network: string): string[] {
+  const db = getDatabase()
+  if (!db) return []
+
+  const rows = db.prepare(
+    "SELECT DISTINCT buffer FROM messages WHERE network = ? ORDER BY buffer"
+  ).all(network) as { buffer: string }[]
+
+  return rows.map((r) => r.buffer)
+}
+
+/** Get total message count and database file size. */
+export function getStats(): { messageCount: number; dbSizeBytes: number } | null {
+  const db = getDatabase()
+  if (!db) return null
+
+  const row = db.prepare("SELECT COUNT(*) as count FROM messages").get() as { count: number }
+  const file = Bun.file(LOG_DB_PATH)
+
+  return {
+    messageCount: row.count,
+    dbSizeBytes: file.size,
+  }
+}
+
+// ─── Read Markers ──────────────────────────────────────────────
+
+/** Update (upsert) a read marker for a client viewing a buffer. */
+export function updateReadMarker(network: string, buffer: string, client: string, timestamp: number): void {
+  const db = getDatabase()
+  if (!db) return
+
+  db.run(
+    `INSERT INTO read_markers (network, buffer, client, last_read)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT (network, buffer, client)
+     DO UPDATE SET last_read = excluded.last_read`,
+    [network, buffer, client, timestamp],
+  )
+}
+
+/** Get the read marker for a specific client on a buffer. */
+export function getReadMarker(network: string, buffer: string, client: string): number | null {
+  const db = getDatabase()
+  if (!db) return null
+
+  const row = db.prepare(
+    "SELECT last_read FROM read_markers WHERE network = ? AND buffer = ? AND client = ?"
+  ).get(network, buffer, client) as { last_read: number } | null
+
+  return row?.last_read ?? null
+}
+
+/** Get all read markers for a buffer (all clients). */
+export function getReadMarkers(network: string, buffer: string): ReadMarker[] {
+  const db = getDatabase()
+  if (!db) return []
+
+  return db.prepare(
+    "SELECT * FROM read_markers WHERE network = ? AND buffer = ?"
+  ).all(network, buffer) as ReadMarker[]
+}
+
+/** Count unread messages for a client on a buffer (messages after their last_read). */
+export function getUnreadCount(network: string, buffer: string, client: string): number {
+  const db = getDatabase()
+  if (!db) return 0
+
+  const marker = getReadMarker(network, buffer, client)
+  if (marker === null) {
+    // Never read — all messages are unread
+    const row = db.prepare(
+      "SELECT COUNT(*) as count FROM messages WHERE network = ? AND buffer = ?"
+    ).get(network, buffer) as { count: number }
+    return row.count
+  }
+
+  const row = db.prepare(
+    "SELECT COUNT(*) as count FROM messages WHERE network = ? AND buffer = ? AND timestamp > ?"
+  ).get(network, buffer, marker) as { count: number }
+  return row.count
+}

package/src/core/storage/types.ts

@@ -0,0 +1,37 @@
+import type { MessageType } from "@/types"
+
+// Re-export from canonical config location
+export type { LoggingConfig } from "@/types/config"
+
+export interface LogRow {
+  msg_id: string       // UUID from Message.id — shared identity across TUI/web
+  network: string
+  buffer: string
+  timestamp: number    // Unix ms
+  type: MessageType
+  nick: string | null
+  text: string
+  highlight: number    // 0 or 1
+}
+
+export interface StoredMessage {
+  id: number
+  msg_id: string
+  network: string
+  buffer: string
+  timestamp: number
+  type: MessageType
+  nick: string | null
+  text: string
+  highlight: boolean
+}
+
+export interface ReadMarker {
+  network: string
+  buffer: string
+  client: string       // 'tui' or web session id
+  last_read: number    // Unix ms timestamp
+}
+
+/** Callback for real-time message events (used by WebSocket server). */
+export type MessageListener = (row: LogRow) => void

package/src/core/storage/writer.ts

@@ -0,0 +1,130 @@
+import type { Database } from "bun:sqlite"
+import type { LogRow, LoggingConfig, MessageListener } from "./types"
+import { encrypt, loadOrCreateKey } from "./crypto"
+
+const BATCH_SIZE = 50
+const FLUSH_INTERVAL_MS = 1000
+
+export class LogWriter {
+  private queue: LogRow[] = []
+  private timer: ReturnType<typeof setTimeout> | null = null
+  private flushing = false
+  private db: Database
+  private config: LoggingConfig
+  private cryptoKey: CryptoKey | null = null
+  private hasFts: boolean
+  private listeners: MessageListener[] = []
+
+  constructor(db: Database, config: LoggingConfig) {
+    this.db = db
+    this.config = config
+    this.hasFts = !config.encrypt
+  }
+
+  async init(): Promise<void> {
+    if (this.config.encrypt) {
+      this.cryptoKey = await loadOrCreateKey()
+    }
+  }
+
+  /** Subscribe to new messages (for WebSocket real-time push). */
+  onMessage(listener: MessageListener): () => void {
+    this.listeners.push(listener)
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== listener)
+    }
+  }
+
+  enqueue(row: LogRow): void {
+    // Filter excluded message types
+    if (this.config.exclude_types.includes(row.type)) return
+
+    // Notify listeners immediately (before batching delay)
+    for (const listener of this.listeners) {
+      try { listener(row) } catch {}
+    }
+
+    this.queue.push(row)
+
+    // Start timer on first buffered message
+    if (this.queue.length === 1) {
+      this.timer = setTimeout(() => {
+        this.flush().catch((err) => console.error("[storage] flush error:", err))
+      }, FLUSH_INTERVAL_MS)
+    }
+
+    // Flush immediately at batch size
+    if (this.queue.length >= BATCH_SIZE) {
+      this.flush().catch((err) => console.error("[storage] flush error:", err))
+    }
+  }
+
+  async flush(): Promise<void> {
+    if (this.timer) {
+      clearTimeout(this.timer)
+      this.timer = null
+    }
+
+    if (this.queue.length === 0 || this.flushing) return
+
+    this.flushing = true
+    const batch = this.queue.splice(0)
+
+    const insert = this.db.prepare(
+      "INSERT INTO messages (msg_id, network, buffer, timestamp, type, nick, text, highlight, iv) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+    )
+
+    // Prepare FTS insert if available
+    const insertFts = this.hasFts
+      ? this.db.prepare(
+          "INSERT INTO messages_fts (rowid, nick, text) VALUES (?, ?, ?)"
+        )
+      : null
+
+    try {
+      // bun:sqlite transactions are sync, but encrypt is async — handle both modes
+      if (this.cryptoKey) {
+        // Encrypted mode: can't use bun:sqlite transaction wrapper (it's sync)
+        this.db.run("BEGIN")
+        try {
+          for (const row of batch) {
+            const encrypted = await encrypt(row.text, this.cryptoKey)
+            insert.run(
+              row.msg_id, row.network, row.buffer, row.timestamp, row.type,
+              row.nick, encrypted.ciphertext, row.highlight, encrypted.iv,
+            )
+          }
+          this.db.run("COMMIT")
+        } catch (err) {
+          this.db.run("ROLLBACK")
+          throw err
+        }
+      } else {
+        // Plain mode: synchronous transaction with FTS5
+        const syncTransaction = this.db.transaction((rows: LogRow[]) => {
+          for (const row of rows) {
+            const result = insert.run(
+              row.msg_id, row.network, row.buffer, row.timestamp, row.type,
+              row.nick, row.text, row.highlight, null,
+            )
+            if (insertFts && result.lastInsertRowid) {
+              insertFts.run(result.lastInsertRowid, row.nick ?? "", row.text)
+            }
+          }
+        })
+        syncTransaction(batch)
+      }
+    } finally {
+      this.flushing = false
+    }
+
+    // If more messages accumulated during flush, flush again
+    if (this.queue.length > 0) {
+      await this.flush()
+    }
+  }
+
+  async shutdown(): Promise<void> {
+    await this.flush()
+  }
+}

package/src/core/theme/index.ts

@@ -0,0 +1,3 @@
+export { parseFormatString, resolveAbstractions } from "./parser"
+export { loadTheme } from "./loader"
+export { StyledText } from "./renderer"

package/src/core/theme/loader.ts

@@ -0,0 +1,45 @@
+import { parse as parseTOML } from "smol-toml"
+import type { ThemeFile, ThemeColors } from "@/types/theme"
+
+const DEFAULT_COLORS: ThemeColors = {
+  bg: "#1a1b26",
+  bg_alt: "#16161e",
+  border: "#292e42",
+  fg: "#a9b1d6",
+  fg_muted: "#565f89",
+  fg_dim: "#292e42",
+  accent: "#7aa2f7",
+  cursor: "#7aa2f7",
+}
+
+const DEFAULT_THEME: ThemeFile = {
+  meta: { name: "Fallback", description: "Minimal fallback theme" },
+  colors: DEFAULT_COLORS,
+  abstracts: {
+    timestamp: "$*",
+    msgnick: "$0$1> ",
+    ownnick: "$*",
+    pubnick: "$*",
+  },
+  formats: {
+    messages: { pubmsg: "$0 $1", own_msg: "$0 $1" },
+    events: {},
+    sidepanel: { header: "$0", item: "$0. $1", item_selected: "> $0. $1" },
+    nicklist: { normal: " $0" },
+  },
+}
+
+export async function loadTheme(path: string): Promise<ThemeFile> {
+  const file = Bun.file(path)
+  if (!(await file.exists())) {
+    return DEFAULT_THEME
+  }
+  const text = await file.text()
+  const parsed = parseTOML(text) as unknown as Partial<ThemeFile>
+  return {
+    meta: parsed.meta ?? DEFAULT_THEME.meta,
+    colors: { ...DEFAULT_COLORS, ...parsed.colors },
+    abstracts: parsed.abstracts ?? DEFAULT_THEME.abstracts,
+    formats: parsed.formats ?? DEFAULT_THEME.formats,
+  }
+}