serverless-ircd 0.3.0 → 0.5.0

package/packages/irc-core/tests/types.test.ts

@@ -1,7 +1,12 @@
 import { describe, expect, it } from 'vitest';
 import type { RawLine } from '../src/effects';
 import { Effect as EffectValue } from '../src/effects';
-import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../src/ports';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryNickHistoryStore,
+  SequentialIdFactory,
+} from '../src/ports';
 import { createConnection } from '../src/state/connection';
 import {
   type Ctx,
@@ -97,6 +102,35 @@ describe('Ctx / Reducer types', () => {
     const keys = Object.keys(ctx) as Array<keyof Ctx>;
     expect(keys).not.toContain('msg');
   });
+
+  it('threads an optional history store through buildCtx onto ctx.history', () => {
+    const history = new InMemoryNickHistoryStore(new FakeClock(0));
+    const serverConfig: ServerConfig = {
+      serverName: 'irc.example.com',
+      networkName: 'ExampleNet',
+      maxChannelsPerUser: 30,
+      maxTargetsPerCommand: 10,
+      maxListEntries: 50,
+      nickLen: 30,
+      channelLen: 50,
+      topicLen: 390,
+      quitMessage: 'Client Quit',
+    };
+    const ctx = buildCtx({
+      serverConfig,
+      clock: new FakeClock(1_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: createConnection({ id: 'c1', connectedSince: 0 }),
+      history,
+    });
+    expect(ctx.history).toBe(history);
+  });
+
+  it('omits ctx.history when no history store is supplied', () => {
+    const ctx = makeCtx();
+    expect(ctx.history).toBeUndefined();
+  });
 });
 
 describe('ServerConfig shape', () => {

package/packages/irc-core/tests/ws-framing.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, it } from 'vitest';
+import {
+  MAX_WS_MESSAGE_BYTES,
+  type WsFrameMode,
+  frameToLines,
+  isWithinWsByteBudget,
+  sanitizeForTextMode,
+  stripTrailingCrLf,
+  wsFrameModeFor,
+} from '../src/ws-framing';
+
+// ============================================================================
+// MAX_WS_MESSAGE_BYTES constant
+// ============================================================================
+
+describe('MAX_WS_MESSAGE_BYTES', () => {
+  it('is 510 (the IRC line-content limit; WS spec omits the trailing CRLF)', () => {
+    expect(MAX_WS_MESSAGE_BYTES).toBe(510);
+  });
+});
+
+// ============================================================================
+// wsFrameModeFor — subprotocol → WsFrameMode mapping
+// ============================================================================
+
+describe('wsFrameModeFor', () => {
+  it('maps text.ircv3.net to spec-text', () => {
+    expect(wsFrameModeFor('text.ircv3.net')).toBe('spec-text');
+  });
+
+  it('maps binary.ircv3.net to spec-binary', () => {
+    expect(wsFrameModeFor('binary.ircv3.net')).toBe('spec-binary');
+  });
+
+  it('maps undefined (no subprotocol) to legacy', () => {
+    expect(wsFrameModeFor(undefined)).toBe('legacy');
+  });
+});
+
+// ============================================================================
+// stripTrailingCrLf
+// ============================================================================
+
+describe('stripTrailingCrLf', () => {
+  it('strips a trailing CR-LF', () => {
+    expect(stripTrailingCrLf('NICK bob\r\n')).toBe('NICK bob');
+  });
+
+  it('strips a trailing bare LF', () => {
+    expect(stripTrailingCrLf('NICK bob\n')).toBe('NICK bob');
+  });
+
+  it('leaves a string with no trailing terminator unchanged', () => {
+    expect(stripTrailingCrLf('NICK bob')).toBe('NICK bob');
+  });
+
+  it('strips only a single trailing terminator', () => {
+    expect(stripTrailingCrLf('a\r\n\r\n')).toBe('a\r\n');
+  });
+
+  it('returns the empty string unchanged', () => {
+    expect(stripTrailingCrLf('')).toBe('');
+  });
+
+  it('does not strip a leading CR-LF', () => {
+    expect(stripTrailingCrLf('\r\nNICK bob')).toBe('\r\nNICK bob');
+  });
+});
+
+// ============================================================================
+// frameToLines — spec-text / spec-binary modes (one IRC message per frame)
+// ============================================================================
+
+describe('frameToLines — spec-text', () => {
+  it('strips a trailing CR-LF and returns a single-element array', () => {
+    expect(frameToLines('NICK bob\r\n', 'spec-text')).toEqual(['NICK bob']);
+  });
+
+  it('strips a trailing bare LF', () => {
+    expect(frameToLines('NICK bob\n', 'spec-text')).toEqual(['NICK bob']);
+  });
+
+  it('does not split on an embedded LF (one WS message === one IRC line)', () => {
+    expect(frameToLines('NICK bob\nextra', 'spec-text')).toEqual(['NICK bob\nextra']);
+  });
+
+  it('returns an empty array for an empty frame', () => {
+    expect(frameToLines('', 'spec-text')).toEqual([]);
+  });
+
+  it('returns an empty array for a frame that is only a terminator', () => {
+    expect(frameToLines('\r\n', 'spec-text')).toEqual([]);
+  });
+
+  it('returns a single bare line unchanged when there is no terminator', () => {
+    expect(frameToLines('PING :tok', 'spec-text')).toEqual(['PING :tok']);
+  });
+});
+
+describe('frameToLines — spec-binary', () => {
+  it('behaves identically to spec-text (single line, terminator stripped)', () => {
+    expect(frameToLines('NICK bob\n', 'spec-binary')).toEqual(['NICK bob']);
+  });
+
+  it('does not split on an embedded LF', () => {
+    expect(frameToLines('a\nb', 'spec-binary')).toEqual(['a\nb']);
+  });
+});
+
+// ============================================================================
+// frameToLines — legacy mode (the pre-spec split-on-/\r?\n/ behaviour)
+// ============================================================================
+
+describe('frameToLines — legacy', () => {
+  it('splits on CR-LF into separate lines', () => {
+    expect(frameToLines('a\r\nb', 'legacy')).toEqual(['a', 'b']);
+  });
+
+  it('splits on bare LF', () => {
+    expect(frameToLines('a\nb', 'legacy')).toEqual(['a', 'b']);
+  });
+
+  it('returns an empty array for the empty string', () => {
+    expect(frameToLines('', 'legacy')).toEqual([]);
+  });
+
+  it('returns a single bare line with no terminator unchanged', () => {
+    expect(frameToLines('PING :tok', 'legacy')).toEqual(['PING :tok']);
+  });
+
+  it('emits a trailing empty string for a terminated frame', () => {
+    expect(frameToLines('PING :tok\r\n', 'legacy')).toEqual(['PING :tok', '']);
+  });
+
+  it('splits several joined messages keeping a trailing empty string', () => {
+    expect(frameToLines('a\r\nb\r\n', 'legacy')).toEqual(['a', 'b', '']);
+  });
+});
+
+// Exhaustiveness guard: every declared mode is covered by the specs above.
+describe('frameToLines — mode coverage', () => {
+  const modes: WsFrameMode[] = ['spec-text', 'spec-binary', 'legacy'];
+  for (const mode of modes) {
+    it(`accepts the '${mode}' mode without throwing`, () => {
+      expect(Array.isArray(frameToLines('x', mode))).toBe(true);
+    });
+  }
+});
+
+// ============================================================================
+// isWithinWsByteBudget — the IRCv3 WS message byte cap
+// ============================================================================
+
+describe('isWithinWsByteBudget', () => {
+  it('accepts a frame whose length equals the 510-byte budget', () => {
+    expect(isWithinWsByteBudget('a'.repeat(510))).toBe(true);
+  });
+
+  it('rejects a frame whose length is one byte over the budget', () => {
+    expect(isWithinWsByteBudget('a'.repeat(511))).toBe(false);
+  });
+
+  it('accepts the empty string', () => {
+    expect(isWithinWsByteBudget('')).toBe(true);
+  });
+
+  it('accepts a short frame', () => {
+    expect(isWithinWsByteBudget('NICK bob')).toBe(true);
+  });
+});
+
+// ============================================================================
+// sanitizeForTextMode — replace lone surrogates with U+FFFD
+// ============================================================================
+
+describe('sanitizeForTextMode', () => {
+  it('replaces a lone high surrogate with U+FFFD', () => {
+    expect(sanitizeForTextMode('\uD800')).toBe('\uFFFD');
+  });
+
+  it('replaces a lone low surrogate with U+FFFD', () => {
+    expect(sanitizeForTextMode('\uDC00')).toBe('\uFFFD');
+  });
+
+  it('leaves a valid surrogate pair (a supplementary code point) unchanged', () => {
+    // U+10000 = \uD800\uDC00
+    expect(sanitizeForTextMode('\uD800\uDC00')).toBe('\uD800\uDC00');
+  });
+
+  it('leaves plain ASCII text unchanged', () => {
+    expect(sanitizeForTextMode('hello')).toBe('hello');
+  });
+
+  it('replaces a lone surrogate embedded in normal text', () => {
+    expect(sanitizeForTextMode('a\uD800b')).toBe('a\uFFFDb');
+  });
+
+  it('replaces two consecutive lone high surrogates with two U+FFFD', () => {
+    expect(sanitizeForTextMode('\uD800\uD800')).toBe('\uFFFD\uFFFD');
+  });
+
+  it('preserves a valid pair surrounded by normal text', () => {
+    expect(sanitizeForTextMode('x\uD83D\uDE00y')).toBe('x\uD83D\uDE00y');
+  });
+
+  it('replaces a lone high surrogate followed later by a lone low surrogate', () => {
+    expect(sanitizeForTextMode('\uD800a\uDC00')).toBe('\uFFFDa\uFFFD');
+  });
+
+  it('returns the empty string unchanged', () => {
+    expect(sanitizeForTextMode('')).toBe('');
+  });
+});

package/packages/irc-core/tests/ws-subprotocol.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it } from 'vitest';
+import {
+  WS_SUBPROTO_BINARY,
+  WS_SUBPROTO_TEXT,
+  type WsSubprotocol,
+  parseSecWsProtocolOffers,
+  selectSubprotocol,
+} from '../src/ws-subprotocol';
+
+// ============================================================================
+// constants & type
+// ============================================================================
+
+describe('WS subprotocol constants', () => {
+  it('exposes the IRCv3 text subprotocol name', () => {
+    expect(WS_SUBPROTO_TEXT).toBe('text.ircv3.net');
+  });
+
+  it('exposes the IRCv3 binary subprotocol name', () => {
+    expect(WS_SUBPROTO_BINARY).toBe('binary.ircv3.net');
+  });
+
+  it('the WsSubprotocol type resolves to the two literal names', () => {
+    const a: WsSubprotocol = WS_SUBPROTO_TEXT;
+    const b: WsSubprotocol = WS_SUBPROTO_BINARY;
+    expect([a, b]).toEqual([WS_SUBPROTO_TEXT, WS_SUBPROTO_BINARY]);
+  });
+});
+
+// ============================================================================
+// parseSecWsProtocolOffers — header parsing
+// ============================================================================
+
+describe('parseSecWsProtocolOffers', () => {
+  it('splits a comma-separated list into ordered offers', () => {
+    expect(parseSecWsProtocolOffers('text.ircv3.net, binary.ircv3.net')).toEqual([
+      'text.ircv3.net',
+      'binary.ircv3.net',
+    ]);
+  });
+
+  it('trims whitespace around each item', () => {
+    expect(parseSecWsProtocolOffers(' text.ircv3.net , binary.ircv3.net ')).toEqual([
+      'text.ircv3.net',
+      'binary.ircv3.net',
+    ]);
+  });
+
+  it('preserves client-preference order', () => {
+    expect(parseSecWsProtocolOffers('binary.ircv3.net, text.ircv3.net')).toEqual([
+      'binary.ircv3.net',
+      'text.ircv3.net',
+    ]);
+  });
+
+  it('returns an empty array for null', () => {
+    expect(parseSecWsProtocolOffers(null)).toEqual([]);
+  });
+
+  it('returns an empty array for undefined', () => {
+    expect(parseSecWsProtocolOffers(undefined)).toEqual([]);
+  });
+
+  it('returns an empty array for an empty string', () => {
+    expect(parseSecWsProtocolOffers('')).toEqual([]);
+  });
+
+  it('drops empty entries produced by stray commas', () => {
+    expect(parseSecWsProtocolOffers('text.ircv3.net,, ,binary.ircv3.net')).toEqual([
+      'text.ircv3.net',
+      'binary.ircv3.net',
+    ]);
+  });
+
+  it('preserves duplicate entries in order', () => {
+    expect(parseSecWsProtocolOffers('text.ircv3.net, text.ircv3.net')).toEqual([
+      'text.ircv3.net',
+      'text.ircv3.net',
+    ]);
+  });
+});
+
+// ============================================================================
+// selectSubprotocol — preference-ordered selection
+// ============================================================================
+
+describe('selectSubprotocol', () => {
+  it('returns the first supported offer in client-preference order (text first)', () => {
+    expect(selectSubprotocol(['text.ircv3.net', 'binary.ircv3.net'])).toBe('text.ircv3.net');
+  });
+
+  it('honours client preference when binary is offered first', () => {
+    expect(selectSubprotocol(['binary.ircv3.net', 'text.ircv3.net'])).toBe('binary.ircv3.net');
+  });
+
+  it('returns null when only unsupported protocols are offered', () => {
+    expect(selectSubprotocol(['foo', 'bar'])).toBeNull();
+  });
+
+  it('returns null for an empty offer list', () => {
+    expect(selectSubprotocol([])).toBeNull();
+  });
+
+  it('skips unsupported offers and selects the first supported one', () => {
+    expect(selectSubprotocol(['foo', 'binary.ircv3.net'])).toBe('binary.ircv3.net');
+  });
+
+  it('returns the first occurrence for duplicate supported offers', () => {
+    expect(selectSubprotocol(['text.ircv3.net', 'text.ircv3.net'])).toBe('text.ircv3.net');
+  });
+});

package/packages/irc-core/tsconfig.build.json

@@ -5,7 +5,7 @@
     "rootDir": "./src",
     "outDir": "./dist",
     "tsBuildInfoFile": "./.tsbuildinfo",
-    "types": []
+    "types": ["node"]
   },
   "include": ["src/**/*.ts"],
   "exclude": ["dist", "tests", "**/*.test.ts"]

package/packages/irc-core/tsconfig.test.json

@@ -2,7 +2,7 @@
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
     "noEmit": true,
-    "types": [],
+    "types": ["node"],
     "composite": false
   },
   "include": ["src/**/*.ts", "tests/**/*.ts"],

package/packages/irc-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/irc-server",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "private": true,
   "description": "Orchestration layer: IrcRuntime port, dispatch interpreter, ConnectionActor",
   "license": "BSD-3-Clause",