serverless-ircd 0.4.0 → 0.5.0

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

@@ -0,0 +1,243 @@
+import { describe, expect, it } from 'vitest';
+import { killReducer } from '../../src/commands/kill';
+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;
+}
+
+function makeTarget(id = 'c2', nick = 'bob'): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = nick;
+  s.host = 'example.com';
+  s.realname = 'Bob';
+  s.registration = 'registered';
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const kill = (nick?: string, comment?: string) =>
+  ({
+    command: 'KILL',
+    params: nick === undefined ? [] : comment === undefined ? [nick] : [nick, comment],
+    tags: {},
+  }) as const;
+
+describe('killReducer — oper happy path', () => {
+  it('emits a Disconnect effect for the target with a kill-formatted reason', () => {
+    const oper = makeOper();
+    const target = makeTarget();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(target, kill('bob', 'flooding'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.disconnect('c2', 'Killed (alice (flooding))'),
+    ]);
+  });
+
+  it('uses the oper display nick in the reason, not the target nick', () => {
+    const oper = makeOper('c1', 'theOper');
+    const target = makeTarget('c2', 'bob');
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(target, kill('bob', 'bye'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([Effect.disconnect('c2', 'Killed (theOper (bye))')]);
+  });
+
+  it('formats multi-word comments verbatim inside the inner parens', () => {
+    const oper = makeOper();
+    const target = makeTarget();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(target, kill('bob', 'stop flooding the channel'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.disconnect('c2', 'Killed (alice (stop flooding the channel))'),
+    ]);
+  });
+
+  it('updates the oper lastSeen to ctx.clock.now()', () => {
+    const oper = makeOper();
+    expect(oper.lastSeen).toBe(0);
+    const ctx = makeCtx(oper);
+
+    killReducer(makeTarget(), kill('bob', 'flooding'), ctx);
+
+    expect(oper.lastSeen).toBe(5_000);
+  });
+
+  it('falls back to "*" for the oper nick in the reason when the oper has none', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.userModes.oper = true;
+    const target = makeTarget();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(target, kill('bob', 'x'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([Effect.disconnect('c2', 'Killed (* (x))')]);
+  });
+});
+
+describe('killReducer — self-kill (RFC-permitted)', () => {
+  it('allows an oper to KILL themselves, disconnecting their own connection', () => {
+    const oper = makeOper('c1', 'alice');
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(oper, kill('alice', 'self-terminate'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.disconnect('c1', 'Killed (alice (self-terminate))'),
+    ]);
+  });
+});
+
+describe('killReducer — non-oper (481 ERR_NOPRIVILEGES)', () => {
+  it('emits 481 when the sender is not an oper', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const target = makeTarget();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(target, kill('bob', 'flooding'), 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 disconnect the target when the sender is not an oper', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const target = makeTarget();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(target, kill('bob', 'flooding'), ctx);
+
+    expect(out.effects.some((e) => e.tag === 'Disconnect')).toBe(false);
+  });
+
+  it('gates before param validation: a non-oper with missing params still gets 481', () => {
+    const oper = makeOper();
+    oper.userModes.oper = false;
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(undefined, kill(), 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 = killReducer(undefined, kill('bob', 'x'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 * :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+});
+
+describe('killReducer — missing parameters (461 ERR_NEEDMOREPARAMS)', () => {
+  it('emits 461 when no parameters are supplied', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(undefined, kill(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice KILL :Not enough parameters')]),
+    ]);
+  });
+
+  it('emits 461 when only the nick is supplied (no comment)', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(makeTarget(), kill('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice KILL :Not enough parameters')]),
+    ]);
+  });
+
+  it('uses "*" as the nick in 461 when the connection has no nick', () => {
+    const oper = createConnection({ id: 'c1', connectedSince: 0 });
+    oper.userModes.oper = true;
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(undefined, kill('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 * KILL :Not enough parameters')]),
+    ]);
+  });
+});
+
+describe('killReducer — unknown nick (401 ERR_NOSUCHNICK)', () => {
+  it('emits 401 when the target resolves to undefined', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(undefined, kill('ghost', 'flooding'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 401 alice ghost :No such nick/channel')]),
+    ]);
+  });
+
+  it('does not emit a Disconnect when the target is unknown', () => {
+    const oper = makeOper();
+    const ctx = makeCtx(oper);
+
+    const out = killReducer(undefined, kill('ghost', 'flooding'), ctx);
+
+    expect(out.effects.some((e) => e.tag === 'Disconnect')).toBe(false);
+  });
+});

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

@@ -0,0 +1,368 @@
+import { describe, expect, it } from 'vitest';
+import { lusersReducer } from '../../src/commands/lusers';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  SequentialIdFactory,
+  type ServerStatsSnapshot,
+} from '../../src/ports';
+import { 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(connId = 'c1', nick = 'alice', clock = new FakeClock(5_000)): Ctx {
+  const conn = createConnection({ id: connId, connectedSince: 0 });
+  conn.nick = nick;
+  conn.user = nick;
+  conn.host = 'example.com';
+  conn.realname = 'Alice';
+  conn.registration = 'registered';
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const lusers = (...params: string[]) =>
+  ({
+    command: 'LUSERS',
+    params,
+    tags: {},
+  }) as const;
+
+const snap = (overrides: Partial<ServerStatsSnapshot> = {}): ServerStatsSnapshot => ({
+  users: 2,
+  invisible: 1,
+  opers: 0,
+  unknownConnections: 0,
+  channels: 0,
+  servers: 1,
+  localConns: 3,
+  globalConns: 3,
+  maxLocalConns: 5,
+  maxGlobalConns: 5,
+  uptimeStartedAt: 1_000,
+  ...overrides,
+});
+
+// ============================================================================
+// lusersReducer — 251–255 baseline
+// ============================================================================
+
+describe('lusersReducer — 251–255 baseline', () => {
+  it('emits 251 RPL_LUSERCLIENT with the visible/invisible/server counts', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap(), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [
+        L(':irc.example.com 251 alice :There are 2 users and 1 invisible on 1 servers'),
+      ]),
+    );
+  });
+
+  it('emits 255 RPL_LUSERME with the local client/server counts', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap(), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 255 alice :I have 3 clients and 1 servers')]),
+    );
+  });
+
+  it('updates the requester lastSeen to ctx.clock.now()', () => {
+    const ctx = makeCtx();
+    expect(ctx.connection.lastSeen).toBe(0);
+
+    lusersReducer(snap(), lusers(), ctx);
+
+    expect(ctx.connection.lastSeen).toBe(5_000);
+  });
+
+  it('uses "*" as the nick when the requester has none', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.registration = 'registered';
+    const ctx = buildCtx({
+      serverConfig,
+      clock: new FakeClock(5_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: conn,
+    });
+
+    const out = lusersReducer(snap(), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [
+        L(':irc.example.com 251 * :There are 2 users and 1 invisible on 1 servers'),
+      ]),
+    );
+  });
+});
+
+// ============================================================================
+// lusersReducer — non-zero omission (RFC: only emit 252/253/254 when non-zero)
+// ============================================================================
+
+describe('lusersReducer — non-zero omission', () => {
+  it('emits 252 RPL_LUSEROP when opers is non-zero', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ opers: 2 }), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 252 alice 2 :operator(s) online')]),
+    );
+  });
+
+  it('omits 252 when opers is zero', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ opers: 0 }), lusers(), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).not.toContain(' 252 ');
+  });
+
+  it('emits 253 RPL_LUSERUNKNOWN when unknownConnections is non-zero', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ unknownConnections: 4 }), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 253 alice 4 :unknown connection(s)')]),
+    );
+  });
+
+  it('omits 253 when unknownConnections is zero', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ unknownConnections: 0 }), lusers(), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).not.toContain(' 253 ');
+  });
+
+  it('emits 254 RPL_LUSERCHANNELS when channels is non-zero', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ channels: 7 }), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 254 alice 7 :channel(s) formed')]),
+    );
+  });
+
+  it('omits 254 when channels is zero', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ channels: 0 }), lusers(), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).not.toContain(' 254 ');
+  });
+});
+
+// ============================================================================
+// lusersReducer — 265/266 local/global context
+// ============================================================================
+
+describe('lusersReducer — 265/266 local/global', () => {
+  it('emits 265 RPL_LOCALUSERS with the current and max local counts', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ localConns: 3, maxLocalConns: 5 }), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 265 alice 3 5 :Current local users 3, max 5')]),
+    );
+  });
+
+  it('emits 266 RPL_GLOBALUSERS with the current and max global counts', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap({ globalConns: 3, maxGlobalConns: 5 }), lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 266 alice 3 5 :Current global users 3, max 5')]),
+    );
+  });
+
+  it('always emits 265 and 266 (modern clients rely on them for the user list count)', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap(), lusers(), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).toContain(' 265 ');
+    expect(text).toContain(' 266 ');
+  });
+});
+
+// ============================================================================
+// lusersReducer — empty deployment
+// ============================================================================
+
+describe('lusersReducer — empty deployment', () => {
+  it('still emits 251 and 255 reporting zero counts', () => {
+    const ctx = makeCtx();
+    const empty: ServerStatsSnapshot = {
+      users: 0,
+      invisible: 0,
+      opers: 0,
+      unknownConnections: 0,
+      channels: 0,
+      servers: 1,
+      localConns: 0,
+      globalConns: 0,
+      maxLocalConns: 0,
+      maxGlobalConns: 0,
+      uptimeStartedAt: 1_000,
+    };
+
+    const out = lusersReducer(empty, lusers(), ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [
+        L(':irc.example.com 251 alice :There are 0 users and 0 invisible on 1 servers'),
+      ]),
+    );
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 255 alice :I have 0 clients and 1 servers')]),
+    );
+  });
+});
+
+// ============================================================================
+// lusersReducer — remote server target
+// ============================================================================
+
+describe('lusersReducer — remote server target', () => {
+  it('emits 402 ERR_NOSUCHSERVER when the actor flags a non-local server target', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap(), lusers('remote.example.org'), ctx, 'remote.example.org');
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 402 alice remote.example.org :No such server')]),
+    ]);
+  });
+
+  it('uses "*" as the nick in 402 when the requester has none', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.registration = 'registered';
+    const ctx = buildCtx({
+      serverConfig,
+      clock: new FakeClock(5_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: conn,
+    });
+
+    const out = lusersReducer(snap(), lusers('remote.example.org'), ctx, 'remote.example.org');
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 402 * remote.example.org :No such server')]),
+    ]);
+  });
+
+  it('does not emit 402 when no serverTarget is flagged', () => {
+    const ctx = makeCtx();
+
+    const out = lusersReducer(snap(), lusers(), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).not.toContain(' 402 ');
+  });
+});
+
+// ============================================================================
+// lusersReducer — ordering
+// ============================================================================
+
+describe('lusersReducer — ordering', () => {
+  it('emits numerics in ascending code order (251, 252, 253, 254, 255, 265, 266)', () => {
+    const ctx = makeCtx();
+    const populated = snap({
+      opers: 1,
+      unknownConnections: 1,
+      channels: 1,
+    });
+
+    const out = lusersReducer(populated, lusers(), ctx);
+
+    const codes: number[] = [];
+    for (const e of out.effects) {
+      if (e.tag !== 'Send') continue;
+      for (const line of e.lines) {
+        const m = line.text.match(/\s(\d{3})\s/);
+        if (m) codes.push(Number(m[1]));
+      }
+    }
+    expect(codes).toEqual([251, 252, 253, 254, 255, 265, 266]);
+  });
+});
+
+// ============================================================================
+// lusersReducer — "*" nick fallback for count/usage lines
+// ============================================================================
+
+describe('lusersReducer — "*" nick fallback for count/usage lines', () => {
+  it('uses "*" in 252/253/254/265/266 when the requester has no nick', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.registration = 'registered';
+    const ctx = buildCtx({
+      serverConfig,
+      clock: new FakeClock(5_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: conn,
+    });
+
+    const out = lusersReducer(
+      snap({ opers: 1, unknownConnections: 1, channels: 1 }),
+      lusers(),
+      ctx,
+    );
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    // Every emitted numeric uses "*" as the requester nick.
+    expect(text).toContain(' 252 * 1 ');
+    expect(text).toContain(' 253 * 1 ');
+    expect(text).toContain(' 254 * 1 ');
+    expect(text).toContain(' 265 * 3 5 ');
+    expect(text).toContain(' 266 * 3 5 ');
+  });
+});

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

@@ -200,6 +200,36 @@ describe('channelModeReducer — prefix modes', () => {
     ]);
   });
 
+  it('+oo <nick1> <nick2> grants op to both members in one combined delta', () => {
+    // Exercises the already-initialized branch of `pushMembershipChange`:
+    // the second membership push reuses the `delta.memberships` array the
+    // first one created.
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    addMember(chan, 'c3', 'carol');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+oo', 'bob', 'carol'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.members.get('c2')?.op).toBe(true);
+    expect(chan.members.get('c3')?.op).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', {
+        memberships: [
+          { type: 'add', conn: 'c2', nick: 'bob', op: true, voice: false },
+          { type: 'add', conn: 'c3', nick: 'carol', op: true, voice: false },
+        ],
+      }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo +oo bob carol')]),
+    ]);
+  });
+
   it('-o <nick> removes op from the named member', () => {
     const chan = makeChan('#foo');
     addMember(chan, 'c1', 'alice', true);
@@ -483,6 +513,33 @@ describe('channelModeReducer — ban masks', () => {
     ]);
   });
 
+  it('+bb <mask1> <mask2> adds both masks in one combined delta', () => {
+    // Exercises the already-initialized branch of `pushBanMaskChange`: the
+    // second ban push reuses the `delta.banMaskChanges` array the first one
+    // created.
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+bb', 'bob!*@*', 'carol!*@*'], tags: {} },
+      ctx,
+    );
+
+    expect([...chan.banMasks]).toEqual(['bob!*@*', 'carol!*@*']);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', {
+        banMaskChanges: [
+          { type: 'add', mask: 'bob!*@*' },
+          { type: 'add', mask: 'carol!*@*' },
+        ],
+      }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo +bb bob!*@* carol!*@*')]),
+    ]);
+  });
+
   it('-b <mask> removes from the ban list', () => {
     const chan = makeChan('#foo');
     chan.banMasks.add('bob!*@*');