serverless-ircd 0.7.0 → 0.9.0

package/packages/irc-core/src/commands/join.ts

@@ -18,14 +18,16 @@
 import { caseFold } from '../case-fold.js';
 import { Effect } from '../effects.js';
 import type { Effect as EffectType, RawLine } from '../effects.js';
-import type { StoredMessage } from '../ports.js';
+import type { PersistedTopic, StoredMessage } from '../ports.js';
 import { wrapBatch } from '../protocol/batch.js';
 import { Numerics } from '../protocol/numerics.js';
-import { type ChanName, type ChannelState, prefixOf } from '../state/channel.js';
+import { type ChanName, type ChannelState, type ChannelTopic, prefixOf } from '../state/channel.js';
 import { hostmaskOf } from '../state/connection.js';
 import type { ConnectionState } from '../state/connection.js';
 import type { Ctx, Reducer } from '../types.js';
+import { CHANSERV_HOSTMASK, DEFAULT_CHANNEL_LEVELS } from './chanserv.js';
 import { CHATHISTORY_CAP, buildChathistoryBatch } from './chathistory.js';
+import { topicNumerics } from './topic.js';
 
 /**
  * RFC 1459/2812 channel-name grammar. The first character must be a channel
@@ -226,6 +228,21 @@ export const joinReducer: Reducer<ChannelState> = (state, msg, ctx) => {
     return { state, effects };
   }
 
+  // ChanServ +R check: unidentified clients may not join a +R channel.
+  if (state.modes.blockUnidentified && ctx.connection.account === undefined) {
+    effects.push(
+      Effect.send(ctx.connId, [
+        numericErr(
+          ctx,
+          Numerics.ERR_ALLMUSTREGISTER,
+          'You must register with NickServ to join this channel',
+          rawName,
+        ),
+      ]),
+    );
+    return { state, effects };
+  }
+
   // Limit check.
   if (state.modes.limit !== undefined && state.members.size >= state.modes.limit) {
     effects.push(
@@ -249,15 +266,49 @@ export const joinReducer: Reducer<ChannelState> = (state, msg, ctx) => {
     }
   }
 
-  // All checks passed: add to roster. First joiner gets op per RFC 2812.
-  const isFirst = state.members.size === 0;
+  // All checks passed: add to roster. First joiner gets op per RFC 2812,
+  // unless the channel is ChanServ-registered — in that case the first
+  // joiner is opped only when they are the founder or meet the AUTOOP
+  // level (computeChanservAutoPrefix), so a random user reconnecting
+  // first after a roster-wiping deploy cannot seize op in a channel they
+  // do not own. The real founder / access-list users who join later are
+  // opped by the same access check on the non-empty path.
+  const wasEmpty = state.members.size === 0;
+  // ChanServ ACCESS auto-prefix: always look up the joiner's access level
+  // so the empty-channel gating above and the non-empty case share one
+  // code path. `autoPrefix` is non-null only when ChanServ could resolve
+  // the joiner's access (services bound, channel registered, joiner
+  // identified); it carries {op:false,voice:false} when the joiner is on
+  // no list, and null when ChanServ is not authoritative for this join
+  // (services unbound / channel unregistered / joiner unidentified).
+  const autoPrefix = computeChanservAutoPrefix(ctx, state.nameLower);
+  const channelRegistered = ctx.services?.getChannel(state.nameLower) !== undefined;
+  // RFC 2812 first-joiner op applies only when the channel is NOT
+  // registered. A registered channel's first joiner gets op solely via
+  // the access check (founder / AUTOOP), never by the empty-channel rule.
+  const grantOp = (wasEmpty && !channelRegistered) || (autoPrefix?.op ?? false);
+  const grantVoice = autoPrefix?.voice ?? false;
+  const joinerNick = ctx.connection.nick ?? '?';
   state.members.set(ctx.connId, {
     conn: ctx.connId,
-    nick: ctx.connection.nick ?? '?',
-    op: isFirst,
-    voice: false,
+    nick: joinerNick,
+    op: grantOp,
+    voice: grantVoice,
   });
 
+  // ChanServ KEEPTOPIC restore: when the channel was empty immediately
+  // before this join and services have a persisted topic snapshot for a
+  // keep-topic-enabled registration, restore the topic onto the
+  // authoritative ChannelState. The 332/333 numerics are emitted to the
+  // joiner below alongside the NAMES list, keyed off `state.topic`.
+  if (wasEmpty) {
+    const restored = restoreKeepTopic(ctx, state.nameLower);
+    if (restored !== undefined) {
+      state.topic = restored;
+      effects.push(Effect.applyChannelDelta(state.name, { topic: restored }));
+    }
+  }
+
   // Pending invite is consumed on a successful join.
   if (myNick !== undefined) state.pendingInvites.delete(caseFold('rfc1459', myNick));
 
@@ -275,13 +326,26 @@ export const joinReducer: Reducer<ChannelState> = (state, msg, ctx) => {
         {
           type: 'add',
           conn: ctx.connId,
-          nick: ctx.connection.nick ?? '?',
-          op: isFirst,
+          nick: joinerNick,
+          op: grantOp,
+          voice: grantVoice,
         },
       ],
     }),
   );
 
+  // ChanServ auto-prefix broadcast: when ChanServ granted op or voice on
+  // a non-empty channel, emit a `:ChanServ!ChanServ@services MODE #chan
+  // +o nick` broadcast so existing clients update their prefix display.
+  // Suppressed on the empty-channel first-join (wasEmpty) because the
+  // joiner is the channel's only client and already sees their prefix in
+  // the NAMES list — the op grant is silent. Supersedes the implicit
+  // voice when op is granted (the channel-prefix grammar already renders
+  // `@` for ops).
+  if (!wasEmpty && autoPrefix !== null && (autoPrefix.op || autoPrefix.voice)) {
+    effects.push(buildChanservPrefixBroadcast(state.name, joinerNick, autoPrefix));
+  }
+
   // IRCv3 draft/chathistory auto-playback: a cap-enabled joiner with a
   // bound MessageStore receives the recent backlog as a BATCH *before*
   // the JOIN broadcast, then the per-(connection, channel) "last read"
@@ -328,6 +392,13 @@ export const joinReducer: Reducer<ChannelState> = (state, msg, ctx) => {
 
   effects.push(Effect.send(ctx.connId, lines));
 
+  // Emit 332/333 topic numerics to the joiner whenever a topic is set on
+  // the channel, regardless of whether it came from a ChanServ KEEPTOPIC
+  // restore this join, a deploy snapshot, or an earlier joiner. Mirrors
+  // the TOPIC read-form reply shape (RFC 2812 §3.2.1).
+  const topicReply = topicNumerics(state, ctx);
+  if (topicReply !== undefined) effects.push(topicReply);
+
   return { state, effects };
 };
 
@@ -360,3 +431,94 @@ export function handleJoinZero(ctx: Ctx): EffectType[] {
   ctx.connection.joinedChannels.clear();
   return effects;
 }
+
+// ============================================================================
+// ChanServ KEEPTOPIC restore
+// ============================================================================
+
+/**
+ * Returns the persisted topic snapshot to restore on a JOIN that re-creates
+ * an empty channel, or `undefined` when:
+ *   - no services store is bound,
+ *   - the channel is not registered,
+ *   - KEEPTOPIC is off, or
+ *   - no topic snapshot is stored.
+ *
+ * Reads the per-channel lowercased name from the joiner's `nameLower`
+ * field; services-store keys are rfc1459-folded so the lookup is
+ * case-insensitive.
+ */
+function restoreKeepTopic(ctx: Ctx, nameLower: string): ChannelTopic | undefined {
+  const services = ctx.services;
+  if (services === undefined) return undefined;
+  const rec = services.getChannel(nameLower);
+  if (rec === undefined || !rec.keepTopic) return undefined;
+  const persisted: PersistedTopic | undefined = services.getChannelTopic(nameLower);
+  if (persisted === undefined) return undefined;
+  return { text: persisted.text, setter: persisted.setter, setAt: persisted.setAt };
+}
+
+// ============================================================================
+// ChanServ ACCESS auto-prefix
+// ============================================================================
+
+/**
+ * Decides whether ChanServ should auto-grant a channel prefix to the
+ * joining connection on a non-empty registered channel.
+ *
+ * Returns `{ op: true, voice: false }` for the channel founder or any
+ * account whose access level meets the founder-configured `AUTOOP`
+ * threshold; `{ op: false, voice: true }` for accounts that meet the
+ * `AUTOVOICE` threshold; `{ op: false, voice: false }` otherwise.
+ *
+ * Returns `null` when no services store is bound, the channel is not
+ * registered, or the joiner is unidentified — the caller treats all of
+ * those as "no ChanServ-derived prefix" and falls back to the RFC 2812
+ * first-joiner rule or the plain-roster defaults.
+ *
+ * Threshold lookup consults the founder-redefined overrides via
+ * {@link ServicesStore.getChannelLevel} and falls back to
+ * {@link DEFAULT_CHANNEL_LEVELS} for ops the founder has not overridden.
+ */
+function computeChanservAutoPrefix(
+  ctx: Ctx,
+  nameLower: string,
+): { op: boolean; voice: boolean } | null {
+  const services = ctx.services;
+  if (services === undefined) return null;
+  const rec = services.getChannel(nameLower);
+  if (rec === undefined) return null;
+  const account = ctx.connection.account;
+  if (account === undefined) return null;
+  if (caseFold('rfc1459', rec.founder) === caseFold('rfc1459', account)) {
+    return { op: true, voice: false };
+  }
+  const level = services.getChannelAccess(nameLower, account);
+  const autoOp = services.getChannelLevel(nameLower, 'AUTOOP') ?? DEFAULT_CHANNEL_LEVELS.AUTOOP;
+  const autoVoice =
+    services.getChannelLevel(nameLower, 'AUTOVOICE') ?? DEFAULT_CHANNEL_LEVELS.AUTOVOICE;
+  if (level >= autoOp) return { op: true, voice: false };
+  if (level >= autoVoice) return { op: false, voice: true };
+  return { op: false, voice: false };
+}
+
+/**
+ * Builds the `Broadcast` effect for a ChanServ-emitted channel prefix
+ * grant. The line shape mirrors the MODE reducer's ChanServ-MLOCK
+ * reassert broadcast so existing clients already special-case
+ * `:ChanServ!ChanServ@services MODE …` correctly.
+ *
+ * Op grants emit `+o` only (the channel-prefix grammar renders `@` for
+ * ops, so a redundant `+v` would only confuse client UIs that show both
+ * prefixes side-by-side).
+ */
+function buildChanservPrefixBroadcast(
+  chanName: ChanName,
+  nick: string,
+  prefix: { op: boolean; voice: boolean },
+): EffectType {
+  const mode = prefix.op ? '+o' : '+v';
+  return Effect.broadcast(chanName, [
+    { text: `:${CHANSERV_HOSTMASK} MODE ${chanName} ${mode} ${nick}` },
+  ]);
+}

package/packages/irc-core/src/commands/markread.ts

@@ -0,0 +1,202 @@
+/**
+ * Pure reducer for the IRCv3 `draft/read-marker` `MARKREAD` command.
+ *
+ * Spec (work-in-progress): https://ircv3.net/specs/extensions/read-marker
+ *
+ * The serverless-ircd deployment stores read markers **by msgid** (see
+ * {@link ../commands/read-marker.ts}) so they compose with the chathistory
+ * last-read plumbing. The draft `MARKREAD` verb, by contrast, is
+ * timestamp-based: a client sends `MARKREAD <target> <timestamp>` where the
+ * timestamp is the `time` tag of the last read message. This reducer is the
+ * translation layer — it resolves the client timestamp to the most recent
+ * retained message at or before it ({@link MessageStore.findAtOrBefore}),
+ * advances the msgid-based marker via {@link persistReadMarker}, and replies
+ * with the resolved message's timestamp so the client observes a value that
+ * corresponds to a real `time` tag.
+ *
+ * Wire forms handled:
+ *   - `MARKREAD <target>` (GET) — replies with the stored marker's timestamp
+ *     (or `*` when none / unresolvable).
+ *   - `MARKREAD <target> <timestamp>` (SET) — advances the marker subject to
+ *     monotonicity (the marker never moves backwards) and replies with the
+ *     resolved timestamp, or with the stored value when the client timestamp
+ *     is older-or-equal.
+ *
+ * Errors use the IRCv3 `standard-replies` `FAIL` form (the draft specifies no
+ * legacy numerics for `MARKREAD`):
+ *   - `FAIL MARKREAD NEED_MORE_PARAMS :Missing parameters`
+ *   - `FAIL MARKREAD INVALID_PARAMS :Invalid parameters`
+ *
+ * The command is gated behind the `draft/read-marker` capability: a client
+ * that did not negotiate it sees `421 ERR_UNKNOWNCOMMAND` (the spec's
+ * permitted "unknown command" fallback, matching the `TAGMSG` precedent).
+ *
+ * Membership mirrors the `TAGMSG` read-marker path: a non-member on a `+n`
+ * channel is ignored silently (the user has no marker to set or get).
+ */
+
+import { Effect } from '../effects.js';
+import type { RawLine } from '../effects.js';
+import { Numerics } from '../protocol/numerics.js';
+import { formatServerTime } from '../protocol/outbound.js';
+import type { ChannelState } from '../state/channel.js';
+import type { Ctx, Reducer } from '../types.js';
+import { READ_MARKER_CAP, persistReadMarker } from './read-marker.js';
+
+/** Prefix that introduces the server-time timestamp in a SET param. */
+const TIMESTAMP_PREFIX = 'timestamp=';
+
+/** Literal timestamp meaning "no known read marker" (server replies only). */
+const NO_MARKER = '*';
+
+/** Formats a numeric error line addressed to the connection's nick (or `*`). */
+function numericErr(ctx: Ctx, code: number, trailing: string, middle: string): RawLine {
+  const nick = ctx.connection.nick ?? '*';
+  const codeStr = code.toString().padStart(3, '0');
+  return { text: [`:${ctx.serverName}`, codeStr, nick, middle, `:${trailing}`].join(' ') };
+}
+
+/** Formats a `FAIL MARKREAD <code> :<desc>` standard-reply line. */
+function failReply(ctx: Ctx, code: string, desc: string): RawLine {
+  return { text: `:${ctx.serverName} FAIL MARKREAD ${code} :${desc}` };
+}
+
+/** Formats the `:<server> MARKREAD <target> <timestamp>` server reply line. */
+function markreadReply(ctx: Ctx, target: string, timestamp: string): RawLine {
+  return { text: `:${ctx.serverName} MARKREAD ${target} ${timestamp}` };
+}
+
+/**
+ * Formats `ms` as the wire timestamp token carried by every server
+ * `MARKREAD` reply: `timestamp=<server-time>` (matching the client SET form
+ * and the spec examples). `NO_MARKER` (`*`) is returned verbatim by callers
+ * and never passes through here.
+ */
+function timestampTag(ms: number): string {
+  return `${TIMESTAMP_PREFIX}${formatServerTime(ms)}`;
+}
+
+/**
+ * Parses a SET timestamp param (`timestamp=<iso>`) into epoch ms, or
+ * `undefined` when the param is malformed (missing prefix or an unparseable
+ * date). The literal `*` is rejected upstream (it is invalid for SET) before
+ * this helper runs.
+ */
+function parseTimestampParam(raw: string): number | undefined {
+  if (!raw.startsWith(TIMESTAMP_PREFIX)) return undefined;
+  const value = raw.slice(TIMESTAMP_PREFIX.length);
+  if (value.length === 0) return undefined;
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? undefined : ms;
+}
+
+/**
+ * Resolves the connection's current marker for `chanLower` to its message's
+ * epoch-ms time, or `undefined` when there is no marker, no bound message
+ * store, or the marker's message is no longer retained. The epoch-ms form
+ * drives the monotonicity comparison; {@link markerTimestampTag} formats the
+ * wire form for replies.
+ */
+function markerTime(
+  ctx: Ctx,
+  chanLower: string,
+  messages: MessageStoreLike | undefined,
+): number | undefined {
+  const msgid = ctx.connection.lastReadMarkers?.get(chanLower);
+  if (msgid === undefined || messages === undefined) return undefined;
+  return messages.getMsg(chanLower, msgid)?.time;
+}
+
+interface MessageStoreLike {
+  getMsg(chan: string, msgid: string): { time: number } | undefined;
+  findAtOrBefore(chan: string, ts: number): { msgid: string; time: number } | undefined;
+}
+
+/** Reducer for `MARKREAD <channel>` (GET) and `MARKREAD <channel> <ts>` (SET). */
+export const markreadChannelReducer: Reducer<ChannelState> = (state, msg, ctx) => {
+  ctx.connection.lastSeen = ctx.clock.now();
+
+  // Cap gate: clients that did not negotiate draft/read-marker see RFC 2812
+  // only (the spec's permitted "unknown command" fallback).
+  if (!ctx.connection.caps.has(READ_MARKER_CAP)) {
+    return {
+      state,
+      effects: [
+        Effect.send(ctx.connId, [
+          numericErr(ctx, Numerics.ERR_UNKNOWNCOMMAND, 'Unknown command', 'MARKREAD'),
+        ]),
+      ],
+    };
+  }
+
+  const target = msg.params[0];
+  if (target === undefined || target.length === 0) {
+    return {
+      state,
+      effects: [
+        Effect.send(ctx.connId, [failReply(ctx, 'NEED_MORE_PARAMS', 'Missing parameters')]),
+      ],
+    };
+  }
+
+  // Membership: a non-member on a +n channel has no marker to set or get.
+  // Silent, mirroring the TAGMSG read-marker path.
+  const senderEntry = state.members.get(ctx.connId);
+  if (state.modes.noExternal && senderEntry === undefined) {
+    return { state, effects: [] };
+  }
+
+  const messages = ctx.messages as MessageStoreLike | undefined;
+
+  // GET command: reply with the stored marker timestamp (or *).
+  if (msg.params.length < 2) {
+    const stored = markerTime(ctx, state.nameLower, messages);
+    const tag = stored === undefined ? NO_MARKER : timestampTag(stored);
+    return { state, effects: [Effect.send(ctx.connId, [markreadReply(ctx, target, tag)])] };
+  }
+
+  // SET command.
+  const raw = msg.params[1] as string;
+  if (raw === NO_MARKER) {
+    // The literal * is reserved for server replies; a client SET MUST NOT use it.
+    return {
+      state,
+      effects: [Effect.send(ctx.connId, [failReply(ctx, 'INVALID_PARAMS', 'Invalid parameters')])],
+    };
+  }
+  const clientMs = parseTimestampParam(raw);
+  if (clientMs === undefined) {
+    return {
+      state,
+      effects: [Effect.send(ctx.connId, [failReply(ctx, 'INVALID_PARAMS', 'Invalid parameters')])],
+    };
+  }
+
+  // Translate the client timestamp to the most recent retained message at or
+  // before it. Without a bound store, or when nothing matches (e.g. the
+  // timestamp predates every retained message), there is no msgid to advance
+  // to: reply with the current marker and do not mutate state.
+  const resolved = messages?.findAtOrBefore(state.nameLower, clientMs);
+  if (resolved === undefined) {
+    const stored = markerTime(ctx, state.nameLower, messages);
+    const tag = stored === undefined ? NO_MARKER : timestampTag(stored);
+    return { state, effects: [Effect.send(ctx.connId, [markreadReply(ctx, target, tag)])] };
+  }
+
+  // Monotonicity: the marker only ever advances. A client timestamp that
+  // resolves to a message at or before the stored marker is rejected — the
+  // server replies with the stored (newer) value and ignores the client value.
+  const storedMs = markerTime(ctx, state.nameLower, messages);
+  if (storedMs !== undefined && resolved.time <= storedMs) {
+    return {
+      state,
+      effects: [Effect.send(ctx.connId, [markreadReply(ctx, target, timestampTag(storedMs))])],
+    };
+  }
+
+  persistReadMarker(ctx, state.nameLower, resolved.msgid);
+  return {
+    state,
+    effects: [Effect.send(ctx.connId, [markreadReply(ctx, target, timestampTag(resolved.time))])],
+  };
+};