serverless-ircd 0.5.0 → 0.7.0

package/packages/irc-core/tests/caps/capabilities.test.ts

@@ -14,23 +14,44 @@ describe('SUPPORTED_CAPABILITIES', () => {
     const names = SUPPORTED_CAPABILITIES.map((c) => c.name).sort();
     expect(names).toEqual(
       [
+        'account-notify',
         'account-tag',
         'away-notify',
         'batch',
         'chghost',
         'draft/chathistory',
+        'draft/multiline',
+        'draft/pre-away',
+        'draft/read-marker',
+        'draft/typing',
         'echo-message',
         'extended-join',
         'invite-notify',
+        'labeled-response',
         'message-tags',
+        'msgid',
+        'monitor',
         'multi-prefix',
         'safelist',
         'sasl',
         'server-time',
+        'standard-replies',
       ].sort(),
     );
   });
 
+  it('advertises draft/typing as a bare name (no value parameter)', () => {
+    const cap = SUPPORTED_CAPABILITIES.find((c) => c.name === 'draft/typing');
+    expect(cap).toBeDefined();
+    expect(cap?.value).toBeUndefined();
+  });
+
+  it('advertises the standard-replies cap as a bare name (no value parameter)', () => {
+    const cap = SUPPORTED_CAPABILITIES.find((c) => c.name === 'standard-replies');
+    expect(cap).toBeDefined();
+    expect(cap?.value).toBeUndefined();
+  });
+
   it('declares the sasl value as the base mechanism list (PLAIN only by default)', () => {
     const sasl = SUPPORTED_CAPABILITIES.find((c) => c.name === 'sasl');
     expect(sasl).toBeDefined();
@@ -38,9 +59,11 @@ describe('SUPPORTED_CAPABILITIES', () => {
   });
 
   it('does not attach a value to caps that have no parameter', () => {
-    // sasl is the only cap with a value.
+    // sasl and draft/multiline are the caps with a value parameter.
+    const withValue = SUPPORTED_CAPABILITIES.filter((c) => c.value !== undefined);
+    expect(withValue.map((c) => c.name).sort()).toEqual(['draft/multiline', 'sasl']);
     const noValue = SUPPORTED_CAPABILITIES.filter((c) => c.value === undefined);
-    expect(noValue.length).toBe(SUPPORTED_CAPABILITIES.length - 1);
+    expect(noValue.length).toBe(SUPPORTED_CAPABILITIES.length - withValue.length);
   });
 
   it('advertises safelist as a bare name (no value parameter)', () => {
@@ -134,6 +157,100 @@ describe('draft/chathistory advertisement', () => {
   });
 });
 
+describe('msgid advertisement', () => {
+  it('is advertised as a bare name (no value parameter)', () => {
+    const cap = SUPPORTED_CAPABILITIES.find((c) => c.name === 'msgid');
+    expect(cap).toBeDefined();
+    expect(cap?.value).toBeUndefined();
+  });
+
+  it('appears in CAP LS output as the bare token', () => {
+    expect(getLsString()).toContain('msgid');
+    expect(getLsString()).not.toContain('msgid=');
+  });
+
+  it('is ACKable via SUPPORTED_CAP_NAMES membership (CAP REQ round-trip)', () => {
+    expect(SUPPORTED_CAP_NAMES.has('msgid')).toBe(true);
+  });
+});
+
+describe('draft/typing advertisement', () => {
+  it('appears in CAP LS output as the bare token', () => {
+    expect(getLsString()).toContain('draft/typing');
+    expect(getLsString()).not.toContain('draft/typing=');
+  });
+
+  it('is ACKable via SUPPORTED_CAP_NAMES membership (CAP REQ round-trip)', () => {
+    expect(SUPPORTED_CAP_NAMES.has('draft/typing')).toBe(true);
+  });
+
+  it('is recognized by isSupportedCap', () => {
+    expect(isSupportedCap('draft/typing')).toBe(true);
+  });
+});
+
+describe('draft/read-marker advertisement', () => {
+  it('is advertised as a bare name (no value parameter)', () => {
+    const cap = SUPPORTED_CAPABILITIES.find((c) => c.name === 'draft/read-marker');
+    expect(cap).toBeDefined();
+    expect(cap?.value).toBeUndefined();
+  });
+
+  it('appears in CAP LS output as the bare token', () => {
+    expect(getLsString()).toContain('draft/read-marker');
+    expect(getLsString()).not.toContain('draft/read-marker=');
+  });
+
+  it('is ACKable via SUPPORTED_CAP_NAMES membership (CAP REQ round-trip)', () => {
+    expect(SUPPORTED_CAP_NAMES.has('draft/read-marker')).toBe(true);
+  });
+
+  it('is recognized by isSupportedCap', () => {
+    expect(isSupportedCap('draft/read-marker')).toBe(true);
+  });
+});
+
+describe('draft/pre-away advertisement', () => {
+  it('is advertised as a bare name (no value parameter)', () => {
+    const cap = SUPPORTED_CAPABILITIES.find((c) => c.name === 'draft/pre-away');
+    expect(cap).toBeDefined();
+    expect(cap?.value).toBeUndefined();
+  });
+
+  it('appears in CAP LS output as the bare token', () => {
+    expect(getLsString()).toContain('draft/pre-away');
+    expect(getLsString()).not.toContain('draft/pre-away=');
+  });
+
+  it('is ACKable via SUPPORTED_CAP_NAMES membership (CAP REQ round-trip)', () => {
+    expect(SUPPORTED_CAP_NAMES.has('draft/pre-away')).toBe(true);
+  });
+
+  it('is recognized by isSupportedCap', () => {
+    expect(isSupportedCap('draft/pre-away')).toBe(true);
+  });
+});
+
+describe('draft/multiline advertisement', () => {
+  it('is advertised with the default byte budget value', () => {
+    const cap = SUPPORTED_CAPABILITIES.find((c) => c.name === 'draft/multiline');
+    expect(cap).toBeDefined();
+    expect(cap?.value).toBe('4096');
+  });
+
+  it('appears in CAP LS output as the name=4096 token', () => {
+    expect(getLsString()).toContain('draft/multiline=4096');
+  });
+
+  it('is ACKable via SUPPORTED_CAP_NAMES membership (CAP REQ round-trip)', () => {
+    expect(SUPPORTED_CAP_NAMES.has('draft/multiline')).toBe(true);
+  });
+
+  it('is recognized by isSupportedCap', () => {
+    expect(isSupportedCap('draft/multiline')).toBe(true);
+  });
+});
+
 describe('splitCapsForWire', () => {
   it('returns a single chunk when everything fits', () => {
     const tokens = ['a', 'b', 'c'];

package/packages/irc-core/tests/caps/sts.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it } from 'vitest';
+import {
+  DEFAULT_STS_DURATION_SECONDS,
+  DEFAULT_STS_PORT,
+  STS_CAP_NAME,
+  stsCapValue,
+} from '../../src/caps/sts';
+import type { StsPolicy } from '../../src/caps/sts';
+
+/**
+ * IRCv3 `sts` (Strict Transport Security) policy builder.
+ *
+ * Spec: https://ircv3.net/specs/extensions/sts
+ *
+ * On a plaintext connection the server advertises the full policy
+ * (`duration=…,port=…` plus optional `preload`) so compliant clients
+ * reconnect over TLS. On a TLS connection only `duration` is sent —
+ * the port is meaningless once the client is already on the secure
+ * listener, and `preload` is only meaningful as an upgrade directive.
+ */
+describe('stsCapValue', () => {
+  describe('STS_CAP_NAME', () => {
+    it('exposes the IRCv3 wire name', () => {
+      expect(STS_CAP_NAME).toBe('sts');
+    });
+  });
+
+  describe('plaintext connection (secure=false)', () => {
+    it('builds duration+port from the supplied config', () => {
+      const cfg: StsPolicy = { duration: 600, port: 6697 };
+      expect(stsCapValue(cfg, false)).toBe('duration=600,port=6697');
+    });
+
+    it('appends `preload` when preload=true', () => {
+      const cfg: StsPolicy = { duration: 600, port: 6697, preload: true };
+      expect(stsCapValue(cfg, false)).toBe('duration=600,port=6697,preload');
+    });
+
+    it('omits `preload` when preload=false', () => {
+      const cfg: StsPolicy = { duration: 600, port: 6697, preload: false };
+      expect(stsCapValue(cfg, false)).toBe('duration=600,port=6697');
+    });
+
+    it('omits `preload` when preload is undefined', () => {
+      const cfg: StsPolicy = { duration: 600, port: 6697 };
+      expect(stsCapValue(cfg, false)).toBe('duration=600,port=6697');
+    });
+
+    it('honours an overridden port', () => {
+      const cfg: StsPolicy = { duration: 600, port: 7000 };
+      expect(stsCapValue(cfg, false)).toBe('duration=600,port=7000');
+    });
+
+    it('honours an overridden duration', () => {
+      const cfg: StsPolicy = { duration: 86_400, port: 6697 };
+      expect(stsCapValue(cfg, false)).toBe('duration=86400,port=6697');
+    });
+  });
+
+  describe('TLS connection (secure=true)', () => {
+    it('advertises only the duration (port is meaningless on TLS)', () => {
+      const cfg: StsPolicy = { duration: 600, port: 6697 };
+      expect(stsCapValue(cfg, true)).toBe('duration=600');
+    });
+
+    it('omits preload on TLS (upgrade-only directive)', () => {
+      const cfg: StsPolicy = { duration: 600, port: 6697, preload: true };
+      expect(stsCapValue(cfg, true)).toBe('duration=600');
+    });
+
+    it('honours an overridden duration on TLS', () => {
+      const cfg: StsPolicy = { duration: 86_400, port: 6697 };
+      expect(stsCapValue(cfg, true)).toBe('duration=86400');
+    });
+  });
+
+  describe('disabled (no policy configured)', () => {
+    it('returns undefined when config is undefined', () => {
+      expect(stsCapValue(undefined, false)).toBeUndefined();
+    });
+
+    it('returns undefined when config is undefined on a TLS connection', () => {
+      expect(stsCapValue(undefined, true)).toBeUndefined();
+    });
+  });
+
+  describe('field defaults', () => {
+    it('falls back to DEFAULT_STS_DURATION_SECONDS when duration is omitted (plaintext)', () => {
+      const value = stsCapValue({ port: 6697 }, false);
+      expect(value).toBe(`duration=${DEFAULT_STS_DURATION_SECONDS},port=6697`);
+    });
+
+    it('falls back to DEFAULT_STS_DURATION_SECONDS when duration is omitted (TLS)', () => {
+      const value = stsCapValue({ port: 6697 }, true);
+      expect(value).toBe(`duration=${DEFAULT_STS_DURATION_SECONDS}`);
+    });
+
+    it('falls back to DEFAULT_STS_PORT when port is omitted (plaintext)', () => {
+      const value = stsCapValue({ duration: 600 }, false);
+      expect(value).toBe(`duration=600,port=${DEFAULT_STS_PORT}`);
+    });
+
+    it('uses both defaults when only an empty object is supplied (plaintext)', () => {
+      const value = stsCapValue({}, false);
+      expect(value).toBe(`duration=${DEFAULT_STS_DURATION_SECONDS},port=${DEFAULT_STS_PORT}`);
+    });
+
+    it('uses both defaults when only an empty object is supplied (TLS)', () => {
+      const value = stsCapValue({}, true);
+      expect(value).toBe(`duration=${DEFAULT_STS_DURATION_SECONDS}`);
+    });
+  });
+
+  describe('defaults', () => {
+    it('exposes 6697 as the canonical IRC-over-TLS port', () => {
+      expect(DEFAULT_STS_PORT).toBe(6697);
+    });
+
+    it('exposes a positive duration default (seconds)', () => {
+      expect(DEFAULT_STS_DURATION_SECONDS).toBeGreaterThan(0);
+    });
+  });
+});

package/packages/irc-core/tests/commands/account-notify.test.ts

@@ -0,0 +1,171 @@
+import { describe, expect, it } from 'vitest';
+import { emitAccountNotify } from '../../src/commands/account-notify';
+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 = 'alice';
+  s.host = 'example.com';
+  s.realname = 'Alice';
+  s.registration = 'registered';
+  return s;
+}
+
+describe('emitAccountNotify — login', () => {
+  it('emits a cap-split Broadcast per joined channel with the account name', () => {
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+    conn.joinedChannels.add('#bar');
+
+    const effects = emitAccountNotify({ conn, account: 'alice' });
+
+    expect(effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [], 'c1', 'account-notify', [
+        L(':alice!alice@example.com ACCOUNT alice'),
+      ]),
+      Effect.broadcast('#bar', [], 'c1', 'account-notify', [
+        L(':alice!alice@example.com ACCOUNT alice'),
+      ]),
+    ]);
+  });
+
+  it('excludes the sender (except) so non-echo peers do not see their own ACCOUNT', () => {
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitAccountNotify({ conn, account: 'alice' });
+
+    const bcast = effects[0];
+    if (bcast?.tag === 'Broadcast') {
+      expect(bcast.except).toBe('c1');
+    }
+  });
+
+  it('uses empty legacy lines so non-cap peers receive nothing', () => {
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitAccountNotify({ conn, account: 'alice' });
+
+    const bcast = effects[0];
+    if (bcast?.tag === 'Broadcast') {
+      expect(bcast.lines).toEqual([]);
+      expect(bcast.cap).toBe('account-notify');
+    }
+  });
+});
+
+describe('emitAccountNotify — logout', () => {
+  it('emits ACCOUNT * for a logout', () => {
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitAccountNotify({ conn, account: undefined });
+
+    expect(effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [], 'c1', 'account-notify', [
+        L(':alice!alice@example.com ACCOUNT *'),
+      ]),
+    ]);
+  });
+});
+
+describe('emitAccountNotify — gating', () => {
+  it('emits nothing before registration completes', () => {
+    const conn = makeConn();
+    conn.registration = 'pre-registration';
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitAccountNotify({ conn, account: 'alice' });
+
+    expect(effects).toEqual([]);
+  });
+
+  it('emits nothing during registration', () => {
+    const conn = makeConn();
+    conn.registration = 'registering';
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitAccountNotify({ conn, account: 'alice' });
+
+    expect(effects).toEqual([]);
+  });
+
+  it('emits nothing when the connection has no joined channels', () => {
+    const conn = makeConn();
+
+    const effects = emitAccountNotify({ conn, account: 'alice' });
+
+    expect(effects).toEqual([]);
+  });
+
+  it('falls back to ? for the source when nick/user/host are absent', () => {
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    conn.registration = 'registered';
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitAccountNotify({ conn, account: 'alice' });
+
+    const bcast = effects[0];
+    if (bcast?.tag === 'Broadcast') {
+      expect(bcast.capLines?.[0]?.text).toBe(':? ACCOUNT alice');
+    }
+  });
+});
+
+describe('emitAccountNotify — echo-message', () => {
+  it('echoes ACCOUNT back to a sender with echo-message negotiated', () => {
+    const conn = makeConn();
+    conn.caps.add('echo-message');
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitAccountNotify({ conn, account: 'alice' });
+
+    // First: the broadcast (sender excluded). Then the echo Send to sender.
+    expect(effects).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [], 'c1', 'account-notify', [
+        L(':alice!alice@example.com ACCOUNT alice'),
+      ]),
+      Effect.send('c1', [L(':alice!alice@example.com ACCOUNT alice')]),
+    ]);
+  });
+
+  it('does not echo when the sender lacks echo-message', () => {
+    const conn = makeConn();
+    conn.joinedChannels.add('#foo');
+
+    const effects = emitAccountNotify({ conn, account: 'alice' });
+
+    expect(effects).toHaveLength(1);
+    expect(effects[0]?.tag).toBe('Broadcast');
+  });
+
+  it('does not echo when the sender has echo-message but no joined channels', () => {
+    const conn = makeConn();
+    conn.caps.add('echo-message');
+
+    const effects = emitAccountNotify({ conn, account: 'alice' });
+
+    expect(effects).toEqual([]);
+  });
+
+  it('echoes a single ACCOUNT even across multiple shared channels', () => {
+    const conn = makeConn();
+    conn.caps.add('echo-message');
+    conn.joinedChannels.add('#foo');
+    conn.joinedChannels.add('#bar');
+
+    const effects = emitAccountNotify({ conn, account: 'alice' });
+
+    // Two broadcasts (one per channel) + exactly one echo Send.
+    const broadcasts = effects.filter((e) => e.tag === 'Broadcast');
+    const sends = effects.filter((e) => e.tag === 'Send');
+    expect(broadcasts).toHaveLength(2);
+    expect(sends).toHaveLength(1);
+  });
+});

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

@@ -2,7 +2,13 @@ import { describe, expect, it } from 'vitest';
 import { awayReducer } from '../../src/commands/away';
 import { Effect } from '../../src/effects';
 import type { Effect as EffectType, RawLine } from '../../src/effects';
-import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import {
+  type AwayStore,
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryAwayStore,
+  SequentialIdFactory,
+} from '../../src/ports';
 import { type ConnectionState, createConnection } from '../../src/state/connection';
 import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
 
@@ -18,13 +24,14 @@ const serverConfig: ServerConfig = {
   quitMessage: 'Client Quit',
 };
 
-function makeCtx(conn: ConnectionState, clock = new FakeClock(1_000)): Ctx {
+function makeCtx(conn: ConnectionState, clock = new FakeClock(1_000), away?: AwayStore): Ctx {
   return buildCtx({
     serverConfig,
     clock,
     ids: new SequentialIdFactory(),
     motd: EmptyMotdProvider,
     connection: conn,
+    ...(away !== undefined ? { away } : {}),
   });
 }
 
@@ -231,3 +238,79 @@ describe('awayReducer — defensive', () => {
     expect(broadcast?.lines[0]?.text).toBe(':? AWAY :gone');
   });
 });
+
+// ============================================================================
+// awayReducer — draft/pre-away persistence
+// ============================================================================
+
+describe('awayReducer — draft/pre-away persistence', () => {
+  it('persists the reason to the AwayStore keyed by account when setting away', () => {
+    const store = new InMemoryAwayStore();
+    const conn = makeConn();
+    conn.account = 'alice';
+    const ctx = makeCtx(conn, new FakeClock(1_000), store);
+
+    awayReducer(conn, { command: 'AWAY', params: ['brb'], tags: {} }, ctx);
+
+    expect(store.get('alice')).toBe('brb');
+  });
+
+  it('overwrites the persisted reason when the away reason changes', () => {
+    const store = new InMemoryAwayStore();
+    const conn = makeConn();
+    conn.account = 'alice';
+    const ctx = makeCtx(conn, new FakeClock(1_000), store);
+
+    awayReducer(conn, { command: 'AWAY', params: ['brb'], tags: {} }, ctx);
+    awayReducer(conn, { command: 'AWAY', params: ['lunch'], tags: {} }, ctx);
+
+    expect(store.get('alice')).toBe('lunch');
+  });
+
+  it('clears the persisted reason when AWAY is unset (no param)', () => {
+    const store = new InMemoryAwayStore();
+    store.set('alice', 'brb');
+    const conn = makeConn();
+    conn.account = 'alice';
+    conn.away = 'brb';
+    const ctx = makeCtx(conn, new FakeClock(1_000), store);
+
+    awayReducer(conn, { command: 'AWAY', params: [], tags: {} }, ctx);
+
+    expect(store.get('alice')).toBeUndefined();
+  });
+
+  it('clears the persisted reason when AWAY is unset (empty param)', () => {
+    const store = new InMemoryAwayStore();
+    store.set('alice', 'brb');
+    const conn = makeConn();
+    conn.account = 'alice';
+    conn.away = 'brb';
+    const ctx = makeCtx(conn, new FakeClock(1_000), store);
+
+    awayReducer(conn, { command: 'AWAY', params: [''], tags: {} }, ctx);
+
+    expect(store.get('alice')).toBeUndefined();
+  });
+
+  it('does not persist when no AwayStore is bound (in-memory only)', () => {
+    const conn = makeConn();
+    conn.account = 'alice';
+    const ctx = makeCtx(conn); // no store
+
+    awayReducer(conn, { command: 'AWAY', params: ['brb'], tags: {} }, ctx);
+
+    // In-memory reason still set so the session's own view is consistent.
+    expect(conn.away).toBe('brb');
+  });
+
+  it('does not persist when the connection is unidentified (no account)', () => {
+    const store = new InMemoryAwayStore();
+    const conn = makeConn(); // no account
+    const ctx = makeCtx(conn, new FakeClock(1_000), store);
+
+    awayReducer(conn, { command: 'AWAY', params: ['brb'], tags: {} }, ctx);
+
+    expect(store.get('alice')).toBeUndefined();
+  });
+});