serverless-ircd 0.6.0 → 0.8.0

package/packages/irc-core/src/protocol/numerics.ts

@@ -190,6 +190,14 @@ export const Numerics = {
   ERR_NOOPERHOST: 491,
   ERR_UMODEUNKNOWNFLAG: 501,
   ERR_USERSDONTMATCH: 502,
+  /**
+   * `519 ERR_ALLMUSTREGISTER` — ChanServ `+R` channel mode rejection.
+   * Emitted to unidentified clients attempting to JOIN a `+R` channel; the
+   * connection must have identified to NickServ (SASL or `IDENTIFY`) to
+   * bypass the gate. Surfaced by ChanServ-registered channels that have
+   * enabled `SET RESTRICTED` or had `+R` applied directly.
+   */
+  ERR_ALLMUSTREGISTER: 519,
 } as const;
 
 export type NumericCode = keyof typeof Numerics;

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

@@ -35,6 +35,13 @@ export interface ChannelTopic {
  * parameterized modes — `k` (key) and `l` (limit) — are optional and use
  * `undefined` to signal "unset", exactly matching how `MODE` deltas encode
  * clearing them.
+ *
+ * Services-derived modes (settable only via ChanServ, not via `MODE`):
+ *   - `registered` — channel is registered with ChanServ (`+r`).
+ *   - `blockUnidentified` — `+R`, blocks join/PRIVMSG from unidentified
+ *     connections.
+ *   - `moderatedIdent` — `+M`, moderated speak requires identification
+ *     (ops/voiced/identified pass).
  */
 export interface ChannelModes {
   // boolean modes
@@ -44,6 +51,10 @@ export interface ChannelModes {
   moderated: boolean; // m
   secret: boolean; // s
   private: boolean; // p
+  // services-derived boolean modes (settable only via ChanServ)
+  registered: boolean; // r
+  blockUnidentified: boolean; // R
+  moderatedIdent: boolean; // M
   // parameterized modes
   key?: string; // k
   limit?: number; // l
@@ -56,7 +67,10 @@ export type BooleanChannelMode =
   | 'noExternal'
   | 'moderated'
   | 'secret'
-  | 'private';
+  | 'private'
+  | 'registered'
+  | 'blockUnidentified'
+  | 'moderatedIdent';
 
 /** Parameterized mode letters we know how to set/clear. */
 export type ParameterChannelMode = 'key' | 'limit';
@@ -143,6 +157,9 @@ export function emptyModes(): ChannelModes {
     moderated: false,
     secret: false,
     private: false,
+    registered: false,
+    blockUnidentified: false,
+    moderatedIdent: false,
   };
 }
 
@@ -271,6 +288,9 @@ function applyModeChange(modes: ChannelModes, change: ModeChange): void {
     case 'moderated':
     case 'secret':
     case 'private':
+    case 'registered':
+    case 'blockUnidentified':
+    case 'moderatedIdent':
       modes[change.mode] = change.set;
       break;
     case 'key':

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

@@ -21,7 +21,8 @@ export type RegistrationState = 'pre-registration' | 'registering' | 'registered
 /**
  * User modes applied to a connection. The IRC user-mode letters are
  * `i` (invisible), `o` (oper), `w` (wallops), `s` (server notices),
- * `S` (TLS connected — read-only, set by the transport at registration).
+ * `S` (TLS connected — read-only, set by the transport at registration),
+ * `r` (registered — read-only, set by NickServ IDENTIFY / SASL login).
  */
 export interface UserModes {
   invisible: boolean;
@@ -35,6 +36,13 @@ export interface UserModes {
    * settable via `MODE` (the parser rejects `+S`/`-S` with `501`).
    */
   tls: boolean;
+  /**
+   * User mode `r` — the connection is identified to a NickServ account.
+   * Read-only: set by the NickServ IDENTIFY reducer (and cleared on
+   * account drop / logout). Not settable via `MODE` (the parser rejects
+   * `+r`/`-r` with `501`).
+   */
+  registered: boolean;
 }
 
 /**
@@ -138,6 +146,21 @@ export interface ConnectionState {
    * ERR_MONLISTFULL` for rejected nicks.
    */
   monitorList?: Set<string>;
+  /**
+   * HostServ vhost state. When true, {@link host} currently carries the
+   * per-account vhost assigned via HostServ (rather than the connection's
+   * real — cloaked or otherwise — host). Toggled by `HostServ ON` /
+   * `HostServ OFF`; absent / false means the connection presents its real
+   * host. Persisted so a reconnect retains the toggle until the user (or
+   * the actor on identify) reapplies the vhost.
+   */
+  vhostActive?: boolean;
+  /**
+   * The real (cloaked) host that was visible before HostServ applied the
+   * vhost. `HostServ OFF` restores {@link host} from this field and
+   * clears it. Only meaningful while {@link vhostActive} is true.
+   */
+  preVhostHost?: string;
 }
 
 /**
@@ -185,6 +208,7 @@ export function createConnection(opts: CreateConnectionOptions): ConnectionState
       wallops: false,
       serverNotices: false,
       tls: false,
+      registered: false,
     },
     lastSeen: opts.lastSeen ?? opts.connectedSince,
     connectedSince: opts.connectedSince,

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

@@ -17,7 +17,7 @@ import type {
   MotdProvider,
   MtlsIdentityProvider,
   NickHistoryStore,
-  ReadMarkerStore,
+  ServicesStore,
 } from './ports.js';
 import type { IrcMessage } from './protocol/messages.js';
 import type { ConnectionState } from './state/connection.js';
@@ -195,6 +195,33 @@ export interface ServerConfig {
    * `exactOptionalPropertyTypes: true`.
    */
   readonly servicesEnabled?: boolean | undefined;
+  /**
+   * Grace period (ms) NickServ applies before force-disconnecting a client
+   * that uses a `ghost`-enforced registered nick without identifying. The
+   * reducer stamps this value onto the emitted `EnforceNick` effect;
+   * `dispatch` schedules the disconnect via its injectable scheduler.
+   *
+   * Omitted → falls back to {@link DEFAULT_NICK_ENFORCE_GRACE_MS} (30s,
+   * matching the Atheme/Anope convention). `0` disables the grace so
+   * `ghost` behaves like `kill` (immediate disconnect).
+   *
+   * Typed `number | undefined` to mirror Zod's optional output shape under
+   * `exactOptionalPropertyTypes: true`.
+   */
+  readonly nickEnforceGraceMs?: number | undefined;
+  /**
+   * HostServ approval mode for `REQUEST <vhost>`. `true` (the parsed
+   * default) preserves the legacy auto-approve behaviour — the vhost is
+   * recorded against the account immediately, no oper review. `false`
+   * switches HostServ into oper-queue mode: `REQUEST` queues a pending
+   * request that an oper must `APPROVE` (or `REJECT`); `LIST` enumerates
+   * the pending queue. See `docs/Services.md` §6.
+   *
+   * Typed `boolean | undefined` so inline `ServerConfig` literals in tests
+   * may omit it (the reducer treats `undefined` as "auto-approve on",
+   * matching the parsed default).
+   */
+  readonly hostservAutoApproveVhosts?: boolean | undefined;
 }
 
 /** Per-invocation context handed to every reducer. */
@@ -230,15 +257,6 @@ export interface Ctx {
    * entries and the WHOWAS reducer replays them.
    */
   readonly history?: NickHistoryStore;
-  /**
-   * Read-marker persistence source for IRCv3 `draft/read-marker` (absent
-   * when the deployment does not persist read markers). When present, a
-   * `+draft/read-marker=<msgid>` TAGMSG from an identified, cap-enabled
-   * client updates the per-`(account, channel)` marker, and SASL identify
-   * seeds the connection's `lastReadMarkers` from the stored values so a
-   * reconnect restores the user's read position.
-   */
-  readonly readMarkers?: ReadMarkerStore;
   /**
    * Away-status persistence source for IRCv3 `draft/pre-away` (absent
    * when the deployment does not persist away reasons). When present, a
@@ -251,6 +269,24 @@ export interface Ctx {
    * connections or restored on reconnect.
    */
   readonly away?: AwayStore;
+  /**
+   * IRC services persistence source for NickServ / ChanServ / HostServ /
+   * MemoServ, plus the per-account read-marker persistence for IRCv3
+   * `draft/read-marker`. Absent when services are not wired for this
+   * deployment. When present, the NickServ reducer answers
+   * `PRIVMSG NickServ :…` subcommands (REGISTER / IDENTIFY / DROP / INFO)
+   * against this store, a `+draft/read-marker=<msgid>` TAGMSG from an
+   * identified, cap-enabled client updates the per-`(account, channel)`
+   * marker via {@link ServicesStore.setLastReadMarker}, SASL identify seeds
+   * the connection's `lastReadMarkers` from
+   * {@link ServicesStore.listReadMarkers} so a reconnect restores the user's
+   * read position, and SASL PLAIN falls back to this store for nicks
+   * registered via NickServ. Omitted (→ `ctx.services` undefined) preserves
+   * the no-services behaviour: `PRIVMSG NickServ :…` is not intercepted,
+   * read-marker persistence stays session-only, and SASL PLAIN consults
+   * only {@link Ctx.accounts}.
+   */
+  readonly services?: ServicesStore;
   /** The connection invoking the command. Reducers mutate this freely. */
   readonly connection: ConnectionState;
   /** Convenience: `connection.id`. */
@@ -291,8 +327,8 @@ export interface BuildCtxOptions {
   mtlsIdentity?: MtlsIdentityProvider;
   messages?: MessageStore;
   history?: NickHistoryStore;
-  readMarkers?: ReadMarkerStore;
   away?: AwayStore;
+  services?: ServicesStore;
   connection: ConnectionState;
   /**
    * IRCv3 `labeled-response` label extracted from the inbound `+label` tag.
@@ -317,8 +353,8 @@ export function buildCtx(opts: BuildCtxOptions): Ctx {
     ...(opts.mtlsIdentity !== undefined ? { mtlsIdentity: opts.mtlsIdentity } : {}),
     ...(opts.messages !== undefined ? { messages: opts.messages } : {}),
     ...(opts.history !== undefined ? { history: opts.history } : {}),
-    ...(opts.readMarkers !== undefined ? { readMarkers: opts.readMarkers } : {}),
     ...(opts.away !== undefined ? { away: opts.away } : {}),
+    ...(opts.services !== undefined ? { services: opts.services } : {}),
     ...(opts.label !== undefined ? { label: opts.label } : {}),
   };
   return ctx;

package/packages/irc-core/tests/batch.test.ts

@@ -34,6 +34,21 @@ describe('wrapBatch — framing', () => {
     expect(out).toEqual<RawLine[]>([]);
   });
 
+  it('returns an empty BatchFrame carrying the framing metadata when lines is empty', () => {
+    // Empty batches are spec-forbidden and silently elided, but the returned
+    // array still advertises the id/type/start/body/end surface so callers
+    // can read the framing shape without a special-case branch.
+    const empty = wrapBatch([], 'ref7', 'chathistory', '#foo');
+    expect(empty).toHaveLength(0);
+    expect(empty.id).toBe('ref7');
+    expect(empty.type).toBe('chathistory');
+    expect(empty.start).toEqual({ text: '' });
+    expect(empty.body).toEqual([]);
+    expect(empty.end).toEqual({ text: '' });
+    // Non-enumerable props must not leak into JSON serialization.
+    expect(JSON.stringify(empty)).toBe('[]');
+  });
+
   it('preserves the order of the inner lines', () => {
     const lines = [L('one'), L('two'), L('three'), L('four')];
     const out = wrapBatch(lines, 'x', 'test');