serverless-ircd 0.1.0 → 0.3.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/kick.test.ts

@@ -134,6 +134,21 @@ describe('kickReducer — success', () => {
     );
   });
 
+  it('resolves the target using rfc1459 case-mapping ([ and { are equal)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'foo[bar]');
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = kickReducer(chan, { command: 'KICK', params: ['#foo', 'FOO{BAR}'], tags: {} }, ctx);
+
+    expect(out.state.members.has('c2')).toBe(false);
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.applyChannelDelta('#foo', { memberships: [{ type: 'remove', conn: 'c2' }] }),
+    );
+  });
+
   it('updates the kicker lastSeen to ctx.clock.now()', () => {
     const chan = makeChan('#foo');
     addMember(chan, 'c1', 'alice', true);

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

@@ -0,0 +1,257 @@
+import { describe, expect, it } from 'vitest';
+import { matchOperCred, operReducer } from '../../src/commands/oper';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import { type ConnectionState, createConnection } 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',
+};
+
+const serverConfigWithCreds: ServerConfig = {
+  ...baseServerConfig,
+  operCreds: [
+    { user: 'alice', password: 'secret' },
+    { user: 'bob', password: 'hunter2' },
+  ],
+};
+
+function makeCtx(state: ConnectionState, config: ServerConfig = serverConfigWithCreds): Ctx {
+  return buildCtx({
+    serverConfig: config,
+    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;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const oper = (name?: string, password?: string) =>
+  ({
+    command: 'OPER',
+    params: name === undefined ? [] : password === undefined ? [name] : [name, password],
+    tags: {},
+  }) as const;
+
+describe('operReducer — successful authentication', () => {
+  it('sets userModes.oper and emits 381 RPL_YOUREOPER on matching credentials', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = operReducer(state, oper('alice', 'secret'), ctx);
+
+    expect(out.state.userModes.oper).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 381 alice :You are now an IRC operator')]),
+    ]);
+  });
+
+  it('matches the second configured credential pair', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = operReducer(state, oper('bob', 'hunter2'), ctx);
+
+    expect(out.state.userModes.oper).toBe(true);
+  });
+
+  it('returns the same state reference (mutation permitted, no copy)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = operReducer(state, oper('alice', 'secret'), ctx);
+
+    expect(out.state).toBe(state);
+  });
+
+  it('updates connection lastSeen to ctx.clock.now()', () => {
+    const state = makeState();
+    expect(state.lastSeen).toBe(0);
+    const ctx = makeCtx(state);
+
+    const out = operReducer(state, oper('alice', 'secret'), ctx);
+
+    expect(out.state.lastSeen).toBe(5_000);
+  });
+
+  it('accepts a lower-case command token', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = operReducer(state, { command: 'oper', params: ['alice', 'secret'], tags: {} }, ctx);
+
+    expect(out.state.userModes.oper).toBe(true);
+  });
+});
+
+describe('operReducer — already an operator (graceful no-op)', () => {
+  it('re-emits 381 without error when the connection is already oper', () => {
+    const state = makeState();
+    state.userModes.oper = true;
+    const ctx = makeCtx(state);
+
+    const out = operReducer(state, oper('alice', 'secret'), ctx);
+
+    expect(out.state.userModes.oper).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 381 alice :You are now an IRC operator')]),
+    ]);
+  });
+
+  it('does not require correct credentials when already oper', () => {
+    const state = makeState();
+    state.userModes.oper = true;
+    const ctx = makeCtx(state);
+
+    const out = operReducer(state, oper('alice', 'wrong'), ctx);
+
+    expect(out.state.userModes.oper).toBe(true);
+    expect(out.effects.some((e) => e.tag === 'Send')).toBe(true);
+    // Critical: never a 464 for an already-oper connection.
+    for (const e of out.effects) {
+      if (e.tag === 'Send') for (const line of e.lines) expect(line.text).not.toContain(' 464 ');
+    }
+  });
+});
+
+describe('operReducer — wrong credentials', () => {
+  it('emits 464 ERR_PASSWDMISMATCH for a wrong password', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = operReducer(state, oper('alice', 'wrong'), ctx);
+
+    expect(out.state.userModes.oper).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 464 alice :Password Incorrect')]),
+    ]);
+  });
+
+  it('emits 464 ERR_PASSWDMISMATCH for an unknown operator name', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = operReducer(state, oper('mallory', 'whatever'), ctx);
+
+    expect(out.state.userModes.oper).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 464 alice :Password Incorrect')]),
+    ]);
+  });
+});
+
+describe('operReducer — no credentials configured', () => {
+  it('emits 491 ERR_NOOPERHOST when operCreds is absent', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, baseServerConfig);
+
+    const out = operReducer(state, oper('alice', 'secret'), ctx);
+
+    expect(out.state.userModes.oper).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 491 alice :No O-lines for your host')]),
+    ]);
+  });
+
+  it('emits 491 ERR_NOOPERHOST when operCreds is an empty array', () => {
+    const state = makeState();
+    const ctx = makeCtx(state, { ...baseServerConfig, operCreds: [] });
+
+    const out = operReducer(state, oper('alice', 'secret'), ctx);
+
+    expect(out.state.userModes.oper).toBe(false);
+    expect(out.effects.some((e) => e.tag === 'Send')).toBe(true);
+    for (const e of out.effects) {
+      if (e.tag === 'Send') for (const line of e.lines) expect(line.text).toContain(' 491 ');
+    }
+  });
+});
+
+describe('operReducer — missing parameters', () => {
+  it('emits 461 ERR_NEEDMOREPARAMS when no parameters are supplied', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = operReducer(state, oper(), ctx);
+
+    expect(out.state.userModes.oper).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice OPER :Not enough parameters')]),
+    ]);
+  });
+
+  it('emits 461 ERR_NEEDMOREPARAMS when only the name is supplied', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = operReducer(state, oper('alice'), ctx);
+
+    expect(out.state.userModes.oper).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice OPER :Not enough parameters')]),
+    ]);
+  });
+
+  it('uses "*" as the nick in 461 when the connection has no nick yet', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state);
+
+    const out = operReducer(state, oper(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 * OPER :Not enough parameters')]),
+    ]);
+  });
+});
+
+describe('matchOperCred', () => {
+  it('returns true when a credential pair matches exactly', () => {
+    const creds = [
+      { user: 'alice', password: 'secret' },
+      { user: 'bob', password: 'hunter2' },
+    ];
+    expect(matchOperCred(creds, 'bob', 'hunter2')).toBe(true);
+  });
+
+  it('returns false when the password does not match', () => {
+    const creds = [{ user: 'alice', password: 'secret' }];
+    expect(matchOperCred(creds, 'alice', 'nope')).toBe(false);
+  });
+
+  it('returns false when no user matches', () => {
+    const creds = [{ user: 'alice', password: 'secret' }];
+    expect(matchOperCred(creds, 'mallory', 'secret')).toBe(false);
+  });
+
+  it('returns false for an empty credential list', () => {
+    expect(matchOperCred([], 'alice', 'secret')).toBe(false);
+  });
+
+  it('does a case-sensitive comparison of both fields', () => {
+    const creds = [{ user: 'alice', password: 'secret' }];
+    expect(matchOperCred(creds, 'Alice', 'secret')).toBe(false);
+    expect(matchOperCred(creds, 'alice', 'Secret')).toBe(false);
+  });
+});