serverless-ircd 0.3.0 → 0.4.0

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

@@ -0,0 +1,101 @@
+/**
+ * Transport seam: turns raw transport input into complete IRC lines.
+ *
+ * PLAN §9 (ADR-009) — the pure reducer core + `ConnectionActor` are shared
+ * across both the WebSocket (`wss`) and the raw TCP+TLS (`irc+tls :6697`)
+ * transports. The only transport-specific concern is line framing:
+ *   - A WebSocket text frame is a complete unit (one or N `\r\n`-joined
+ *     messages), so a trailing unterminated line is still emitted.
+ *   - A raw TCP byte stream arrives in arbitrary chunks, so a partial line
+ *     at a chunk boundary must be buffered until its `\r\n` terminator
+ *     arrives.
+ *
+ * Both transports emit complete lines (no terminators); the actor skips
+ * empty lines and parses each non-empty one through the shared
+ * parser/reducer/dispatch pipeline.
+ */
+
+/**
+ * The line-framing contract a {@link ConnectionActor} consumes. `feed`
+ * returns the complete IRC lines terminated within `chunk`; a stateful
+ * transport buffers any incomplete trailing line for the next call.
+ */
+export interface Transport {
+  feed(chunk: string): string[];
+}
+
+/**
+ * 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.
+ */
+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.
+ * A frame may carry one message or N `\r\n`-joined messages; a trailing
+ * unterminated line is emitted because the frame itself is the unit of
+ * completeness. This is the default transport for the WebSocket adapters.
+ */
+export class WsTextFrameTransport implements Transport {
+  feed(chunk: string): string[] {
+    return splitFrameLines(chunk);
+  }
+}
+
+/**
+ * Stateful TCP byte-stream transport: reassembles `\r\n`- (or bare `\n`-)
+ * terminated lines across arbitrary chunks, buffering any partial trailing
+ * line until its terminator arrives. Used by the raw TCP+TLS adapter path
+ * (PLAN §9). One instance owns one connection's buffer for its lifetime.
+ *
+ * For long-lived TCP connections fronted by request/response compute (AWS
+ * NLB + Lambda) each client chunk arrives in a fresh Lambda
+ * invocation. The partial-line buffer must persist across those
+ * invocations. {@link getBuffer} / {@link restore} snapshot the in-flight
+ * bytes so the adapter can round-trip them through its data store
+ * (DynamoDB) between chunks.
+ */
+export class TcpByteStreamTransport implements Transport {
+  private buffer = '';
+
+  feed(chunk: string): string[] {
+    if (chunk.length === 0) return [];
+    this.buffer += chunk;
+    const lines: string[] = [];
+    let start = 0;
+    for (let i = 0; i < this.buffer.length; i++) {
+      if (this.buffer[i] === '\n') {
+        // A `\n` terminates a line. Strip a preceding `\r` so both `\r\n`
+        // and bare `\n` yield the same bare line.
+        const lineEnd = i > 0 && this.buffer[i - 1] === '\r' ? i - 1 : i;
+        lines.push(this.buffer.slice(start, lineEnd));
+        start = i + 1;
+      }
+    }
+    this.buffer = this.buffer.slice(start);
+    return lines;
+  }
+
+  /**
+   * Returns the partial-line bytes currently buffered (not yet terminated).
+   * Empty when every fed byte has been emitted as a complete line. The
+   * adapter persists this between compute invocations so a chunk split
+   * across two requests is reassembled correctly.
+   */
+  getBuffer(): string {
+    return this.buffer;
+  }
+
+  /**
+   * Replaces the internal buffer with `buffer`. Call before {@link feed}
+   * when restoring from a persisted snapshot. An empty (or omitted)
+   * `buffer` resets the transport to a fresh state.
+   */
+  restore(buffer: string): void {
+    this.buffer = buffer;
+  }
+}

package/packages/irc-server/tests/actor.test.ts

@@ -12,10 +12,13 @@ import {
   FakeClock,
   type FloodControlConfig,
   InMemoryMessageStore,
+  InMemoryNickHistoryStore,
   LogLevel,
   type Logger,
   type MessageStore,
+  type MtlsIdentityProvider,
   type Nick,
+  type NickHistoryStore,
   Numerics,
   type RawLine,
   type SaslPayload,
@@ -34,6 +37,8 @@ import {
 import { describe, expect, it } from 'vitest';
 import { ConnectionActor } from '../src/actor';
 import type { IrcRuntime } from '../src/runtime';
+import { TcpByteStreamTransport, WsTextFrameTransport } from '../src/transport';
+import type { Transport } from '../src/transport';
 
 // ---------------------------------------------------------------------------
 // Fakes
@@ -161,7 +166,10 @@ function makeActor(opts: {
   traceId?: string;
   messages?: MessageStore;
   accounts?: AccountStore;
+  mtlsIdentity?: MtlsIdentityProvider;
+  history?: NickHistoryStore;
   operCreds?: ReadonlyArray<{ user: string; password: string }>;
+  transport?: Transport;
 }): { actor: ConnectionActor; runtime: FakeRuntime; conn: ConnectionState } {
   const clock = opts.clock ?? new FakeClock(1_000);
   const conn = createConnection({ id: 'c1', connectedSince: 0 });
@@ -215,6 +223,15 @@ function makeActor(opts: {
   if (opts.accounts !== undefined) {
     finalOpts.accounts = opts.accounts;
   }
+  if (opts.mtlsIdentity !== undefined) {
+    finalOpts.mtlsIdentity = opts.mtlsIdentity;
+  }
+  if (opts.history !== undefined) {
+    finalOpts.history = opts.history;
+  }
+  if (opts.transport !== undefined) {
+    finalOpts.transport = opts.transport;
+  }
   const actor = new ConnectionActor(finalOpts);
   return { actor, runtime, conn };
 }
@@ -278,6 +295,112 @@ describe('ConnectionActor — framing', () => {
   });
 });
 
+describe('ConnectionActor — TCP byte-stream transport seam', () => {
+  it('two TCP chunks split mid-line produce exactly one PRIVMSG broadcast', async () => {
+    const { actor, runtime } = makeActor({ transport: new TcpByteStreamTransport() });
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    runtime.calls.length = 0;
+
+    // Split the single message mid-payload across two chunks. The partial
+    // line is buffered across the first chunk; only the second completes it.
+    await actor.receive('PRIVMSG #foo :hel');
+    expect(runtime.calls).toHaveLength(0);
+    await actor.receive('lo\r\n');
+
+    const broadcasts = runtime.calls.filter((c) => c.method === 'broadcast');
+    expect(broadcasts).toHaveLength(1);
+    expect(broadcasts[0]?.args[0]).toBe('#foo');
+    const lines = broadcasts[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toBe(':alice!alice@example.com PRIVMSG #foo :hello');
+  });
+
+  it('one message per WS text frame and one per CRLF over TCP produce identical effects', async () => {
+    // Same bytes, same connection setup, two transports. The WS actor gets
+    // the whole frame in one receiveTextFrame; the TCP actor gets the same
+    // bytes split across arbitrary chunks via receive().
+    const wsSetup = makeActor({});
+    const tcpSetup = makeActor({ transport: new TcpByteStreamTransport() });
+    for (const rt of [wsSetup.runtime, tcpSetup.runtime]) {
+      await rt.applyChannelDelta('#foo', {
+        memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+      });
+    }
+    wsSetup.runtime.calls.length = 0;
+    tcpSetup.runtime.calls.length = 0;
+
+    const stream = 'PRIVMSG #foo :hello\r\n';
+    await wsSetup.actor.receiveTextFrame(stream);
+    // Feed the TCP actor the same bytes in 4-byte chunks.
+    for (let i = 0; i < stream.length; i += 4) {
+      await tcpSetup.actor.receive(stream.slice(i, i + 4));
+    }
+
+    const wsBroadcast = wsSetup.runtime.calls.filter((c) => c.method === 'broadcast');
+    const tcpBroadcast = tcpSetup.runtime.calls.filter((c) => c.method === 'broadcast');
+    expect(tcpBroadcast).toHaveLength(wsBroadcast.length);
+    expect((tcpBroadcast[0]?.args[1] as RawLine[])[0]?.text).toBe(
+      (wsBroadcast[0]?.args[1] as RawLine[])[0]?.text,
+    );
+  });
+
+  it('buffers a partial line across multiple chunks with no loss or duplication', async () => {
+    const { actor, runtime } = makeActor({ transport: new TcpByteStreamTransport() });
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    runtime.calls.length = 0;
+
+    // Three messages, each fed byte-by-byte. Every complete line is emitted
+    // exactly once; nothing is lost or duplicated at the chunk boundaries.
+    const stream = 'PING :a\r\nPRIVMSG #foo :b\r\nPING :c\r\n';
+    for (const ch of stream) {
+      await actor.receive(ch);
+    }
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const broadcasts = runtime.calls.filter((c) => c.method === 'broadcast');
+    expect(sends).toHaveLength(2); // PONG :a, PONG :c
+    expect((sends[0]?.args[1] as RawLine[])[0]?.text).toBe('PONG :a');
+    expect((sends[1]?.args[1] as RawLine[])[0]?.text).toBe('PONG :c');
+    expect(broadcasts).toHaveLength(1); // PRIVMSG #foo :b
+    expect((broadcasts[0]?.args[1] as RawLine[])[0]?.text).toBe(
+      ':alice!alice@example.com PRIVMSG #foo :b',
+    );
+  });
+
+  it('uses the default WS-frame transport when none is injected (backward compat)', () => {
+    // No `transport` option → the actor still frames WS text frames exactly
+    // as before. Confirms the default is the stateless WS transport.
+    const { actor, runtime } = makeActor({});
+    // A trailing unterminated line is still emitted by the WS transport
+    // (frame = complete unit), so this produces one PONG with no terminator.
+    return actor.receiveTextFrame('PING :tok').then(() => {
+      const sends = runtime.calls.filter((c) => c.method === 'send');
+      expect(sends).toHaveLength(1);
+      expect((sends[0]?.args[1] as RawLine[])[0]?.text).toBe('PONG :tok');
+    });
+  });
+
+  it('a TCP actor does NOT emit a trailing unterminated line until the terminator arrives', async () => {
+    const tcpActor = makeActor({ transport: new TcpByteStreamTransport() });
+    const wsActor = makeActor({ transport: new WsTextFrameTransport() });
+    tcpActor.runtime.calls.length = 0;
+    wsActor.runtime.calls.length = 0;
+
+    // WS treats the frame as complete → emits a PONG. TCP buffers the
+    // unterminated line → emits nothing yet. This is the defining
+    // behavioural difference of stateful byte-stream framing.
+    await wsActor.actor.receiveTextFrame('PING :unterminated');
+    await tcpActor.actor.receive('PING :unterminated');
+    expect(wsActor.runtime.calls.filter((c) => c.method === 'send')).toHaveLength(1);
+    expect(tcpActor.runtime.calls).toHaveLength(0);
+    // …until the terminator completes the line.
+    await tcpActor.actor.receive('\r\n');
+    expect(tcpActor.runtime.calls.filter((c) => c.method === 'send')).toHaveLength(1);
+  });
+});
+
 describe('ConnectionActor — malformed input', () => {
   it('emits 421 for an unparseable line and continues processing the rest', async () => {
     const { actor, runtime } = makeActor({});
@@ -512,9 +635,7 @@ describe('ConnectionActor — additional routing', () => {
 
     // Cap-gated broadcast dispatches per-recipient via send (only to
     // message-tags-enabled members, excluding the sender).
-    const sends = runtime.calls.filter(
-      (c) => c.method === 'send' && c.args[0] === 'c2',
-    );
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c2');
     expect(sends).toHaveLength(1);
     const lines = sends[0]?.args[1] as RawLine[];
     expect(lines[0]?.text).toBe('@+typing=active :alice!alice@example.com TAGMSG #foo');
@@ -664,6 +785,76 @@ describe('ConnectionActor — additional routing', () => {
     }
   });
 
+  it('routes WHOWAS of a quit nick through whowasReducer (314 + 369, never 421)', async () => {
+    const history = new InMemoryNickHistoryStore(new FakeClock(1_000));
+    history.record({
+      nick: 'bob',
+      connId: 'c2',
+      username: 'bob',
+      hostname: 'example.com',
+      realname: 'Bob',
+      signoffTime: 500,
+    });
+    const { actor, runtime } = makeActor({ history });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('WHOWAS bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends.length).toBeGreaterThanOrEqual(2);
+    const firstBatch = sends[0]?.args[1] as RawLine[];
+    expect(firstBatch[0]?.text).toContain(' 314 ');
+    expect(firstBatch[0]?.text).toContain(' bob ');
+    const endBatch = sends[sends.length - 1]?.args[1] as RawLine[];
+    expect(endBatch[0]?.text).toContain(' 369 ');
+    for (const s of sends) {
+      for (const line of s.args[1] as RawLine[]) {
+        expect(line.text).not.toContain(' 421 ');
+      }
+    }
+  });
+
+  it('routes WHOWAS of an unknown nick to 406 then 369 (never 421)', async () => {
+    const history = new InMemoryNickHistoryStore(new FakeClock(1_000));
+    const { actor, runtime } = makeActor({ history });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('WHOWAS ghost\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(2);
+    const notFound = sends[0]?.args[1] as RawLine[];
+    expect(notFound[0]?.text).toContain(' 406 ');
+    expect(notFound[0]?.text).toContain(' ghost ');
+    const end = sends[1]?.args[1] as RawLine[];
+    expect(end[0]?.text).toContain(' 369 ');
+  });
+
+  it('still emits 406 + 369 for WHOWAS when no history store is bound (no crash)', async () => {
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('WHOWAS ghost\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(2);
+    const notFound = sends[0]?.args[1] as RawLine[];
+    expect(notFound[0]?.text).toContain(' 406 ');
+    const end = sends[1]?.args[1] as RawLine[];
+    expect(end[0]?.text).toContain(' 369 ');
+  });
+
+  it('records a nick into history on QUIT when a store is bound', async () => {
+    const history = new InMemoryNickHistoryStore(new FakeClock(1_000));
+    const { actor } = makeActor({ history });
+
+    await actor.receiveTextFrame('QUIT\r\n');
+
+    const entries = history.query('alice', 10);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.nick).toBe('alice');
+  });
+
   it('routes AUTHENTICATE PLAIN (post CAP REQ sasl) through authenticateReducer, never 421', async () => {
     // Pre-registration: client has opened CAP negotiation and requested sasl.
     // AUTHENTICATE must reach the SASL reducer, not the 421 fallthrough.
@@ -1489,3 +1680,209 @@ describe('ConnectionActor — SASL AccountStore plumbing', () => {
     expect(conn.account).toBeUndefined();
   });
 });
+
+describe('ConnectionActor — SASL EXTERNAL + mTLS plumbing', () => {
+  /** Fake AccountStore that accepts EXTERNAL with a known cert subject. */
+  class FakeAccountStore implements AccountStore {
+    readonly calls: Array<{ mech: string; payload: SaslPayload }> = [];
+    constructor(private readonly result: SaslResult) {}
+    verify(mech: string, payload: SaslPayload): SaslResult {
+      this.calls.push({ mech, payload });
+      return this.result;
+    }
+  }
+
+  /** Fake MtlsIdentityProvider returning a canned subject for 'c1'. */
+  class FakeMtlsProvider implements MtlsIdentityProvider {
+    constructor(private readonly identity: string | undefined) {}
+    getIdentity(connId: string): string | undefined {
+      return connId === 'c1' ? this.identity : undefined;
+    }
+  }
+
+  function saslReadyConn(): Partial<ConnectionState> {
+    return {
+      registration: 'pre-registration',
+      capNegotiating: true,
+      caps: new Set<string>(['sasl']),
+    };
+  }
+
+  it('completes SASL EXTERNAL with 900/903 when mTLS provider and store accept', async () => {
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const mtlsIdentity = new FakeMtlsProvider('CN=alice');
+    const { actor, runtime, conn } = makeActor({
+      conn: saslReadyConn(),
+      accounts,
+      mtlsIdentity,
+    });
+    conn.nick = 'alice';
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('AUTHENTICATE EXTERNAL\r\n');
+    await actor.receiveTextFrame('AUTHENTICATE +\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text.includes(' 900 '))).toBe(true);
+    expect(lines.some((l) => l.text.includes(' 903 '))).toBe(true);
+    expect(lines.some((l) => l.text.includes(' 904 '))).toBe(false);
+    expect(accounts.calls).toEqual([
+      { mech: 'EXTERNAL', payload: { kind: 'EXTERNAL', identity: 'CN=alice' } },
+    ]);
+    expect(conn.account).toBe('alice');
+  });
+
+  it('returns 908 for EXTERNAL when no mTLS provider is bound', async () => {
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const { actor, runtime, conn } = makeActor({
+      conn: saslReadyConn(),
+      accounts,
+      // No mtlsIdentity → EXTERNAL should 908 at mechanism phase.
+    });
+    conn.nick = 'alice';
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('AUTHENTICATE EXTERNAL\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text.includes(' 908 '))).toBe(true);
+    expect(lines.some((l) => l.text.includes(' 904 '))).toBe(false);
+    expect(conn.account).toBeUndefined();
+  });
+});
+
+describe('ConnectionActor — server-info commands (VERSION/TIME/ADMIN/INFO/USERHOST/ISON)', () => {
+  it('routes VERSION through versionReducer (351, never 421)', async () => {
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('VERSION\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 351 ');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+
+  it('routes TIME through timeReducer (391, never 421)', async () => {
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('TIME\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 391 ');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+
+  it('routes ADMIN through adminReducer (256, never 421)', async () => {
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('ADMIN\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 256 ');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+
+  it('routes INFO through infoReducer (371 + 374, never 421)', async () => {
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('INFO\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines.some((l) => l.text.includes(' 371 '))).toBe(true);
+    expect(lines.some((l) => l.text.includes(' 374 '))).toBe(true);
+    expect(lines.every((l) => !l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('routes USERHOST resolving online nicks (302, never 421)', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.nick = 'bob';
+    bobState.user = 'bobuser';
+    bobState.host = 'bobhost';
+    bobState.registration = 'registered';
+    runtime.addConnection(conn);
+    runtime.addConnection(bobState);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('USERHOST bob ghost\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 302 ');
+    expect(lines[0]?.text).toContain('bob=+bobuser@bobhost');
+    // Offline nick `ghost` is omitted from the reply.
+    expect(lines[0]?.text).not.toContain('ghost');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+
+  it('USERHOST marks away users with - and opers with *', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.nick = 'bob';
+    bobState.user = 'bobuser';
+    bobState.host = 'bobhost';
+    bobState.away = 'brb';
+    bobState.userModes.oper = true;
+    bobState.registration = 'registered';
+    runtime.addConnection(conn);
+    runtime.addConnection(bobState);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('USERHOST bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain('bob*=-bobuser@bobhost');
+  });
+
+  it('routes ISON resolving online nicks (303, never 421)', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.nick = 'bob';
+    bobState.registration = 'registered';
+    runtime.addConnection(conn);
+    runtime.addConnection(bobState);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('ISON bob ghost\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(' 303 ');
+    expect(lines[0]?.text).toContain('bob');
+    expect(lines[0]?.text).not.toContain('ghost');
+    expect(lines[0]?.text).not.toContain(' 421 ');
+  });
+
+  it('ISON matches case-insensitively and reports the registered spelling', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.nick = 'Bob';
+    bobState.registration = 'registered';
+    runtime.addConnection(conn);
+    runtime.addConnection(bobState);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('ISON BOB\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toContain(':Bob');
+  });
+});

package/packages/irc-server/tests/dispatch.test.ts

@@ -146,23 +146,6 @@ describe('dispatch', () => {
     expect(calls[0]).toEqual({ method: 'applyChannelDelta', args: ['#foo', delta] });
   });
 
-  it('invokes lookupNick, getConnectionInfo, getChannelSnapshot lookups', async () => {
-    const calls: RecordedCall[] = [];
-    await dispatch(
-      [
-        Effect.lookupNick('alice'),
-        Effect.getConnectionInfo('c1'),
-        Effect.getChannelSnapshot('#foo'),
-      ],
-      fakeRuntime(calls),
-    );
-    expect(calls.map((c) => c.method)).toEqual([
-      'lookupNick',
-      'getConnectionInfo',
-      'getChannelSnapshot',
-    ]);
-  });
-
   it('awaits each effect in sequence (one fails, the rest after it do not run)', async () => {
     const calls: RecordedCall[] = [];
     const failing: IrcRuntime = {

package/packages/irc-server/tests/routing.test.ts

@@ -109,10 +109,12 @@ describe('buildRoutedReducers', () => {
     const reducers = buildRoutedReducers(baseServerConfig);
     expect(Object.keys(reducers).sort()).toEqual(
       [
+        'admin',
         'authenticate',
         'away',
         'cap',
         'channelMode',
+        'info',
         'invite',
         'join',
         'kick',
@@ -131,9 +133,11 @@ describe('buildRoutedReducers', () => {
         'quit',
         'tagmsgChannel',
         'tagmsgUser',
+        'time',
         'topic',
         'user',
         'userMode',
+        'version',
       ].sort(),
     );
   });