serverless-ircd 0.7.0 → 0.9.0

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

@@ -32,12 +32,9 @@ import type { Effect as EffectType, RawLine } from '../effects.js';
 import type { SaslResult } from '../ports.js';
 import { decodeBase64 } from '../protocol/base64.js';
 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';
+import { applyAccountSuccess } from './account-auth.js';
 
 /** Per-ircdocs.horse: a single `AUTHENTICATE` payload chunk is at most 400 bytes. */
 const SASL_CHUNK_BYTES = 400;
@@ -172,18 +169,28 @@ function finalizePlain(
     return { state, effects: [Effect.send(ctx.connId, [saslFail(ctx)])] };
   }
 
+  // Prefer the static AccountStore; fall back to the ServicesStore so a
+  // nick registered via NickServ can authenticate via SASL PLAIN without a
+  // separate static credential table. When neither verifies, fail.
   const store = ctx.accounts;
-  if (store === undefined) {
-    clearSasl(state);
-    return { state, effects: [Effect.send(ctx.connId, [saslFail(ctx)])] };
-  }
-
-  const result = store.verify('PLAIN', {
+  let result = store?.verify('PLAIN', {
     kind: 'PLAIN',
     username: parsed.username,
     password: parsed.password,
   });
 
+  if (result === undefined || !result.ok) {
+    const servicesResult = ctx.services?.verifyNick(parsed.username, parsed.password);
+    if (servicesResult?.ok) {
+      result = servicesResult;
+    }
+  }
+
+  if (result === undefined) {
+    clearSasl(state);
+    return { state, effects: [Effect.send(ctx.connId, [saslFail(ctx)])] };
+  }
+
   return applyResult(state, result, ctx);
 }
 
@@ -220,31 +227,7 @@ function applyResult(
   clearSasl(state);
 
   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)]),
-        ...awayEffects,
-        ...emitAccountNotify({ conn: state, account: result.account }),
-      ],
-    };
+    return { state, effects: applyAccountSuccess(state, ctx, result.account) };
   }
   return { state, effects: [Effect.send(ctx.connId, [saslFail(ctx)])] };
 }
@@ -274,20 +257,6 @@ function clearSasl(state: ConnectionState): void {
   delete state.saslBuffer;
 }
 
-function loggedIn(ctx: Ctx, account: string): RawLine {
-  const nick = nickOf(ctx);
-  const hostmask = hostmaskOf(ctx.connection) ?? nick;
-  return L(
-    `:${ctx.serverName} ${code(Numerics.RPL_LOGGEDIN)} ${nick} ${hostmask} ${account} :You are now logged in as ${account}`,
-  );
-}
-
-function saslSuccess(ctx: Ctx): RawLine {
-  return L(
-    `:${ctx.serverName} ${code(Numerics.RPL_SASLSUCCESS)} ${nickOf(ctx)} :SASL authentication successful`,
-  );
-}
-
 function saslFail(ctx: Ctx): RawLine {
   return L(
     `:${ctx.serverName} ${code(Numerics.ERR_SASLFAIL)} ${nickOf(ctx)} :SASL authentication failed`,

package/packages/irc-core/src/commands/service-aliases.ts

@@ -0,0 +1,52 @@
+/**
+ * Service shortcut command aliases (Atheme/Anope convention).
+ *
+ * Clients and user expectations support shortcut verbs like
+ * `NICKSERV REGISTER pw` as an alias for `PRIVMSG NickServ :REGISTER pw`.
+ * These are not RFC-standardized but are a de facto convention from
+ * services packages (Atheme/Anope) and IRCd alias modules (InspIRCd
+ * `m_alias`, UnrealIRCd `alias{}`).
+ *
+ * The actor's dispatcher rewrites any of these verbs to a
+ * `PRIVMSG <ServiceNick> :<joined args>` and delegates to the existing
+ * `routeMessageTarget` path, so the service reducers see the canonical
+ * `params=[serviceNick, body]` shape unchanged.
+ *
+ * This module is the **single source of truth** for the alias → service
+ * nick mapping. Both the dispatcher rewrite (in `irc-server`'s actor) and
+ * the service-nick recognition in `serviceReducerFor` consult the derived
+ * {@link SERVICE_NICKS} list rather than maintaining their own copies.
+ */
+
+import { CHANSERV_NICK } from './chanserv.js';
+import { HOSTSERV_NICK } from './hostserv.js';
+import { MEMOSERV_NICK } from './memoserv.js';
+import { NICKSERV_NICK } from './nickserv.js';
+import { OPERSERV_NICK } from './operserv.js';
+
+/**
+ * Shortcut command verb (uppercased) → canonical service nick. Keyed by
+ * uppercased command so the dispatcher's `msg.command.toUpperCase()` lookup
+ * is case-insensitive. The full set of Atheme/Anope-convention aliases.
+ */
+export const SHORTCUT_TO_SERVICE: ReadonlyMap<string, string> = new Map<string, string>([
+  ['NICKSERV', NICKSERV_NICK],
+  ['NS', NICKSERV_NICK],
+  ['CHANSERV', CHANSERV_NICK],
+  ['CS', CHANSERV_NICK],
+  ['HOSTSERV', HOSTSERV_NICK],
+  ['HS', HOSTSERV_NICK],
+  ['MEMOSERV', MEMOSERV_NICK],
+  ['MS', MEMOSERV_NICK],
+  ['OPERSERV', OPERSERV_NICK],
+  ['OS', OPERSERV_NICK],
+]);
+
+/**
+ * The canonical, de-duplicated list of service nicks derived from
+ * {@link SHORTCUT_TO_SERVICE}'s values. Used by `serviceReducerFor` for the
+ * "is this target a service nick?" membership check so the service-nick list
+ * lives in exactly one place (this module), not duplicated across an
+ * `if`-chain.
+ */
+export const SERVICE_NICKS: readonly string[] = Array.from(new Set(SHORTCUT_TO_SERVICE.values()));

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

@@ -202,13 +202,26 @@ export const tagmsgChannelReducer: Reducer<ChannelState> = (state, msg, ctx) =>
   // 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 isReadMarker = isReadMarkerTagmsg(msg.tags);
+  if (isReadMarker) {
     const msgid = readMarkerMsgid(msg.tags);
     if (msgid !== undefined) {
       persistReadMarker(ctx, state.nameLower, msgid);
     }
   }
 
+  // IRCv3 draft/read-marker spec compliance: a read marker is private to
+  // the originator's account and MUST NOT be disclosed to other users. The
+  // mark TAGMSG fans out ONLY to the originator's own account (account-
+  // scoped broadcast); dispatch restricts the recipient set to same-account
+  // channel members. An unidentified originator has no account to share the
+  // mark with, so the mark stays session-local — no fanout at all (the
+  // originator's own client still observes its mark via echo-message below).
+  // Every other TAGMSG (typing, generic) keeps the channel-wide fanout.
+  const originAccount = ctx.connection.account;
+  const suppressFanout = isReadMarker && originAccount === undefined;
+  const accountFilter = isReadMarker ? originAccount : undefined;
+
   // 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
@@ -217,11 +230,33 @@ export const tagmsgChannelReducer: Reducer<ChannelState> = (state, msg, ctx) =>
   // `caps` so dispatch applies OR semantics per recipient.
   const tagPrefix = serializeTags(msg.tags);
   const line: RawLine = { text: `${tagPrefix}:${hostmask} TAGMSG ${state.name}` };
-  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));
+  if (!suppressFanout) {
+    const widenCaps = widenAudienceCaps(msg.tags);
+    if (widenCaps !== undefined) {
+      effects.push(
+        Effect.broadcast(
+          state.name,
+          [line],
+          ctx.connId,
+          undefined,
+          undefined,
+          widenCaps,
+          accountFilter,
+        ),
+      );
+    } else {
+      effects.push(
+        Effect.broadcast(
+          state.name,
+          [line],
+          ctx.connId,
+          MESSAGE_TAGS_CAP,
+          undefined,
+          undefined,
+          accountFilter,
+        ),
+      );
+    }
   }
 
   // IRCv3 echo-message: echo the same line back to the sender, after

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

@@ -20,6 +20,7 @@
 
 import { Effect } from '../effects.js';
 import type { Effect as EffectType, RawLine } from '../effects.js';
+import type { PersistedTopic } from '../ports.js';
 import { Numerics } from '../protocol/numerics.js';
 import type { ChannelState, ChannelTopic } from '../state/channel.js';
 import { hostmaskOf } from '../state/connection.js';
@@ -121,6 +122,10 @@ export const topicReducer: Reducer<ChannelState> = (state, msg, ctx) => {
     // path that persists the change, so subsequent reads by other
     // connections observe the cleared topic.
     effects.push(Effect.applyChannelDelta(state.name, { topic: null }));
+    // ChanServ KEEPTOPIC: clear the persisted snapshot when the channel has
+    // KEEPTOPIC enabled, so a subsequent empty-recreate does not restore a
+    // stale topic.
+    persistKeepTopic(ctx, state.nameLower, undefined);
   } else {
     const topic: ChannelTopic = {
       text: truncated,
@@ -130,6 +135,9 @@ export const topicReducer: Reducer<ChannelState> = (state, msg, ctx) => {
     state.topic = topic;
     // Mirror the topic set to the channel authority (see comment above).
     effects.push(Effect.applyChannelDelta(state.name, { topic }));
+    // ChanServ KEEPTOPIC: persist the snapshot when the channel has
+    // KEEPTOPIC enabled, so a subsequent empty-recreate restores it.
+    persistKeepTopic(ctx, state.nameLower, topic);
   }
 
   const hostmask = callerHostmask(ctx.connection);
@@ -145,7 +153,8 @@ function readTopic(
   ctx: Ctx,
   effects: EffectType[],
 ): { state: ChannelState; effects: EffectType[] } {
-  if (state.topic === undefined) {
+  const topicReply = topicNumerics(state, ctx);
+  if (topicReply === undefined) {
     effects.push(
       Effect.send(ctx.connId, [
         numericErr(ctx, Numerics.RPL_NOTOPIC, 'No topic is set', state.name),
@@ -153,17 +162,58 @@ function readTopic(
     );
     return { state, effects };
   }
+  effects.push(topicReply);
+  return { state, effects };
+}
 
+/**
+ * Builds the `332 RPL_TOPIC` + `333 RPL_TOPICWHOTIME` {@link Effect.send}
+ * for the connection's current nick, or `undefined` when no topic is set
+ * on `state.topic`.
+ *
+ * Shared by the TOPIC read-form ({@link readTopic}) and the JOIN success
+ * path so both emit an identical numeric block whenever a topic is
+ * present, regardless of whether the topic came from a ChanServ KEEPTOPIC
+ * restore, a deploy snapshot, or an earlier joiner.
+ */
+export function topicNumerics(state: ChannelState, ctx: Ctx): EffectType | undefined {
+  if (state.topic === undefined) return undefined;
   const nick = ctx.connection.nick ?? '*';
   const codeStr332 = Numerics.RPL_TOPIC.toString().padStart(3, '0');
   const codeStr333 = Numerics.RPL_TOPICWHOTIME.toString().padStart(3, '0');
-  effects.push(
-    Effect.send(ctx.connId, [
-      { text: `:${ctx.serverName} ${codeStr332} ${nick} ${state.name} :${state.topic.text}` },
-      {
-        text: `:${ctx.serverName} ${codeStr333} ${nick} ${state.name} ${state.topic.setter} ${state.topic.setAt}`,
-      },
-    ]),
-  );
-  return { state, effects };
+  return Effect.send(ctx.connId, [
+    { text: `:${ctx.serverName} ${codeStr332} ${nick} ${state.name} :${state.topic.text}` },
+    {
+      text: `:${ctx.serverName} ${codeStr333} ${nick} ${state.name} ${state.topic.setter} ${state.topic.setAt}`,
+    },
+  ]);
+}
+
+// ============================================================================
+// ChanServ KEEPTOPIC persistence
+// ============================================================================
+
+/**
+ * Persists the topic snapshot for a ChanServ-registered channel with
+ * KEEPTOPIC enabled. Called by the topic reducer on every topic change
+ * (set or clear) so a subsequent empty-recreate can restore the snapshot.
+ *
+ * No-op when:
+ *   - no services store is bound,
+ *   - the channel is not registered,
+ *   - KEEPTOPIC is off.
+ *
+ * `topic === undefined` clears the persisted snapshot; a {@link ChannelTopic}
+ * replaces it.
+ */
+function persistKeepTopic(ctx: Ctx, nameLower: string, topic: ChannelTopic | undefined): void {
+  const services = ctx.services;
+  if (services === undefined) return;
+  const rec = services.getChannel(nameLower);
+  if (rec === undefined || !rec.keepTopic) return;
+  const persisted: PersistedTopic | undefined =
+    topic === undefined
+      ? undefined
+      : { text: topic.text, setter: topic.setter, setAt: topic.setAt };
+  services.setChannelTopic(nameLower, persisted);
 }

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

@@ -17,7 +17,7 @@
  */
 
 import { z } from 'zod';
-import { BUILD_DATE } from './build-info.js';
+import { BUILD_DATE, PACKAGE_VERSION } from './build-info.js';
 import { DEFAULT_MULTILINE_MAX_BYTES } from './caps/capabilities.js';
 
 /**
@@ -144,11 +144,14 @@ export const DEFAULT_FLOOD_CONTROL_CONFIG: {
 
 /**
  * Default server version surfaced in `002`/`004`/`351`/`371` when a deployment
- * does not supply one. Kept in sync with `irc-core/package.json` `version`;
- * adapters inject the deploy-time version via the `serverVersion` config
- * knob (see the per-adapter config loaders).
+ * does not supply one. Sourced from `irc-core/package.json` at build time via
+ * `scripts/generate-build-info.mjs`, so a deployment that omits the
+ * `serverVersion` knob advertises the version of the package it was shipped
+ * with — no manual sync required. Adapters may still inject a deploy-time
+ * version via the `serverVersion` config knob (see the per-adapter config
+ * loaders).
  */
-export const DEFAULT_SERVER_VERSION = '0.3.0';
+export const DEFAULT_SERVER_VERSION: string = PACKAGE_VERSION;
 
 /**
  * Default "created" text for `003 RPL_CREATED` when a deployment does not
@@ -162,6 +165,14 @@ export const DEFAULT_SERVER_VERSION = '0.3.0';
  */
 export const DEFAULT_CREATED_TEXT: string = BUILD_DATE;
 
+/**
+ * Default grace period (ms) NickServ applies before force-disconnecting a
+ * client using a `ghost`-enforced registered nick without identifying.
+ * Matches the Atheme/Anope convention (~30s); overridable per deployment
+ * via `ServerConfig.nickEnforceGraceMs`.
+ */
+export const DEFAULT_NICK_ENFORCE_GRACE_MS = 30_000;
+
 /**
  * The full server-config schema. Optional fields default to deployment-
  * sensible values so a minimal `{ serverName, networkName }` config is
@@ -337,6 +348,26 @@ export const ServerConfigSchema = z.object({
    * nicks make them meaningless.
    */
   servicesEnabled: z.boolean().optional(),
+
+  /**
+   * Grace period (ms) NickServ applies before force-disconnecting a client
+   * using a `ghost`-enforced registered nick without identifying. See
+   * `ServerConfig.nickEnforceGraceMs`. `0` disables the grace (ghost
+   * behaves like kill). Omit for the 30s default.
+   */
+  nickEnforceGraceMs: z.number().int().nonnegative().optional(),
+
+  /**
+   * HostServ approval mode for `REQUEST <vhost>`. `true` (the default)
+   * preserves the legacy auto-approve behaviour — the requested vhost is
+   * recorded against the account immediately (no oper review). `false`
+   * switches HostServ into oper-queue mode: `REQUEST` records a pending
+   * request that an oper must `APPROVE` (or `REJECT`) via HostServ. The
+   * queue + the `APPROVE` / `REJECT` / `LIST` (oper-only) commands are
+   * available in either mode, but only `false` routes `REQUEST` through
+   * them.
+   */
+  hostservAutoApproveVhosts: z.boolean().default(false),
 });
 
 /** Input type: what adapters supply (fields with defaults may be omitted). */

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

@@ -55,6 +55,17 @@ export interface BroadcastEffect {
    * path.
    */
   caps?: readonly string[];
+  /**
+   * Account-scoped recipient filter (IRCv3 `draft/read-marker` privacy).
+   * When set, dispatch restricts the recipient set to channel members
+   * authenticated as this account — a read marker is private to the
+   * originator's own account and MUST NOT be disclosed to other users.
+   * Comparison is case-insensitive (RFC 1459 fold). Recipients still must
+   * satisfy the {@link cap} / {@link caps} filter; the {@link except}
+   * originator skip still applies. Used only by the read-marker mark
+   * TAGMSG path; every other broadcast leaves this unset (channel-wide).
+   */
+  account?: string;
 }
 
 export interface DisconnectEffect {
@@ -121,6 +132,39 @@ export interface BroadcastWallopsEffect {
   except?: ConnId;
 }
 
+/**
+ * NickServ nick-enforcement directive.
+ *
+ * Emitted by the NICK path when a client takes a registered nick they are
+ * not identified as, and the registered account's
+ * {@link NickEnforcePolicy} is `ghost` or `kill`. The actor layer (via
+ * `dispatch`) interprets the policy:
+ *
+ *   - `none`  — never emitted (the reducer sends the warning NOTICE only).
+ *   - `kill`  — `disconnect("Nick enforced by NickServ")` immediately.
+ *   - `ghost` — schedule the same disconnect after {@link EnforceNickEffect.graceMs};
+ *     when `graceMs === 0` the disconnect is immediate (matches `kill`).
+ *
+ * The grace duration is stamped by the reducer from the deployment's
+ * `nickEnforceGraceMs` config so `dispatch` stays free of clock access and
+ * the in-memory tests stay deterministic (the scheduler is injectable via
+ * {@link DispatchOptions.scheduler}).
+ */
+export interface EnforceNickEffect {
+  tag: 'EnforceNick';
+  /** Connection using the enforced nick. */
+  conn: ConnId;
+  /** Display spelling of the enforced nick. */
+  nick: Nick;
+  /** Per-account enforcement policy. */
+  policy: import('./ports.js').NickEnforcePolicy;
+  /**
+   * Grace period in ms before the disconnect fires (`ghost` only).
+   * `0` for `kill` and for `ghost` when the deployment disables the grace.
+   */
+  graceMs: number;
+}
+
 /** Discriminated union of every effect the dispatch interpreter knows. */
 export type Effect =
   | SendEffect
@@ -131,7 +175,8 @@ export type Effect =
   | ReleaseNickEffect
   | ApplyChannelDeltaEffect
   | SendToNickEffect
-  | BroadcastWallopsEffect;
+  | BroadcastWallopsEffect
+  | EnforceNickEffect;
 
 /** Literal string tag of every {@link Effect} variant. */
 export type EffectTag = Effect['tag'];
@@ -163,12 +208,14 @@ export const Effect = {
     cap?: string,
     capLines?: RawLine[],
     caps?: readonly string[],
+    account?: 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;
+    if (account !== undefined) e.account = account;
     return e;
   },
   disconnect(conn: ConnId, reason?: string): Effect {
@@ -198,4 +245,12 @@ export const Effect = {
     if (except !== undefined) e.except = except;
     return e;
   },
+  enforceNick(
+    conn: ConnId,
+    nick: Nick,
+    policy: import('./ports.js').NickEnforcePolicy,
+    graceMs: number,
+  ): Effect {
+    return { tag: 'EnforceNick', conn, nick, policy, graceMs };
+  },
 } as const;