serverless-ircd 0.3.0 → 0.4.0

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');
+    }
+  });
+});

package/packages/irc-core/tests/config.test.ts

@@ -1,5 +1,13 @@
 import { describe, expect, it } from 'vitest';
-import { DEFAULT_SERVER_CONFIG, ServerConfigSchema, parseServerConfig } from '../src/config';
+import {
+  DEFAULT_CREATED_TEXT,
+  DEFAULT_SERVER_CONFIG,
+  DEFAULT_SERVER_VERSION,
+  ServerConfigSchema,
+  formatCreatedAt,
+  parseServerConfig,
+  resolveServerVersion,
+} from '../src/config';
 
 // ============================================================================
 // ServerConfigSchema — valid inputs
@@ -213,6 +221,92 @@ describe('ServerConfigSchema — maxClients', () => {
   });
 });
 
+// ============================================================================
+// ServerConfigSchema — serverVersion / createdAt
+// ============================================================================
+
+describe('ServerConfigSchema — serverVersion', () => {
+  it('accepts an explicit non-empty version', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n', serverVersion: '9.9.9' });
+    expect(cfg.serverVersion).toBe('9.9.9');
+  });
+
+  it('defaults to DEFAULT_SERVER_VERSION when omitted', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.serverVersion).toBe(DEFAULT_SERVER_VERSION);
+  });
+
+  it('rejects an empty version string', () => {
+    expect(() =>
+      parseServerConfig({ serverName: 's', networkName: 'n', serverVersion: '' }),
+    ).toThrowError(/serverVersion/u);
+  });
+
+  it('rejects a non-string version', () => {
+    expect(() =>
+      parseServerConfig({ serverName: 's', networkName: 'n', serverVersion: 42 }),
+    ).toThrowError(/serverVersion/u);
+  });
+});
+
+describe('ServerConfigSchema — createdAt', () => {
+  it('accepts a non-empty string verbatim', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n', createdAt: '2024-06-01' });
+    expect(cfg.createdAt).toBe('2024-06-01');
+  });
+
+  it('accepts an epoch-ms number', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      createdAt: 1_700_000_000_000,
+    });
+    expect(cfg.createdAt).toBe(1_700_000_000_000);
+  });
+
+  it('defaults to DEFAULT_CREATED_TEXT when omitted', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.createdAt).toBe(DEFAULT_CREATED_TEXT);
+  });
+
+  it('rejects an empty string', () => {
+    expect(() =>
+      parseServerConfig({ serverName: 's', networkName: 'n', createdAt: '' }),
+    ).toThrowError(/createdAt/u);
+  });
+
+  it('rejects a non-string/non-number value', () => {
+    expect(() =>
+      parseServerConfig({ serverName: 's', networkName: 'n', createdAt: true }),
+    ).toThrowError(/createdAt/u);
+  });
+});
+
+// ============================================================================
+// resolveServerVersion / formatCreatedAt helpers
+// ============================================================================
+
+describe('resolveServerVersion', () => {
+  it('returns the configured value when present', () => {
+    expect(resolveServerVersion({ serverVersion: '1.2.3' })).toBe('1.2.3');
+  });
+  it('falls back to DEFAULT_SERVER_VERSION when undefined', () => {
+    expect(resolveServerVersion({})).toBe(DEFAULT_SERVER_VERSION);
+  });
+});
+
+describe('formatCreatedAt', () => {
+  it('returns a string verbatim', () => {
+    expect(formatCreatedAt('2024-06-01')).toBe('2024-06-01');
+  });
+  it('formats an epoch-ms number as a UTC timestamp', () => {
+    expect(formatCreatedAt(1_700_000_000_000)).toBe(new Date(1_700_000_000_000).toUTCString());
+  });
+  it('falls back to DEFAULT_CREATED_TEXT when undefined', () => {
+    expect(formatCreatedAt(undefined)).toBe(DEFAULT_CREATED_TEXT);
+  });
+});
+
 // ============================================================================
 // ServerConfigSchema — operCreds
 // ============================================================================

package/packages/irc-core/tests/credential-hashing.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, it } from 'vitest';
+import {
+  type HashedAccountCredential,
+  HashedAccountStore,
+  hashAccountCredential,
+  verifyHashedPassword,
+} from '../src/credential-hashing';
+import type { AccountStore, SaslPayload } from '../src/ports';
+
+describe('hashAccountCredential', () => {
+  it('produces an entry keyed by the username with scrypt', () => {
+    const entry = hashAccountCredential('alice', 'secret');
+    expect(entry.account).toBe('alice');
+    expect(entry.algorithm).toBe('scrypt');
+    expect(entry.salt.length).toBeGreaterThan(0);
+    expect(entry.hash.length).toBeGreaterThan(0);
+  });
+
+  it('never stores the plaintext password in any field', () => {
+    const entry = hashAccountCredential('alice', 'hunter2-secret');
+    expect(entry.account).not.toContain('hunter2');
+    expect(entry.salt).not.toContain('hunter2');
+    expect(entry.hash).not.toContain('hunter2');
+  });
+
+  it('produces different hashes for the same password under different salts', () => {
+    const a = hashAccountCredential('alice', 'secret', { salt: new Uint8Array(16).fill(0x61) });
+    const b = hashAccountCredential('alice', 'secret', { salt: new Uint8Array(16).fill(0x62) });
+    expect(a.hash).not.toBe(b.hash);
+  });
+
+  it('is deterministic for a fixed salt', () => {
+    const salt = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+    const a = hashAccountCredential('alice', 'secret', { salt });
+    const b = hashAccountCredential('alice', 'secret', { salt });
+    expect(a.hash).toBe(b.hash);
+  });
+
+  it('honours a custom key length', () => {
+    const entry = hashAccountCredential('alice', 'secret', { keyLen: 32 });
+    // base64 of 32 bytes → ~44 chars; decode to verify length.
+    const decoded = Buffer.from(entry.hash, 'base64');
+    expect(decoded.length).toBe(32);
+  });
+
+  it('generates a fresh random salt when none is supplied', () => {
+    const a = hashAccountCredential('alice', 'secret');
+    const b = hashAccountCredential('alice', 'secret');
+    expect(a.salt).not.toBe(b.salt);
+    expect(a.hash).not.toBe(b.hash);
+  });
+});
+
+describe('verifyHashedPassword', () => {
+  it('round-trips a hashed credential: correct password verifies', () => {
+    const entry = hashAccountCredential('alice', 's3cret');
+    expect(verifyHashedPassword('s3cret', entry)).toBe(true);
+  });
+
+  it('rejects a wrong password', () => {
+    const entry = hashAccountCredential('alice', 's3cret');
+    expect(verifyHashedPassword('wrong', entry)).toBe(false);
+  });
+
+  it('rejects a non-scrypt algorithm entry', () => {
+    const entry: HashedAccountCredential = {
+      account: 'alice',
+      algorithm: 'argon2' as 'scrypt',
+      salt: 'aaaa',
+      hash: 'bbbb',
+    };
+    expect(verifyHashedPassword('s3cret', entry)).toBe(false);
+  });
+
+  it('rejects a malformed base64 salt without throwing', () => {
+    const entry: HashedAccountCredential = {
+      account: 'alice',
+      algorithm: 'scrypt',
+      salt: 'not!!valid*b64',
+      hash: 'bbbb',
+    };
+    expect(verifyHashedPassword('s3cret', entry)).toBe(false);
+  });
+
+  it('rejects an entry whose decoded hash is empty', () => {
+    const entry: HashedAccountCredential = {
+      account: 'alice',
+      algorithm: 'scrypt',
+      salt: 'AAAA',
+      hash: '',
+    };
+    expect(verifyHashedPassword('s3cret', entry)).toBe(false);
+  });
+});
+
+describe('HashedAccountStore', () => {
+  function plain(username: string, password: string): SaslPayload {
+    return { kind: 'PLAIN', username, password };
+  }
+
+  it('implements the AccountStore port', () => {
+    const store: AccountStore = new HashedAccountStore([hashAccountCredential('alice', 's3cret')]);
+    expect(store).toBeDefined();
+  });
+
+  it('accepts valid PLAIN credentials and returns the account name', () => {
+    const store = new HashedAccountStore([hashAccountCredential('alice', 's3cret')]);
+    expect(store.verify('PLAIN', plain('alice', 's3cret'))).toEqual({
+      ok: true,
+      account: 'alice',
+    });
+  });
+
+  it('rejects a wrong password', () => {
+    const store = new HashedAccountStore([hashAccountCredential('alice', 's3cret')]);
+    expect(store.verify('PLAIN', plain('alice', 'wrong')).ok).toBe(false);
+  });
+
+  it('rejects an unknown username', () => {
+    const store = new HashedAccountStore([hashAccountCredential('alice', 's3cret')]);
+    expect(store.verify('PLAIN', plain('bob', 's3cret')).ok).toBe(false);
+  });
+
+  it('rejects a non-PLAIN mechanism', () => {
+    const store = new HashedAccountStore([hashAccountCredential('alice', 's3cret')]);
+    expect(store.verify('EXTERNAL', plain('alice', 's3cret')).ok).toBe(false);
+  });
+
+  it('rejects a RAW payload', () => {
+    const store = new HashedAccountStore([hashAccountCredential('alice', 's3cret')]);
+    expect(store.verify('PLAIN', { kind: 'RAW', data: 'whatever' }).ok).toBe(false);
+  });
+
+  it('handles multiple loaded accounts', () => {
+    const store = new HashedAccountStore([
+      hashAccountCredential('alice', 'a-secret'),
+      hashAccountCredential('bob', 'b-secret'),
+    ]);
+    expect(store.verify('PLAIN', plain('alice', 'a-secret'))).toEqual({
+      ok: true,
+      account: 'alice',
+    });
+    expect(store.verify('PLAIN', plain('bob', 'b-secret'))).toEqual({
+      ok: true,
+      account: 'bob',
+    });
+  });
+
+  it('fails every verify when constructed with no entries', () => {
+    const store = new HashedAccountStore([]);
+    expect(store.verify('PLAIN', plain('alice', 's3cret')).ok).toBe(false);
+  });
+
+  it('reports the number of loaded entries via size', () => {
+    const store = new HashedAccountStore([
+      hashAccountCredential('alice', 'a'),
+      hashAccountCredential('bob', 'b'),
+    ]);
+    expect(store.size).toBe(2);
+  });
+
+  it('round-trips an externally-constructed HashedAccountCredential', () => {
+    const row: HashedAccountCredential = hashAccountCredential('carol', 'p@ss');
+    const store = new HashedAccountStore([row]);
+    expect(store.verify('PLAIN', plain('carol', 'p@ss'))).toEqual({
+      ok: true,
+      account: 'carol',
+    });
+  });
+});

package/packages/irc-core/tests/effects.test.ts

@@ -67,27 +67,6 @@ describe('Effect constructors', () => {
     });
   });
 
-  it('LookupNick carries nick', () => {
-    expect(Effect.lookupNick('alice')).toEqual<EffectType>({
-      tag: 'LookupNick',
-      nick: 'alice',
-    });
-  });
-
-  it('GetConnectionInfo carries conn', () => {
-    expect(Effect.getConnectionInfo('c1')).toEqual<EffectType>({
-      tag: 'GetConnectionInfo',
-      conn: 'c1',
-    });
-  });
-
-  it('GetChannelSnapshot carries chan', () => {
-    expect(Effect.getChannelSnapshot('#foo')).toEqual<EffectType>({
-      tag: 'GetChannelSnapshot',
-      chan: '#foo',
-    });
-  });
-
   it('SendToNick carries nick, sender, lines, and optional notFoundLines', () => {
     expect(Effect.sendToNick('alice', 'c1', [line('hi')])).toEqual<EffectType>({
       tag: 'SendToNick',
@@ -115,9 +94,6 @@ describe('Effect tag set', () => {
     'ChangeNick',
     'ReleaseNick',
     'ApplyChannelDelta',
-    'LookupNick',
-    'GetConnectionInfo',
-    'GetChannelSnapshot',
     'SendToNick',
   ];
 
@@ -130,9 +106,6 @@ describe('Effect tag set', () => {
       ChangeNick: Effect.changeNick('c', 'a', 'b'),
       ReleaseNick: Effect.releaseNick('n'),
       ApplyChannelDelta: Effect.applyChannelDelta('#c', { memberships: [] }),
-      LookupNick: Effect.lookupNick('n'),
-      GetConnectionInfo: Effect.getConnectionInfo('c'),
-      GetChannelSnapshot: Effect.getChannelSnapshot('#c'),
       SendToNick: Effect.sendToNick('n', 'c', []),
     };
     expect(constructors[tag].tag).toBe(tag);