kokoirc 0.2.0

package/src/core/scripts/api.ts

@@ -0,0 +1,240 @@
+import { useStore } from "@/core/state/store"
+import { getClient } from "@/core/irc"
+import { makeBufferId } from "@/types"
+import { eventBus } from "./event-bus"
+import { EventPriority } from "./types"
+import type {
+  KokoAPI,
+  ScriptMeta,
+  ScriptCommandDef,
+  EventHandler,
+  TimerHandle,
+  StoreAccess,
+  IrcAccess,
+  UiAccess,
+  ScriptConfigAccess,
+} from "./types"
+
+/** Registry of script-defined commands. Checked in execution.ts between built-ins and aliases. */
+export const scriptCommands = new Map<string, { def: ScriptCommandDef; owner: string }>()
+
+export function createScriptAPI(meta: ScriptMeta, scriptDefaults: Record<string, any>): {
+  api: KokoAPI
+  cleanup: () => void
+} {
+  const scriptName = meta.name
+  const unsubs: Array<() => void> = []
+  const timers: Array<TimerHandle> = []
+  const registeredCommands: string[] = []
+
+  // ─── Store Access ────────────────────────────────────────
+
+  const store: StoreAccess = {
+    getConnections: () => useStore.getState().connections,
+    getBuffers: () => useStore.getState().buffers,
+    getActiveBufferId: () => useStore.getState().activeBufferId,
+    getConfig: () => useStore.getState().config,
+    getConnection: (id) => useStore.getState().connections.get(id),
+    getBuffer: (id) => useStore.getState().buffers.get(id),
+    subscribe: (listener) => useStore.subscribe(listener),
+  }
+
+  // ─── IRC Access ──────────────────────────────────────────
+
+  function resolveConnId(explicit?: string): string | undefined {
+    if (explicit) return explicit
+    const s = useStore.getState()
+    const bufId = s.activeBufferId
+    if (!bufId) return undefined
+    const buf = s.buffers.get(bufId)
+    return buf?.connectionId
+  }
+
+  const irc: IrcAccess = {
+    say(target, message, connectionId) {
+      const connId = resolveConnId(connectionId)
+      if (!connId) return
+      getClient(connId)?.say(target, message)
+    },
+    action(target, message, connectionId) {
+      const connId = resolveConnId(connectionId)
+      if (!connId) return
+      getClient(connId)?.action(target, message)
+    },
+    notice(target, message, connectionId) {
+      const connId = resolveConnId(connectionId)
+      if (!connId) return
+      getClient(connId)?.notice(target, message)
+    },
+    join(channel, key, connectionId) {
+      const connId = resolveConnId(connectionId)
+      if (!connId) return
+      getClient(connId)?.join(channel, key)
+    },
+    part(channel, message, connectionId) {
+      const connId = resolveConnId(connectionId)
+      if (!connId) return
+      getClient(connId)?.part(channel, message)
+    },
+    raw(line, connectionId) {
+      const connId = resolveConnId(connectionId)
+      if (!connId) return
+      getClient(connId)?.raw(line)
+    },
+    changeNick(nick, connectionId) {
+      const connId = resolveConnId(connectionId)
+      if (!connId) return
+      getClient(connId)?.changeNick(nick)
+    },
+    whois(nick, connectionId) {
+      const connId = resolveConnId(connectionId)
+      if (!connId) return
+      getClient(connId)?.whois(nick)
+    },
+    getClient(connectionId) {
+      const connId = resolveConnId(connectionId)
+      if (!connId) return undefined
+      return getClient(connId)
+    },
+  }
+
+  // ─── UI Access ───────────────────────────────────────────
+
+  const ui: UiAccess = {
+    addLocalEvent(text) {
+      const s = useStore.getState()
+      const buf = s.activeBufferId
+      if (!buf) return
+      s.addMessage(buf, {
+        id: crypto.randomUUID(),
+        timestamp: new Date(),
+        type: "event",
+        text,
+        highlight: false,
+      })
+    },
+    addMessage(bufferId, partial) {
+      useStore.getState().addMessage(bufferId, {
+        id: crypto.randomUUID(),
+        timestamp: new Date(),
+        ...partial,
+      })
+    },
+    switchBuffer(bufferId) {
+      useStore.getState().setActiveBuffer(bufferId)
+    },
+    makeBufferId,
+  }
+
+  // ─── Config Access ───────────────────────────────────────
+
+  const config: ScriptConfigAccess = {
+    get<T = any>(key: string, defaultValue: T): T {
+      const appConfig = useStore.getState().config
+      const scriptConfig = (appConfig as any)?.scripts?.[scriptName]
+      if (scriptConfig && key in scriptConfig) return scriptConfig[key]
+      if (key in scriptDefaults) return scriptDefaults[key] as T
+      return defaultValue
+    },
+    set(key: string, value: any) {
+      const s = useStore.getState()
+      const appConfig = s.config
+      if (!appConfig) return
+      // Mutate scripts config in-place (same pattern as /set command)
+      if (!(appConfig as any).scripts) (appConfig as any).scripts = {}
+      if (!(appConfig as any).scripts[scriptName]) {
+        (appConfig as any).scripts[scriptName] = { ...scriptDefaults }
+      }
+      ;(appConfig as any).scripts[scriptName][key] = value
+      s.setConfig({ ...appConfig })
+    },
+  }
+
+  // ─── KokoAPI ─────────────────────────────────────────────
+
+  const api: KokoAPI = {
+    meta,
+
+    on(event, handler, priority = EventPriority.NORMAL) {
+      const unsub = eventBus.on(event, handler, priority, scriptName)
+      unsubs.push(unsub)
+      return unsub
+    },
+
+    once(event, handler, priority = EventPriority.NORMAL) {
+      const unsub = eventBus.once(event, handler, priority, scriptName)
+      unsubs.push(unsub)
+      return unsub
+    },
+
+    emit(event, data) {
+      return eventBus.emit(`script.${event}`, data)
+    },
+
+    command(name, def) {
+      const lower = name.toLowerCase()
+      scriptCommands.set(lower, { def, owner: scriptName })
+      registeredCommands.push(lower)
+    },
+
+    removeCommand(name) {
+      const lower = name.toLowerCase()
+      const entry = scriptCommands.get(lower)
+      if (entry?.owner === scriptName) {
+        scriptCommands.delete(lower)
+      }
+    },
+
+    timer(ms, handler) {
+      const id = setInterval(handler, ms)
+      const handle: TimerHandle = { clear: () => clearInterval(id) }
+      timers.push(handle)
+      return handle
+    },
+
+    timeout(ms, handler) {
+      const id = setTimeout(handler, ms)
+      const handle: TimerHandle = { clear: () => clearTimeout(id) }
+      timers.push(handle)
+      return handle
+    },
+
+    store,
+    irc,
+    ui,
+    config,
+    EventPriority,
+
+    log(...args) {
+      const appConfig = useStore.getState().config
+      const debug = (appConfig as any)?.scripts?.debug ?? false
+      if (debug) {
+        console.log(`[script:${scriptName}]`, ...args)
+      }
+    },
+  }
+
+  // ─── Cleanup ─────────────────────────────────────────────
+
+  function cleanup() {
+    // Remove all event handlers
+    eventBus.removeAll(scriptName)
+    for (const unsub of unsubs) unsub()
+    unsubs.length = 0
+
+    // Clear all timers
+    for (const t of timers) t.clear()
+    timers.length = 0
+
+    // Remove all commands
+    for (const name of registeredCommands) {
+      const entry = scriptCommands.get(name)
+      if (entry?.owner === scriptName) {
+        scriptCommands.delete(name)
+      }
+    }
+    registeredCommands.length = 0
+  }
+
+  return { api, cleanup }
+}

package/src/core/scripts/event-bus.ts

@@ -0,0 +1,82 @@
+import { EventPriority } from "./types"
+import type { EventHandler, EventRegistration, EventContext } from "./types"
+
+export class EventBus {
+  private handlers: EventRegistration[] = []
+
+  /** Subscribe to an event. Returns an unsubscribe function. */
+  on(event: string, handler: EventHandler, priority = EventPriority.NORMAL, owner = ""): () => void {
+    const reg: EventRegistration = { event, handler, priority, once: false, owner }
+    this.insert(reg)
+    return () => this.remove(reg)
+  }
+
+  /** Subscribe to an event for a single firing. */
+  once(event: string, handler: EventHandler, priority = EventPriority.NORMAL, owner = ""): () => void {
+    const reg: EventRegistration = { event, handler, priority, once: true, owner }
+    this.insert(reg)
+    return () => this.remove(reg)
+  }
+
+  /** Emit an event. Returns false if a handler called stop(). */
+  emit(event: string, data?: any): boolean {
+    const ctx: EventContext = {
+      stopped: false,
+      stop() { this.stopped = true },
+    }
+
+    // Snapshot matching handlers (allows safe removal during iteration)
+    const matching = this.handlers.filter((h) => h.event === event)
+
+    for (const reg of matching) {
+      reg.handler(data, ctx)
+
+      if (reg.once) {
+        this.remove(reg)
+      }
+
+      if (ctx.stopped) {
+        // Remove remaining once handlers that matched but didn't fire
+        for (const r of matching) {
+          if (r.once && r !== reg) this.remove(r)
+        }
+        return false
+      }
+    }
+
+    return true
+  }
+
+  /** Remove all registrations for a given owner. */
+  removeAll(owner: string): void {
+    this.handlers = this.handlers.filter((h) => h.owner !== owner)
+  }
+
+  /** Remove all handlers. */
+  clear(): void {
+    this.handlers = []
+  }
+
+  /** Number of registered handlers (for testing). */
+  get size(): number {
+    return this.handlers.length
+  }
+
+  /** Insert a registration in priority-sorted position (descending). */
+  private insert(reg: EventRegistration): void {
+    let i = 0
+    while (i < this.handlers.length && this.handlers[i].priority >= reg.priority) {
+      i++
+    }
+    this.handlers.splice(i, 0, reg)
+  }
+
+  /** Remove a specific registration by reference. */
+  private remove(reg: EventRegistration): void {
+    const idx = this.handlers.indexOf(reg)
+    if (idx !== -1) this.handlers.splice(idx, 1)
+  }
+}
+
+/** Singleton event bus shared across the app and all scripts. */
+export const eventBus = new EventBus()

package/src/core/scripts/index.ts

@@ -0,0 +1,26 @@
+export { EventBus, eventBus } from "./event-bus"
+export { createScriptAPI, scriptCommands } from "./api"
+export {
+  loadScript,
+  unloadScript,
+  reloadScript,
+  getLoadedScripts,
+  getAvailableScripts,
+  autoloadScripts,
+  isLoaded,
+} from "./manager"
+export { EventPriority } from "./types"
+export type {
+  KokoAPI,
+  ScriptMeta,
+  ScriptModule,
+  ScriptCommandDef,
+  EventHandler,
+  EventContext,
+  EventRegistration,
+  TimerHandle,
+  StoreAccess,
+  IrcAccess,
+  UiAccess,
+  ScriptConfigAccess,
+} from "./types"

package/src/core/scripts/manager.ts

@@ -0,0 +1,154 @@
+import { join } from "node:path"
+import { useStore } from "@/core/state/store"
+import { SCRIPTS_DIR } from "@/core/constants"
+import { createScriptAPI } from "./api"
+import type { ScriptMeta, ScriptModule } from "./types"
+
+interface LoadedScript {
+  name: string
+  path: string
+  meta: ScriptMeta
+  cleanup: () => void
+  scriptCleanup?: () => void
+}
+
+const loaded = new Map<string, LoadedScript>()
+
+/** Resolve a script name or path to an absolute file path. */
+function resolvePath(nameOrPath: string): string {
+  if (nameOrPath.startsWith("/") || nameOrPath.startsWith("./") || nameOrPath.startsWith("~")) {
+    return nameOrPath
+  }
+  // Strip .ts extension if given, we'll add it back
+  const base = nameOrPath.replace(/\.ts$/, "")
+  return join(SCRIPTS_DIR, `${base}.ts`)
+}
+
+/** Load a script by name or path. */
+export async function loadScript(nameOrPath: string): Promise<{ ok: true; name: string } | { ok: false; error: string }> {
+  const path = resolvePath(nameOrPath)
+
+  // Check file exists
+  const file = Bun.file(path)
+  if (!(await file.exists())) {
+    return { ok: false, error: `Script not found: ${path}` }
+  }
+
+  let mod: ScriptModule
+  try {
+    mod = await import(`file://${path}?t=${Date.now()}`)
+  } catch (err: any) {
+    return { ok: false, error: `Failed to import: ${err.message}` }
+  }
+
+  if (typeof mod.default !== "function") {
+    return { ok: false, error: `Script has no default export function` }
+  }
+
+  const meta: ScriptMeta = mod.meta ?? {
+    name: nameOrPath.replace(/\.ts$/, "").split("/").pop() ?? nameOrPath,
+  }
+
+  // Unload existing version if already loaded
+  if (loaded.has(meta.name)) {
+    unloadScript(meta.name)
+  }
+
+  const scriptDefaults = mod.config ?? {}
+  const { api, cleanup } = createScriptAPI(meta, scriptDefaults)
+
+  let scriptCleanup: (() => void) | undefined
+  try {
+    const result = mod.default(api)
+    if (typeof result === "function") {
+      scriptCleanup = result
+    }
+  } catch (err: any) {
+    cleanup()
+    return { ok: false, error: `init() threw: ${err.message}` }
+  }
+
+  loaded.set(meta.name, { name: meta.name, path, meta, cleanup, scriptCleanup })
+  return { ok: true, name: meta.name }
+}
+
+/** Unload a script by name. */
+export function unloadScript(name: string): boolean {
+  const script = loaded.get(name)
+  if (!script) return false
+
+  // Call script's own cleanup first
+  try {
+    script.scriptCleanup?.()
+  } catch {
+    // Ignore cleanup errors
+  }
+
+  // Then clean up all tracked registrations
+  script.cleanup()
+  loaded.delete(name)
+  return true
+}
+
+/** Reload a script (unload + load with cache bust). */
+export async function reloadScript(name: string): Promise<{ ok: true; name: string } | { ok: false; error: string }> {
+  const script = loaded.get(name)
+  if (!script) {
+    return { ok: false, error: `Script '${name}' is not loaded` }
+  }
+
+  const path = script.path
+  unloadScript(name)
+
+  // Re-import with cache bust
+  return loadScript(path)
+}
+
+/** Get list of loaded scripts. */
+export function getLoadedScripts(): Array<{ name: string; path: string; meta: ScriptMeta }> {
+  return Array.from(loaded.values()).map(({ name, path, meta }) => ({ name, path, meta }))
+}
+
+/** Get list of available script files in SCRIPTS_DIR. */
+export async function getAvailableScripts(): Promise<Array<{ name: string; path: string; loaded: boolean }>> {
+  const glob = new Bun.Glob("*.ts")
+  const results: Array<{ name: string; path: string; loaded: boolean }> = []
+
+  try {
+    for await (const file of glob.scan({ cwd: SCRIPTS_DIR })) {
+      const name = file.replace(/\.ts$/, "")
+      results.push({
+        name,
+        path: join(SCRIPTS_DIR, file),
+        loaded: loaded.has(name),
+      })
+    }
+  } catch {
+    // Directory might not exist yet
+  }
+
+  return results.sort((a, b) => a.name.localeCompare(b.name))
+}
+
+/** Load all scripts listed in config.scripts.autoload. */
+export async function autoloadScripts(): Promise<void> {
+  const config = useStore.getState().config
+  const autoload: string[] = (config as any)?.scripts?.autoload ?? []
+  const debug: boolean = (config as any)?.scripts?.debug ?? false
+
+  for (const name of autoload) {
+    const result = await loadScript(name)
+    if (debug) {
+      if (result.ok) {
+        console.log(`[scripts] autoloaded: ${result.name}`)
+      } else {
+        console.error(`[scripts] autoload failed for '${name}': ${result.error}`)
+      }
+    }
+  }
+}
+
+/** Check if a script is loaded. */
+export function isLoaded(name: string): boolean {
+  return loaded.has(name)
+}