serverless-ircd 0.5.0 → 0.7.0

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

@@ -175,18 +175,18 @@ function buildChannelReducer(command: MessageCommand): Reducer<ChannelState> {
 
     // All checks passed: persist the message for chathistory playback when a
     // MessageStore is bound. The msgid/time are generated once here and travel
-    // on the StoredMessage; the live broadcast line stays bare (per-recipient
-    // server-time/msgid decoration is the dispatch layer's job). Recording is
-    // gated on ctx.messages so deployments with chathistory disabled see no
-    // change whatsoever.
+    // on the StoredMessage AND on the live fanout line (IRCv3 msgid). A single
+    // nonce is shared between the live tag and the record so the value a cap
+    // enabled peer sees live matches the value replayed by chathistory.
     //
     // By this point the sender's hostmask has already been computed and used
     // in the `+b` ban check above, so the connection's nick/user/host are all
     // defined for any registered PRIVMSG (registration sets all three); the
     // fallbacks mirror `senderHostmask` purely for the type-checker.
+    const msgid = ctx.ids.nonce();
     if (ctx.messages !== undefined) {
       ctx.messages.record({
-        msgid: ctx.ids.nonce(),
+        msgid,
         time: ctx.clock.now(),
         chan: state.nameLower,
         command,
@@ -197,14 +197,21 @@ function buildChannelReducer(command: MessageCommand): Reducer<ChannelState> {
       });
     }
 
-    // All checks passed: broadcast to the channel, excluding the sender.
-    const line: RawLine = { text: `:${hostmask} ${command} ${state.name} :${text}` };
-    effects.push(Effect.broadcast(state.name, [line], ctx.connId));
-
-    // IRCv3 echo-message: echo the same line back to the sender, after
-    // the broadcast effect so clients observe their own message last.
+    // All checks passed: broadcast to the channel, excluding the sender. The
+    // bare line goes to every member; the `@msgid=<id>` decorated line is sent
+    // only to members who negotiated the `msgid` cap (IRCv3 msgid). The
+    // dispatch layer's cap-split resolves per-recipient.
+    const body = `${command} ${state.name} :${text}`;
+    const line: RawLine = { text: `:${hostmask} ${body}` };
+    const msgidLine: RawLine = { text: `@msgid=${msgid} :${hostmask} ${body}` };
+    effects.push(Effect.broadcast(state.name, [line], ctx.connId, 'msgid', [msgidLine]));
+
+    // IRCv3 echo-message: echo the line back to the sender, after the
+    // broadcast effect so clients observe their own message last. A sender
+    // that also negotiated `msgid` sees the decorated echo.
     if (ctx.connection.caps.has('echo-message')) {
-      effects.push(Effect.send(ctx.connId, [line]));
+      const echoLine = ctx.connection.caps.has('msgid') ? msgidLine : line;
+      effects.push(Effect.send(ctx.connId, [echoLine]));
     }
 
     return { state, effects };

package/packages/irc-core/src/commands/read-marker.ts

@@ -0,0 +1,108 @@
+/**
+ * Pure helpers for IRCv3 `draft/read-marker` (persistent last-read marker).
+ *
+ * Spec (work-in-progress): https://ircv3.net/specs/extensions/read-marker
+ *
+ * The serverless-ircd deployment diverges from the work-in-progress draft:
+ * instead of the draft's `MARKREAD` command + server-time timestamp, this
+ * implementation is **msgid-based** so it composes with the
+ * per-`(connection, channel)` last-read marker the chathistory command
+ * already maintains in {@link ConnectionState.lastReadMarkers}.
+ *
+ * Flow:
+ *   - A cap-enabled client marks a message read by sending a
+ *     `TAGMSG <target>` carrying `+draft/read-marker=<msgid>`. The
+ *     {@link tagmsgChannelReducer} detects the tag, calls
+ *     {@link persistReadMarker} to advance the per-`(account, channel)`
+ *     record in the bound {@link ReadMarkerStore}, and fans the TAGMSG out
+ *     (carrying the tag) so the user's other connections learn the new
+ *     read position.
+ *   - On SASL identify, the actor calls {@link seedReadMarkers} so a fresh
+ *     connection's `lastReadMarkers` is restored from the stored values and
+ *     a reconnect resumes at the user's last read position.
+ */
+
+import { READ_MARKER_CAP_NAME } from '../caps/capabilities.js';
+import type { ReadMarkerStore } from '../ports.js';
+import type { ConnectionState } from '../state/connection.js';
+import type { Ctx } from '../types.js';
+
+/**
+ * Wire name of the IRCv3 `draft/read-marker` capability. Aliased from
+ * {@link READ_MARKER_CAP_NAME} (the canonical home in the cap data table)
+ * for ergonomic use inside the reducer.
+ */
+export const READ_MARKER_CAP = READ_MARKER_CAP_NAME;
+
+/**
+ * The client-tag key that carries a read-marker update. Presence of this key
+ * (with a non-empty value) on a `TAGMSG` identifies a read-marker update the
+ * server persists and propagates.
+ */
+export const READ_MARKER_TAG = '+draft/read-marker';
+
+/** Returns true iff `tags` carries the `+draft/read-marker` client tag. */
+export function isReadMarkerTagmsg(tags: Readonly<Record<string, string>>): boolean {
+  return READ_MARKER_TAG in tags;
+}
+
+/**
+ * Returns the msgid carried by the `+draft/read-marker` tag, or `undefined`
+ * when the tag is absent or valueless. A valueless tag carries no msgid and
+ * therefore no marker to persist.
+ */
+export function readMarkerMsgid(tags: Readonly<Record<string, string>>): string | undefined {
+  const value = tags[READ_MARKER_TAG];
+  if (value === undefined || value === '') return undefined;
+  return value;
+}
+
+/**
+ * Advances the per-`(account, channel)` last-read marker.
+ *
+ * Always advances the connection's in-memory {@link ConnectionState.lastReadMarkers}
+ * so the current session tracks the read position. When a {@link ReadMarkerStore}
+ * is bound AND the connection is identified (has an `account`), the marker is
+ * also persisted so it survives reconnects and is shared across the account's
+ * connections.
+ *
+ * `chanLower` is the lowercased channel name (the storage key); callers pass
+ * the authoritative `ChannelState.nameLower`.
+ */
+export function persistReadMarker(ctx: Ctx, chanLower: string, msgid: string): void {
+  if (ctx.connection.lastReadMarkers === undefined) {
+    ctx.connection.lastReadMarkers = new Map<string, string>();
+  }
+  ctx.connection.lastReadMarkers.set(chanLower, msgid);
+
+  const store = ctx.readMarkers;
+  const account = ctx.connection.account;
+  if (store !== undefined && account !== undefined) {
+    store.set(account, chanLower, msgid);
+  }
+}
+
+/**
+ * Seeds a fresh connection's `lastReadMarkers` from the persisted values for
+ * `account`. Called at SASL identify so a reconnect restores the user's last
+ * read position across every channel they have a marker for.
+ *
+ * Existing in-memory markers are preserved: a session may have already
+ * advanced past the stored value, and the in-memory (newer) marker wins.
+ */
+export function seedReadMarkers(
+  conn: ConnectionState,
+  store: ReadMarkerStore,
+  account: string,
+): void {
+  const entries = store.forAccount(account);
+  if (entries.length === 0) return;
+  if (conn.lastReadMarkers === undefined) {
+    conn.lastReadMarkers = new Map<string, string>();
+  }
+  for (const entry of entries) {
+    if (!conn.lastReadMarkers.has(entry.channel)) {
+      conn.lastReadMarkers.set(entry.channel, entry.msgid);
+    }
+  }
+}

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

@@ -117,6 +117,14 @@ export function emitWelcomeIfReady(state: ConnectionState, ctx: Ctx): EffectType
   // so the `001` hostmask and every downstream message uses the cloak.
   applyCloakIfEnabled(state, ctx);
 
+  // Surface the transport's TLS fact as read-only user mode `S` so clients
+  // learn the connection is secure via `221` / `WHOIS`. The adapter sets
+  // `state.secure` from the platform's transport metadata at construction;
+  // the mode is not settable via `MODE` (the parser rejects `+S`/`-S`).
+  if (state.secure) {
+    state.userModes.tls = true;
+  }
+
   state.registration = 'registered';
   return [Effect.send(ctx.connId, buildWelcomeLines(state, ctx))];
 }

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

@@ -35,6 +35,9 @@ import { Numerics } from '../protocol/numerics.js';
 import { hostmaskOf } from '../state/connection.js';
 import type { ConnectionState } from '../state/connection.js';
 import type { Ctx, Reducer } from '../types.js';
+import { emitAccountNotify } from './account-notify.js';
+import { nowAwayLine, replayPersistedAway } from './pre-away.js';
+import { seedReadMarkers } from './read-marker.js';
 
 /** Per-ircdocs.horse: a single `AUTHENTICATE` payload chunk is at most 400 bytes. */
 const SASL_CHUNK_BYTES = 400;
@@ -218,9 +221,29 @@ function applyResult(
 
   if (result.ok) {
     state.account = result.account;
+    // IRCv3 draft/read-marker: restore the user's per-channel last-read
+    // markers from the persisted store so a reconnect resumes at their
+    // last read position. No-op when no ReadMarkerStore is bound.
+    if (ctx.readMarkers !== undefined) {
+      seedReadMarkers(state, ctx.readMarkers, result.account);
+    }
+    // IRCv3 draft/pre-away: replay the user's persisted away reason onto
+    // the fresh connection so a reconnect restores the away state, and
+    // emit the 306 numeric so the user sees they are still away. No-op
+    // when no AwayStore is bound or no reason is stored.
+    const replayedAway =
+      ctx.away !== undefined ? replayPersistedAway(state, ctx.away, result.account) : undefined;
+    const awayEffects: EffectType[] =
+      replayedAway !== undefined
+        ? [Effect.send(ctx.connId, [nowAwayLine(state, ctx.serverName)])]
+        : [];
     return {
       state,
-      effects: [Effect.send(ctx.connId, [loggedIn(ctx, result.account), saslSuccess(ctx)])],
+      effects: [
+        Effect.send(ctx.connId, [loggedIn(ctx, result.account), saslSuccess(ctx)]),
+        ...awayEffects,
+        ...emitAccountNotify({ conn: state, account: result.account }),
+      ],
     };
   }
   return { state, effects: [Effect.send(ctx.connId, [saslFail(ctx)])] };

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

@@ -27,10 +27,58 @@ import type { ChannelState } 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 {
+  READ_MARKER_CAP,
+  isReadMarkerTagmsg,
+  persistReadMarker,
+  readMarkerMsgid,
+} from './read-marker.js';
 
 /** The cap name advertising message-tags support. */
 const MESSAGE_TAGS_CAP = 'message-tags';
 
+/**
+ * The cap name advertising IRCv3 `draft/typing` support. Typing TAGMSGs
+ * (those carrying the `+draft/typing` client tag) fan out to members that
+ * announced EITHER `message-tags` (the baseline for every TAGMSG) OR
+ * `draft/typing` (the spec's client-tag exception for peers that did not
+ * negotiate `message-tags`).
+ */
+const TYPING_CAP = 'draft/typing';
+
+/**
+ * The client-tag key that identifies a typing TAGMSG. Presence of this key
+ * (regardless of value, including the valueless form) triggers the OR-caps
+ * broadcast above.
+ */
+const TYPING_TAG = '+draft/typing';
+
+/** Returns true iff `tags` carries the `+draft/typing` client tag. */
+function isTypingTagmsg(tags: Readonly<Record<string, string>>): boolean {
+  return TYPING_TAG in tags;
+}
+
+/**
+ * Returns the OR-semantics cap list a TAGMSG fanout should use, or `undefined`
+ * when the plain single-cap (`message-tags`) broadcast path applies.
+ *
+ * A TAGMSG carrying `+draft/typing` widens to `message-tags` OR `draft/typing`;
+ * one carrying `+draft/read-marker` widens to `message-tags` OR
+ * `draft/read-marker`. Both spec exceptions let a peer that announced only the
+ * draft cap (not `message-tags`) still receive the notification. The baseline
+ * `message-tags` cap always leads the list so message-tags peers keep receiving
+ * every TAGMSG.
+ */
+function widenAudienceCaps(tags: Readonly<Record<string, string>>): readonly string[] | undefined {
+  const typing = isTypingTagmsg(tags);
+  const readMarker = isReadMarkerTagmsg(tags);
+  if (!typing && !readMarker) return undefined;
+  const caps = [MESSAGE_TAGS_CAP];
+  if (typing) caps.push(TYPING_CAP);
+  if (readMarker) caps.push(READ_MARKER_CAP);
+  return caps;
+}
+
 /**
  * Returns true iff `hostmask` matches the IRC ban mask `mask`. Identical to
  * the implementation in `privmsg.ts`; duplicated to keep the message path
@@ -149,10 +197,32 @@ export const tagmsgChannelReducer: Reducer<ChannelState> = (state, msg, ctx) =>
     });
   }
 
+  // IRCv3 draft/read-marker: a TAGMSG carrying `+draft/read-marker=<msgid>`
+  // marks `<msgid>` as the last read message for the sender's account in
+  // this channel. Persist the marker (advances the connection's in-memory
+  // marker too); a valueless tag carries no msgid and is dropped here. The
+  // TAGMSG still fans out below so the user's other connections learn it.
+  if (isReadMarkerTagmsg(msg.tags)) {
+    const msgid = readMarkerMsgid(msg.tags);
+    if (msgid !== undefined) {
+      persistReadMarker(ctx, state.nameLower, msgid);
+    }
+  }
+
   // Broadcast the tag-bearing line to message-tags-enabled members only.
+  // When the TAGMSG carries `+draft/typing` or `+draft/read-marker`, the
+  // audience widens to also include members that announced the matching
+  // draft cap (the spec's client-tag exception): such peers receive the
+  // notification even without `message-tags`. The caps are passed via
+  // `caps` so dispatch applies OR semantics per recipient.
   const tagPrefix = serializeTags(msg.tags);
   const line: RawLine = { text: `${tagPrefix}:${hostmask} TAGMSG ${state.name}` };
-  effects.push(Effect.broadcast(state.name, [line], ctx.connId, MESSAGE_TAGS_CAP));
+  const widenCaps = widenAudienceCaps(msg.tags);
+  if (widenCaps !== undefined) {
+    effects.push(Effect.broadcast(state.name, [line], ctx.connId, undefined, undefined, widenCaps));
+  } else {
+    effects.push(Effect.broadcast(state.name, [line], ctx.connId, MESSAGE_TAGS_CAP));
+  }
 
   // IRCv3 echo-message: echo the same line back to the sender, after
   // the broadcast effect so clients observe their own message last.

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

@@ -134,6 +134,11 @@ export function whoisReducer(
       text: `:${ctx.serverName} ${Numerics.RPL_WHOISOPERATOR.toString().padStart(3, '0')} ${requesterNick} ${tNick} :is an IRC operator`,
     });
   }
+  if (target.userModes.tls) {
+    lines.push({
+      text: `:${ctx.serverName} ${Numerics.RPL_WHOISSECURE.toString().padStart(3, '0')} ${requesterNick} ${tNick} :is using a secure connection`,
+    });
+  }
   if (target.account !== undefined) {
     lines.push({
       text: `:${ctx.serverName} ${Numerics.RPL_WHOISACCOUNT.toString().padStart(3, '0')} ${requesterNick} ${tNick} ${target.account} :is logged in as`,

package/packages/irc-core/src/config.ts

@@ -18,6 +18,7 @@
 
 import { z } from 'zod';
 import { BUILD_DATE } from './build-info.js';
+import { DEFAULT_MULTILINE_MAX_BYTES } from './caps/capabilities.js';
 
 /**
  * Schema for a single IRC operator credential.
@@ -61,6 +62,33 @@ export const CloakingConfigSchema = z.object({
   cloakedSuffix: z.string().min(1).optional(),
 });
 
+/**
+ * IRCv3 `sts` (Strict Transport Security) policy. When supplied, the
+ * server advertises an `sts` capability whose value tells compliant
+ * clients how long to pin TLS and which port to upgrade to on a
+ * plaintext connection. Omit entirely (the default) to disable STS.
+ *
+ * Spec: https://ircv3.net/specs/extensions/sts
+ */
+export const StsConfigSchema = z.object({
+  /**
+   * Pin duration in seconds. Defaults to 30 days at the cap-builder layer
+   * when omitted; supply an explicit value in production.
+   */
+  duration: z.number().int().positive(),
+  /**
+   * TLS listener port advertised on plaintext connections. The canonical
+   * IRC-over-TLS port is 6697 (RFC 7193). Defaults to 6697 at the
+   * cap-builder layer when omitted.
+   */
+  port: z.number().int().positive(),
+  /**
+   * Optional preload directive. When true the policy may be hard-coded
+   * into a client preload list (only advertised on plaintext connections).
+   */
+  preload: z.boolean().optional(),
+});
+
 /**
  * Per-IP connection-rate limit. Caps how many new connections a single
  * source IP may open within a sliding `windowMs` window before the
@@ -272,6 +300,43 @@ export const ServerConfigSchema = z.object({
    * lower per deployment. Only consulted when a MessageStore is bound.
    */
   chatHistoryPlaybackLimit: z.number().int().positive().default(50),
+
+  /**
+   * IRCv3 `sts` (Strict Transport Security) policy. Omit entirely (the
+   * default) to disable STS advertisement; supply `{ duration, port }`
+   * (plus optional `preload`) to advertise the cap and let compliant
+   * clients upgrade from plaintext to TLS and pin the secure listener.
+   */
+  sts: StsConfigSchema.optional(),
+
+  /**
+   * IRCv3 `draft/multiline` byte budget. Advertised as
+   * `draft/multiline=<n>` in `CAP LS` and enforced on every finalized
+   * multi-line batch. Defaults to the IRCv3-recommended 4096; raise or
+   * lower per deployment.
+   */
+  multilineMaxBytes: z.number().int().positive().default(DEFAULT_MULTILINE_MAX_BYTES),
+
+  /**
+   * Per-connection MONITOR watchlist ceiling, advertised as `MONITOR=<n>`
+   * in `005 RPL_ISUPPORT`. Omit to inherit the monitor reducer's built-in
+   * ceiling (DEFAULT_MONITOR_LIMIT, 30).
+   */
+  monitorLimit: z.number().int().positive().optional(),
+
+  /**
+   * Extended-ban prefix sigil for `EXTBAN=<prefix>,…` in
+   * `005 RPL_ISUPPORT`. Omit for the IRC-standard `~`.
+   */
+  extbanPrefix: z.string().min(1).optional(),
+
+  /**
+   * Enables IRC-services-derived ISUPPORT tokens (currently
+   * `ACCOUNTEXTBAN=a`). Set to true once a `ServicesStore` is bound; until
+   * then account-name extended bans are suppressed because unregistered
+   * nicks make them meaningless.
+   */
+  servicesEnabled: z.boolean().optional(),
 });
 
 /** Input type: what adapters supply (fields with defaults may be omitted). */
@@ -303,16 +368,6 @@ export function parseServerConfig(input: unknown): ParsedServerConfig {
   return result.data;
 }
 
-/**
- * Default server config: the result of parsing an empty input. Useful as a
- * known-good baseline for tests and for adapters that want to overlay
- * per-deployment overrides via object spread.
- */
-export const DEFAULT_SERVER_CONFIG: ParsedServerConfig = ServerConfigSchema.parse({
-  serverName: 'irc.example.com',
-  networkName: 'ServerlessIRCd',
-});
-
 /**
  * Resolves the effective server version for wire output: the configured
  * value when present, otherwise {@link DEFAULT_SERVER_VERSION}. Used by the

package/packages/irc-core/src/effects.ts

@@ -43,6 +43,18 @@ export interface BroadcastEffect {
   except?: ConnId;
   cap?: string;
   capLines?: RawLine[];
+  /**
+   * OR-semantics cap list: the recipient receives `lines` iff they
+   * negotiated ANY of the listed caps. Used by capabilities whose delivery
+   * rule is the union of two caps — e.g. `draft/typing` TAGMSGs reach
+   * peers that announced `draft/typing` OR `message-tags` (the latter
+   * because every TAGMSG goes to message-tags peers regardless of tag).
+   *
+   * Mutually exclusive with {@link cap}: set one or the other, not both.
+   * When neither is set, dispatch takes the runtime's bulk broadcast fast
+   * path.
+   */
+  caps?: readonly string[];
 }
 
 export interface DisconnectEffect {
@@ -150,11 +162,13 @@ export const Effect = {
     except?: ConnId,
     cap?: string,
     capLines?: RawLine[],
+    caps?: readonly string[],
   ): Effect {
     const e: BroadcastEffect = { tag: 'Broadcast', chan, lines };
     if (except !== undefined) e.except = except;
     if (cap !== undefined) e.cap = cap;
     if (capLines !== undefined) e.capLines = capLines;
+    if (caps !== undefined) e.caps = caps;
     return e;
   },
   disconnect(conn: ConnId, reason?: string): Effect {