serverless-ircd 0.8.0 → 0.10.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/markread.test.ts

@@ -115,6 +115,24 @@ describe('markreadChannelReducer — cap gating', () => {
       Effect.send('c1', [L(':irc.example.com 421 alice MARKREAD :Unknown command')]),
     ]);
   });
+
+  it('substitutes * for the nick in the 421 numeric when the connection has no nick', () => {
+    const chan = makeChan();
+    // A bare connection: no nick set and no draft/read-marker cap negotiated.
+    // The 421 numeric's `ctx.connection.nick ?? '*'` falls back to `*`.
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = markreadChannelReducer(
+      chan,
+      { command: 'MARKREAD', params: ['#foo', ts(2_000)], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 421 * MARKREAD :Unknown command')]),
+    ]);
+  });
 });
 
 // ============================================================================
@@ -168,6 +186,42 @@ describe('markreadChannelReducer — parameter errors', () => {
       Effect.send('c1', [READ_MARKER_FAIL('INVALID_PARAMS', 'Invalid parameters')]),
     ]);
   });
+
+  it('FAILs with INVALID_PARAMS when the timestamp prefix is present but the value is empty', () => {
+    const chan = makeChan();
+    addMember(chan, 'c1', 'alice');
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 3);
+    const ctx = makeCtx(makeConn(), new FakeClock(10_000), store);
+
+    const out = markreadChannelReducer(
+      chan,
+      { command: 'MARKREAD', params: ['#foo', 'timestamp='], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [READ_MARKER_FAIL('INVALID_PARAMS', 'Invalid parameters')]),
+    ]);
+  });
+
+  it('FAILs with INVALID_PARAMS when the timestamp value is not a parseable date', () => {
+    const chan = makeChan();
+    addMember(chan, 'c1', 'alice');
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 3);
+    const ctx = makeCtx(makeConn(), new FakeClock(10_000), store);
+
+    const out = markreadChannelReducer(
+      chan,
+      { command: 'MARKREAD', params: ['#foo', 'timestamp=not-a-date'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [READ_MARKER_FAIL('INVALID_PARAMS', 'Invalid parameters')]),
+    ]);
+  });
 });
 
 // ============================================================================

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

@@ -71,6 +71,25 @@ describe('memoservReducer — services availability', () => {
   });
 });
 
+describe('memoservReducer — empty body', () => {
+  it('replies with the help notice when the PRIVMSG carries no body parameter', () => {
+    const conn = makeConn();
+    const services = new InMemoryServicesStore();
+    const ctx = makeCtx(conn, services);
+    // params: [MEMOSERV_NICK] only — params[1] is undefined, exercising the
+    // `msg.params[1] ?? ''` fallback. The empty body resolves to an empty
+    // subcommand, which emits the help notice.
+    const out = memoservReducer(
+      conn,
+      { command: 'PRIVMSG', params: [MEMOSERV_NICK], tags: {} },
+      ctx,
+    );
+    expect(sentTexts(out.effects)).toContain(
+      ':MemoServ!MemoServ@services NOTICE alice :Available commands: SEND, LIST, READ, DEL',
+    );
+  });
+});
+
 describe('memoservReducer — SEND', () => {
   it('requires the sender to be identified', () => {
     const services = new InMemoryServicesStore({ clock: new FakeClock(NOW) });