serverless-ircd 0.3.0 → 0.5.0

package/packages/cf-adapter/src/cf-runtime.ts

@@ -35,13 +35,16 @@ import {
   type Nick,
   type RawLine,
   type RosterEntry,
+  type ServerConfig,
   toSnapshot,
 } from '@serverless-ircd/irc-core';
 import type { IrcRuntime } from '@serverless-ircd/irc-server';
+import type { CfConfigEnv } from './config-loader.js';
+import { loadServerConfigFromCfEnv } from './config-loader.js';
 import type { ChannelRegistryRpc, Env, RegistryRpc } from './env.js';
-import { DEFAULT_REGISTRY_SHARDS, registryKeyForNick, shardNick } from './sharding.js';
 import type { PersistedConnectionState } from './serialize.js';
 import { deserialize } from './serialize.js';
+import { DEFAULT_REGISTRY_SHARDS, registryKeyForNick, shardNick } from './sharding.js';
 
 /** Per-connection transport callbacks the ConnectionDO wires up. */
 export interface CfConnectionHandlers {
@@ -144,6 +147,48 @@ export class CfRuntime implements IrcRuntime {
     }
   }
 
+  /**
+   * Global cross-connection fan-out for `WALLOPS`. Enumerates every registry
+   * shard to collect all live connection ids, fetches each connection's
+   * state to honour the `+w` recipient gate, and delivers via the
+   * ConnectionDO `deliver` RPC. `except` (the originator) is skipped, as is
+   * the bound connection's own live state shortcut.
+   *
+   * Cost: this is N shard RPCs + one `getConnState` per online connection +
+   * one `deliver` per `+w` recipient. At very high connection counts the
+   * per-WALLOPS cost grows linearly with the fleet; deployments should bound
+   * the oper's WALLOPS rate (an oper flooding WALLOPS is a self-DoS). The
+   * shard walk is parallelised via `Promise.all` so wall-clock stays near one
+   * round-trip for the enumeration phase.
+   */
+  async broadcastWallops(lines: RawLine[], except?: ConnId): Promise<void> {
+    // Phase 1 — enumerate every connId across all registry shards.
+    const shardEntries = await Promise.all(
+      Array.from({ length: this.registryShards }, (_, i) => this.registryShardRpc(i).listEntries()),
+    );
+    const seen = new Set<ConnId>();
+    for (const entries of shardEntries) {
+      for (const [, connId] of entries) {
+        seen.add(connId);
+      }
+    }
+
+    // Phase 2 — fetch each candidate's state, filter +w, deliver.
+    // Bound the per-call fan-out by skipping the excepted/bound connection
+    // up front (the bound connection's own +w never needs a self-RPC).
+    await Promise.all(
+      Array.from(seen, async (connId) => {
+        if (connId === except || connId === this.connId) return;
+        const stub = this.env.CONNECTION_DO.get(this.env.CONNECTION_DO.idFromString(connId));
+        const dto = await (stub as unknown as ConnectionRpc).getConnState();
+        if (dto === null) return;
+        const state = deserialize(dto);
+        if (!state.userModes.wallops) return;
+        await (stub as unknown as ConnectionRpc).deliver(lines);
+      }),
+    );
+  }
+
   // -------------------------------------------------------------------------
   // Nick registry
   // -------------------------------------------------------------------------
@@ -247,9 +292,7 @@ export class CfRuntime implements IrcRuntime {
     const out = new Map<ConnId, ConnectionState>();
     await Promise.all(
       memberIds.map(async (id) => {
-        const connStub = this.env.CONNECTION_DO.get(
-          this.env.CONNECTION_DO.idFromString(id),
-        );
+        const connStub = this.env.CONNECTION_DO.get(this.env.CONNECTION_DO.idFromString(id));
         const dto = await (connStub as unknown as ConnectionRpc).getConnState();
         if (dto !== null) {
           out.set(id, deserialize(dto));
@@ -267,6 +310,16 @@ export class CfRuntime implements IrcRuntime {
     return snapshots.filter((s): s is ChanSnapshot => s !== null);
   }
 
+  /**
+   * Re-reads the bound Workers env (vars + secrets, the config source for
+   * Cloudflare deployments) and reparses it through the shared schema. The
+   * actor swaps its live config with the result; a rejection leaves the
+   * previous config in effect.
+   */
+  async reloadConfig(): Promise<ServerConfig> {
+    return loadServerConfigFromCfEnv(this.env as unknown as CfConfigEnv);
+  }
+
   // -------------------------------------------------------------------------
   // Internal
   // -------------------------------------------------------------------------
@@ -283,6 +336,16 @@ export class CfRuntime implements IrcRuntime {
     return stub as unknown as RegistryRpc;
   }
 
+  /**
+   * Returns the registry DO RPC stub for shard index `i` (`0 <= i < shards`).
+   * Used by global fan-out paths (WALLOPS) that must enumerate every shard
+   * rather than address the one owning a specific nick.
+   */
+  private registryShardRpc(i: number): RegistryRpc {
+    const stub = this.env.REGISTRY_DO.get(this.env.REGISTRY_DO.idFromName(`s${i}`));
+    return stub as unknown as RegistryRpc;
+  }
+
   /** Returns the channel DO RPC stub for `name` (keyed by lowercased name). */
   private channelRpc(name: ChanName): {
     broadcast(lines: unknown[], except?: string): Promise<void>;
@@ -321,7 +384,7 @@ export function makeCfRuntime(
   handlers: CfConnectionHandlers,
 ): IrcRuntime {
   // `_registryKey` is ignored — the production CfRuntime always shards the
-  // registry by nick (the prior per-conn key was a 033 scaffolding
+  // registry by nick (the prior per-conn key was a scaffolding
   // convention that the real RegistryDO does not use).
   void _registryKey;
   return new CfRuntime(env, connId, handlers);

package/packages/cf-adapter/src/channel-do.ts

@@ -30,7 +30,7 @@
  * RPC return-type note: snapshot reads return the JSON-friendly
  * {@link ChannelSnapshotDto} (members/banMasks/pendingInvites as
  * arrays) so they survive the DO RPC boundary without relying on
- * structured-clone of `Map`/`Set`. The CfRuntime (036)
+ * structured-clone of `Map`/`Set`. The CfRuntime
  * rehydrates these into a full {@link ChanSnapshot} at the call site.
  */
 
@@ -89,7 +89,7 @@ export interface ConnectionDeliveryRpc {
  * JSON-friendly snapshot DTO returned by `getChannelSnapshot`. Maps and
  * Sets are flattened to arrays so the value survives the DO RPC
  * boundary in both production and the test pool. The CfRuntime
- * (036) rehydrates this into a {@link ChanSnapshot} at the
+ * rehydrates this into a {@link ChanSnapshot} at the
  * call site.
  */
 export interface ChannelSnapshotDto {

package/packages/cf-adapter/src/config-loader.ts

@@ -22,6 +22,17 @@ import { type ParsedServerConfig, parseServerConfig } from '@serverless-ircd/irc
 export interface CfConfigEnv {
   SERVER_NAME?: string;
   NETWORK_NAME?: string;
+  /**
+   * Server version surfaced in `002`/`004`/`351`/`371`. When unset the
+   * schema default ({@link DEFAULT_SERVER_VERSION}) applies.
+   */
+  SERVER_VERSION?: string;
+  /**
+   * "Created" text for `003 RPL_CREATED`. A numeric string is parsed into
+   * an epoch-ms number so the reducer formats it as a UTC timestamp; any
+   * other value is passed through verbatim.
+   */
+  CREATED_AT?: string;
   MOTD_LINES?: string;
   MAX_CLIENTS?: string;
   CHANNEL_PREFIXES?: string;
@@ -56,6 +67,12 @@ function buildConfigInput(env: CfConfigEnv): Record<string, unknown> {
     serverName: env.SERVER_NAME,
     networkName: env.NETWORK_NAME,
   };
+  if (env.SERVER_VERSION !== undefined) {
+    input.serverVersion = env.SERVER_VERSION;
+  }
+  if (env.CREATED_AT !== undefined) {
+    input.createdAt = parseCreatedAt(env.CREATED_AT);
+  }
   if (env.MOTD_LINES !== undefined && env.MOTD_LINES.length > 0) {
     input.motdLines = env.MOTD_LINES.split('\n');
   }
@@ -102,6 +119,22 @@ function buildConfigInput(env: CfConfigEnv): Record<string, unknown> {
   return input;
 }
 
+/**
+ * Parses the `CREATED_AT` env var into the schema's `createdAt` field.
+ *
+ * A purely numeric string is treated as epoch-ms (returned as a number so
+ * the reducer formats it as a UTC timestamp); any other value is returned
+ * verbatim as a human-readable string. Empty strings fall through to the
+ * schema default (the caller only invokes this when the env var is set).
+ */
+function parseCreatedAt(raw: string): string | number {
+  if (/^\d+$/.test(raw.trim())) {
+    const n = Number(raw.trim());
+    if (Number.isFinite(n)) return n;
+  }
+  return raw;
+}
+
 /**
  * Parses a newline-delimited `username:password` string into the config's
  * `saslAccounts` shape. Malformed entries are skipped so a trailing