serverless-ircd 0.8.0 → 0.9.0

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

@@ -139,6 +139,77 @@ describe('hostservReducer — dispatch', () => {
     expect(sentTexts(out.effects).some((t) => t.includes('Unknown command'))).toBe(true);
   });
 
+  it('hides oper-only commands from a non-oper on empty body', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    const conn = identifiedConn('bob');
+    const ctx = makeCtx(conn, services);
+
+    const out = hostservReducer(conn, privmsg(''), ctx);
+
+    const lines = sentTexts(out.effects);
+    expect(lines).toContain(
+      ':HostServ!HostServ@services NOTICE bob :Available commands: ON, OFF, REQUEST',
+    );
+    const helpLine = lines.find((t) => t.includes('Available commands'));
+    for (const cmd of ['SET', 'APPROVE', 'REJECT', 'LIST']) {
+      expect(helpLine).not.toContain(cmd);
+    }
+  });
+
+  it('lists the full command set to an oper on empty body', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    const conn = operConn('admin');
+    const ctx = makeCtx(conn, services);
+
+    const out = hostservReducer(conn, privmsg(''), ctx);
+
+    expect(sentTexts(out.effects)).toContain(
+      ':HostServ!HostServ@services NOTICE admin :Available commands: ON, OFF, REQUEST, SET, APPROVE, REJECT, LIST',
+    );
+  });
+
+  it('hides oper-only commands from a non-oper on an unknown subcommand', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    const conn = identifiedConn('bob');
+    const ctx = makeCtx(conn, services);
+
+    const out = hostservReducer(conn, privmsg('FOOBAR'), ctx);
+
+    const lines = sentTexts(out.effects);
+    expect(lines).toContain(
+      ':HostServ!HostServ@services NOTICE bob :Unknown command. Available: ON, OFF, REQUEST',
+    );
+    const unknownLine = lines.find((t) => t.includes('Unknown command'));
+    for (const cmd of ['SET', 'APPROVE', 'REJECT', 'LIST']) {
+      expect(unknownLine).not.toContain(cmd);
+    }
+  });
+
+  it('lists the full command set to an oper on an unknown subcommand', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    const conn = operConn('admin');
+    const ctx = makeCtx(conn, services);
+
+    const out = hostservReducer(conn, privmsg('FOOBAR'), ctx);
+
+    expect(sentTexts(out.effects)).toContain(
+      ':HostServ!HostServ@services NOTICE admin :Unknown command. Available: ON, OFF, REQUEST, SET, APPROVE, REJECT, LIST',
+    );
+  });
+
+  it('still rejects a non-oper who guesses an oper-only command (LIST)', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    services.requestVhost('alice', 'cool.example.net');
+    const conn = identifiedConn('bob');
+    const ctx = makeCtx(conn, services);
+
+    const out = hostservReducer(conn, privmsg('LIST'), ctx);
+
+    expect(sentTexts(out.effects)).toContain(
+      ':HostServ!HostServ@services NOTICE bob :You must be an oper to use LIST.',
+    );
+  });
+
   it('updates lastSeen to ctx.clock.now()', () => {
     const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
     const conn = identifiedConn('alice');

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

@@ -1064,6 +1064,83 @@ describe('joinReducer — KEEPTOPIC restore from ServicesStore', () => {
   });
 });
 
+// ============================================================================
+// joinReducer — TOPIC numerics (332/333) on JOIN
+// ============================================================================
+//
+// RFC 2812 §3.2.1: after a successful JOIN the server sends 332 RPL_TOPIC
+// and 333 RPL_TOPICWHOTIME whenever a topic is set, regardless of how the
+// topic reached the authoritative ChannelState (KEEPTOPIC restore, a
+// deploy snapshot, or an earlier joiner). These tests pin the behaviour
+// that was previously missing for every non-KEEPTOPIC-restore code path.
+// ============================================================================
+
+describe('joinReducer — TOPIC numerics on JOIN', () => {
+  it('emits 332/333 to the joiner when state.topic is already set (deploy snapshot)', () => {
+    const chan = makeChan('#foo');
+    // Simulate a topic that survived a deploy in storage and was loaded
+    // onto the authoritative ChannelState before this JOIN (empty roster,
+    // no KEEPTOPIC restore path taken).
+    chan.topic = { text: 'persisted topic', setter: 'alice!alice@example.com', setAt: 5_000 };
+    const conn = makeConn('c1', 'bob');
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text) : []));
+    expect(texts).toContain(':irc.example.com 332 bob #foo :persisted topic');
+    expect(
+      texts.some((t) => t.startsWith(':irc.example.com 333 bob #foo alice!alice@example.com 5000')),
+    ).toBe(true);
+  });
+
+  it('emits 332/333 to a second joiner when the topic was set by an earlier joiner', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c0', 'alice', true);
+    // Topic set by an earlier joiner on a non-empty channel.
+    chan.topic = { text: 'hello world', setter: 'alice!alice@example.com', setAt: 1_000 };
+    const conn = makeConn('c1', 'bob');
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text) : []));
+    expect(texts).toContain(':irc.example.com 332 bob #foo :hello world');
+    expect(
+      texts.some((t) => t.startsWith(':irc.example.com 333 bob #foo alice!alice@example.com 1000')),
+    ).toBe(true);
+  });
+
+  it('emits 332/333 after the 353/366 NAMES list (existing emission order)', () => {
+    const chan = makeChan('#foo');
+    chan.topic = { text: 't', setter: 's', setAt: 1 };
+    const conn = makeConn('c1', 'bob');
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const send = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text) : []));
+    const idx353 = send.findIndex((t) => t.includes(' 353 '));
+    const idx366 = send.findIndex((t) => t.includes(' 366 '));
+    const idx332 = send.findIndex((t) => t.includes(' 332 '));
+    expect(idx353).toBeGreaterThanOrEqual(0);
+    expect(idx366).toBeGreaterThan(idx353);
+    expect(idx332).toBeGreaterThan(idx366);
+  });
+
+  it('does not emit 332/333 when no topic is set', () => {
+    const chan = makeChan('#foo');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text) : []));
+    expect(texts.some((t) => t.includes(' 332 '))).toBe(false);
+    expect(texts.some((t) => t.includes(' 333 '))).toBe(false);
+  });
+});
+
 // ============================================================================
 // joinReducer — ChanServ ACCESS auto-op / auto-voice
 // ============================================================================
@@ -1269,6 +1346,108 @@ describe('joinReducer — ChanServ ACCESS auto-prefix', () => {
     expect(broadcasts.some((t) => t.includes('ChanServ MODE'))).toBe(false);
   });
 
+  it('does not auto-op the first joiner of an empty registered channel when off the access list', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerNick('bob', 'pw', 'b@e');
+    services.registerChannel('#foo', 'alice');
+    const chan = makeChan('#foo');
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(false);
+    expect(entry?.voice).toBe(false);
+    const broadcasts = out.effects.flatMap((e) =>
+      e.tag === 'Broadcast' && e.chan === '#foo' ? e.lines.map((l) => l.text) : [],
+    );
+    expect(broadcasts.some((t) => t.includes('ChanServ MODE'))).toBe(false);
+    expect(broadcasts.some((t) => t.includes('+o bob'))).toBe(false);
+  });
+
+  it('auto-ops the first joiner of an empty registered channel when they hold AUTOOP-level access', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerNick('bob', 'pw', 'b@e');
+    services.registerChannel('#foo', 'alice');
+    services.setChannelAccess('#foo', 'bob', 5);
+    const chan = makeChan('#foo');
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(true);
+  });
+
+  it('does not auto-op an unidentified first joiner of an empty registered channel', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    const chan = makeChan('#foo');
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'bob');
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(false);
+  });
+
+  it('still auto-ops the founder first-joining an empty registered channel', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    const chan = makeChan('#foo');
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'alice');
+    conn.account = 'alice';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(true);
+  });
+
+  it('auto-ops the first joiner of an empty channel when services are bound but the channel is unregistered', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('bob', 'pw', 'b@e');
+    const chan = makeChan('#foo');
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(true);
+  });
+
+  it('auto-ops the first joiner of an empty channel when no services store is bound', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('bob', 'pw', 'b@e');
+    const chan = makeChan('#foo');
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, undefined);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(true);
+  });
+
   it('does nothing when no services store is bound', () => {
     const chan = makeChan('#foo');
     chan.members.set('c0', { conn: 'c0', nick: 'alice', op: true, voice: false });

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

@@ -283,6 +283,144 @@ describe('nickservReducer — IDENTIFY', () => {
   });
 });
 
+describe('nickservReducer — ID (alias for IDENTIFY)', () => {
+  it('sets +r and account on correct password (ID <password>)', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    services.registerNick('alice', 'hunter2', 'alice@example.com');
+    const conn = makeConn();
+    const ctx = makeCtx(conn, services);
+
+    const out = nickservReducer(conn, privmsg('ID hunter2'), ctx);
+
+    expect(conn.account).toBe('alice');
+    expect(conn.userModes.registered).toBe(true);
+    expect(sentTexts(out.effects)).toContain(
+      ':NickServ!NickServ@services NOTICE alice :You are now identified for nick alice.',
+    );
+  });
+
+  it('is case-insensitive on the subcommand (id)', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    services.registerNick('alice', 'hunter2', 'alice@example.com');
+    const conn = makeConn();
+    const ctx = makeCtx(conn, services);
+
+    nickservReducer(conn, privmsg('id hunter2'), ctx);
+
+    expect(conn.account).toBe('alice');
+    expect(conn.userModes.registered).toBe(true);
+  });
+
+  it('rejects ID with wrong password (no +r, NOTICE only)', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    services.registerNick('alice', 'hunter2', 'alice@example.com');
+    const conn = makeConn();
+    const ctx = makeCtx(conn, services);
+
+    const out = nickservReducer(conn, privmsg('ID wrongpw'), ctx);
+
+    expect(conn.account).toBeUndefined();
+    expect(conn.userModes.registered).toBe(false);
+    expect(sentTexts(out.effects)).toContain(
+      ':NickServ!NickServ@services NOTICE alice :Invalid password.',
+    );
+    expect(out.effects.filter((e) => e.tag === 'Broadcast')).toHaveLength(0);
+  });
+
+  it('sets +r and account for ID <nick> <password>', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    services.registerNick('alice', 'hunter2', 'alice@example.com');
+    // Connection is using nick "bob" but identifies as "alice".
+    const conn = makeConn('c1', 'bob');
+    const ctx = makeCtx(conn, services);
+
+    const out = nickservReducer(conn, privmsg('ID alice hunter2'), ctx);
+
+    expect(conn.account).toBe('alice');
+    expect(conn.userModes.registered).toBe(true);
+    expect(sentTexts(out.effects)).toContain(
+      ':NickServ!NickServ@services NOTICE bob :You are now identified for nick alice.',
+    );
+  });
+});
+
+// ============================================================================
+// IDENTIFY — HostServ vhost auto-apply on identify
+// ============================================================================
+
+describe('nickservReducer — IDENTIFY applies HostServ vhost', () => {
+  it('applies an assigned vhost on a successful IDENTIFY', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    services.registerNick('alice', 'hunter2', 'alice@example.com');
+    services.setVhost('alice', 'cool.example.net');
+    const conn = makeConn();
+    conn.host = 'real.example.net';
+    const ctx = makeCtx(conn, services);
+
+    nickservReducer(conn, privmsg('IDENTIFY hunter2'), ctx);
+
+    expect(conn.account).toBe('alice');
+    expect(conn.vhostActive).toBe(true);
+    expect(conn.host).toBe('cool.example.net');
+    expect(conn.preVhostHost).toBe('real.example.net');
+  });
+
+  it('leaves the host unchanged on IDENTIFY when no vhost is assigned', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    services.registerNick('alice', 'hunter2', 'alice@example.com');
+    const conn = makeConn();
+    conn.host = 'real.example.net';
+    const ctx = makeCtx(conn, services);
+
+    nickservReducer(conn, privmsg('IDENTIFY hunter2'), ctx);
+
+    expect(conn.vhostActive).toBeUndefined();
+    expect(conn.host).toBe('real.example.net');
+  });
+
+  it('emits a CHGHOST broadcast to joined peers on a post-JOIN IDENTIFY', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    services.registerNick('alice', 'hunter2', 'alice@example.com');
+    services.setVhost('alice', 'cool.example.net');
+    const conn = makeConn();
+    conn.user = 'aliceuser';
+    conn.host = 'real.example.net';
+    conn.joinedChannels.add('#foo');
+    const ctx = makeCtx(conn, services);
+
+    const out = nickservReducer(conn, privmsg('IDENTIFY hunter2'), ctx);
+
+    const chghost = out.effects.filter((e) => e.tag === 'Broadcast' && e.cap === 'chghost');
+    expect(chghost).toHaveLength(1);
+    if (chghost[0]?.tag === 'Broadcast') {
+      expect(chghost[0].chan).toBe('#foo');
+      expect(chghost[0].capLines?.[0]?.text).toBe(
+        ':alice!aliceuser@real.example.net CHGHOST aliceuser :cool.example.net',
+      );
+    }
+  });
+
+  it('still emits the NickServ confirmation NOTICE and ACCOUNT broadcast alongside the vhost apply', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    services.registerNick('alice', 'hunter2', 'alice@example.com');
+    services.setVhost('alice', 'cool.example.net');
+    const conn = makeConn();
+    conn.host = 'real.example.net';
+    conn.joinedChannels.add('#foo');
+    const ctx = makeCtx(conn, services);
+
+    const out = nickservReducer(conn, privmsg('IDENTIFY hunter2'), ctx);
+
+    expect(sentTexts(out.effects)).toContain(
+      ':NickServ!NickServ@services NOTICE alice :You are now identified for nick alice.',
+    );
+    const accountBcast = out.effects.find(
+      (e) => e.tag === 'Broadcast' && e.cap === 'account-notify',
+    );
+    expect(accountBcast).toBeDefined();
+  });
+});
+
 describe('nickservReducer — DROP', () => {
   it('removes the registration when the connection is identified', () => {
     const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
@@ -364,10 +502,11 @@ describe('nickservReducer — DROP', () => {
 });
 
 describe('nickservReducer — INFO', () => {
-  it('reports info for a registered nick', () => {
+  it('shows the full record (incl. Email) to the owner via INFO with no target', () => {
     const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
     services.registerNick('alice', 'hunter2', 'alice@example.com');
     const conn = makeConn();
+    conn.account = 'alice';
     const ctx = makeCtx(conn, services);
 
     const out = nickservReducer(conn, privmsg('INFO'), ctx);
@@ -378,10 +517,54 @@ describe('nickservReducer — INFO', () => {
     expect(texts).toContain(':NickServ!NickServ@services NOTICE alice :Email: alice@example.com');
   });
 
-  it('reports info for an explicitly named registered nick', () => {
+  it('withholds Email from a non-owner querying someone else nick', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    services.registerNick('bob', 'pw', 'bob@example.com');
+    const conn = makeConn();
+    const ctx = makeCtx(conn, services);
+
+    const out = nickservReducer(conn, privmsg('INFO bob'), ctx);
+
+    const texts = sentTexts(out.effects);
+    expect(texts).toContain(':NickServ!NickServ@services NOTICE alice :Nick: bob');
+    expect(texts).toContain(':NickServ!NickServ@services NOTICE alice :Account: bob');
+    expect(texts).not.toContain(':NickServ!NickServ@services NOTICE alice :Email: bob@example.com');
+  });
+
+  it('withholds Email from a non-owner querying their own nick when unidentified', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    services.registerNick('alice', 'hunter2', 'alice@example.com');
+    const conn = makeConn();
+    const ctx = makeCtx(conn, services);
+
+    const out = nickservReducer(conn, privmsg('INFO'), ctx);
+
+    const texts = sentTexts(out.effects);
+    expect(texts).toContain(':NickServ!NickServ@services NOTICE alice :Nick: alice');
+    expect(texts).not.toContain(
+      ':NickServ!NickServ@services NOTICE alice :Email: alice@example.com',
+    );
+  });
+
+  it('shows Email to the owner querying their own nick by name', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    services.registerNick('bob', 'pw', 'bob@example.com');
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, services);
+
+    const out = nickservReducer(conn, privmsg('INFO bob'), ctx);
+
+    const texts = sentTexts(out.effects);
+    expect(texts).toContain(':NickServ!NickServ@services NOTICE bob :Nick: bob');
+    expect(texts).toContain(':NickServ!NickServ@services NOTICE bob :Email: bob@example.com');
+  });
+
+  it('shows Email to an oper even when not the owner', () => {
     const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
     services.registerNick('bob', 'pw', 'bob@example.com');
     const conn = makeConn();
+    conn.userModes.oper = true;
     const ctx = makeCtx(conn, services);
 
     const out = nickservReducer(conn, privmsg('INFO bob'), ctx);