serverless-ircd 0.5.0 → 0.7.0

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

@@ -17,26 +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
@@ -59,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;
 }
 
 /**
@@ -107,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', {
@@ -175,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;
   }
@@ -187,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>();