serverless-ircd 0.5.0 → 0.7.0

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

@@ -119,7 +119,13 @@ describe('privmsgChannelReducer — success', () => {
     );
 
     expect(out.effects).toEqual<EffectType[]>([
-      Effect.broadcast('#foo', [L(':alice!alice@example.com PRIVMSG #foo :hello world')], 'c1'),
+      Effect.broadcast(
+        '#foo',
+        [L(':alice!alice@example.com PRIVMSG #foo :hello world')],
+        'c1',
+        'msgid',
+        [L('@msgid=nonce-0 :alice!alice@example.com PRIVMSG #foo :hello world')],
+      ),
     ]);
   });
 
@@ -140,6 +146,8 @@ describe('privmsgChannelReducer — success', () => {
         '#foo',
         [L(':alice!alice@example.com PRIVMSG #foo :hi there everyone')],
         'c1',
+        'msgid',
+        [L('@msgid=nonce-0 :alice!alice@example.com PRIVMSG #foo :hi there everyone')],
       ),
     );
   });
@@ -415,7 +423,9 @@ describe('privmsgChannelReducer — rejections', () => {
     );
 
     expect(out.effects).toEqual<EffectType[]>([
-      Effect.broadcast('#foo', [L(':? PRIVMSG #foo :hi')], 'c1'),
+      Effect.broadcast('#foo', [L(':? PRIVMSG #foo :hi')], 'c1', 'msgid', [
+        L('@msgid=nonce-0 :? PRIVMSG #foo :hi'),
+      ]),
     ]);
   });
 });
@@ -439,7 +449,9 @@ describe('noticeChannelReducer', () => {
     );
 
     expect(out.effects).toEqual<EffectType[]>([
-      Effect.broadcast('#foo', [L(':alice!alice@example.com NOTICE #foo :psst')], 'c1'),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com NOTICE #foo :psst')], 'c1', 'msgid', [
+        L('@msgid=nonce-0 :alice!alice@example.com NOTICE #foo :psst'),
+      ]),
     ]);
   });
 
@@ -676,6 +688,145 @@ describe('noticeUserReducer', () => {
   });
 });
 
+// ============================================================================
+// privmsgChannelReducer — IRCv3 msgid tag (emit @msgid=<id> on the live
+// fanout for cap-enabled peers; share the nonce with the chathistory record).
+// ============================================================================
+
+describe('privmsgChannelReducer — msgid tag', () => {
+  it('carries @msgid=<id> on the capLines delivered to msgid-cap peers', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    const bcast = out.effects[0];
+    expect(bcast?.tag).toBe('Broadcast');
+    if (bcast?.tag === 'Broadcast') {
+      expect(bcast.cap).toBe('msgid');
+      expect(bcast.capLines?.[0]?.text).toBe(
+        '@msgid=nonce-0 :alice!alice@example.com PRIVMSG #foo :hi',
+      );
+    }
+  });
+
+  it('leaves the legacy lines bare so non-cap peers see no msgid tag', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    const bcast = out.effects[0];
+    if (bcast?.tag === 'Broadcast') {
+      expect(bcast.lines[0]?.text).toBe(':alice!alice@example.com PRIVMSG #foo :hi');
+      expect(bcast.lines[0]?.text).not.toContain('msgid');
+    }
+  });
+
+  it('uses the same msgid on the live capLine and the chathistory record', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const ctx = makeCtx(conn, new FakeClock(1_000), store);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    const recorded = store.query({ chan: '#foo', direction: 'latest', limit: 10 });
+    expect(recorded).toHaveLength(1);
+    const recordedMsgid = (recorded[0] as StoredMessage).msgid;
+
+    const bcast = out.effects[0];
+    if (bcast?.tag === 'Broadcast') {
+      const liveText = bcast.capLines?.[0]?.text ?? '';
+      expect(liveText).toContain(`@msgid=${recordedMsgid}`);
+    }
+  });
+
+  it('still emits the msgid tag when chathistory is disabled (no MessageStore)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn); // no store
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    const bcast = out.effects[0];
+    if (bcast?.tag === 'Broadcast') {
+      expect(bcast.cap).toBe('msgid');
+      expect(bcast.capLines?.[0]?.text).toContain('@msgid=');
+    }
+  });
+
+  it('echoes the msgid-decorated line to a sender with both echo-message and msgid', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.caps.add('echo-message');
+    conn.caps.add('msgid');
+    const ctx = makeCtx(conn);
+
+    const out = privmsgChannelReducer(
+      chan,
+      { command: 'PRIVMSG', params: ['#foo', 'hi'], tags: {} },
+      ctx,
+    );
+
+    const echo = out.effects[1];
+    expect(echo?.tag).toBe('Send');
+    if (echo?.tag === 'Send') {
+      expect(echo.lines[0]?.text).toBe('@msgid=nonce-0 :alice!alice@example.com PRIVMSG #foo :hi');
+    }
+  });
+});
+
+// ============================================================================
+// noticeChannelReducer — IRCv3 msgid tag
+// ============================================================================
+
+describe('noticeChannelReducer — msgid tag', () => {
+  it('carries @msgid=<id> on the capLines delivered to msgid-cap peers', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = noticeChannelReducer(
+      chan,
+      { command: 'NOTICE', params: ['#foo', 'note'], tags: {} },
+      ctx,
+    );
+
+    const bcast = out.effects[0];
+    if (bcast?.tag === 'Broadcast') {
+      expect(bcast.cap).toBe('msgid');
+      expect(bcast.capLines?.[0]?.text).toBe(
+        '@msgid=nonce-0 :alice!alice@example.com NOTICE #foo :note',
+      );
+    }
+  });
+});
+
 // ============================================================================
 // chathistory recording — MessageStore.record is driven from the channel
 // PRIVMSG/NOTICE reducer for every accepted message.

package/packages/irc-core/tests/commands/read-marker.test.ts

@@ -0,0 +1,211 @@
+import { describe, expect, it } from 'vitest';
+import {
+  READ_MARKER_CAP,
+  READ_MARKER_TAG,
+  isReadMarkerTagmsg,
+  persistReadMarker,
+  readMarkerMsgid,
+  seedReadMarkers,
+} from '../../src/commands/read-marker';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryReadMarkerStore,
+  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 makeConn(id = 'c1', account?: string): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = 'alice';
+  s.user = 'alice';
+  s.host = 'example.com';
+  s.registration = 'registered';
+  if (account !== undefined) s.account = account;
+  return s;
+}
+
+function makeCtx(conn: ConnectionState, readMarkers?: InMemoryReadMarkerStore): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock: new FakeClock(1_000),
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+    ...(readMarkers !== undefined ? { readMarkers } : {}),
+  });
+}
+
+// ============================================================================
+// constants
+// ============================================================================
+
+describe('read-marker constants', () => {
+  it('exposes the draft/read-marker cap name', () => {
+    expect(READ_MARKER_CAP).toBe('draft/read-marker');
+  });
+
+  it('exposes the +draft/read-marker client-tag key', () => {
+    expect(READ_MARKER_TAG).toBe('+draft/read-marker');
+  });
+});
+
+// ============================================================================
+// isReadMarkerTagmsg
+// ============================================================================
+
+describe('isReadMarkerTagmsg', () => {
+  it('returns true when the +draft/read-marker tag is present', () => {
+    expect(isReadMarkerTagmsg({ '+draft/read-marker': 'm1' })).toBe(true);
+  });
+
+  it('returns true when the tag is valueless', () => {
+    expect(isReadMarkerTagmsg({ '+draft/read-marker': '' })).toBe(true);
+  });
+
+  it('returns false when the tag is absent', () => {
+    expect(isReadMarkerTagmsg({ '+draft/typing': 'active' })).toBe(false);
+  });
+
+  it('returns false for an empty tag bag', () => {
+    expect(isReadMarkerTagmsg({})).toBe(false);
+  });
+});
+
+// ============================================================================
+// readMarkerMsgid
+// ============================================================================
+
+describe('readMarkerMsgid', () => {
+  it('returns the value of the +draft/read-marker tag', () => {
+    expect(readMarkerMsgid({ '+draft/read-marker': 'm42' })).toBe('m42');
+  });
+
+  it('returns undefined when the tag is valueless', () => {
+    expect(readMarkerMsgid({ '+draft/read-marker': '' })).toBeUndefined();
+  });
+
+  it('returns undefined when the tag is absent', () => {
+    expect(readMarkerMsgid({ '+draft/typing': 'active' })).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// persistReadMarker
+// ============================================================================
+
+describe('persistReadMarker', () => {
+  it('writes the marker to the store keyed by (account, channel)', () => {
+    const store = new InMemoryReadMarkerStore();
+    const ctx = makeCtx(makeConn('c1', 'alice'), store);
+
+    persistReadMarker(ctx, '#foo', 'm7');
+
+    expect(store.get('alice', '#foo')).toBe('m7');
+  });
+
+  it('also advances the connection in-memory lastReadMarkers', () => {
+    const store = new InMemoryReadMarkerStore();
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn, store);
+
+    persistReadMarker(ctx, '#foo', 'm7');
+
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m7');
+  });
+
+  it('overwrites a previously stored marker for the same pair', () => {
+    const store = new InMemoryReadMarkerStore();
+    const ctx = makeCtx(makeConn('c1', 'alice'), store);
+
+    persistReadMarker(ctx, '#foo', 'm1');
+    persistReadMarker(ctx, '#foo', 'm2');
+
+    expect(store.get('alice', '#foo')).toBe('m2');
+  });
+
+  it('is a no-op when no ReadMarkerStore is bound', () => {
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn); // no store
+
+    persistReadMarker(ctx, '#foo', 'm1');
+
+    // In-memory marker still advances so the connection's own session tracks it.
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m1');
+  });
+
+  it('is a no-op on the store when the connection has no account', () => {
+    const store = new InMemoryReadMarkerStore();
+    const conn = makeConn('c1'); // no account
+    const ctx = makeCtx(conn, store);
+
+    persistReadMarker(ctx, '#foo', 'm1');
+
+    expect(store.get('alice', '#foo')).toBeUndefined();
+    expect(store.forAccount('alice')).toEqual([]);
+  });
+});
+
+// ============================================================================
+// seedReadMarkers
+// ============================================================================
+
+describe('seedReadMarkers', () => {
+  it('populates lastReadMarkers from every persisted entry for the account', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('alice', '#foo', 'm1');
+    store.set('alice', '#bar', 'm2');
+    const conn = makeConn();
+
+    seedReadMarkers(conn, store, 'alice');
+
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m1');
+    expect(conn.lastReadMarkers?.get('#bar')).toBe('m2');
+  });
+
+  it('leaves existing in-memory markers untouched when the store is empty', () => {
+    const store = new InMemoryReadMarkerStore();
+    const conn = makeConn();
+    conn.lastReadMarkers = new Map<string, string>([['#foo', 'm9']]);
+
+    seedReadMarkers(conn, store, 'alice');
+
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m9');
+  });
+
+  it('seeds markers for an account regardless of case spelling', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('Alice', '#foo', 'm1');
+    const conn = makeConn();
+
+    seedReadMarkers(conn, store, 'alice');
+
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m1');
+  });
+
+  it('does not overwrite an in-memory marker already present for a channel', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('alice', '#foo', 'stored');
+    const conn = makeConn();
+    conn.lastReadMarkers = new Map<string, string>([['#foo', 'in-memory']]);
+
+    seedReadMarkers(conn, store, 'alice');
+
+    // The in-memory (session) marker wins: the connection may have already
+    // advanced past the persisted value this session.
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('in-memory');
+  });
+});

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

@@ -1102,3 +1102,67 @@ function expectedWelcomeWithHost(nick: string, hostmask: string): RawLine[] {
     L(`${prefix} 422 ${nick} :MOTD File is missing`),
   ];
 }
+
+// ============================================================================
+// emitWelcomeIfReady — user mode `S` (TLS connected)
+// ============================================================================
+
+describe('emitWelcomeIfReady — user mode `S` (TLS connected)', () => {
+  it('sets user mode `S` (tls) at registration when the transport is secure', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    state.host = 'example.com';
+    state.realname = 'Alice';
+    state.secure = true;
+    const ctx = makeCtx(state);
+
+    emitWelcomeIfReady(state, ctx);
+
+    expect(state.registration).toBe('registered');
+    expect(state.userModes.tls).toBe(true);
+  });
+
+  it('does not set user mode `S` when the transport is not secure', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    state.host = 'example.com';
+    state.realname = 'Alice';
+    state.secure = false;
+    const ctx = makeCtx(state);
+
+    emitWelcomeIfReady(state, ctx);
+
+    expect(state.registration).toBe('registered');
+    expect(state.userModes.tls).toBe(false);
+  });
+
+  it('does not set user mode `S` when secure is absent (default plain transport)', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    state.host = 'example.com';
+    state.realname = 'Alice';
+    const ctx = makeCtx(state);
+
+    emitWelcomeIfReady(state, ctx);
+
+    expect(state.registration).toBe('registered');
+    expect(state.userModes.tls).toBe(false);
+  });
+
+  it('completes registration over TLS via the NICK reducer end-to-end', () => {
+    const state = makeState();
+    state.user = 'alice';
+    state.realname = 'Alice';
+    state.registration = 'registering';
+    state.secure = true;
+    const ctx = makeCtx(state);
+
+    const out = nickReducer(state, { command: 'NICK', params: ['alice'], tags: {} }, ctx);
+
+    expect(out.state.registration).toBe('registered');
+    expect(out.state.userModes.tls).toBe(true);
+  });
+});

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

@@ -4,8 +4,21 @@ import { capReducer } from '../../src/commands/cap';
 import { authenticateReducer } from '../../src/commands/sasl';
 import { Effect } from '../../src/effects';
 import type { Effect as EffectType, RawLine } from '../../src/effects';
-import type { AccountStore, MtlsIdentityProvider, SaslPayload, SaslResult } from '../../src/ports';
-import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import type {
+  AccountStore,
+  AwayStore,
+  MtlsIdentityProvider,
+  ReadMarkerStore,
+  SaslPayload,
+  SaslResult,
+} from '../../src/ports';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryAwayStore,
+  InMemoryReadMarkerStore,
+  SequentialIdFactory,
+} from '../../src/ports';
 import { encodeBase64 } from '../../src/protocol/base64';
 import type { IrcMessage } from '../../src/protocol/messages';
 import { type ConnectionState, createConnection } from '../../src/state/connection';
@@ -44,6 +57,8 @@ function makeCtx(
   state: ConnectionState,
   accounts?: AccountStore,
   mtlsIdentity?: MtlsIdentityProvider,
+  readMarkers?: ReadMarkerStore,
+  away?: AwayStore,
 ): Ctx {
   return buildCtx({
     serverConfig,
@@ -53,6 +68,8 @@ function makeCtx(
     connection: state,
     ...(accounts !== undefined ? { accounts } : {}),
     ...(mtlsIdentity !== undefined ? { mtlsIdentity } : {}),
+    ...(readMarkers !== undefined ? { readMarkers } : {}),
+    ...(away !== undefined ? { away } : {}),
   });
 }
 
@@ -144,6 +161,103 @@ describe('authenticateReducer — PLAIN success', () => {
     expect(state.account).toBe('alice');
   });
 
+  it('seeds lastReadMarkers from the ReadMarkerStore at identify', () => {
+    const state = saslReadyState();
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const readMarkers = new InMemoryReadMarkerStore();
+    readMarkers.set('alice', '#foo', 'm1');
+    readMarkers.set('alice', '#bar', 'm2');
+    const ctx = makeCtx(state, accounts, undefined, readMarkers);
+
+    authenticateReducer(state, authenticate('PLAIN'), ctx);
+    authenticateReducer(state, authenticate(plainPayload('alice', 'secret')), ctx);
+
+    expect(state.lastReadMarkers?.get('#foo')).toBe('m1');
+    expect(state.lastReadMarkers?.get('#bar')).toBe('m2');
+  });
+
+  it('does not seed markers for a different account', () => {
+    const state = saslReadyState();
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const readMarkers = new InMemoryReadMarkerStore();
+    readMarkers.set('bob', '#foo', 'm9');
+    const ctx = makeCtx(state, accounts, undefined, readMarkers);
+
+    authenticateReducer(state, authenticate('PLAIN'), ctx);
+    authenticateReducer(state, authenticate(plainPayload('alice', 'secret')), ctx);
+
+    expect(state.lastReadMarkers?.get('#foo')).toBeUndefined();
+  });
+
+  it('replays the persisted away reason on identify (draft/pre-away)', () => {
+    const state = saslReadyState();
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const away = new InMemoryAwayStore();
+    away.set('alice', 'brb');
+    const ctx = makeCtx(state, accounts, undefined, undefined, away);
+
+    authenticateReducer(state, authenticate('PLAIN'), ctx);
+    authenticateReducer(state, authenticate(plainPayload('alice', 'secret')), ctx);
+
+    expect(state.away).toBe('brb');
+  });
+
+  it('emits 306 RPL_NOWAWAY after identifying when an away reason is replayed', () => {
+    const state = saslReadyState();
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const away = new InMemoryAwayStore();
+    away.set('alice', 'brb');
+    const ctx = makeCtx(state, accounts, undefined, undefined, away);
+
+    authenticateReducer(state, authenticate('PLAIN'), ctx);
+    const out = authenticateReducer(state, authenticate(plainPayload('alice', 'secret')), ctx);
+
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines : []));
+    expect(texts.map((l) => l.text)).toContain(
+      ':irc.example.com 306 alice :You have been marked as being away',
+    );
+  });
+
+  it('does not replay an away reason when none is persisted', () => {
+    const state = saslReadyState();
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const away = new InMemoryAwayStore();
+    const ctx = makeCtx(state, accounts, undefined, undefined, away);
+
+    authenticateReducer(state, authenticate('PLAIN'), ctx);
+    const out = authenticateReducer(state, authenticate(plainPayload('alice', 'secret')), ctx);
+
+    expect(state.away).toBeUndefined();
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines : []));
+    expect(texts.some((l) => l.text.includes('306'))).toBe(false);
+  });
+
+  it('does not replay an away reason when no AwayStore is bound', () => {
+    const state = saslReadyState();
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const ctx = makeCtx(state, accounts); // no away store
+
+    authenticateReducer(state, authenticate('PLAIN'), ctx);
+    const out = authenticateReducer(state, authenticate(plainPayload('alice', 'secret')), ctx);
+
+    expect(state.away).toBeUndefined();
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines : []));
+    expect(texts.some((l) => l.text.includes('306'))).toBe(false);
+  });
+
+  it('looks up the persisted away reason case-insensitively', () => {
+    const state = saslReadyState();
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const away = new InMemoryAwayStore();
+    away.set('ALICE', 'brb');
+    const ctx = makeCtx(state, accounts, undefined, undefined, away);
+
+    authenticateReducer(state, authenticate('PLAIN'), ctx);
+    authenticateReducer(state, authenticate(plainPayload('alice', 'secret')), ctx);
+
+    expect(state.away).toBe('brb');
+  });
+
   it('clears the in-progress mechanism after a successful authentication', () => {
     const state = saslReadyState();
     const accounts = new FakeAccountStore({ ok: true, account: 'alice' });