serverless-ircd 0.2.0 → 0.4.0

package/packages/irc-core/tests/commands/userhost.test.ts

@@ -0,0 +1,264 @@
+import { describe, expect, it } from 'vitest';
+import { formatUserhostReply, userhostReducer } from '../../src/commands/userhost';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import {
+  type ConnSnapshot,
+  type ConnectionState,
+  createConnection,
+  toSnapshot,
+} from '../../src/state/connection';
+import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
+
+const baseServerConfig: ServerConfig = {
+  serverName: 'irc.example.com',
+  networkName: 'ExampleNet',
+  maxChannelsPerUser: 30,
+  maxTargetsPerCommand: 10,
+  maxListEntries: 50,
+  nickLen: 30,
+  channelLen: 50,
+  topicLen: 390,
+  quitMessage: 'Client Quit',
+};
+
+function makeCtx(state: ConnectionState): Ctx {
+  return buildCtx({
+    serverConfig: baseServerConfig,
+    clock: new FakeClock(5_000),
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: state,
+  });
+}
+
+function makeState(): ConnectionState {
+  const s = createConnection({ id: 'c1', connectedSince: 0 });
+  s.nick = 'alice';
+  s.user = 'alice';
+  s.host = 'example.com';
+  s.realname = 'Alice';
+  s.registration = 'registered';
+  return s;
+}
+
+function makeSnapshot(
+  nick: string,
+  user: string,
+  host: string,
+  opts?: { away?: string; oper?: boolean },
+): ConnSnapshot {
+  const s = createConnection({ id: `c-${nick}`, connectedSince: 0 });
+  s.nick = nick;
+  s.user = user;
+  s.host = host;
+  s.registration = 'registered';
+  if (opts?.away !== undefined) s.away = opts.away;
+  if (opts?.oper) s.userModes.oper = true;
+  return toSnapshot(s);
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const userhost = (...nicks: string[]) =>
+  ({ command: 'USERHOST', params: nicks, tags: {} }) as const;
+
+describe('userhostReducer', () => {
+  it('emits 302 RPL_USERHOST with the resolved hostmask for one nick', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([['bob', makeSnapshot('bob', 'bobuser', 'bobhost')]]);
+
+    const out = userhostReducer(resolved, userhost('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :bob=+bobuser@bobhost')]),
+    ]);
+  });
+
+  it('includes multiple replies space-separated in one 302 line', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([
+      ['bob', makeSnapshot('bob', 'bobuser', 'bobhost')],
+      ['carol', makeSnapshot('carol', 'caroluser', 'carolhost')],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob', 'carol'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(':irc.example.com 302 alice :bob=+bobuser@bobhost carol=+caroluser@carolhost'),
+      ]),
+    ]);
+  });
+
+  it('marks away users with - instead of +', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([
+      ['bob', makeSnapshot('bob', 'bobuser', 'bobhost', { away: 'gone' })],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :bob=-bobuser@bobhost')]),
+    ]);
+  });
+
+  it('prefixes oper users with *', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([['bob', makeSnapshot('bob', 'bobuser', 'bobhost', { oper: true })]]);
+
+    const out = userhostReducer(resolved, userhost('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :bob*=+bobuser@bobhost')]),
+    ]);
+  });
+
+  it('omits nicks that are offline (null in the resolved map)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map<string, ConnSnapshot | null>([
+      ['bob', makeSnapshot('bob', 'bobuser', 'bobhost')],
+      ['ghost', null],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob', 'ghost'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :bob=+bobuser@bobhost')]),
+    ]);
+  });
+
+  it('emits an empty trailing when no requested nicks are online', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map<string, ConnSnapshot | null>([['ghost', null]]);
+
+    const out = userhostReducer(resolved, userhost('ghost'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :')]),
+    ]);
+  });
+
+  it('emits an empty trailing when no nicks are requested', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map<string, ConnSnapshot | null>();
+
+    const out = userhostReducer(resolved, userhost(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 302 alice :')]),
+    ]);
+  });
+
+  it('uses * as nick placeholder for unregistered connections', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state);
+    const resolved = new Map([['bob', makeSnapshot('bob', 'bobuser', 'bobhost')]]);
+
+    const out = userhostReducer(resolved, userhost('bob'), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 302 * :bob=+bobuser@bobhost')]),
+    );
+  });
+
+  it('updates lastSeen to ctx.clock.now()', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    userhostReducer(new Map(), userhost('bob'), ctx);
+
+    expect(state.lastSeen).toBe(5_000);
+  });
+
+  it('returns the same state reference', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = userhostReducer(new Map(), userhost(), ctx);
+
+    expect(out.state).toBe(state);
+  });
+
+  it('respects the max-targets cap (caps the number of queried nicks)', () => {
+    const state = makeState();
+    const config: ServerConfig = { ...baseServerConfig, maxTargetsPerCommand: 2 };
+    const ctx = buildCtx({
+      serverConfig: config,
+      clock: new FakeClock(5_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: state,
+    });
+    const resolved = new Map([
+      ['bob', makeSnapshot('bob', 'bu', 'bh')],
+      ['carol', makeSnapshot('carol', 'cu', 'ch')],
+      ['dave', makeSnapshot('dave', 'du', 'dh')],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob', 'carol', 'dave'), ctx);
+
+    const text = (out.effects[0] as { lines: RawLine[] }).lines[0]?.text;
+    // Only the first two nicks should appear; the third is beyond the cap.
+    expect(text).not.toContain('dave');
+    expect(text).toContain('bob');
+    expect(text).toContain('carol');
+  });
+
+  it('skips an empty-string nick in the parameter list', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const resolved = new Map([['bob', makeSnapshot('bob', 'bobuser', 'bobhost')]]);
+
+    const out = userhostReducer(resolved, userhost('', 'bob'), ctx);
+
+    const text = (out.effects[0] as { lines: RawLine[] }).lines[0]?.text;
+    expect(text).toContain('bob=+bobuser@bobhost');
+  });
+
+  it('omits a resolved snapshot that is missing required fields (host absent)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const incomplete = makeSnapshot('bob', 'bobuser', 'bobhost');
+    (incomplete as { host: string | undefined }).host = undefined;
+    const resolved = new Map<string, ConnSnapshot | null>([
+      ['bob', incomplete],
+      ['carol', makeSnapshot('carol', 'caroluser', 'carolhost')],
+    ]);
+
+    const out = userhostReducer(resolved, userhost('bob', 'carol'), ctx);
+
+    const text = (out.effects[0] as { lines: RawLine[] }).lines[0]?.text;
+    expect(text).not.toContain('bob');
+    expect(text).toContain('carol=+caroluser@carolhost');
+  });
+});
+
+describe('formatUserhostReply', () => {
+  it('returns null when the snapshot is missing a nick', () => {
+    const snap = makeSnapshot('bob', 'bu', 'bh');
+    (snap as { nick: string | undefined }).nick = undefined;
+    expect(formatUserhostReply(snap)).toBeNull();
+  });
+
+  it('returns null when the snapshot is missing a user', () => {
+    const snap = makeSnapshot('bob', 'bu', 'bh');
+    (snap as { user: string | undefined }).user = undefined;
+    expect(formatUserhostReply(snap)).toBeNull();
+  });
+
+  it('returns null when the snapshot is missing a host', () => {
+    const snap = makeSnapshot('bob', 'bu', 'bh');
+    (snap as { host: string | undefined }).host = undefined;
+    expect(formatUserhostReply(snap)).toBeNull();
+  });
+});

package/packages/irc-core/tests/commands/who.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest';
+import { operReducer } from '../../src/commands/oper';
 import { whoReducer } from '../../src/commands/who';
 import { Effect } from '../../src/effects';
 import type { Effect as EffectType, RawLine } from '../../src/effects';
@@ -10,6 +11,10 @@ import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
 const serverConfig: ServerConfig = {
   serverName: 'irc.example.com',
   networkName: 'ExampleNet',
+  operCreds: [
+    { user: 'alice', password: 'oppass' },
+    { user: 'bob', password: 'oppass' },
+  ],
   maxChannelsPerUser: 30,
   maxTargetsPerCommand: 10,
   maxListEntries: 50,
@@ -19,6 +24,13 @@ const serverConfig: ServerConfig = {
   quitMessage: 'Client Quit',
 };
 
+/** Grants oper to a connection via the real OPER command flow. */
+function grantOper(conn: ConnectionState): void {
+  const ctx = makeCtx(conn);
+  const user = conn.nick ?? 'oper';
+  operReducer(conn, { command: 'OPER', params: [user, 'oppass'], tags: {} }, ctx);
+}
+
 function makeCtx(conn: ConnectionState, clock = new FakeClock(1_000)): Ctx {
   return buildCtx({
     serverConfig,
@@ -129,9 +141,11 @@ describe('whoReducer — channel target', () => {
     addMember(chan, 'c1', 'alice');
     const conn = makeConn();
     const ctx = makeCtx(conn);
-    const connStates = new Map<string, ConnectionState>([
-      ['c1', makeConnState('c1', 'alice', { oper: true })],
-    ]);
+    const alice = makeConnState('c1', 'alice');
+    // Grant oper via the real OPER command flow, not by poking state.
+    grantOper(alice);
+    expect(alice.userModes.oper).toBe(true);
+    const connStates = new Map<string, ConnectionState>([['c1', alice]]);
 
     const out = whoReducer(chan, connStates, { command: 'WHO', params: ['#foo'] }, ctx);
 
@@ -333,9 +347,13 @@ describe('whoReducer — operators-only filter', () => {
     addMember(chan, 'c2', 'bob');
     const conn = makeConn();
     const ctx = makeCtx(conn);
+    const bob = makeConnState('c2', 'bob');
+    // Grant oper via the real OPER command flow, not by poking state.
+    grantOper(bob);
+    expect(bob.userModes.oper).toBe(true);
     const connStates = new Map<string, ConnectionState>([
       ['c1', makeConnState('c1', 'alice')],
-      ['c2', makeConnState('c2', 'bob', { oper: true })],
+      ['c2', bob],
     ]);
 
     const out = whoReducer(chan, connStates, { command: 'WHO', params: ['#foo', 'o'] }, ctx);

package/packages/irc-core/tests/commands/whois.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest';
+import { operReducer } from '../../src/commands/oper';
 import { whoisReducer } from '../../src/commands/whois';
 import { Effect } from '../../src/effects';
 import type { Effect as EffectType, RawLine } from '../../src/effects';
@@ -10,6 +11,7 @@ import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
 const serverConfig: ServerConfig = {
   serverName: 'irc.example.com',
   networkName: 'ExampleNet',
+  operCreds: [{ user: 'bob', password: 'oppass' }],
   maxChannelsPerUser: 30,
   maxTargetsPerCommand: 10,
   maxListEntries: 50,
@@ -150,13 +152,18 @@ describe('whoisReducer — happy path', () => {
   it('emits 313 RPL_WHOISOPERATOR when the target is an IRC operator', () => {
     const requester = makeConn();
     const ctx = makeCtx(requester);
-    const target = makeTarget('c2', 'bob', { oper: true });
+    // Grant oper via the real OPER command flow rather than poking state directly.
+    const target = makeTarget('c2', 'bob');
+    const targetCtx = makeCtx(target);
+    operReducer(target, { command: 'OPER', params: ['bob', 'oppass'], tags: {} }, targetCtx);
+    expect(target.userModes.oper).toBe(true);
 
     const out = whoisReducer(target, [], { command: 'WHOIS', params: ['bob'] }, ctx);
 
     const send = out.effects[0];
     if (send?.tag === 'Send') {
       expect(send.lines.some((l) => l.text.includes(' 313 '))).toBe(true);
+      expect(send.lines.some((l) => l.text.endsWith(':is an IRC operator'))).toBe(true);
     }
   });
 });

package/packages/irc-core/tests/commands/whowas.test.ts

@@ -0,0 +1,312 @@
+import { describe, expect, it } from 'vitest';
+import { whowasReducer } from '../../src/commands/whowas';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryNickHistoryStore,
+  SequentialIdFactory,
+} from '../../src/ports';
+import { type ConnectionState, createConnection } from '../../src/state/connection';
+import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
+
+const serverConfig: ServerConfig = {
+  serverName: 'irc.example.com',
+  networkName: 'ExampleNet',
+  maxChannelsPerUser: 30,
+  maxTargetsPerCommand: 10,
+  maxListEntries: 50,
+  nickLen: 30,
+  channelLen: 50,
+  topicLen: 390,
+  quitMessage: 'Client Quit',
+};
+
+function makeCtx(conn: ConnectionState, clock = new FakeClock(10_000)): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+function makeConn(id = 'c1', nick = 'alice'): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = nick;
+  s.host = 'example.com';
+  s.realname = 'Alice';
+  s.registration = 'registered';
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+describe('whowasReducer — single nick with history', () => {
+  it('emits 314 RPL_WHOWASUSER then 369 RPL_ENDOFWHOWAS for a recorded nick', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({
+      nick: 'bob',
+      connId: 'c2',
+      username: 'bob',
+      hostname: 'target.example.net',
+      realname: 'Bob',
+      signoffTime: 5_000,
+    });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob'] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 314 alice bob bob target.example.net * :Bob')]),
+      Effect.send('c1', [L(':irc.example.com 369 alice bob :End of WHOWAS')]),
+    ]);
+  });
+
+  it('updates the requester lastSeen to ctx.clock.now()', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(7_700);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({ nick: 'bob', connId: 'c2', signoffTime: 1_000 });
+
+    whowasReducer(history, { command: 'WHOWAS', params: ['bob'] }, ctx);
+
+    expect(requester.lastSeen).toBe(7_700);
+  });
+
+  it('uses ? fallbacks when the entry has no user/host and nick as realname', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({ nick: 'bob', connId: 'c2', signoffTime: 1_000 });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob'] }, ctx);
+
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      expect(send.lines[0]?.text).toBe(':irc.example.com 314 alice bob ? ? * :bob');
+    }
+  });
+});
+
+describe('whowasReducer — no match', () => {
+  it('emits 406 ERR_WASNOSUCHNICK then 369 for an unknown nick', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const history = new InMemoryNickHistoryStore(new FakeClock(10_000));
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['ghost'] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 406 alice ghost :There was no such nickname')]),
+      Effect.send('c1', [L(':irc.example.com 369 alice ghost :End of WHOWAS')]),
+    ]);
+  });
+});
+
+describe('whowasReducer — multiple comma-separated nicks', () => {
+  it('emits a 314+369 (or 406+369) block per queried nick in order', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({
+      nick: 'bob',
+      connId: 'c2',
+      username: 'bob',
+      hostname: 'h',
+      realname: 'Bob',
+      signoffTime: 1_000,
+    });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob,ghost'] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 314 alice bob bob h * :Bob')]),
+      Effect.send('c1', [L(':irc.example.com 369 alice bob :End of WHOWAS')]),
+      Effect.send('c1', [L(':irc.example.com 406 alice ghost :There was no such nickname')]),
+      Effect.send('c1', [L(':irc.example.com 369 alice ghost :End of WHOWAS')]),
+    ]);
+  });
+});
+
+describe('whowasReducer — count cap', () => {
+  it('caps the number of 314 lines at the requested count', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({
+      nick: 'bob',
+      connId: 'c1',
+      username: 'u1',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_000,
+    });
+    clock.advance(100);
+    history.record({
+      nick: 'bob',
+      connId: 'c2',
+      username: 'u2',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_100,
+    });
+    clock.advance(100);
+    history.record({
+      nick: 'bob',
+      connId: 'c3',
+      username: 'u3',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_200,
+    });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob', '1'] }, ctx);
+
+    // Only the most-recent entry (c3) is emitted, then the single 369.
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 314 alice bob u3 h * :R')]),
+      Effect.send('c1', [L(':irc.example.com 369 alice bob :End of WHOWAS')]),
+    ]);
+  });
+
+  it('emits all matches when count exceeds the available history', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({
+      nick: 'bob',
+      connId: 'c1',
+      username: 'u1',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_000,
+    });
+    history.record({
+      nick: 'bob',
+      connId: 'c2',
+      username: 'u2',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_100,
+    });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob', '50'] }, ctx);
+
+    const lines314 = out.effects.filter((e) => {
+      if (e.tag !== 'Send') return false;
+      return e.lines.some((l) => l.text.includes(' 314 '));
+    });
+    expect(lines314).toHaveLength(2);
+  });
+
+  it('treats a non-positive or malformed count as unlimited', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({
+      nick: 'bob',
+      connId: 'c1',
+      username: 'u1',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_000,
+    });
+    history.record({
+      nick: 'bob',
+      connId: 'c2',
+      username: 'u2',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_100,
+    });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob', '0'] }, ctx);
+
+    const count314 = out.effects.filter((e) => {
+      if (e.tag !== 'Send') return false;
+      return e.lines.some((l) => l.text.includes(' 314 '));
+    });
+    expect(count314).toHaveLength(2);
+  });
+});
+
+describe('whowasReducer — no arg / 431', () => {
+  it('emits 431 ERR_NONICKNAMEGIVEN when no nick argument is supplied', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const history = new InMemoryNickHistoryStore(new FakeClock(10_000));
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: [] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 431 alice :No nickname given')]),
+    ]);
+  });
+});
+
+describe('whowasReducer — case-insensitive lookup', () => {
+  it('matches the recorded nick regardless of case', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({
+      nick: 'Bob',
+      connId: 'c2',
+      username: 'bob',
+      hostname: 'h',
+      realname: 'Bob',
+      signoffTime: 1_000,
+    });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['BOB'] }, ctx);
+
+    expect(out.effects[0]?.tag).toBe('Send');
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      expect(send.lines[0]?.text).toContain(' 314 alice Bob ');
+    }
+  });
+});
+
+describe('whowasReducer — no store bound', () => {
+  it('treats undefined history as no matches (406 + 369, no crash)', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+
+    const out = whowasReducer(undefined, { command: 'WHOWAS', params: ['ghost'] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 406 alice ghost :There was no such nickname')]),
+      Effect.send('c1', [L(':irc.example.com 369 alice ghost :End of WHOWAS')]),
+    ]);
+  });
+});
+
+describe('whowasReducer — requester without nick', () => {
+  it('uses * as the requester nick in replies', () => {
+    const requester = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(requester);
+    const history = new InMemoryNickHistoryStore(new FakeClock(10_000));
+    history.record({ nick: 'bob', connId: 'c2', signoffTime: 1_000 });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob'] }, ctx);
+
+    const end = out.effects.at(-1);
+    if (end?.tag === 'Send') {
+      expect(end.lines[0]?.text).toBe(':irc.example.com 369 * bob :End of WHOWAS');
+    }
+  });
+});