serverless-ircd 0.5.0 → 0.6.0

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

@@ -6,7 +6,9 @@ import {
   EmptyMotdProvider,
   FakeClock,
   InMemoryMessageStore,
+  InMemoryReadMarkerStore,
   type MessageStore,
+  type ReadMarkerStore,
   SequentialIdFactory,
   type StoredMessage,
 } from '../../src/ports';
@@ -30,6 +32,7 @@ function makeCtx(
   conn: ConnectionState,
   clock = new FakeClock(1_000),
   messages?: MessageStore,
+  readMarkers?: ReadMarkerStore,
 ): Ctx {
   return buildCtx({
     serverConfig,
@@ -38,6 +41,7 @@ function makeCtx(
     motd: EmptyMotdProvider,
     connection: conn,
     ...(messages !== undefined ? { messages } : {}),
+    ...(readMarkers !== undefined ? { readMarkers } : {}),
   });
 }
 
@@ -417,6 +421,328 @@ describe('tagmsgChannelReducer — echo-message', () => {
   });
 });
 
+// ============================================================================
+// tagmsgChannelReducer — draft/typing broadcast
+// ============================================================================
+//
+// IRCv3 draft/typing: a TAGMSG carrying `+draft/typing=<active|paused|done>`
+// fans out to channel members that negotiated `draft/typing` OR
+// `message-tags`. The `message-tags` path is the baseline (every TAGMSG goes
+// to message-tags peers); `draft/typing` adds the spec's client-tag
+// exception — peers that lack `message-tags` but negotiated `draft/typing`
+// still receive the typing TAGMSG. The reducer annotates the Broadcast
+// effect with `caps` (OR semantics) so dispatch routes per-recipient.
+// ============================================================================
+
+describe('tagmsgChannelReducer — draft/typing broadcast', () => {
+  it('emits a Broadcast with caps=[message-tags, draft/typing] for a +draft/typing TAGMSG', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      {
+        tag: 'Broadcast',
+        chan: '#foo',
+        lines: [L('@+draft/typing=active :alice!alice@example.com TAGMSG #foo')],
+        except: 'c1',
+        caps: ['message-tags', 'draft/typing'],
+      },
+    ]);
+  });
+
+  it('still uses cap=message-tags (single cap) for a non-typing TAGMSG', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast(
+        '#foo',
+        [L('@+typing=active :alice!alice@example.com TAGMSG #foo')],
+        'c1',
+        'message-tags',
+      ),
+    ]);
+  });
+
+  it('treats a valueless +draft/typing tag as a typing TAGMSG', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/typing': '' } },
+      ctx,
+    );
+
+    const broadcast = out.effects[0];
+    expect(broadcast?.tag).toBe('Broadcast');
+    expect((broadcast as Extract<EffectType, { tag: 'Broadcast' }>).caps).toEqual([
+      'message-tags',
+      'draft/typing',
+    ]);
+  });
+
+  it('excludes the sender unless echo-message is negotiated (typing TAGMSG)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect((out.effects[0] as Extract<EffectType, { tag: 'Broadcast' }>).except).toBe('c1');
+  });
+
+  it('echoes the typing TAGMSG back to the sender when echo-message is negotiated', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.caps.add('echo-message');
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/typing': 'active' } },
+      ctx,
+    );
+
+    const line = L('@+draft/typing=active :alice!alice@example.com TAGMSG #foo');
+    expect(out.effects).toEqual<EffectType[]>([
+      {
+        tag: 'Broadcast',
+        chan: '#foo',
+        lines: [line],
+        except: 'c1',
+        caps: ['message-tags', 'draft/typing'],
+      },
+      Effect.send('c1', [line]),
+    ]);
+  });
+});
+
+// ============================================================================
+// tagmsgChannelReducer — draft/read-marker broadcast + persistence
+// ============================================================================
+//
+// IRCv3 draft/read-marker: a TAGMSG carrying `+draft/read-marker=<msgid>`
+// marks `<msgid>` as the last read message for the sender's account in the
+// target channel. The reducer (1) persists the marker via the bound
+// ReadMarkerStore keyed by (account, channel), (2) advances the connection's
+// in-memory lastReadMarkers, and (3) fans the TAGMSG out — carrying the
+// `+draft/read-marker` tag — to members that negotiated `draft/read-marker`
+// OR `message-tags` (OR-semantics, matching the draft/typing precedent).
+// ============================================================================
+
+describe('tagmsgChannelReducer — draft/read-marker broadcast + persistence', () => {
+  it('emits a Broadcast with caps=[message-tags, draft/read-marker] carrying the tag', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm42' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      {
+        tag: 'Broadcast',
+        chan: '#foo',
+        lines: [L('@+draft/read-marker=m42 :alice!alice@example.com TAGMSG #foo')],
+        except: 'c1',
+        caps: ['message-tags', 'draft/read-marker'],
+      },
+    ]);
+  });
+
+  it('persists the marker to the ReadMarkerStore keyed by (account, channel)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.account = 'alice';
+    const store = new InMemoryReadMarkerStore();
+    const ctx = makeCtx(conn, undefined, undefined, store);
+
+    tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm7' } },
+      ctx,
+    );
+
+    expect(store.get('alice', '#foo')).toBe('m7');
+  });
+
+  it('advances the connection in-memory lastReadMarkers', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.account = 'alice';
+    const ctx = makeCtx(conn, undefined, undefined, new InMemoryReadMarkerStore());
+
+    tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm7' } },
+      ctx,
+    );
+
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m7');
+  });
+
+  it('overwrites a previously stored marker when a newer msgid arrives', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.account = 'alice';
+    const store = new InMemoryReadMarkerStore();
+    const ctx = makeCtx(conn, undefined, undefined, store);
+
+    tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm1' } },
+      ctx,
+    );
+    tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm2' } },
+      ctx,
+    );
+
+    expect(store.get('alice', '#foo')).toBe('m2');
+  });
+
+  it('does NOT persist to the store when the connection has no account', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn(); // no account
+    const store = new InMemoryReadMarkerStore();
+    const ctx = makeCtx(conn, undefined, undefined, store);
+
+    tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm1' } },
+      ctx,
+    );
+
+    expect(store.forAccount('alice')).toEqual([]);
+    // The in-memory marker still advances for the session.
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m1');
+  });
+
+  it('does NOT persist when no ReadMarkerStore is bound but still fans out', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.account = 'alice';
+    const ctx = makeCtx(conn); // no store
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm1' } },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect((out.effects[0] as Extract<EffectType, { tag: 'Broadcast' }>).caps).toEqual([
+      'message-tags',
+      'draft/read-marker',
+    ]);
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m1');
+  });
+
+  it('excludes the sender unless echo-message is negotiated', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm1' } },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect((out.effects[0] as Extract<EffectType, { tag: 'Broadcast' }>).except).toBe('c1');
+  });
+
+  it('echoes the read-marker TAGMSG back to the sender when echo-message is negotiated', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.caps.add('echo-message');
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm3' } },
+      ctx,
+    );
+
+    const line = L('@+draft/read-marker=m3 :alice!alice@example.com TAGMSG #foo');
+    expect(out.effects).toEqual<EffectType[]>([
+      {
+        tag: 'Broadcast',
+        chan: '#foo',
+        lines: [line],
+        except: 'c1',
+        caps: ['message-tags', 'draft/read-marker'],
+      },
+      Effect.send('c1', [line]),
+    ]);
+  });
+
+  it('fans out a valueless +draft/read-marker tag but persists no msgid', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.account = 'alice';
+    const store = new InMemoryReadMarkerStore();
+    const ctx = makeCtx(conn, undefined, undefined, store);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': '' } },
+      ctx,
+    );
+
+    // Broadcast still widens to draft/read-marker peers (tag is present)...
+    expect((out.effects[0] as Extract<EffectType, { tag: 'Broadcast' }>).caps).toEqual([
+      'message-tags',
+      'draft/read-marker',
+    ]);
+    // ...but nothing is persisted (no msgid to store).
+    expect(store.forAccount('alice')).toEqual([]);
+    expect(conn.lastReadMarkers?.get('#foo')).toBeUndefined();
+  });
+});
+
 // ============================================================================
 // tagmsgChannelReducer — chathistory recording
 // ============================================================================
@@ -631,6 +957,37 @@ describe('tagmsgUserReducer', () => {
     ]);
   });
 
+  it('routes a +draft/typing TAGMSG to a single nick target', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgUserReducer(
+      conn,
+      { command: 'TAGMSG', params: ['bob'], tags: { '+draft/typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.sendToNick('bob', 'c1', [
+        L('@+draft/typing=active :alice!alice@example.com TAGMSG bob'),
+      ]),
+    ]);
+  });
+
+  it('excludes the sender from the echo for a +draft/typing TAGMSG without echo-message', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgUserReducer(
+      conn,
+      { command: 'TAGMSG', params: ['bob'], tags: { '+draft/typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('SendToNick');
+  });
+
   it('updates lastSeen to ctx.clock.now()', () => {
     const conn = makeConn();
     const clock = new FakeClock(12_000);

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