serverless-ircd 0.3.0 → 0.4.0

package/packages/irc-core/tests/nick-history-store.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from 'vitest';
+import { FakeClock } from '../src/ports';
+import {
+  InMemoryNickHistoryStore,
+  type NickHistoryEntry,
+  type NickHistoryStore,
+} from '../src/ports';
+
+/** Builds a history entry with sensible defaults for tests. */
+function entry(
+  nick: string,
+  signoffTime: number,
+  opts: Partial<NickHistoryEntry> = {},
+): NickHistoryEntry {
+  return {
+    nick,
+    connId: opts.connId ?? 'c1',
+    signoffTime,
+    ...(opts.username !== undefined ? { username: opts.username } : {}),
+    ...(opts.hostname !== undefined ? { hostname: opts.hostname } : {}),
+    ...(opts.realname !== undefined ? { realname: opts.realname } : {}),
+  };
+}
+
+describe('InMemoryNickHistoryStore — record + query', () => {
+  it('implements the NickHistoryStore port', () => {
+    const store: NickHistoryStore = new InMemoryNickHistoryStore(new FakeClock(1_000));
+    expect(store).toBeDefined();
+  });
+
+  it('returns a recorded entry on query (most-recent-first)', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('alice', 1_000, { username: 'alice', hostname: 'ex.org' }));
+
+    const out = store.query('alice', 10);
+
+    expect(out).toHaveLength(1);
+    expect(out[0]?.nick).toBe('alice');
+    expect(out[0]?.username).toBe('alice');
+    expect(out[0]?.hostname).toBe('ex.org');
+    expect(out[0]?.signoffTime).toBe(1_000);
+  });
+
+  it('returns multiple entries most-recent-first', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('alice', 1_000, { connId: 'c1' }));
+    clock.advance(500);
+    store.record(entry('alice', 1_500, { connId: 'c2' }));
+    clock.advance(500);
+    store.record(entry('alice', 2_000, { connId: 'c3' }));
+
+    const out = store.query('alice', 10);
+    expect(out.map((e) => e.connId)).toEqual(['c3', 'c2', 'c1']);
+  });
+
+  it('caps the result at the requested count', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('alice', 1_000, { connId: 'c1' }));
+    clock.advance(500);
+    store.record(entry('alice', 1_500, { connId: 'c2' }));
+    clock.advance(500);
+    store.record(entry('alice', 2_000, { connId: 'c3' }));
+
+    const out = store.query('alice', 2);
+
+    expect(out.map((e) => e.connId)).toEqual(['c3', 'c2']);
+  });
+
+  it('returns an empty array for a nick with no history', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    expect(store.query('ghost', 10)).toEqual([]);
+  });
+
+  it('matches nicks case-insensitively (rfc1459 fold)', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('Ali[e', 1_000));
+
+    expect(store.query('ali{e', 10)).toHaveLength(1);
+    expect(store.query('ALI{E', 10)).toHaveLength(1);
+    expect(store.query('ALI[E', 10)).toHaveLength(1);
+  });
+
+  it('returns an empty array when count is zero', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('alice', 1_000));
+
+    expect(store.query('alice', 0)).toEqual([]);
+  });
+
+  it('keeps nick histories independent', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('alice', 1_000));
+    clock.advance(500);
+    store.record(entry('bob', 1_500));
+
+    expect(store.query('alice', 10)).toHaveLength(1);
+    expect(store.query('bob', 10)).toHaveLength(1);
+  });
+});
+
+describe('InMemoryNickHistoryStore — TTL purge', () => {
+  it('purges entries older than maxAge on query', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock, { maxAge: 5_000 });
+    store.record(entry('alice', 1_000, { connId: 'c1' }));
+    clock.advance(3_000);
+    store.record(entry('alice', 4_000, { connId: 'c2' }));
+    clock.advance(3_000);
+
+    const out = store.query('alice', 10);
+
+    expect(out.map((e) => e.connId)).toEqual(['c2']);
+  });
+
+  it('purges all entries once they exceed maxAge', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock, { maxAge: 1_000 });
+    store.record(entry('alice', 1_000));
+    clock.advance(2_000);
+
+    expect(store.query('alice', 10)).toEqual([]);
+  });
+
+  it('purges on record so the per-nick buffer does not grow unbounded', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock, { maxAge: 1_000 });
+    for (let i = 0; i < 50; i++) {
+      store.record(entry('alice', clock.now(), { connId: `c${i}` }));
+      clock.advance(100);
+    }
+    // clock.now() is now 6_000; entries older than cutoff 5_000 are purged.
+    const out = store.query('alice', 100);
+    expect(out.length).toBeLessThan(50);
+  });
+
+  it('purges to an empty array when all entries expire, then query returns empty', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock, { maxAge: 1_000 });
+    store.record(entry('alice', 1_000, { connId: 'c1' }));
+    clock.advance(2_000);
+    // First query purges the lone entry → empty buffer remains in the map.
+    expect(store.query('alice', 10)).toEqual([]);
+    // Second query hits purgeExpired on the now-empty buffer (no-op splice).
+    expect(store.query('alice', 10)).toEqual([]);
+  });
+
+  it('uses a sane default maxAge when omitted', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('alice', 1_000));
+    clock.advance(10_000);
+
+    expect(store.query('alice', 10)).toHaveLength(1);
+  });
+});

package/packages/irc-core/tests/numerics.test.ts

@@ -23,6 +23,18 @@ describe('Numerics registry', () => {
     expect(Numerics.ERR_NEEDMOREPARAMS).toBe(461);
   });
 
+  it('maps RPL_WHOWASUSER to 314', () => {
+    expect(Numerics.RPL_WHOWASUSER).toBe(314);
+  });
+
+  it('maps RPL_ENDOFWHOWAS to 369', () => {
+    expect(Numerics.RPL_ENDOFWHOWAS).toBe(369);
+  });
+
+  it('maps ERR_WASNOSUCHNICK to 406', () => {
+    expect(Numerics.ERR_WASNOSUCHNICK).toBe(406);
+  });
+
   it('maps ERR_NICKNAMEINUSE to 433', () => {
     expect(Numerics.ERR_NICKNAMEINUSE).toBe(433);
   });

package/packages/irc-core/tests/types.test.ts

@@ -1,7 +1,12 @@
 import { describe, expect, it } from 'vitest';
 import type { RawLine } from '../src/effects';
 import { Effect as EffectValue } from '../src/effects';
-import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../src/ports';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryNickHistoryStore,
+  SequentialIdFactory,
+} from '../src/ports';
 import { createConnection } from '../src/state/connection';
 import {
   type Ctx,
@@ -97,6 +102,35 @@ describe('Ctx / Reducer types', () => {
     const keys = Object.keys(ctx) as Array<keyof Ctx>;
     expect(keys).not.toContain('msg');
   });
+
+  it('threads an optional history store through buildCtx onto ctx.history', () => {
+    const history = new InMemoryNickHistoryStore(new FakeClock(0));
+    const serverConfig: ServerConfig = {
+      serverName: 'irc.example.com',
+      networkName: 'ExampleNet',
+      maxChannelsPerUser: 30,
+      maxTargetsPerCommand: 10,
+      maxListEntries: 50,
+      nickLen: 30,
+      channelLen: 50,
+      topicLen: 390,
+      quitMessage: 'Client Quit',
+    };
+    const ctx = buildCtx({
+      serverConfig,
+      clock: new FakeClock(1_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: createConnection({ id: 'c1', connectedSince: 0 }),
+      history,
+    });
+    expect(ctx.history).toBe(history);
+  });
+
+  it('omits ctx.history when no history store is supplied', () => {
+    const ctx = makeCtx();
+    expect(ctx.history).toBeUndefined();
+  });
 });
 
 describe('ServerConfig shape', () => {

package/packages/irc-core/tsconfig.build.json

@@ -5,7 +5,7 @@
     "rootDir": "./src",
     "outDir": "./dist",
     "tsBuildInfoFile": "./.tsbuildinfo",
-    "types": []
+    "types": ["node"]
   },
   "include": ["src/**/*.ts"],
   "exclude": ["dist", "tests", "**/*.test.ts"]

package/packages/irc-core/tsconfig.test.json

@@ -2,7 +2,7 @@
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
     "noEmit": true,
-    "types": [],
+    "types": ["node"],
     "composite": false
   },
   "include": ["src/**/*.ts", "tests/**/*.ts"],

package/packages/irc-server/package.json

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

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

@@ -30,6 +30,7 @@ import {
   type ChanName,
   type ChannelState,
   type Clock,
+  type ConnSnapshot,
   type ConnectionState,
   Effect,
   type Effect as EffectType,
@@ -39,6 +40,8 @@ import {
   type Logger,
   type MessageStore,
   type MotdProvider,
+  type MtlsIdentityProvider,
+  type NickHistoryStore,
   NoopLoggerInstance,
   Numerics,
   type RawLine,
@@ -47,15 +50,20 @@ import {
   chathistoryReducer,
   handleJoinZero,
   isChannelTarget,
+  isonReducer,
   listReducer,
   parse,
+  toSnapshot,
+  userhostReducer,
   whoReducer,
   whoisReducer,
+  whowasReducer,
 } from '@serverless-ircd/irc-core';
 import { dispatch } from './dispatch.js';
 import type { DispatchOptions } from './dispatch.js';
 import { type RoutedReducers, buildRoutedReducers } from './routing.js';
 import type { IrcRuntime } from './runtime.js';
+import { type Transport, WsTextFrameTransport } from './transport.js';
 
 /**
  * Channel-state access for the actor.
@@ -114,6 +122,22 @@ export interface ConnectionActorOptions {
    * can vouch for the credentials.
    */
   readonly accounts?: AccountStore;
+  /**
+   * mTLS client-cert identity source for SASL EXTERNAL (absent when mTLS
+   * is not configured). When bound, `ctx.mtlsIdentity` is defined so the
+   * `AUTHENTICATE EXTERNAL` reducer can resolve the connection's verified
+   * certificate subject. Omitted (→ `ctx.mtlsIdentity` undefined) means
+   * EXTERNAL is rejected with `904 ERR_SASLFAIL`.
+   */
+  readonly mtlsIdentity?: MtlsIdentityProvider;
+  /**
+   * Nick-history source for the `WHOWAS` command (absent when WHOWAS
+   * history retention is disabled). When bound, `ctx.history` is defined
+   * so the QUIT and NICK-change reducers record sign-off entries and the
+   * WHOWAS reducer replays them. Omitted (→ `ctx.history` undefined)
+   * preserves the no-store behaviour: `WHOWAS <nick>` emits `406`+`369`.
+   */
+  readonly history?: NickHistoryStore;
   /**
    * Structured-logger port. When omitted the actor runs
    * silently — observability is purely opt-in. When supplied, every
@@ -127,6 +151,15 @@ export interface ConnectionActorOptions {
    * still uniquely identifiable in logs.
    */
   readonly traceId?: string;
+  /**
+   * Line-framing seam (PLAN §9, ADR-009). Turns inbound transport input
+   * into complete IRC lines. Defaults to a {@link WsTextFrameTransport}
+   * (one message per WebSocket text frame, the serverless default). A raw
+   * TCP+TLS adapter injects a {@link TcpByteStreamTransport} for stateful
+   * `\r\n` byte-stream framing across chunks. The parser/reducer/dispatch
+   * pipeline is shared unchanged across both transports.
+   */
+  readonly transport?: Transport;
 }
 
 export class ConnectionActor {
@@ -139,7 +172,16 @@ export class ConnectionActor {
   private readonly motd: MotdProvider;
   private readonly messages: MessageStore | undefined;
   private readonly accounts: AccountStore | undefined;
+  private readonly mtlsIdentity: MtlsIdentityProvider | undefined;
+  private readonly history: NickHistoryStore | undefined;
   private readonly reducers: RoutedReducers;
+  /**
+   * Line-framing seam. Turns inbound input (a WS text frame or a raw TCP
+   * chunk) into complete IRC lines. Defaulted to a WS-frame transport for
+   * the serverless default; a TCP+TLS adapter injects the stateful
+   * byte-stream transport at construction.
+   */
+  private readonly transport: Transport;
   /**
    * Bound logger. Defaults to a no-op so the actor pipeline has no
    * observable side effects when callers do not opt in.
@@ -163,6 +205,8 @@ export class ConnectionActor {
     this.motd = opts.motd ?? EmptyMotdProvider;
     this.messages = opts.messages;
     this.accounts = opts.accounts;
+    this.mtlsIdentity = opts.mtlsIdentity;
+    this.history = opts.history;
     this.logger = opts.logger ?? NoopLoggerInstance;
     this.pinnedTraceId = opts.traceId;
     // Bind the connection id once so every record the actor emits carries
@@ -176,15 +220,19 @@ export class ConnectionActor {
     // reducer when flood control is disabled) so a flooding client is bounded
     // regardless of which authority owns the command's state.
     this.reducers = buildRoutedReducers(opts.serverConfig);
+    this.transport = opts.transport ?? new WsTextFrameTransport();
   }
 
   /**
-   * Processes one WebSocket text frame. Splits on `\r\n` (tolerating bare
-   * `\n`) and dispatches each non-empty line in order. A parse failure on
-   * one line emits a `421` and processing continues with the next line.
+   * Transport-agnostic entry point: feeds `chunk` through the bound
+   * {@link Transport} and dispatches each complete, non-empty line in order.
+   * A WS adapter passes one text frame per call; a raw TCP+TLS adapter
+   * passes one arbitrary byte chunk per call and the transport buffers any
+   * partial trailing line across calls. A parse failure on one line emits a
+   * `421` and processing continues with the next line.
    */
-  async receiveTextFrame(text: string): Promise<void> {
-    const lines = splitFrameLines(text);
+  async receive(chunk: string): Promise<void> {
+    const lines = this.transport.feed(chunk);
     if (lines.length === 0) return;
     const traceId = this.pinnedTraceId ?? this.ids.traceId();
     const log = this.logger.child({ traceId });
@@ -194,6 +242,17 @@ export class ConnectionActor {
     }
   }
 
+  /**
+   * Processes one WebSocket text frame. Equivalent to {@link receive} — kept
+   * as the named entry point every WS adapter already calls. Splits on
+   * `\r\n` (tolerating bare `\n`) via the default WS-frame transport and
+   * dispatches each non-empty line in order. A parse failure on one line
+   * emits a `421` and processing continues with the next line.
+   */
+  async receiveTextFrame(text: string): Promise<void> {
+    await this.receive(text);
+  }
+
   private async processLine(line: string, log: Logger, traceId: string): Promise<void> {
     let msg: IrcMessage;
     let parseFailed = false;
@@ -256,6 +315,8 @@ export class ConnectionActor {
       connection: this.state,
       ...(this.messages !== undefined ? { messages: this.messages } : {}),
       ...(this.accounts !== undefined ? { accounts: this.accounts } : {}),
+      ...(this.mtlsIdentity !== undefined ? { mtlsIdentity: this.mtlsIdentity } : {}),
+      ...(this.history !== undefined ? { history: this.history } : {}),
     });
 
     switch (msg.command) {
@@ -283,6 +344,20 @@ export class ConnectionActor {
       case 'AWAY':
         return this.reducers.away(this.state, msg, ctx).effects;
 
+      // -------- Server-info query commands --------
+      case 'VERSION':
+        return this.reducers.version(this.state, msg, ctx).effects;
+      case 'TIME':
+        return this.reducers.time(this.state, msg, ctx).effects;
+      case 'ADMIN':
+        return this.reducers.admin(this.state, msg, ctx).effects;
+      case 'INFO':
+        return this.reducers.info(this.state, msg, ctx).effects;
+      case 'USERHOST':
+        return this.routeUserhost(msg, ctx);
+      case 'ISON':
+        return this.routeIson(msg, ctx);
+
       // -------- Channel-authority commands --------
       case 'JOIN':
         return this.routeJoin(msg, ctx);
@@ -305,6 +380,8 @@ export class ConnectionActor {
         return this.routeWho(msg, ctx);
       case 'WHOIS':
         return this.routeWhois(msg, ctx);
+      case 'WHOWAS':
+        return this.routeWhowas(msg, ctx);
       case 'CHATHISTORY':
         return this.routeChathistory(msg, ctx);
 
@@ -339,6 +416,16 @@ export class ConnectionActor {
           : this.reducers.userMode(this.state, msg, ctx).effects;
 
       default:
+        // Remaining standard IRC verbs not yet implemented. They fall through
+        // to a graceful `421 ERR_UNKNOWNCOMMAND`. Triage of remaining verbs:
+        //   - Deferred (serverless-incompatible / S2S / needs new infra):
+        //     LUSERS (needs cross-adapter getStats), KILL (oper disconnect),
+        //     REHASH (no runtime config reload), CONNECT/SQUIT (S2S, PLAN
+        //     non-goal), TRACE (complex routing info), STATS (stats backend),
+        //     WALLOPS (oper broadcast mechanism), SETNAME (CHGHOST plumbing),
+        //     LINKS (S2S server list).
+        //   - Obsolete (RFC 2812, never widely implemented): SERVICE, SUMMON,
+        //     USERS.
         return [this.unknownCommandEffect(msg.command)];
     }
   }
@@ -387,6 +474,72 @@ export class ConnectionActor {
     return whoisReducer(target, channels, msg, ctx).effects;
   }
 
+  /**
+   * Routes `WHOWAS <nick>{,<nick>} [<count>]` to the whowas reducer. The
+   * command is query-only: it reads the bound nick-history store
+   * (`this.history`, absent when no store is wired) and emits
+   * `314`/`369`/`406` numerics. No runtime lookups are needed — the store
+   * is synchronous and self-contained.
+   */
+  private async routeWhowas(
+    msg: IrcMessage,
+    ctx: ReturnType<typeof buildCtx>,
+  ): Promise<EffectType[]> {
+    return whowasReducer(this.history, msg, ctx).effects;
+  }
+
+  /**
+   * Routes `USERHOST <nick>{ <nick>}` to the userhost reducer. Resolves each
+   * requested nick via the nick registry + connection lookup, passing the
+   * resulting snapshots (or `null` for offline nicks) to the pure formatter.
+   * The number of queried nicks is capped at
+   * `serverConfig.maxTargetsPerCommand` by the reducer.
+   */
+  private async routeUserhost(
+    msg: IrcMessage,
+    ctx: ReturnType<typeof buildCtx>,
+  ): Promise<EffectType[]> {
+    const cap = ctx.serverConfig.maxTargetsPerCommand;
+    const nicks = msg.params.slice(0, cap);
+    const resolved = new Map<string, ConnSnapshot | null>();
+    for (const nick of nicks) {
+      if (nick.length === 0) continue;
+      const connId = await this.runtime.lookupNick(nick);
+      if (connId === null) {
+        resolved.set(nick, null);
+        continue;
+      }
+      const conn = await this.runtime.getConnection(connId);
+      resolved.set(nick, conn === null ? null : toSnapshot(conn));
+    }
+    return userhostReducer(resolved, msg, ctx).effects;
+  }
+
+  /**
+   * Routes `ISON <nick>{ <nick>}` to the ison reducer. Resolves each requested
+   * nick via the nick registry; for online nicks, fetches the connection to
+   * recover the registered (display) spelling. Passes a folded→display map to
+   * the pure formatter.
+   */
+  private async routeIson(
+    msg: IrcMessage,
+    ctx: ReturnType<typeof buildCtx>,
+  ): Promise<EffectType[]> {
+    const cap = ctx.serverConfig.maxTargetsPerCommand;
+    const nicks = msg.params.slice(0, cap);
+    const online = new Map<string, string>();
+    for (const nick of nicks) {
+      if (nick.length === 0) continue;
+      const connId = await this.runtime.lookupNick(nick);
+      if (connId === null) continue;
+      const conn = await this.runtime.getConnection(connId);
+      if (conn?.nick !== undefined) {
+        online.set(conn.nick.toLowerCase(), conn.nick);
+      }
+    }
+    return isonReducer(online, msg, ctx).effects;
+  }
+
   /**
    * Routes `CHATHISTORY <sub> <target> [<args>...]` to the chathistory
    * reducer. The command is query-only and must NOT create a channel as a
@@ -531,15 +684,6 @@ export class ConnectionActor {
   }
 }
 
-/**
- * Splits a WebSocket text frame into IRC lines. Tolerates `\r\n`, bare `\n`,
- * and missing trailing terminators. Returns each line bare (no CRLF).
- */
-export function splitFrameLines(text: string): string[] {
-  if (text.length === 0) return [];
-  return text.split(/\r?\n/u);
-}
-
 /** Returns the first whitespace-delimited token of `line`, or `''`. */
 function firstToken(line: string): string {
   const m = line.match(/^\S+/u);

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

@@ -33,9 +33,6 @@ const handlers: { [K in Effect['tag']]: Handler<Extract<Effect, { tag: K }>> } =
   ChangeNick: (e, r) => r.changeNick(e.conn, e.oldNick, e.newNick).then(noop),
   ReleaseNick: (e, r) => r.releaseNick(e.nick),
   ApplyChannelDelta: (e, r) => r.applyChannelDelta(e.chan, e.delta),
-  LookupNick: (e, r) => r.lookupNick(e.nick).then(noop),
-  GetConnectionInfo: (e, r) => r.getConnectionInfo(e.conn).then(noop),
-  GetChannelSnapshot: (e, r) => r.getChannelSnapshot(e.chan).then(noop),
 };
 
 function noop(): void {}

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

@@ -3,11 +3,19 @@
  *
  * Orchestration layer: defines the {@link IrcRuntime} port, the {@link dispatch}
  * interpreter that runs an `Effect[]` against it, and the {@link ConnectionActor}
- * that turns a WebSocket text frame into reducer invocations + dispatch.
+ * that turns inbound transport input (a WebSocket text frame or a raw TCP byte
+ * chunk) into reducer invocations + dispatch via the transport-agnostic
+ * {@link Transport} framing seam.
  */
 export type { IrcRuntime } from './runtime.js';
 export { dispatch } from './dispatch.js';
-export { ConnectionActor, splitFrameLines } from './actor.js';
+export { ConnectionActor } from './actor.js';
 export type { ActorChannelAccess, ConnectionActorOptions } from './actor.js';
+export {
+  splitFrameLines,
+  WsTextFrameTransport,
+  TcpByteStreamTransport,
+} from './transport.js';
+export type { Transport } from './transport.js';
 export { buildRoutedReducers, resolveFloodControl } from './routing.js';
 export type { RoutedReducers } from './routing.js';

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

@@ -29,11 +29,13 @@ import {
   type FloodControlConfig,
   type Reducer,
   type ServerConfig,
+  adminReducer,
   authenticateReducer,
   awayReducer,
   capReducer,
   channelModeReducer,
   defaultCommandCost,
+  infoReducer,
   inviteReducer,
   joinReducer,
   kickReducer,
@@ -52,9 +54,11 @@ import {
   quitReducer,
   tagmsgChannelReducer,
   tagmsgUserReducer,
+  timeReducer,
   topicReducer,
   userModeReducer,
   userReducer,
+  versionReducer,
   wrapWithFloodControl,
 } from '@serverless-ircd/irc-core';
 
@@ -76,6 +80,10 @@ export interface RoutedReducers {
   readonly cap: Reducer<ConnectionState>;
   readonly authenticate: Reducer<ConnectionState>;
   readonly away: Reducer<ConnectionState>;
+  readonly version: Reducer<ConnectionState>;
+  readonly time: Reducer<ConnectionState>;
+  readonly admin: Reducer<ConnectionState>;
+  readonly info: Reducer<ConnectionState>;
   // Channel-authority reducers.
   readonly join: Reducer<ChannelState>;
   readonly part: Reducer<ChannelState>;
@@ -142,6 +150,10 @@ export function buildRoutedReducers(serverConfig: ServerConfig): RoutedReducers
     cap: wrap(capReducer),
     authenticate: wrap(authenticateReducer),
     away: wrap(awayReducer),
+    version: wrap(versionReducer),
+    time: wrap(timeReducer),
+    admin: wrap(adminReducer),
+    info: wrap(infoReducer),
     join: wrap(joinReducer),
     part: wrap(partReducer),
     topic: wrap(topicReducer),