serverless-ircd 0.5.0 → 0.6.0

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

@@ -140,6 +140,12 @@ describe('generateIsupport — token values', () => {
     const allNoCap = linesNoCap.flatMap((l) => l.text.split(' '));
     expect(allNoCap).toContain('SAFELIST');
   });
+
+  it('advertises MONITOR=<n> with the default monitor cap ceiling', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('MONITOR=30');
+  });
 });
 
 // ============================================================================
@@ -207,3 +213,77 @@ describe('generateIsupport — capability-aware tokens', () => {
     expect(lines.length).toBeGreaterThan(0);
   });
 });
+
+// ============================================================================
+// generateIsupport — cap/mode-derived ISUPPORT tokens
+// ============================================================================
+
+describe('generateIsupport — MONITOR token (config-derived)', () => {
+  it('derives MONITOR=<n> from serverConfig.monitorLimit when set', () => {
+    const lines = generateIsupport(makeConfig({ monitorLimit: 50 }), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('MONITOR=50');
+  });
+
+  it('falls back to the default monitor ceiling when monitorLimit is unset', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('MONITOR=30');
+  });
+});
+
+describe('generateIsupport — STATUSMSG token', () => {
+  it('advertises STATUSMSG=@+ (status-msg prefixes mirror PREFIX)', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('STATUSMSG=@+');
+  });
+});
+
+describe('generateIsupport — EXTBAN token (config-derived prefix)', () => {
+  it('advertises EXTBAN=<prefix>,q with the default extban prefix', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('EXTBAN=~,q');
+  });
+
+  it('derives the EXTBAN prefix from serverConfig.extbanPrefix', () => {
+    const lines = generateIsupport(makeConfig({ extbanPrefix: '$' }), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('EXTBAN=$,q');
+  });
+});
+
+describe('generateIsupport — ACCOUNTEXTBAN token (services-gated)', () => {
+  it('omits ACCOUNTEXTBAN when services are not enabled', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all.some((t) => t.startsWith('ACCOUNTEXTBAN'))).toBe(false);
+  });
+
+  it('advertises ACCOUNTEXTBAN=a when services are enabled', () => {
+    const lines = generateIsupport(makeConfig({ servicesEnabled: true }), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('ACCOUNTEXTBAN=a');
+  });
+});
+
+describe('generateIsupport — draft cap advertisement tokens', () => {
+  it('advertises the TYPING token (draft/typing is supported)', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('TYPING');
+  });
+
+  it('derives MULTILINE=<n> from serverConfig.multilineMaxBytes (draft/multiline)', () => {
+    const lines = generateIsupport(makeConfig({ multilineMaxBytes: 8192 }), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('MULTILINE=8192');
+  });
+
+  it('falls back to the default multiline byte budget when multilineMaxBytes is unset', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('MULTILINE=4096');
+  });
+});

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

@@ -1103,3 +1103,75 @@ describe('userModeReducer — write', () => {
     expect(conn.lastSeen).toBe(11_000);
   });
 });
+
+// ============================================================================
+// userModeReducer — read-only mode `S` (TLS connected)
+// ============================================================================
+
+describe('userModeReducer — read-only mode `S` (TLS connected)', () => {
+  it('emits 221 with +S when the connection has the tls user mode set', () => {
+    const conn = makeConn();
+    conn.userModes.tls = true;
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 221 alice +S')]),
+    ]);
+  });
+
+  it('emits 221 with +iS when invisible and tls are both set', () => {
+    const conn = makeConn();
+    conn.userModes.invisible = true;
+    conn.userModes.tls = true;
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 221 alice +iS')]),
+    ]);
+  });
+
+  it('rejects MODE nick +S with 501 ERR_UMODEUNKNOWNFLAG (read-only)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice', '+S'], tags: {} }, ctx);
+
+    expect(conn.userModes.tls).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 501 alice :Unknown MODE flag')]),
+    ]);
+  });
+
+  it('rejects MODE nick -S with 501 ERR_UMODEUNKNOWNFLAG even when tls is set', () => {
+    const conn = makeConn();
+    conn.userModes.tls = true;
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice', '-S'], tags: {} }, ctx);
+
+    // The mode stays set: a client cannot clear a transport-owned mode.
+    expect(conn.userModes.tls).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 501 alice :Unknown MODE flag')]),
+    ]);
+  });
+
+  it('does not echo a MODE line when only +S was supplied (rejected, no-op)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice', '+iS'], tags: {} }, ctx);
+
+    // `i` is applied (and echoed), `S` is rejected with 501. The echo only
+    // carries the applied `+i`; the 501 is emitted alongside it.
+    expect(conn.userModes.invisible).toBe(true);
+    expect(conn.userModes.tls).toBe(false);
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines : []));
+    expect(texts).toContainEqual(L(':alice!alice@example.com MODE alice +i'));
+    expect(texts).toContainEqual(L(':irc.example.com 501 alice :Unknown MODE flag'));
+  });
+});

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

@@ -0,0 +1,411 @@
+import { describe, expect, it } from 'vitest';
+import { monitorReducer } from '../../src/commands/monitor';
+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',
+};
+
+/** Monitor cap ceiling used in tests; mirrors the production default. */
+const MAX_MONITOR = 30;
+
+function makeCtx(state: ConnectionState): Ctx {
+  return buildCtx({
+    serverConfig: baseServerConfig,
+    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 monitor = (sub: string, target?: string) =>
+  ({
+    command: 'MONITOR',
+    params: target === undefined ? [sub] : [sub, target],
+    tags: {},
+  }) as const;
+
+/** Builds an online map from display nicks (auto-folds each key). */
+const onlineMap = (...nicks: string[]): ReadonlyMap<string, string> =>
+  new Map(nicks.map((n) => [n.toLowerCase(), n]));
+
+describe('monitorReducer — MONITOR + (add)', () => {
+  it('emits 731 RPL_MONOFFLINE for an offline nick', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('+', 'bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 731 alice :bob')]),
+    ]);
+    expect(state.monitorList?.has('bob')).toBe(true);
+  });
+
+  it('emits 730 RPL_MONONLINE for an online nick', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(onlineMap('bob'), MAX_MONITOR, monitor('+', 'bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 730 alice :bob')]),
+    ]);
+    expect(state.monitorList?.has('bob')).toBe(true);
+  });
+
+  it('handles a comma-separated add list, splitting online/offline into 730/731', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(
+      onlineMap('bob', 'carol'),
+      MAX_MONITOR,
+      monitor('+', 'bob,carol,dave'),
+      ctx,
+    );
+
+    // Two separate effects: 730 with online nicks, then 731 with offline.
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 730 alice :bob,carol')]),
+      Effect.send('c1', [L(':irc.example.com 731 alice :dave')]),
+    ]);
+    expect(Array.from(state.monitorList ?? []).sort()).toEqual(['bob', 'carol', 'dave']);
+  });
+
+  it('omits the 730 line when no added nick is online', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('+', 'dave,eve'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 731 alice :dave,eve')]),
+    ]);
+  });
+
+  it('omits the 731 line when every added nick is online', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(onlineMap('bob'), MAX_MONITOR, monitor('+', 'bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 730 alice :bob')]),
+    ]);
+  });
+
+  it('skips nicks already in the watchlist without re-emitting their status', () => {
+    const state = makeState();
+    state.monitorList = new Set(['bob']);
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(onlineMap('bob'), MAX_MONITOR, monitor('+', 'bob'), ctx);
+
+    // Already-monitored nick produces no output (per ircv3 MONITOR spec).
+    expect(out.effects).toEqual<EffectType[]>([]);
+  });
+
+  it('reports the registered display spelling, not the requester spelling', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(onlineMap('Bob'), MAX_MONITOR, monitor('+', 'BOB'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 730 alice :Bob')]),
+    ]);
+    // Stored in the folded form for case-insensitive membership tests.
+    expect(state.monitorList?.has('bob')).toBe(true);
+  });
+
+  it('emits 734 ERR_MONLISTFULL when adding would exceed the cap, naming the rejected nicks', () => {
+    const state = makeState();
+    // Pre-fill the list to the cap.
+    state.monitorList = new Set(Array.from({ length: MAX_MONITOR }, (_, i) => `nick${i}`));
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('+', 'bob,carol'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(`:irc.example.com 734 alice ${MAX_MONITOR} :bob,carol`)]),
+    ]);
+    // Cap unchanged.
+    expect(state.monitorList?.size).toBe(MAX_MONITOR);
+  });
+
+  it('partially admits an oversized add list up to the cap and 734s the rest', () => {
+    const state = makeState();
+    state.monitorList = new Set(Array.from({ length: MAX_MONITOR - 1 }, (_, i) => `nick${i}`));
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('+', 'bob,carol'), ctx);
+
+    // First nick admitted (offline) → 731; second rejected → 734.
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 731 alice :bob')]),
+      Effect.send('c1', [L(`:irc.example.com 734 alice ${MAX_MONITOR} :carol`)]),
+    ]);
+    expect(state.monitorList?.has('bob')).toBe(true);
+    expect(state.monitorList?.has('carol')).toBe(false);
+  });
+});
+
+describe('monitorReducer — MONITOR - (remove)', () => {
+  it('removes nicks from the watchlist silently (no numeric output)', () => {
+    const state = makeState();
+    state.monitorList = new Set(['bob', 'carol']);
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(onlineMap('bob'), MAX_MONITOR, monitor('-', 'bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([]);
+    expect(state.monitorList?.has('bob')).toBe(false);
+    expect(state.monitorList?.has('carol')).toBe(true);
+  });
+
+  it('removes multiple comma-separated nicks', () => {
+    const state = makeState();
+    state.monitorList = new Set(['bob', 'carol', 'dave']);
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('-', 'bob,dave'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([]);
+    expect(state.monitorList?.has('bob')).toBe(false);
+    expect(state.monitorList?.has('carol')).toBe(true);
+    expect(state.monitorList?.has('dave')).toBe(false);
+  });
+
+  it('is a no-op for a nick that was not being monitored', () => {
+    const state = makeState();
+    state.monitorList = new Set(['bob']);
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('-', 'ghost'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([]);
+    expect(state.monitorList?.has('bob')).toBe(true);
+  });
+
+  it('is a no-op when no watchlist has been allocated yet', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('-', 'bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([]);
+    expect(state.monitorList).toBeUndefined();
+  });
+
+  it('is a no-op when the target list is empty (`MONITOR -` with no args)', () => {
+    const state = makeState();
+    state.monitorList = new Set(['bob']);
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('-'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([]);
+    expect(state.monitorList?.has('bob')).toBe(true);
+  });
+});
+
+describe('monitorReducer — MONITOR C (clear)', () => {
+  it('empties the entire watchlist silently', () => {
+    const state = makeState();
+    state.monitorList = new Set(['bob', 'carol', 'dave']);
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('C'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([]);
+    expect(state.monitorList?.size).toBe(0);
+  });
+
+  it('is a no-op when the watchlist is already empty', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('C'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([]);
+    expect(state.monitorList?.size).toBe(0);
+  });
+});
+
+describe('monitorReducer — MONITOR L (list)', () => {
+  it('emits 732 RPL_MONLIST per line then 733 RPL_ENDOFMONLIST', () => {
+    const state = makeState();
+    state.monitorList = new Set(['bob', 'carol']);
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('L'), ctx);
+
+    // Nicks are listed in their stored display form (which is folded, so
+    // lowercase here). Order is the Set's insertion order.
+    const sends = out.effects.map((e) => (e as { lines: RawLine[] }).lines[0]?.text);
+    expect(sends).toContain(':irc.example.com 732 alice :bob');
+    expect(sends).toContain(':irc.example.com 732 alice :carol');
+    expect(sends[sends.length - 1]).toBe(':irc.example.com 733 alice :End of MONITOR list');
+  });
+
+  it('emits only 733 when the watchlist is empty', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('L'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 733 alice :End of MONITOR list')]),
+    ]);
+  });
+});
+
+describe('monitorReducer — MONITOR S (status)', () => {
+  it('emits 730 for online monitored nicks and 731 for offline ones', () => {
+    const state = makeState();
+    state.monitorList = new Set(['bob', 'carol', 'dave']);
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(onlineMap('bob', 'carol'), MAX_MONITOR, monitor('S'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 730 alice :bob,carol')]),
+      Effect.send('c1', [L(':irc.example.com 731 alice :dave')]),
+    ]);
+  });
+
+  it('emits only 730 when every monitored nick is online', () => {
+    const state = makeState();
+    state.monitorList = new Set(['bob', 'carol']);
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(onlineMap('bob', 'carol'), MAX_MONITOR, monitor('S'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 730 alice :bob,carol')]),
+    ]);
+  });
+
+  it('emits only 731 when every monitored nick is offline', () => {
+    const state = makeState();
+    state.monitorList = new Set(['dave', 'eve']);
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('S'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 731 alice :dave,eve')]),
+    ]);
+  });
+
+  it('emits nothing when the watchlist is empty', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('S'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([]);
+  });
+});
+
+describe('monitorReducer — validation & state', () => {
+  it('uses * as nick placeholder for unregistered connections', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('+', 'bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 731 * :bob')]),
+    ]);
+  });
+
+  it('updates lastSeen to ctx.clock.now()', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    monitorReducer(new Map(), MAX_MONITOR, monitor('+', 'bob'), ctx);
+
+    expect(state.lastSeen).toBe(5_000);
+  });
+
+  it('returns the same state reference', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('L'), ctx);
+
+    expect(out.state).toBe(state);
+  });
+
+  it('rejects an unknown subcommand with 461 ERR_NEEDMOREPARAMS', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('Z'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice MONITOR :Unknown command')]),
+    ]);
+  });
+
+  it('rejects MONITOR + with no nick argument via 461 ERR_NEEDMOREPARAMS', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor('+'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice MONITOR :Not enough parameters')]),
+    ]);
+  });
+
+  it('treats MONITOR (no sub) as 461 ERR_NEEDMOREPARAMS', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    const out = monitorReducer(new Map(), MAX_MONITOR, monitor(''), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice MONITOR :Not enough parameters')]),
+    ]);
+  });
+
+  it('treats MONITOR with no params array at all as 461 ERR_NEEDMOREPARAMS', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+
+    // Mirrors the parser shape for a bare `MONITOR` with no subcommand.
+    const out = monitorReducer(new Map(), MAX_MONITOR, { params: [] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice MONITOR :Not enough parameters')]),
+    ]);
+  });
+});