serverless-ircd 0.5.0 → 0.7.0

package/packages/irc-core/src/caps/capabilities.ts

@@ -21,29 +21,63 @@ export interface Capability {
   value?: string;
 }
 
+/** Wire name of the SASL capability. */
+export const SASL_CAP_NAME = 'sasl';
+
+/** Wire name of the IRCv3 `draft/multiline` capability. */
+export const MULTILINE_CAP_NAME = 'draft/multiline';
+
+/** Wire name of the IRCv3 `draft/read-marker` capability. */
+export const READ_MARKER_CAP_NAME = 'draft/read-marker';
+
+/** Wire name of the IRCv3 `draft/pre-away` capability. */
+export const PRE_AWAY_CAP_NAME = 'draft/pre-away';
+
+/**
+ * Default byte budget advertised in `draft/multiline=<n>` and enforced on
+ * every finalized multi-line batch. Mirrors the IRCv3 spec's canonical
+ * recommendation; deployments override via `ServerConfig.multilineMaxBytes`.
+ */
+export const DEFAULT_MULTILINE_MAX_BYTES = 4096;
+
+/**
+ * Builds the `draft/multiline` cap *value* (the substring after `=`) for the
+ * advertised byte budget. The {@link CapReducer} and the multi-line reducer
+ * share this helper so the wire token has one source of truth.
+ */
+export function multilineCapValue(maxBytes: number): string {
+  return String(maxBytes);
+}
+
 /**
  * Every cap advertised by this server in PLAN §3, in canonical (alpha) order
  * so wire output is deterministic across runs.
  */
 export const SUPPORTED_CAPABILITIES: ReadonlyArray<Capability> = Object.freeze([
+  { name: 'account-notify' },
   { name: 'account-tag' },
   { name: 'away-notify' },
   { name: 'batch' },
   { name: 'chghost' },
   { name: 'draft/chathistory' },
+  { name: 'draft/multiline', value: multilineCapValue(DEFAULT_MULTILINE_MAX_BYTES) },
+  { name: 'draft/pre-away' },
+  { name: 'draft/read-marker' },
+  { name: 'draft/typing' },
   { name: 'echo-message' },
   { name: 'extended-join' },
   { name: 'invite-notify' },
+  { name: 'labeled-response' },
   { name: 'message-tags' },
+  { name: 'msgid' },
+  { name: 'monitor' },
   { name: 'multi-prefix' },
   { name: 'safelist' },
   { name: 'sasl', value: 'PLAIN' },
   { name: 'server-time' },
+  { name: 'standard-replies' },
 ]);
 
-/** Wire name of the SASL capability. */
-export const SASL_CAP_NAME = 'sasl';
-
 /**
  * Returns the `sasl` cap value to advertise given whether an mTLS identity
  * provider is bound for the connection.

package/packages/irc-core/src/caps/index.ts

@@ -1 +1,2 @@
 export * from './capabilities.js';
+export * from './sts.js';

package/packages/irc-core/src/caps/sts.ts

@@ -0,0 +1,84 @@
+/**
+ * IRCv3 `sts` (Strict Transport Security) policy.
+ *
+ * Spec: https://ircv3.net/specs/extensions/sts
+ *
+ * The server advertises an `sts` capability whose value is a
+ * comma-separated `key=value` policy. Compliant clients inspect the
+ * policy and:
+ *
+ *   - On a plaintext connection: reconnect over TLS to the advertised
+ *     `port` and pin it for `duration` seconds. `preload` (optional)
+ *     signals the client may hard-code the policy into a preload list.
+ *   - On a TLS connection: only the `duration` is locked in — `port`
+ *     is meaningless once the client is already on the secure listener,
+ *     and `preload` is an upgrade-time directive.
+ *
+ * Config-driven only: there is no per-connection protocol state. The
+ * deployment supplies the policy through {@link StsConfig} on
+ * {@link ServerConfig}; when omitted entirely the cap is not advertised.
+ */
+
+/**
+ * IRC-over-TLS port per RFC 7193 / IRCv3 STS spec examples. Used as the
+ * fallback `port` when a deployment turns on STS without pinning a port.
+ */
+export const DEFAULT_STS_PORT = 6697;
+
+/**
+ * Default pin duration (30 days, in seconds). Mirrors the IRCv3 spec's
+ * canonical example and what mainstream IRC networks publish. Deployments
+ * override via {@link StsConfig.duration}.
+ */
+export const DEFAULT_STS_DURATION_SECONDS = 30 * 24 * 60 * 60;
+
+/** Wire name of the STS capability. */
+export const STS_CAP_NAME = 'sts';
+
+/**
+ * Raw STS policy as supplied by {@link ServerConfig}. Every field is
+ * optional; {@link stsCapValue} applies the documented defaults when a
+ * field is omitted. `undefined` (the whole object) disables STS.
+ *
+ * Optional fields are widened to `T | undefined` to mirror Zod's
+ * `.optional()` output under `exactOptionalPropertyTypes: true` so the
+ * parsed config is structurally assignable here.
+ */
+export interface StsPolicy {
+  /** Pin duration in seconds. Defaults to 30 days. */
+  readonly duration?: number;
+  /** TLS listener port advertised on plaintext connections. Defaults to 6697. */
+  readonly port?: number;
+  /** Optional preload directive (plaintext advertisements only). */
+  readonly preload?: boolean | undefined;
+}
+
+/**
+ * Builds the IRCv3 `sts` capability *value* (the substring after `sts=`)
+ * for the given policy and transport.
+ *
+ * Returns `undefined` when STS is disabled (`policy` undefined), so the cap
+ * table consumer can omit the token entirely from `CAP LS`.
+ *
+ * On a plaintext transport the full policy is advertised:
+ *   `duration=<seconds>,port=<tls-port>[,preload]`
+ *
+ * On a TLS transport only `duration=<seconds>` is sent — the port is
+ * meaningless (the client is already on the secure listener) and
+ * `preload` is an upgrade-time directive that does not apply.
+ *
+ * Missing `duration`/`port` fall back to {@link DEFAULT_STS_DURATION_SECONDS}
+ * and {@link DEFAULT_STS_PORT} so a deployment can enable STS with a bare
+ * `{}` policy and still publish a sensible value.
+ */
+export function stsCapValue(policy: StsPolicy | undefined, secure: boolean): string | undefined {
+  if (policy === undefined) return undefined;
+  const duration = policy.duration ?? DEFAULT_STS_DURATION_SECONDS;
+  if (secure) {
+    return `duration=${duration}`;
+  }
+  const port = policy.port ?? DEFAULT_STS_PORT;
+  const parts = [`duration=${duration}`, `port=${port}`];
+  if (policy.preload === true) parts.push('preload');
+  return parts.join(',');
+}

package/packages/irc-core/src/commands/account-notify.ts

@@ -0,0 +1,53 @@
+import { Effect } from '../effects.js';
+import type { Effect as EffectType, RawLine } from '../effects.js';
+import type { ChanName } from '../state/channel.js';
+import { hostmaskOf } from '../state/connection.js';
+import type { ConnectionState } from '../state/connection.js';
+
+export interface AccountNotifyInput {
+  conn: ConnectionState;
+  /**
+   * New account name on login. Pass `undefined` to signal a logout, which
+   * serializes the account field as `*` per IRCv3 `account-notify`.
+   */
+  account?: string | undefined;
+}
+
+/**
+ * Builds the cap-split Broadcast effects that announce an `ACCOUNT` login
+ * (or logout) to peers in every shared channel.
+ *
+ * Mirrors the `emitChghost` broadcast helper: each joined channel produces
+ * one {@link Effect.broadcast} carrying empty `lines` (so non-cap peers
+ * receive nothing) and the `ACCOUNT` line in `capLines` for peers that
+ * negotiated `account-notify`. The sender is excluded via `except` unless
+ * they negotiated `echo-message`, in which case a single echo
+ * {@link Effect.send} is appended (one echo regardless of how many shared
+ * channels the user occupies).
+ *
+ * Returns `[]` before registration completes or when the connection holds
+ * no joined channels — there is no audience to notify.
+ */
+export function emitAccountNotify(input: AccountNotifyInput): EffectType[] {
+  const { conn, account } = input;
+
+  if (conn.registration !== 'registered') return [];
+  if (conn.joinedChannels.size === 0) return [];
+
+  const source = hostmaskOf(conn) ?? conn.nick ?? '?';
+  const accountField = account ?? '*';
+  const line: RawLine = { text: `:${source} ACCOUNT ${accountField}` };
+
+  const effects: EffectType[] = [];
+  for (const chan of conn.joinedChannels) {
+    effects.push(Effect.broadcast(chan as ChanName, [], conn.id, 'account-notify', [line]));
+  }
+
+  // IRCv3 echo-message: the sender observes its own ACCOUNT change exactly
+  // once, regardless of how many channels it shares with peers.
+  if (conn.caps.has('echo-message')) {
+    effects.push(Effect.send(conn.id, [line]));
+  }
+
+  return effects;
+}

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

@@ -27,6 +27,7 @@ import type { ChanName } from '../state/channel.js';
 import { hostmaskOf } from '../state/connection.js';
 import type { ConnectionState } from '../state/connection.js';
 import type { Reducer } from '../types.js';
+import { clearPersistedAway, persistAway } from './pre-away.js';
 
 /**
  * Handles `AWAY [:<reason>]`.
@@ -45,7 +46,10 @@ export const awayReducer: Reducer<ConnectionState> = (state, msg, ctx) => {
   const nick = state.nick ?? '*';
 
   if (isSettingAway) {
-    state.away = reason;
+    // IRCv3 draft/pre-away: persist the reason keyed by account when an
+    // AwayStore is bound and the connection is identified. The in-memory
+    // away is also set so the current session tracks the new reason.
+    persistAway(ctx, reason as string);
     effects.push(
       Effect.send(ctx.connId, [
         {
@@ -54,8 +58,10 @@ export const awayReducer: Reducer<ConnectionState> = (state, msg, ctx) => {
       ]),
     );
   } else {
-    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes forbids `= undefined`.
-    delete state.away;
+    // IRCv3 draft/pre-away: clear the persisted reason on unset so a
+    // reconnect does not re-mark the user away. The in-memory away is
+    // also cleared so the session's view stays consistent.
+    clearPersistedAway(ctx);
     effects.push(
       Effect.send(ctx.connId, [
         {

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

@@ -33,13 +33,17 @@
  */
 
 import {
+  DEFAULT_MULTILINE_MAX_BYTES,
+  MULTILINE_CAP_NAME,
   SASL_CAP_NAME,
   SUPPORTED_CAPABILITIES,
   capToLsString,
   isSupportedCap,
+  multilineCapValue,
   saslCapValue,
   splitCapsForWire,
 } from '../caps/capabilities.js';
+import { STS_CAP_NAME, stsCapValue } from '../caps/sts.js';
 import { Effect } from '../effects.js';
 import type { RawLine } from '../effects.js';
 import { Numerics } from '../protocol/numerics.js';
@@ -91,11 +95,21 @@ function handleLs(state: ConnectionState, ctx: Ctx): ReducerResult<ConnectionSta
 
   const target = state.nick ?? '*';
   const hasMtls = ctx.mtlsIdentity !== undefined;
-  const tokens = SUPPORTED_CAPABILITIES.map((cap) =>
-    cap.name === SASL_CAP_NAME
-      ? capToLsString({ ...cap, value: saslCapValue(hasMtls) })
-      : capToLsString(cap),
-  );
+  const multilineMax = ctx.serverConfig.multilineMaxBytes ?? DEFAULT_MULTILINE_MAX_BYTES;
+  const tokens = SUPPORTED_CAPABILITIES.map((cap) => {
+    if (cap.name === SASL_CAP_NAME) {
+      return capToLsString({ ...cap, value: saslCapValue(hasMtls) });
+    }
+    if (cap.name === MULTILINE_CAP_NAME) {
+      return capToLsString({ ...cap, value: multilineCapValue(multilineMax) });
+    }
+    return capToLsString(cap);
+  });
+  // STS is conditionally advertised: appended only when the deployment
+  // supplies a policy, and the value is per-transport (plaintext sees the
+  // full `duration,port[,preload]`; TLS sees only `duration`).
+  const stsValue = stsCapValue(ctx.serverConfig.sts, ctx.connection.secure);
+  if (stsValue !== undefined) tokens.push(`${STS_CAP_NAME}=${stsValue}`);
   const maxLen = maxCapsContentLen(ctx, target);
   const chunks = splitCapsForWire(tokens, maxLen);
 
@@ -164,8 +178,12 @@ function handleReq(
   const requested = rawCaps.split(' ').filter((c) => c.length > 0);
   const target = state.nick ?? '*';
 
+  // STS is conditionally supported: ACKed only when the deployment supplies
+  // a policy. Other caps consult the static table.
+  const stsConfigured = ctx.serverConfig.sts !== undefined;
   const allSupported = requested.every((tok) => {
     const name = tok.startsWith('-') ? tok.slice(1) : tok;
+    if (name === STS_CAP_NAME) return stsConfigured;
     return isSupportedCap(name);
   });
 

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

@@ -141,7 +141,17 @@ function handleChannelSub(
   // LATEST / BEFORE / AFTER / AROUND
   const pivot = msg.params[2];
   const limitRaw = msg.params[3];
-  if (sub !== 'LATEST' && pivot === undefined) {
+
+  // IRCv3 draft/read-marker integration: BEFORE without an explicit pivot
+  // falls back to the connection's per-channel last-read marker so a client
+  // can resume "everything before my last read position" without re-supplying
+  // the msgid. AFTER/AROUND still require an explicit pivot.
+  const markerPivot =
+    sub === 'BEFORE' && pivot === undefined
+      ? ctx.connection.lastReadMarkers?.get(chanLower)
+      : undefined;
+
+  if (sub !== 'LATEST' && pivot === undefined && markerPivot === undefined) {
     return { effects: [Effect.send(ctx.connId, [needMoreParamsLine(ctx)])] };
   }
   const limit = parseLimit(limitRaw);
@@ -163,12 +173,13 @@ function handleChannelSub(
     return { effects: buildChathistoryBatch(ctx, channel.name, result) };
   }
 
-  // BEFORE / AFTER / AROUND — pivot is required. The `sub !== 'LATEST' &&
-  // pivot === undefined` guard above already rejected the missing-pivot
-  // case and LATEST returned early just above; assert non-null for the
-  // type-checker without an unreachable branch.
-  const pivotMsgid = pivot as string;
-  if (!storeHas(ctx, chanLower, pivotMsgid)) {
+  // BEFORE / AFTER / AROUND — pivot is required. Resolve from the explicit
+  // msgid when supplied, otherwise from the marker fallback computed above.
+  // The guard near the top already guaranteed at least one is defined.
+  const pivotMsgid = (pivot ?? markerPivot) as string;
+  // An explicit pivot must reference a retained message; a marker fallback
+  // may point at an evicted message (→ empty result, not INVALID_PARAMS).
+  if (pivot !== undefined && !storeHas(ctx, chanLower, pivotMsgid)) {
     return { effects: [Effect.send(ctx.connId, [invalidParamsLine(ctx)])] };
   }
   const result = storeQuery(ctx, {
@@ -228,16 +239,34 @@ export function buildChathistoryBatch(
 /**
  * Reconstructs the wire line for one stored message, decorated with the
  * original server-time and msgid tags. PRIVMSG/NOTICE carry the trailing
- * text; TAGMSG has no trailing parameter.
+ * text; TAGMSG has no trailing parameter. Optional `clientTags` recorded
+ * with the message (e.g. `+draft/multiline`) are appended to the tag
+ * section so chathistory clients can recognise the message kind.
  */
 export function formatReplayLine(m: StoredMessage, displayChan: string): RawLine {
   const stamp = formatServerTime(m.time);
   const prefix = storedHostmask(m);
-  const tag = `@time=${stamp};msgid=${m.msgid}`;
+  const tags = buildReplayTags(stamp, m.msgid, m.clientTags);
   if (m.command === 'TAGMSG') {
-    return { text: `${tag} :${prefix} TAGMSG ${displayChan}` };
+    return { text: `${tags} :${prefix} TAGMSG ${displayChan}` };
+  }
+  return { text: `${tags} :${prefix} ${m.command} ${displayChan} :${m.text}` };
+}
+
+/**
+ * Builds the `@time=…;msgid=…[;+client-tag…]` tag section for a replay line.
+ * Client tags (when present) are appended after the server tags, matching the
+ * IRCv3 message-tags wire order.
+ */
+function buildReplayTags(
+  stamp: string,
+  msgid: string,
+  clientTags: readonly string[] | undefined,
+): string {
+  if (clientTags === undefined || clientTags.length === 0) {
+    return `@time=${stamp};msgid=${msgid}`;
   }
-  return { text: `${tag} :${prefix} ${m.command} ${displayChan} :${m.text}` };
+  return `@time=${stamp};msgid=${msgid};${clientTags.join(';')}`;
 }
 
 /** Builds the `nick!user@host` source for a stored message. */

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

@@ -46,6 +46,8 @@ export { generateIsupport } from './isupport.js';
 export { capReducer } from './cap.js';
 export { emitChghost } from './chghost.js';
 export type { ChgHostInput } from './chghost.js';
+export { emitAccountNotify } from './account-notify.js';
+export type { AccountNotifyInput } from './account-notify.js';
 export { awayReducer } from './away.js';
 export { setnameReducer } from './setname.js';
 export { authenticateReducer } from './sasl.js';
@@ -56,6 +58,18 @@ export {
   CHATHISTORY_CAP,
 } from './chathistory.js';
 export { tagmsgChannelReducer, tagmsgUserReducer } from './tagmsg.js';
+export {
+  DEFAULT_MULTILINE_MAX_BYTES,
+  MULTILINE_CAP,
+  type FinalizeMultilineResult,
+  type MultilineEntry,
+  type MultilineFanout,
+  buildMultilineFanout,
+  finalizeMultilineBatch,
+  joinMultiline,
+  multilineByteLength,
+  recordMultilineMessage,
+} from './multiline.js';
 export {
   versionReducer,
   timeReducer,
@@ -64,3 +78,23 @@ export {
 } from './server-info.js';
 export { userhostReducer, formatUserhostReply } from './userhost.js';
 export { isonReducer } from './ison.js';
+export {
+  monitorReducer,
+  MONITOR_CAP,
+  DEFAULT_MONITOR_LIMIT,
+} from './monitor.js';
+export {
+  READ_MARKER_CAP,
+  READ_MARKER_TAG,
+  isReadMarkerTagmsg,
+  persistReadMarker,
+  readMarkerMsgid,
+  seedReadMarkers,
+} from './read-marker.js';
+export {
+  PRE_AWAY_CAP,
+  clearPersistedAway,
+  nowAwayLine,
+  persistAway,
+  replayPersistedAway,
+} from './pre-away.js';

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

@@ -15,8 +15,10 @@
  * per-deployment (PLAN §10 capacity planning).
  */
 
+import { DEFAULT_MULTILINE_MAX_BYTES } from '../caps/capabilities.js';
 import type { RawLine } from '../effects.js';
 import type { ServerConfig } from '../types.js';
+import { DEFAULT_MONITOR_LIMIT } from './monitor.js';
 
 /** Max bytes per IRC wire line, including trailing `\r\n`. */
 const LINE_MAX_BYTES = 510;
@@ -36,6 +38,32 @@ const CHANMODES = {
 /** Channel-user prefix sigils, in PREFIX order (highest rank first). */
 const PREFIX = '(ov)@+';
 
+/**
+ * STATUSMSG delivery prefixes — the channel-user sigils a sender may prefix
+ * a target with (`@#channel` / `+#channel`) so only that rank and above
+ * receive the message. Mirrors the PREFIX sigil tail.
+ */
+const STATUSMSG_PREFIXES = '@+';
+
+/**
+ * Default extended-ban prefix when {@link ServerConfig.extbanPrefix} is
+ * unset. `~` is the de-facto IRC standard (matches nearly every daemon).
+ */
+const DEFAULT_EXTBAN_PREFIX = '~';
+
+/**
+ * Extended-ban types this server understands independent of services.
+ * `q` = quiet ban (prevents matching targets from speaking).
+ */
+const EXTBAN_TYPES = 'q';
+
+/**
+ * Account-name extended-ban type, advertised as a dedicated `ACCOUNTEXTBAN=a`
+ * token only when services are enabled, since account bans require registered
+ * nicks to be meaningful.
+ */
+const ACCOUNTEXTBAN_TYPE = 'a';
+
 /** Channel name sigils this server recognises. */
 const CHANTYPES = '#';
 
@@ -56,6 +84,9 @@ const TRAILER = 'are supported by this server';
  * can diff between servers. Tokens are space-separated, never empty.
  */
 function buildTokens(cfg: ServerConfig): string[] {
+  const monitorLimit = cfg.monitorLimit ?? DEFAULT_MONITOR_LIMIT;
+  const extbanPrefix = cfg.extbanPrefix ?? DEFAULT_EXTBAN_PREFIX;
+  const multilineMax = cfg.multilineMaxBytes ?? DEFAULT_MULTILINE_MAX_BYTES;
   return [
     `CHANTYPES=${CHANTYPES}`,
     `CHANMODES=${CHANMODES.list},${CHANMODES.paramSet},${CHANMODES.paramAlways},${CHANMODES.boolean}`,
@@ -73,6 +104,28 @@ function buildTokens(cfg: ServerConfig): string[] {
     // per-connection opt-in). LIST is always non-destructive here so the
     // token is unconditional.
     'SAFELIST',
+    // IRCv3 MONITOR cap ceiling. The value matches the per-connection
+    // watchlist size enforced by the monitor reducer; deployments lower it
+    // via `serverConfig.monitorLimit`.
+    `MONITOR=${monitorLimit}`,
+    // STATUSMSG — prefixes a sender may target (`@#chan`/`+#chan`) for
+    // rank-scoped delivery. The sigil set mirrors PREFIX.
+    `STATUSMSG=${STATUSMSG_PREFIXES}`,
+    // EXTBAN — extended-ban prefix and the base type list (`q` = quiet).
+    // The prefix is config-derived. The account-name extban is advertised
+    // as a separate `ACCOUNTEXTBAN=a` token (below) when services ship.
+    `EXTBAN=${extbanPrefix},${EXTBAN_TYPES}`,
+    // draft/typing advertisement — the cap is always supported, so the
+    // token is unconditional. (Draft caps have no RFC ISUPPORT token; this
+    // is the local marker clients can key on.)
+    'TYPING',
+    // draft/multiline byte budget — mirrors the `draft/multiline=<n>` cap
+    // value so the ceiling is visible pre-cap-negotiation.
+    `MULTILINE=${multilineMax}`,
+    // ACCOUNTEXTBAN — account-name extended ban. Meaningful only once
+    // services register nicks, so suppressed until a deployment wires
+    // services up via `serverConfig.servicesEnabled`.
+    ...(cfg.servicesEnabled ? [`ACCOUNTEXTBAN=${ACCOUNTEXTBAN_TYPE}`] : []),
   ];
 }
 

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

@@ -528,7 +528,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'] as const;
+const USER_MODE_LETTER_ORDER = ['i', 'w', 's', 'o', 'S'] as const;
 
 /**
  * Handles `MODE <nick> [<modestring>]`.
@@ -640,6 +640,13 @@ 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.
+    if (letter === 'S') {
+      if (state.userModes.tls) modeStr += 'S';
+      continue;
+    }
     const field = USER_MODE_LETTERS[letter];
     if (field !== undefined && state.userModes[field]) modeStr += letter;
   }