serverless-ircd 0.2.0 → 0.4.0

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
 // ============================================================================
@@ -288,6 +382,81 @@ describe('ServerConfigSchema — operCreds', () => {
   });
 });
 
+// ============================================================================
+// ServerConfigSchema — saslAccounts
+// ============================================================================
+
+describe('ServerConfigSchema — saslAccounts', () => {
+  it('accepts an array of {username,password} entries', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      saslAccounts: [
+        { username: 'alice', password: 'p1' },
+        { username: 'bob', password: 'p2' },
+      ],
+    });
+    expect(cfg.saslAccounts).toHaveLength(2);
+    expect(cfg.saslAccounts[0]?.username).toBe('alice');
+    expect(cfg.saslAccounts[1]?.password).toBe('p2');
+  });
+
+  it('defaults saslAccounts to an empty array when omitted', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.saslAccounts).toEqual([]);
+  });
+
+  it('rejects saslAccounts entries missing username', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        saslAccounts: [{ password: 'p' }],
+      }),
+    ).toThrowError(/username/u);
+  });
+
+  it('rejects saslAccounts entries missing password', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        saslAccounts: [{ username: 'u' }],
+      }),
+    ).toThrowError(/password/u);
+  });
+
+  it('rejects saslAccounts entries with empty username', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        saslAccounts: [{ username: '', password: 'p' }],
+      }),
+    ).toThrowError(/username/u);
+  });
+
+  it('rejects saslAccounts entries with empty password', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        saslAccounts: [{ username: 'u', password: '' }],
+      }),
+    ).toThrowError(/password/u);
+  });
+
+  it('rejects a non-array saslAccounts', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        saslAccounts: { username: 'u', password: 'p' },
+      }),
+    ).toThrowError(/saslAccounts/u);
+  });
+});
+
 // ============================================================================
 // ServerConfigSchema — limit knobs
 // ============================================================================

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);

package/packages/irc-core/tests/nick-history-store.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from 'vitest';
+import { FakeClock } from '../src/ports';
+import {
+  InMemoryNickHistoryStore,
+  type NickHistoryEntry,
+  type NickHistoryStore,
+} from '../src/ports';
+
+/** Builds a history entry with sensible defaults for tests. */
+function entry(
+  nick: string,
+  signoffTime: number,
+  opts: Partial<NickHistoryEntry> = {},
+): NickHistoryEntry {
+  return {
+    nick,
+    connId: opts.connId ?? 'c1',
+    signoffTime,
+    ...(opts.username !== undefined ? { username: opts.username } : {}),
+    ...(opts.hostname !== undefined ? { hostname: opts.hostname } : {}),
+    ...(opts.realname !== undefined ? { realname: opts.realname } : {}),
+  };
+}
+
+describe('InMemoryNickHistoryStore — record + query', () => {
+  it('implements the NickHistoryStore port', () => {
+    const store: NickHistoryStore = new InMemoryNickHistoryStore(new FakeClock(1_000));
+    expect(store).toBeDefined();
+  });
+
+  it('returns a recorded entry on query (most-recent-first)', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('alice', 1_000, { username: 'alice', hostname: 'ex.org' }));
+
+    const out = store.query('alice', 10);
+
+    expect(out).toHaveLength(1);
+    expect(out[0]?.nick).toBe('alice');
+    expect(out[0]?.username).toBe('alice');
+    expect(out[0]?.hostname).toBe('ex.org');
+    expect(out[0]?.signoffTime).toBe(1_000);
+  });
+
+  it('returns multiple entries most-recent-first', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('alice', 1_000, { connId: 'c1' }));
+    clock.advance(500);
+    store.record(entry('alice', 1_500, { connId: 'c2' }));
+    clock.advance(500);
+    store.record(entry('alice', 2_000, { connId: 'c3' }));
+
+    const out = store.query('alice', 10);
+    expect(out.map((e) => e.connId)).toEqual(['c3', 'c2', 'c1']);
+  });
+
+  it('caps the result at the requested count', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('alice', 1_000, { connId: 'c1' }));
+    clock.advance(500);
+    store.record(entry('alice', 1_500, { connId: 'c2' }));
+    clock.advance(500);
+    store.record(entry('alice', 2_000, { connId: 'c3' }));
+
+    const out = store.query('alice', 2);
+
+    expect(out.map((e) => e.connId)).toEqual(['c3', 'c2']);
+  });
+
+  it('returns an empty array for a nick with no history', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    expect(store.query('ghost', 10)).toEqual([]);
+  });
+
+  it('matches nicks case-insensitively (rfc1459 fold)', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('Ali[e', 1_000));
+
+    expect(store.query('ali{e', 10)).toHaveLength(1);
+    expect(store.query('ALI{E', 10)).toHaveLength(1);
+    expect(store.query('ALI[E', 10)).toHaveLength(1);
+  });
+
+  it('returns an empty array when count is zero', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('alice', 1_000));
+
+    expect(store.query('alice', 0)).toEqual([]);
+  });
+
+  it('keeps nick histories independent', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('alice', 1_000));
+    clock.advance(500);
+    store.record(entry('bob', 1_500));
+
+    expect(store.query('alice', 10)).toHaveLength(1);
+    expect(store.query('bob', 10)).toHaveLength(1);
+  });
+});
+
+describe('InMemoryNickHistoryStore — TTL purge', () => {
+  it('purges entries older than maxAge on query', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock, { maxAge: 5_000 });
+    store.record(entry('alice', 1_000, { connId: 'c1' }));
+    clock.advance(3_000);
+    store.record(entry('alice', 4_000, { connId: 'c2' }));
+    clock.advance(3_000);
+
+    const out = store.query('alice', 10);
+
+    expect(out.map((e) => e.connId)).toEqual(['c2']);
+  });
+
+  it('purges all entries once they exceed maxAge', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock, { maxAge: 1_000 });
+    store.record(entry('alice', 1_000));
+    clock.advance(2_000);
+
+    expect(store.query('alice', 10)).toEqual([]);
+  });
+
+  it('purges on record so the per-nick buffer does not grow unbounded', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock, { maxAge: 1_000 });
+    for (let i = 0; i < 50; i++) {
+      store.record(entry('alice', clock.now(), { connId: `c${i}` }));
+      clock.advance(100);
+    }
+    // clock.now() is now 6_000; entries older than cutoff 5_000 are purged.
+    const out = store.query('alice', 100);
+    expect(out.length).toBeLessThan(50);
+  });
+
+  it('purges to an empty array when all entries expire, then query returns empty', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock, { maxAge: 1_000 });
+    store.record(entry('alice', 1_000, { connId: 'c1' }));
+    clock.advance(2_000);
+    // First query purges the lone entry → empty buffer remains in the map.
+    expect(store.query('alice', 10)).toEqual([]);
+    // Second query hits purgeExpired on the now-empty buffer (no-op splice).
+    expect(store.query('alice', 10)).toEqual([]);
+  });
+
+  it('uses a sane default maxAge when omitted', () => {
+    const clock = new FakeClock(1_000);
+    const store = new InMemoryNickHistoryStore(clock);
+    store.record(entry('alice', 1_000));
+    clock.advance(10_000);
+
+    expect(store.query('alice', 10)).toHaveLength(1);
+  });
+});

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

@@ -23,6 +23,18 @@ describe('Numerics registry', () => {
     expect(Numerics.ERR_NEEDMOREPARAMS).toBe(461);
   });
 
+  it('maps RPL_WHOWASUSER to 314', () => {
+    expect(Numerics.RPL_WHOWASUSER).toBe(314);
+  });
+
+  it('maps RPL_ENDOFWHOWAS to 369', () => {
+    expect(Numerics.RPL_ENDOFWHOWAS).toBe(369);
+  });
+
+  it('maps ERR_WASNOSUCHNICK to 406', () => {
+    expect(Numerics.ERR_WASNOSUCHNICK).toBe(406);
+  });
+
   it('maps ERR_NICKNAMEINUSE to 433', () => {
     expect(Numerics.ERR_NICKNAMEINUSE).toBe(433);
   });

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

@@ -1,7 +1,12 @@
 import { describe, expect, it } from 'vitest';
 import type { RawLine } from '../src/effects';
 import { Effect as EffectValue } from '../src/effects';
-import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../src/ports';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryNickHistoryStore,
+  SequentialIdFactory,
+} from '../src/ports';
 import { createConnection } from '../src/state/connection';
 import {
   type Ctx,
@@ -97,6 +102,35 @@ describe('Ctx / Reducer types', () => {
     const keys = Object.keys(ctx) as Array<keyof Ctx>;
     expect(keys).not.toContain('msg');
   });
+
+  it('threads an optional history store through buildCtx onto ctx.history', () => {
+    const history = new InMemoryNickHistoryStore(new FakeClock(0));
+    const serverConfig: ServerConfig = {
+      serverName: 'irc.example.com',
+      networkName: 'ExampleNet',
+      maxChannelsPerUser: 30,
+      maxTargetsPerCommand: 10,
+      maxListEntries: 50,
+      nickLen: 30,
+      channelLen: 50,
+      topicLen: 390,
+      quitMessage: 'Client Quit',
+    };
+    const ctx = buildCtx({
+      serverConfig,
+      clock: new FakeClock(1_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: createConnection({ id: 'c1', connectedSince: 0 }),
+      history,
+    });
+    expect(ctx.history).toBe(history);
+  });
+
+  it('omits ctx.history when no history store is supplied', () => {
+    const ctx = makeCtx();
+    expect(ctx.history).toBeUndefined();
+  });
 });
 
 describe('ServerConfig shape', () => {

package/packages/irc-core/tsconfig.build.json

@@ -5,7 +5,7 @@
     "rootDir": "./src",
     "outDir": "./dist",
     "tsBuildInfoFile": "./.tsbuildinfo",
-    "types": []
+    "types": ["node"]
   },
   "include": ["src/**/*.ts"],
   "exclude": ["dist", "tests", "**/*.test.ts"]

package/packages/irc-core/tsconfig.test.json

@@ -2,7 +2,7 @@
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
     "noEmit": true,
-    "types": [],
+    "types": ["node"],
     "composite": false
   },
   "include": ["src/**/*.ts", "tests/**/*.ts"],

package/packages/irc-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/irc-server",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "private": true,
   "description": "Orchestration layer: IrcRuntime port, dispatch interpreter, ConnectionActor",
   "license": "BSD-3-Clause",