serverless-ircd 0.2.0 → 0.4.0

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

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

@@ -2,7 +2,12 @@ import { describe, expect, it } from 'vitest';
 import { quitReducer } from '../../src/commands/quit';
 import { Effect } from '../../src/effects';
 import type { Effect as EffectType, RawLine } from '../../src/effects';
-import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+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';
 
@@ -18,13 +23,18 @@ const serverConfig: ServerConfig = {
   quitMessage: 'Client Quit',
 };
 
-function makeCtx(state: ConnectionState, clock = new FakeClock(1_000)): Ctx {
+function makeCtx(
+  state: ConnectionState,
+  clock = new FakeClock(1_000),
+  history?: InMemoryNickHistoryStore,
+): Ctx {
   return buildCtx({
     serverConfig,
     clock,
     ids: new SequentialIdFactory(),
     motd: EmptyMotdProvider,
     connection: state,
+    ...(history !== undefined ? { history } : {}),
   });
 }
 
@@ -217,4 +227,61 @@ describe('quitReducer', () => {
       Effect.disconnect('c1'),
     ]);
   });
+
+  it('records a nick-history entry when ctx.history is bound', () => {
+    const state = makeRegisteredState();
+    const clock = new FakeClock(5_000);
+    const history = new InMemoryNickHistoryStore(clock);
+    const ctx = makeCtx(state, clock, history);
+
+    quitReducer(state, { command: 'QUIT', params: ['bye'], tags: {} }, ctx);
+
+    const entries = history.query('alice', 10);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.nick).toBe('alice');
+    expect(entries[0]?.connId).toBe('c1');
+    expect(entries[0]?.username).toBe('alice');
+    expect(entries[0]?.hostname).toBe('example.com');
+    expect(entries[0]?.realname).toBe('Alice');
+    expect(entries[0]?.signoffTime).toBe(5_000);
+  });
+
+  it('does not record history when no store is bound (ctx.history undefined)', () => {
+    const state = makeRegisteredState();
+    const ctx = makeCtx(state);
+
+    const out = quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(Effect.disconnect('c1'));
+    // No crash; the no-store path is a graceful no-op.
+  });
+
+  it('does not record history when the connection was never registered', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const clock = new FakeClock(5_000);
+    const history = new InMemoryNickHistoryStore(clock);
+    const ctx = makeCtx(state, clock, history);
+
+    quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    expect(history.query('ghost', 10)).toEqual([]);
+  });
+
+  it('records a history entry with only nick/connId when user/host/realname are absent', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    state.nick = 'alice';
+    state.registration = 'registered';
+    const clock = new FakeClock(5_000);
+    const history = new InMemoryNickHistoryStore(clock);
+    const ctx = makeCtx(state, clock, history);
+
+    quitReducer(state, { command: 'QUIT', params: [], tags: {} }, ctx);
+
+    const entries = history.query('alice', 10);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.nick).toBe('alice');
+    expect(entries[0]?.username).toBeUndefined();
+    expect(entries[0]?.hostname).toBeUndefined();
+    expect(entries[0]?.realname).toBeUndefined();
+  });
 });

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

@@ -9,9 +9,17 @@ import {
   passReducer,
   userReducer,
 } from '../../src/commands/registration';
+import { DEFAULT_CREATED_TEXT, DEFAULT_SERVER_VERSION } from '../../src/config';
 import { Effect } from '../../src/effects';
 import type { Effect as EffectType, RawLine } from '../../src/effects';
-import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryNickHistoryStore,
+  SequentialIdFactory,
+  StaticMotdProvider,
+} from '../../src/ports';
+import type { MotdProvider } from '../../src/ports';
 import { type ConnectionState, createConnection } from '../../src/state/connection';
 import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
 
@@ -27,13 +35,33 @@ const serverConfig: ServerConfig = {
   quitMessage: 'Client Quit',
 };
 
-function makeCtx(state: ConnectionState, clock = new FakeClock(1_000)): Ctx {
+function makeCtx(
+  state: ConnectionState,
+  clock = new FakeClock(1_000),
+  motd: MotdProvider = EmptyMotdProvider,
+): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd,
+    connection: state,
+  });
+}
+
+/** Like {@link makeCtx} but also threads a bound nick-history store. */
+function makeCtxWithHistory(
+  state: ConnectionState,
+  history: InMemoryNickHistoryStore,
+  clock = new FakeClock(1_000),
+): Ctx {
   return buildCtx({
     serverConfig,
     clock,
     ids: new SequentialIdFactory(),
     motd: EmptyMotdProvider,
     connection: state,
+    history,
   });
 }
 
@@ -76,13 +104,11 @@ function expectedWelcome(nick: string, user: string, host: string | undefined):
   );
   return [
     L(`${prefix} 001 ${nick} :Welcome to the ExampleNet IRC Network, ${hostmask}`),
-    L(`${prefix} 002 ${nick} :Your host is ${sv}, running version 0.2.0`),
-    L(`${prefix} 003 ${nick} :This server was created in Phase 1`),
-    L(`${prefix} 004 ${nick} ${sv} 0.2.0 iosw biklmnstp`),
+    L(`${prefix} 002 ${nick} :Your host is ${sv}, running version ${DEFAULT_SERVER_VERSION}`),
+    L(`${prefix} 003 ${nick} :This server was created in ${DEFAULT_CREATED_TEXT}`),
+    L(`${prefix} 004 ${nick} ${sv} ${DEFAULT_SERVER_VERSION} iosw biklmnstp`),
     ...isupport,
-    L(`${prefix} 375 ${nick} :- ${sv} Message of the day -`),
-    L(`${prefix} 372 ${nick} :- MOTD placeholder`),
-    L(`${prefix} 376 ${nick} :End of MOTD command`),
+    L(`${prefix} 422 ${nick} :MOTD File is missing`),
   ];
 }
 
@@ -319,6 +345,63 @@ describe('nickReducer', () => {
     expect(out.effects).toEqual([]);
     expect(out.state.nick).toBeUndefined();
   });
+
+  it('records the old nick into ctx.history on a post-registration nick change', () => {
+    const state = registeredState();
+    const clock = new FakeClock(5_000);
+    const history = new InMemoryNickHistoryStore(clock);
+    const ctx = makeCtxWithHistory(state, history, clock);
+
+    nickReducer(state, { command: 'NICK', params: ['bob'], tags: {} }, ctx);
+
+    const entries = history.query('alice', 10);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.nick).toBe('alice');
+    expect(entries[0]?.connId).toBe('c1');
+    expect(entries[0]?.username).toBe('alice');
+    expect(entries[0]?.hostname).toBe('example.com');
+    expect(entries[0]?.realname).toBe('Alice');
+    expect(entries[0]?.signoffTime).toBe(5_000);
+  });
+
+  it('does not record history on a pre-registration NICK', () => {
+    const state = makeState();
+    const clock = new FakeClock(5_000);
+    const history = new InMemoryNickHistoryStore(clock);
+    const ctx = makeCtxWithHistory(state, history, clock);
+
+    nickReducer(state, { command: 'NICK', params: ['alice'], tags: {} }, ctx);
+
+    expect(history.query('alice', 10)).toEqual([]);
+  });
+
+  it('does not record history on a nick change when no store is bound', () => {
+    const state = registeredState();
+    const ctx = makeCtx(state);
+
+    const out = nickReducer(state, { command: 'NICK', params: ['bob'], tags: {} }, ctx);
+
+    // No crash; the no-store path is a graceful no-op.
+    expect(out.state.nick).toBe('bob');
+  });
+
+  it('records a history entry with only nick/connId when user/host/realname are absent', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.registration = 'registered';
+    const clock = new FakeClock(5_000);
+    const history = new InMemoryNickHistoryStore(clock);
+    const ctx = makeCtxWithHistory(state, history, clock);
+
+    nickReducer(state, { command: 'NICK', params: ['bob'], tags: {} }, ctx);
+
+    const entries = history.query('alice', 10);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.nick).toBe('alice');
+    expect(entries[0]?.username).toBeUndefined();
+    expect(entries[0]?.hostname).toBeUndefined();
+    expect(entries[0]?.realname).toBeUndefined();
+  });
 });
 
 // ============================================================================
@@ -489,19 +572,22 @@ describe('passReducer', () => {
 // ============================================================================
 
 describe('buildWelcomeLines', () => {
-  it('produces the welcome block in the correct numeric order', () => {
+  it('produces the welcome block in the correct numeric order with MOTD content', () => {
     const state = makeState();
     state.nick = 'alice';
     state.user = 'alice';
     state.host = 'example.com';
-    const lines = buildWelcomeLines(state, makeCtx(state));
-    // 8 base lines (001-004, one or more 005, 375, 372, 376).
+    const lines = buildWelcomeLines(
+      state,
+      makeCtx(state, new FakeClock(1_000), new StaticMotdProvider(['line one', 'line two'])),
+    );
     expect(lines.length).toBeGreaterThanOrEqual(8);
     const codes = lines.map((l) => l.text.split(' ')[1]);
-    // First four numerics in fixed order; 005 (>=1); final three in order.
+    // First four numerics in fixed order; 005 (>=1); MOTD block last.
     expect(codes.slice(0, 4)).toEqual(['001', '002', '003', '004']);
     expect(codes[4]).toBe('005');
-    expect(codes.at(-3)).toBe('375');
+    expect(codes.at(-4)).toBe('375');
+    expect(codes.at(-3)).toBe('372');
     expect(codes.at(-2)).toBe('372');
     expect(codes.at(-1)).toBe('376');
   });
@@ -557,6 +643,159 @@ describe('buildWelcomeLines', () => {
   });
 });
 
+// ============================================================================
+// buildWelcomeLines — server version / created text driven from ServerConfig
+// ============================================================================
+
+describe('buildWelcomeLines — config-driven version & created text', () => {
+  /** Builds a ctx whose serverConfig carries the supplied version/created. */
+  function makeCtxWithMeta(
+    state: ConnectionState,
+    serverVersion: string | undefined,
+    createdAt: string | number | undefined,
+  ): Ctx {
+    const cfg: ServerConfig = {
+      ...serverConfig,
+      ...(serverVersion !== undefined ? { serverVersion } : {}),
+      ...(createdAt !== undefined ? { createdAt } : {}),
+    };
+    return buildCtx({
+      serverConfig: cfg,
+      clock: new FakeClock(1_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: state,
+    });
+  }
+
+  function registeredConn(): ConnectionState {
+    const s = makeState();
+    s.nick = 'alice';
+    s.user = 'alice';
+    s.host = 'example.com';
+    return s;
+  }
+
+  it('reflects the configured serverVersion in the 002 and 004 lines', () => {
+    const ctx = makeCtxWithMeta(registeredConn(), '9.9.9', undefined);
+    const lines = buildWelcomeLines(ctx.connection, ctx);
+    const line002 = lines.find((l) => l.text.split(' ')[1] === '002');
+    const line004 = lines.find((l) => l.text.split(' ')[1] === '004');
+    expect(line002?.text).toContain('9.9.9');
+    expect(line004?.text).toContain('9.9.9');
+  });
+
+  it('reflects the configured createdAt string in the 003 line', () => {
+    const ctx = makeCtxWithMeta(registeredConn(), undefined, '2024-06-01');
+    const lines = buildWelcomeLines(ctx.connection, ctx);
+    const line003 = lines.find((l) => l.text.split(' ')[1] === '003');
+    expect(line003?.text).toContain('2024-06-01');
+  });
+
+  it('formats a numeric createdAt (epoch ms) into the 003 line', () => {
+    const ctx = makeCtxWithMeta(registeredConn(), undefined, 1_700_000_000_000);
+    const lines = buildWelcomeLines(ctx.connection, ctx);
+    const line003 = lines.find((l) => l.text.split(' ')[1] === '003');
+    // 1700000000000ms → 2023-11-14T22:13:20.000Z ; the formatted text must
+    // contain a human-readable rendering of that instant, not the raw number.
+    expect(line003?.text).not.toContain('1700000000000');
+    expect(line003?.text).toContain('2023');
+  });
+
+  it('falls back to the default version when serverVersion is omitted', () => {
+    const ctx = makeCtxWithMeta(registeredConn(), undefined, undefined);
+    const lines = buildWelcomeLines(ctx.connection, ctx);
+    const line002 = lines.find((l) => l.text.split(' ')[1] === '002');
+    // The hardcoded placeholder '0.2.0' must no longer appear; the default
+    // is the irc-core package version (DEFAULT_SERVER_VERSION).
+    expect(line002?.text).not.toContain('0.2.0');
+    expect(line002?.text).toContain(DEFAULT_SERVER_VERSION);
+  });
+});
+
+// ============================================================================
+// buildWelcomeLines — MOTD driven from MotdProvider
+// ============================================================================
+
+describe('buildWelcomeLines — MOTD content', () => {
+  it('emits one 372 per MOTD line sourced from the MotdProvider', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    state.host = 'example.com';
+    const lines = buildWelcomeLines(
+      state,
+      makeCtx(state, new FakeClock(1_000), new StaticMotdProvider(['line A', 'line B'])),
+    );
+    const rpl372 = lines.filter((l) => l.text.split(' ')[1] === '372');
+    expect(rpl372).toHaveLength(2);
+    expect(rpl372[0]).toEqual(L(':irc.example.com 372 alice :- line A'));
+    expect(rpl372[1]).toEqual(L(':irc.example.com 372 alice :- line B'));
+  });
+
+  it('frames the MOTD content with 375 start and 376 end', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    const lines = buildWelcomeLines(
+      state,
+      makeCtx(state, new FakeClock(1_000), new StaticMotdProvider(['hi'])),
+    );
+    expect(lines).toContainEqual(
+      L(':irc.example.com 375 alice :- irc.example.com Message of the day -'),
+    );
+    expect(lines).toContainEqual(L(':irc.example.com 372 alice :- hi'));
+    expect(lines).toContainEqual(L(':irc.example.com 376 alice :End of MOTD command'));
+  });
+
+  it('reads MOTD lines fresh from the provider on each call', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    const provider = new StaticMotdProvider(['first']);
+    const ctx = makeCtx(state, new FakeClock(1_000), provider);
+    const first = buildWelcomeLines(state, ctx).filter((l) => l.text.split(' ')[1] === '372');
+    provider.setLines(['first', 'second']);
+    const second = buildWelcomeLines(state, ctx).filter((l) => l.text.split(' ')[1] === '372');
+    expect(first).toHaveLength(1);
+    expect(second).toHaveLength(2);
+  });
+
+  it('splits over-long MOTD lines so every emitted line fits the 510-byte budget', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    state.host = 'example.com';
+    const long = 'A'.repeat(2_000);
+    const lines = buildWelcomeLines(
+      state,
+      makeCtx(state, new FakeClock(1_000), new StaticMotdProvider([long])),
+    );
+    for (const line of lines) {
+      expect(line.text.length).toBeLessThanOrEqual(510);
+    }
+    // The single over-long line is hard-wrapped into many 372 chunks.
+    const rpl372 = lines.filter((l) => l.text.split(' ')[1] === '372');
+    expect(rpl372.length).toBeGreaterThan(1);
+  });
+});
+
+describe('buildWelcomeLines — empty MOTD', () => {
+  it('emits 422 ERR_NOMOTD instead of a placeholder when no MOTD is configured', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    const lines = buildWelcomeLines(state, makeCtx(state));
+    const codes = lines.map((l) => l.text.split(' ')[1]);
+    expect(codes.at(-1)).toBe('422');
+    expect(lines).toContainEqual(L(':irc.example.com 422 alice :MOTD File is missing'));
+    // No MOTD framing numerics leak through on the empty path.
+    expect(codes).not.toContain('375');
+    expect(codes).not.toContain('372');
+    expect(codes).not.toContain('376');
+  });
+});
+
 // ============================================================================
 // emitWelcomeIfReady
 // ============================================================================
@@ -856,12 +1095,10 @@ function expectedWelcomeWithHost(nick: string, hostmask: string): RawLine[] {
   );
   return [
     L(`${prefix} 001 ${nick} :Welcome to the ExampleNet IRC Network, ${hostmask}`),
-    L(`${prefix} 002 ${nick} :Your host is ${sv}, running version 0.2.0`),
-    L(`${prefix} 003 ${nick} :This server was created in Phase 1`),
-    L(`${prefix} 004 ${nick} ${sv} 0.2.0 iosw biklmnstp`),
+    L(`${prefix} 002 ${nick} :Your host is ${sv}, running version ${DEFAULT_SERVER_VERSION}`),
+    L(`${prefix} 003 ${nick} :This server was created in ${DEFAULT_CREATED_TEXT}`),
+    L(`${prefix} 004 ${nick} ${sv} ${DEFAULT_SERVER_VERSION} iosw biklmnstp`),
     ...isupport,
-    L(`${prefix} 375 ${nick} :- ${sv} Message of the day -`),
-    L(`${prefix} 372 ${nick} :- MOTD placeholder`),
-    L(`${prefix} 376 ${nick} :End of MOTD command`),
+    L(`${prefix} 422 ${nick} :MOTD File is missing`),
   ];
 }