serverless-ircd 0.7.0 → 0.8.0

package/packages/irc-core/tests/state/channel.test.ts

@@ -25,6 +25,9 @@ describe('emptyModes', () => {
       moderated: false,
       secret: false,
       private: false,
+      registered: false,
+      blockUnidentified: false,
+      moderatedIdent: false,
     });
     // optional fields are absent, not undefined
     expect('key' in modes).toBe(false);

package/packages/irc-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/irc-server",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": true,
   "description": "Orchestration layer: IrcRuntime port, dispatch interpreter, ConnectionActor",
   "license": "BSD-3-Clause",

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

@@ -28,6 +28,7 @@
 import {
   type AccountStore,
   type AwayStore,
+  CHANSERV_NICK,
   type ChanName,
   type ChannelState,
   type Clock,
@@ -38,25 +39,30 @@ import {
   Effect,
   type Effect as EffectType,
   EmptyMotdProvider,
+  HOSTSERV_NICK,
   type IdFactory,
   type IrcMessage,
   LABELED_RESPONSE_CAP_NAME,
   type Logger,
+  MEMOSERV_NICK,
   type MessageStore,
   type MonitorStore,
   type MotdProvider,
   type MtlsIdentityProvider,
   type MultilineEntry,
+  NICKSERV_NICK,
   type NickHistoryStore,
   NoopLoggerInstance,
   Numerics,
+  OPERSERV_NICK,
   type RawLine,
-  type ReadMarkerStore,
   type ServerConfig,
   type ServerStats,
+  type ServicesStore,
   applyLabelToEffects,
   buildCtx,
   buildMultilineFanout,
+  caseFold,
   chathistoryReducer,
   extractLabel,
   finalizeMultilineBatch,
@@ -168,18 +174,6 @@ export interface ConnectionActorOptions {
    * preserves the no-store behaviour: `WHOWAS <nick>` emits `406`+`369`.
    */
   readonly history?: NickHistoryStore;
-  /**
-   * Read-marker persistence source for IRCv3 `draft/read-marker` (absent
-   * when the deployment does not persist read markers). When bound,
-   * `ctx.readMarkers` is defined so a `+draft/read-marker=<msgid>` TAGMSG
-   * from an identified, cap-enabled client updates the per-`(account,
-   * channel)` marker, and SASL identify seeds the connection's
-   * `lastReadMarkers` from the stored values. Omitted (→ `ctx.readMarkers`
-   * undefined) preserves the session-only marker behaviour: the connection
-   * still tracks its own read position via chathistory playback, but the
-   * marker is not shared across connections or restored on reconnect.
-   */
-  readonly readMarkers?: ReadMarkerStore;
   /**
    * Away-status persistence source for IRCv3 `draft/pre-away` (absent
    * when the deployment does not persist away reasons). When bound,
@@ -192,6 +186,22 @@ export interface ConnectionActorOptions {
    * is not shared across connections or restored on reconnect.
    */
   readonly away?: AwayStore;
+  /**
+   * IRC services persistence source for NickServ / ChanServ / HostServ /
+   * MemoServ, plus the per-account read-marker persistence for IRCv3
+   * `draft/read-marker` (absent when services are not wired). When bound,
+   * the actor routes `PRIVMSG NickServ :…` to the NickServ reducer
+   * (REGISTER / IDENTIFY / DROP / INFO) against this store, a
+   * `+draft/read-marker=<msgid>` TAGMSG from an identified, cap-enabled
+   * client updates the per-`(account, channel)` marker via
+   * {@link ServicesStore.setLastReadMarker}, SASL identify seeds the
+   * connection's `lastReadMarkers` from {@link ServicesStore.listReadMarkers},
+   * and SASL PLAIN falls back to it for nicks registered via NickServ.
+   * Omitted (→ no services routing) preserves the existing behaviour:
+   * `PRIVMSG NickServ :…` is treated as a normal nick-target message and
+   * read-marker persistence stays session-only.
+   */
+  readonly services?: ServicesStore;
   /**
    * Monitor-subscription registry for the IRCv3 `MONITOR` command (absent
    * when MONITOR push notifications are disabled). When bound, the actor
@@ -262,8 +272,8 @@ export class ConnectionActor {
   private readonly accounts: AccountStore | undefined;
   private readonly mtlsIdentity: MtlsIdentityProvider | undefined;
   private readonly history: NickHistoryStore | undefined;
-  private readonly readMarkers: ReadMarkerStore | undefined;
   private readonly away: AwayStore | undefined;
+  private readonly services: ServicesStore | undefined;
   private readonly monitor: MonitorStore | undefined;
   private readonly stats: ServerStats | undefined;
   private readonly reducers: RoutedReducers;
@@ -316,8 +326,8 @@ export class ConnectionActor {
     this.accounts = opts.accounts;
     this.mtlsIdentity = opts.mtlsIdentity;
     this.history = opts.history;
-    this.readMarkers = opts.readMarkers;
     this.away = opts.away;
+    this.services = opts.services;
     this.monitor = opts.monitor;
     this.stats = opts.stats;
     this.logger = opts.logger ?? NoopLoggerInstance;
@@ -502,8 +512,8 @@ export class ConnectionActor {
       ...(this.accounts !== undefined ? { accounts: this.accounts } : {}),
       ...(this.mtlsIdentity !== undefined ? { mtlsIdentity: this.mtlsIdentity } : {}),
       ...(this.history !== undefined ? { history: this.history } : {}),
-      ...(this.readMarkers !== undefined ? { readMarkers: this.readMarkers } : {}),
       ...(this.away !== undefined ? { away: this.away } : {}),
+      ...(this.services !== undefined ? { services: this.services } : {}),
       ...(label !== undefined ? { label } : {}),
     });
 
@@ -631,6 +641,20 @@ export class ConnectionActor {
             )
           : this.reducers.userMode(this.state, msg, ctx).effects;
 
+      case 'MARKREAD': {
+        // draft/read-marker MARKREAD verb. Read-marker persistence is
+        // channel-scoped in this deployment, so a non-channel (nick) target
+        // is unsupported and silently ignored. An empty target is routed
+        // through the reducer so it can FAIL NEED_MORE_PARAMS rather than
+        // hitting the generic 421 fallthrough.
+        const markreadTarget = msg.params[0] ?? '';
+        if (markreadTarget.length === 0 || isChannelTarget(markreadTarget)) {
+          const chan = this.channels.getOrCreateChannel(markreadTarget);
+          return this.reducers.markreadChannel(chan, msg, ctx).effects;
+        }
+        return [];
+      }
+
       default:
         // Remaining standard IRC verbs not yet implemented. They fall through
         // to a graceful `421 ERR_UNKNOWNCOMMAND`. Triage of remaining verbs:
@@ -1327,6 +1351,36 @@ export class ConnectionActor {
       if (isChannelTarget(target)) {
         const chan = this.channels.getOrCreateChannel(target);
         effects.push(...channelReducer(chan, singleParamMsg, ctx).effects);
+      } else if (
+        msg.command === 'PRIVMSG' &&
+        this.services !== undefined &&
+        caseFold('rfc1459', target) === caseFold('rfc1459', NICKSERV_NICK)
+      ) {
+        effects.push(...this.reducers.nickserv(this.state, singleParamMsg, ctx).effects);
+      } else if (
+        msg.command === 'PRIVMSG' &&
+        this.services !== undefined &&
+        caseFold('rfc1459', target) === caseFold('rfc1459', CHANSERV_NICK)
+      ) {
+        effects.push(...this.reducers.chanserv(this.state, singleParamMsg, ctx).effects);
+      } else if (
+        msg.command === 'PRIVMSG' &&
+        this.services !== undefined &&
+        caseFold('rfc1459', target) === caseFold('rfc1459', HOSTSERV_NICK)
+      ) {
+        effects.push(...this.reducers.hostserv(this.state, singleParamMsg, ctx).effects);
+      } else if (
+        msg.command === 'PRIVMSG' &&
+        this.services !== undefined &&
+        caseFold('rfc1459', target) === caseFold('rfc1459', MEMOSERV_NICK)
+      ) {
+        effects.push(...this.reducers.memoserv(this.state, singleParamMsg, ctx).effects);
+      } else if (
+        msg.command === 'PRIVMSG' &&
+        this.services !== undefined &&
+        caseFold('rfc1459', target) === caseFold('rfc1459', OPERSERV_NICK)
+      ) {
+        effects.push(...this.reducers.operserv(this.state, singleParamMsg, ctx).effects);
       } else {
         effects.push(...userReducer(this.state, singleParamMsg, ctx).effects);
       }
@@ -1405,6 +1459,7 @@ export function channelTargetsForMessage(msg: IrcMessage): ChanName[] {
     case 'PRIVMSG':
     case 'NOTICE':
     case 'TAGMSG':
+    case 'MARKREAD':
       return splitCsv(msg.params[0] ?? '').filter(isChannelTarget) as ChanName[];
     case 'INVITE':
       // INVITE <nick> <channel> — the channel is the second param.

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

@@ -24,7 +24,7 @@ import type {
   MonitorStore,
   RawLine,
 } from '@serverless-ircd/irc-core';
-import { LogLevel, filterClientTags } from '@serverless-ircd/irc-core';
+import { LogLevel, caseFold, filterClientTags } from '@serverless-ircd/irc-core';
 import type { IrcRuntime } from './runtime.js';
 
 /**
@@ -32,12 +32,15 @@ import type { IrcRuntime } from './runtime.js';
  * 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.
+ * watchers. The optional 4th argument carries {@link DispatchOptions} for
+ * handlers that need it (currently only `EnforceNick`, which reads the
+ * injectable grace scheduler); most handlers ignore it.
  */
 type Handler<E extends Effect> = (
   effect: E,
   runtime: IrcRuntime,
   monitor: MonitorStore | undefined,
+  opts: DispatchOptions | undefined,
 ) => Promise<void>;
 
 const handlers: { [K in Effect['tag']]: Handler<Extract<Effect, { tag: K }>> } = {
@@ -50,6 +53,50 @@ const handlers: { [K in Effect['tag']]: Handler<Extract<Effect, { tag: K }>> } =
   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),
+  EnforceNick: (e, r, _m, opts) => enforceNick(e, r, opts),
+};
+
+/** Canonical disconnect reason applied by the EnforceNick handler. */
+const ENFORCE_NICK_REASON = 'Nick enforced by NickServ';
+
+/**
+ * Host timer used by the default grace scheduler. Declared locally because
+ * the package's `lib` is ES2022 (no DOM/WebWorker/Node globals); on every
+ * target (Node, Cloudflare Workers, Lambda) `setTimeout` is a real global,
+ * so this purely satisfies the type-checker. Scoped to this module.
+ */
+declare function setTimeout(callback: () => void, ms?: number): unknown;
+
+/**
+ * Interprets an {@link EnforceNickEffect} against the runtime:
+ *   - `none`  — no-op (the reducer already sent the warning NOTICE).
+ *   - `kill`  — immediate `disconnect`.
+ *   - `ghost` — `disconnect` after `graceMs` via the injectable scheduler
+ *     ({@link DispatchOptions.scheduler}, defaulting to `setTimeout`); when
+ *     `graceMs === 0` the disconnect is immediate (matches `kill`).
+ */
+async function enforceNick(
+  e: Extract<Effect, { tag: 'EnforceNick' }>,
+  r: IrcRuntime,
+  opts: DispatchOptions | undefined,
+): Promise<void> {
+  if (e.policy === 'none') return;
+  if (e.policy === 'kill' || e.graceMs <= 0) {
+    await r.disconnect(e.conn, ENFORCE_NICK_REASON);
+    return;
+  }
+  // ghost with a positive grace: schedule the disconnect so the client has
+  // a window to IDENTIFY. The scheduler is injectable for deterministic
+  // tests; production defaults to setTimeout.
+  const schedule = opts?.scheduler ?? defaultScheduler;
+  schedule(() => {
+    void r.disconnect(e.conn, ENFORCE_NICK_REASON);
+  }, e.graceMs);
+}
+
+/** Default scheduler: defers to the host's `setTimeout`. */
+const defaultScheduler: DispatchScheduler = (cb, ms) => {
+  setTimeout(cb, ms);
 };
 
 async function reserveNickEtc(
@@ -115,8 +162,29 @@ export interface DispatchOptions {
    * dispatch behaviour for callers that have not opted into MONITOR.
    */
   readonly monitor?: MonitorStore;
+  /**
+   * Grace-timer scheduler consulted by the `EnforceNick(ghost)` handler.
+   * When supplied, the handler defers the `disconnect` by the effect's
+   * `graceMs` via this callback instead of firing immediately — giving
+   * the client a window to IDENTIFY before NickServ reclaims the nick.
+   * Production adapters inject a thin `setTimeout` wrapper (or a Durable
+   * Object alarm on Cloudflare); tests inject a capturing fake so the
+   * scheduled delay and the flushed disconnect are both deterministic.
+   *
+   * Omitted → dispatch falls back to the host `setTimeout`. The fallback
+   * only matters for `ghost` enforcements with a positive `graceMs`;
+   * `kill` and `graceMs === 0` always disconnect immediately.
+   */
+  readonly scheduler?: DispatchScheduler;
 }
 
+/**
+ * Scheduler signature for {@link DispatchOptions.scheduler}. Mirrors the
+ * subset of `setTimeout` the `EnforceNick(ghost)` handler needs so tests
+ * can substitute a deterministic fake.
+ */
+export type DispatchScheduler = (callback: () => void, ms: number) => void;
+
 /**
  * Returns true iff two effects are interchangeable — used to coalesce
  * consecutive duplicates so a reducer's accidental double-send is a no-op.
@@ -178,7 +246,7 @@ async function handle(
   // for exhaustive-union dispatch.
   const handler = handlers[effect.tag] as Handler<Effect>;
   try {
-    await handler(effect, runtime, monitor);
+    await handler(effect, runtime, monitor, opts);
   } catch (err) {
     if (opts?.logger !== undefined) {
       opts.logger.on(logLevelFor(err), 'dispatch.error', {
@@ -247,7 +315,7 @@ function logLevelFor(_err: unknown): LogLevel {
  * (the connection has gone) is treated as lacking the cap.
  */
 async function broadcast(e: BroadcastEffect, r: IrcRuntime): Promise<void> {
-  if (e.cap === undefined && e.caps === undefined) {
+  if (e.cap === undefined && e.caps === undefined && e.account === undefined) {
     await r.broadcast(e.chan, e.lines, e.except);
     return;
   }
@@ -256,14 +324,33 @@ async function broadcast(e: BroadcastEffect, r: IrcRuntime): Promise<void> {
   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];
+  // the only entry. When neither cap field is set (only `account`), the
+  // recipient set is account-scoped with no cap gate — every same-account
+  // member receives `lines`. The early-return above guarantees at least one
+  // of the three filters is set.
+  const capsList: readonly string[] | undefined =
+    e.caps ?? (e.cap !== undefined ? [e.cap] : undefined);
+  // RFC 1459 case-fold the account filter once so per-recipient comparison
+  // is a cheap string equality (draft/read-marker privacy is account-scoped).
+  const accountFolded = e.account !== undefined ? caseFold('rfc1459', e.account) : undefined;
   for (const connId of snapshot.members.keys()) {
     if (connId === e.except) continue;
 
     const info = await r.getConnectionInfo(connId);
+    // Account-scoped recipient gate (draft/read-marker). When set, only
+    // members authenticated as this account pass; unidentified peers (no
+    // account) and other accounts are excluded — a read marker is private.
+    if (accountFolded !== undefined) {
+      const recipientAccount = info?.account;
+      if (
+        recipientAccount === undefined ||
+        caseFold('rfc1459', recipientAccount) !== accountFolded
+      ) {
+        continue;
+      }
+    }
     const recipientCaps = info?.caps ?? EMPTY_CAPS;
-    const hasAnyCap = capsList.some((c) => recipientCaps.has(c));
+    const hasAnyCap = capsList === undefined || capsList.some((c) => recipientCaps.has(c));
 
     let toSend: RawLine[] | undefined;
     if (e.capLines !== undefined) {

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

@@ -34,17 +34,23 @@ import {
   awayReducer,
   capReducer,
   channelModeReducer,
+  chanservReducer,
   defaultCommandCost,
+  hostservReducer,
   infoReducer,
   inviteReducer,
   joinReducer,
   kickReducer,
+  markreadChannelReducer,
+  memoservReducer,
   motdReducer,
   namesReducer,
   nickReducer,
+  nickservReducer,
   noticeChannelReducer,
   noticeUserReducer,
   operReducer,
+  operservReducer,
   partReducer,
   passReducer,
   pingReducer,
@@ -100,8 +106,15 @@ export interface RoutedReducers {
   readonly noticeUser: Reducer<ConnectionState>;
   readonly tagmsgChannel: Reducer<ChannelState>;
   readonly tagmsgUser: Reducer<ConnectionState>;
+  readonly markreadChannel: Reducer<ChannelState>;
   readonly channelMode: Reducer<ChannelState>;
   readonly userMode: Reducer<ConnectionState>;
+  // Services reducers (target-routed, not command-routed).
+  readonly nickserv: Reducer<ConnectionState>;
+  readonly chanserv: Reducer<ConnectionState>;
+  readonly hostserv: Reducer<ConnectionState>;
+  readonly memoserv: Reducer<ConnectionState>;
+  readonly operserv: Reducer<ConnectionState>;
 }
 
 /**
@@ -169,7 +182,13 @@ export function buildRoutedReducers(serverConfig: ServerConfig): RoutedReducers
     noticeUser: wrap(noticeUserReducer),
     tagmsgChannel: wrap(tagmsgChannelReducer),
     tagmsgUser: wrap(tagmsgUserReducer),
+    markreadChannel: wrap(markreadChannelReducer),
     channelMode: wrap(channelModeReducer),
     userMode: wrap(userModeReducer),
+    nickserv: wrap(nickservReducer),
+    chanserv: wrap(chanservReducer),
+    hostserv: wrap(hostservReducer),
+    memoserv: wrap(memoservReducer),
+    operserv: wrap(operservReducer),
   };
 }