kokoirc 0.2.0

package/src/core/commands/types.ts

@@ -0,0 +1,19 @@
+import type { AppConfig } from "@/types/config"
+
+export type Handler = (args: string[], connectionId: string) => void
+
+export interface CommandDef {
+  handler: Handler
+  description: string
+  usage: string
+  aliases?: string[]
+}
+
+export interface ResolvedConfig {
+  value: any
+  field: string
+  isCredential: boolean
+  serverId?: string
+}
+
+export const CREDENTIAL_FIELDS = new Set(["password", "sasl_pass"])

package/src/core/config/defaults.ts

@@ -0,0 +1,66 @@
+import type { AppConfig } from "@/types/config"
+
+export const DEFAULT_CONFIG: AppConfig = {
+  general: {
+    nick: "kokoIRC",
+    username: "kokoirc",
+    realname: "kokoIRC Client",
+    theme: "default",
+    timestamp_format: "%H:%M:%S",
+    flood_protection: true,
+    ctcp_version: "kokoIRC",
+  },
+  display: {
+    nick_column_width: 8,
+    nick_max_length: 8,
+    nick_alignment: "right",
+    nick_truncation: true,
+    show_timestamps: true,
+    scrollback_lines: 2000,
+  },
+  sidepanel: {
+    left: { width: 20, visible: true },
+    right: { width: 18, visible: true },
+  },
+  statusbar: {
+    enabled: true,
+    items: ["time", "nick_info", "channel_info", "lag", "active_windows"],
+    separator: " | ",
+    item_formats: {},
+
+    // "" means "use theme color" — resolved at render time
+    background: "",
+    text_color: "",
+    accent_color: "",
+    muted_color: "",
+    dim_color: "",
+
+    prompt: "[$server\u2771 ",
+    prompt_color: "",
+    input_color: "",
+    cursor_color: "",
+  },
+  servers: {
+    ircnet: {
+      label: "IRCnet",
+      address: "hostsailor.ircnet.nl",
+      port: 6697,
+      tls: true,
+      tls_verify: true,
+      autoconnect: false,
+      channels: ["#ircnet", "#polska"],
+    },
+  },
+  aliases: {},
+  ignores: [],
+  scripts: {
+    autoload: [],
+    debug: false,
+  },
+  logging: {
+    enabled: true,
+    encrypt: false,
+    retention_days: 0,
+    exclude_types: [],
+  },
+}

package/src/core/config/loader.ts

@@ -0,0 +1,209 @@
+import { parse as parseTOML, stringify as stringifyTOML } from "smol-toml"
+import { DEFAULT_CONFIG } from "./defaults"
+import { ENV_PATH } from "@/core/constants"
+import type { AppConfig, ServerConfig, IgnoreEntry, ScriptsConfig } from "@/types/config"
+
+/** Create a deep-ish clone of config, safe for in-place mutation. */
+export function cloneConfig(config: AppConfig): AppConfig {
+  return {
+    general: { ...config.general },
+    display: { ...config.display },
+    sidepanel: {
+      left: { ...config.sidepanel.left },
+      right: { ...config.sidepanel.right },
+    },
+    statusbar: { ...config.statusbar, items: [...config.statusbar.items], item_formats: { ...config.statusbar.item_formats } },
+    servers: Object.fromEntries(
+      Object.entries(config.servers).map(([id, srv]) => [id, { ...srv, channels: [...srv.channels] }])
+    ),
+    aliases: { ...config.aliases },
+    ignores: config.ignores.map((e) => ({
+      ...e,
+      levels: [...e.levels],
+      channels: e.channels ? [...e.channels] : undefined,
+    })),
+    scripts: {
+      ...config.scripts,
+      autoload: [...config.scripts.autoload],
+    },
+    logging: {
+      ...config.logging,
+      exclude_types: [...config.logging.exclude_types],
+    },
+  }
+}
+
+export function mergeWithDefaults(partial: Record<string, any>): AppConfig {
+  return {
+    general: { ...DEFAULT_CONFIG.general, ...partial.general },
+    display: { ...DEFAULT_CONFIG.display, ...partial.display },
+    sidepanel: {
+      left: { ...DEFAULT_CONFIG.sidepanel.left, ...partial.sidepanel?.left },
+      right: { ...DEFAULT_CONFIG.sidepanel.right, ...partial.sidepanel?.right },
+    },
+    statusbar: { ...DEFAULT_CONFIG.statusbar, ...partial.statusbar },
+    servers: partial.servers ?? {},
+    aliases: partial.aliases ?? {},
+    ignores: (partial.ignores as IgnoreEntry[] | undefined) ?? [],
+    scripts: {
+      autoload: [],
+      debug: false,
+      ...DEFAULT_CONFIG.scripts,
+      ...partial.scripts,
+    },
+    logging: { ...DEFAULT_CONFIG.logging, ...partial.logging },
+  }
+}
+
+export function loadCredentials(
+  servers: Record<string, ServerConfig>,
+  env: Record<string, string | undefined>,
+): Record<string, ServerConfig> {
+  const result: Record<string, ServerConfig> = {}
+  for (const [id, server] of Object.entries(servers)) {
+    const prefix = id.toUpperCase()
+    result[id] = {
+      ...server,
+      sasl_user: env[`${prefix}_SASL_USER`] ?? server.sasl_user,
+      sasl_pass: env[`${prefix}_SASL_PASS`] ?? server.sasl_pass,
+      password: env[`${prefix}_PASSWORD`] ?? server.password,
+    }
+  }
+  return result
+}
+
+export async function loadConfig(configPath: string): Promise<AppConfig> {
+  const file = Bun.file(configPath)
+  if (!(await file.exists())) {
+    return { ...DEFAULT_CONFIG }
+  }
+  const text = await file.text()
+  const parsed = parseTOML(text)
+  const config = mergeWithDefaults(parsed)
+  config.servers = loadCredentials(config.servers, process.env)
+  return config
+}
+
+/** Strip undefined/empty optional fields before serializing to TOML */
+function cleanServerForTOML(server: ServerConfig): Record<string, any> {
+  const obj: Record<string, any> = {
+    label: server.label,
+    address: server.address,
+    port: server.port,
+    tls: server.tls,
+    tls_verify: server.tls_verify,
+    autoconnect: server.autoconnect,
+    channels: server.channels,
+  }
+  // Only include non-empty optional fields
+  if (server.nick) obj.nick = server.nick
+  if (server.username) obj.username = server.username
+  if (server.realname) obj.realname = server.realname
+  if (server.bind_ip) obj.bind_ip = server.bind_ip
+  if (server.encoding && server.encoding !== "utf8") obj.encoding = server.encoding
+  if (server.auto_reconnect === false) obj.auto_reconnect = false
+  if (server.reconnect_delay && server.reconnect_delay !== 30) obj.reconnect_delay = server.reconnect_delay
+  if (server.reconnect_max_retries != null) obj.reconnect_max_retries = server.reconnect_max_retries
+  // SASL and password stored in config only if NOT in .env — sasl_user kept, pass stripped
+  if (server.sasl_user) obj.sasl_user = server.sasl_user
+  // password and sasl_pass NOT saved to TOML — they go to .env
+  return obj
+}
+
+/** Save the full config to TOML file */
+export async function saveConfig(configPath: string, config: AppConfig): Promise<void> {
+  // Build a clean object for serialization
+  const tomlObj: Record<string, any> = {
+    general: config.general,
+    display: config.display,
+    sidepanel: config.sidepanel,
+    statusbar: {} as Record<string, any>,
+    servers: {} as Record<string, any>,
+  }
+
+  // Statusbar: only non-empty values
+  const sb = config.statusbar
+  tomlObj.statusbar.enabled = sb.enabled
+  tomlObj.statusbar.items = sb.items
+  if (sb.separator) tomlObj.statusbar.separator = sb.separator
+  if (sb.background) tomlObj.statusbar.background = sb.background
+  if (sb.text_color) tomlObj.statusbar.text_color = sb.text_color
+  if (sb.accent_color) tomlObj.statusbar.accent_color = sb.accent_color
+  if (sb.muted_color) tomlObj.statusbar.muted_color = sb.muted_color
+  if (sb.dim_color) tomlObj.statusbar.dim_color = sb.dim_color
+  if (sb.prompt) tomlObj.statusbar.prompt = sb.prompt
+  if (sb.prompt_color) tomlObj.statusbar.prompt_color = sb.prompt_color
+  if (sb.input_color) tomlObj.statusbar.input_color = sb.input_color
+  if (sb.cursor_color) tomlObj.statusbar.cursor_color = sb.cursor_color
+  if (sb.item_formats && Object.keys(sb.item_formats).length > 0) {
+    tomlObj.statusbar.item_formats = sb.item_formats
+  }
+
+  if (Object.keys(config.aliases).length > 0) {
+    tomlObj.aliases = config.aliases
+  }
+
+  for (const [id, server] of Object.entries(config.servers)) {
+    tomlObj.servers[id] = cleanServerForTOML(server)
+  }
+
+  if (config.ignores.length > 0) {
+    tomlObj.ignores = config.ignores.map((e) => {
+      const obj: Record<string, any> = { mask: e.mask, levels: e.levels }
+      if (e.channels?.length) obj.channels = e.channels
+      return obj
+    })
+  }
+
+  // Scripts config — only write if non-default
+  if (config.scripts) {
+    const sc: Record<string, any> = {}
+    if (config.scripts.autoload.length > 0) sc.autoload = config.scripts.autoload
+    if (config.scripts.debug) sc.debug = true
+    // Per-script configs: [scripts.my-script]
+    for (const [key, val] of Object.entries(config.scripts)) {
+      if (key === "autoload" || key === "debug") continue
+      if (typeof val === "object" && val !== null) sc[key] = val
+    }
+    if (Object.keys(sc).length > 0) tomlObj.scripts = sc
+  }
+
+  // Logging config — only write non-default values
+  if (config.logging) {
+    const lg: Record<string, any> = {}
+    if (!config.logging.enabled) lg.enabled = false  // only write if disabled (default is true)
+    if (config.logging.encrypt) lg.encrypt = true
+    if (config.logging.retention_days > 0) lg.retention_days = config.logging.retention_days
+    if (config.logging.exclude_types.length > 0) lg.exclude_types = config.logging.exclude_types
+    if (Object.keys(lg).length > 0) tomlObj.logging = lg
+  }
+
+  const toml = stringifyTOML(tomlObj)
+  await Bun.write(configPath, toml)
+}
+
+/** Append or update credentials in .env file */
+export async function saveCredentialsToEnv(
+  serverId: string,
+  credentials: { sasl_user?: string; sasl_pass?: string; password?: string },
+): Promise<void> {
+  const file = Bun.file(ENV_PATH)
+  let content = (await file.exists()) ? await file.text() : ""
+
+  const prefix = serverId.toUpperCase()
+  const updates: [string, string][] = []
+  if (credentials.sasl_user) updates.push([`${prefix}_SASL_USER`, credentials.sasl_user])
+  if (credentials.sasl_pass) updates.push([`${prefix}_SASL_PASS`, credentials.sasl_pass])
+  if (credentials.password) updates.push([`${prefix}_PASSWORD`, credentials.password])
+
+  for (const [key, value] of updates) {
+    const regex = new RegExp(`^${key}=.*$`, "m")
+    if (regex.test(content)) {
+      content = content.replace(regex, `${key}=${value}`)
+    } else {
+      content = content.trimEnd() + (content.length > 0 ? "\n" : "") + `${key}=${value}\n`
+    }
+  }
+
+  await Bun.write(ENV_PATH, content)
+}

package/src/core/constants.ts

@@ -0,0 +1,20 @@
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+// Package directory — where bundled defaults and docs live
+const PKG_DIR = join(import.meta.dir, "../..")
+
+// User home directory — mutable config, themes, .env
+export const HOME_DIR = join(homedir(), ".kokoirc")
+
+export const CONFIG_PATH = join(HOME_DIR, "config.toml")
+export const THEME_PATH = (name: string) => join(HOME_DIR, "themes", `${name}.theme`)
+export const DOCS_DIR = join(PKG_DIR, "docs/commands")
+export const ENV_PATH = join(HOME_DIR, ".env")
+
+export const SCRIPTS_DIR = join(HOME_DIR, "scripts")
+
+export const LOG_DB_PATH = join(HOME_DIR, "logs.db")
+
+// Default assets bundled with the package
+export const DEFAULT_THEMES_DIR = join(PKG_DIR, "themes")

package/src/core/init.ts

@@ -0,0 +1,32 @@
+import { mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import { HOME_DIR, CONFIG_PATH, DEFAULT_THEMES_DIR, SCRIPTS_DIR } from "./constants"
+import { DEFAULT_CONFIG } from "./config/defaults"
+import { saveConfig } from "./config/loader"
+
+/** Create ~/.kokoirc/ and copy default themes + generate config on first run */
+export async function initHomeDir(): Promise<void> {
+  const themesDir = join(HOME_DIR, "themes")
+
+  // Create directories
+  await mkdir(themesDir, { recursive: true })
+  await mkdir(SCRIPTS_DIR, { recursive: true })
+
+  // Generate default config if missing
+  const configFile = Bun.file(CONFIG_PATH)
+  if (!(await configFile.exists())) {
+    await saveConfig(CONFIG_PATH, DEFAULT_CONFIG)
+  }
+
+  // Copy default themes if themes dir is empty
+  const glob = new Bun.Glob("*.theme")
+  let hasThemes = false
+  for await (const _ of glob.scan(themesDir)) { hasThemes = true; break }
+
+  if (!hasThemes) {
+    for await (const file of glob.scan(DEFAULT_THEMES_DIR)) {
+      const src = Bun.file(join(DEFAULT_THEMES_DIR, file))
+      await Bun.write(join(themesDir, file), src)
+    }
+  }
+}

package/src/core/irc/antiflood.ts

@@ -0,0 +1,244 @@
+import { useStore } from "@/core/state/store"
+import { makeBufferId } from "@/types"
+import type { Message } from "@/types"
+import type { Client } from "kofany-irc-framework"
+
+// ─── Constants (proven thresholds from erssi) ────────────────
+
+const CTCP_THRESHOLD = 5
+const CTCP_WINDOW = 5_000
+const CTCP_BLOCK = 60_000
+
+const TILDE_THRESHOLD = 5
+const TILDE_WINDOW = 5_000
+const TILDE_BLOCK = 60_000
+
+const DUP_MIN_IN_WINDOW = 5     // need 5+ msgs in window before checking dups
+const DUP_THRESHOLD = 3          // 3 identical out of those = flood
+const DUP_WINDOW = 5_000
+const DUP_BLOCK = 60_000
+
+const NICK_THRESHOLD = 5
+const NICK_WINDOW = 3_000
+const NICK_BLOCK = 60_000
+
+// ─── Per-connection state ────────────────────────────────────
+
+interface FloodState {
+  ctcpTimes: number[]
+  ctcpBlockedUntil: number
+  tildeTimes: number[]
+  tildeBlockedUntil: number
+  msgWindow: { text: string; time: number }[]
+  blockedTexts: Map<string, number>       // text → blockedUntil
+  nickTimes: Map<string, number[]>        // bufferId → timestamps
+  nickBlockedUntil: Map<string, number>   // bufferId → blockedUntil
+}
+
+const states = new Map<string, FloodState>()
+
+function getState(connId: string): FloodState {
+  let s = states.get(connId)
+  if (!s) {
+    s = {
+      ctcpTimes: [],
+      ctcpBlockedUntil: 0,
+      tildeTimes: [],
+      tildeBlockedUntil: 0,
+      msgWindow: [],
+      blockedTexts: new Map(),
+      nickTimes: new Map(),
+      nickBlockedUntil: new Map(),
+    }
+    states.set(connId, s)
+  }
+  return s
+}
+
+export function destroyAntifloodState(connId: string) {
+  states.delete(connId)
+}
+
+// ─── Helpers ─────────────────────────────────────────────────
+
+function isFloodProtectionEnabled(): boolean {
+  return useStore.getState().config?.general?.flood_protection ?? true
+}
+
+function statusNotify(connId: string, text: string) {
+  const store = useStore.getState()
+  const statusId = makeBufferId(connId, "Status")
+  if (store.buffers.has(statusId)) {
+    store.addMessage(statusId, makeEventMessage(
+      `%Zf7768eFlood protection:%N %Ze0af68${text}%N`
+    ))
+  }
+}
+
+function makeEventMessage(text: string): Message {
+  return {
+    id: crypto.randomUUID(),
+    timestamp: new Date(),
+    type: "event",
+    text,
+    highlight: false,
+  }
+}
+
+/** Prune timestamps older than `window` ms, return count remaining. */
+function pruneWindow(times: number[], now: number, window: number): number {
+  const cutoff = now - window
+  let i = 0
+  while (i < times.length && times[i] < cutoff) i++
+  if (i > 0) times.splice(0, i)
+  return times.length
+}
+
+// ─── Parsed middleware (CTCP + message floods) ───────────────
+
+export function createAntiFloodMiddleware(connId: string) {
+  return function middlewareInstaller(client: Client, rawEvents: any, parsedEvents: any) {
+    parsedEvents.use(function antiFloodHandler(command: string, event: any, _client: Client, next: () => void) {
+      if (!isFloodProtectionEnabled()) {
+        next()
+        return
+      }
+
+      const state = getState(connId)
+      const now = Date.now()
+
+      // ── CTCP requests ──
+      if (command === "ctcp request") {
+        if (state.ctcpBlockedUntil > now) {
+          // Still blocked — extend silently
+          state.ctcpBlockedUntil = now + CTCP_BLOCK
+          return // don't call next() — suppress event + auto-response
+        }
+
+        state.ctcpTimes.push(now)
+        const count = pruneWindow(state.ctcpTimes, now, CTCP_WINDOW)
+
+        if (count >= CTCP_THRESHOLD) {
+          state.ctcpBlockedUntil = now + CTCP_BLOCK
+          state.ctcpTimes.length = 0
+          statusNotify(connId, "CTCP flood detected \u2014 blocking CTCP for 60s")
+          return // suppress
+        }
+
+        next()
+        return
+      }
+
+      // ── Messages: privmsg, notice, action ──
+      if (command === "privmsg" || command === "notice" || command === "action") {
+        const ident: string = event.ident || ""
+        const message: string = event.message || ""
+        const target: string = event.target || ""
+        const isChannel = target.startsWith("#") || target.startsWith("&") ||
+                          target.startsWith("+") || target.startsWith("!")
+
+        // ~ident flood check
+        if (ident.startsWith("~")) {
+          if (state.tildeBlockedUntil > now) {
+            state.tildeBlockedUntil = now + TILDE_BLOCK
+            return // suppress
+          }
+
+          state.tildeTimes.push(now)
+          const count = pruneWindow(state.tildeTimes, now, TILDE_WINDOW)
+
+          if (count >= TILDE_THRESHOLD) {
+            state.tildeBlockedUntil = now + TILDE_BLOCK
+            state.tildeTimes.length = 0
+            statusNotify(connId, "~ident flood detected \u2014 blocking tilde messages for 60s")
+            return // suppress
+          }
+        }
+
+        // Duplicate text flood (channel messages only)
+        if (isChannel && message) {
+          // Check if this exact text is already blocked
+          const blockedUntil = state.blockedTexts.get(message)
+          if (blockedUntil && blockedUntil > now) {
+            state.blockedTexts.set(message, now + DUP_BLOCK)
+            return // suppress
+          }
+
+          // Add to sliding message window
+          state.msgWindow.push({ text: message, time: now })
+          // Prune old entries
+          const cutoff = now - DUP_WINDOW
+          while (state.msgWindow.length > 0 && state.msgWindow[0].time < cutoff) {
+            state.msgWindow.shift()
+          }
+
+          // Only analyze when enough messages in window
+          if (state.msgWindow.length >= DUP_MIN_IN_WINDOW) {
+            // Count occurrences of this message in window
+            let dupes = 0
+            for (const entry of state.msgWindow) {
+              if (entry.text === message) dupes++
+            }
+            if (dupes >= DUP_THRESHOLD) {
+              state.blockedTexts.set(message, now + DUP_BLOCK)
+              statusNotify(connId, "Duplicate flood detected \u2014 blocking pattern for 60s")
+              return // suppress
+            }
+          }
+
+          // Clean expired blocked texts periodically
+          if (state.blockedTexts.size > 50) {
+            for (const [text, until] of state.blockedTexts) {
+              if (until <= now) state.blockedTexts.delete(text)
+            }
+          }
+        }
+
+        next()
+        return
+      }
+
+      // Everything else passes through
+      next()
+    })
+  }
+}
+
+// ─── Nick flood guard (called from events.ts) ────────────────
+
+export function shouldSuppressNickFlood(connId: string, bufferId: string): boolean {
+  if (!isFloodProtectionEnabled()) return false
+
+  const state = getState(connId)
+  const now = Date.now()
+
+  // Check if currently blocked for this buffer
+  const blockedUntil = state.nickBlockedUntil.get(bufferId) ?? 0
+  if (blockedUntil > now) {
+    // Extend block silently
+    state.nickBlockedUntil.set(bufferId, now + NICK_BLOCK)
+    return true
+  }
+
+  // Track nick change timestamp
+  let times = state.nickTimes.get(bufferId)
+  if (!times) {
+    times = []
+    state.nickTimes.set(bufferId, times)
+  }
+  times.push(now)
+  pruneWindow(times, now, NICK_WINDOW)
+
+  if (times.length >= NICK_THRESHOLD) {
+    state.nickBlockedUntil.set(bufferId, now + NICK_BLOCK)
+    times.length = 0
+
+    // Extract channel name from bufferId for status message
+    const parts = bufferId.split("/")
+    const channel = parts.length > 1 ? parts[parts.length - 1] : bufferId
+    statusNotify(connId, `Nick flood in ${channel} \u2014 suppressing nick changes for 60s`)
+    return true
+  }
+
+  return false
+}