serverless-ircd 0.4.0 → 0.6.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/rehash.test.ts

@@ -0,0 +1,171 @@
+import { describe, expect, it } from 'vitest';
+import { buildRehashTrailing, rehashLine, rehashReducer } from '../../src/commands/rehash';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import type { IrcMessage } from '../../src/protocol/messages';
+import { type ConnectionState, createConnection } from '../../src/state/connection';
+import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
+
+const baseServerConfig: ServerConfig = {
+  serverName: 'irc.example.com',
+  networkName: 'ExampleNet',
+  maxChannelsPerUser: 30,
+  maxTargetsPerCommand: 10,
+  maxListEntries: 50,
+  nickLen: 30,
+  channelLen: 50,
+  topicLen: 390,
+  quitMessage: 'Client Quit',
+};
+
+function makeCtx(state: ConnectionState, config: ServerConfig = baseServerConfig): Ctx {
+  return buildCtx({
+    serverConfig: config,
+    clock: new FakeClock(5_000),
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: state,
+  });
+}
+
+function makeState(oper = false): ConnectionState {
+  const s = createConnection({ id: 'c1', connectedSince: 0 });
+  s.nick = 'alice';
+  s.user = 'alice';
+  s.host = 'example.com';
+  s.realname = 'Alice';
+  s.registration = 'registered';
+  s.userModes.oper = oper;
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const rehash = (): IrcMessage => ({ command: 'REHASH', params: [], tags: {} });
+
+describe('rehashReducer — oper gating', () => {
+  it('emits 382 RPL_REHASHING and signals reload when the caller is oper', () => {
+    const state = makeState(true);
+    const ctx = makeCtx(state);
+
+    const out = rehashReducer(state, rehash(), ctx, 'KV');
+
+    expect(out.shouldReload).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 382 alice :Rehashing from KV')]),
+    ]);
+  });
+
+  it('emits 481 ERR_NOPRIVILEGES and does not signal reload for a non-oper', () => {
+    const state = makeState(false);
+    const ctx = makeCtx(state);
+
+    const out = rehashReducer(state, rehash(), ctx, 'KV');
+
+    expect(out.shouldReload).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 alice :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+
+  it('accepts a lower-case command token', () => {
+    const state = makeState(true);
+    const ctx = makeCtx(state);
+
+    const out = rehashReducer(state, { command: 'rehash', params: [], tags: {} }, ctx, 'KV');
+    expect(out.shouldReload).toBe(true);
+  });
+});
+
+describe('rehashReducer — state handling', () => {
+  it('returns the same state reference (mutation permitted, no copy)', () => {
+    const state = makeState(true);
+    const ctx = makeCtx(state);
+
+    const out = rehashReducer(state, rehash(), ctx, 'KV');
+
+    expect(out.state).toBe(state);
+  });
+
+  it('updates connection lastSeen to ctx.clock.now()', () => {
+    const state = makeState(true);
+    expect(state.lastSeen).toBe(0);
+    const ctx = makeCtx(state);
+
+    rehashReducer(state, rehash(), ctx, 'KV');
+
+    expect(state.lastSeen).toBe(5_000);
+  });
+
+  it('also updates lastSeen for the non-oper rejection path', () => {
+    const state = makeState(false);
+    const ctx = makeCtx(state);
+
+    rehashReducer(state, rehash(), ctx, 'KV');
+
+    expect(state.lastSeen).toBe(5_000);
+  });
+
+  it('uses "*" as the nick in 382 when the connection has no nick', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    state.userModes.oper = true;
+    const ctx = makeCtx(state);
+
+    const out = rehashReducer(state, rehash(), ctx, 'KV');
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 382 * :Rehashing from KV')]),
+    ]);
+  });
+
+  it('uses "*" as the nick in 481 when an unregistered non-oper has no nick', () => {
+    const state = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(state);
+
+    const out = rehashReducer(state, rehash(), ctx, 'KV');
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 * :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+
+  it('reflects the configured source label in the 382 trailing text', () => {
+    const state = makeState(true);
+    const ctx = makeCtx(state);
+
+    const out = rehashReducer(state, rehash(), ctx, 'Secrets Manager');
+
+    expect((out.effects[0] as { lines: RawLine[] }).lines[0]?.text).toContain(
+      ':Rehashing from Secrets Manager',
+    );
+  });
+});
+
+describe('rehash formatting helpers', () => {
+  it('buildRehashTrailing composes the success phrase from the source label', () => {
+    expect(buildRehashTrailing('config file')).toBe('Rehashing from config file');
+  });
+
+  it('buildRehashTrailing appends the error suffix when supplied', () => {
+    expect(buildRehashTrailing('KV', 'store unreachable')).toBe(
+      'Rehashing from KV failed: store unreachable',
+    );
+  });
+
+  it('rehashLine renders the full :server 382 nick :trailing wire line', () => {
+    expect(rehashLine('irc.example.com', 'alice', 'KV')).toEqual(
+      L(':irc.example.com 382 alice :Rehashing from KV'),
+    );
+  });
+
+  it('rehashLine renders the error-suffixed line for the failure path', () => {
+    expect(rehashLine('irc.example.com', 'alice', 'KV', 'boom')).toEqual(
+      L(':irc.example.com 382 alice :Rehashing from KV failed: boom'),
+    );
+  });
+});