serverless-ircd 0.5.0 → 0.7.0

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

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest';
+import { InMemoryReadMarkerStore, type ReadMarkerStore } from '../src/ports';
+
+describe('InMemoryReadMarkerStore — port conformance', () => {
+  it('implements the ReadMarkerStore port', () => {
+    const store: ReadMarkerStore = new InMemoryReadMarkerStore();
+    expect(store).toBeDefined();
+  });
+});
+
+describe('InMemoryReadMarkerStore — set + get', () => {
+  it('returns undefined for an unknown (account, channel) pair', () => {
+    const store = new InMemoryReadMarkerStore();
+    expect(store.get('alice', '#foo')).toBeUndefined();
+  });
+
+  it('stores and returns the msgid for a known (account, channel) pair', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('alice', '#foo', 'm1');
+    expect(store.get('alice', '#foo')).toBe('m1');
+  });
+
+  it('overwrites the marker on a subsequent set for the same pair', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('alice', '#foo', 'm1');
+    store.set('alice', '#foo', 'm2');
+    expect(store.get('alice', '#foo')).toBe('m2');
+  });
+
+  it('keys channels case-insensitively (rfc1459 fold)', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('alice', '#Foo', 'm1');
+    expect(store.get('alice', '#foo')).toBe('m1');
+    expect(store.get('alice', '#FOO')).toBe('m1');
+  });
+
+  it('keys accounts case-insensitively (rfc1459 fold)', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('Alice', '#foo', 'm1');
+    expect(store.get('alice', '#foo')).toBe('m1');
+    expect(store.get('ALICE', '#foo')).toBe('m1');
+  });
+
+  it('keeps markers for distinct accounts on the same channel separate', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('alice', '#foo', 'm1');
+    store.set('bob', '#foo', 'm9');
+    expect(store.get('alice', '#foo')).toBe('m1');
+    expect(store.get('bob', '#foo')).toBe('m9');
+  });
+
+  it('keeps markers for distinct channels on the same account separate', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('alice', '#foo', 'm1');
+    store.set('alice', '#bar', 'm2');
+    expect(store.get('alice', '#foo')).toBe('m1');
+    expect(store.get('alice', '#bar')).toBe('m2');
+  });
+});
+
+describe('InMemoryReadMarkerStore — forAccount', () => {
+  it('returns an empty array for an account with no markers', () => {
+    const store = new InMemoryReadMarkerStore();
+    expect(store.forAccount('alice')).toEqual([]);
+  });
+
+  it('returns every (channel, msgid) pair recorded for the account', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('alice', '#foo', 'm1');
+    store.set('alice', '#bar', 'm2');
+
+    const entries = store.forAccount('alice');
+    expect(entries).toHaveLength(2);
+    const byChan = Object.fromEntries(entries.map((e) => [e.channel, e.msgid]));
+    expect(byChan['#foo']).toBe('m1');
+    expect(byChan['#bar']).toBe('m2');
+  });
+
+  it('reports the account name on each entry', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('alice', '#foo', 'm1');
+    const entries = store.forAccount('alice');
+    expect(entries[0]?.account).toBe('alice');
+  });
+
+  it('reflects the most recent set when a pair is overwritten', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('alice', '#foo', 'm1');
+    store.set('alice', '#foo', 'm2');
+    const entries = store.forAccount('alice');
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.msgid).toBe('m2');
+  });
+
+  it('does not leak markers belonging to a different account', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('alice', '#foo', 'm1');
+    store.set('bob', '#bar', 'm2');
+    expect(store.forAccount('alice')).toHaveLength(1);
+    expect(store.forAccount('bob')).toHaveLength(1);
+  });
+
+  it('folds the account name case-insensitively on lookup', () => {
+    const store = new InMemoryReadMarkerStore();
+    store.set('Alice', '#foo', 'm1');
+    expect(store.forAccount('ALICE')).toHaveLength(1);
+  });
+});

package/packages/irc-core/tests/standard-replies.test.ts

@@ -0,0 +1,412 @@
+import { describe, expect, it } from 'vitest';
+import type { RawLine } from '../src/effects';
+import { Numerics } from '../src/protocol/numerics';
+import { numericToStandardReply, toStandardReply } from '../src/protocol/standard-replies';
+
+const L = (text: string): RawLine => ({ text });
+
+const CAPS = new Set<string>(['standard-replies']);
+const NO_CAPS = new Set<string>();
+
+const SERVER = 'irc.example.com';
+
+/**
+ * Builds a numeric line in the canonical `:server CODE nick [middle] :trailing`
+ * form this server emits.
+ */
+function numericLine(
+  code: number,
+  nick: string,
+  middle: string | undefined,
+  trailing: string,
+): RawLine {
+  const codeStr = code.toString().padStart(3, '0');
+  const parts = [`:${SERVER}`, codeStr, nick];
+  if (middle !== undefined) parts.push(middle);
+  parts.push(`:${trailing}`);
+  return L(parts.join(' '));
+}
+
+// ============================================================================
+// toStandardReply — 461 ERR_NEEDMOREPARAMS (the seed case)
+// ============================================================================
+
+describe('toStandardReply — 461 ERR_NEEDMOREPARAMS', () => {
+  it('rewrites 461 to FAIL <command> INVALID_PARAMS :description for a cap-enabled client', () => {
+    // Arrange: the canonical 461 form emitted by every reducer that ships a
+    // command name in the middle slot. The cap-enabled client should see
+    // the structured FAIL form instead.
+    const input = numericLine(
+      Numerics.ERR_NEEDMOREPARAMS,
+      'alice',
+      'JOIN',
+      'Not enough parameters',
+    );
+
+    // Act
+    const out = toStandardReply(input, CAPS);
+
+    // Assert: middle (JOIN) becomes the FAIL COMMAND; the trailing text is
+    // preserved verbatim as the description. The nick token is dropped —
+    // standard replies are addressed by routing, not by the nick field.
+    expect(out.text).toBe(`:${SERVER} FAIL JOIN INVALID_PARAMS :Not enough parameters`);
+  });
+});
+
+// ============================================================================
+// toStandardReply — 403 ERR_NOSUCHCHANNEL
+// ============================================================================
+
+describe('toStandardReply — 403 ERR_NOSUCHCHANNEL', () => {
+  it('rewrites 403 to FAIL JOIN NO_SUCH_CHANNEL <channel> :description', () => {
+    const input = numericLine(
+      Numerics.ERR_NOSUCHCHANNEL,
+      'alice',
+      '#nonexistent',
+      'No such channel',
+    );
+
+    const out = toStandardReply(input, CAPS);
+
+    // The numeric's middle (the bad channel name) is emitted as the
+    // standard-reply context, and the reducer's command (best known as
+    // JOIN here — the most common caller) is the FAIL COMMAND.
+    expect(out.text).toBe(`:${SERVER} FAIL JOIN NO_SUCH_CHANNEL #nonexistent :No such channel`);
+  });
+});
+
+// ============================================================================
+// toStandardReply — 432 ERR_ERRONEUSNICKNAME
+// ============================================================================
+
+describe('toStandardReply — 432 ERR_ERRONEUSNICKNAME', () => {
+  it('rewrites 432 to FAIL NICK INVALID_NICK <nick> :description', () => {
+    const input = numericLine(
+      Numerics.ERR_ERRONEUSNICKNAME,
+      'alice',
+      'b@dnick',
+      'Erroneous nickname',
+    );
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out.text).toBe(`:${SERVER} FAIL NICK INVALID_NICK b@dnick :Erroneous nickname`);
+  });
+});
+
+// ============================================================================
+// toStandardReply — 433 ERR_NICKNAMEINUSE
+// ============================================================================
+
+describe('toStandardReply — 433 ERR_NICKNAMEINUSE', () => {
+  it('rewrites 433 to FAIL NICK NICKNAME_IN_USE <nick> :description', () => {
+    const input = numericLine(
+      Numerics.ERR_NICKNAMEINUSE,
+      'alice',
+      'bob',
+      'Nickname is already in use',
+    );
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out.text).toBe(`:${SERVER} FAIL NICK NICKNAME_IN_USE bob :Nickname is already in use`);
+  });
+});
+
+// ============================================================================
+// toStandardReply — 904 ERR_SASLFAIL (SASL failure)
+// ============================================================================
+
+describe('toStandardReply — 904 ERR_SASLFAIL', () => {
+  it('rewrites 904 to FAIL AUTHENTICATE SASL_FAILED :description', () => {
+    const input = numericLine(
+      Numerics.ERR_SASLFAIL,
+      'alice',
+      undefined,
+      'SASL authentication failed',
+    );
+
+    const out = toStandardReply(input, CAPS);
+
+    // 904 has no middle parameter; the structured form carries only the
+    // fixed AUTHENTICATE command and the SASL_FAILED code.
+    expect(out.text).toBe(`:${SERVER} FAIL AUTHENTICATE SASL_FAILED :SASL authentication failed`);
+  });
+});
+
+// ============================================================================
+// toStandardReply — legacy client gating (no standard-replies cap)
+// ============================================================================
+
+describe('toStandardReply — legacy client gating', () => {
+  it('returns the unchanged 461 numeric when the recipient lacks the cap', () => {
+    const input = numericLine(
+      Numerics.ERR_NEEDMOREPARAMS,
+      'alice',
+      'JOIN',
+      'Not enough parameters',
+    );
+
+    // Same line, same object identity — the helper short-circuits before
+    // touching the table when the cap is absent.
+    const out = toStandardReply(input, NO_CAPS);
+
+    expect(out).toBe(input);
+    expect(out.text).toBe(`:${SERVER} 461 alice JOIN :Not enough parameters`);
+  });
+
+  it('returns the unchanged 403 numeric when the recipient lacks the cap', () => {
+    const input = numericLine(Numerics.ERR_NOSUCHCHANNEL, 'alice', '#nope', 'No such channel');
+
+    const out = toStandardReply(input, NO_CAPS);
+
+    expect(out).toBe(input);
+    expect(out.text).toBe(`:${SERVER} 403 alice #nope :No such channel`);
+  });
+
+  it('returns the unchanged 433 numeric when the recipient lacks the cap', () => {
+    const input = numericLine(
+      Numerics.ERR_NICKNAMEINUSE,
+      'alice',
+      'bob',
+      'Nickname is already in use',
+    );
+
+    const out = toStandardReply(input, NO_CAPS);
+
+    expect(out).toBe(input);
+    expect(out.text).toBe(`:${SERVER} 433 alice bob :Nickname is already in use`);
+  });
+
+  it('returns the unchanged 904 numeric when the recipient lacks the cap', () => {
+    const input = numericLine(
+      Numerics.ERR_SASLFAIL,
+      'alice',
+      undefined,
+      'SASL authentication failed',
+    );
+
+    const out = toStandardReply(input, NO_CAPS);
+
+    expect(out).toBe(input);
+    expect(out.text).toBe(`:${SERVER} 904 alice :SASL authentication failed`);
+  });
+});
+
+// ============================================================================
+// toStandardReply — non-curated numerics pass through unchanged
+// ============================================================================
+
+describe('toStandardReply — non-curated numerics pass through', () => {
+  it('passes a 372 RPL_MOTD line through unchanged for a cap-enabled client', () => {
+    // Numeric-only families (MOTD lines, NAMES, the welcome block, …) are
+    // intentionally left on the numeric form per the spec.
+    const input = numericLine(Numerics.RPL_MOTD, 'alice', undefined, '- Welcome to ExampleNet');
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+
+  it('passes a 001 RPL_WELCOME line through unchanged for a cap-enabled client', () => {
+    const input = numericLine(Numerics.RPL_WELCOME, 'alice', undefined, 'Welcome to the network');
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+
+  it('passes a 353 RPL_NAMREPLY line through unchanged for a cap-enabled client', () => {
+    // NAMES replies carry two middle tokens (sigil + channel); they are
+    // not in the curated set and must be delivered verbatim.
+    const input = numericLine(Numerics.RPL_NAMREPLY, 'alice', '= #foo', 'alice bob @carol');
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+});
+
+// ============================================================================
+// toStandardReply — non-numeric lines pass through unchanged
+// ============================================================================
+
+describe('toStandardReply — non-numeric lines pass through', () => {
+  it('passes a PRIVMSG line through unchanged for a cap-enabled client', () => {
+    const input = L(':alice!alice@example.com PRIVMSG #foo :hi');
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+
+  it('passes a FAIL line already emitted by a reducer through unchanged', () => {
+    // Defensive: a reducer that already emits the structured form must not
+    // be re-translated. The leading token after the prefix is `FAIL`, not
+    // a three-digit numeric, so the parser rejects it.
+    const input = L(`:${SERVER} FAIL JOIN INVALID_PARAMS :Not enough parameters`);
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+
+  it('passes a line without a server prefix through unchanged', () => {
+    // e.g. a server-to-server PING carrying no leading `:`. Defensive.
+    const input = L('PING :ping.example.com');
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+});
+
+// ============================================================================
+// toStandardReply — defensive parsing (malformed numeric lines)
+// ============================================================================
+
+describe('toStandardReply — malformed numeric lines pass through', () => {
+  it('passes a bare server prefix through unchanged (no space, no code)', () => {
+    // `:irc.example.com` alone — every reducer emits at least one trailing
+    // token, so this never ships in practice; defensive.
+    const input = L(`:${SERVER}`);
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+
+  it('passes a server prefix with a single trailing token through unchanged', () => {
+    // `:irc.example.com 001` — no second space, so no nick and no trailing.
+    const input = L(`:${SERVER} 001`);
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+
+  it('passes a server prefix with a non-numeric command token through unchanged', () => {
+    // `:server PING …` — second token is not three digits, so this is not
+    // a numeric line; pass through verbatim.
+    const input = L(`:${SERVER} PING :ping`);
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+
+  it('passes a curated numeric line with no nick token through unchanged', () => {
+    // `:server 461 :trailing` — no nick between code and trailing. Every
+    // reducer emits the nick, so this never ships; defensive.
+    const input = L(`:${SERVER} 461 :Not enough parameters`);
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+
+  it('passes a numeric line with trailing whitespace after the code through unchanged', () => {
+    // `:server 001 ` — secondSpace is found but afterCode is empty. The
+    // reducer never emits this; defensive.
+    const input = L(`:${SERVER} 001 `);
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+
+  it('passes a numeric line whose head collapses to empty after trim through unchanged', () => {
+    // `:server 001   :trailing` — multiple spaces after the code, then the
+    // trailing param. The nick slot is empty after trimming; defensive.
+    const input = L(`:${SERVER} 001   :trailing`);
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+
+  it('passes a curated numeric line with no trailing parameter through unchanged', () => {
+    // `:server 461 alice JOIN` — no `:trailing`. The structured reply form
+    // requires a description, so the translator bails and the bare numeric
+    // ships verbatim (defensive).
+    const input = L(`:${SERVER} 461 alice JOIN`);
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+
+  it('passes a curated numeric line whose command-from-middle has no middle through unchanged', () => {
+    // 461 normally carries the failed command name as its middle param.
+    // When the middle is missing, the translator cannot infer the COMMAND
+    // token (required by the spec), so it bails and ships the numeric
+    // verbatim. Mirrors how some legacy daemons emit `461 nick :msg`.
+    const input = L(`:${SERVER} 461 alice :Not enough parameters`);
+
+    const out = toStandardReply(input, CAPS);
+
+    expect(out).toBe(input);
+  });
+
+  it('passes a curated context-bearing numeric line with no middle through unchanged', () => {
+    // 403 normally carries the bad channel name as its middle param. When
+    // the middle is missing, no context token is available, so the FAIL
+    // form degrades to `FAIL JOIN NO_SUCH_CHANNEL :description` (no context).
+    const input = L(`:${SERVER} 403 alice :No such channel`);
+
+    const out = toStandardReply(input, CAPS);
+
+    // The structured form is still emitted; only the context slot is
+    // elided when the middle is missing.
+    expect(out.text).toBe(`:${SERVER} FAIL JOIN NO_SUCH_CHANNEL :No such channel`);
+  });
+});
+
+// ============================================================================
+// numericToStandardReply — table data
+// ============================================================================
+
+describe('numericToStandardReply — curated table', () => {
+  it('maps every curated numeric from the ticket to a FAIL', () => {
+    const curated: ReadonlyArray<[number, string]> = [
+      [Numerics.ERR_NEEDMOREPARAMS, 'INVALID_PARAMS'],
+      [Numerics.ERR_NOSUCHCHANNEL, 'NO_SUCH_CHANNEL'],
+      [Numerics.ERR_ERRONEUSNICKNAME, 'INVALID_NICK'],
+      [Numerics.ERR_NICKNAMEINUSE, 'NICKNAME_IN_USE'],
+      [Numerics.ERR_SASLFAIL, 'SASL_FAILED'],
+    ];
+    for (const [code, expected] of curated) {
+      const mapping = numericToStandardReply.get(code);
+      expect(mapping).toBeDefined();
+      expect(mapping?.kind).toBe('FAIL');
+      expect(mapping?.code).toBe(expected);
+    }
+  });
+
+  it('leaves a non-curated error numeric unmapped', () => {
+    expect(numericToStandardReply.has(Numerics.ERR_NOSUCHNICK)).toBe(false);
+    expect(numericToStandardReply.has(Numerics.RPL_WELCOME)).toBe(false);
+    expect(numericToStandardReply.has(Numerics.ERR_PASSWDMISMATCH)).toBe(false);
+  });
+
+  it('declares a command strategy for every mapping (no ambiguous rows)', () => {
+    // Invariant: every row resolves a COMMAND. When commandFromMiddle is
+    // false, a fixed `command` MUST be supplied — otherwise the helper
+    // would have to bail at runtime.
+    for (const mapping of numericToStandardReply.values()) {
+      if (mapping.commandFromMiddle) {
+        expect(mapping.contextFromMiddle).toBe(false);
+      } else {
+        expect(mapping.command).toBeDefined();
+      }
+    }
+  });
+
+  it('never declares both commandFromMiddle and contextFromMiddle simultaneously', () => {
+    // The two strategies consume the same middle slot; they are mutually
+    // exclusive by construction.
+    for (const mapping of numericToStandardReply.values()) {
+      expect(mapping.commandFromMiddle && mapping.contextFromMiddle).toBe(false);
+    }
+  });
+});

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

@@ -131,6 +131,33 @@ describe('Ctx / Reducer types', () => {
     const ctx = makeCtx();
     expect(ctx.history).toBeUndefined();
   });
+
+  it('threads an inbound label through buildCtx onto ctx.label', () => {
+    const ctx = buildCtx({
+      serverConfig: {
+        serverName: 'irc.example.com',
+        networkName: 'ExampleNet',
+        maxChannelsPerUser: 30,
+        maxTargetsPerCommand: 10,
+        maxListEntries: 50,
+        nickLen: 30,
+        channelLen: 50,
+        topicLen: 390,
+        quitMessage: 'Client Quit',
+      },
+      clock: new FakeClock(1_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: createConnection({ id: 'c1', connectedSince: 0 }),
+      label: 'foo',
+    });
+    expect(ctx.label).toBe('foo');
+  });
+
+  it('omits ctx.label when no label is supplied', () => {
+    const ctx = makeCtx();
+    expect(ctx.label).toBeUndefined();
+  });
 });
 
 describe('ServerConfig shape', () => {

package/packages/irc-server/package.json

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