serverless-ircd 0.4.0 → 0.6.0

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

@@ -0,0 +1,231 @@
+import { describe, expect, it } from 'vitest';
+import { wallopsReducer } from '../../src/commands/wallops';
+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 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(5_000)): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+function makeOper(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';
+  s.userModes.oper = true;
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const wallops = (message?: string) =>
+  ({
+    command: 'WALLOPS',
+    params: message === undefined ? [] : [message],
+    tags: {},
+  }) as const;
+
+describe('wallopsReducer — oper happy path', () => {
+  it('emits a global BroadcastWallops effect carrying the oper source prefix', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hello'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcastWallops([L(':alice!alice@example.com WALLOPS :hello')], 'c1'),
+    ]);
+  });
+
+  it('passes the message text through verbatim (multi-word)', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('restart in 5 minutes'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcastWallops([L(':alice!alice@example.com WALLOPS :restart in 5 minutes')], 'c1'),
+    ]);
+  });
+
+  it('defaults except to the sender (skip-self, NOTICE/PRIVMSG semantics)', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects[0]?.tag).toBe('BroadcastWallops');
+    // except is the oper's own connection id, so the runtime never echoes
+    // the wallops back to its originator.
+    expect((out.effects[0] as { except?: string }).except).toBe('c1');
+  });
+
+  it('updates the oper lastSeen to ctx.clock.now()', () => {
+    const oper = makeOper();
+    expect(oper.lastSeen).toBe(0);
+    const ctx = makeCtx(oper);
+
+    wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(oper.lastSeen).toBe(5_000);
+  });
+
+  it('returns the same state reference unchanged', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.state).toBe(oper);
+  });
+
+  it('falls back to the bare nick when the hostmask is incomplete (no user/host)', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.nick = 'alice';
+    oper.registration = 'registered';
+    oper.userModes.oper = true;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcastWallops([L(':alice WALLOPS :hi')], 'c1'),
+    ]);
+  });
+
+  it('falls back to "*" when the oper has neither nick nor hostmask (defensive)', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.registration = 'registered';
+    oper.userModes.oper = true;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcastWallops([L(':* WALLOPS :hi')], 'c1'),
+    ]);
+  });
+});
+
+describe('wallopsReducer — non-oper (481 ERR_NOPRIVILEGES)', () => {
+  it('emits 481 when the sender is not an oper', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 alice :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+
+  it('does not emit a BroadcastWallops when the sender is not an oper', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects.some((e) => e.tag === 'BroadcastWallops')).toBe(false);
+  });
+
+  it('gates before param validation: a non-oper with no message still gets 481', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 alice :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+
+  it('uses "*" as the nick in 481 when the connection has no nick', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops('hi'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 * :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+});
+
+describe('wallopsReducer — empty message (412 ERR_NOTEXTTOSEND)', () => {
+  it('emits 412 when no message parameter is supplied', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 412 alice :No text to send')]),
+    ]);
+  });
+
+  it('emits 412 when the message is the empty string', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(''), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 412 alice :No text to send')]),
+    ]);
+  });
+
+  it('does not broadcast when the message is empty', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(''), ctx);
+
+    expect(out.effects.some((e) => e.tag === 'BroadcastWallops')).toBe(false);
+  });
+
+  it('uses "*" as the nick in 412 when the connection has no nick', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.registration = 'registered';
+    oper.userModes.oper = true;
+    const ctx = makeCtx(oper);
+
+    const out = wallopsReducer(oper, wallops(''), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 412 * :No text to send')]),
+    ]);
+  });
+});

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

@@ -166,6 +166,40 @@ describe('whoisReducer — happy path', () => {
       expect(send.lines.some((l) => l.text.endsWith(':is an IRC operator'))).toBe(true);
     }
   });
+
+  it('emits 276 RPL_WHOISSECURE when the target connected over TLS (user mode S)', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+    target.userModes.tls = true;
+
+    const out = whoisReducer(target, [], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    const send = out.effects[0];
+    expect(send?.tag).toBe('Send');
+    if (send?.tag === 'Send') {
+      expect(send.lines.some((l) => l.text.includes(' 276 '))).toBe(true);
+      expect(
+        send.lines.some(
+          (l) => l.text === ':irc.example.com 276 alice bob :is using a secure connection',
+        ),
+      ).toBe(true);
+    }
+  });
+
+  it('does not emit 276 when the target is not on a secure connection', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+    // tls left at its default (false).
+
+    const out = whoisReducer(target, [], { command: 'WHOIS', params: ['bob'] }, ctx);
+
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      expect(send.lines.some((l) => l.text.includes(' 276 '))).toBe(false);
+    }
+  });
 });
 
 // ============================================================================

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

@@ -1,7 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import {
   DEFAULT_CREATED_TEXT,
-  DEFAULT_SERVER_CONFIG,
   DEFAULT_SERVER_VERSION,
   ServerConfigSchema,
   formatCreatedAt,
@@ -567,22 +566,34 @@ describe('ServerConfigSchema — failure diagnostics', () => {
 });
 
 // ============================================================================
-// ServerConfigSchema — defaults
+// ServerConfigSchema — no placeholder serverName baseline
 // ============================================================================
 
-describe('ServerConfigSchema — DEFAULT_SERVER_CONFIG', () => {
-  it('is a valid parsed config', () => {
-    expect(DEFAULT_SERVER_CONFIG.serverName.length).toBeGreaterThan(0);
-    expect(DEFAULT_SERVER_CONFIG.networkName.length).toBeGreaterThan(0);
-    expect(Array.isArray(DEFAULT_SERVER_CONFIG.motdLines)).toBe(true);
-    expect(DEFAULT_SERVER_CONFIG.channelPrefixes.length).toBeGreaterThan(0);
-    expect(DEFAULT_SERVER_CONFIG.maxClients).toBeGreaterThan(0);
-    expect(Array.isArray(DEFAULT_SERVER_CONFIG.operCreds)).toBe(true);
+describe('ServerConfigSchema — required serverName', () => {
+  it('rejects an empty input with a serverName error (no placeholder fallback)', () => {
+    try {
+      parseServerConfig({});
+      expect.fail('expected parseServerConfig({}) to throw');
+    } catch (err) {
+      expect(err).toBeInstanceOf(Error);
+      const msg = (err as Error).message;
+      expect(msg).toMatch(/invalid server config/iu);
+      expect(msg).toMatch(/serverName/u);
+    }
   });
 
-  it('round-trips through the schema unchanged', () => {
-    const reparsed = parseServerConfig(DEFAULT_SERVER_CONFIG);
-    expect(reparsed).toEqual(DEFAULT_SERVER_CONFIG);
+  it('rejects an empty-string serverName', () => {
+    expect(() => parseServerConfig({ serverName: '', networkName: 'n' })).toThrowError(
+      /serverName/u,
+    );
+  });
+
+  it('accepts a minimal {serverName, networkName} input', () => {
+    const cfg = parseServerConfig({ serverName: 'irc.test', networkName: 'TestNet' });
+    expect(cfg.serverName).toBe('irc.test');
+    expect(cfg.networkName).toBe('TestNet');
+    expect(cfg.channelPrefixes.length).toBeGreaterThan(0);
+    expect(cfg.maxClients).toBeGreaterThan(0);
   });
 });
 
@@ -813,3 +824,82 @@ describe('ServerConfigSchema — perIpConnectionRate', () => {
     ).toThrowError(/perIpConnectionRate/u);
   });
 });
+
+// ============================================================================
+// ServerConfigSchema — sts (Strict Transport Security)
+// ============================================================================
+
+describe('ServerConfigSchema — sts', () => {
+  it('defaults sts to undefined when omitted (STS disabled)', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.sts).toBeUndefined();
+  });
+
+  it('accepts a valid sts config with duration + port', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      sts: { duration: 600, port: 6697 },
+    });
+    expect(cfg.sts).toEqual({ duration: 600, port: 6697 });
+  });
+
+  it('accepts an optional preload directive', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      sts: { duration: 600, port: 6697, preload: true },
+    });
+    expect(cfg.sts?.preload).toBe(true);
+  });
+
+  it('rejects an sts config missing duration', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        sts: { port: 6697 },
+      }),
+    ).toThrowError(/duration/u);
+  });
+
+  it('rejects an sts config missing port', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        sts: { duration: 600 },
+      }),
+    ).toThrowError(/port/u);
+  });
+
+  it('rejects a zero duration', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        sts: { duration: 0, port: 6697 },
+      }),
+    ).toThrowError(/duration/u);
+  });
+
+  it('rejects a zero port', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        sts: { duration: 600, port: 0 },
+      }),
+    ).toThrowError(/port/u);
+  });
+
+  it('rejects a non-object sts value', () => {
+    expect(() =>
+      parseServerConfig({
+        serverName: 's',
+        networkName: 'n',
+        sts: 'secure',
+      }),
+    ).toThrowError(/sts/u);
+  });
+});

package/packages/irc-core/tests/dropped-s2s-and-obsolete-verbs.test.ts

@@ -0,0 +1,90 @@
+/**
+ * Regression guards for the formally-dropped S2S and obsolete RFC 2812 verbs.
+ *
+ * - S2S drop: `CONNECT` / `SQUIT` / `LINKS` are server-to-server commands.
+ *   S2S is an explicit PLAN non-goal (`PLAN.md` §1), so the three verbs are
+ *   formally dropped (they still return `421 ERR_UNKNOWNCOMMAND` — that is
+ *   the correct response for an unimplemented command). Their reserved
+ *   numerics (`RPL_LINKS`, `RPL_ENDOFLINKS`, `ERR_CANTKILLSERVER`) are removed
+ *   here.
+ *
+ * - Obsolete-verb drop: `SERVICE` / `SUMMON` / `USERS` are RFC 2812 verbs
+ *   that were never widely implemented and are effectively dead. They are
+ *   formally dropped (also still `421`). Their reserved numerics
+ *   (`RPL_YOURESERVICE`, `ERR_NOSUCHSERVICE`, `ERR_SUMMONDISABLED`,
+ *   `ERR_USERSDISABLED`) are removed here.
+ *
+ * Because the drop is "remove the numeric, keep the 421", there is no runtime
+ * behaviour to assert — these are source-level / registry-level regression
+ * guards that prevent the numerics (and the "deferred verb" framing) from
+ * creeping back in.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { Numerics, numericToName } from '../src/protocol/numerics';
+import numericsSource from '../src/protocol/numerics.ts?raw';
+
+describe('dropped S2S verbs (CONNECT / SQUIT / LINKS)', () => {
+  // S2S is a PLAN non-goal; the three verbs are formally dropped. Their
+  // reserved numerics are removed from the registry.
+  const droppedS2SNumerics = ['RPL_LINKS', 'RPL_ENDOFLINKS', 'ERR_CANTKILLSERVER'] as const;
+
+  it.each(droppedS2SNumerics)('numerics.ts source no longer defines %s', (name) => {
+    expect(numericsSource).not.toContain(`${name}:`);
+  });
+
+  it.each(droppedS2SNumerics)('Numerics runtime object has no %s key', (name) => {
+    expect((Numerics as Record<string, unknown>)[name]).toBeUndefined();
+  });
+
+  it('numericToName no longer resolves the dropped S2S codes (364, 365, 483)', () => {
+    expect(numericToName.get(364)).toBeUndefined();
+    expect(numericToName.get(365)).toBeUndefined();
+    expect(numericToName.get(483)).toBeUndefined();
+  });
+
+  it('numerics.ts source documents the S2S drop', () => {
+    // The drop must be explained where the numerics used to live, so the
+    // absence is not mistaken for a gap.
+    expect(numericsSource).toMatch(/S2S/);
+    expect(numericsSource).toMatch(/PLAN non-goal/);
+  });
+
+  it('ERR_NOSUCHSERVER (402) is retained (used by LUSERS/STATS/TRACE)', () => {
+    // 402 stays because the implemented query verbs use it for remote-server
+    // gating.
+    expect(Numerics.ERR_NOSUCHSERVER).toBe(402);
+    expect(numericToName.get(402)).toBe('ERR_NOSUCHSERVER');
+  });
+});
+
+describe('dropped obsolete RFC 2812 verbs (SERVICE / SUMMON / USERS)', () => {
+  // RFC 2812 obsolete verbs, never widely implemented. Formally dropped;
+  // their reserved numerics are removed from the registry.
+  const droppedObsoleteNumerics = [
+    'RPL_YOURESERVICE',
+    'ERR_NOSUCHSERVICE',
+    'ERR_SUMMONDISABLED',
+    'ERR_USERSDISABLED',
+  ] as const;
+
+  it.each(droppedObsoleteNumerics)('numerics.ts source no longer defines %s', (name) => {
+    expect(numericsSource).not.toContain(`${name}:`);
+  });
+
+  it.each(droppedObsoleteNumerics)('Numerics runtime object has no %s key', (name) => {
+    expect((Numerics as Record<string, unknown>)[name]).toBeUndefined();
+  });
+
+  it('numericToName no longer resolves the dropped obsolete codes (383, 408, 445, 446)', () => {
+    expect(numericToName.get(383)).toBeUndefined();
+    expect(numericToName.get(408)).toBeUndefined();
+    expect(numericToName.get(445)).toBeUndefined();
+    expect(numericToName.get(446)).toBeUndefined();
+  });
+
+  it('numerics.ts source documents the obsolete-verb drop', () => {
+    expect(numericsSource).toMatch(/RFC 2812/);
+    expect(numericsSource).toMatch(/obsolete/);
+  });
+});

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

@@ -82,6 +82,18 @@ describe('Effect constructors', () => {
       notFoundLines: [{ text: '401' }],
     });
   });
+
+  it('BroadcastWallops carries lines and optional except', () => {
+    expect(Effect.broadcastWallops([line(':a WALLOPS :hi')])).toEqual<EffectType>({
+      tag: 'BroadcastWallops',
+      lines: [{ text: ':a WALLOPS :hi' }],
+    });
+    expect(Effect.broadcastWallops([line(':a WALLOPS :hi')], 'c1')).toEqual<EffectType>({
+      tag: 'BroadcastWallops',
+      lines: [{ text: ':a WALLOPS :hi' }],
+      except: 'c1',
+    });
+  });
 });
 
 describe('Effect tag set', () => {
@@ -95,6 +107,7 @@ describe('Effect tag set', () => {
     'ReleaseNick',
     'ApplyChannelDelta',
     'SendToNick',
+    'BroadcastWallops',
   ];
 
   it.each(expectedTags)('exposes a constructor for the %s tag', (tag) => {
@@ -107,6 +120,7 @@ describe('Effect tag set', () => {
       ReleaseNick: Effect.releaseNick('n'),
       ApplyChannelDelta: Effect.applyChannelDelta('#c', { memberships: [] }),
       SendToNick: Effect.sendToNick('n', 'c', []),
+      BroadcastWallops: Effect.broadcastWallops([]),
     };
     expect(constructors[tag].tag).toBe(tag);
   });