serverless-ircd 0.2.0 → 0.3.0

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

@@ -0,0 +1,688 @@
+import { describe, expect, it } from 'vitest';
+import { tagmsgChannelReducer, tagmsgUserReducer } from '../../src/commands/tagmsg';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryMessageStore,
+  type MessageStore,
+  SequentialIdFactory,
+  type StoredMessage,
+} 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),
+  messages?: MessageStore,
+): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+    ...(messages !== undefined ? { messages } : {}),
+  });
+}
+
+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';
+  s.caps.add('message-tags');
+  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 });
+
+// ============================================================================
+// tagmsgChannelReducer — success path
+// ============================================================================
+
+describe('tagmsgChannelReducer — success', () => {
+  it('broadcasts TAGMSG to channel members (excluding sender) with the tag prefix', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast(
+        '#foo',
+        [L('@+typing=active :alice!alice@example.com TAGMSG #foo')],
+        'c1',
+        'message-tags',
+      ),
+    ]);
+  });
+
+  it('broadcasts without an @ prefix when no tags are present', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [L(':alice!alice@example.com TAGMSG #foo')], 'c1', 'message-tags'),
+    ]);
+  });
+
+  it('serializes multiple tags correctly', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active', 'vendor/foo': 'bar' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast(
+        '#foo',
+        [L('@+typing=active;vendor/foo=bar :alice!alice@example.com TAGMSG #foo')],
+        'c1',
+        'message-tags',
+      ),
+    ]);
+  });
+
+  it('serializes a valueless tag as a bare key (no =suffix)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+ack': '' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast(
+        '#foo',
+        [L('@+ack :alice!alice@example.com TAGMSG #foo')],
+        'c1',
+        'message-tags',
+      ),
+    ]);
+  });
+
+  it('updates the connection lastSeen to ctx.clock.now()', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const clock = new FakeClock(8_800);
+    const ctx = makeCtx(conn, clock);
+
+    tagmsgChannelReducer(chan, { command: 'TAGMSG', params: ['#foo'], tags: {} }, ctx);
+
+    expect(conn.lastSeen).toBe(8_800);
+  });
+
+  it('returns the same state reference (no mutation to channel state)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.state).toBe(chan);
+  });
+});
+
+// ============================================================================
+// tagmsgChannelReducer — cap gate
+// ============================================================================
+
+describe('tagmsgChannelReducer — cap gate', () => {
+  it('emits 421 ERR_UNKNOWNCOMMAND when message-tags cap is not negotiated', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.caps.delete('message-tags');
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 421 alice TAGMSG :Unknown command')]),
+    ]);
+  });
+
+  it('uses * as the nick in 421 when the connection has no nick', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c2', 'bob');
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 421 * TAGMSG :Unknown command')]),
+    ]);
+  });
+});
+
+// ============================================================================
+// tagmsgChannelReducer — NOTICE-style silent rejections
+// ============================================================================
+
+describe('tagmsgChannelReducer — silent rejections', () => {
+  it('MUST NOT produce any numeric reply when target is missing', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: [], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('MUST NOT produce any numeric reply when rejected by +n (no external)', () => {
+    const chan = makeChan('#foo');
+    chan.modes.noExternal = true;
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('MUST NOT produce any numeric reply when rejected by +m (moderated)', () => {
+    const chan = makeChan('#foo');
+    chan.modes.moderated = true;
+    addMember(chan, 'c1', 'alice', false, false);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('MUST NOT produce any numeric reply when +m rejects a non-member (no +n)', () => {
+    const chan = makeChan('#foo');
+    chan.modes.moderated = true;
+    addMember(chan, 'c2', 'bob', true, false);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('still broadcasts when the sender is an op of a +m channel', () => {
+    const chan = makeChan('#foo');
+    chan.modes.moderated = true;
+    addMember(chan, 'c1', 'alice', true, false);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('Broadcast');
+  });
+
+  it('still broadcasts when the sender is voiced on a +m channel', () => {
+    const chan = makeChan('#foo');
+    chan.modes.moderated = true;
+    addMember(chan, 'c1', 'alice', false, true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('Broadcast');
+  });
+
+  it('MUST NOT produce any numeric reply when banned (+b)', () => {
+    const chan = makeChan('#foo');
+    chan.banMasks.add('*!*@example.com');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('honors the ? wildcard in ban masks', () => {
+    const chan = makeChan('#foo');
+    chan.banMasks.add('alice!?????@example.com');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('proceeds with the broadcast when the ban list is non-empty but no mask matches', () => {
+    const chan = makeChan('#foo');
+    chan.banMasks.add('*!*@baddomain.example');
+    chan.banMasks.add('evil!*@*');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('Broadcast');
+  });
+});
+
+// ============================================================================
+// tagmsgChannelReducer — echo-message
+// ============================================================================
+
+describe('tagmsgChannelReducer — echo-message', () => {
+  it('echoes the TAGMSG back to the sender when echo-message cap is present', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.caps.add('echo-message');
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    const line = L('@+typing=active :alice!alice@example.com TAGMSG #foo');
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [line], 'c1', 'message-tags'),
+      Effect.send('c1', [line]),
+    ]);
+  });
+
+  it('does NOT echo when echo-message cap is absent', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('Broadcast');
+  });
+});
+
+// ============================================================================
+// tagmsgChannelReducer — chathistory recording
+// ============================================================================
+
+describe('tagmsgChannelReducer — chathistory recording', () => {
+  it('records the TAGMSG into ctx.messages with a fresh msgid and time', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const clock = new FakeClock(7_700);
+    const ctx = makeCtx(conn, clock, store);
+
+    tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    const recorded = store.query({ chan: '#foo', direction: 'latest', limit: 10 });
+    expect(recorded).toHaveLength(1);
+    const entry = recorded[0] as StoredMessage | undefined;
+    expect(entry).toBeDefined();
+    expect(entry?.msgid).toBe('nonce-0');
+    expect(entry?.time).toBe(7_700);
+    expect(entry?.chan).toBe('#foo');
+    expect(entry?.command).toBe('TAGMSG');
+    expect(entry?.nick).toBe('alice');
+    expect(entry?.user).toBe('alice');
+    expect(entry?.host).toBe('example.com');
+    expect(entry?.text).toBe('');
+  });
+
+  it('does NOT crash when no MessageStore is bound', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects[0]?.tag).toBe('Broadcast');
+  });
+
+  it('does NOT record when rejected by +n', () => {
+    const chan = makeChan('#foo');
+    chan.modes.noExternal = true;
+    const store = new InMemoryMessageStore();
+    const ctx = makeCtx(makeConn(), new FakeClock(1_000), store);
+
+    tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(store.query({ chan: '#foo', direction: 'latest', limit: 10 })).toEqual([]);
+  });
+
+  it('does NOT record when rejected by +b', () => {
+    const chan = makeChan('#foo');
+    chan.banMasks.add('*!*@example.com');
+    addMember(chan, 'c1', 'alice');
+    const store = new InMemoryMessageStore();
+    const ctx = makeCtx(makeConn(), new FakeClock(1_000), store);
+
+    tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(store.query({ chan: '#foo', direction: 'latest', limit: 10 })).toEqual([]);
+  });
+});
+
+// ============================================================================
+// tagmsgChannelReducer — defensive hostmask fallbacks
+// ============================================================================
+
+describe('tagmsgChannelReducer — defensive hostmask', () => {
+  it('falls back to the bare nick when user/host are absent', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c2', 'bob');
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.nick = 'alice';
+    conn.realname = 'Alice';
+    conn.registration = 'registered';
+    conn.caps.add('message-tags');
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: {} },
+      ctx,
+    );
+
+    const broadcast = out.effects[0];
+    expect(broadcast?.tag).toBe('Broadcast');
+    const lines = (broadcast as { lines: RawLine[] } | undefined)?.lines;
+    expect(lines?.[0]?.text).toBe(':alice TAGMSG #foo');
+  });
+
+  it('falls back to ? when the connection has no nick at all', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c2', 'bob');
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.caps.add('message-tags');
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: {} },
+      ctx,
+    );
+
+    const broadcast = out.effects[0];
+    expect(broadcast?.tag).toBe('Broadcast');
+    const lines = (broadcast as { lines: RawLine[] } | undefined)?.lines;
+    expect(lines?.[0]?.text).toBe(':? TAGMSG #foo');
+  });
+});
+
+// ============================================================================
+// tagmsgUserReducer
+// ============================================================================
+
+describe('tagmsgUserReducer', () => {
+  it('routes a private TAGMSG via SendToNick', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgUserReducer(
+      conn,
+      { command: 'TAGMSG', params: ['bob'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.sendToNick(
+        'bob',
+        'c1',
+        [L('@+typing=active :alice!alice@example.com TAGMSG bob')],
+      ),
+    ]);
+  });
+
+  it('has no notFoundLines for an offline target (silent like NOTICE)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgUserReducer(
+      conn,
+      { command: 'TAGMSG', params: ['nobody'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.sendToNick(
+        'nobody',
+        'c1',
+        [L('@+typing=active :alice!alice@example.com TAGMSG nobody')],
+      ),
+    ]);
+  });
+
+  it('emits 421 ERR_UNKNOWNCOMMAND when message-tags cap is not negotiated', () => {
+    const conn = makeConn();
+    conn.caps.delete('message-tags');
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgUserReducer(
+      conn,
+      { command: 'TAGMSG', params: ['bob'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 421 alice TAGMSG :Unknown command')]),
+    ]);
+  });
+
+  it('MUST NOT produce any numeric reply when target is missing', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgUserReducer(
+      conn,
+      { command: 'TAGMSG', params: [], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('echoes back to the sender when echo-message cap is present', () => {
+    const conn = makeConn();
+    conn.caps.add('echo-message');
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgUserReducer(
+      conn,
+      { command: 'TAGMSG', params: ['bob'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    const line = L('@+typing=active :alice!alice@example.com TAGMSG bob');
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.sendToNick('bob', 'c1', [line]),
+      Effect.send('c1', [line]),
+    ]);
+  });
+
+  it('works without tags (no @ prefix)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgUserReducer(
+      conn,
+      { command: 'TAGMSG', params: ['bob'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.sendToNick('bob', 'c1', [L(':alice!alice@example.com TAGMSG bob')]),
+    ]);
+  });
+
+  it('updates lastSeen to ctx.clock.now()', () => {
+    const conn = makeConn();
+    const clock = new FakeClock(12_000);
+    const ctx = makeCtx(conn, clock);
+
+    tagmsgUserReducer(conn, { command: 'TAGMSG', params: ['bob'], tags: {} }, ctx);
+
+    expect(conn.lastSeen).toBe(12_000);
+  });
+
+  it('returns the same state reference', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgUserReducer(
+      conn,
+      { command: 'TAGMSG', params: ['bob'], tags: {} },
+      ctx,
+    );
+
+    expect(out.state).toBe(conn);
+  });
+
+  it('does NOT record a user-target TAGMSG', () => {
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const ctx = makeCtx(conn, new FakeClock(1_000), store);
+
+    tagmsgUserReducer(conn, { command: 'TAGMSG', params: ['bob'], tags: {} }, ctx);
+
+    expect(store.targets(0, 100_000)).toEqual([]);
+  });
+});