serverless-ircd 0.1.0

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

@@ -0,0 +1,322 @@
+import { describe, expect, it } from 'vitest';
+import { motdReducer } from '../../src/commands/motd';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, type MotdProvider, StaticMotdProvider } from '../../src/ports';
+import { FakeClock, 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(
+  state: ConnectionState,
+  motd: MotdProvider = new StaticMotdProvider([]),
+  clock = new FakeClock(1_000),
+): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    connection: state,
+    motd,
+  });
+}
+
+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;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+// ============================================================================
+// motdReducer — success path
+// ============================================================================
+
+describe('motdReducer — success', () => {
+  it('emits 375, one 372 per MOTD line, then 376 for a 3-line MOTD', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, new StaticMotdProvider(['line one', 'line two', 'line three']));
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(':irc.example.com 375 alice :- irc.example.com Message of the day -'),
+        L(':irc.example.com 372 alice :- line one'),
+        L(':irc.example.com 372 alice :- line two'),
+        L(':irc.example.com 372 alice :- line three'),
+        L(':irc.example.com 376 alice :End of MOTD command'),
+      ]),
+    ]);
+  });
+
+  it('emits exactly one 372 for a single-line MOTD', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, new StaticMotdProvider(['only line']));
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+
+    const send = out.effects[0];
+    expect(send).toBeDefined();
+    expect(send?.tag).toBe('Send');
+    if (send?.tag === 'Send') {
+      const codes = send.lines.map((l) => l.text.split(' ')[1]);
+      expect(codes).toEqual(['375', '372', '376']);
+    }
+  });
+
+  it('produces exactly one Send effect to the requesting connection', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, new StaticMotdProvider(['a', 'b']));
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('Send');
+    if (out.effects[0]?.tag === 'Send') {
+      expect(out.effects[0].to).toBe('c1');
+    }
+  });
+
+  it('reads MOTD lines fresh from the provider on each invocation', () => {
+    const state = makeState();
+    const provider = new StaticMotdProvider(['first']);
+    const ctx = makeCtx(state, provider);
+    const out1 = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+    provider.setLines(['first', 'second']);
+    const out2 = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+
+    const count372 = (e: EffectType | undefined): number => {
+      if (e?.tag !== 'Send') return 0;
+      return e.lines.filter((l) => l.text.split(' ')[1] === '372').length;
+    };
+    expect(count372(out1.effects[0])).toBe(1);
+    expect(count372(out2.effects[0])).toBe(2);
+  });
+});
+
+// ============================================================================
+// motdReducer — empty MOTD → 422
+// ============================================================================
+
+describe('motdReducer — empty MOTD', () => {
+  it('emits a single 422 ERR_NOMOTD when the provider has no lines', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, new StaticMotdProvider([]));
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 422 alice :MOTD File is missing')]),
+    ]);
+  });
+
+  it('emits 422 when using the EmptyMotdProvider constant', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, EmptyMotdProvider);
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 422 alice :MOTD File is missing')]),
+    ]);
+  });
+});
+
+// ============================================================================
+// motdReducer — unregistered connection
+// ============================================================================
+
+describe('motdReducer — unregistered', () => {
+  it('addresses the reply to * when the connection has no nick', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state, new StaticMotdProvider(['hi']));
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(':irc.example.com 375 * :- irc.example.com Message of the day -'),
+        L(':irc.example.com 372 * :- hi'),
+        L(':irc.example.com 376 * :End of MOTD command'),
+      ]),
+    ]);
+  });
+});
+
+// ============================================================================
+// motdReducer — long-line splitting (512-byte limit incl. tags / CR-LF)
+// ============================================================================
+
+describe('motdReducer — line splitting', () => {
+  /**
+   * Per RFC 1459 §2.3 the maximum IRC line length is 512 bytes including the
+   * trailing CR-LF. The 372 wire format is:
+   *
+   *   ":<server> 372 <nick> :- <chunk>\r\n"
+   *
+   * The reducer must split over-long MOTD content lines so every emitted 372
+   * fits within the 512-byte budget.
+   */
+  it('splits a content line longer than the 372 budget into multiple 372 replies', () => {
+    const state = makeState();
+    // Overhead = ":" + "irc.example.com" + " 372 " + "alice" + " :- " + "\r\n"
+    //         = 1 + 15 + 5 + 5 + 4 + 2 = 32 bytes.
+    // So the per-372 content budget is 512 - 32 = 480 chars.
+    // 500 chars of content → 2 chunks (480 + 20).
+    const long = 'A'.repeat(500);
+    const ctx = makeCtx(state, new StaticMotdProvider([long]));
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+
+    const send = out.effects[0];
+    expect(send?.tag).toBe('Send');
+    if (send?.tag === 'Send') {
+      const rpl372 = send.lines.filter((l) => l.text.split(' ')[1] === '372');
+      expect(rpl372).toHaveLength(2);
+      // First chunk: 480 chars of A.
+      expect(rpl372[0]?.text).toBe(`:irc.example.com 372 alice :- ${'A'.repeat(480)}`);
+      // Second chunk: remaining 20 chars.
+      expect(rpl372[1]?.text).toBe(`:irc.example.com 372 alice :- ${'A'.repeat(20)}`);
+    }
+  });
+
+  it('never emits a wire line longer than 510 chars (512 minus CR-LF)', () => {
+    const state = makeState();
+    const long = 'Z'.repeat(2_000);
+    const ctx = makeCtx(state, new StaticMotdProvider([long]));
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      for (const line of send.lines) {
+        expect(line.text.length).toBeLessThanOrEqual(510);
+      }
+    }
+  });
+
+  it('still emits the 375 and 376 framing lines around split 372 chunks', () => {
+    const state = makeState();
+    const long = 'B'.repeat(1_000);
+    const ctx = makeCtx(state, new StaticMotdProvider([long]));
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+
+    const send = out.effects[0];
+    expect(send?.tag).toBe('Send');
+    if (send?.tag === 'Send') {
+      const codes = send.lines.map((l) => l.text.split(' ')[1]);
+      expect(codes[0]).toBe('375');
+      expect(codes[codes.length - 1]).toBe('376');
+      // Every middle code is a 372.
+      for (let i = 1; i < codes.length - 1; i++) {
+        expect(codes[i]).toBe('372');
+      }
+    }
+  });
+
+  it('emits a single empty 372 chunk for an empty MOTD line', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, new StaticMotdProvider(['']));
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      // Still exactly one 372 line for the empty input line.
+      const rpl372 = send.lines.filter((l) => l.text.split(' ')[1] === '372');
+      expect(rpl372).toHaveLength(1);
+      expect(rpl372[0]?.text).toBe(':irc.example.com 372 alice :- ');
+    }
+  });
+
+  it('still emits one 372 per line when server+nick exhaust the 372 budget', () => {
+    // Drive `maxMotdContentLen` to <= 0 by giving the connection a nick so long
+    // that the 372 line prefix exceeds 510 bytes. splitForMotd then returns
+    // [''] per input line — the reducer still emits one 372 per MOTD line,
+    // never silently dropping content.
+    const state = makeState();
+    state.nick = 'a'.repeat(600);
+    const ctx = makeCtx(state, new StaticMotdProvider(['hello']));
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      const rpl372 = send.lines.filter((l) => l.text.split(' ')[1] === '372');
+      expect(rpl372).toHaveLength(1);
+      // Content is empty (the whole input got dropped because it cannot fit
+      // at all) — but the empty-chunk path was still taken.
+      expect(rpl372[0]?.text.endsWith(':- ')).toBe(true);
+    }
+  });
+});
+
+// ============================================================================
+// motdReducer — state side-effects
+// ============================================================================
+
+describe('motdReducer — state', () => {
+  it('updates connection lastSeen to ctx.clock.now()', () => {
+    const state = makeState();
+    expect(state.lastSeen).toBe(0);
+    const clock = new FakeClock(7_777);
+    const ctx = makeCtx(state, new StaticMotdProvider(['hi']), clock);
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+    expect(out.state.lastSeen).toBe(7_777);
+  });
+
+  it('does not mutate any connection field other than lastSeen', () => {
+    const state = makeState();
+    state.caps.add('server-time');
+    state.joinedChannels.add('#foo');
+    state.userModes.invisible = true;
+
+    const ctx = makeCtx(state, new StaticMotdProvider(['hi']));
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+
+    expect(out.state.id).toBe('c1');
+    expect(out.state.nick).toBe('alice');
+    expect(out.state.user).toBe('alice');
+    expect(out.state.host).toBe('example.com');
+    expect(out.state.realname).toBe('Alice');
+    expect(out.state.caps).toEqual(new Set(['server-time']));
+    expect(out.state.joinedChannels).toEqual(new Set(['#foo']));
+    expect(out.state.userModes.invisible).toBe(true);
+    expect(out.state.registration).toBe('registered');
+    expect(out.state.connectedSince).toBe(0);
+  });
+
+  it('returns the same state reference (mutation permitted, no copy)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, new StaticMotdProvider(['hi']));
+    const out = motdReducer(state, { command: 'MOTD', params: [], tags: {} }, ctx);
+    expect(out.state).toBe(state);
+  });
+});
+
+// ============================================================================
+// motdReducer — case-insensitivity
+// ============================================================================
+
+describe('motdReducer — case-insensitivity', () => {
+  it('accepts a lower-case command token', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, new StaticMotdProvider(['hi']));
+    const out = motdReducer(state, { command: 'motd', params: [], tags: {} }, ctx);
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('Send');
+  });
+
+  it('accepts a mixed-case command token', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, new StaticMotdProvider(['hi']));
+    const out = motdReducer(state, { command: 'MoTd', params: [], tags: {} }, ctx);
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('Send');
+  });
+});

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

@@ -0,0 +1,342 @@
+import { describe, expect, it } from 'vitest';
+import { namesReducer } from '../../src/commands/names';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import { type ChannelState, createChannel } from '../../src/state/channel';
+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(1_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 = nick.charAt(0).toUpperCase() + nick.slice(1);
+  s.registration = 'registered';
+  return s;
+}
+
+function makeChan(name = '#foo'): ChannelState {
+  return createChannel({ name, nameLower: name.toLowerCase(), createdAt: 0 });
+}
+
+function addMember(
+  chan: ChannelState,
+  connId: string,
+  nick: string,
+  op = false,
+  voice = false,
+): void {
+  chan.members.set(connId, { conn: connId, nick, op, voice });
+}
+
+const L = (text: string): RawLine => ({ text });
+
+// ============================================================================
+// namesReducer — success
+// ============================================================================
+
+describe('namesReducer — success', () => {
+  it('emits 353 RPL_NAMREPLY with the member list and 366 RPL_ENDOFNAMES', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(':irc.example.com 353 alice = #foo :@alice bob'),
+        L(':irc.example.com 366 alice #foo :End of /NAMES list.'),
+      ]),
+    ]);
+  });
+
+  it('emits a 353 with an empty names list when the channel has no members', () => {
+    const chan = makeChan('#foo');
+    // alice is a member so the visibility check passes, but no other members.
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(':irc.example.com 353 alice = #foo :alice'),
+        L(':irc.example.com 366 alice #foo :End of /NAMES list.'),
+      ]),
+    ]);
+  });
+
+  it('uses * sigil in 353 when the channel is +s (secret)', () => {
+    const chan = makeChan('#foo');
+    chan.modes.secret = true;
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#foo'], tags: {} }, ctx);
+
+    const send = out.effects[0];
+    expect(send?.tag).toBe('Send');
+    if (send?.tag === 'Send') {
+      expect(send.lines[0]?.text).toBe(':irc.example.com 353 alice * #foo :alice');
+    }
+  });
+
+  it('uses @ sigil in 353 when the channel is +p (private)', () => {
+    const chan = makeChan('#foo');
+    chan.modes.private = true;
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#foo'], tags: {} }, ctx);
+
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      expect(send.lines[0]?.text).toBe(':irc.example.com 353 alice @ #foo :alice');
+    }
+  });
+
+  it('shows only the highest-priority prefix when multi-prefix is not negotiated', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    addMember(chan, 'c2', 'bob', true, true); // op AND voice
+    addMember(chan, 'c3', 'carol', false, true); // voiced but NOT op
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+    // No multi-prefix cap.
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#foo'], tags: {} }, ctx);
+
+    const send = out.effects[0];
+    expect(send?.tag).toBe('Send');
+    if (send?.tag === 'Send') {
+      // bob has both @ and + but only @ is shown without multi-prefix.
+      // carol has only +; that is shown as her highest prefix.
+      // Order matches roster iteration (insertion order); assert substrings.
+      const namesLine = send.lines[0]?.text ?? '';
+      expect(namesLine).toContain('@bob');
+      expect(namesLine).not.toContain('+bob');
+      expect(namesLine).toContain('+carol');
+      expect(namesLine).toContain('alice');
+    }
+  });
+
+  it('shows all applicable prefixes when multi-prefix is negotiated', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    addMember(chan, 'c2', 'bob', true, true); // op AND voice
+    const conn = makeConn();
+    conn.caps.add('multi-prefix');
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#foo'], tags: {} }, ctx);
+
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      // bob has both @ and +; both shown with multi-prefix.
+      const namesLine = send.lines[0]?.text ?? '';
+      expect(namesLine).toContain('@+bob');
+      expect(namesLine).toContain('alice');
+    }
+  });
+
+  it('updates the connection lastSeen to ctx.clock.now()', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const clock = new FakeClock(4_200);
+    const ctx = makeCtx(conn, clock);
+
+    namesReducer(chan, { command: 'NAMES', params: ['#foo'], tags: {} }, ctx);
+
+    expect(conn.lastSeen).toBe(4_200);
+  });
+
+  it('returns the same state reference (read-only reducer)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.state).toBe(chan);
+  });
+});
+
+// ============================================================================
+// namesReducer — rejections
+// ============================================================================
+
+describe('namesReducer — rejections', () => {
+  it('emits 461 ERR_NEEDMOREPARAMS only when no channel is supplied AND the reducer is invoked directly', () => {
+    // The reducer is invoked per-channel by the actor layer; if it is invoked
+    // with no params at all that is a programming error in the actor layer,
+    // but we still emit 461 for safety.
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice NAMES :Not enough parameters')]),
+    ]);
+  });
+
+  it('emits 403 ERR_NOSUCHCHANNEL for a channel name without a valid prefix', () => {
+    const chan = makeChan('foo');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 403 alice foo :No such channel')]),
+    ]);
+  });
+
+  it('emits 403 ERR_NOSUCHCHANNEL for a channel name containing a comma', () => {
+    const chan = makeChan('#foo');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#foo,bar'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 403 alice #foo,bar :No such channel')]),
+    ]);
+  });
+
+  it('emits 403 ERR_NOSUCHCHANNEL for an empty channel name', () => {
+    const chan = makeChan('#foo');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: [''], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 403 alice  :No such channel')]),
+    ]);
+  });
+
+  it('emits 442 ERR_NOTONCHANNEL when listing a +s channel the connection has not joined', () => {
+    const chan = makeChan('#secret');
+    chan.modes.secret = true;
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#secret'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(":irc.example.com 442 alice #secret :You're not on that channel")]),
+    ]);
+  });
+
+  it('emits 442 ERR_NOTONCHANNEL when listing a +p channel the connection has not joined', () => {
+    const chan = makeChan('#priv');
+    chan.modes.private = true;
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#priv'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(":irc.example.com 442 alice #priv :You're not on that channel")]),
+    ]);
+  });
+
+  it('allows a member to list a +s channel', () => {
+    const chan = makeChan('#secret');
+    chan.modes.secret = true;
+    addMember(chan, 'c1', 'alice');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#secret'], tags: {} }, ctx);
+
+    const send = out.effects[0];
+    expect(send?.tag).toBe('Send');
+    if (send?.tag === 'Send') {
+      expect(send.lines[0]?.text).toBe(':irc.example.com 353 alice * #secret :alice bob');
+    }
+  });
+
+  it('allows a non-member to list a regular (non-+s, non-+p) channel', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#foo'], tags: {} }, ctx);
+
+    const send = out.effects[0];
+    expect(send?.tag).toBe('Send');
+    if (send?.tag === 'Send') {
+      expect(send.lines[0]?.text).toBe(':irc.example.com 353 alice = #foo :bob');
+    }
+  });
+
+  it('uses * in numeric replies when the connection has no nick (defensive)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(':irc.example.com 353 * = #foo :alice'),
+        L(':irc.example.com 366 * #foo :End of /NAMES list.'),
+      ]),
+    ]);
+  });
+
+  it('uses * in error numeric replies when the connection has no nick (defensive)', () => {
+    const chan = makeChan('#secret');
+    chan.modes.secret = true;
+    addMember(chan, 'c2', 'bob');
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#secret'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(":irc.example.com 442 * #secret :You're not on that channel")]),
+    ]);
+  });
+});