kokoirc 0.2.0

package/src/core/scripts/types.ts

@@ -0,0 +1,256 @@
+import type { Connection, Buffer, Message } from "@/types"
+import type { AppConfig } from "@/types/config"
+import type { Client } from "kofany-irc-framework"
+
+// ─── Event System ────────────────────────────────────────────
+
+export enum EventPriority {
+  HIGHEST = 100,
+  HIGH = 75,
+  NORMAL = 50,
+  LOW = 25,
+  LOWEST = 0,
+}
+
+export interface EventContext {
+  /** Prevent lower-priority handlers and built-in store update from running.
+   *  Must be called synchronously (before any await). */
+  stop(): void
+  stopped: boolean
+}
+
+export type EventHandler = (data: any, ctx: EventContext) => void | Promise<void>
+
+export interface EventRegistration {
+  event: string
+  handler: EventHandler
+  priority: number
+  once: boolean
+  owner: string
+}
+
+// ─── Script Module ───────────────────────────────────────────
+
+export interface ScriptMeta {
+  name: string
+  version?: string
+  description?: string
+}
+
+export interface ScriptModule {
+  meta?: ScriptMeta
+  config?: Record<string, any>
+  default: (api: KokoAPI) => void | (() => void)
+}
+
+// ─── Commands ────────────────────────────────────────────────
+
+export interface ScriptCommandDef {
+  handler: (args: string[], connectionId: string) => void
+  description: string
+  usage?: string
+}
+
+// ─── Timers ──────────────────────────────────────────────────
+
+export interface TimerHandle {
+  clear(): void
+}
+
+// ─── Store Access (read-only) ────────────────────────────────
+
+export interface StoreAccess {
+  getConnections(): Map<string, Connection>
+  getBuffers(): Map<string, Buffer>
+  getActiveBufferId(): string | null
+  getConfig(): AppConfig | null
+  getConnection(id: string): Connection | undefined
+  getBuffer(id: string): Buffer | undefined
+  subscribe(listener: () => void): () => void
+}
+
+// ─── IRC Access ──────────────────────────────────────────────
+
+export interface IrcAccess {
+  say(target: string, message: string, connectionId?: string): void
+  action(target: string, message: string, connectionId?: string): void
+  notice(target: string, message: string, connectionId?: string): void
+  join(channel: string, key?: string, connectionId?: string): void
+  part(channel: string, message?: string, connectionId?: string): void
+  raw(line: string, connectionId?: string): void
+  changeNick(nick: string, connectionId?: string): void
+  whois(nick: string, connectionId?: string): void
+  getClient(connectionId?: string): Client | undefined
+}
+
+// ─── UI Access ───────────────────────────────────────────────
+
+export interface UiAccess {
+  addLocalEvent(text: string): void
+  addMessage(bufferId: string, message: Omit<Message, "id" | "timestamp">): void
+  switchBuffer(bufferId: string): void
+  makeBufferId(connectionId: string, name: string): string
+}
+
+// ─── Config Access ───────────────────────────────────────────
+
+export interface ScriptConfigAccess {
+  get<T = any>(key: string, defaultValue: T): T
+  set(key: string, value: any): void
+}
+
+// ─── KokoAPI ─────────────────────────────────────────────────
+
+export interface KokoAPI {
+  meta: ScriptMeta
+
+  // Events
+  on(event: string, handler: EventHandler, priority?: number): () => void
+  once(event: string, handler: EventHandler, priority?: number): () => void
+  emit(event: string, data?: any): boolean
+
+  // Commands
+  command(name: string, def: ScriptCommandDef): void
+  removeCommand(name: string): void
+
+  // Timers
+  timer(ms: number, handler: () => void): TimerHandle
+  timeout(ms: number, handler: () => void): TimerHandle
+
+  // Access
+  store: StoreAccess
+  irc: IrcAccess
+  ui: UiAccess
+  config: ScriptConfigAccess
+
+  /** Event priority constants — use instead of importing EventPriority */
+  EventPriority: typeof EventPriority
+
+  log(...args: any[]): void
+}
+
+// ─── Event Payloads ──────────────────────────────────────────
+
+export interface IrcMessageEvent {
+  connectionId: string
+  nick: string
+  ident?: string
+  hostname?: string
+  target: string
+  message: string
+  tags?: Record<string, string>
+  time?: string
+  isChannel: boolean
+}
+
+export interface IrcJoinEvent {
+  connectionId: string
+  nick: string
+  ident?: string
+  hostname?: string
+  channel: string
+  account?: string
+}
+
+export interface IrcPartEvent {
+  connectionId: string
+  nick: string
+  ident?: string
+  hostname?: string
+  channel: string
+  message?: string
+}
+
+export interface IrcQuitEvent {
+  connectionId: string
+  nick: string
+  ident?: string
+  hostname?: string
+  message?: string
+}
+
+export interface IrcKickEvent {
+  connectionId: string
+  nick: string
+  ident?: string
+  hostname?: string
+  channel: string
+  kicked: string
+  message?: string
+}
+
+export interface IrcNickEvent {
+  connectionId: string
+  nick: string
+  new_nick: string
+  ident?: string
+  hostname?: string
+}
+
+export interface IrcTopicEvent {
+  connectionId: string
+  nick?: string
+  channel: string
+  topic: string
+}
+
+export interface IrcModeEvent {
+  connectionId: string
+  nick?: string
+  target: string
+  modes: Array<{ mode: string; param?: string }>
+}
+
+export interface IrcInviteEvent {
+  connectionId: string
+  nick: string
+  channel: string
+}
+
+export interface IrcNoticeEvent {
+  connectionId: string
+  nick?: string
+  target?: string
+  message: string
+  from_server?: boolean
+}
+
+export interface IrcCtcpEvent {
+  connectionId: string
+  nick: string
+  type: string
+  message?: string
+}
+
+export interface IrcWallopsEvent {
+  connectionId: string
+  nick?: string
+  message: string
+  from_server?: boolean
+}
+
+// App events
+export interface MessageAddEvent {
+  bufferId: string
+  message: Message
+}
+
+export interface BufferSwitchEvent {
+  from: string | null
+  to: string
+}
+
+export interface CommandInputEvent {
+  command: string
+  args: string[]
+  connectionId: string
+}
+
+export interface ConnectedEvent {
+  connectionId: string
+  nick: string
+}
+
+export interface DisconnectedEvent {
+  connectionId: string
+}

package/src/core/state/selectors.ts

@@ -0,0 +1,39 @@
+import { useMemo } from "react"
+import { useStore } from "./store"
+import { sortBuffers, sortNicks } from "./sorting"
+import type { Buffer, NickEntry } from "@/types"
+
+export function useActiveBuffer(): Buffer | null {
+  const activeBufferId = useStore((s) => s.activeBufferId)
+  const buffersMap = useStore((s) => s.buffers)
+  return activeBufferId ? buffersMap.get(activeBufferId) ?? null : null
+}
+
+export function useSortedBuffers(): Array<Buffer & { connectionLabel: string }> {
+  const buffersMap = useStore((s) => s.buffers)
+  const connectionsMap = useStore((s) => s.connections)
+  return useMemo(() => {
+    const list = Array.from(buffersMap.values())
+      .filter((buf) => buf.connectionId !== "_default")
+      .map((buf) => ({
+        ...buf,
+        connectionLabel: connectionsMap.get(buf.connectionId)?.label ?? buf.connectionId,
+      }))
+    return sortBuffers(list)
+  }, [buffersMap, connectionsMap])
+}
+
+const EMPTY_NICKS: NickEntry[] = []
+
+export function useSortedNicks(bufferId: string, prefixOrder: string): NickEntry[] {
+  const buffersMap = useStore((s) => s.buffers)
+  const buffer = buffersMap.get(bufferId)
+  return useMemo(() => {
+    if (!buffer) return EMPTY_NICKS
+    return sortNicks(Array.from(buffer.users.values()), prefixOrder)
+  }, [buffer, prefixOrder])
+}
+
+export function useConnection(id: string) {
+  return useStore((s) => s.connections.get(id))
+}

package/src/core/state/sorting.ts

@@ -0,0 +1,30 @@
+import type { Buffer, NickEntry } from "@/types"
+import { getSortGroup } from "@/types"
+
+interface SortableBuffer {
+  connectionLabel: string
+  type: Buffer["type"]
+  name: string
+}
+
+export function sortBuffers<T extends SortableBuffer>(buffers: T[]): T[] {
+  return [...buffers].sort((a, b) => {
+    const labelCmp = a.connectionLabel.localeCompare(b.connectionLabel, undefined, { sensitivity: "base" })
+    if (labelCmp !== 0) return labelCmp
+    const groupA = getSortGroup(a.type)
+    const groupB = getSortGroup(b.type)
+    if (groupA !== groupB) return groupA - groupB
+    return a.name.localeCompare(b.name, undefined, { sensitivity: "base" })
+  })
+}
+
+export function sortNicks(nicks: NickEntry[], prefixOrder: string): NickEntry[] {
+  return [...nicks].sort((a, b) => {
+    const prefixA = a.prefix ? prefixOrder.indexOf(a.prefix) : prefixOrder.length
+    const prefixB = b.prefix ? prefixOrder.indexOf(b.prefix) : prefixOrder.length
+    const pA = prefixA === -1 ? prefixOrder.length : prefixA
+    const pB = prefixB === -1 ? prefixOrder.length : prefixB
+    if (pA !== pB) return pA - pB
+    return a.nick.localeCompare(b.nick, undefined, { sensitivity: "base" })
+  })
+}

package/src/core/state/store.ts

@@ -0,0 +1,242 @@
+import { create } from "zustand"
+import type { Connection, Buffer, Message, NickEntry, ActivityLevel, ListEntry, ListModeKey } from "@/types"
+import type { AppConfig } from "@/types/config"
+import type { ThemeFile } from "@/types/theme"
+import { logMessage, updateReadMarker } from "@/core/storage"
+
+interface AppState {
+  // Data
+  connections: Map<string, Connection>
+  buffers: Map<string, Buffer>
+  activeBufferId: string | null
+  previousActiveBufferId: string | null
+  config: AppConfig | null
+  theme: ThemeFile | null
+
+  // Connection actions
+  addConnection: (conn: Connection) => void
+  updateConnection: (id: string, updates: Partial<Connection>) => void
+  removeConnection: (id: string) => void
+
+  // Buffer actions
+  addBuffer: (buffer: Buffer) => void
+  removeBuffer: (id: string) => void
+  setActiveBuffer: (id: string) => void
+  updateBufferActivity: (id: string, level: ActivityLevel) => void
+
+  // Message actions
+  addMessage: (bufferId: string, message: Message) => void
+
+  // Nicklist actions
+  addNick: (bufferId: string, entry: NickEntry) => void
+  removeNick: (bufferId: string, nick: string) => void
+  updateNick: (bufferId: string, oldNick: string, newNick: string, prefix?: string) => void
+
+  // Buffer topic & modes
+  updateBufferTopic: (bufferId: string, topic: string, setBy?: string) => void
+  updateBufferModes: (bufferId: string, modes: string, modeParams?: Record<string, string>) => void
+
+  // List modes (bans, exceptions, invex, reop)
+  setListEntries: (bufferId: string, modeChar: ListModeKey, entries: ListEntry[]) => void
+  addListEntry: (bufferId: string, modeChar: ListModeKey, entry: ListEntry) => void
+  removeListEntry: (bufferId: string, modeChar: ListModeKey, mask: string) => void
+
+  // Config/Theme
+  setConfig: (config: AppConfig) => void
+  setTheme: (theme: ThemeFile) => void
+
+  // App lifecycle
+  shutdownHandler: (() => void) | null
+  setShutdownHandler: (handler: () => void) => void
+  requestShutdown: () => void
+}
+
+export const useStore = create<AppState>((set, get) => ({
+  connections: new Map(),
+  buffers: new Map(),
+  activeBufferId: null,
+  previousActiveBufferId: null,
+  config: null,
+  theme: null,
+
+  addConnection: (conn) => set((s) => {
+    const connections = new Map(s.connections)
+    connections.set(conn.id, conn)
+    return { connections }
+  }),
+
+  updateConnection: (id, updates) => set((s) => {
+    const connections = new Map(s.connections)
+    const existing = connections.get(id)
+    if (existing) connections.set(id, { ...existing, ...updates })
+    return { connections }
+  }),
+
+  removeConnection: (id) => set((s) => {
+    const connections = new Map(s.connections)
+    connections.delete(id)
+    return { connections }
+  }),
+
+  addBuffer: (buffer) => set((s) => {
+    const buffers = new Map(s.buffers)
+    buffers.set(buffer.id, buffer)
+    return { buffers }
+  }),
+
+  removeBuffer: (id) => set((s) => {
+    const buffers = new Map(s.buffers)
+    buffers.delete(id)
+    if (s.activeBufferId !== id) return { buffers }
+    // Fall back to previous buffer if it still exists, otherwise null
+    const fallback = s.previousActiveBufferId && buffers.has(s.previousActiveBufferId)
+      ? s.previousActiveBufferId : null
+    return { buffers, activeBufferId: fallback }
+  }),
+
+  setActiveBuffer: (id) => {
+    // Persist read marker for TUI client
+    const slashIdx = id.indexOf("/")
+    if (slashIdx > 0) {
+      const network = id.slice(0, slashIdx)
+      const buffer = id.slice(slashIdx + 1)
+      updateReadMarker(network, buffer, "tui", Date.now())
+    }
+
+    return set((s) => {
+      // Reset activity when switching to buffer
+      const buffers = new Map(s.buffers)
+      const buf = buffers.get(id)
+      if (buf) {
+        buffers.set(id, { ...buf, activity: 0, unreadCount: 0, lastRead: new Date() })
+      }
+      const previousActiveBufferId = s.activeBufferId !== id ? s.activeBufferId : s.previousActiveBufferId
+      return { activeBufferId: id, previousActiveBufferId, buffers }
+    })
+  },
+
+  updateBufferActivity: (id, level) => set((s) => {
+    const buffers = new Map(s.buffers)
+    const buf = buffers.get(id)
+    if (buf && level > buf.activity) {
+      buffers.set(id, { ...buf, activity: level, unreadCount: buf.unreadCount + 1 })
+    }
+    return { buffers }
+  }),
+
+  addMessage: (bufferId, message) => {
+    // Log to persistent storage (fire-and-forget, outside Zustand set)
+    const slashIdx = bufferId.indexOf("/")
+    if (slashIdx > 0) {
+      const network = bufferId.slice(0, slashIdx)
+      const buffer = bufferId.slice(slashIdx + 1)
+      logMessage(network, buffer, message.id, message.type, message.text, message.nick ?? null, message.highlight, message.timestamp)
+    }
+
+    return set((s) => {
+      const buffers = new Map(s.buffers)
+      const buf = buffers.get(bufferId)
+      if (!buf) return s
+      const maxLines = s.config?.display.scrollback_lines ?? 2000
+      const messages = [...buf.messages, message]
+      if (messages.length > maxLines) messages.splice(0, messages.length - maxLines)
+      buffers.set(bufferId, { ...buf, messages })
+      return { buffers }
+    })
+  },
+
+  addNick: (bufferId, entry) => set((s) => {
+    const buffers = new Map(s.buffers)
+    const buf = buffers.get(bufferId)
+    if (!buf) return s
+    const users = new Map(buf.users)
+    users.set(entry.nick, entry)
+    buffers.set(bufferId, { ...buf, users })
+    return { buffers }
+  }),
+
+  removeNick: (bufferId, nick) => set((s) => {
+    const buffers = new Map(s.buffers)
+    const buf = buffers.get(bufferId)
+    if (!buf) return s
+    const users = new Map(buf.users)
+    users.delete(nick)
+    buffers.set(bufferId, { ...buf, users })
+    return { buffers }
+  }),
+
+  updateNick: (bufferId, oldNick, newNick, prefix) => set((s) => {
+    const buffers = new Map(s.buffers)
+    const buf = buffers.get(bufferId)
+    if (!buf) return s
+    const users = new Map(buf.users)
+    const existing = users.get(oldNick)
+    if (existing) {
+      users.delete(oldNick)
+      users.set(newNick, { ...existing, nick: newNick, prefix: prefix ?? existing.prefix })
+    }
+    buffers.set(bufferId, { ...buf, users })
+    return { buffers }
+  }),
+
+  updateBufferTopic: (bufferId, topic, setBy) => set((s) => {
+    const buffers = new Map(s.buffers)
+    const buf = buffers.get(bufferId)
+    if (!buf) return s
+    buffers.set(bufferId, { ...buf, topic, topicSetBy: setBy })
+    return { buffers }
+  }),
+
+  updateBufferModes: (bufferId, modes, modeParams) => set((s) => {
+    const buffers = new Map(s.buffers)
+    const buf = buffers.get(bufferId)
+    if (!buf) return s
+    buffers.set(bufferId, { ...buf, modes, modeParams: modeParams ?? buf.modeParams })
+    return { buffers }
+  }),
+
+  setListEntries: (bufferId, modeChar, entries) => set((s) => {
+    const buffers = new Map(s.buffers)
+    const buf = buffers.get(bufferId)
+    if (!buf) return s
+    const listModes = new Map(buf.listModes)
+    listModes.set(modeChar, entries)
+    buffers.set(bufferId, { ...buf, listModes })
+    return { buffers }
+  }),
+
+  addListEntry: (bufferId, modeChar, entry) => set((s) => {
+    const buffers = new Map(s.buffers)
+    const buf = buffers.get(bufferId)
+    if (!buf) return s
+    const listModes = new Map(buf.listModes)
+    const existing = listModes.get(modeChar) ?? []
+    // Deduplicate by mask
+    if (existing.some((e) => e.mask === entry.mask)) return s
+    listModes.set(modeChar, [...existing, entry])
+    buffers.set(bufferId, { ...buf, listModes })
+    return { buffers }
+  }),
+
+  removeListEntry: (bufferId, modeChar, mask) => set((s) => {
+    const buffers = new Map(s.buffers)
+    const buf = buffers.get(bufferId)
+    if (!buf) return s
+    const listModes = new Map(buf.listModes)
+    const existing = listModes.get(modeChar)
+    if (!existing) return s
+    listModes.set(modeChar, existing.filter((e) => e.mask !== mask))
+    buffers.set(bufferId, { ...buf, listModes })
+    return { buffers }
+  }),
+
+  setConfig: (config) => set({ config }),
+  setTheme: (theme) => set({ theme }),
+
+  shutdownHandler: null,
+  setShutdownHandler: (handler) => set({ shutdownHandler: handler }),
+  requestShutdown: () => {
+    const handler = get().shutdownHandler
+    if (handler) handler()
+  },
+}))

package/src/core/storage/crypto.ts

@@ -0,0 +1,78 @@
+import { chmod } from "node:fs/promises"
+import { ENV_PATH } from "@/core/constants"
+
+const ALGORITHM = "AES-GCM"
+const KEY_LENGTH = 256
+const IV_LENGTH = 12
+const ENV_KEY_NAME = "KOKO_LOG_KEY"
+
+let cachedKey: CryptoKey | null = null
+
+/** Generate a random 256-bit hex key string. */
+export function generateKeyHex(): string {
+  const bytes = new Uint8Array(KEY_LENGTH / 8)
+  crypto.getRandomValues(bytes)
+  return Buffer.from(bytes).toString("hex")
+}
+
+/** Import a hex key string into a CryptoKey. */
+async function importKey(hexKey: string): Promise<CryptoKey> {
+  const raw = Buffer.from(hexKey, "hex")
+  return crypto.subtle.importKey("raw", raw, { name: ALGORITHM }, false, ["encrypt", "decrypt"])
+}
+
+/** Encrypt plaintext. Returns { ciphertext: base64, iv: 12-byte Uint8Array }. */
+export async function encrypt(
+  text: string,
+  key: CryptoKey,
+): Promise<{ ciphertext: string; iv: Uint8Array }> {
+  const iv = new Uint8Array(IV_LENGTH)
+  crypto.getRandomValues(iv)
+  const encoded = new TextEncoder().encode(text)
+  const encrypted = await crypto.subtle.encrypt({ name: ALGORITHM, iv }, key, encoded)
+  return {
+    ciphertext: Buffer.from(encrypted).toString("base64"),
+    iv,
+  }
+}
+
+/** Decrypt base64 ciphertext with the given IV. */
+export async function decrypt(
+  ciphertext: string,
+  iv: Uint8Array,
+  key: CryptoKey,
+): Promise<string> {
+  const data = Buffer.from(ciphertext, "base64")
+  const decrypted = await crypto.subtle.decrypt({ name: ALGORITHM, iv: new Uint8Array(iv) }, key, data)
+  return new TextDecoder().decode(decrypted)
+}
+
+/** Load key from .env, or generate and save one if missing. Returns CryptoKey. */
+export async function loadOrCreateKey(): Promise<CryptoKey> {
+  if (cachedKey) return cachedKey
+
+  const file = Bun.file(ENV_PATH)
+  let content = (await file.exists()) ? await file.text() : ""
+
+  // Try to find existing key
+  const match = content.match(new RegExp(`^${ENV_KEY_NAME}=(.+)$`, "m"))
+  let hexKey: string
+
+  if (match) {
+    hexKey = match[1].trim()
+  } else {
+    // Generate and append to .env
+    hexKey = generateKeyHex()
+    content = content.trimEnd() + (content.length > 0 ? "\n" : "") + `${ENV_KEY_NAME}=${hexKey}\n`
+    await Bun.write(ENV_PATH, content)
+    await chmod(ENV_PATH, 0o600)
+  }
+
+  cachedKey = await importKey(hexKey)
+  return cachedKey
+}
+
+/** Clear cached key (for testing). */
+export function clearKeyCache(): void {
+  cachedKey = null
+}