serverless-ircd 0.7.0 → 0.9.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.9.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,32 @@ 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 Reducer,
+  SHORTCUT_TO_SERVICE,
   type ServerConfig,
   type ServerStats,
+  type ServicesStore,
   applyLabelToEffects,
   buildCtx,
   buildMultilineFanout,
+  caseFold,
   chathistoryReducer,
   extractLabel,
   finalizeMultilineBatch,
@@ -168,18 +176,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 +188,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 +274,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 +328,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 +514,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 } : {}),
     });
 
@@ -517,6 +529,28 @@ export class ConnectionActor {
       return this.accumulateMultilineLine(msg);
     }
 
+    // Service shortcut commands (Atheme/Anope convention): rewrite verbs
+    // like `NICKSERV IDENTIFY pw` / `NS INFO` / `CS REGISTER #home` to the
+    // canonical `PRIVMSG <ServiceNick> :<joined args>` and delegate to the
+    // existing service-routing path (`routeMessageTarget` →
+    // `serviceReducerFor`). `SHORTCUT_TO_SERVICE` is the single source of
+    // truth for the alias → service nick mapping; the service reducers run
+    // unchanged against the rewritten `params=[serviceNick, body]` shape.
+    const serviceShortcutTarget = SHORTCUT_TO_SERVICE.get(msg.command.toUpperCase());
+    if (serviceShortcutTarget !== undefined) {
+      const rewritten: IrcMessage = {
+        ...msg,
+        command: 'PRIVMSG',
+        params: [serviceShortcutTarget, msg.params.join(' ')],
+      };
+      return this.routeMessageTarget(
+        rewritten,
+        this.reducers.privmsgChannel,
+        this.reducers.privmsgUser,
+        ctx,
+      );
+    }
+
     switch (msg.command) {
       // -------- Connection-authority commands --------
       case 'PING':
@@ -631,6 +665,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:
@@ -1324,9 +1372,22 @@ export class ConnectionActor {
     }
     for (const target of targets) {
       const singleParamMsg: IrcMessage = { ...msg, params: [target, ...tail] };
+      const serviceReducer = this.serviceReducerFor(target, msg.command);
       if (isChannelTarget(target)) {
         const chan = this.channels.getOrCreateChannel(target);
         effects.push(...channelReducer(chan, singleParamMsg, ctx).effects);
+      } else if (serviceReducer !== undefined) {
+        // Echo the sender's own PRIVMSG back BEFORE the service reducer's NOTICE
+        // reply — matching how every other PRIVMSG renders (your outgoing line
+        // first, then any reply). Without this ordering a client sees the
+        // service's response above its own message, which reads as a bug.
+        if (ctx.connection.caps.has('echo-message')) {
+          const hostmask = hostmaskOf(this.state) ?? this.state.nick ?? '?';
+          const text = singleParamMsg.params[1] ?? '';
+          const echoLine: RawLine = { text: `:${hostmask} PRIVMSG ${target} :${text}` };
+          effects.push(Effect.send(ctx.connId, [echoLine]));
+        }
+        effects.push(...serviceReducer(this.state, singleParamMsg, ctx).effects);
       } else {
         effects.push(...userReducer(this.state, singleParamMsg, ctx).effects);
       }
@@ -1334,6 +1395,26 @@ export class ConnectionActor {
     return effects;
   }
 
+  /**
+   * Resolves the service pseudo-client reducer for a nick target, or
+   * `undefined` when the target is not a service nick / the command is not
+   * `PRIVMSG` / no services store is bound. Centralised so the
+   * `echo-message` echo (and any future service-routing concern) lives in a
+   * single place rather than being duplicated across five near-identical
+   * branches. `NOTICE` / `TAGMSG` to a service nick intentionally return
+   * `undefined` so they fall through to the normal user-target reducer.
+   *
+   * The membership test is a table lookup against {@link SERVICE_REDUCER_KEYS}
+   * (built from the same `*_NICK` constants that back
+   * {@link SHORTCUT_TO_SERVICE}), so the service-nick list has one source of
+   * truth rather than a per-service `if`-chain here.
+   */
+  private serviceReducerFor(target: string, command: string): Reducer<ConnectionState> | undefined {
+    if (command !== 'PRIVMSG' || this.services === undefined) return undefined;
+    const key = SERVICE_REDUCER_KEYS.get(caseFold('rfc1459', target));
+    return key === undefined ? undefined : this.reducers[key];
+  }
+
   private unknownCommandEffect(command: string): EffectType {
     const nick = this.state.nick ?? '*';
     const code = Numerics.ERR_UNKNOWNCOMMAND.toString().padStart(3, '0');
@@ -1362,6 +1443,29 @@ function splitCsv(param: string): string[] {
   return param.split(',').filter((p) => p.length > 0);
 }
 
+/**
+ * Service reducer keys on {@link RoutedReducers}. Narrower than
+ * `keyof RoutedReducers` so the table lookup resolves to a
+ * `Reducer<ConnectionState>` without a widening cast.
+ */
+type ServiceReducerKey = 'nickserv' | 'chanserv' | 'hostserv' | 'memoserv' | 'operserv';
+
+/**
+ * rfc1459 case-folded service nick → reducer key. The single source of
+ * truth for "which targets are service nicks" — built from the canonical
+ * `*_NICK` constants that also back {@link SHORTCUT_TO_SERVICE}, so the
+ * dispatcher's shortcut rewrite and `serviceReducerFor`'s routing consult
+ * one set of service nicks rather than each maintaining its own
+ * hand-written `if`-chain.
+ */
+const SERVICE_REDUCER_KEYS: ReadonlyMap<string, ServiceReducerKey> = new Map([
+  [caseFold('rfc1459', NICKSERV_NICK), 'nickserv'],
+  [caseFold('rfc1459', CHANSERV_NICK), 'chanserv'],
+  [caseFold('rfc1459', HOSTSERV_NICK), 'hostserv'],
+  [caseFold('rfc1459', MEMOSERV_NICK), 'memoserv'],
+  [caseFold('rfc1459', OPERSERV_NICK), 'operserv'],
+]);
+
 /**
  * Resolves the `<server>` parameter shared by `LUSERS` / `STATS` (and any
  * future single-server-aware query verb). Returns `undefined` when the
@@ -1405,6 +1509,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),
   };
 }