kokoirc 0.2.2 → 0.2.4

package/src/core/image-preview/encode.ts

@@ -0,0 +1,116 @@
+import { image2sixel } from "sixel"
+
+const ESC = "\x1b"
+const ST = `${ESC}\\`
+
+// ─── tmux DCS passthrough ────────────────────────────────────
+
+/** Wrap an escape sequence in tmux DCS passthrough */
+export function wrapTmuxDCS(sequence: string): string {
+  // Escape all ESC bytes inside the payload
+  const escaped = sequence.replace(/\x1b/g, "\x1b\x1b")
+  return `${ESC}Ptmux;${escaped}${ST}`
+}
+
+// ─── Kitty Graphics Protocol ─────────────────────────────────
+//
+// Each chunk is a self-contained ESC_G...ESC\ sequence.
+// First chunk carries metadata (a=T,f=,s=,v=,c=,r=) + payload.
+// Continuation chunks carry m=1 + payload. Last chunk has m=0.
+//
+// q=2 suppresses terminal responses (prevents PTY echo issues).
+// Each chunk MUST be written to stdout as a separate writeSync call
+// (see render.ts) — subterm's async write pipeline can race when
+// processing many sequences delivered in a single large buffer.
+
+export type KittyFormat = "rgba" | "png"
+
+/** Encode RGBA pixels as Kitty APC sequences using f=32 (raw RGBA). */
+export function encodeKittyRGBA(rgbaBuffer: Buffer, width: number, height: number, cols: number, rows: number): string[] {
+  return encodeKittyChunked(rgbaBuffer.toString("base64"), `a=T,q=2,f=32,s=${width},v=${height},c=${cols},r=${rows}`)
+}
+
+/** Encode a PNG buffer as Kitty APC sequences using f=100 (PNG). */
+export function encodeKittyPNG(pngBuffer: Buffer, cols: number, rows: number): string[] {
+  return encodeKittyChunked(pngBuffer.toString("base64"), `a=T,q=2,f=100,c=${cols},r=${rows}`)
+}
+
+/** Split base64 into Kitty APC chunks. First chunk includes metadata. */
+function encodeKittyChunked(b64: string, firstChunkParams: string): string[] {
+  // tmux DCS passthrough buffer is 4096 bytes (tmux < 3.4).
+  // First chunk overhead: ~80 bytes params + 11 bytes framing = ~91.
+  // Continuation overhead: ~11 bytes. DCS wrap adds ~22.
+  // 3800 + 91 + 22 = 3913, safely under 4096.
+  const CHUNK_SIZE = 3800
+  const parts: string[] = []
+
+  for (let i = 0, idx = 0; i < b64.length; i += CHUNK_SIZE, idx++) {
+    const chunk = b64.slice(i, i + CHUNK_SIZE)
+    const isFirst = idx === 0
+    const isLast = i + CHUNK_SIZE >= b64.length
+    const m = isLast ? 0 : 1
+
+    if (isFirst) {
+      parts.push(`${ESC}_G${firstChunkParams},m=${m};${chunk}${ST}`)
+    } else {
+      parts.push(`${ESC}_Gm=${m};${chunk}${ST}`)
+    }
+  }
+
+  return parts
+}
+
+// ─── iTerm2 Inline Image Protocol ────────────────────────────
+
+/** Encode an image buffer as a raw iTerm2 inline image sequence */
+export function encodeIterm2(imageBuffer: Buffer, cols: number, rows: number): string {
+  const b64 = imageBuffer.toString("base64")
+  // preserveAspectRatio=0: we already calculated correct dimensions in render.ts,
+  // so let iTerm2 stretch to fill the cell area. Using 1 causes double-correction.
+  return `${ESC}]1337;File=inline=1;width=${cols};height=${rows};preserveAspectRatio=0:${b64}\x07`
+}
+
+// ─── Sixel Encoding ──────────────────────────────────────────
+
+/** Encode raw RGBA pixels as a raw sixel sequence */
+export function encodeSixel(rgbaBuffer: Buffer, width: number, height: number): string {
+  // Create a clean Uint8ClampedArray from a copy — Buffer.buffer is the shared Node pool
+  const copy = new Uint8ClampedArray(rgbaBuffer.length)
+  copy.set(rgbaBuffer)
+  return image2sixel(copy, width, height, 256)
+}
+
+// ─── Unicode Half-Block Fallback ─────────────────────────────
+
+/** Encode RGBA pixels as Unicode half-block characters with 24-bit ANSI color */
+export function encodeSymbols(rgbaBuffer: Buffer, width: number, height: number): string {
+  const lines: string[] = []
+
+  for (let y = 0; y < height; y += 2) {
+    let line = ""
+    for (let x = 0; x < width; x++) {
+      // Top pixel
+      const topIdx = (y * width + x) * 4
+      const tr = rgbaBuffer[topIdx]
+      const tg = rgbaBuffer[topIdx + 1]
+      const tb = rgbaBuffer[topIdx + 2]
+
+      // Bottom pixel (may be beyond height)
+      if (y + 1 < height) {
+        const botIdx = ((y + 1) * width + x) * 4
+        const br = rgbaBuffer[botIdx]
+        const bg = rgbaBuffer[botIdx + 1]
+        const bb = rgbaBuffer[botIdx + 2]
+        // ▀ = upper half block: fg=top, bg=bottom
+        line += `${ESC}[38;2;${tr};${tg};${tb}m${ESC}[48;2;${br};${bg};${bb}m▀`
+      } else {
+        // Last odd row: only top pixel
+        line += `${ESC}[38;2;${tr};${tg};${tb}m▀`
+      }
+    }
+    line += `${ESC}[0m`
+    lines.push(line)
+  }
+
+  return lines.join("\n")
+}

package/src/core/image-preview/fetch.ts

@@ -0,0 +1,174 @@
+import type { ImagePreviewConfig } from "@/types/config"
+
+export type UrlType = "direct_image" | "page_imgur" | "page_imgbb" | "page_generic"
+
+const IMAGE_EXT_RE = /\.(jpe?g|png|gif|webp|bmp)(\?.*)?$/i
+const DIRECT_HOST_RE = /^i\.(imgur\.com|ibb\.co)$/i
+const IMGUR_PAGE_RE = /^(www\.)?imgur\.com\//i
+const IMGBB_PAGE_RE = /^(www\.)?ibb\.co\//i
+
+const USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+
+/** Classify a URL — returns null only for non-HTTP URLs */
+export function classifyUrl(url: string): UrlType | null {
+  let parsed: URL
+  try {
+    parsed = new URL(url)
+  } catch {
+    return null
+  }
+
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null
+
+  // Direct image by extension
+  if (IMAGE_EXT_RE.test(parsed.pathname)) return "direct_image"
+
+  // Direct image hosts (i.imgur.com, i.ibb.co)
+  if (DIRECT_HOST_RE.test(parsed.host)) return "direct_image"
+
+  // Known image page hosts
+  if (IMGUR_PAGE_RE.test(parsed.host + parsed.pathname)) return "page_imgur"
+  if (IMGBB_PAGE_RE.test(parsed.host + parsed.pathname)) return "page_imgbb"
+
+  // Any other HTTP URL — try as generic page (will check content-type)
+  return "page_generic"
+}
+
+/** Quick check: is this URL likely an image we should try to preview?
+ *  Used by click handler to avoid previewing every random link. */
+export function isLikelyImageUrl(url: string): boolean {
+  let parsed: URL
+  try {
+    parsed = new URL(url)
+  } catch {
+    return false
+  }
+
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false
+
+  // Direct image by extension
+  if (IMAGE_EXT_RE.test(parsed.pathname)) return true
+
+  // Known image hosts
+  if (DIRECT_HOST_RE.test(parsed.host)) return true
+  if (IMGUR_PAGE_RE.test(parsed.host + parsed.pathname)) return true
+  if (IMGBB_PAGE_RE.test(parsed.host + parsed.pathname)) return true
+
+  return false
+}
+
+/** Extract og:image URL from HTML string */
+function extractOgImage(html: string): string | null {
+  const match = html.match(
+    /<meta\s+(?:property="og:image"\s+content="([^"]+)"|content="([^"]+)"\s+property="og:image")/i
+  )
+  return match?.[1] ?? match?.[2] ?? null
+}
+
+/** Get file extension from Content-Type header */
+function extFromContentType(ct: string | null): string {
+  if (!ct) return ".img"
+  if (ct.includes("jpeg") || ct.includes("jpg")) return ".jpg"
+  if (ct.includes("png")) return ".png"
+  if (ct.includes("gif")) return ".gif"
+  if (ct.includes("webp")) return ".webp"
+  if (ct.includes("bmp")) return ".bmp"
+  return ".img"
+}
+
+/** Check if a content-type header indicates an image */
+function isImageContentType(ct: string | null): boolean {
+  if (!ct) return false
+  return ct.startsWith("image/")
+}
+
+/** Fetch a URL body with size limits, return raw Buffer + content-type */
+async function fetchUrl(
+  url: string,
+  config: ImagePreviewConfig,
+  maxSize?: number
+): Promise<{ data: Buffer; contentType: string | null }> {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), config.fetch_timeout * 1000)
+
+  try {
+    const resp = await fetch(url, {
+      signal: controller.signal,
+      headers: { "User-Agent": USER_AGENT },
+      redirect: "follow",
+    })
+
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`)
+
+    const limit = maxSize ?? config.max_file_size
+    const contentLength = parseInt(resp.headers.get("content-length") ?? "0", 10)
+    if (contentLength > limit) {
+      throw new Error(`Too large: ${(contentLength / 1024 / 1024).toFixed(1)}MB`)
+    }
+
+    const reader = resp.body?.getReader()
+    if (!reader) throw new Error("No response body")
+
+    const chunks: Uint8Array[] = []
+    let totalSize = 0
+
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      chunks.push(value)
+      totalSize += value.length
+      if (totalSize > limit) {
+        reader.cancel()
+        throw new Error(`Too large: exceeded ${(limit / 1024 / 1024).toFixed(0)}MB limit`)
+      }
+    }
+
+    return { data: Buffer.concat(chunks), contentType: resp.headers.get("content-type") }
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+/**
+ * Fetch an image from a URL using erssi-style two-phase detection:
+ * 1. Fetch the URL directly
+ * 2. If content-type is image/* → done, return the image data
+ * 3. If content-type is text/html → extract og:image, fetch that instead
+ */
+export async function fetchImage(
+  url: string,
+  config: ImagePreviewConfig
+): Promise<{ data: Buffer; ext: string }> {
+  // Phase 1: Fetch the URL
+  const result = await fetchUrl(url, config)
+
+  // If it's already an image, return directly
+  if (isImageContentType(result.contentType)) {
+    return { data: result.data, ext: extFromContentType(result.contentType) }
+  }
+
+  // Phase 2: If HTML, look for og:image
+  if (result.contentType?.includes("text/html")) {
+    const html = new TextDecoder().decode(result.data)
+    const ogImage = extractOgImage(html)
+
+    if (!ogImage) throw new Error("Page has no og:image")
+
+    // Resolve relative og:image URLs
+    let imageUrl: string
+    try {
+      imageUrl = new URL(ogImage, url).href
+    } catch {
+      imageUrl = ogImage
+    }
+
+    // Fetch the actual image
+    const imgResult = await fetchUrl(imageUrl, config)
+    if (!isImageContentType(imgResult.contentType)) {
+      throw new Error(`og:image URL returned ${imgResult.contentType}, not an image`)
+    }
+    return { data: imgResult.data, ext: extFromContentType(imgResult.contentType) }
+  }
+
+  throw new Error(`URL returned ${result.contentType}, not an image`)
+}

package/src/core/image-preview/index.ts

@@ -0,0 +1,6 @@
+export { detectProtocol, isInsideTmux, getTmuxPaneOffset, type ImageProtocol } from "./detect"
+export { isCached, writeCache, validateImage, cleanupCache } from "./cache"
+export { classifyUrl, isLikelyImageUrl, fetchImage } from "./fetch"
+export { encodeKittyRGBA, encodeKittyPNG, encodeIterm2, encodeSixel, encodeSymbols, wrapTmuxDCS, type KittyFormat } from "./encode"
+export { preparePreview } from "./render"
+export { flushStdin } from "./stdin-guard"

package/src/core/image-preview/render.ts

@@ -0,0 +1,222 @@
+import sharp from "sharp"
+import { writeSync } from "node:fs"
+import { useStore } from "@/core/state/store"
+import { detectProtocol, isInsideTmux } from "./detect"
+import { isCached, writeCache } from "./cache"
+import { classifyUrl, fetchImage } from "./fetch"
+import { encodeKittyRGBA, encodeKittyPNG, encodeIterm2, encodeSixel, encodeSymbols, wrapTmuxDCS, type KittyFormat } from "./encode"
+import { flushStdin } from "./stdin-guard"
+
+// Mouse tracking escape sequences — disable during image write to prevent
+// accumulated stdin mouse events from crashing Bun's event loop (malloc double-free).
+const MOUSE_DISABLE = "\x1b[?1003l\x1b[?1006l\x1b[?1002l\x1b[?1000l"
+const MOUSE_ENABLE  = "\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h"
+
+/** Main pipeline: fetch → cache → encode → write to stdout directly */
+export async function preparePreview(url: string): Promise<void> {
+  const store = useStore.getState()
+  const config = store.config?.image_preview
+
+  if (!config?.enabled) {
+    store.updateImagePreview({ status: "error", error: "Image preview disabled" })
+    return
+  }
+
+  try {
+    // 1. Classify URL
+    const urlType = classifyUrl(url)
+    if (!urlType) {
+      store.updateImagePreview({ status: "error", error: "Not an image URL" })
+      return
+    }
+
+    // 2. Check cache
+    let imagePath = await isCached(url)
+
+    // 3. Fetch if not cached
+    if (!imagePath) {
+      const { data, ext } = await fetchImage(url, config)
+      imagePath = await writeCache(url, data, ext)
+    }
+
+    // Bail if preview was dismissed while we were fetching
+    if (!useStore.getState().imagePreview) return
+
+    // 4. Load with sharp and get metadata
+    const metadata = await sharp(imagePath).metadata()
+    const imgWidth = metadata.width ?? 0
+    const imgHeight = metadata.height ?? 0
+
+    if (imgWidth === 0 || imgHeight === 0) {
+      store.updateImagePreview({ status: "error", error: "Invalid image dimensions" })
+      return
+    }
+
+    // 5. Detect protocol
+    const [protocol] = detectProtocol(config.protocol)
+    const inTmux = isInsideTmux()
+    // Always use PNG for kitty protocol. Raw RGBA (f=32) produces hundreds of
+    // chunks (453 for a 492×656 image) — causes chunk misalignment in terminals
+    // with async parsers (subterm), and hundreds of writeSync calls trigger
+    // malloc double-free in Bun. PNG compresses to ~20-35 chunks, and terminals
+    // decode it natively via createImageBitmap/PNG decoder — more robust.
+    const kittyFmt: KittyFormat = (protocol === "kitty") ? "png" : (config.kitty_format ?? "rgba") as KittyFormat
+
+    // 6. Calculate display dimensions — match erssi's approach:
+    //    max = 75% of terminal, aspect ratio with cellAspect=2, cell geometry 8×16
+    const termCols = process.stdout.columns || 80
+    const termRows = process.stdout.rows || 24
+
+    const maxCols = config.max_width || Math.floor(termCols * 0.75)
+    const maxRows = config.max_height || Math.floor(termRows * 0.75)
+
+    const innerCols = maxCols - 2
+    const innerRows = maxRows - 2
+
+    const cellAspect = 2
+    const imgAspect = imgWidth / imgHeight
+
+    let displayCols: number
+    let displayRows: number
+
+    if (imgAspect * cellAspect > innerCols / innerRows) {
+      displayCols = innerCols
+      displayRows = Math.max(1, Math.round(innerCols / (imgAspect * cellAspect)))
+    } else {
+      displayRows = innerRows
+      displayCols = Math.max(1, Math.round(innerRows * imgAspect * cellAspect))
+    }
+
+    let pixelWidth = protocol === "symbols" ? displayCols : displayCols * 8
+    let pixelHeight = protocol === "symbols" ? displayRows * 2 : displayRows * 16
+
+    // Byte limit like erssi (IMAGE_PREVIEW_MAX_BYTES = 2MB).
+    // Only applies to raw RGBA (f=32) — PNG is already compressed and much smaller.
+    if (protocol !== "symbols" && !(protocol === "kitty" && kittyFmt === "png")) {
+      const MAX_BYTES = 2_000_000
+      // Raw RGBA = W*H*4, base64 overhead = *1.37, DCS overhead = *1.05
+      const estimatedBytes = pixelWidth * pixelHeight * 4 * 1.4
+      if (estimatedBytes > MAX_BYTES) {
+        const scale = Math.sqrt(MAX_BYTES / estimatedBytes)
+        pixelWidth = Math.floor(pixelWidth * scale)
+        pixelHeight = Math.floor(pixelHeight * scale)
+        // Recalculate display cells to match
+        displayCols = Math.max(1, Math.round(pixelWidth / 8))
+        displayRows = Math.max(1, Math.round(pixelHeight / 16))
+      }
+    }
+
+    // 7. Encode based on protocol — returns raw sequences (no DCS wrapping)
+    let rawChunks: string[]
+
+    if (protocol === "kitty") {
+      if (kittyFmt === "png") {
+        // PNG (f=100) — terminal decodes natively, more robust at chunk boundaries
+        const pngBuf = await sharp(imagePath)
+          .resize(pixelWidth, pixelHeight, { fit: "inside" })
+          .png()
+          .toBuffer()
+        rawChunks = encodeKittyPNG(pngBuf, displayCols, displayRows)
+      } else {
+        // Raw RGBA (f=32) — direct pixel data, matches erssi/chafa output
+        const { data, info } = await sharp(imagePath)
+          .resize(pixelWidth, pixelHeight, { fit: "inside" })
+          .ensureAlpha()
+          .raw()
+          .toBuffer({ resolveWithObject: true })
+        const rgbaCopy = Buffer.from(data)
+        rawChunks = encodeKittyRGBA(rgbaCopy, info.width, info.height, displayCols, displayRows)
+      }
+    } else if (protocol === "iterm2") {
+      const resized = await sharp(imagePath)
+        .resize(pixelWidth, pixelHeight, { fit: "inside" })
+        .png()
+        .toBuffer()
+      rawChunks = [encodeIterm2(resized, displayCols, displayRows)]
+    } else if (protocol === "sixel") {
+      const { data, info } = await sharp(imagePath)
+        .resize(pixelWidth, pixelHeight, { fit: "inside" })
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true })
+      const rgbaCopy = Buffer.from(data)
+      rawChunks = [encodeSixel(rgbaCopy, info.width, info.height)]
+    } else {
+      const { data, info } = await sharp(imagePath)
+        .resize(displayCols, displayRows * 2, { fit: "inside" })
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true })
+      const rgbaCopy = Buffer.from(data)
+      rawChunks = [encodeSymbols(rgbaCopy, info.width, info.height)]
+    }
+
+    // Bail if preview was dismissed while we were encoding
+    if (!useStore.getState().imagePreview) return
+
+    const title = decodeURIComponent(url.split("/").pop()?.split("?")[0] ?? url).slice(0, 40)
+
+    // 8. Update store with dimensions (NO encoded data — it stays out of React)
+    store.updateImagePreview({
+      status: "ready",
+      width: displayCols + 2,
+      height: displayRows + 2,
+      title,
+      protocol,
+    })
+
+    // 9. Write image directly to stdout, bypassing React/OpenTUI
+    //    Use setTimeout to let the overlay box render first.
+    //    MUST be synchronous — async yields (Bun.sleep) let OpenTUI render frames
+    //    between DCS chunks, corrupting tmux's virtual terminal state (ghostty+tmux).
+    setTimeout(() => {
+      if (!useStore.getState().imagePreview) return
+
+      const popupWidth = displayCols + 2
+      const popupHeight = displayRows + 2
+      const left = Math.max(0, Math.floor((termCols - popupWidth) / 2))
+      const top = Math.max(0, Math.floor((termRows - popupHeight) / 2))
+
+      // Interior position: skip border + title row
+      const interiorRow = top + 2
+      const interiorCol = left + 1
+
+      try {
+        // Disable mouse tracking — terminal stops generating mouse events.
+        // Then flush any already-queued input from the kernel buffer.
+        // We intentionally do NOT call process.stdin.pause()/resume() — that
+        // triggers a buffer overwrite race in Bun's streams.zig (issue #8695)
+        // causing a malloc double-free crash on macOS.
+        writeSync(1, MOUSE_DISABLE)
+        flushStdin()
+
+        // Write strategy differs by environment:
+        // - Direct (no tmux): one write of all chunks — matches erssi's fwrite()
+        // - tmux: per-chunk writeSync — matches erssi's per-chunk fflush().
+        //   tmux needs to process each DCS individually; one big write can cause
+        //   tmux to split delivery at arbitrary boundaries → partial images.
+        //   With PNG (~25 chunks), ~25 writeSync calls are safe for Bun.
+        writeSync(1, `\x1b7\x1b[${interiorRow};${interiorCol}H`)
+        if (inTmux && protocol !== "symbols") {
+          for (const chunk of rawChunks) {
+            writeSync(1, Buffer.from(wrapTmuxDCS(chunk)))
+          }
+        } else {
+          writeSync(1, Buffer.from(rawChunks.join("")))
+        }
+        writeSync(1, "\x1b8")
+
+        // Flush any stray input that arrived during writes, then re-enable mouse
+        flushStdin()
+        writeSync(1, MOUSE_ENABLE)
+      } catch {
+        try { writeSync(1, MOUSE_ENABLE) } catch {}
+      }
+    }, 50)
+  } catch (err: any) {
+    store.updateImagePreview({
+      status: "error",
+      error: err.message ?? "Unknown error",
+    })
+  }
+}

package/src/core/image-preview/stdin-guard.ts

@@ -0,0 +1,33 @@
+/**
+ * Terminal I/O helpers for image write operations.
+ *
+ * Bun uses kqueue on macOS for stdin I/O. Calling process.stdin.pause()/resume()
+ * triggers a buffer overwrite race in Bun's streams.zig (issue #8695) that causes
+ * a malloc double-free crash. Instead of pause/resume, we:
+ *
+ * 1. Disable mouse tracking at the terminal level (caller's responsibility)
+ *    — the terminal stops generating mouse events entirely
+ * 2. Call tcflush(TCIFLUSH) to discard any already-queued input at the kernel level
+ *
+ * This avoids touching Bun's stdin stream state while still preventing event
+ * accumulation during synchronous image writes.
+ */
+
+let tcflushFn: ((fd: number) => void) | null = null
+
+try {
+  const { dlopen, FFIType } = require("bun:ffi")
+  const TCIFLUSH = process.platform === "darwin" ? 1 : 0
+  const lib = dlopen(
+    process.platform === "darwin" ? "libSystem.B.dylib" : "libc.so.6",
+    {
+      tcflush: { args: [FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+    },
+  )
+  tcflushFn = (fd) => lib.symbols.tcflush(fd, TCIFLUSH)
+} catch {}
+
+/** Flush the kernel stdin buffer — discards any queued input data */
+export function flushStdin() {
+  try { tcflushFn?.(0) } catch {}
+}

package/src/core/init.ts

@@ -1,6 +1,6 @@
 import { mkdir } from "node:fs/promises"
 import { join } from "node:path"
-import { HOME_DIR, CONFIG_PATH, DEFAULT_THEMES_DIR, SCRIPTS_DIR } from "./constants"
+import { HOME_DIR, CONFIG_PATH, DEFAULT_THEMES_DIR, SCRIPTS_DIR, IMAGE_CACHE_DIR } from "./constants"
 import { DEFAULT_CONFIG } from "./config/defaults"
 import { saveConfig } from "./config/loader"
 
@@ -11,6 +11,7 @@ export async function initHomeDir(): Promise<void> {
   // Create directories
   await mkdir(themesDir, { recursive: true })
   await mkdir(SCRIPTS_DIR, { recursive: true })
+  await mkdir(IMAGE_CACHE_DIR, { recursive: true })
 
   // Generate default config if missing
   const configFile = Bun.file(CONFIG_PATH)

package/src/core/irc/antiflood.ts

@@ -1,6 +1,7 @@
 import { useStore } from "@/core/state/store"
 import { makeBufferId } from "@/types"
 import type { Message } from "@/types"
+import { nextMsgId } from "@/core/utils/id"
 import type { Client } from "kofany-irc-framework"
 
 // ─── Constants (proven thresholds from erssi) ────────────────
@@ -77,7 +78,7 @@ function statusNotify(connId: string, text: string) {
 
 function makeEventMessage(text: string): Message {
   return {
-    id: crypto.randomUUID(),
+    id: nextMsgId(),
     timestamp: new Date(),
     type: "event",
     text,

package/src/core/irc/client.ts

@@ -3,6 +3,7 @@ import type { ConnectOptions } from "kofany-irc-framework"
 import type { ServerConfig } from "@/types/config"
 import { useStore } from "@/core/state/store"
 import { makeBufferId, BufferType, ActivityLevel } from "@/types"
+import { nextMsgId } from "@/core/utils/id"
 import { bindEvents } from "./events"
 import { createAntiFloodMiddleware } from "./antiflood"
 import { createIgnoreMiddleware } from "./ignore"
@@ -61,7 +62,7 @@ export function connectServer(id: string, config: ServerConfig): Client {
 
   // Show connecting message in Status buffer
   store.addMessage(statusBufferId, {
-    id: crypto.randomUUID(),
+    id: nextMsgId(),
     timestamp: new Date(),
     type: "event" as const,
     text: `%Ze0af68Connecting to ${config.address}:${config.port}${config.tls ? " (TLS)" : ""}...%N`,
@@ -121,7 +122,7 @@ export function connectServer(id: string, config: ServerConfig): Client {
 export function disconnectServer(id: string, message?: string) {
   const client = clients.get(id)
   if (client) {
-    client.quit(message ?? "kIRC")
+    client.quit(message ?? "kokoIRC — https://github.com/kofany/kokoIRC")
     clients.delete(id)
   }
 }