serverless-ircd 0.1.0

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

@@ -0,0 +1,186 @@
+import { describe, expect, it } from 'vitest';
+import { emitChghost } from '../../src/commands/chghost';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { type ConnectionState, createConnection } from '../../src/state/connection';
+
+const L = (text: string): RawLine => ({ text });
+
+function makeConn(id = 'c1', nick = 'alice'): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = 'olduser';
+  s.host = 'oldhost.example.com';
+  s.realname = 'Alice';
+  s.registration = 'registered';
+  return s;
+}
+
+describe('emitChghost', () => {
+  it('emits a cap-split Broadcast per joined channel for a host change', () => {
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+    conn.joinedChannels.add('#bar');
+
+    const effects = emitChghost({
+      conn,
+      oldUser: 'olduser',
+      oldHost: 'oldhost.example.com',
+      newUser: 'newuser',
+      newHost: 'newhost.example.com',
+    });
+
+    expect(effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [], undefined, 'chghost', [
+        L(':alice!olduser@oldhost.example.com CHGHOST newuser :newhost.example.com'),
+      ]),
+      Effect.broadcast('#bar', [], undefined, 'chghost', [
+        L(':alice!olduser@oldhost.example.com CHGHOST newuser :newhost.example.com'),
+      ]),
+    ]);
+  });
+
+  it('emits a CHGHOST when only the host changes', () => {
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitChghost({
+      conn,
+      oldUser: 'olduser',
+      oldHost: 'oldhost.example.com',
+      newUser: 'olduser',
+      newHost: 'cloaked.example.com',
+    });
+
+    expect(effects).toHaveLength(1);
+    const bcast = effects[0];
+    expect(bcast?.tag).toBe('Broadcast');
+    if (bcast?.tag === 'Broadcast') {
+      expect(bcast.capLines?.[0]?.text).toBe(
+        ':alice!olduser@oldhost.example.com CHGHOST olduser :cloaked.example.com',
+      );
+    }
+  });
+
+  it('emits a CHGHOST when only the user changes', () => {
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitChghost({
+      conn,
+      oldUser: 'olduser',
+      oldHost: 'oldhost.example.com',
+      newUser: 'newuser',
+      newHost: 'oldhost.example.com',
+    });
+
+    expect(effects).toHaveLength(1);
+    const bcast = effects[0];
+    if (bcast?.tag === 'Broadcast') {
+      expect(bcast.capLines?.[0]?.text).toBe(
+        ':alice!olduser@oldhost.example.com CHGHOST newuser :oldhost.example.com',
+      );
+    }
+  });
+
+  it('emits nothing when neither user nor host changed', () => {
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitChghost({
+      conn,
+      oldUser: 'olduser',
+      oldHost: 'oldhost.example.com',
+      newUser: 'olduser',
+      newHost: 'oldhost.example.com',
+    });
+
+    expect(effects).toEqual([]);
+  });
+
+  it('emits nothing before registration completes', () => {
+    const conn = makeConn();
+    conn.registration = 'pre-registration';
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitChghost({
+      conn,
+      oldUser: 'olduser',
+      oldHost: 'oldhost.example.com',
+      newUser: 'newuser',
+      newHost: 'newhost.example.com',
+    });
+
+    expect(effects).toEqual([]);
+  });
+
+  it('emits nothing during registration', () => {
+    const conn = makeConn();
+    conn.registration = 'registering';
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitChghost({
+      conn,
+      oldUser: 'olduser',
+      oldHost: 'oldhost.example.com',
+      newUser: 'newuser',
+      newHost: 'newhost.example.com',
+    });
+
+    expect(effects).toEqual([]);
+  });
+
+  it('emits nothing when the connection has no joined channels', () => {
+    const conn = makeConn();
+
+    const effects = emitChghost({
+      conn,
+      oldUser: 'olduser',
+      oldHost: 'oldhost.example.com',
+      newUser: 'newuser',
+      newHost: 'newhost.example.com',
+    });
+
+    expect(effects).toEqual([]);
+  });
+
+  it('uses empty lines so non-cap peers receive nothing', () => {
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitChghost({
+      conn,
+      oldUser: 'olduser',
+      oldHost: 'oldhost.example.com',
+      newUser: 'newuser',
+      newHost: 'newhost.example.com',
+    });
+
+    const bcast = effects[0];
+    if (bcast?.tag === 'Broadcast') {
+      expect(bcast.lines).toEqual([]);
+      expect(bcast.cap).toBe('chghost');
+    }
+  });
+
+  it('falls back to ? for nick when absent', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.registration = 'registered';
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitChghost({
+      conn,
+      oldUser: 'olduser',
+      oldHost: 'oldhost.example.com',
+      newUser: 'newuser',
+      newHost: 'newhost.example.com',
+    });
+
+    const bcast = effects[0];
+    if (bcast?.tag === 'Broadcast') {
+      expect(bcast.capLines?.[0]?.text).toBe(
+        ':?!olduser@oldhost.example.com CHGHOST newuser :newhost.example.com',
+      );
+    }
+  });
+});

package/packages/irc-core/tests/commands/echo-message.test.ts

@@ -0,0 +1,212 @@
+import { describe, expect, it } from 'vitest';
+import {
+  noticeChannelReducer,
+  noticeUserReducer,
+  privmsgChannelReducer,
+  privmsgUserReducer,
+} from '../../src/commands/privmsg';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import { type ChannelState, createChannel } from '../../src/state/channel';
+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(1_000)): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+function makeConn(id = 'c1', nick = 'alice', caps: ReadonlyArray<string> = []): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = nick;
+  s.host = 'example.com';
+  s.realname = nick.charAt(0).toUpperCase() + nick.slice(1);
+  s.registration = 'registered';
+  for (const c of caps) s.caps.add(c);
+  return s;
+}
+
+function makeChan(name = '#foo'): ChannelState {
+  return createChannel({ name, nameLower: name.toLowerCase(), createdAt: 0 });
+}
+
+function addMember(chan: ChannelState, connId: string, nick: string): void {
+  chan.members.set(connId, { conn: connId, nick, op: false, voice: false });
+}
+
+const L = (text: string): RawLine => ({ text });
+
+// ============================================================================
+// echo-message — channel path
+// ============================================================================
+
+describe('echo-message — channel PRIVMSG', () => {
+  it('does NOT echo when the sender lacks the echo-message cap', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [L(':alice!alice@example.com PRIVMSG #foo :hi')], 'c1'),
+    ]);
+  });
+
+  it('echoes the PRIVMSG back to the sender AFTER the broadcast when the cap is set', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn('c1', 'alice', ['echo-message']);
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [L(':alice!alice@example.com PRIVMSG #foo :hi')], 'c1'),
+      Effect.send('c1', [L(':alice!alice@example.com PRIVMSG #foo :hi')]),
+    ]);
+  });
+
+  it('echoes NOTICE back to the sender when the cap is set', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn('c1', 'alice', ['echo-message']);
+    const ctx = makeCtx(conn);
+
+    const out = noticeChannelReducer(
+      chan,
+      { command: 'NOTICE', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [L(':alice!alice@example.com NOTICE #foo :hi')], 'c1'),
+      Effect.send('c1', [L(':alice!alice@example.com NOTICE #foo :hi')]),
+    ]);
+  });
+
+  it('does not echo on error paths (no recipient)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn('c1', 'alice', ['echo-message']);
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(chan, { command: 'PRIVMSG', params: [], tags: {} }, ctx);
+
+    // Only the 411 error; no broadcast, no echo.
+    expect(out.effects.length).toBe(1);
+    expect(out.effects[0]?.tag).toBe('Send');
+  });
+
+  it('does not echo on +m rejection', () => {
+    const chan = makeChan('#foo');
+    chan.modes.moderated = true;
+    addMember(chan, 'c1', 'alice'); // not opped/voiced
+    const conn = makeConn('c1', 'alice', ['echo-message']);
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    // Only the 404 error; no broadcast, no echo.
+    expect(out.effects.length).toBe(1);
+    expect(out.effects[0]?.tag).toBe('Send');
+  });
+});
+
+// ============================================================================
+// echo-message — user (PM) path
+// ============================================================================
+
+describe('echo-message — user PRIVMSG', () => {
+  it('does NOT echo when the sender lacks the echo-message cap', () => {
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = privmsgUserReducer(
+      conn,
+      { command: 'PRIVMSG', params: ['bob', 'hi'], tags: {} },
+      ctx,
+    );
+
+    // Just SendToNick; no echo.
+    expect(out.effects.length).toBe(1);
+    expect(out.effects[0]?.tag).toBe('SendToNick');
+  });
+
+  it('echoes the PRIVMSG back to the sender AFTER SendToNick when the cap is set', () => {
+    const conn = makeConn('c1', 'alice', ['echo-message']);
+    const ctx = makeCtx(conn);
+
+    const out = privmsgUserReducer(
+      conn,
+      { command: 'PRIVMSG', params: ['bob', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects.length).toBe(2);
+    expect(out.effects[0]?.tag).toBe('SendToNick');
+    expect(out.effects[1]).toEqual(
+      Effect.send('c1', [L(':alice!alice@example.com PRIVMSG bob :hi')]),
+    );
+  });
+
+  it('echoes NOTICE back to the sender when the cap is set', () => {
+    const conn = makeConn('c1', 'alice', ['echo-message']);
+    const ctx = makeCtx(conn);
+
+    const out = noticeUserReducer(
+      conn,
+      { command: 'NOTICE', params: ['bob', 'hi'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects.length).toBe(2);
+    expect(out.effects[0]?.tag).toBe('SendToNick');
+    expect(out.effects[1]).toEqual(
+      Effect.send('c1', [L(':alice!alice@example.com NOTICE bob :hi')]),
+    );
+  });
+
+  it('does not echo on missing-text error path', () => {
+    const conn = makeConn('c1', 'alice', ['echo-message']);
+    const ctx = makeCtx(conn);
+
+    const out = privmsgUserReducer(conn, { command: 'PRIVMSG', params: ['bob'], tags: {} }, ctx);
+
+    // Only the 412 error; no SendToNick, no echo.
+    expect(out.effects.length).toBe(1);
+    expect(out.effects[0]?.tag).toBe('Send');
+  });
+});

package/packages/irc-core/tests/commands/extended-join.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it } from 'vitest';
+import { joinReducer } from '../../src/commands/join';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import { type ChannelState, createChannel } from '../../src/state/channel';
+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(1_000)): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+function makeConn(id = 'c1', nick = 'alice'): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = nick;
+  s.host = 'example.com';
+  s.realname = nick.charAt(0).toUpperCase() + nick.slice(1);
+  s.registration = 'registered';
+  return s;
+}
+
+function makeChan(name = '#foo'): ChannelState {
+  return createChannel({ name, nameLower: name.toLowerCase(), createdAt: 0 });
+}
+
+const L = (text: string): RawLine => ({ text });
+
+describe('extended-join — JOIN broadcast format', () => {
+  it('emits a cap-split broadcast with the extended JOIN line for cap-enabled recipients', () => {
+    const chan = makeChan('#foo');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.broadcast(
+        '#foo',
+        [L(':alice!alice@example.com JOIN #foo')],
+        undefined,
+        'extended-join',
+        [L(':alice!alice@example.com JOIN #foo _ :Alice')],
+      ),
+    );
+  });
+
+  it('uses the authenticated account name when the joiner has one', () => {
+    const chan = makeChan('#foo');
+    const conn = makeConn();
+    conn.account = 'alice-account';
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.broadcast(
+        '#foo',
+        [L(':alice!alice@example.com JOIN #foo')],
+        undefined,
+        'extended-join',
+        [L(':alice!alice@example.com JOIN #foo alice-account :Alice')],
+      ),
+    );
+  });
+
+  it('uses _ as the account when the joiner is not authenticated', () => {
+    const chan = makeChan('#foo');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    expect(broadcast?.cap).toBe('extended-join');
+    expect(broadcast?.capLines?.[0]?.text).toBe(':alice!alice@example.com JOIN #foo _ :Alice');
+  });
+
+  it('still emits the legacy JOIN line for non-cap recipients', () => {
+    const chan = makeChan('#foo');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    expect(broadcast?.lines).toEqual<RawLine[]>([L(':alice!alice@example.com JOIN #foo')]);
+  });
+
+  it('includes the joiner in the broadcast (no except)', () => {
+    const chan = makeChan('#foo');
+    const conn = makeConn();
+    conn.caps.add('extended-join');
+    const ctx = makeCtx(conn);
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    expect(broadcast?.except).toBeUndefined();
+  });
+
+  it('omits @host from the extended JOIN prefix when host is absent', () => {
+    const chan = makeChan('#foo');
+    const conn = makeConn();
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes forbids `= undefined`.
+    delete conn.host;
+    const ctx = makeCtx(conn);
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    expect(broadcast?.capLines?.[0]?.text).toBe(':alice!alice JOIN #foo _ :Alice');
+  });
+
+  it('falls back to legacy-only broadcast when realname is absent', () => {
+    const chan = makeChan('#foo');
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.nick = '?';
+    const ctx = makeCtx(conn);
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    expect(broadcast?.cap).toBeUndefined();
+    expect(broadcast?.capLines).toBeUndefined();
+    expect(broadcast?.lines).toEqual<RawLine[]>([L(':? JOIN #foo')]);
+  });
+});