serverless-ircd 0.4.0 → 0.6.0

package/packages/irc-server/src/dispatch.ts

@@ -17,25 +17,72 @@
  * pipeline can be reconstructed end-to-end.
  */
 
-import type { BroadcastEffect, Effect, Logger, RawLine } from '@serverless-ircd/irc-core';
-import { LogLevel } from '@serverless-ircd/irc-core';
+import type {
+  BroadcastEffect,
+  Effect,
+  Logger,
+  MonitorStore,
+  RawLine,
+} from '@serverless-ircd/irc-core';
+import { LogLevel, filterClientTags } from '@serverless-ircd/irc-core';
 import type { IrcRuntime } from './runtime.js';
 
-/** Discriminated-union handler: each Effect tag maps to one runtime call. */
-type Handler<E extends Effect> = (effect: E, runtime: IrcRuntime) => Promise<void>;
+/**
+ * Discriminated-union handler: each Effect tag maps to one runtime call.
+ * The handler also receives the bound {@link MonitorStore} (or
+ * `undefined`) so ReserveNick / ChangeNick / ReleaseNick can react to the
+ * runtime's success/failure and enqueue `730`/`731` pushes for subscribed
+ * watchers.
+ */
+type Handler<E extends Effect> = (
+  effect: E,
+  runtime: IrcRuntime,
+  monitor: MonitorStore | undefined,
+) => Promise<void>;
 
 const handlers: { [K in Effect['tag']]: Handler<Extract<Effect, { tag: K }>> } = {
   Send: (e, r) => r.send(e.to, e.lines),
   Broadcast: (e, r) => broadcast(e, r),
   Disconnect: (e, r) => r.disconnect(e.conn, e.reason),
   SendToNick: (e, r) => r.sendToNick(e.nick, e.sender, e.lines, e.notFoundLines),
-  ReserveNick: (e, r) => r.reserveNick(e.nick, e.conn).then(noop),
-  ChangeNick: (e, r) => r.changeNick(e.conn, e.oldNick, e.newNick).then(noop),
-  ReleaseNick: (e, r) => r.releaseNick(e.nick),
+  ReserveNick: (e, r, m) => reserveNickEtc(e, r, m),
+  ChangeNick: (e, r, m) => changeNickEtc(e, r, m),
+  ReleaseNick: (e, r, m) => releaseNickEtc(e, r, m),
   ApplyChannelDelta: (e, r) => r.applyChannelDelta(e.chan, e.delta),
+  BroadcastWallops: (e, r) => r.broadcastWallops(e.lines, e.except),
 };
 
-function noop(): void {}
+async function reserveNickEtc(
+  e: Extract<Effect, { tag: 'ReserveNick' }>,
+  r: IrcRuntime,
+  m: MonitorStore | undefined,
+): Promise<void> {
+  const result = await r.reserveNick(e.nick, e.conn);
+  if (result.ok) {
+    m?.onNickOnline(e.nick);
+  }
+}
+
+async function changeNickEtc(
+  e: Extract<Effect, { tag: 'ChangeNick' }>,
+  r: IrcRuntime,
+  m: MonitorStore | undefined,
+): Promise<void> {
+  const ok = await r.changeNick(e.conn, e.oldNick, e.newNick);
+  if (ok) {
+    m?.onNickOffline(e.oldNick);
+    m?.onNickOnline(e.newNick);
+  }
+}
+
+async function releaseNickEtc(
+  e: Extract<Effect, { tag: 'ReleaseNick' }>,
+  r: IrcRuntime,
+  m: MonitorStore | undefined,
+): Promise<void> {
+  await r.releaseNick(e.nick);
+  m?.onNickOffline(e.nick);
+}
 
 /**
  * Optional knobs for {@link dispatch}. All observability-related; the
@@ -58,6 +105,16 @@ export interface DispatchOptions {
    * Stamped on every record alongside `traceId`.
    */
   readonly connectionId?: string;
+  /**
+   * Optional {@link MonitorStore} consulted by the ReserveNick /
+   * ChangeNick / ReleaseNick handlers. When supplied, successful nick
+   * registry transitions fan out an asynchronous `730`/`731` push to
+   * every subscribed watcher of the affected nick. The actor drains
+   * those pushes after `dispatch` returns and emits one `Send` effect
+   * per push. Omitted (→ no monitor fanout) preserves the existing
+   * dispatch behaviour for callers that have not opted into MONITOR.
+   */
+  readonly monitor?: MonitorStore;
 }
 
 /**
@@ -106,17 +163,22 @@ export async function dispatch(
       previous = effect;
       continue;
     }
-    await handle(effect, runtime, opts);
+    await handle(effect, runtime, opts, opts?.monitor);
     previous = effect;
   }
 }
 
-async function handle(effect: Effect, runtime: IrcRuntime, opts?: DispatchOptions): Promise<void> {
+async function handle(
+  effect: Effect,
+  runtime: IrcRuntime,
+  opts: DispatchOptions | undefined,
+  monitor: MonitorStore | undefined,
+): Promise<void> {
   // The dispatch table is keyed by tag; the cast is the standard TS pattern
   // for exhaustive-union dispatch.
   const handler = handlers[effect.tag] as Handler<Effect>;
   try {
-    await handler(effect, runtime);
+    await handler(effect, runtime, monitor);
   } catch (err) {
     if (opts?.logger !== undefined) {
       opts.logger.on(logLevelFor(err), 'dispatch.error', {
@@ -174,11 +236,18 @@ function logLevelFor(_err: unknown): LogLevel {
  *   - `cap` without `capLines` (cap-only mode): `lines` go ONLY to
  *     cap-enabled members; the rest receive nothing.
  *
+ * `caps` (plural) is the OR-semantics variant: `lines` go to members that
+ * announced ANY of the listed caps. Used by capabilities like
+ * `draft/typing` whose delivery rule unions `message-tags` (the baseline
+ * for every TAGMSG) with `draft/typing` (the client-tag exception for
+ * peers that did not negotiate `message-tags`). `caps` does not support
+ * a `capLines` split — both audiences receive the same `lines`.
+ *
  * `except` is always honored. A member whose connection info is unavailable
  * (the connection has gone) is treated as lacking the cap.
  */
 async function broadcast(e: BroadcastEffect, r: IrcRuntime): Promise<void> {
-  if (e.cap === undefined) {
+  if (e.cap === undefined && e.caps === undefined) {
     await r.broadcast(e.chan, e.lines, e.except);
     return;
   }
@@ -186,16 +255,40 @@ async function broadcast(e: BroadcastEffect, r: IrcRuntime): Promise<void> {
   const snapshot = await r.getChannelSnapshot(e.chan);
   if (snapshot === null) return;
 
+  // `caps` (OR semantics) takes precedence; otherwise the single `cap` is
+  // the only entry. The early-return above guarantees one of them is set.
+  const capsList: readonly string[] = e.caps ?? [e.cap as string];
   for (const connId of snapshot.members.keys()) {
     if (connId === e.except) continue;
 
     const info = await r.getConnectionInfo(connId);
-    const hasCap = info?.caps.has(e.cap) ?? false;
+    const recipientCaps = info?.caps ?? EMPTY_CAPS;
+    const hasAnyCap = capsList.some((c) => recipientCaps.has(c));
 
+    let toSend: RawLine[] | undefined;
     if (e.capLines !== undefined) {
-      await r.send(connId, hasCap ? e.capLines : e.lines);
-    } else if (hasCap) {
-      await r.send(connId, e.lines);
+      toSend = hasAnyCap ? e.capLines : e.lines;
+    } else if (hasAnyCap) {
+      toSend = e.lines;
+    }
+    if (toSend !== undefined) {
+      await r.send(connId, filterLinesForRecipient(toSend, recipientCaps));
     }
   }
 }
+
+/**
+ * Applies per-recipient IRCv3 message-tags gating to each outbound line.
+ * Client-only tags (`+`-prefixed keys) are stripped for recipients that did
+ * NOT negotiate `message-tags` (with the documented `draft/typing` /
+ * `draft/read-marker` whitelist exceptions). Recipients that DID negotiate
+ * `message-tags` see the line verbatim. Lines with no `@` tag section pass
+ * through unchanged.
+ */
+function filterLinesForRecipient(lines: readonly RawLine[], caps: ReadonlySet<string>): RawLine[] {
+  if (caps.has('message-tags')) return [...lines];
+  return lines.map((l) => filterClientTags(l, caps));
+}
+
+/** Reusable empty cap set for recipients whose connection info is unavailable. */
+const EMPTY_CAPS: ReadonlySet<string> = new Set<string>();

package/packages/irc-server/src/routing.ts

@@ -52,6 +52,7 @@ import {
   privmsgChannelReducer,
   privmsgUserReducer,
   quitReducer,
+  setnameReducer,
   tagmsgChannelReducer,
   tagmsgUserReducer,
   timeReducer,
@@ -80,6 +81,7 @@ export interface RoutedReducers {
   readonly cap: Reducer<ConnectionState>;
   readonly authenticate: Reducer<ConnectionState>;
   readonly away: Reducer<ConnectionState>;
+  readonly setname: Reducer<ConnectionState>;
   readonly version: Reducer<ConnectionState>;
   readonly time: Reducer<ConnectionState>;
   readonly admin: Reducer<ConnectionState>;
@@ -150,6 +152,7 @@ export function buildRoutedReducers(serverConfig: ServerConfig): RoutedReducers
     cap: wrap(capReducer),
     authenticate: wrap(authenticateReducer),
     away: wrap(awayReducer),
+    setname: wrap(setnameReducer),
     version: wrap(versionReducer),
     time: wrap(timeReducer),
     admin: wrap(adminReducer),

package/packages/irc-server/src/runtime.ts

@@ -17,6 +17,7 @@ import type {
   ConnectionState,
   Nick,
   RawLine,
+  ServerConfig,
 } from '@serverless-ircd/irc-core';
 
 export interface IrcRuntime {
@@ -35,6 +36,24 @@ export interface IrcRuntime {
     lines: RawLine[],
     notFoundLines?: RawLine[],
   ): Promise<void>;
+  /**
+   * Global cross-connection fanout for `WALLOPS`. Delivers `lines` to every
+   * live connection whose `+w` user mode is set, skipping `except` (the
+   * originator, so an oper never receives their own wallops). Unlike
+   * {@link broadcast} this is NOT channel-scoped — it reaches connections
+   * with no shared channel membership.
+   *
+   * Each adapter applies its own cost cap and enumeration strategy:
+   *   - in-memory: scans its connection map, filters `+w`.
+   *   - Cloudflare: walks the sharded registry to enumerate connIds, then
+   *     fetches each state to check `+w`. Capped to bound the fan-out RPC
+   *     count; document a ceiling for very large fleets.
+   *   - AWS: `Scan`s the `Connections` table and `PostToConnection`s each
+   *     `+w` row. DynamoDB `Scan` reads scale with table size, so this is
+   *     expensive at high connection counts — callers should bound the
+   *     oper's WALLOPS rate.
+   */
+  broadcastWallops(lines: RawLine[], except?: ConnId): Promise<void>;
 
   // nickname registry
   reserveNick(nick: Nick, conn: ConnId): Promise<{ ok: true } | { ok: false }>;
@@ -58,4 +77,16 @@ export interface IrcRuntime {
   getChannelSnapshot(chan: ChanName): Promise<ChanSnapshot | null>;
   getChannelConnections(chan: ChanName): Promise<ReadonlyMap<ConnId, ConnectionState>>;
   listChannels(): Promise<ChanSnapshot[]>;
+  /**
+   * Re-fetches the deployment's {@link ServerConfig} from the adapter's bound
+   * source (CF: KV/secret env; AWS: Secrets Manager/SSM env; local-cli: the
+   * config file/options) and returns the fresh value. The caller (the
+   * ConnectionActor's `REHASH` route) swaps its live config reference with
+   * the result; on rejection the previous config stays in effect.
+   *
+   * Modelled as a request/response runtime method — like `lookupNick` /
+   * `getConnection` — rather than a fire-and-forget `Effect`, because the
+   * refreshed value must come back to the actor.
+   */
+  reloadConfig(): Promise<ServerConfig>;
 }

package/packages/irc-server/src/transport.ts

@@ -15,6 +15,10 @@
  * parser/reducer/dispatch pipeline.
  */
 
+import { splitFrameLines } from '@serverless-ircd/irc-core';
+
+export { splitFrameLines };
+
 /**
  * The line-framing contract a {@link ConnectionActor} consumes. `feed`
  * returns the complete IRC lines terminated within `chunk`; a stateful
@@ -25,14 +29,13 @@ export interface Transport {
 }
 
 /**
- * Splits a WebSocket text frame into IRC lines. Tolerates `\r\n`, bare `\n`,
- * and a missing trailing terminator (a WS frame is a complete unit). Returns
- * each line bare (no CRLF). This is the legacy-tolerant WS contract.
+ * Splits a WebSocket text frame into IRC lines. Re-exported from
+ * `@serverless-ircd/irc-core` (`ws-framing.ts`), which owns the canonical
+ * legacy-tolerant framing so the IRCv3 spec-mode framing and this legacy
+ * behaviour never diverge. Tolerates `\r\n`, bare `\n`, and a missing
+ * trailing terminator (a WS frame is a complete unit). Returns each line
+ * bare (no CRLF). This is the legacy-tolerant WS contract.
  */
-export function splitFrameLines(text: string): string[] {
-  if (text.length === 0) return [];
-  return text.split(/\r?\n/u);
-}
 
 /**
  * Stateless WS-frame transport: one {@link feed} call per inbound text frame.