serverless-ircd 0.4.0 → 0.6.0

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

@@ -19,6 +19,8 @@ export { handleJoinZero, isValidChannelName, joinReducer } from './join.js';
 export { partReducer } from './part.js';
 export { motdReducer } from './motd.js';
 export { operReducer, matchOperCred } from './oper.js';
+export { rehashReducer, rehashLine, buildRehashTrailing } from './rehash.js';
+export type { RehashResult } from './rehash.js';
 export {
   isChannelTarget,
   noticeChannelReducer,
@@ -27,6 +29,8 @@ export {
   privmsgUserReducer,
 } from './privmsg.js';
 export { kickReducer } from './kick.js';
+export { killReducer, formatKillReason } from './kill.js';
+export { wallopsReducer, wallopsLine } from './wallops.js';
 export { topicReducer } from './topic.js';
 export { namesReducer } from './names.js';
 export { listReducer } from './list.js';
@@ -35,11 +39,17 @@ export { inviteReducer } from './invite.js';
 export { whoReducer } from './who.js';
 export { whoisReducer } from './whois.js';
 export { whowasReducer } from './whowas.js';
+export { traceReducer } from './trace.js';
+export { lusersReducer } from './lusers.js';
+export { statsReducer } from './stats.js';
 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';
 export {
   chathistoryReducer,
@@ -48,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,
@@ -56,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/invite.ts

@@ -42,12 +42,10 @@ function callerHostmask(conn: ConnectionState): string {
 }
 
 /** Formats a numeric error/reply line addressed to the connection's nick. */
-function numericErr(ctx: Ctx, code: number, trailing: string, middle?: string): RawLine {
+function numericErr(ctx: Ctx, code: number, trailing: string, middle: string): RawLine {
   const nick = ctx.connection.nick ?? '*';
   const codeStr = code.toString().padStart(3, '0');
-  const parts = [`:${ctx.serverName}`, codeStr, nick];
-  if (middle !== undefined) parts.push(middle);
-  parts.push(`:${trailing}`);
+  const parts = [`:${ctx.serverName}`, codeStr, nick, middle, `:${trailing}`];
   return { text: parts.join(' ') };
 }
 

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}`] : []),
   ];
 }
 
@@ -82,6 +135,10 @@ function buildTokens(cfg: ServerConfig): string[] {
  * batch. The caller appends the trailer separately.
  *
  * Each batch returns just the joined token string (no `005`, no trailer).
+ *
+ * Contract: `tokens` is non-empty. The only caller (`generateIsupport`)
+ * satisfies this — `buildTokens` always emits at least the network/casing
+ * tokens — so no defensive empty-input handling is needed here.
  */
 function packTokens(tokens: ReadonlyArray<string>, baseLen: number): string[] {
   const batches: string[] = [];
@@ -96,7 +153,7 @@ function packTokens(tokens: ReadonlyArray<string>, baseLen: number): string[] {
       current = candidate;
     }
   }
-  if (current !== '') batches.push(current);
+  batches.push(current);
   return batches;
 }
 
@@ -106,7 +163,7 @@ function packTokens(tokens: ReadonlyArray<string>, baseLen: number): string[] {
  * @param cfg          Server configuration (size limits, network name).
  * @param _connCaps    IRCv3 capabilities negotiated by the connection
  *                     (reserved for `BOT=` and similar v3 tokens; currently
- *                     unused — kept in the signature per the ticket spec).
+ *                     unused — kept in the signature for forward compatibility).
  * @param nick         Optional nick for the reply target; defaults to `*`.
  * @returns One or more {@link RawLine}s, each within the 510-byte ceiling.
  *          Only the final line carries the `:are supported by this server`

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

@@ -35,12 +35,10 @@ function isValidChannelName(name: string, maxLen: number): boolean {
  * nick (or `*` when unregistered). Optional `middle` is emitted before the
  * trailing `:`-prefixed text.
  */
-function numericErr(ctx: Ctx, code: number, trailing: string, middle?: string): RawLine {
+function numericErr(ctx: Ctx, code: number, trailing: string, middle: string): RawLine {
   const nick = ctx.connection.nick ?? '*';
   const codeStr = code.toString().padStart(3, '0');
-  const parts = [`:${ctx.serverName}`, codeStr, nick];
-  if (middle !== undefined) parts.push(middle);
-  parts.push(`:${trailing}`);
+  const parts = [`:${ctx.serverName}`, codeStr, nick, middle, `:${trailing}`];
   return { text: parts.join(' ') };
 }
 

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

@@ -0,0 +1,127 @@
+/**
+ * Pure reducer for the IRC `KILL` command (oper-gated force-disconnect).
+ *
+ * PLAN §2.1 location-of-authority: KILL runs against the *target*'s
+ * connection. The actor layer resolves `<nick>` to a live
+ * {@link ConnectionState} via the nick registry and passes it here. The
+ * reducer performs the oper gate, validates parameters, and emits a single
+ * {@link DisconnectEffect} for the target. The runtime's `disconnect`
+ * method is responsible for closing the target's transport and fanning the
+ * QUIT out to shared-channel peers — the reducer does not model that
+ * fanout itself.
+ *
+ * Wire format (RFC 2812 §4.6.1):
+ *   - `KILL <nickname> <comment>`
+ *   - The target receives an `ERROR` / `QUIT` carrying a reason formatted
+ *     as `Killed (<oper> (<comment>))`.
+ *   - `481 ERR_NOPRIVILEGES`: `:<server> 481 <nick> :Permission Denied - ...`
+ *   - `461 ERR_NEEDMOREPARAMS`:
+ *     `:<server> 461 <nick> KILL :Not enough parameters`
+ *   - `401 ERR_NOSUCHNICK`: `:<server> 401 <nick> <target> :No such nick/channel`
+ *
+ * Behaviour:
+ *   - Non-oper sender → `481` (checked before parameters so a non-oper
+ *     cannot probe which nicks are online).
+ *   - Missing `<nickname>` or `<comment>` → `461`.
+ *   - Unknown nick → `401`.
+ *   - Otherwise emit `Disconnect(targetConnId, "Killed (<oper> (<comment>))")`.
+ *   - An oper may `KILL` themselves (RFC-permitted); no special-casing.
+ *
+ * Platform asymmetry: the emitted `Disconnect` is interpreted by the bound
+ * runtime. On CF the `disconnect` RPC closes the target DO's socket
+ * immediately; on AWS a `$default` invocation cannot close a remote APIGW
+ * WebSocket, so QUIT fanout to peers fires but the target's live socket
+ * only closes on its next `$disconnect`/sweeper cycle. The reducer is
+ * identical across adapters — only the runtime's `disconnect` semantics
+ * differ.
+ */
+
+import { Effect } from '../effects.js';
+import type { Effect as EffectType, RawLine } from '../effects.js';
+import { Numerics } from '../protocol/numerics.js';
+import type { ConnectionState } from '../state/connection.js';
+import type { Ctx } from '../types.js';
+
+/** Fixed text emitted for `481 ERR_NOPRIVILEGES`. */
+const NOPRIVILEGES_TRAILING_TEXT = "Permission Denied - You're not an IRC operator";
+
+/** Fixed text emitted for `461 ERR_NEEDMOREPARAMS`. */
+const NEEDMOREPARAMS_TRAILING_TEXT = 'Not enough parameters';
+
+/** Fixed text emitted for `401 ERR_NOSUCHNICK`. */
+const NOSUCHNICK_TRAILING_TEXT = 'No such nick/channel';
+
+/**
+ * Formats the canonical kill reason, `Killed (<oper> (<comment>))`, that
+ * the target receives on its closing transport. `<oper>` is the killing
+ * oper's display nick; `<comment>` is the oper-supplied reason verbatim.
+ */
+export function formatKillReason(operNick: string, comment: string): string {
+  return `Killed (${operNick} (${comment}))`;
+}
+
+/**
+ * Handles `KILL <nick> <comment>`.
+ *
+ * `target` is the live {@link ConnectionState} the actor resolved for
+ * `<nick>`, or `undefined` when the nick is offline / unknown. The
+ * signature is bespoke (not {@link Reducer}) because the actor must
+ * resolve the target asynchronously — mirrors `whoisReducer`.
+ */
+export function killReducer(
+  target: ConnectionState | undefined,
+  msg: { command: string; params: readonly string[] },
+  ctx: Ctx,
+): { effects: EffectType[] } {
+  ctx.connection.lastSeen = ctx.clock.now();
+
+  if (!ctx.connection.userModes.oper) {
+    return {
+      effects: [
+        Effect.send(ctx.connId, [
+          numericLine(ctx, Numerics.ERR_NOPRIVILEGES, NOPRIVILEGES_TRAILING_TEXT),
+        ]),
+      ],
+    };
+  }
+
+  const targetNick = msg.params[0];
+  const comment = msg.params[1];
+
+  if (targetNick === undefined || comment === undefined) {
+    return {
+      effects: [
+        Effect.send(ctx.connId, [
+          numericLine(ctx, Numerics.ERR_NEEDMOREPARAMS, NEEDMOREPARAMS_TRAILING_TEXT, 'KILL'),
+        ]),
+      ],
+    };
+  }
+
+  if (target === undefined) {
+    return {
+      effects: [
+        Effect.send(ctx.connId, [
+          numericLine(ctx, Numerics.ERR_NOSUCHNICK, NOSUCHNICK_TRAILING_TEXT, targetNick),
+        ]),
+      ],
+    };
+  }
+
+  const operNick = ctx.connection.nick ?? '*';
+  return { effects: [Effect.disconnect(target.id, formatKillReason(operNick, comment))] };
+}
+
+/**
+ * Builds a `:<server> <code> <nick> [<middle>] :<trailing>` line. The nick
+ * falls back to `*` when the connection has not yet registered one,
+ * matching the rest of the codebase's numeric formatting.
+ */
+function numericLine(ctx: Ctx, code: number, trailing: string, middle?: string): RawLine {
+  const nick = ctx.connection.nick ?? '*';
+  const codeStr = code.toString().padStart(3, '0');
+  const parts = [`:${ctx.serverName}`, codeStr, nick];
+  if (middle !== undefined) parts.push(middle);
+  parts.push(`:${trailing}`);
+  return { text: parts.join(' ') };
+}

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

@@ -11,7 +11,7 @@
  *   - `322 RPL_LIST`       — `:<server> 322 <nick> <chan> <#users> :<topic>`
  *   - `323 RPL_LISTEND`    — `:<server> 323 <nick> :End of /LIST`
  *
- * Visibility rules (ticket spec):
+ * Visibility rules:
  *   - Secret (`+s`) channels are hidden from non-members.
  *   - Membership is checked against `chan.members` using `ctx.connId`.
  *