serverless-ircd 0.1.0 → 0.2.0

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

@@ -2,7 +2,14 @@ import { describe, expect, it } from 'vitest';
 import { handleJoinZero, isValidChannelName, joinReducer } from '../../src/commands/join';
 import { Effect } from '../../src/effects';
 import type { Effect as EffectType, RawLine } from '../../src/effects';
-import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+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';
@@ -19,13 +26,18 @@ const serverConfig: ServerConfig = {
   quitMessage: 'Client Quit',
 };
 
-function makeCtx(conn: ConnectionState, clock = new FakeClock(1_000)): Ctx {
+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 } : {}),
   });
 }
 
@@ -685,3 +697,235 @@ describe('joinReducer — extended-join', () => {
     expect(broadcast?.capLines).toBeUndefined();
   });
 });
+
+// ============================================================================
+// joinReducer — chathistory auto-playback
+// ============================================================================
+
+/** Connection negotiated draft/chathistory (+ the deps it implies). */
+function makeCapConn(id = 'c1', nick = 'alice'): ConnectionState {
+  const conn = makeConn(id, nick);
+  conn.caps.add('draft/chathistory');
+  conn.caps.add('batch');
+  conn.caps.add('server-time');
+  conn.caps.add('message-tags');
+  return conn;
+}
+
+/** Records N messages into the store as if spoken by `bob`. */
+function seedHistory(store: MessageStore, chan: string, count: number): StoredMessage[] {
+  const out: StoredMessage[] = [];
+  for (let i = 1; i <= count; i++) {
+    const m: StoredMessage = {
+      msgid: `m${i}`,
+      time: i * 1_000,
+      chan: chan.toLowerCase(),
+      command: 'PRIVMSG',
+      nick: 'bob',
+      user: 'bob',
+      host: 'ex.org',
+      text: `msg ${i}`,
+    };
+    store.record(m);
+    out.push(m);
+  }
+  return out;
+}
+
+describe('joinReducer — chathistory auto-playback', () => {
+  it('prepends a chathistory BATCH before the JOIN/353/366 lines for a cap-enabled joiner', () => {
+    const chan = makeChan('#foo');
+    const store = new InMemoryMessageStore();
+    const seeded = seedHistory(store, '#foo', 2);
+    const conn = makeCapConn();
+    const ctx = makeCtx(conn, new FakeClock(10_000), store);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    // The first client-visible line must be the BATCH +start marker.
+    const firstSend = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Send' }> => e.tag === 'Send',
+    );
+    const firstLine = firstSend?.lines[0]?.text;
+    expect(firstLine).toBe('BATCH +batch-0 chathistory #foo');
+
+    // The chathistory batch body carries the two replayed messages.
+    expect(firstSend?.lines.map((l) => l.text)).toEqual([
+      'BATCH +batch-0 chathistory #foo',
+      `@time=1970-01-01T00:00:01.000Z;msgid=${seeded[0]?.msgid} :bob!bob@ex.org PRIVMSG #foo :msg 1`,
+      `@time=1970-01-01T00:00:02.000Z;msgid=${seeded[1]?.msgid} :bob!bob@ex.org PRIVMSG #foo :msg 2`,
+      'BATCH -batch-0',
+    ]);
+
+    // The JOIN broadcast and NAMES follow the playback Send.
+    const tags = out.effects.map((e) => e.tag);
+    const sendIdx = tags.indexOf('Send');
+    const broadcastIdx = tags.indexOf('Broadcast');
+    expect(sendIdx).toBeLessThan(broadcastIdx);
+    expect(broadcastIdx).toBeGreaterThan(-1);
+  });
+
+  it('advances the last-read marker to the newest replayed msgid', () => {
+    const chan = makeChan('#foo');
+    const store = new InMemoryMessageStore();
+    seedHistory(store, '#foo', 3);
+    const conn = makeCapConn();
+    const ctx = makeCtx(conn, new FakeClock(10_000), store);
+
+    joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m3');
+  });
+
+  it('does NOT emit playback when the store is empty', () => {
+    const chan = makeChan('#foo');
+    const store = new InMemoryMessageStore();
+    const conn = makeCapConn();
+    const ctx = makeCtx(conn, new FakeClock(10_000), store);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    // No Send carrying a BATCH chathistory start line.
+    const hasPlayback = out.effects.some(
+      (e) =>
+        e.tag === 'Send' &&
+        e.lines.some((l) => l.text.startsWith('BATCH +') && l.text.includes('chathistory')),
+    );
+    expect(hasPlayback).toBe(false);
+  });
+
+  it('does NOT emit playback when the connection lacks the chathistory cap', () => {
+    const chan = makeChan('#foo');
+    const store = new InMemoryMessageStore();
+    seedHistory(store, '#foo', 3);
+    const conn = makeConn(); // no chathistory cap
+    conn.caps.add('batch');
+    const ctx = makeCtx(conn, new FakeClock(10_000), store);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const hasPlayback = out.effects.some(
+      (e) =>
+        e.tag === 'Send' &&
+        e.lines.some((l) => l.text.startsWith('BATCH +') && l.text.includes('chathistory')),
+    );
+    expect(hasPlayback).toBe(false);
+  });
+
+  it('does NOT emit playback when no MessageStore is bound', () => {
+    const chan = makeChan('#foo');
+    const conn = makeCapConn();
+    const ctx = makeCtx(conn); // no store
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const hasPlayback = out.effects.some(
+      (e) =>
+        e.tag === 'Send' &&
+        e.lines.some((l) => l.text.startsWith('BATCH +') && l.text.includes('chathistory')),
+    );
+    expect(hasPlayback).toBe(false);
+  });
+
+  it('replays nothing on re-JOIN when no new messages arrived (marker unchanged)', () => {
+    const chan = makeChan('#foo');
+    const store = new InMemoryMessageStore();
+    seedHistory(store, '#foo', 2);
+    const conn = makeCapConn();
+    const ctx = makeCtx(conn, new FakeClock(10_000), store);
+
+    // First join: replays both, marker → m2.
+    joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m2');
+
+    // Simulate PART (roster + joinedChannels cleared; marker persists).
+    chan.members.delete('c1');
+    conn.joinedChannels.delete('#foo');
+
+    // Re-JOIN with no new messages: marker still m2 → nothing newer.
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+    const hasPlayback = out.effects.some(
+      (e) =>
+        e.tag === 'Send' &&
+        e.lines.some((l) => l.text.startsWith('BATCH +') && l.text.includes('chathistory')),
+    );
+    expect(hasPlayback).toBe(false);
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m2');
+  });
+
+  it('replays exactly the K new messages on re-JOIN after K new messages', () => {
+    const chan = makeChan('#foo');
+    const store = new InMemoryMessageStore();
+    seedHistory(store, '#foo', 2);
+    const conn = makeCapConn();
+    const ctx = makeCtx(conn, new FakeClock(10_000), store);
+
+    joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m2');
+
+    // PART.
+    chan.members.delete('c1');
+    conn.joinedChannels.delete('#foo');
+
+    // Two new messages arrive.
+    store.record({
+      msgid: 'm3',
+      time: 3_000,
+      chan: '#foo',
+      command: 'PRIVMSG',
+      nick: 'bob',
+      user: 'bob',
+      host: 'ex.org',
+      text: 'msg 3',
+    });
+    store.record({
+      msgid: 'm4',
+      time: 4_000,
+      chan: '#foo',
+      command: 'PRIVMSG',
+      nick: 'bob',
+      user: 'bob',
+      host: 'ex.org',
+      text: 'msg 4',
+    });
+
+    // Re-JOIN: replay exactly m3, m4 (the K=2 new), then advance marker to m4.
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+    const send = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Send' }> =>
+        e.tag === 'Send' && e.lines.some((l) => l.text.includes('chathistory')),
+    );
+    const msgids = send?.lines
+      .filter((l) => l.text.startsWith('@time='))
+      .map((l) => l.text.match(/msgid=([^ ;]+)/)?.[1]);
+    expect(msgids).toEqual(['m3', 'm4']);
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m4');
+  });
+
+  it('respects chatHistoryPlaybackLimit from ServerConfig', () => {
+    const chan = makeChan('#foo');
+    const store = new InMemoryMessageStore();
+    seedHistory(store, '#foo', 5);
+    const conn = makeCapConn();
+    const ctx = buildCtx({
+      serverConfig: { ...serverConfig, chatHistoryPlaybackLimit: 2 },
+      clock: new FakeClock(10_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      messages: store,
+      connection: conn,
+    });
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+    const send = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Send' }> =>
+        e.tag === 'Send' && e.lines.some((l) => l.text.includes('chathistory')),
+    );
+    const msgids = send?.lines
+      .filter((l) => l.text.startsWith('@time='))
+      .map((l) => l.text.match(/msgid=([^ ;]+)/)?.[1]);
+    // Only the most recent 2 (m4, m5) and marker advances to m5.
+    expect(msgids).toEqual(['m4', 'm5']);
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m5');
+  });
+});

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

@@ -8,7 +8,14 @@ import {
 } from '../../src/commands/privmsg';
 import { Effect } from '../../src/effects';
 import type { Effect as EffectType, RawLine } from '../../src/effects';
-import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+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';
@@ -25,13 +32,18 @@ const serverConfig: ServerConfig = {
   quitMessage: 'Client Quit',
 };
 
-function makeCtx(conn: ConnectionState, clock = new FakeClock(1_000)): Ctx {
+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 } : {}),
   });
 }
 
@@ -663,3 +675,135 @@ describe('noticeUserReducer', () => {
     expect(out.effects).toEqual([]);
   });
 });
+
+// ============================================================================
+// chathistory recording — MessageStore.record is driven from the channel
+// PRIVMSG/NOTICE reducer for every accepted message.
+// ============================================================================
+
+describe('privmsgChannelReducer — chathistory recording', () => {
+  it('records the accepted PRIVMSG 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);
+
+    privmsgChannelReducer(chan, { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} }, 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('PRIVMSG');
+    expect(entry?.nick).toBe('alice');
+    expect(entry?.user).toBe('alice');
+    expect(entry?.host).toBe('example.com');
+    expect(entry?.text).toBe('hi');
+  });
+
+  it('records an accepted channel NOTICE too', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const store = new InMemoryMessageStore();
+    const ctx = makeCtx(makeConn(), new FakeClock(1_000), store);
+
+    noticeChannelReducer(chan, { command: 'NOTICE', params: ['#foo', 'note'], tags: {} }, ctx);
+
+    const recorded = store.query({ chan: '#foo', direction: 'latest', limit: 10 });
+    expect(recorded).toHaveLength(1);
+    expect((recorded[0] as StoredMessage).command).toBe('NOTICE');
+    expect((recorded[0] as StoredMessage).text).toBe('note');
+  });
+
+  it('does NOT record when ctx.messages is absent (chathistory disabled)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn); // no store
+
+    // Should not throw and should still broadcast.
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+    expect(out.effects[0]?.tag).toBe('Broadcast');
+  });
+
+  it('does NOT record a user-target PRIVMSG (only channel messages are persisted)', () => {
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const ctx = makeCtx(conn, new FakeClock(1_000), store);
+
+    privmsgUserReducer(conn, { command: 'PRIVMSG', params: ['bob', 'hi'], tags: {} }, ctx);
+
+    expect(store.targets(0, 100_000)).toEqual([]);
+  });
+
+  it('does NOT record a user-target NOTICE', () => {
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const ctx = makeCtx(conn, new FakeClock(1_000), store);
+
+    noticeUserReducer(conn, { command: 'NOTICE', params: ['bob', 'hi'], tags: {} }, ctx);
+
+    expect(store.targets(0, 100_000)).toEqual([]);
+  });
+
+  it('does NOT record when the message is blocked by +n (no external messages)', () => {
+    const chan = makeChan('#foo');
+    chan.modes.noExternal = true;
+    // sender c1 is NOT a member
+    const store = new InMemoryMessageStore();
+    const ctx = makeCtx(makeConn(), new FakeClock(1_000), store);
+
+    privmsgChannelReducer(chan, { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} }, ctx);
+
+    expect(store.query({ chan: '#foo', direction: 'latest', limit: 10 })).toEqual([]);
+  });
+
+  it('does NOT record when the message is blocked by +m (moderated, no voice)', () => {
+    const chan = makeChan('#foo');
+    chan.modes.moderated = true;
+    addMember(chan, 'c1', 'alice', false, false); // not op, not voiced
+    const store = new InMemoryMessageStore();
+    const ctx = makeCtx(makeConn(), new FakeClock(1_000), store);
+
+    privmsgChannelReducer(chan, { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} }, ctx);
+
+    expect(store.query({ chan: '#foo', direction: 'latest', limit: 10 })).toEqual([]);
+  });
+
+  it('does NOT record when the sender is banned (+b)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    chan.banMasks.add('*!*@evil.com');
+    const conn = makeConn('c1', 'alice');
+    conn.host = 'evil.com';
+    const store = new InMemoryMessageStore();
+    const ctx = makeCtx(conn, new FakeClock(1_000), store);
+
+    privmsgChannelReducer(chan, { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} }, ctx);
+
+    expect(store.query({ chan: '#foo', direction: 'latest', limit: 10 })).toEqual([]);
+  });
+
+  it('uses a distinct msgid per recorded message (ctx.ids.nonce() each time)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const ctx = makeCtx(conn, new FakeClock(1_000), store);
+
+    privmsgChannelReducer(chan, { command: 'PRIVMSG', params: ['#foo', 'one'], tags: {} }, ctx);
+    privmsgChannelReducer(chan, { command: 'PRIVMSG', params: ['#foo', 'two'], tags: {} }, ctx);
+
+    const recorded = store.query({ chan: '#foo', direction: 'latest', limit: 10 });
+    expect(recorded.map((m) => m.msgid)).toEqual(['nonce-0', 'nonce-1']);
+  });
+});