serverless-ircd 0.5.0 → 0.6.0

package/packages/irc-core/src/types.ts

@@ -10,12 +10,14 @@ import type { Effect } from './effects.js';
 import type { FloodControlConfig } from './flood-control.js';
 import type {
   AccountStore,
+  AwayStore,
   Clock,
   IdFactory,
   MessageStore,
   MotdProvider,
   MtlsIdentityProvider,
   NickHistoryStore,
+  ReadMarkerStore,
 } from './ports.js';
 import type { IrcMessage } from './protocol/messages.js';
 import type { ConnectionState } from './state/connection.js';
@@ -33,6 +35,23 @@ export interface CloakingConfig {
   readonly cloakedSuffix?: string | undefined;
 }
 
+/**
+ * IRCv3 `sts` (Strict Transport Security) policy as seen by reducers.
+ * Mirrors the {@link StsConfigSchema} shape; the cap builder reads it to
+ * construct the `sts=…` advertisement per connection.
+ *
+ * Optional fields are widened to `T | undefined` to mirror Zod's
+ * `.optional()` output under `exactOptionalPropertyTypes: true`.
+ */
+export interface StsConfig {
+  /** Pin duration in seconds. */
+  readonly duration: number;
+  /** TLS listener port (plaintext advertisements only). */
+  readonly port: number;
+  /** Optional preload directive (plaintext advertisements only). */
+  readonly preload?: boolean | undefined;
+}
+
 /**
  * A single IRC operator credential. The {@link operReducer} consults the
  * configured list to authenticate `OPER <name> <password>`. Both fields are
@@ -127,6 +146,55 @@ export interface ServerConfig {
    * `exactOptionalPropertyTypes: true`.
    */
   chatHistoryPlaybackLimit?: number | undefined;
+  /**
+   * IRCv3 `sts` (Strict Transport Security) policy. `undefined` disables
+   * STS advertisement; an object supplies the policy the cap builder
+   * serializes per connection (plaintext vs TLS).
+   *
+   * Typed `StsConfig | undefined` to mirror Zod's optional output shape
+   * under `exactOptionalPropertyTypes: true`.
+   */
+  readonly sts?: StsConfig | undefined;
+  /**
+   * IRCv3 `draft/multiline` byte budget. Advertised as
+   * `draft/multiline=<n>` in `CAP LS` and enforced on every finalized
+   * multi-line batch. Defaults to {@link DEFAULT_MULTILINE_MAX_BYTES}
+   * (4096) when omitted; the parsed config always supplies a value.
+   *
+   * Typed `number | undefined` to mirror Zod's optional output shape
+   * under `exactOptionalPropertyTypes: true` so inline `ServerConfig`
+   * literals in tests may omit it.
+   */
+  readonly multilineMaxBytes?: number | undefined;
+  /**
+   * Per-connection MONITOR watchlist ceiling, advertised as `MONITOR=<n>`
+   * in `005 RPL_ISUPPORT`. Omitted → the reducer falls back to
+   * {@link DEFAULT_MONITOR_LIMIT} (the monitor cap's built-in ceiling).
+   *
+   * Typed `number | undefined` to mirror Zod's optional output shape under
+   * `exactOptionalPropertyTypes: true`.
+   */
+  readonly monitorLimit?: number | undefined;
+  /**
+   * Extended-ban prefix sigil advertised as `EXTBAN=<prefix>,…` in
+   * `005 RPL_ISUPPORT`. Omitted → defaults to `~` (the IRC-standard
+   * extban prefix).
+   *
+   * Typed `string | undefined` to mirror Zod's optional output shape under
+   * `exactOptionalPropertyTypes: true`.
+   */
+  readonly extbanPrefix?: string | undefined;
+  /**
+   * Whether IRC services (NickServ/ChanServ) are wired up for this
+   * deployment. When true, `005 RPL_ISUPPORT` advertises `ACCOUNTEXTBAN=a`
+   * (account-name extended bans), which are only meaningful once nicks are
+   * registered. Omitted/false → the token is suppressed until services
+   * ship.
+   *
+   * Typed `boolean | undefined` to mirror Zod's optional output shape under
+   * `exactOptionalPropertyTypes: true`.
+   */
+  readonly servicesEnabled?: boolean | undefined;
 }
 
 /** Per-invocation context handed to every reducer. */
@@ -162,10 +230,43 @@ export interface Ctx {
    * entries and the WHOWAS reducer replays them.
    */
   readonly history?: NickHistoryStore;
+  /**
+   * Read-marker persistence source for IRCv3 `draft/read-marker` (absent
+   * when the deployment does not persist read markers). When present, a
+   * `+draft/read-marker=<msgid>` TAGMSG from an identified, cap-enabled
+   * client updates the per-`(account, channel)` marker, and SASL identify
+   * seeds the connection's `lastReadMarkers` from the stored values so a
+   * reconnect restores the user's read position.
+   */
+  readonly readMarkers?: ReadMarkerStore;
+  /**
+   * Away-status persistence source for IRCv3 `draft/pre-away` (absent
+   * when the deployment does not persist away reasons). When present, a
+   * set/clear of `AWAY` from an identified connection mirrors the change
+   * into the per-`account` record, and SASL identify replays the stored
+   * reason onto the connection (emitting `306 RPL_NOWAWAY`) so a
+   * reconnect restores the user's away state. Omitted (→ `ctx.away`
+   * undefined) preserves the session-only behaviour: the connection
+   * still tracks its own `AWAY` but the reason is not shared across
+   * connections or restored on reconnect.
+   */
+  readonly away?: AwayStore;
   /** The connection invoking the command. Reducers mutate this freely. */
   readonly connection: ConnectionState;
   /** Convenience: `connection.id`. */
   readonly connId: string;
+  /**
+   * IRCv3 `labeled-response` label carried by the inbound message (the value
+   * of the `+label` client tag), or `undefined` when the request was
+   * unlabeled. Plumbed through ctx so every reducer's emitted effects are
+   * uniformly attributable to the labeled request; the actor layer wraps the
+   * requester's replies in one `BATCH +label labeled-response … -label` frame
+   * (or emits an empty batch when there is no reply).
+   *
+   * Typed `string | undefined` to mirror the optional-output shape under
+   * `exactOptionalPropertyTypes: true`.
+   */
+  readonly label?: string | undefined;
 }
 
 /** Result of a single reducer invocation. */
@@ -190,7 +291,15 @@ export interface BuildCtxOptions {
   mtlsIdentity?: MtlsIdentityProvider;
   messages?: MessageStore;
   history?: NickHistoryStore;
+  readMarkers?: ReadMarkerStore;
+  away?: AwayStore;
   connection: ConnectionState;
+  /**
+   * IRCv3 `labeled-response` label extracted from the inbound `+label` tag.
+   * Omitted (→ `ctx.label` undefined) when the request was unlabeled. See
+   * {@link Ctx.label}.
+   */
+  readonly label?: string | undefined;
 }
 
 /** Constructs a {@link Ctx} from the required parts. */
@@ -208,6 +317,9 @@ export function buildCtx(opts: BuildCtxOptions): Ctx {
     ...(opts.mtlsIdentity !== undefined ? { mtlsIdentity: opts.mtlsIdentity } : {}),
     ...(opts.messages !== undefined ? { messages: opts.messages } : {}),
     ...(opts.history !== undefined ? { history: opts.history } : {}),
+    ...(opts.readMarkers !== undefined ? { readMarkers: opts.readMarkers } : {}),
+    ...(opts.away !== undefined ? { away: opts.away } : {}),
+    ...(opts.label !== undefined ? { label: opts.label } : {}),
   };
   return ctx;
 }

package/packages/irc-core/stryker.commands.conf.json

@@ -36,6 +36,5 @@
   },
   "reporters": ["clear-text", "html"],
   "timeoutMS": 5000,
-  "concurrency": 2,
-  "ignoreStatic": true
+  "concurrency": 2
 }

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

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest';
+import { type AwayStore, InMemoryAwayStore } from '../src/ports';
+
+describe('InMemoryAwayStore — port conformance', () => {
+  it('implements the AwayStore port', () => {
+    const store: AwayStore = new InMemoryAwayStore();
+    expect(store).toBeDefined();
+  });
+});
+
+describe('InMemoryAwayStore — get / set / clear', () => {
+  it('returns undefined for an unknown account', () => {
+    const store = new InMemoryAwayStore();
+    expect(store.get('alice')).toBeUndefined();
+  });
+
+  it('stores and returns the away reason for a known account', () => {
+    const store = new InMemoryAwayStore();
+    store.set('alice', 'brb');
+    expect(store.get('alice')).toBe('brb');
+  });
+
+  it('overwrites the reason on a subsequent set for the same account', () => {
+    const store = new InMemoryAwayStore();
+    store.set('alice', 'brb');
+    store.set('alice', 'lunch');
+    expect(store.get('alice')).toBe('lunch');
+  });
+
+  it('keys accounts case-insensitively (rfc1459 fold)', () => {
+    const store = new InMemoryAwayStore();
+    store.set('Alice', 'brb');
+    expect(store.get('alice')).toBe('brb');
+    expect(store.get('ALICE')).toBe('brb');
+  });
+
+  it('keeps reasons for distinct accounts separate', () => {
+    const store = new InMemoryAwayStore();
+    store.set('alice', 'brb');
+    store.set('bob', 'afk');
+    expect(store.get('alice')).toBe('brb');
+    expect(store.get('bob')).toBe('afk');
+  });
+
+  it('clears the reason for an account on clear', () => {
+    const store = new InMemoryAwayStore();
+    store.set('alice', 'brb');
+    store.clear('alice');
+    expect(store.get('alice')).toBeUndefined();
+  });
+
+  it('is a no-op to clear an account that has no stored reason', () => {
+    const store = new InMemoryAwayStore();
+    store.clear('alice');
+    expect(store.get('alice')).toBeUndefined();
+  });
+
+  it('clears only the named account, leaving others intact', () => {
+    const store = new InMemoryAwayStore();
+    store.set('alice', 'brb');
+    store.set('bob', 'afk');
+    store.clear('alice');
+    expect(store.get('alice')).toBeUndefined();
+    expect(store.get('bob')).toBe('afk');
+  });
+
+  it('folds the account name case-insensitively on clear', () => {
+    const store = new InMemoryAwayStore();
+    store.set('Alice', 'brb');
+    store.clear('ALICE');
+    expect(store.get('alice')).toBeUndefined();
+  });
+});

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