serverless-ircd 0.1.0

package/packages/cf-adapter/wrangler.test.toml

@@ -0,0 +1,50 @@
+#:schema node_modules/wrangler/config-schema.json
+name = "cf-adapter-test"
+main = "tests/worker/main.ts"
+compatibility_date = "2024-11-01"
+compatibility_flags = ["nodejs_compat"]
+
+# Server-level vars. MOTD_LINES is newline-delimited; content mirrors the
+# integration-test harness so scenario 18 (MOTD) asserts against the same
+# body text in every runtime factory.
+[vars]
+MOTD_LINES = "Welcome to the ServerlessIRCd integration-test harness.\nAll scenarios run parametrized over the IrcRuntime factory matrix."
+
+# Production bindings: REGISTRY_DO and CHANNEL_DO point at the real DO
+# classes so CfRuntime, ConnectionDO, and the integration suite all
+# exercise the actual sharded-registry + per-channel fanout path.
+[[durable_objects.bindings]]
+name = "CONNECTION_DO"
+class_name = "ConnectionDO"
+
+[[durable_objects.bindings]]
+name = "REGISTRY_DO"
+class_name = "RegistryDO"
+
+[[durable_objects.bindings]]
+name = "CHANNEL_DO"
+class_name = "ChannelDO"
+
+# Recording stubs (kept under separate names for any test that wants to
+# assert "this exact RPC was emitted" rather than the end-to-end effect).
+[[durable_objects.bindings]]
+name = "REGISTRY_DO_STUB"
+class_name = "RecordingRegistryDO"
+
+[[durable_objects.bindings]]
+name = "CHANNEL_DO_STUB"
+class_name = "RecordingChannelDO"
+
+# Real DO aliases — exercised by the per-DO unit suites (registry-do,
+# channel-do) which pre-date the binding switch.
+[[durable_objects.bindings]]
+name = "REGISTRY_DO_REAL"
+class_name = "RegistryDO"
+
+[[durable_objects.bindings]]
+name = "CHANNEL_DO_REAL"
+class_name = "ChannelDO"
+
+[[migrations]]
+tag = "v1"
+new_classes = ["ConnectionDO", "RegistryDO", "ChannelDO", "RecordingRegistryDO", "RecordingChannelDO"]

package/packages/in-memory-runtime/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@serverless-ircd/in-memory-runtime",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Single-process reference implementation of the IrcRuntime port, backed by Maps",
+  "license": "BSD-3-Clause",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.test.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
+    "clean": "rimraf dist coverage .tsbuildinfo .turbo"
+  },
+  "files": ["dist", "src", "README.md"],
+  "dependencies": {
+    "@serverless-ircd/irc-core": "workspace:*",
+    "@serverless-ircd/irc-server": "workspace:*"
+  }
+}

package/packages/in-memory-runtime/src/in-memory-runtime.ts

@@ -0,0 +1,245 @@
+/**
+ * Single-process reference {@link IrcRuntime}.
+ *
+ * Backed by plain `Map`s. Owns the authoritative channel and nick-registry
+ * state; shares live {@link ConnectionState} references with the actor layer
+ * (reducers mutate those in place). Used by integration tests, the local
+ * CLI, and as the contract spec for the CF and AWS runtimes.
+ *
+ * PLAN §2.2 — every method here corresponds one-to-one with an {@link Effect}
+ * tag interpreted by `dispatch`. Extra methods on this class
+ * ({@link registerConnection}, {@link getOrCreateChannel}, …) are lifecycle
+ * helpers for the actor and are NOT part of the port.
+ */
+
+import {
+  type ChanName,
+  type ChanSnapshot,
+  type ChannelDelta,
+  type ChannelState,
+  type Clock,
+  type ConnId,
+  type ConnSnapshot,
+  type ConnectionState,
+  type Nick,
+  type RawLine,
+  applyChannelDelta as applyDelta,
+  createChannel,
+  toChannelSnapshot,
+  toSnapshot as toConnSnapshot,
+} from '@serverless-ircd/irc-core';
+import type { IrcRuntime } from '@serverless-ircd/irc-server';
+
+/** Per-connection transport callbacks the actor wires up. */
+export interface ConnectionHandlers {
+  /** Called by `send` / `broadcast` / `sendToNick` to deliver outbound lines. */
+  send: (lines: RawLine[]) => void;
+  /** Called by `disconnect` to close the underlying transport. */
+  disconnect: (reason?: string) => void;
+}
+
+interface TrackedConnection {
+  state: ConnectionState;
+  handlers: ConnectionHandlers;
+}
+
+function lower(s: string): string {
+  return s.toLowerCase();
+}
+
+export class InMemoryRuntime implements IrcRuntime {
+  private readonly clock: Clock;
+  private readonly connections = new Map<ConnId, TrackedConnection>();
+  private readonly channels = new Map<string, ChannelState>();
+  private readonly nicks = new Map<string, ConnId>();
+
+  constructor(opts: { clock: Clock }) {
+    this.clock = opts.clock;
+  }
+
+  // ------------------------------------------------------------------
+  // Lifecycle (NOT part of the IrcRuntime port — actor/CLI only)
+  // ------------------------------------------------------------------
+
+  /**
+   * Tracks a connection and its transport handlers. The runtime keeps a
+   * reference to `state`; the actor may continue mutating it in place and
+   * the runtime will observe the changes via {@link getConnectionInfo}.
+   */
+  registerConnection(state: ConnectionState, handlers: ConnectionHandlers): void {
+    this.connections.set(state.id, { state, handlers });
+  }
+
+  /** Stops tracking a connection. Idempotent. Does NOT release its nick. */
+  unregisterConnection(conn: ConnId): void {
+    this.connections.delete(conn);
+  }
+
+  /** True iff {@link registerConnection} has been called and not undone. */
+  hasConnection(conn: ConnId): boolean {
+    return this.connections.has(conn);
+  }
+
+  // ------------------------------------------------------------------
+  // IrcRuntime — lookups
+  // ------------------------------------------------------------------
+
+  /**
+   * Returns the authoritative {@link ChannelState} for `name`, creating an
+   * empty channel on first access. Subsequent calls (case-insensitively)
+   * return the same object.
+   */
+  getOrCreateChannel(name: ChanName): ChannelState {
+    const key = lower(name);
+    const existing = this.channels.get(key);
+    if (existing !== undefined) return existing;
+    const created = createChannel({
+      name,
+      nameLower: key,
+      createdAt: this.clock.now(),
+    });
+    this.channels.set(key, created);
+    return created;
+  }
+
+  // ------------------------------------------------------------------
+  // IrcRuntime — transport
+  // ------------------------------------------------------------------
+
+  async send(to: ConnId, lines: RawLine[]): Promise<void> {
+    const conn = this.connections.get(to);
+    if (conn === undefined) return;
+    conn.handlers.send(lines);
+  }
+
+  async broadcast(chan: ChanName, lines: RawLine[], except?: ConnId): Promise<void> {
+    const channel = this.channels.get(lower(chan));
+    if (channel === undefined) return;
+    for (const member of channel.members.keys()) {
+      if (member === except) continue;
+      const conn = this.connections.get(member);
+      if (conn === undefined) continue;
+      conn.handlers.send(lines);
+    }
+  }
+
+  async disconnect(conn: ConnId, reason?: string): Promise<void> {
+    const c = this.connections.get(conn);
+    if (c === undefined) return;
+    c.handlers.disconnect(reason);
+  }
+
+  async sendToNick(
+    nick: Nick,
+    sender: ConnId,
+    lines: RawLine[],
+    notFoundLines?: RawLine[],
+  ): Promise<void> {
+    const owner = this.nicks.get(lower(nick));
+    if (owner !== undefined) {
+      const conn = this.connections.get(owner);
+      if (conn !== undefined) {
+        conn.handlers.send(lines);
+        return;
+      }
+    }
+    if (notFoundLines !== undefined) {
+      const senderConn = this.connections.get(sender);
+      if (senderConn !== undefined) {
+        senderConn.handlers.send(notFoundLines);
+      }
+    }
+  }
+
+  // ------------------------------------------------------------------
+  // IrcRuntime — nick registry
+  // ------------------------------------------------------------------
+
+  async reserveNick(nick: Nick, conn: ConnId): Promise<{ ok: true } | { ok: false }> {
+    const key = lower(nick);
+    const existing = this.nicks.get(key);
+    if (existing !== undefined && existing !== conn) {
+      return { ok: false };
+    }
+    this.nicks.set(key, conn);
+    return { ok: true };
+  }
+
+  async changeNick(conn: ConnId, oldNick: Nick, newNick: Nick): Promise<boolean> {
+    const newKey = lower(newNick);
+    const oldKey = lower(oldNick);
+    const owner = this.nicks.get(newKey);
+    if (owner !== undefined && owner !== conn) {
+      return false;
+    }
+    this.nicks.set(newKey, conn);
+    // Only clear the old mapping if it still points at us; a stale release
+    // would clobber a third party that grabbed it via re-reserve.
+    if (this.nicks.get(oldKey) === conn) {
+      this.nicks.delete(oldKey);
+    }
+    return true;
+  }
+
+  async releaseNick(nick: Nick): Promise<void> {
+    this.nicks.delete(lower(nick));
+  }
+
+  // ------------------------------------------------------------------
+  // IrcRuntime — channel ownership
+  // ------------------------------------------------------------------
+
+  async applyChannelDelta(chan: ChanName, delta: ChannelDelta): Promise<void> {
+    const channel = this.getOrCreateChannel(chan);
+    // The irc-core `applyChannelDelta` returns a *new* ChannelState; we
+    // replace the stored object so subsequent snapshots see the new data
+    // while any outstanding references to the prior state stay coherent.
+    const next = applyDelta(channel, delta);
+    this.channels.set(lower(chan), next);
+  }
+
+  // ------------------------------------------------------------------
+  // IrcRuntime — lookups
+  // ------------------------------------------------------------------
+
+  async lookupNick(nick: Nick): Promise<ConnId | null> {
+    return this.nicks.get(lower(nick)) ?? null;
+  }
+
+  async getConnectionInfo(conn: ConnId): Promise<ConnSnapshot | null> {
+    const tracked = this.connections.get(conn);
+    if (tracked === undefined) return null;
+    return toConnSnapshot(tracked.state);
+  }
+
+  /**
+   * Returns the live {@link ConnectionState} for `conn`, or `null` if the
+   * connection is unknown. Adapters that materialize state from storage
+   * return a fresh object; the in-memory runtime hands out its authority-
+   * owned reference (reducers and the actor mutate it in place).
+   */
+  async getConnection(conn: ConnId): Promise<ConnectionState | null> {
+    return this.connections.get(conn)?.state ?? null;
+  }
+
+  async getChannelSnapshot(chan: ChanName): Promise<ChanSnapshot | null> {
+    const channel = this.channels.get(lower(chan));
+    if (channel === undefined) return null;
+    return toChannelSnapshot(channel);
+  }
+
+  async getChannelConnections(chan: ChanName): Promise<ReadonlyMap<ConnId, ConnectionState>> {
+    const channel = this.channels.get(lower(chan));
+    const out = new Map<ConnId, ConnectionState>();
+    if (channel === undefined) return out;
+    for (const connId of channel.members.keys()) {
+      const tracked = this.connections.get(connId);
+      if (tracked !== undefined) out.set(connId, tracked.state);
+    }
+    return out;
+  }
+
+  async listChannels(): Promise<ChanSnapshot[]> {
+    return Array.from(this.channels.values(), (c) => toChannelSnapshot(c));
+  }
+}

package/packages/in-memory-runtime/src/index.ts

@@ -0,0 +1,9 @@
+/**
+ * @serverless-ircd/in-memory-runtime
+ *
+ * Single-process reference {@link IrcRuntime} backed by `Map`s. Used by
+ * integration tests, the local CLI, and as the contract spec for the CF
+ * and AWS runtimes.
+ */
+export { InMemoryRuntime } from './in-memory-runtime.js';
+export type { ConnectionHandlers } from './in-memory-runtime.js';