serverless-ircd 0.8.0 → 0.9.0

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

@@ -413,6 +413,31 @@ function handleList(
 // vhost application helpers
 // ============================================================================
 
+/**
+ * Consults the bound {@link ServicesStore} for an assigned vhost for `account`
+ * and, when one is present, applies it to {@link ConnectionState} via
+ * {@link applyVhost}. This is the shared login-time hook invoked by every
+ * account-success path (SASL PLAIN, PASS-auth via {@link applyAccountSuccess},
+ * and NickServ `IDENTIFY` via {@link applyIdentify}) so a reconnecting user
+ * with an assigned vhost does not have to re-run `HostServ ON` every session.
+ *
+ * No-op (no effects emitted, no state change) when no vhost is recorded. The
+ * CHGHOST fanout appended to `effects` is empty at SASL / PASS-auth time
+ * (registration has not completed and/or no channels are joined yet) but fires
+ * for a post-registration NickServ `IDENTIFY` when the user is already in
+ * channels — reusing {@link applyVhost} so the wire shape matches `HostServ ON`.
+ */
+export function applyAssignedVhost(
+  state: ConnectionState,
+  services: ServicesStore,
+  account: string,
+  effects: EffectType[],
+): void {
+  const vhost = services.getVhost(account);
+  if (vhost === undefined) return;
+  applyVhost(state, vhost, effects);
+}
+
 /**
  * Applies `vhost` to {@link ConnectionState.host}, records the prior host
  * on {@link ConnectionState.preVhostHost}, flips
@@ -421,7 +446,7 @@ function handleList(
  * {@link emitChghost} helper so the wire shape matches every other
  * user/host mutation.
  */
-function applyVhost(state: ConnectionState, vhost: string, effects: EffectType[]): void {
+export function applyVhost(state: ConnectionState, vhost: string, effects: EffectType[]): void {
   const oldUser = state.user ?? '';
   const oldHost = state.host ?? '';
   state.preVhostHost = oldHost;
@@ -457,13 +482,23 @@ function notice(state: ConnectionState, text: string): EffectType {
   return Effect.send(state.id, [servicesNotice(HOSTSERV_NICK, state, text)]);
 }
 
+/** User-visible HostServ subcommands (shown to every caller). */
+const USER_COMMANDS = 'ON, OFF, REQUEST';
+
+/** Oper-only HostServ subcommands, appended to {@link USER_COMMANDS} for opers. */
+const OPER_COMMANDS = 'SET, APPROVE, REJECT, LIST';
+
 /** Builds a help `:HostServ!HostServ@services NOTICE <nick> :…` line. */
 function helpNotice(state: ConnectionState): EffectType {
-  return notice(state, 'Available commands: ON, OFF, REQUEST, SET, APPROVE, REJECT, LIST');
+  const commands =
+    state.userModes.oper === true ? `${USER_COMMANDS}, ${OPER_COMMANDS}` : USER_COMMANDS;
+  return notice(state, `Available commands: ${commands}`);
 }
 
 function unknownNotice(state: ConnectionState): EffectType {
-  return notice(state, 'Unknown command. Available: ON, OFF, REQUEST, SET, APPROVE, REJECT, LIST');
+  const commands =
+    state.userModes.oper === true ? `${USER_COMMANDS}, ${OPER_COMMANDS}` : USER_COMMANDS;
+  return notice(state, `Unknown command. Available: ${commands}`);
 }
 
 /**

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

@@ -110,3 +110,4 @@ export {
 } from './chanserv.js';
 export { HOSTSERV_NICK, hostservReducer } from './hostserv.js';
 export { OPERSERV_NICK, operservReducer } from './operserv.js';
+export { SERVICE_NICKS, SHORTCUT_TO_SERVICE } from './service-aliases.js';

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

@@ -27,6 +27,7 @@ import type { ConnectionState } from '../state/connection.js';
 import type { Ctx, Reducer } from '../types.js';
 import { CHANSERV_HOSTMASK, DEFAULT_CHANNEL_LEVELS } from './chanserv.js';
 import { CHATHISTORY_CAP, buildChathistoryBatch } from './chathistory.js';
+import { topicNumerics } from './topic.js';
 
 /**
  * RFC 1459/2812 channel-name grammar. The first character must be a channel
@@ -265,16 +266,27 @@ export const joinReducer: Reducer<ChannelState> = (state, msg, ctx) => {
     }
   }
 
-  // All checks passed: add to roster. First joiner gets op per RFC 2812.
+  // All checks passed: add to roster. First joiner gets op per RFC 2812,
+  // unless the channel is ChanServ-registered — in that case the first
+  // joiner is opped only when they are the founder or meet the AUTOOP
+  // level (computeChanservAutoPrefix), so a random user reconnecting
+  // first after a roster-wiping deploy cannot seize op in a channel they
+  // do not own. The real founder / access-list users who join later are
+  // opped by the same access check on the non-empty path.
   const wasEmpty = state.members.size === 0;
-  // ChanServ ACCESS auto-prefix: when services are bound, the channel is
-  // registered, and this is not the RFC 2812 first-joiner case, look up
-  // the joiner's access level and apply the matching channel prefix.
-  // `chanservPrefix` is non-null only when ChanServ (not the RFC 2812
-  // rule) granted the prefix, so the JOIN hook knows to emit a ChanServ
-  // MODE broadcast alongside the roster mutation.
-  const autoPrefix = wasEmpty ? null : computeChanservAutoPrefix(ctx, state.nameLower);
-  const grantOp = wasEmpty || (autoPrefix?.op ?? false);
+  // ChanServ ACCESS auto-prefix: always look up the joiner's access level
+  // so the empty-channel gating above and the non-empty case share one
+  // code path. `autoPrefix` is non-null only when ChanServ could resolve
+  // the joiner's access (services bound, channel registered, joiner
+  // identified); it carries {op:false,voice:false} when the joiner is on
+  // no list, and null when ChanServ is not authoritative for this join
+  // (services unbound / channel unregistered / joiner unidentified).
+  const autoPrefix = computeChanservAutoPrefix(ctx, state.nameLower);
+  const channelRegistered = ctx.services?.getChannel(state.nameLower) !== undefined;
+  // RFC 2812 first-joiner op applies only when the channel is NOT
+  // registered. A registered channel's first joiner gets op solely via
+  // the access check (founder / AUTOOP), never by the empty-channel rule.
+  const grantOp = (wasEmpty && !channelRegistered) || (autoPrefix?.op ?? false);
   const grantVoice = autoPrefix?.voice ?? false;
   const joinerNick = ctx.connection.nick ?? '?';
   state.members.set(ctx.connId, {
@@ -288,13 +300,12 @@ export const joinReducer: Reducer<ChannelState> = (state, msg, ctx) => {
   // before this join and services have a persisted topic snapshot for a
   // keep-topic-enabled registration, restore the topic onto the
   // authoritative ChannelState. The 332/333 numerics are emitted to the
-  // joiner below alongside the NAMES list.
-  let restoredTopic: ChannelTopic | undefined;
+  // joiner below alongside the NAMES list, keyed off `state.topic`.
   if (wasEmpty) {
-    restoredTopic = restoreKeepTopic(ctx, state.nameLower);
-    if (restoredTopic !== undefined) {
-      state.topic = restoredTopic;
-      effects.push(Effect.applyChannelDelta(state.name, { topic: restoredTopic }));
+    const restored = restoreKeepTopic(ctx, state.nameLower);
+    if (restored !== undefined) {
+      state.topic = restored;
+      effects.push(Effect.applyChannelDelta(state.name, { topic: restored }));
     }
   }
 
@@ -323,13 +334,15 @@ export const joinReducer: Reducer<ChannelState> = (state, msg, ctx) => {
     }),
   );
 
-  // ChanServ auto-prefix broadcast: when ChanServ granted op or voice
-  // (i.e. NOT the RFC 2812 first-joiner case), emit a
-  // `:ChanServ!ChanServ@services MODE #chan +o nick` broadcast so every
-  // client in the channel updates its prefix display. Supersedes the
-  // implicit voice when op is granted (the channel-prefix grammar
-  // already renders `@` for ops).
-  if (autoPrefix !== null && (autoPrefix.op || autoPrefix.voice)) {
+  // ChanServ auto-prefix broadcast: when ChanServ granted op or voice on
+  // a non-empty channel, emit a `:ChanServ!ChanServ@services MODE #chan
+  // +o nick` broadcast so existing clients update their prefix display.
+  // Suppressed on the empty-channel first-join (wasEmpty) because the
+  // joiner is the channel's only client and already sees their prefix in
+  // the NAMES list — the op grant is silent. Supersedes the implicit
+  // voice when op is granted (the channel-prefix grammar already renders
+  // `@` for ops).
+  if (!wasEmpty && autoPrefix !== null && (autoPrefix.op || autoPrefix.voice)) {
     effects.push(buildChanservPrefixBroadcast(state.name, joinerNick, autoPrefix));
   }
 
@@ -379,19 +392,12 @@ export const joinReducer: Reducer<ChannelState> = (state, msg, ctx) => {
 
   effects.push(Effect.send(ctx.connId, lines));
 
-  // When ChanServ KEEPTOPIC restored a topic this JOIN, emit the 332/333
-  // topic numerics to the joiner so their client renders the restored
-  // topic (mirroring the TOPIC read-form reply shape).
-  if (restoredTopic !== undefined) {
-    effects.push(
-      Effect.send(ctx.connId, [
-        { text: `:${ctx.serverName} 332 ${nick} ${chanName} :${restoredTopic.text}` },
-        {
-          text: `:${ctx.serverName} 333 ${nick} ${chanName} ${restoredTopic.setter} ${restoredTopic.setAt}`,
-        },
-      ]),
-    );
-  }
+  // Emit 332/333 topic numerics to the joiner whenever a topic is set on
+  // the channel, regardless of whether it came from a ChanServ KEEPTOPIC
+  // restore this join, a deploy snapshot, or an earlier joiner. Mirrors
+  // the TOPIC read-form reply shape (RFC 2812 §3.2.1).
+  const topicReply = topicNumerics(state, ctx);
+  if (topicReply !== undefined) effects.push(topicReply);
 
   return { state, effects };
 };

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

@@ -36,6 +36,7 @@ import type { NickEnforcePolicy, ServicesStore } from '../ports.js';
 import type { ConnectionState } from '../state/connection.js';
 import type { Ctx, Reducer } from '../types.js';
 import { emitAccountNotify } from './account-notify.js';
+import { applyAssignedVhost } from './hostserv.js';
 import { deliverUnreadMemos } from './memoserv.js';
 
 /** Canonical NickServ pseudo-client nick. */
@@ -74,6 +75,7 @@ export const nickservReducer: Reducer<ConnectionState> = (state, msg, ctx) => {
   switch (sub) {
     case 'REGISTER':
       return handleRegister(state, args, ctx, effects);
+    case 'ID':
     case 'IDENTIFY':
       return handleIdentify(state, args, ctx, effects);
     case 'DROP':
@@ -166,9 +168,10 @@ function handleIdentify(
 }
 
 /**
- * Applies a successful identify: records the account, sets `+r`, emits the
- * confirmation NOTICE, fans `ACCOUNT` out to peers, and delivers queued
- * memos.
+ * Applies a successful identify: records the account, sets `+r`, re-applies any
+ * assigned HostServ vhost (so a reconnecting user does not have to re-run
+ * `HostServ ON`), emits the confirmation NOTICE, fans `ACCOUNT` out to peers,
+ * and delivers queued memos.
  */
 function applyIdentify(
   state: ConnectionState,
@@ -178,6 +181,10 @@ function applyIdentify(
 ): void {
   state.account = account;
   state.userModes.registered = true;
+  // Re-apply an assigned HostServ vhost. At identify time the connection is
+  // usually pre-JOIN so the CHGHOST fanout is empty, but a post-JOIN IDENTIFY
+  // fans CHGHOST out to the user's current `chghost`-capable peers.
+  applyAssignedVhost(state, services, account, effects);
   effects.push(notice(state, `You are now identified for nick ${account}.`));
   effects.push(...emitAccountNotify({ conn: state, account }));
   deliverUnreadMemos(state, services, account, effects);
@@ -241,7 +248,12 @@ function handleInfo(
 
   effects.push(notice(state, `Nick: ${rec.nick}`));
   effects.push(notice(state, `Account: ${rec.account}`));
-  effects.push(notice(state, `Email: ${rec.email}`));
+  // Email is private: only the account owner or an oper may see it. Mirrors
+  // the `state.account === rec.account` gate used by SET ENFORCE / the
+  // enforcement hook, extended to opers.
+  if (state.account === rec.account || state.userModes.oper) {
+    effects.push(notice(state, `Email: ${rec.email}`));
+  }
   return { state, effects };
 }
 

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

@@ -22,7 +22,7 @@ import type { ChanName } 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 { passBasedAccountAuth } from './account-auth.js';
+import { attemptPassAccountAuth, passBasedAccountAuth } from './account-auth.js';
 import { generateIsupport } from './isupport.js';
 import { buildMotdNumerics } from './motd-lines.js';
 import { enforceRegisteredNick } from './nickserv.js';
@@ -161,12 +161,16 @@ export function emitWelcomeIfReady(state: ConnectionState, ctx: Ctx): EffectType
  * Replaces `state.host` with a deterministic cloak derived from the
  * deployment's cloaking secret + the current (real) host. No-op when
  * cloaking is disabled or no host is set yet (e.g. transport didn't supply
- * one, or the connection sets it later via CHGHOST).
+ * one, or the connection sets it later via CHGHOST). Also a no-op when a
+ * HostServ vhost is already active (`vhostActive`) — the vhost was re-applied
+ * by {@link applyAccountSuccess} during SASL / PASS-auth and must win over the
+ * cloak so it remains visible in the `001` welcome.
  */
 function applyCloakIfEnabled(state: ConnectionState, ctx: Ctx): void {
   const cloaking = ctx.serverConfig.cloaking;
   if (cloaking === undefined || !cloaking.enabled) return;
   if (state.host === undefined) return;
+  if (state.vhostActive === true) return;
   state.host = cloakHost(state.host, cloaking, ctx.networkName);
 }
 
@@ -340,33 +344,40 @@ export const userReducer: Reducer<ConnectionState> = (state, msg, ctx) => {
 /**
  * Reducer for `PASS <password>`.
  *
- * Stashes the attempt as `state.passAttempt`. The pure-reducer gate
- * itself lives in {@link passwordGateFailure} (same file), which
- * {@link emitWelcomeIfReady} consults at registration completion:
- * it compares `state.passAttempt` against
- * `ctx.serverConfig.serverPassword` and, on mismatch, emits
- * `464 ERR_PASSWDMISMATCH` plus a `Disconnect("Bad Password")`. A
- * SASL-identified connection (`state.account !== undefined`) short-
- * circuits the gate, so PASS is unnecessary when SASL has already
- * authenticated an account.
+ * Pre-registration: stashes the attempt as `state.passAttempt` for the
+ * server-password gate ({@link passwordGateFailure}) and the at-completion
+ * PASS-auth ({@link passBasedAccountAuth}). A second `PASS` before
+ * registration completes is rejected with `462 ERR_ALREADYREGISTRED`.
+ *
+ * Post-registration: a bare server password is meaningless, so only the
+ * `<nick>:<password>` form is honoured — as a late account login via
+ * {@link attemptPassAccountAuth} against the bound `ctx.accounts`. Every
+ * other outcome (bare value, no store, already identified, verify failure)
+ * is a silent no-op: no `462`, no disconnect. This lets a client that
+ * completed `NICK`+`USER` before sending `PASS` identify after the fact.
  */
 export const passReducer: Reducer<ConnectionState> = (state, msg, ctx) => {
   const effects: EffectType[] = [];
 
-  if (state.registration === 'registered') {
+  const password = msg.params[0];
+  if (password === undefined) {
     effects.push(
       Effect.send(ctx.connId, [
-        numericErr(ctx, Numerics.ERR_ALREADYREGISTRED, 'You may not reregister'),
+        numericErr(ctx, Numerics.ERR_NEEDMOREPARAMS, 'Not enough parameters', 'PASS'),
       ]),
     );
     return { state, effects };
   }
 
-  const password = msg.params[0];
-  if (password === undefined) {
+  if (state.registration === 'registered') {
+    effects.push(...attemptPassAccountAuth(state, ctx, password));
+    return { state, effects };
+  }
+
+  if (state.passAttempt !== undefined) {
     effects.push(
       Effect.send(ctx.connId, [
-        numericErr(ctx, Numerics.ERR_NEEDMOREPARAMS, 'Not enough parameters', 'PASS'),
+        numericErr(ctx, Numerics.ERR_ALREADYREGISTRED, 'You may not reregister'),
       ]),
     );
     return { state, effects };

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/topic.ts

@@ -153,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),
@@ -161,19 +162,31 @@ 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}`,
+    },
+  ]);
 }
 
 // ============================================================================

package/packages/irc-core/src/state/channel.ts

@@ -92,6 +92,23 @@ export interface MembershipDelta {
   conn: ConnId;
   /** Required on `add`; ignored on `remove`. */
   nick?: Nick;
+  /**
+   * Nick-keyed resolution hint for ChanServ prefix/kick commands. When set,
+   * the actor layer resolves nick→connId against the channel roster at apply
+   * time and overwrites {@link conn} with the resolved id; if the nick is not
+   * on the channel, the delta is a no-op and ChanServ NOTICEs the caller.
+   *
+   * ChanServ operates on `ConnectionState` and cannot see the roster, so it
+   * emits a placeholder {@link conn} (`''`) plus this hint — see
+   * `resolveMembershipTarget` in `commands/chanserv.ts`.
+   *
+   * When `targetNick` is present on an `add` delta, the actor treats the
+   * `op`/`voice` fields as a *patch*: only fields set on the delta are
+   * applied, others retain the existing entry's value. This lets ChanServ
+   * op a voiced user without clobbering their voice (a pure reducer cannot
+   * read both flags ahead of time).
+   */
+  targetNick?: Nick;
   op?: boolean;
   voice?: boolean;
 }