serverless-ircd 0.7.0 → 0.9.0

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

@@ -0,0 +1,319 @@
+/**
+ * Pure reducer for the MemoServ services pseudo-client.
+ *
+ * MemoServ is invoked via `PRIVMSG MemoServ :<command>`. The actor routes
+ * any `PRIVMSG` whose target matches {@link MEMOSERV_NICK}
+ * (case-insensitive) to {@link memoservReducer} instead of the normal
+ * user-target reducer.
+ *
+ * Supported subcommands:
+ *   - `SEND <nick> <message>` — records a memo against the recipient's
+ *     registered account. The caller must be identified (NickServ `+r`).
+ *     The memo is queued and delivered as a MemoServ NOTICE on the
+ *     recipient's next NickServ IDENTIFY (handled by the NickServ
+ *     reducer's `applyIdentify` path).
+ *   - `LIST` — enumerates the caller's unread memos (id, sender, body).
+ *   - `READ <n>` — delivers memo #n to the caller as a NOTICE and marks
+ *     it read.
+ *   - `DEL <n>` — removes memo #n from the caller's inbox.
+ *
+ * The reducer is a pure `Reducer<ConnectionState>`: all side effects are
+ * emitted as {@link Effect}s. The services store is synchronous (mirrors
+ * the {@link AccountStore} / {@link MessageStore} pattern).
+ */
+
+import { caseFold } from '../case-fold.js';
+import { Effect } from '../effects.js';
+import type { Effect as EffectType, RawLine } from '../effects.js';
+import type { MemoEntry, ServicesStore } from '../ports.js';
+import type { ConnectionState } from '../state/connection.js';
+import type { Ctx, Reducer } from '../types.js';
+
+/** Canonical MemoServ pseudo-client nick. */
+export const MEMOSERV_NICK = 'MemoServ';
+
+/** Services hostmask fragment used by every services pseudo-client. */
+const SERVICES_HOST = 'services';
+
+/**
+ * Reducer for `PRIVMSG MemoServ :<subcommand> <args…>`.
+ * Authority: the invoking connection's {@link ConnectionState}.
+ */
+export const memoservReducer: Reducer<ConnectionState> = (state, msg, ctx) => {
+  state.lastSeen = ctx.clock.now();
+
+  const effects: EffectType[] = [];
+
+  if (ctx.services === undefined) {
+    effects.push(notice(state, 'Services are not available on this server.'));
+    return { state, effects };
+  }
+
+  const body = msg.params[1] ?? '';
+  // The subcommand is the first whitespace token; the remainder (incl. any
+  // embedded spaces) is left intact so memo bodies can contain spaces.
+  const firstSpace = body.search(/\s/u);
+  let subRaw: string;
+  let rest: string;
+  if (firstSpace === -1) {
+    subRaw = body;
+    rest = '';
+  } else {
+    subRaw = body.slice(0, firstSpace);
+    rest = body.slice(firstSpace + 1).trimStart();
+  }
+
+  if (subRaw.length === 0) {
+    effects.push(helpNotice(state));
+    return { state, effects };
+  }
+
+  const sub = subRaw.toUpperCase();
+
+  switch (sub) {
+    case 'SEND':
+      return handleSend(state, rest, ctx, effects);
+    case 'LIST':
+      return handleList(state, ctx, effects);
+    case 'READ':
+      return handleRead(state, rest, ctx, effects);
+    case 'DEL':
+      return handleDel(state, rest, ctx, effects);
+    default:
+      effects.push(unknownNotice(state));
+      return { state, effects };
+  }
+};
+
+// ============================================================================
+// Queue delivery (NickServ IDENTIFY / SASL login)
+// ============================================================================
+
+/**
+ * Delivers every queued unread memo for `account` as MemoServ NOTICEs on the
+ * given connection, marking each one read as it goes.
+ *
+ * Invoked from the NickServ `IDENTIFY` path and the SASL `applyResult`
+ * success path so an offline `SEND` reaches the recipient on their next
+ * login regardless of which authentication route they took. No-op when the
+ * account has no unread memos. Mutates `effects` in place by appending.
+ */
+export function deliverUnreadMemos(
+  state: ConnectionState,
+  services: ServicesStore,
+  account: string,
+  effects: EffectType[],
+): void {
+  const memos = services.listMemos(account);
+  const unread = memos.filter((m) => !m.read);
+  for (const memo of unread) {
+    effects.push(memoNotice(state, memo));
+    services.markMemoRead(account, memo.id);
+  }
+}
+
+// ============================================================================
+// SEND
+// ============================================================================
+
+function handleSend(
+  state: ConnectionState,
+  rest: string,
+  ctx: Ctx,
+  effects: EffectType[],
+): { state: ConnectionState; effects: EffectType[] } {
+  const services = ctx.services as ServicesStore;
+  const account = state.account;
+
+  if (account === undefined) {
+    effects.push(notice(state, 'You must identify before sending a memo.'));
+    return { state, effects };
+  }
+
+  // Split into recipient + body. The body keeps its embedded spaces.
+  const sep = rest.search(/\s/u);
+  let recipientRaw: string;
+  let bodyText: string;
+  if (sep === -1) {
+    recipientRaw = rest;
+    bodyText = '';
+  } else {
+    recipientRaw = rest.slice(0, sep);
+    bodyText = rest.slice(sep + 1).trimStart();
+  }
+
+  if (recipientRaw.length === 0 || bodyText.length === 0) {
+    effects.push(notice(state, 'Syntax: SEND <nick> <message>'));
+    return { state, effects };
+  }
+
+  if (caseFold('rfc1459', recipientRaw) === caseFold('rfc1459', account)) {
+    effects.push(notice(state, 'You cannot send a memo to yourself.'));
+    return { state, effects };
+  }
+
+  if (!services.isRegisteredNick(recipientRaw)) {
+    effects.push(notice(state, `Nick ${recipientRaw} is not registered.`));
+    return { state, effects };
+  }
+
+  services.recordMemo({
+    from: account,
+    to: recipientRaw,
+    body: bodyText,
+    sentAt: ctx.clock.now(),
+  });
+  effects.push(notice(state, `Memo sent to ${recipientRaw}.`));
+  return { state, effects };
+}
+
+// ============================================================================
+// LIST
+// ============================================================================
+
+function handleList(
+  state: ConnectionState,
+  ctx: Ctx,
+  effects: EffectType[],
+): { state: ConnectionState; effects: EffectType[] } {
+  const services = ctx.services as ServicesStore;
+  const account = state.account;
+
+  if (account === undefined) {
+    effects.push(notice(state, 'You must identify before listing memos.'));
+    return { state, effects };
+  }
+
+  const unread = services.listMemos(account).filter((m) => !m.read);
+
+  if (unread.length === 0) {
+    effects.push(notice(state, 'You have no memos.'));
+    return { state, effects };
+  }
+
+  effects.push(notice(state, 'Memos:'));
+  for (const memo of unread) {
+    effects.push(notice(state, `#${memo.id} ${memo.from}: ${memo.body}`));
+  }
+  return { state, effects };
+}
+
+// ============================================================================
+// READ
+// ============================================================================
+
+function handleRead(
+  state: ConnectionState,
+  rest: string,
+  ctx: Ctx,
+  effects: EffectType[],
+): { state: ConnectionState; effects: EffectType[] } {
+  const services = ctx.services as ServicesStore;
+  const account = state.account;
+
+  if (account === undefined) {
+    effects.push(notice(state, 'You must identify before reading memos.'));
+    return { state, effects };
+  }
+
+  const parsed = parseMemoNumber(rest);
+  if (parsed === undefined) {
+    effects.push(notice(state, 'Syntax: READ <number>'));
+    return { state, effects };
+  }
+
+  const memo = services.listMemos(account).find((m) => m.id === parsed);
+  if (memo === undefined) {
+    effects.push(notice(state, `No such memo #${parsed}.`));
+    return { state, effects };
+  }
+
+  effects.push(memoNotice(state, memo));
+  services.markMemoRead(account, memo.id);
+  return { state, effects };
+}
+
+// ============================================================================
+// DEL
+// ============================================================================
+
+function handleDel(
+  state: ConnectionState,
+  rest: string,
+  ctx: Ctx,
+  effects: EffectType[],
+): { state: ConnectionState; effects: EffectType[] } {
+  const services = ctx.services as ServicesStore;
+  const account = state.account;
+
+  if (account === undefined) {
+    effects.push(notice(state, 'You must identify before deleting memos.'));
+    return { state, effects };
+  }
+
+  const parsed = parseMemoNumber(rest);
+  if (parsed === undefined) {
+    effects.push(notice(state, 'Syntax: DEL <number>'));
+    return { state, effects };
+  }
+
+  const removed = services.deleteMemo(account, parsed);
+  if (!removed) {
+    effects.push(notice(state, `No such memo #${parsed}.`));
+    return { state, effects };
+  }
+
+  effects.push(notice(state, `Deleted memo #${parsed}.`));
+  return { state, effects };
+}
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+/**
+ * Parses a positive-integer memo number from the trailing argument.
+ * Returns `undefined` for empty / non-numeric / non-positive input.
+ */
+function parseMemoNumber(rest: string): number | undefined {
+  const trimmed = rest.trim();
+  if (trimmed.length === 0) return undefined;
+  if (!/^[1-9][0-9]*$/u.test(trimmed)) return undefined;
+  return Number.parseInt(trimmed, 10);
+}
+
+// ============================================================================
+// Notice helpers
+// ============================================================================
+
+/** Builds a `:MemoServ!MemoServ@services NOTICE <nick> :<text>` line. */
+function notice(state: ConnectionState, text: string): EffectType {
+  return Effect.send(state.id, [servicesNotice(text, state.nick)]);
+}
+
+/** Builds a help/unknown `:MemoServ!MemoServ@services NOTICE <nick> :…` line. */
+function helpNotice(state: ConnectionState): EffectType {
+  return notice(state, 'Available commands: SEND, LIST, READ, DEL');
+}
+
+function unknownNotice(state: ConnectionState): EffectType {
+  return notice(state, 'Unknown command. Available: SEND, LIST, READ, DEL');
+}
+
+/** Builds a `:MemoServ!MemoServ@services NOTICE <nick> :…` line for a memo. */
+function memoNotice(state: ConnectionState, memo: MemoEntry): EffectType {
+  return Effect.send(state.id, [
+    servicesNotice(`[Memo #${memo.id} from ${memo.from}] ${memo.body}`, state.nick),
+  ]);
+}
+
+/**
+ * Formats a services NOTICE line. The source hostmask is
+ * `<svc>!<svc>@services` regardless of the deployment's serverName so the
+ * pseudo-clients are stable across deployments and easy to identify in
+ * client UIs.
+ */
+function servicesNotice(text: string, nick: string | undefined): RawLine {
+  const target = nick ?? '*';
+  return { text: `:${MEMOSERV_NICK}!${MEMOSERV_NICK}@${SERVICES_HOST} NOTICE ${target} :${text}` };
+}

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

@@ -43,6 +43,7 @@ import type {
 import { hostmaskOf } from '../state/connection.js';
 import type { ConnectionState } from '../state/connection.js';
 import type { Ctx, Reducer } from '../types.js';
+import { positiveMlockLetters } from './chanserv.js';
 
 /** Channel-name grammar; mirrors {@link isValidChannelName} in `join.ts`. */
 const CHANNEL_NAME_RE = /^[#&][^\s,:]+$/u;
@@ -77,9 +78,24 @@ const BOOLEAN_LETTERS: Readonly<Record<string, BooleanChannelMode>> = {
   p: 'private',
 };
 
+/**
+ * Services-only boolean channel mode letters. These appear in the 324 read
+ * reply and persist on the channel state, but {@link channelModeReducer}
+ * rejects any attempt to set them via `MODE` with `472 ERR_UNKNOWNMODE`
+ * (only ChanServ may toggle them via an `ApplyChannelDelta`).
+ */
+const SERVICES_BOOLEAN_LETTERS: Readonly<Record<string, BooleanChannelMode>> = {
+  r: 'registered',
+  R: 'blockUnidentified',
+  M: 'moderatedIdent',
+};
+
 /** Boolean channel mode letters in canonical 324 output order. */
 const BOOLEAN_LETTER_ORDER = ['i', 't', 'n', 'm', 's', 'p'] as const;
 
+/** Services-only boolean channel mode letters in canonical 324 output order. */
+const SERVICES_BOOLEAN_LETTER_ORDER = ['r', 'R', 'M'] as const;
+
 /** Prefix channel mode letters (always take a nick arg). */
 const PREFIX_LETTERS = new Set<string>(['o', 'v']);
 
@@ -199,6 +215,13 @@ export const channelModeReducer: Reducer<ChannelState> = (state, msg, ctx) => {
     effects.push(Effect.broadcast(state.name, [buildModeBroadcast(hostmask, state.name, applied)]));
   }
 
+  // ChanServ MLOCK reapplication: after the op's MODE applied, check the
+  // registered channel's locked modes. Any positively-locked boolean mode
+  // that is now unset (whether by this MODE or by a prior state) is
+  // reapplied on top via a ChanServ ApplyChannelDelta + broadcast, so an
+  // op cannot bypass the lock.
+  effects.push(...reapplyMlock(state, ctx));
+
   return { state, effects };
 };
 
@@ -436,6 +459,64 @@ function buildModeBroadcast(hostmask: string, chanName: string, applied: Applied
   return { text: `${lead} ${args.join(' ')}` };
 }
 
+// ============================================================================
+// ChanServ MLOCK reapplication
+// ============================================================================
+
+/**
+ * Hostmask used as the source of ChanServ-emitted MODE reapplies. Mirrors
+ * the `:ChanServ!ChanServ@services` pseudo-client source used by the
+ * ChanServ reducer's NOTICE lines.
+ */
+const CHANSERV_HOSTMASK = 'ChanServ!ChanServ@services';
+
+/**
+ * Returns the effects to emit when ChanServ's MLOCK must reapply locked
+ * boolean modes after an op's MODE has applied.
+ *
+ * Loads the channel's locked modestring from the bound {@link ServicesStore}
+ * (no-op when services are unbound, the channel is not registered, or the
+ * MLOCK is empty). For every positively-locked boolean mode letter that is
+ * currently unset on the channel state, emits:
+ *   - an `ApplyChannelDelta` re-applying the mode,
+ *   - a `Broadcast` of `:ChanServ!ChanServ@services MODE <chan> +<letters>`
+ *     so clients observe ChanServ reasserting the lock.
+ *
+ * Services-only modes (r/R/M) are also defended here, so a registered
+ * channel's `+r` survives even if a future code path applies an `ApplyChannelDelta`
+ * clearing it.
+ *
+ * Returns an empty array when nothing needs to be reapplied.
+ */
+function reapplyMlock(state: ChannelState, ctx: Ctx): EffectType[] {
+  const services = ctx.services;
+  if (services === undefined) return [];
+  const rec = services.getChannel(state.nameLower);
+  if (rec === undefined) return [];
+  if (rec.mlock.length === 0) return [];
+
+  const locked = positiveMlockLetters(rec.mlock);
+  if (locked.size === 0) return [];
+
+  const toReapply: AppliedMode[] = [];
+  const delta: ChannelDelta = {};
+  for (const letter of locked) {
+    const field = BOOLEAN_LETTERS[letter] ?? SERVICES_BOOLEAN_LETTERS[letter];
+    if (field === undefined) continue;
+    if (state.modes[field]) continue;
+    state.modes[field] = true;
+    pushModeChange(delta, field, true);
+    toReapply.push({ sign: '+', letter });
+  }
+
+  if (toReapply.length === 0) return [];
+
+  return [
+    Effect.applyChannelDelta(state.name, delta),
+    Effect.broadcast(state.name, [buildModeBroadcast(CHANSERV_HOSTMASK, state.name, toReapply)]),
+  ];
+}
+
 // ============================================================================
 // Channel MODE — read / query helpers
 // ============================================================================
@@ -479,6 +560,12 @@ function buildReadModeString(state: ChannelState): string {
     const field = BOOLEAN_LETTERS[letter];
     if (field !== undefined && state.modes[field]) modeStr += letter;
   }
+  // Services-only boolean modes (r/R/M) surface in the read reply when
+  // ChanServ has set them; they cannot be toggled via MODE.
+  for (const letter of SERVICES_BOOLEAN_LETTER_ORDER) {
+    const field = SERVICES_BOOLEAN_LETTERS[letter];
+    if (field !== undefined && state.modes[field]) modeStr += letter;
+  }
   if (state.modes.key !== undefined) {
     modeStr += 'k';
     args.push(state.modes.key);
@@ -528,7 +615,7 @@ const USER_MODE_LETTERS: Readonly<Record<string, keyof ConnectionState['userMode
 };
 
 /** User-mode letters in canonical 221 output order. */
-const USER_MODE_LETTER_ORDER = ['i', 'w', 's', 'o', 'S'] as const;
+const USER_MODE_LETTER_ORDER = ['i', 'w', 's', 'o', 'r', 'S'] as const;
 
 /**
  * Handles `MODE <nick> [<modestring>]`.
@@ -640,13 +727,18 @@ export const userModeReducer: Reducer<ConnectionState> = (state, msg, ctx) => {
 function buildUserModeString(state: ConnectionState): string {
   let modeStr = '+';
   for (const letter of USER_MODE_LETTER_ORDER) {
-    // `S` (TLS connected) is read-only: it is not in USER_MODE_LETTERS
-    // (the write-side map the parser consults) so `MODE nick +S` rejects
-    // with 501. Surface it on the read side directly from its field.
+    // `S` (TLS connected) and `r` (registered) are read-only: neither is
+    // in USER_MODE_LETTERS (the write-side map the parser consults) so
+    // `MODE nick +S` / `MODE nick +r` reject with 501. Surface them on
+    // the read side directly from their fields.
     if (letter === 'S') {
       if (state.userModes.tls) modeStr += 'S';
       continue;
     }
+    if (letter === 'r') {
+      if (state.userModes.registered) modeStr += 'r';
+      continue;
+    }
     const field = USER_MODE_LETTERS[letter];
     if (field !== undefined && state.userModes[field]) modeStr += letter;
   }