kokoirc 0.2.0

package/src/core/irc/formatting.ts

@@ -0,0 +1,132 @@
+import type { ModeEvent } from "kofany-irc-framework"
+import type { Buffer } from "@/types"
+
+/**
+ * Strip mIRC/IRC formatting codes from a string.
+ * Removes: bold (\x02), color (\x03NN,NN), hex color (\x04RRGGBB,RRGGBB),
+ * reset (\x0F), monospace (\x11), reverse (\x16), italic (\x1D),
+ * strikethrough (\x1E), underline (\x1F).
+ */
+export function stripIrcFormatting(text: string): string {
+  // eslint-disable-next-line no-control-regex
+  return text.replace(/\x04([0-9a-fA-F]{6}(,[0-9a-fA-F]{6})?)?|\x03(\d{1,2}(,\d{1,2})?)?|[\x02\x0F\x11\x16\x1D\x1E\x1F]/g, "")
+}
+
+/** Format seconds into human-readable duration (e.g. "2d 5h 30m"). */
+export function formatDuration(seconds: number): string {
+  if (seconds < 60) return `${seconds}s`
+  const days = Math.floor(seconds / 86400)
+  const hours = Math.floor((seconds % 86400) / 3600)
+  const mins = Math.floor((seconds % 3600) / 60)
+  const secs = seconds % 60
+  const parts: string[] = []
+  if (days > 0) parts.push(`${days}d`)
+  if (hours > 0) parts.push(`${hours}h`)
+  if (mins > 0) parts.push(`${mins}m`)
+  if (secs > 0 && days === 0) parts.push(`${secs}s`)
+  return parts.join(" ")
+}
+
+/** Format a Date to "YYYY-MM-DD HH:MM:SS". */
+export function formatDate(date: Date): string {
+  const y = date.getFullYear()
+  const mo = String(date.getMonth() + 1).padStart(2, "0")
+  const d = String(date.getDate()).padStart(2, "0")
+  const h = String(date.getHours()).padStart(2, "0")
+  const mi = String(date.getMinutes()).padStart(2, "0")
+  const s = String(date.getSeconds()).padStart(2, "0")
+  return `${y}-${mo}-${d} ${h}:${mi}:${s}`
+}
+
+/** Format a timestamp with a simple %H:%M:%S template. */
+export function formatTimestamp(date: Date, format: string): string {
+  const h = String(date.getHours()).padStart(2, "0")
+  const m = String(date.getMinutes()).padStart(2, "0")
+  const s = String(date.getSeconds()).padStart(2, "0")
+  return format.replace("%H", h).replace("%M", m).replace("%S", s)
+}
+
+/** Reconstruct a displayable mode string from irc-framework mode event. */
+export function buildModeString(event: ModeEvent): string {
+  if (event.raw_modes) {
+    const params = event.raw_params ?? []
+    return event.raw_modes + (params.length > 0 ? " " + params.join(" ") : "")
+  }
+  if (!Array.isArray(event.modes)) return String(event.modes ?? "")
+
+  let modeChars = ""
+  const params: string[] = []
+  let lastSign = ""
+
+  for (const m of event.modes) {
+    const sign = m.mode[0]
+    const char = m.mode.slice(1)
+    if (sign !== lastSign) {
+      modeChars += sign
+      lastSign = sign
+    }
+    modeChars += char
+    if (m.param) params.push(m.param)
+  }
+
+  return modeChars + (params.length > 0 ? " " + params.join(" ") : "")
+}
+
+/**
+ * Build a map from mode char → prefix symbol using ISUPPORT PREFIX.
+ * e.g., "(ov)@+" → { o: "@", v: "+" }
+ * Also maps prefix symbols to themselves so both formats work.
+ */
+export function buildPrefixMap(isupportPrefix: unknown): Record<string, string> {
+  const map: Record<string, string> = {}
+  if (typeof isupportPrefix !== "string") {
+    // Default fallback mapping
+    map["o"] = "@"; map["v"] = "+"; map["h"] = "%"
+    map["a"] = "&"; map["q"] = "~"
+    map["@"] = "@"; map["+"] = "+"; map["%"] = "%"
+    map["&"] = "&"; map["~"] = "~"
+    return map
+  }
+  const match = isupportPrefix.match(/^\(([^)]+)\)(.+)$/)
+  if (!match) return map
+  const modes = match[1]
+  const prefixes = match[2]
+  for (let i = 0; i < modes.length && i < prefixes.length; i++) {
+    map[modes[i]] = prefixes[i]
+    map[prefixes[i]] = prefixes[i] // identity mapping for prefix symbols
+  }
+  return map
+}
+
+/** Get the prefix mode character for a nick in a buffer. */
+export function getNickMode(buffers: Map<string, Buffer>, bufferId: string, nick: string): string {
+  const buf = buffers.get(bufferId)
+  return buf?.users.get(nick)?.prefix ?? ""
+}
+
+/**
+ * Extract mode character ordering from ISUPPORT PREFIX (highest rank first).
+ * e.g. "(qaohv)~&@%+" → "qaohv"
+ */
+export function buildModeOrder(isupportPrefix: unknown): string {
+  if (typeof isupportPrefix === "string") {
+    const match = isupportPrefix.match(/^\(([^)]+)\)/)
+    if (match) return match[1]
+  }
+  return "qaohv" // default rank order
+}
+
+/**
+ * Compute the displayed prefix from a set of raw mode chars.
+ * Returns the prefix symbol of the highest-ranked mode the user holds.
+ */
+export function getHighestPrefix(
+  modes: string,
+  modeOrder: string,
+  prefixMap: Record<string, string>,
+): string {
+  for (const ch of modeOrder) {
+    if (modes.includes(ch)) return prefixMap[ch] ?? ""
+  }
+  return ""
+}

package/src/core/irc/ignore.ts

@@ -0,0 +1,84 @@
+import { useStore } from "@/core/state/store"
+import type { IgnoreLevel, IgnoreEntry } from "@/types/config"
+import type { Client } from "kofany-irc-framework"
+
+// ─── Wildcard matching ───────────────────────────────────────
+
+/** Convert a simple wildcard pattern (*, ?) to a RegExp. */
+function wildcardToRegex(pattern: string): RegExp {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&")
+  const withWildcards = escaped.replace(/\*/g, ".*").replace(/\?/g, ".")
+  return new RegExp(`^${withWildcards}$`, "i")
+}
+
+// ─── Public helpers ──────────────────────────────────────────
+
+/** Build a nick!user@host mask from event data. */
+export function buildMask(nick: string, ident?: string, hostname?: string): string {
+  return `${nick}!${ident || "*"}@${hostname || "*"}`
+}
+
+/** Check if an event from this user/level/channel should be ignored. */
+export function shouldIgnore(
+  nick: string,
+  ident: string | undefined,
+  hostname: string | undefined,
+  level: IgnoreLevel,
+  channel?: string,
+): boolean {
+  const ignores = useStore.getState().config?.ignores
+  if (!ignores?.length) return false
+
+  const fullMask = buildMask(nick, ident, hostname)
+
+  for (const entry of ignores) {
+    // Level check
+    if (!entry.levels.includes("ALL") && !entry.levels.includes(level)) continue
+
+    // Pattern check: bare nick vs full mask
+    if (entry.mask.includes("!")) {
+      if (!wildcardToRegex(entry.mask).test(fullMask)) continue
+    } else {
+      if (!wildcardToRegex(entry.mask).test(nick)) continue
+    }
+
+    // Channel restriction
+    if (entry.channels?.length) {
+      if (!channel || !entry.channels.some((ch) => ch.toLowerCase() === channel.toLowerCase())) continue
+    }
+
+    return true
+  }
+
+  return false
+}
+
+// ─── Parsed middleware (privmsg, action, notice, ctcp) ───────
+
+function isChannel(target: string): boolean {
+  return target.startsWith("#") || target.startsWith("&") || target.startsWith("+") || target.startsWith("!")
+}
+
+export function createIgnoreMiddleware() {
+  return function middlewareInstaller(_client: Client, _rawEvents: any, parsedEvents: any) {
+    parsedEvents.use(function ignoreHandler(command: string, event: any, _c: Client, next: () => void) {
+      const nick: string = event.nick || ""
+      const ident: string = event.ident || ""
+      const hostname: string = event.hostname || ""
+      const target: string = event.target || ""
+
+      if (command === "privmsg") {
+        const level: IgnoreLevel = isChannel(target) ? "PUBLIC" : "MSGS"
+        if (shouldIgnore(nick, ident, hostname, level, isChannel(target) ? target : undefined)) return
+      } else if (command === "action") {
+        if (shouldIgnore(nick, ident, hostname, "ACTIONS", isChannel(target) ? target : undefined)) return
+      } else if (command === "notice") {
+        if (shouldIgnore(nick, ident, hostname, "NOTICES", isChannel(target) ? target : undefined)) return
+      } else if (command === "ctcp request" || command === "ctcp response") {
+        if (shouldIgnore(nick, ident, hostname, "CTCPS")) return
+      }
+
+      next()
+    })
+  }
+}

package/src/core/irc/index.ts

@@ -0,0 +1,2 @@
+export { connectServer, disconnectServer, getClient, getAllClientIds, connectAllAutoconnect } from "./client"
+export { formatDuration, formatDate, formatTimestamp, buildModeString, buildPrefixMap, getNickMode, stripIrcFormatting } from "./formatting"

package/src/core/irc/netsplit.ts

@@ -0,0 +1,292 @@
+import { useStore } from "@/core/state/store"
+import { makeBufferId } from "@/types"
+import type { Message } from "@/types"
+
+// ─── Types ───────────────────────────────────────────────────
+
+interface SplitRecord {
+  nick: string
+  channels: string[]  // buffer IDs the user was in
+}
+
+interface SplitGroup {
+  server1: string
+  server2: string
+  nicks: SplitRecord[]
+  lastQuit: number
+  printed: boolean
+}
+
+interface NetjoinGroup {
+  server1: string
+  server2: string
+  nicks: string[]
+  channels: Set<string>  // buffer IDs
+  lastJoin: number
+  printed: boolean
+}
+
+// ─── Constants ───────────────────────────────────────────────
+
+const SPLIT_BATCH_WAIT = 5_000       // 5s — collect quits before printing
+const NETJOIN_BATCH_WAIT = 5_000     // 5s — collect joins before printing
+const SPLIT_EXPIRE = 3600_000        // 1 hour — forget split records
+const MAX_NICKS_DISPLAY = 15         // truncate nick list after this
+
+// ─── Per-connection state ────────────────────────────────────
+
+const splitState = new Map<string, {
+  groups: SplitGroup[]
+  /** nick → SplitGroup mapping for fast netjoin lookup */
+  nickIndex: Map<string, SplitGroup>
+  netjoins: NetjoinGroup[]
+  timer: ReturnType<typeof setInterval> | null
+}>()
+
+function getState(connId: string) {
+  let s = splitState.get(connId)
+  if (!s) {
+    s = { groups: [], nickIndex: new Map(), netjoins: [], timer: null }
+    splitState.set(connId, s)
+  }
+  if (!s.timer) {
+    s.timer = setInterval(() => tick(connId), 1_000)
+  }
+  return s
+}
+
+/** Clean up when disconnecting. */
+export function destroyNetsplitState(connId: string) {
+  const s = splitState.get(connId)
+  if (s?.timer) clearInterval(s.timer)
+  splitState.delete(connId)
+}
+
+// ─── Detection ───────────────────────────────────────────────
+
+/**
+ * Check if a QUIT message looks like a netsplit.
+ * Format: "host1.domain host2.domain" — two valid hostnames separated by a single space.
+ */
+export function isNetsplitQuit(message: string): boolean {
+  if (!message) return false
+  // Must not contain : or / (avoids URLs and other messages)
+  if (message.includes(":") || message.includes("/")) return false
+
+  const space = message.indexOf(" ")
+  if (space <= 0 || space === message.length - 1) return false
+  // Only one space
+  if (message.indexOf(" ", space + 1) !== -1) return false
+
+  const host1 = message.slice(0, space)
+  const host2 = message.slice(space + 1)
+
+  return isValidSplitHost(host1) && isValidSplitHost(host2) && host1 !== host2
+}
+
+function isValidSplitHost(host: string): boolean {
+  if (host.length < 3) return false
+  if (host.startsWith(".") || host.endsWith(".")) return false
+  if (host.includes("..")) return false
+
+  const dot = host.lastIndexOf(".")
+  if (dot <= 0) return false
+
+  const tld = host.slice(dot + 1)
+  if (tld.length < 2) return false
+  if (!/^[a-zA-Z]+$/.test(tld)) return false
+
+  return true
+}
+
+// ─── Quit handling ───────────────────────────────────────────
+
+/**
+ * Process a QUIT that looks like a netsplit.
+ * Returns true if it was handled (suppress normal quit display).
+ */
+export function handleNetsplitQuit(
+  connId: string,
+  nick: string,
+  message: string,
+  affectedBufferIds: string[],
+): boolean {
+  if (!isNetsplitQuit(message)) return false
+
+  const space = message.indexOf(" ")
+  const server1 = message.slice(0, space)
+  const server2 = message.slice(space + 1)
+  const state = getState(connId)
+  const now = Date.now()
+
+  // Find existing group for this server pair
+  let group = state.groups.find(
+    (g) => g.server1 === server1 && g.server2 === server2 && !g.printed,
+  )
+
+  if (!group) {
+    group = { server1, server2, nicks: [], lastQuit: now, printed: false }
+    state.groups.push(group)
+  }
+
+  group.nicks.push({ nick, channels: affectedBufferIds })
+  group.lastQuit = now
+  state.nickIndex.set(nick, group)
+
+  return true
+}
+
+// ─── Join handling (netjoin) ─────────────────────────────────
+
+/**
+ * Check if a JOIN is from a user who was in a netsplit.
+ * Returns true if it was handled (suppress normal join display).
+ */
+export function handleNetsplitJoin(
+  connId: string,
+  nick: string,
+  bufferId: string,
+): boolean {
+  const state = splitState.get(connId)
+  if (!state) return false
+
+  const splitGroup = state.nickIndex.get(nick)
+  if (!splitGroup) return false
+
+  // This nick was in a netsplit — batch the rejoin
+  const now = Date.now()
+  const key = `${splitGroup.server1} ${splitGroup.server2}`
+
+  let njGroup = state.netjoins.find(
+    (g) => g.server1 === splitGroup.server1 && g.server2 === splitGroup.server2 && !g.printed,
+  )
+
+  if (!njGroup) {
+    njGroup = {
+      server1: splitGroup.server1,
+      server2: splitGroup.server2,
+      nicks: [],
+      channels: new Set(),
+      lastJoin: now,
+      printed: false,
+    }
+    state.netjoins.push(njGroup)
+  }
+
+  if (!njGroup.nicks.includes(nick)) {
+    njGroup.nicks.push(nick)
+  }
+  njGroup.channels.add(bufferId)
+  njGroup.lastJoin = now
+
+  // Remove from split index
+  state.nickIndex.delete(nick)
+
+  return true
+}
+
+// ─── Tick — check for batches to print ───────────────────────
+
+function tick(connId: string) {
+  const state = splitState.get(connId)
+  if (!state) return
+  const now = Date.now()
+
+  // Print split groups that have been quiet for SPLIT_BATCH_WAIT
+  for (const group of state.groups) {
+    if (!group.printed && now - group.lastQuit >= SPLIT_BATCH_WAIT) {
+      printSplitGroup(connId, group)
+      group.printed = true
+    }
+  }
+
+  // Print netjoin groups that have been quiet for NETJOIN_BATCH_WAIT
+  for (const nj of state.netjoins) {
+    if (!nj.printed && now - nj.lastJoin >= NETJOIN_BATCH_WAIT) {
+      printNetjoinGroup(connId, nj)
+      nj.printed = true
+    }
+  }
+
+  // Expire old split records
+  state.groups = state.groups.filter((g) => now - g.lastQuit < SPLIT_EXPIRE)
+  state.netjoins = state.netjoins.filter((nj) => now - nj.lastJoin < SPLIT_EXPIRE)
+
+  // Clean up nick index for expired groups
+  for (const [nick, group] of state.nickIndex) {
+    if (now - group.lastQuit >= SPLIT_EXPIRE) {
+      state.nickIndex.delete(nick)
+    }
+  }
+
+  // If nothing left, stop the timer
+  if (state.groups.length === 0 && state.netjoins.length === 0 && state.nickIndex.size === 0) {
+    if (state.timer) {
+      clearInterval(state.timer)
+      state.timer = null
+    }
+  }
+}
+
+// ─── Printing ────────────────────────────────────────────────
+
+function makeEventMessage(text: string): Message {
+  return {
+    id: crypto.randomUUID(),
+    timestamp: new Date(),
+    type: "event",
+    text,
+    highlight: false,
+  }
+}
+
+function printSplitGroup(connId: string, group: SplitGroup) {
+  const store = useStore.getState()
+
+  // Collect all affected buffer IDs
+  const allBufferIds = new Set<string>()
+  for (const rec of group.nicks) {
+    for (const id of rec.channels) allBufferIds.add(id)
+  }
+
+  // Build nick list with truncation
+  const nickNames = group.nicks.map((r) => r.nick)
+  let nickStr: string
+  if (nickNames.length > MAX_NICKS_DISPLAY) {
+    const shown = nickNames.slice(0, MAX_NICKS_DISPLAY).join(", ")
+    const more = nickNames.length - MAX_NICKS_DISPLAY
+    nickStr = `${shown} %Z565f89(+${more} more)%N`
+  } else {
+    nickStr = nickNames.join(", ")
+  }
+
+  const msg = `%Zf7768eNetsplit%N %Za9b1d6${group.server1}%N %Z565f89\u21C4%N %Za9b1d6${group.server2}%N %Z565f89quits:%N %Ze0af68${nickStr}%N`
+
+  // Show in all affected channels
+  for (const bufferId of allBufferIds) {
+    if (store.buffers.has(bufferId)) {
+      store.addMessage(bufferId, makeEventMessage(msg))
+    }
+  }
+}
+
+function printNetjoinGroup(connId: string, group: NetjoinGroup) {
+  const store = useStore.getState()
+
+  let nickStr: string
+  if (group.nicks.length > MAX_NICKS_DISPLAY) {
+    const shown = group.nicks.slice(0, MAX_NICKS_DISPLAY).join(", ")
+    const more = group.nicks.length - MAX_NICKS_DISPLAY
+    nickStr = `${shown} %Z565f89(+${more} more)%N`
+  } else {
+    nickStr = group.nicks.join(", ")
+  }
+
+  const msg = `%Z9ece6aNetsplit over%N %Za9b1d6${group.server1}%N %Z565f89\u21C4%N %Za9b1d6${group.server2}%N %Z565f89joins:%N %Ze0af68${nickStr}%N`
+
+  for (const bufferId of group.channels) {
+    if (store.buffers.has(bufferId)) {
+      store.addMessage(bufferId, makeEventMessage(msg))
+    }
+  }
+}