-
-
-
- ⚠️ External Content Warning
-
-
- Enabling external content display will load images and media
- from external servers. This may reveal your IP address to those
- servers.
-
-
- Only enable this if you understand the privacy implications and
- trust the content sources.
-
-
-
-
-
-
+
setShowExternalContentWarning(false)}
+ preventClose={true}
+ className="bg-discord-dark-300 rounded-lg shadow-xl max-w-md w-full mx-4"
+ >
+
+
+ ⚠️ External Content Warning
+
+
+ Enabling external content display will load images and media from
+ external servers. This may reveal your IP address to those servers.
+
+
+ Only enable this if you understand the privacy implications and
+ trust the content sources.
+
+
+
+
+
+
);
});
diff --git a/src/hooks/useReactions.ts b/src/hooks/useReactions.ts
index 293e3eef..52bdff35 100644
--- a/src/hooks/useReactions.ts
+++ b/src/hooks/useReactions.ts
@@ -120,7 +120,10 @@ export function useReactions({
if (messages) {
const msgIndex = messages.findIndex((m) => m.id === message.id);
if (msgIndex !== -1) {
- const updatedMessage = { ...messages[msgIndex] };
+ // Type assertion to avoid TypeScript's type instantiation depth limit with Immer
+ const updatedMessage = {
+ ...(messages[msgIndex] as unknown as Message),
+ };
if (existingReaction) {
// Remove the reaction
updatedMessage.reactions = updatedMessage.reactions.filter(
@@ -136,14 +139,17 @@ export function useReactions({
{ emoji, userId: currentUser?.username || "" },
];
}
+ // Type assertion to avoid TypeScript's type instantiation depth limit with Immer
+ const messagesArray = messages as unknown as Message[];
+ const newMessages = [
+ ...messagesArray.slice(0, msgIndex),
+ updatedMessage,
+ ...messagesArray.slice(msgIndex + 1),
+ ];
return {
messages: {
...state.messages,
- [key]: [
- ...messages.slice(0, msgIndex),
- updatedMessage,
- ...messages.slice(msgIndex + 1),
- ],
+ [key]: newMessages,
},
};
}
@@ -184,7 +190,10 @@ export function useReactions({
if (messages) {
const msgIndex = messages.findIndex((m) => m.id === message.id);
if (msgIndex !== -1) {
- const updatedMessage = { ...messages[msgIndex] };
+ // Type assertion to avoid TypeScript's type instantiation depth limit with Immer
+ const updatedMessage = {
+ ...(messages[msgIndex] as unknown as Message),
+ };
// Check if user already reacted
const existingReactionIndex = updatedMessage.reactions.findIndex(
(r) => r.emoji === emoji && r.userId === currentUser?.username,
@@ -194,14 +203,17 @@ export function useReactions({
...updatedMessage.reactions,
{ emoji, userId: currentUser?.username || "" },
];
+ // Type assertion to avoid TypeScript's type instantiation depth limit with Immer
+ const messagesArray = messages as unknown as Message[];
+ const newMessages = [
+ ...messagesArray.slice(0, msgIndex),
+ updatedMessage,
+ ...messagesArray.slice(msgIndex + 1),
+ ];
return {
messages: {
...state.messages,
- [key]: [
- ...messages.slice(0, msgIndex),
- updatedMessage,
- ...messages.slice(msgIndex + 1),
- ],
+ [key]: newMessages,
},
};
}
@@ -234,20 +246,26 @@ export function useReactions({
if (messages) {
const msgIndex = messages.findIndex((m) => m.id === message.id);
if (msgIndex !== -1) {
- const updatedMessage = { ...messages[msgIndex] };
+ // Type assertion to avoid TypeScript's type instantiation depth limit with Immer
+ const updatedMessage = {
+ ...(messages[msgIndex] as unknown as Message),
+ };
// Remove the reaction
updatedMessage.reactions = updatedMessage.reactions.filter(
(r) =>
!(r.emoji === emoji && r.userId === currentUser?.username),
);
+ // Type assertion to avoid TypeScript's type instantiation depth limit with Immer
+ const messagesArray = messages as unknown as Message[];
+ const newMessages = [
+ ...messagesArray.slice(0, msgIndex),
+ updatedMessage,
+ ...messagesArray.slice(msgIndex + 1),
+ ];
return {
messages: {
...state.messages,
- [key]: [
- ...messages.slice(0, msgIndex),
- updatedMessage,
- ...messages.slice(msgIndex + 1),
- ],
+ [key]: newMessages,
},
};
}
diff --git a/src/lib/irc/capabilities/capabilityNegotiator.ts b/src/lib/irc/capabilities/capabilityNegotiator.ts
new file mode 100644
index 00000000..6e34bfea
--- /dev/null
+++ b/src/lib/irc/capabilities/capabilityNegotiator.ts
@@ -0,0 +1,188 @@
+import type { StateManager } from "../core/state";
+import type { EventEmitter } from "../events/eventEmitter";
+
+export class CapabilityNegotiator {
+ private eventEmitter: EventEmitter;
+ private stateManager: StateManager;
+ private sendRaw: (serverId: string, data: string) => void;
+ private userOnConnect: (serverId: string) => void;
+
+ private readonly supportedCapabilities: string[] = [
+ "multi-prefix",
+ "message-tags",
+ "server-time",
+ "echo-message",
+ "userhost-in-names",
+ "draft/chathistory",
+ "draft/extended-isupport",
+ "sasl",
+ "cap-notify",
+ "draft/channel-rename",
+ "setname",
+ "account-notify",
+ "account-tag",
+ "extended-join",
+ "away-notify",
+ "batch",
+ "invite-notify",
+ "chghost",
+ "labeled-response",
+ "multiline",
+ "redact",
+ ];
+
+ private capLsAccumulated: Map
> = new Map();
+ private pendingCapReqs: Map = new Map();
+ private saslMechanisms: Map = new Map();
+
+ constructor(
+ eventEmitter: EventEmitter,
+ stateManager: StateManager,
+ sendRaw: (serverId: string, data: string) => void,
+ userOnConnect: (serverId: string) => void,
+ ) {
+ this.eventEmitter = eventEmitter;
+ this.stateManager = stateManager;
+ this.sendRaw = sendRaw;
+ this.userOnConnect = userOnConnect;
+ }
+
+ handleCapLs(serverId: string, cliCaps: string, isFinal: boolean): void {
+ let accumulated = this.capLsAccumulated.get(serverId);
+ if (!accumulated) {
+ accumulated = new Set();
+ this.capLsAccumulated.set(serverId, accumulated);
+ }
+
+ const caps = cliCaps.split(" ");
+ for (const c of caps) {
+ const [cap, value] = c.split("=", 2);
+ accumulated.add(cap);
+
+ if (cap === "sasl" && value) {
+ this.saslMechanisms.set(serverId, value.split(","));
+ }
+
+ if (cap === "unrealircd.org/link-security" && value) {
+ const linkSecurityValue = Number.parseInt(value, 10) || 0;
+ this.eventEmitter.triggerEvent("CAP LS", {
+ serverId,
+ cliCaps: `unrealircd.org/link-security=${linkSecurityValue}`,
+ });
+ }
+ }
+
+ if (isFinal) {
+ const capsToRequest: string[] = [];
+ const saslEnabled = this.stateManager.isSaslEnabled(serverId);
+
+ for (const cap of accumulated) {
+ if (
+ (this.supportedCapabilities.includes(cap) ||
+ cap.startsWith("draft/metadata")) &&
+ (cap !== "sasl" || saslEnabled)
+ ) {
+ capsToRequest.push(cap);
+ }
+ }
+
+ if (capsToRequest.length > 0) {
+ let currentBatch: string[] = [];
+ const baseLength = "CAP REQ :".length + 2;
+ let currentLength = baseLength;
+ let batchCount = 0;
+
+ for (const cap of capsToRequest) {
+ const capLength = cap.length + (currentBatch.length > 0 ? 1 : 0);
+
+ if (currentLength + capLength > 500 && currentBatch.length > 0) {
+ this.sendRaw(serverId, `CAP REQ :${currentBatch.join(" ")}`);
+ batchCount++;
+ currentBatch = [];
+ currentLength = baseLength;
+ }
+
+ currentBatch.push(cap);
+ currentLength += capLength;
+ }
+
+ if (currentBatch.length > 0) {
+ this.sendRaw(serverId, `CAP REQ :${currentBatch.join(" ")}`);
+ batchCount++;
+ }
+
+ this.pendingCapReqs.set(serverId, batchCount);
+
+ setTimeout(() => {
+ if (this.pendingCapReqs.has(serverId)) {
+ this.pendingCapReqs.delete(serverId);
+ this.sendRaw(serverId, "CAP END");
+ this.stateManager.setCapNegotiationComplete(serverId, true);
+ this.userOnConnect(serverId);
+ }
+ }, 5000);
+
+ if (capsToRequest.includes("draft/extended-isupport")) {
+ this.sendRaw(serverId, "ISUPPORT");
+ }
+ }
+
+ this.capLsAccumulated.delete(serverId);
+ }
+ }
+
+ handleCapAck(serverId: string, cliCaps: string): void {
+ this.eventEmitter.triggerEvent("CAP ACK", { serverId, cliCaps });
+
+ const pendingCount = this.pendingCapReqs.get(serverId) || 0;
+ if (pendingCount > 0) {
+ const newCount = pendingCount - 1;
+
+ if (newCount === 0) {
+ this.pendingCapReqs.delete(serverId);
+ } else {
+ this.pendingCapReqs.set(serverId, newCount);
+ }
+ }
+ }
+
+ handleCapNew(serverId: string, cliCaps: string): void {
+ const caps = cliCaps.split(" ");
+ for (const c of caps) {
+ const [cap, value] = c.split("=", 2);
+ if (cap === "sasl" && value) {
+ this.saslMechanisms.set(serverId, value.split(","));
+ }
+ }
+ }
+
+ handleCapDel(serverId: string, cliCaps: string): void {
+ const caps = cliCaps.split(" ");
+ for (const c of caps) {
+ const [cap] = c.split("=", 2);
+ if (cap === "sasl") {
+ this.saslMechanisms.delete(serverId);
+ }
+ }
+ }
+
+ handleCapNak(serverId: string): void {
+ this.sendRaw(serverId, "CAP END");
+ this.stateManager.setCapNegotiationComplete(serverId, true);
+ }
+
+ getSaslMechanisms(serverId: string): string[] | undefined {
+ return this.saslMechanisms.get(serverId);
+ }
+
+ isSupported(capability: string): boolean {
+ return (
+ this.supportedCapabilities.includes(capability) ||
+ capability.startsWith("draft/metadata")
+ );
+ }
+
+ getSupportedCapabilities(): string[] {
+ return [...this.supportedCapabilities];
+ }
+}
diff --git a/src/lib/irc/capabilities/metadata.ts b/src/lib/irc/capabilities/metadata.ts
new file mode 100644
index 00000000..68cf7e6c
--- /dev/null
+++ b/src/lib/irc/capabilities/metadata.ts
@@ -0,0 +1,181 @@
+import type { EventEmitter } from "../events/eventEmitter";
+
+export interface MetadataValue {
+ key: string;
+ value: string;
+ visibility: string;
+}
+
+export class MetadataManager {
+ // biome-ignore lint/correctness/noUnusedPrivateClassMembers: Used in constructor
+ private eventEmitter: EventEmitter;
+ private sendRaw: (serverId: string, data: string) => void;
+ private getNick: (serverId: string) => string | undefined;
+ private subscriptions: Map> = new Map();
+ private metadataCache: Map>> =
+ new Map();
+
+ constructor(
+ eventEmitter: EventEmitter,
+ sendRaw: (serverId: string, data: string) => void,
+ getNick: (serverId: string) => string | undefined,
+ ) {
+ this.eventEmitter = eventEmitter;
+ this.sendRaw = sendRaw;
+ this.getNick = getNick;
+ }
+
+ get(serverId: string, target: string, keys: string[]): void {
+ const keysStr = keys.join(" ");
+ this.sendRaw(serverId, `METADATA ${target} GET ${keysStr}`);
+ }
+
+ list(serverId: string, target: string): void {
+ this.sendRaw(serverId, `METADATA ${target} LIST`);
+ }
+
+ set(
+ serverId: string,
+ target: string,
+ key: string,
+ value?: string,
+ _visibility?: string,
+ ): void {
+ const currentNick = this.getNick(serverId);
+ const actualTarget =
+ target === "*" || target === currentNick ? "*" : target;
+
+ const command =
+ value !== undefined && value !== ""
+ ? `METADATA ${actualTarget} SET ${key} :${value}`
+ : `METADATA ${actualTarget} SET ${key}`;
+
+ this.sendRaw(serverId, command);
+ }
+
+ clear(serverId: string, target: string): void {
+ this.sendRaw(serverId, `METADATA ${target} CLEAR`);
+
+ const serverCache = this.metadataCache.get(serverId);
+ if (serverCache) {
+ serverCache.delete(target);
+ }
+ }
+
+ subscribe(serverId: string, keys: string[]): void {
+ for (const key of keys) {
+ this.sendRaw(serverId, `METADATA * SUB ${key}`);
+ }
+
+ let subs = this.subscriptions.get(serverId);
+ if (!subs) {
+ subs = new Set();
+ this.subscriptions.set(serverId, subs);
+ }
+ for (const key of keys) {
+ subs.add(key);
+ }
+ }
+
+ unsubscribe(serverId: string, keys: string[]): void {
+ const keysStr = keys.join(" ");
+ this.sendRaw(serverId, `METADATA * UNSUB ${keysStr}`);
+
+ const subs = this.subscriptions.get(serverId);
+ if (subs) {
+ for (const key of keys) {
+ subs.delete(key);
+ }
+ }
+ }
+
+ listSubscriptions(serverId: string): void {
+ this.sendRaw(serverId, "METADATA * SUBS");
+ }
+
+ sync(serverId: string, target: string): void {
+ this.sendRaw(serverId, `METADATA ${target} SYNC`);
+ }
+
+ handleMetadataValue(
+ serverId: string,
+ target: string,
+ key: string,
+ value: string,
+ visibility: string,
+ ): void {
+ let serverCache = this.metadataCache.get(serverId);
+ if (!serverCache) {
+ serverCache = new Map();
+ this.metadataCache.set(serverId, serverCache);
+ }
+
+ let targetCache = serverCache.get(target);
+ if (!targetCache) {
+ targetCache = new Map();
+ serverCache.set(target, targetCache);
+ }
+
+ targetCache.set(key, { key, value, visibility });
+ }
+
+ handleKeyNotSet(serverId: string, target: string, key: string): void {
+ const serverCache = this.metadataCache.get(serverId);
+ const targetCache = serverCache?.get(target);
+ if (targetCache) {
+ targetCache.delete(key);
+ }
+ }
+
+ handleSubOk(serverId: string, keys: string[]): void {
+ let subs = this.subscriptions.get(serverId);
+ if (!subs) {
+ subs = new Set();
+ this.subscriptions.set(serverId, subs);
+ }
+ for (const key of keys) {
+ subs.add(key);
+ }
+ }
+
+ handleUnsubOk(serverId: string, keys: string[]): void {
+ const subs = this.subscriptions.get(serverId);
+ if (subs) {
+ for (const key of keys) {
+ subs.delete(key);
+ }
+ }
+ }
+
+ getCachedValue(
+ serverId: string,
+ target: string,
+ key: string,
+ ): MetadataValue | undefined {
+ return this.metadataCache.get(serverId)?.get(target)?.get(key);
+ }
+
+ getCachedMetadata(
+ serverId: string,
+ target: string,
+ ): Map | undefined {
+ return this.metadataCache.get(serverId)?.get(target);
+ }
+
+ getSubscriptions(serverId: string): Set {
+ return this.subscriptions.get(serverId) || new Set();
+ }
+
+ isSubscribed(serverId: string, key: string): boolean {
+ return this.subscriptions.get(serverId)?.has(key) ?? false;
+ }
+
+ clearCache(serverId: string): void {
+ this.metadataCache.delete(serverId);
+ this.subscriptions.delete(serverId);
+ }
+
+ clearTargetCache(serverId: string, target: string): void {
+ this.metadataCache.get(serverId)?.delete(target);
+ }
+}
diff --git a/src/lib/irc/capabilities/sasl.ts b/src/lib/irc/capabilities/sasl.ts
new file mode 100644
index 00000000..f4e5eef1
--- /dev/null
+++ b/src/lib/irc/capabilities/sasl.ts
@@ -0,0 +1,152 @@
+import type { EventEmitter } from "../events/eventEmitter";
+
+export interface SaslCredentials {
+ username: string;
+ password: string;
+}
+
+export type SaslMechanism = "PLAIN" | "EXTERNAL" | "SCRAM-SHA-256";
+
+export class SaslAuthenticator {
+ // biome-ignore lint/correctness/noUnusedPrivateClassMembers: Used in constructor
+ private eventEmitter: EventEmitter;
+ private sendRaw: (serverId: string, data: string) => void;
+ private credentials: Map = new Map();
+ private availableMechanisms: Map = new Map();
+ private saslEnabled: Map = new Map();
+ private saslInProgress: Map = new Map();
+
+ constructor(
+ eventEmitter: EventEmitter,
+ sendRaw: (serverId: string, data: string) => void,
+ ) {
+ this.eventEmitter = eventEmitter;
+ this.sendRaw = sendRaw;
+ }
+
+ setCredentials(serverId: string, username: string, password: string): void {
+ this.credentials.set(serverId, { username, password });
+ this.saslEnabled.set(serverId, true);
+ }
+
+ getCredentials(serverId: string): SaslCredentials | undefined {
+ return this.credentials.get(serverId);
+ }
+
+ isEnabled(serverId: string): boolean {
+ return this.saslEnabled.get(serverId) ?? false;
+ }
+
+ setAvailableMechanisms(serverId: string, mechanisms: string[]): void {
+ this.availableMechanisms.set(serverId, mechanisms);
+ }
+
+ getAvailableMechanisms(serverId: string): string[] | undefined {
+ return this.availableMechanisms.get(serverId);
+ }
+
+ startAuthentication(
+ serverId: string,
+ mechanism: SaslMechanism = "PLAIN",
+ ): boolean {
+ const creds = this.credentials.get(serverId);
+ if (!creds) {
+ console.warn(`No SASL credentials for server ${serverId}`);
+ return false;
+ }
+
+ const available = this.availableMechanisms.get(serverId);
+ if (available && !available.includes(mechanism)) {
+ console.warn(
+ `SASL mechanism ${mechanism} not available on server ${serverId}`,
+ );
+ return false;
+ }
+
+ this.saslInProgress.set(serverId, true);
+ this.sendRaw(serverId, `AUTHENTICATE ${mechanism}`);
+ return true;
+ }
+
+ handleAuthenticateResponse(serverId: string, param: string): void {
+ if (!this.saslInProgress.get(serverId)) {
+ return;
+ }
+
+ const creds = this.credentials.get(serverId);
+ if (!creds) {
+ console.warn(`No SASL credentials for server ${serverId}`);
+ this.abortAuthentication(serverId);
+ return;
+ }
+
+ if (param === "+" || param === ":+") {
+ this.sendPlainAuth(serverId, creds);
+ }
+ }
+
+ private sendPlainAuth(serverId: string, creds: SaslCredentials): void {
+ const authString = `${creds.username}\0${creds.username}\0${creds.password}`;
+ const base64Auth = this.base64Encode(authString);
+ const chunks = this.splitIntoChunks(base64Auth, 400);
+
+ for (const chunk of chunks) {
+ this.sendRaw(serverId, `AUTHENTICATE ${chunk}`);
+ }
+
+ if (base64Auth.length % 400 === 0 && base64Auth.length > 0) {
+ this.sendRaw(serverId, "AUTHENTICATE +");
+ }
+ }
+
+ handleSuccess(serverId: string): void {
+ this.saslInProgress.set(serverId, false);
+ console.log(`SASL authentication successful for server ${serverId}`);
+ }
+
+ handleFailure(serverId: string, code: string, message: string): void {
+ this.saslInProgress.set(serverId, false);
+ console.warn(
+ `SASL authentication failed for server ${serverId}: ${code} ${message}`,
+ );
+ }
+
+ abortAuthentication(serverId: string): void {
+ this.saslInProgress.set(serverId, false);
+ this.sendRaw(serverId, "AUTHENTICATE *");
+ }
+
+ clearCredentials(serverId: string): void {
+ this.credentials.delete(serverId);
+ this.saslEnabled.set(serverId, false);
+ this.saslInProgress.set(serverId, false);
+ }
+
+ clearMechanisms(serverId: string): void {
+ this.availableMechanisms.delete(serverId);
+ }
+
+ isInProgress(serverId: string): boolean {
+ return this.saslInProgress.get(serverId) ?? false;
+ }
+
+ private base64Encode(str: string): string {
+ if (typeof btoa !== "undefined") {
+ return btoa(str);
+ }
+
+ if (typeof Buffer !== "undefined") {
+ return Buffer.from(str, "utf-8").toString("base64");
+ }
+
+ throw new Error("No base64 encoding method available");
+ }
+
+ private splitIntoChunks(str: string, chunkSize: number): string[] {
+ const chunks: string[] = [];
+ for (let i = 0; i < str.length; i += chunkSize) {
+ chunks.push(str.substring(i, i + chunkSize));
+ }
+ return chunks.length > 0 ? chunks : [""];
+ }
+}
diff --git a/src/lib/irc/core/connection.ts b/src/lib/irc/core/connection.ts
new file mode 100644
index 00000000..6af4f73f
--- /dev/null
+++ b/src/lib/irc/core/connection.ts
@@ -0,0 +1,145 @@
+import type { EventEmitter } from "../events/eventEmitter";
+
+/**
+ * Manages WebSocket connections for IRC servers
+ */
+export class ConnectionManager {
+ private sockets: Map = new Map();
+ private pendingConnections: Map> = new Map();
+
+ constructor(private eventEmitter: EventEmitter) {}
+
+ /**
+ * Create a WebSocket connection to a server
+ */
+ async connect(
+ host: string,
+ port: number,
+ serverId: string,
+ onOpen: (socket: WebSocket) => void,
+ onMessage: (data: string, serverId: string) => void,
+ onClose: () => void,
+ onError: () => void,
+ ): Promise {
+ const connectionKey = `${host}:${port}`;
+
+ // Check if there's already a pending connection
+ const existingConnection = this.pendingConnections.get(connectionKey);
+ if (existingConnection) {
+ throw new Error(`Connection to ${host}:${port} is already in progress`);
+ }
+
+ // Create connection promise
+ const connectionPromise = new Promise((resolve, reject) => {
+ // Determine protocol based on host
+ const protocol = ["localhost", "127.0.0.1"].includes(host) ? "ws" : "wss";
+ const url = `${protocol}://${host}:${port}`;
+
+ let socket: WebSocket;
+ try {
+ socket = new WebSocket(url);
+ } catch (error) {
+ reject(new Error(`Failed to connect to ${host}:${port}`));
+ return;
+ }
+
+ socket.onopen = () => {
+ this.sockets.set(serverId, socket);
+ this.eventEmitter.triggerEvent("connectionStateChange", {
+ serverId,
+ connectionState: "connected",
+ });
+ onOpen(socket);
+ resolve(socket);
+ };
+
+ socket.onclose = () => {
+ console.log(`WebSocket closed for server ${serverId}`);
+ this.sockets.delete(serverId);
+ this.eventEmitter.triggerEvent("connectionStateChange", {
+ serverId,
+ connectionState: "disconnected",
+ });
+ onClose();
+ };
+
+ socket.onerror = (error) => {
+ console.error(`WebSocket error for server ${serverId}:`, error);
+ this.sockets.delete(serverId);
+ this.eventEmitter.triggerEvent("connectionStateChange", {
+ serverId,
+ connectionState: "disconnected",
+ });
+ onError();
+ reject(new Error(`Failed to connect to ${host}:${port}`));
+ };
+
+ socket.onmessage = (event) => {
+ onMessage(event.data, serverId);
+ };
+ });
+
+ // Store and clean up pending connection
+ this.pendingConnections.set(connectionKey, connectionPromise);
+ connectionPromise.finally(() => {
+ this.pendingConnections.delete(connectionKey);
+ });
+
+ return connectionPromise;
+ }
+
+ /**
+ * Disconnect from a server
+ */
+ disconnect(serverId: string, quitMessage?: string): void {
+ const socket = this.sockets.get(serverId);
+ if (socket) {
+ if (quitMessage && socket.readyState === WebSocket.OPEN) {
+ socket.send(`QUIT :${quitMessage}`);
+ }
+ socket.close();
+ this.sockets.delete(serverId);
+ }
+ }
+
+ /**
+ * Get socket for a server
+ */
+ getSocket(serverId: string): WebSocket | undefined {
+ return this.sockets.get(serverId);
+ }
+
+ /**
+ * Check if connected to a server
+ */
+ isConnected(serverId: string): boolean {
+ const socket = this.sockets.get(serverId);
+ return socket?.readyState === WebSocket.OPEN;
+ }
+
+ /**
+ * Send raw IRC command to server
+ */
+ sendRaw(serverId: string, command: string): void {
+ const socket = this.sockets.get(serverId);
+ if (socket && socket.readyState === WebSocket.OPEN) {
+ console.log(
+ `IRC Client: Sending command to server ${serverId}: ${command}`,
+ );
+ socket.send(command);
+ } else {
+ console.error(`Socket for server ${serverId} is not open`);
+ }
+ }
+
+ /**
+ * Clean up all connections
+ */
+ disconnectAll(): void {
+ for (const serverId of this.sockets.keys()) {
+ this.disconnect(serverId);
+ }
+ this.sockets.clear();
+ this.pendingConnections.clear();
+ }
+}
diff --git a/src/lib/irc/core/ping.ts b/src/lib/irc/core/ping.ts
new file mode 100644
index 00000000..5d00c7da
--- /dev/null
+++ b/src/lib/irc/core/ping.ts
@@ -0,0 +1,86 @@
+/**
+ * Manages WebSocket keepalive through IRC PING/PONG
+ */
+export class PingManager {
+ private pingTimers: Map = new Map();
+ private pongTimeouts: Map = new Map();
+
+ /**
+ * Start sending periodic pings to a server
+ */
+ startPing(serverId: string, sendRaw: (msg: string) => void): void {
+ // Clear any existing ping timer
+ this.stopPing(serverId);
+
+ // Send ping every 30 seconds
+ const pingTimer = setInterval(() => {
+ try {
+ const timestamp = Date.now().toString();
+ sendRaw(`PING ${timestamp}`);
+
+ // Set a timeout for pong response (10 seconds)
+ const pongTimeout = setTimeout(() => {
+ console.warn(
+ `WebSocket ping timeout for server ${serverId}, closing connection`,
+ );
+ // Connection will be closed by the caller
+ }, 10000);
+
+ this.pongTimeouts.set(serverId, pongTimeout);
+ } catch (error) {
+ console.error(`Failed to send ping for server ${serverId}:`, error);
+ }
+ }, 30000); // 30 seconds
+
+ this.pingTimers.set(serverId, pingTimer);
+ }
+
+ /**
+ * Stop sending pings to a server
+ */
+ stopPing(serverId: string): void {
+ const pingTimer = this.pingTimers.get(serverId);
+ if (pingTimer) {
+ clearInterval(pingTimer);
+ this.pingTimers.delete(serverId);
+ }
+
+ const pongTimeout = this.pongTimeouts.get(serverId);
+ if (pongTimeout) {
+ clearTimeout(pongTimeout);
+ this.pongTimeouts.delete(serverId);
+ }
+ }
+
+ /**
+ * Handle pong response from server
+ */
+ handlePong(serverId: string): void {
+ const pongTimeout = this.pongTimeouts.get(serverId);
+ if (pongTimeout) {
+ clearTimeout(pongTimeout);
+ this.pongTimeouts.delete(serverId);
+ }
+ }
+
+ /**
+ * Check if ping is active for a server
+ */
+ isPinging(serverId: string): boolean {
+ return this.pingTimers.has(serverId);
+ }
+
+ /**
+ * Stop all ping timers
+ */
+ stopAll(): void {
+ for (const timer of this.pingTimers.values()) {
+ clearInterval(timer);
+ }
+ for (const timeout of this.pongTimeouts.values()) {
+ clearTimeout(timeout);
+ }
+ this.pingTimers.clear();
+ this.pongTimeouts.clear();
+ }
+}
diff --git a/src/lib/irc/core/reconnection.ts b/src/lib/irc/core/reconnection.ts
new file mode 100644
index 00000000..5a39b102
--- /dev/null
+++ b/src/lib/irc/core/reconnection.ts
@@ -0,0 +1,131 @@
+import type { EventEmitter } from "../events/eventEmitter";
+
+export type ReconnectCallback = () => Promise;
+
+/**
+ * Manages automatic reconnection logic with exponential backoff
+ */
+export class ReconnectionManager {
+ private reconnectionAttempts: Map = new Map();
+ private reconnectionTimeouts: Map = new Map();
+ private reconnectCallbacks: Map = new Map();
+
+ constructor(private eventEmitter: EventEmitter) {}
+
+ /**
+ * Start reconnection process for a server
+ */
+ startReconnection(serverId: string, onReconnect: ReconnectCallback): void {
+ console.log(`Starting reconnection for server ${serverId}`);
+
+ const existingTimeout = this.reconnectionTimeouts.get(serverId);
+ if (existingTimeout) {
+ clearTimeout(existingTimeout);
+ }
+
+ this.reconnectCallbacks.set(serverId, onReconnect);
+
+ const attempts = this.reconnectionAttempts.get(serverId) || 0;
+ this.reconnectionAttempts.set(serverId, attempts + 1);
+
+ let delay = 0;
+ if (attempts === 0) {
+ delay = 0; // Immediate retry
+ } else if (attempts === 1) {
+ delay = 15000; // 15 seconds
+ } else if (attempts === 2) {
+ delay = 30000; // 30 seconds
+ } else if (attempts <= 100) {
+ delay = 60000; // 60 seconds for attempts 3-100
+ } else {
+ this.eventEmitter.triggerEvent("connectionStateChange", {
+ serverId,
+ connectionState: "disconnected",
+ });
+ this.clearReconnection(serverId);
+ return;
+ }
+
+ this.eventEmitter.triggerEvent("connectionStateChange", {
+ serverId,
+ connectionState: "reconnecting",
+ });
+
+ const timeout = setTimeout(() => {
+ console.log(
+ `Reconnection timeout fired for server ${serverId}, attempting reconnection`,
+ );
+ this.attemptReconnection(serverId);
+ }, delay);
+
+ this.reconnectionTimeouts.set(serverId, timeout);
+ }
+
+ /**
+ * Attempt to reconnect to a server
+ */
+ private async attemptReconnection(serverId: string): Promise {
+ console.log(`Attempting reconnection for server ${serverId}`);
+
+ const callback = this.reconnectCallbacks.get(serverId);
+ if (!callback) {
+ console.error(`No reconnect callback found for server ${serverId}`);
+ return;
+ }
+
+ try {
+ this.eventEmitter.triggerEvent("connectionStateChange", {
+ serverId,
+ connectionState: "connecting",
+ });
+
+ await callback();
+
+ console.log(`Reconnection successful for server ${serverId}`);
+ this.clearReconnection(serverId);
+ } catch (error) {
+ console.log(`Reconnection failed for server ${serverId}:`, error);
+ this.startReconnection(serverId, callback);
+ }
+ }
+
+ /**
+ * Clear reconnection state for a server
+ */
+ clearReconnection(serverId: string): void {
+ this.reconnectionAttempts.delete(serverId);
+ this.reconnectCallbacks.delete(serverId);
+
+ const timeout = this.reconnectionTimeouts.get(serverId);
+ if (timeout) {
+ clearTimeout(timeout);
+ this.reconnectionTimeouts.delete(serverId);
+ }
+ }
+
+ /**
+ * Get current reconnection attempt count
+ */
+ getAttemptCount(serverId: string): number {
+ return this.reconnectionAttempts.get(serverId) || 0;
+ }
+
+ /**
+ * Check if reconnection is in progress
+ */
+ isReconnecting(serverId: string): boolean {
+ return this.reconnectionTimeouts.has(serverId);
+ }
+
+ /**
+ * Clean up all reconnection state
+ */
+ clearAll(): void {
+ for (const timeout of this.reconnectionTimeouts.values()) {
+ clearTimeout(timeout);
+ }
+ this.reconnectionTimeouts.clear();
+ this.reconnectionAttempts.clear();
+ this.reconnectCallbacks.clear();
+ }
+}
diff --git a/src/lib/irc/core/state.ts b/src/lib/irc/core/state.ts
new file mode 100644
index 00000000..bacdb24a
--- /dev/null
+++ b/src/lib/irc/core/state.ts
@@ -0,0 +1,227 @@
+import type { Server, User } from "../../../types";
+
+export interface BatchInfo {
+ type: string;
+ parameters?: string[];
+ messages: string[];
+ timestamps?: Date[];
+ concatFlags?: boolean[];
+ sender?: string;
+ messageIds?: string[];
+ batchMsgId?: string;
+ batchTime?: Date;
+}
+
+export class StateManager {
+ private servers: Map = new Map();
+ private nicks: Map = new Map();
+ private currentUsers: Map = new Map();
+ private activeBatches: Map> = new Map();
+ private saslMechanisms: Map = new Map();
+ private capLsAccumulated: Map> = new Map();
+ private saslEnabled: Map = new Map();
+ private saslCredentials: Map =
+ new Map();
+ private capNegotiationComplete: Map = new Map();
+ private pendingCapReqs: Map = new Map();
+
+ addServer(serverId: string, server: Server): void {
+ this.servers.set(serverId, server);
+ }
+
+ getServer(serverId: string): Server | undefined {
+ return this.servers.get(serverId);
+ }
+
+ removeServer(serverId: string): void {
+ this.servers.delete(serverId);
+ this.nicks.delete(serverId);
+ this.currentUsers.delete(serverId);
+ this.activeBatches.delete(serverId);
+ this.saslMechanisms.delete(serverId);
+ this.capLsAccumulated.delete(serverId);
+ this.saslEnabled.delete(serverId);
+ this.saslCredentials.delete(serverId);
+ this.capNegotiationComplete.delete(serverId);
+ this.pendingCapReqs.delete(serverId);
+ }
+
+ getAllServers(): Server[] {
+ return Array.from(this.servers.values());
+ }
+
+ getServers(): Server[] {
+ return this.getAllServers();
+ }
+
+ getAllUsers(serverId: string): User[] {
+ const server = this.getServer(serverId);
+ if (!server) return [];
+
+ const allUsers = new Map();
+
+ // Collect users from all joined channels
+ for (const channel of server.channels) {
+ for (const user of channel.users) {
+ allUsers.set(user.username, user);
+ }
+ }
+
+ return Array.from(allUsers.values());
+ }
+
+ setNick(serverId: string, nick: string): void {
+ this.nicks.set(serverId, nick);
+ }
+
+ getNick(serverId: string): string | undefined {
+ return this.nicks.get(serverId);
+ }
+
+ setCurrentUser(serverId: string, user: User | null): void {
+ this.currentUsers.set(serverId, user);
+ }
+
+ getCurrentUser(serverId: string): User | null {
+ return this.currentUsers.get(serverId) || null;
+ }
+
+ updateCurrentUser(serverId: string, updates: Partial): void {
+ const currentUser = this.currentUsers.get(serverId);
+ if (currentUser) {
+ this.currentUsers.set(serverId, { ...currentUser, ...updates });
+ }
+ }
+
+ startBatch(
+ serverId: string,
+ batchId: string,
+ type: string,
+ parameters?: string[],
+ batchMsgId?: string,
+ batchTime?: Date,
+ ): void {
+ if (!this.activeBatches.has(serverId)) {
+ this.activeBatches.set(serverId, new Map());
+ }
+ this.activeBatches.get(serverId)?.set(batchId, {
+ type,
+ parameters,
+ messages: [],
+ timestamps: [],
+ concatFlags: [],
+ messageIds: [],
+ batchMsgId,
+ batchTime,
+ });
+ }
+
+ getBatch(serverId: string, batchId: string): BatchInfo | undefined {
+ return this.activeBatches.get(serverId)?.get(batchId);
+ }
+
+ endBatch(serverId: string, batchId: string): BatchInfo | undefined {
+ const serverBatches = this.activeBatches.get(serverId);
+ const batch = serverBatches?.get(batchId);
+ serverBatches?.delete(batchId);
+ return batch;
+ }
+
+ addMessageToBatch(
+ serverId: string,
+ batchId: string,
+ message: string,
+ sender?: string,
+ msgid?: string,
+ timestamp?: Date,
+ hasConcat?: boolean,
+ ): void {
+ const batch = this.getBatch(serverId, batchId);
+ if (batch) {
+ batch.messages.push(message);
+ if (!batch.sender) {
+ batch.sender = sender;
+ }
+ if (msgid && batch.messageIds) {
+ batch.messageIds.push(msgid);
+ }
+ if (timestamp && batch.timestamps) {
+ batch.timestamps.push(timestamp);
+ }
+ if (batch.concatFlags) {
+ batch.concatFlags.push(!!hasConcat);
+ }
+ }
+ }
+
+ setSaslEnabled(serverId: string, enabled: boolean): void {
+ this.saslEnabled.set(serverId, enabled);
+ }
+
+ isSaslEnabled(serverId: string): boolean {
+ return this.saslEnabled.get(serverId) ?? false;
+ }
+
+ setSaslCredentials(
+ serverId: string,
+ username: string,
+ password: string,
+ ): void {
+ this.saslCredentials.set(serverId, { username, password });
+ }
+
+ getSaslCredentials(
+ serverId: string,
+ ): { username: string; password: string } | undefined {
+ return this.saslCredentials.get(serverId);
+ }
+
+ setSaslMechanisms(serverId: string, mechanisms: string[]): void {
+ this.saslMechanisms.set(serverId, mechanisms);
+ }
+
+ getSaslMechanisms(serverId: string): string[] | undefined {
+ return this.saslMechanisms.get(serverId);
+ }
+
+ deleteSaslMechanisms(serverId: string): void {
+ this.saslMechanisms.delete(serverId);
+ }
+
+ getCapLsAccumulated(serverId: string): Set {
+ let accumulated = this.capLsAccumulated.get(serverId);
+ if (!accumulated) {
+ accumulated = new Set();
+ this.capLsAccumulated.set(serverId, accumulated);
+ }
+ return accumulated;
+ }
+
+ deleteCapLsAccumulated(serverId: string): void {
+ this.capLsAccumulated.delete(serverId);
+ }
+
+ setCapNegotiationComplete(serverId: string, complete: boolean): void {
+ this.capNegotiationComplete.set(serverId, complete);
+ }
+
+ isCapNegotiationComplete(serverId: string): boolean {
+ return this.capNegotiationComplete.get(serverId) ?? false;
+ }
+
+ deleteCapNegotiationComplete(serverId: string): void {
+ this.capNegotiationComplete.delete(serverId);
+ }
+
+ setPendingCapReqs(serverId: string, count: number): void {
+ this.pendingCapReqs.set(serverId, count);
+ }
+
+ getPendingCapReqs(serverId: string): number {
+ return this.pendingCapReqs.get(serverId) || 0;
+ }
+
+ deletePendingCapReqs(serverId: string): void {
+ this.pendingCapReqs.delete(serverId);
+ }
+}
diff --git a/src/lib/irc/events/eventEmitter.ts b/src/lib/irc/events/eventEmitter.ts
new file mode 100644
index 00000000..14fb374e
--- /dev/null
+++ b/src/lib/irc/events/eventEmitter.ts
@@ -0,0 +1,70 @@
+import type { EventCallback, EventKey, EventMap } from "../types";
+
+/**
+ * Type-safe event emitter for IRC client events
+ */
+export class EventEmitter {
+ private eventCallbacks: {
+ [K in EventKey]?: EventCallback[];
+ } = {};
+
+ /**
+ * Subscribe to an event
+ */
+ on(event: K, callback: EventCallback): void {
+ if (!this.eventCallbacks[event]) {
+ this.eventCallbacks[event] = [];
+ }
+ this.eventCallbacks[event]?.push(callback);
+ }
+
+ /**
+ * Unsubscribe from an event
+ */
+ deleteHook(event: K, callback: EventCallback): void {
+ const cbs = this.eventCallbacks[event];
+ if (!cbs) return;
+ const index = cbs.indexOf(callback);
+ if (index !== -1) {
+ cbs.splice(index, 1);
+ }
+ }
+
+ /**
+ * Trigger an event with data
+ */
+ triggerEvent(event: K, data: EventMap[K]): void {
+ const cbs = this.eventCallbacks[event];
+ if (!cbs) return;
+ for (const cb of cbs) {
+ cb(data);
+ }
+ }
+
+ /**
+ * Check if there are any listeners for an event
+ */
+ hasListeners(event: K): boolean {
+ const cbs = this.eventCallbacks[event];
+ return !!cbs && cbs.length > 0;
+ }
+
+ /**
+ * Remove all listeners for a specific event or all events
+ */
+ removeAllListeners(event?: K): void {
+ if (event) {
+ delete this.eventCallbacks[event];
+ } else {
+ this.eventCallbacks = {};
+ }
+ }
+
+ /**
+ * Get the number of listeners for an event
+ */
+ listenerCount(event: K): number {
+ const cbs = this.eventCallbacks[event];
+ return cbs ? cbs.length : 0;
+ }
+}
diff --git a/src/lib/irc/handlers/baseHandler.ts b/src/lib/irc/handlers/baseHandler.ts
new file mode 100644
index 00000000..a78463e7
--- /dev/null
+++ b/src/lib/irc/handlers/baseHandler.ts
@@ -0,0 +1,41 @@
+import type { StateManager } from "../core/state";
+import type { EventEmitter } from "../events/eventEmitter";
+import type { CommandHandler } from "../protocol/commandRouter";
+import type { ParsedMessage } from "../protocol/messageParser";
+import type { EventKey, EventMap } from "../types";
+
+/**
+ * Base class for all IRC command handlers
+ */
+export abstract class BaseHandler implements CommandHandler {
+ constructor(
+ protected eventEmitter: EventEmitter,
+ protected stateManager: StateManager,
+ ) {}
+
+ /**
+ * Handle an IRC command - must be implemented by subclasses
+ */
+ abstract handle(message: ParsedMessage, serverId: string): void;
+
+ /**
+ * Emit an event
+ */
+ protected emit(event: K, data: EventMap[K]): void {
+ this.eventEmitter.triggerEvent(event, data);
+ }
+
+ /**
+ * Get server from state
+ */
+ protected getServer(serverId: string) {
+ return this.stateManager.getServer(serverId);
+ }
+
+ /**
+ * Get nick for a server
+ */
+ protected getNick(serverId: string) {
+ return this.stateManager.getNick(serverId);
+ }
+}
diff --git a/src/lib/irc/handlers/batchHandlers.ts b/src/lib/irc/handlers/batchHandlers.ts
new file mode 100644
index 00000000..ed3f4bca
--- /dev/null
+++ b/src/lib/irc/handlers/batchHandlers.ts
@@ -0,0 +1,88 @@
+import type { ParsedMessage } from "../protocol/messageParser";
+import { getTimestampFromTags } from "../utils/ircUtils";
+import { BaseHandler } from "./baseHandler";
+
+/**
+ * Handles BATCH command
+ */
+export class BatchHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const batchRef = msg.params[0];
+ const isStart = batchRef.startsWith("+");
+ const batchId = batchRef.substring(1); // Remove + or -
+
+ if (isStart) {
+ const batchType = msg.params[1];
+ const parameters = msg.params.slice(2);
+
+ this.stateManager.startBatch(
+ serverId,
+ batchId,
+ batchType,
+ parameters,
+ msg.tags?.msgid,
+ msg.tags?.time ? new Date(msg.tags.time) : undefined,
+ );
+
+ this.emit("BATCH_START", {
+ serverId,
+ batchId,
+ type: batchType,
+ parameters,
+ });
+ } else {
+ // Process completed batch
+ const batch = this.stateManager.endBatch(serverId, batchId);
+
+ if (
+ batch &&
+ (batch.type === "multiline" || batch.type === "draft/multiline")
+ ) {
+ // Handle completed multiline batch
+ const target =
+ batch.parameters && batch.parameters.length > 0
+ ? batch.parameters[0]
+ : "";
+ const sender = batch.sender || "unknown";
+
+ // Combine messages, handling draft/multiline-concat tags
+ let combinedMessage = "";
+ batch.messages.forEach((message, index) => {
+ const wasConcat = batch.concatFlags?.[index];
+
+ if (index === 0) {
+ combinedMessage = message;
+ } else {
+ if (wasConcat) {
+ // Concatenate directly without separator
+ combinedMessage += message;
+ } else {
+ // Join with newline (normal multiline)
+ combinedMessage += `\n${message}`;
+ }
+ }
+ });
+
+ this.emit("MULTILINE_MESSAGE", {
+ serverId,
+ mtags: batch.batchMsgId ? { msgid: batch.batchMsgId } : undefined,
+ sender,
+ channelName: target.startsWith("#") ? target : undefined,
+ message: combinedMessage,
+ lines: batch.messages,
+ messageIds: batch.messageIds || [],
+ timestamp:
+ batch.batchTime ||
+ (batch.timestamps && batch.timestamps.length > 0
+ ? new Date(Math.min(...batch.timestamps.map((t) => t.getTime())))
+ : getTimestampFromTags(msg.tags)),
+ });
+ }
+
+ this.emit("BATCH_END", {
+ serverId,
+ batchId,
+ });
+ }
+ }
+}
diff --git a/src/lib/irc/handlers/channelHandlers.ts b/src/lib/irc/handlers/channelHandlers.ts
new file mode 100644
index 00000000..ac325bc0
--- /dev/null
+++ b/src/lib/irc/handlers/channelHandlers.ts
@@ -0,0 +1,78 @@
+import type { ParsedMessage } from "../protocol/messageParser";
+import { getNickFromNuh } from "../utils/ircUtils";
+import { BaseHandler } from "./baseHandler";
+
+/**
+ * Handles MODE command
+ */
+export class ModeHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const sender = getNickFromNuh(msg.source);
+ const target = msg.params[0];
+ const modestring = msg.params[1] || "";
+ const modeargs = msg.params.slice(2);
+
+ this.emit("MODE", {
+ serverId,
+ mtags: msg.tags,
+ sender,
+ target,
+ modestring,
+ modeargs,
+ });
+ }
+}
+
+/**
+ * Handles TOPIC command
+ */
+export class TopicHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channelName = msg.params[0];
+ const topic = msg.params.slice(1).join(" ");
+ const sender = getNickFromNuh(msg.source);
+
+ this.emit("TOPIC", {
+ serverId,
+ channelName,
+ topic,
+ sender,
+ });
+ }
+}
+
+/**
+ * Handles RENAME command (draft/channel-rename)
+ */
+export class RenameHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const user = getNickFromNuh(msg.source);
+ const oldName = msg.params[0];
+ const newName = msg.params[1];
+ const reason = msg.params.slice(2).join(" ");
+
+ this.emit("RENAME", {
+ serverId,
+ oldName,
+ newName,
+ reason,
+ user,
+ });
+ }
+}
+
+/**
+ * Handles SETNAME command
+ */
+export class SetnameHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const user = getNickFromNuh(msg.source);
+ const realname = msg.params.join(" ");
+
+ this.emit("SETNAME", {
+ serverId,
+ user,
+ realname,
+ });
+ }
+}
diff --git a/src/lib/irc/handlers/messageHandlers.ts b/src/lib/irc/handlers/messageHandlers.ts
new file mode 100644
index 00000000..643616ac
--- /dev/null
+++ b/src/lib/irc/handlers/messageHandlers.ts
@@ -0,0 +1,130 @@
+import type { ParsedMessage } from "../protocol/messageParser";
+import { getNickFromNuh, getTimestampFromTags } from "../utils/ircUtils";
+import { BaseHandler } from "./baseHandler";
+
+/**
+ * Handles PRIVMSG command
+ */
+export class PrivmsgHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const target = msg.params[0];
+ const isChannel = target.startsWith("#");
+ const sender = getNickFromNuh(msg.source);
+ const message = msg.params.slice(1).join(" ");
+
+ // Check if this message is part of a multiline batch
+ const batchId = msg.tags?.batch;
+ if (batchId) {
+ const batch = this.stateManager.getBatch(serverId, batchId);
+ if (
+ batch &&
+ (batch.type === "multiline" || batch.type === "draft/multiline")
+ ) {
+ // Add this message line to the batch
+ this.stateManager.addMessageToBatch(
+ serverId,
+ batchId,
+ message,
+ sender,
+ msg.tags?.msgid,
+ getTimestampFromTags(msg.tags),
+ msg.tags && msg.tags["draft/multiline-concat"] !== undefined,
+ );
+ return; // Don't trigger individual message event
+ }
+ }
+
+ if (isChannel) {
+ this.emit("CHANMSG", {
+ serverId,
+ mtags: msg.tags,
+ sender,
+ channelName: target,
+ message,
+ timestamp: getTimestampFromTags(msg.tags),
+ });
+ } else {
+ this.emit("USERMSG", {
+ serverId,
+ mtags: msg.tags,
+ sender,
+ target,
+ message,
+ timestamp: getTimestampFromTags(msg.tags),
+ });
+ }
+ }
+}
+
+/**
+ * Handles NOTICE command
+ */
+export class NoticeHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const target = msg.params[0];
+ const isChannel = target.startsWith("#");
+ const sender = getNickFromNuh(msg.source);
+ const message = msg.params.slice(1).join(" ");
+
+ if (isChannel) {
+ this.emit("CHANNNOTICE", {
+ serverId,
+ mtags: msg.tags,
+ sender,
+ channelName: target,
+ message,
+ timestamp: getTimestampFromTags(msg.tags),
+ });
+ } else {
+ this.emit("USERNOTICE", {
+ serverId,
+ mtags: msg.tags,
+ sender,
+ message,
+ timestamp: getTimestampFromTags(msg.tags),
+ });
+ }
+ }
+}
+
+/**
+ * Handles TAGMSG command
+ */
+export class TagmsgHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const rawTarget = msg.params[0] || "";
+ const target = rawTarget.startsWith(":")
+ ? rawTarget.substring(1)
+ : rawTarget;
+ const sender = getNickFromNuh(msg.source);
+
+ this.emit("TAGMSG", {
+ serverId,
+ mtags: msg.tags,
+ sender,
+ channelName: target,
+ timestamp: getTimestampFromTags(msg.tags),
+ });
+ }
+}
+
+/**
+ * Handles REDACT command
+ */
+export class RedactHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const target = msg.params[0];
+ const msgid = msg.params[1];
+ const reason = msg.params[2] ? msg.params[2].substring(1) : "";
+ const sender = getNickFromNuh(msg.source);
+
+ this.emit("REDACT", {
+ serverId,
+ mtags: msg.tags,
+ target,
+ msgid,
+ reason,
+ sender,
+ });
+ }
+}
diff --git a/src/lib/irc/handlers/numericHandlers.ts b/src/lib/irc/handlers/numericHandlers.ts
new file mode 100644
index 00000000..48f01205
--- /dev/null
+++ b/src/lib/irc/handlers/numericHandlers.ts
@@ -0,0 +1,505 @@
+import type { ParsedMessage } from "../protocol/messageParser";
+import { parseIsupport, parseNamesResponse } from "../utils/ircUtils";
+import { BaseHandler } from "./baseHandler";
+
+export class WelcomeHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const serverName = msg.source;
+ const nickname = msg.params[0];
+
+ this.stateManager.setNick(serverId, nickname);
+ this.stateManager.updateCurrentUser(serverId, { username: nickname });
+
+ this.emit("ready", { serverId, serverName, nickname });
+
+ const server = this.getServer(serverId);
+ if (server && server.channels.length > 0) {
+ console.log(
+ `Rejoining ${server.channels.length} channels after reconnection`,
+ );
+ }
+ }
+}
+
+export class YourHostHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const message = msg.params.slice(1).join(" ");
+ const match = message.match(/Your host is ([^,]+), running version (.+)/);
+ if (match) {
+ this.emit("RPL_YOURHOST", {
+ serverId,
+ serverName: match[1],
+ version: match[2],
+ });
+ }
+ }
+}
+
+export class IsupportHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const capabilities = parseIsupport(msg.params.join(" "));
+ for (const [key, value] of Object.entries(capabilities)) {
+ if (key === "NETWORK") {
+ const server = this.getServer(serverId);
+ if (server) {
+ server.networkName = value;
+ }
+ }
+ this.emit("ISUPPORT", { serverId, key, value });
+ }
+ }
+}
+
+export class RplAwayHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const nick = msg.params[1];
+ const awayMessage = msg.params.slice(2).join(" ");
+ this.emit("RPL_AWAY", { serverId, nick, awayMessage });
+ }
+}
+
+export class RplUnawayHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const message = msg.params.slice(1).join(" ");
+ this.emit("RPL_UNAWAY", { serverId, message });
+ }
+}
+
+export class RplNowawayHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const message = msg.params.slice(1).join(" ");
+ this.emit("RPL_NOWAWAY", { serverId, message });
+ }
+}
+
+export class WhoisUserHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const nick = msg.params[1];
+ const username = msg.params[2];
+ const host = msg.params[3];
+ const realname = msg.params.slice(5).join(" ");
+ this.emit("WHOIS_USER", { serverId, nick, username, host, realname });
+ }
+}
+
+export class WhoisServerHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const nick = msg.params[1];
+ const server = msg.params[2];
+ const serverInfo = msg.params.slice(3).join(" ");
+ this.emit("WHOIS_SERVER", { serverId, nick, server, serverInfo });
+ }
+}
+
+export class EndOfWhoHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const mask = msg.params[1];
+ this.emit("WHO_END", { serverId, mask });
+ }
+}
+
+export class WhoisIdleHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const nick = msg.params[1];
+ const idle = Number.parseInt(msg.params[2], 10);
+ const signon = Number.parseInt(msg.params[3], 10);
+ this.emit("WHOIS_IDLE", { serverId, nick, idle, signon });
+ }
+}
+
+export class EndOfWhoisHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const nick = msg.params[1];
+ this.emit("WHOIS_END", { serverId, nick });
+ }
+}
+
+export class WhoisChannelsHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const nick = msg.params[1];
+ const channels = msg.params.slice(2).join(" ");
+ this.emit("WHOIS_CHANNELS", { serverId, nick, channels });
+ }
+}
+
+export class WhoisSpecialHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const nick = msg.params[1];
+ const message = msg.params.slice(2).join(" ");
+ this.emit("WHOIS_SPECIAL", { serverId, nick, message });
+ }
+}
+
+export class ListChannelHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channelName = msg.params[1];
+ const userCount = msg.params[2] ? Number.parseInt(msg.params[2], 10) : 0;
+ const topic = msg.params.slice(3).join(" ");
+ this.emit("LIST_CHANNEL", {
+ serverId,
+ channel: channelName,
+ userCount,
+ topic,
+ });
+ }
+}
+
+export class ListEndHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ this.emit("LIST_END", { serverId });
+ }
+}
+
+export class ChannelModeIsHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channelName = msg.params[1];
+ const modestring = msg.params[2] || "";
+ const modeargs = msg.params.slice(3);
+ this.emit("RPL_CHANNELMODEIS", {
+ serverId,
+ channelName,
+ modestring,
+ modeargs,
+ });
+ }
+}
+
+export class WhoisAccountHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const nick = msg.params[1];
+ const account = msg.params[2];
+ this.emit("WHOIS_ACCOUNT", { serverId, nick, account });
+ }
+}
+
+export class NoTopicHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channelName = msg.params[1];
+ this.emit("RPL_NOTOPIC", { serverId, channelName });
+ }
+}
+
+export class RplTopicHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channelName = msg.params[1];
+ const topic = msg.params.slice(2).join(" ");
+ this.emit("RPL_TOPIC", { serverId, channelName, topic });
+ }
+}
+
+export class TopicWhoTimeHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channelName = msg.params[1];
+ const setter = msg.params[2];
+ const timestamp = Number.parseInt(msg.params[3], 10);
+ this.emit("RPL_TOPICWHOTIME", { serverId, channelName, setter, timestamp });
+ }
+}
+
+export class WhoisBotHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const nick = msg.params[0];
+ const target = msg.params[1];
+ const message = msg.params.slice(2).join(" ");
+ this.emit("WHOIS_BOT", { serverId, nick, target, message });
+ }
+}
+
+export class InviteListHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channel = msg.params[1];
+ const mask = msg.params[2];
+ const setter = msg.params[3];
+ const timestamp = Number.parseInt(msg.params[4], 10);
+ this.emit("RPL_INVITELIST", { serverId, channel, mask, setter, timestamp });
+ }
+}
+
+export class EndOfInviteListHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channel = msg.params[1];
+ this.emit("RPL_ENDOFINVITELIST", { serverId, channel });
+ }
+}
+
+export class ExceptListHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channel = msg.params[1];
+ const mask = msg.params[2];
+ const setter = msg.params[3];
+ const timestamp = Number.parseInt(msg.params[4], 10);
+ this.emit("RPL_EXCEPTLIST", { serverId, channel, mask, setter, timestamp });
+ }
+}
+
+export class EndOfExceptListHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channel = msg.params[1];
+ this.emit("RPL_ENDOFEXCEPTLIST", { serverId, channel });
+ }
+}
+
+export class WhoReplyHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channel = msg.params[1];
+ const username = msg.params[2];
+ const host = msg.params[3];
+ const server = msg.params[4];
+ const nick = msg.params[5];
+ const flags = msg.params[6];
+ const trailing = msg.params[7] || "";
+ const spaceIndex = trailing.indexOf(" ");
+ let hopcount = trailing;
+ let realname = "";
+ if (spaceIndex !== -1) {
+ hopcount = trailing.substring(0, spaceIndex);
+ realname = trailing.substring(spaceIndex + 1);
+ }
+ this.emit("WHO_REPLY", {
+ serverId,
+ channel,
+ username,
+ host,
+ server,
+ nick,
+ flags,
+ hopcount,
+ realname,
+ });
+ }
+}
+
+export class NamesHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channelName = msg.params[2];
+ const namesStr = msg.params.slice(3).join(" ").trim();
+ const names = namesStr.startsWith(":") ? namesStr.substring(1) : namesStr;
+ const newUsers = parseNamesResponse(names);
+
+ this.emit("NAMES", { serverId, channelName, users: newUsers });
+ }
+}
+
+export class WhoxReplyHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channel = msg.params[1];
+ const username = msg.params[2];
+ const host = msg.params[3];
+ const nick = msg.params[4];
+ const flags = msg.params[5];
+ const account = msg.params[6];
+ const opLevelField = msg.params[7] || "";
+ const realname = msg.params[8] || "";
+ const isAway = flags.includes("G");
+ let opLevel = "";
+ if (flags.length > 1) {
+ const statusPart = flags.substring(1);
+ opLevel = statusPart
+ .split("")
+ .filter((char) => ["@", "+", "~", "%", "&"].includes(char))
+ .join("");
+ }
+ this.emit("WHOX_REPLY", {
+ serverId,
+ channel,
+ username,
+ host,
+ nick,
+ account,
+ flags,
+ realname,
+ isAway,
+ opLevel,
+ });
+ }
+}
+
+export class BanListHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channel = msg.params[1];
+ const mask = msg.params[2];
+ const setter = msg.params[3];
+ const timestamp = Number.parseInt(msg.params[4], 10);
+ this.emit("RPL_BANLIST", { serverId, channel, mask, setter, timestamp });
+ }
+}
+
+export class EndOfBanListHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const channel = msg.params[1];
+ this.emit("RPL_ENDOFBANLIST", { serverId, channel });
+ }
+}
+
+export class YoureOperHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const message = msg.params.slice(1).join(" ");
+ this.emit("RPL_YOUREOPER", { serverId, message });
+ }
+}
+
+export class NickErrorHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const code = msg.command;
+ const nick = msg.params[1];
+ const message = msg.params.slice(2).join(" ");
+ const errorMap: Record = {
+ "431": "No nickname given",
+ "432": "Invalid nickname",
+ "433": "Nickname already in use",
+ "436": "Nickname collision",
+ };
+ this.emit("NICK_ERROR", {
+ serverId,
+ code,
+ error: errorMap[code] || "Unknown error",
+ nick: code === "431" ? undefined : nick,
+ message,
+ });
+ }
+}
+
+export class WhoisSecureHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const nick = msg.params[1];
+ const message = msg.params.slice(2).join(" ");
+ this.emit("WHOIS_SECURE", { serverId, nick, message });
+ }
+}
+
+export class MonOnlineHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const targetList = msg.params.slice(1).join(" ");
+ const cleanTargetList = targetList.startsWith(":")
+ ? targetList.substring(1)
+ : targetList;
+ const targets = cleanTargetList.split(",").map((target) => {
+ const parts = target.split("!");
+ if (parts.length === 2) {
+ const [nick, userhost] = parts;
+ const [user, host] = userhost.split("@");
+ return { nick, user, host };
+ }
+ return { nick: target };
+ });
+ this.emit("MONONLINE", { serverId, targets });
+ }
+}
+
+export class MonOfflineHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const targetList = msg.params.slice(1).join(" ");
+ const cleanTargetList = targetList.startsWith(":")
+ ? targetList.substring(1)
+ : targetList;
+ const targets = cleanTargetList.split(",");
+ this.emit("MONOFFLINE", { serverId, targets });
+ }
+}
+
+export class MonListHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const targetList = msg.params.slice(1).join(" ");
+ const cleanTargetList = targetList.startsWith(":")
+ ? targetList.substring(1)
+ : targetList;
+ const targets = cleanTargetList.split(",");
+ this.emit("MONLIST", { serverId, targets });
+ }
+}
+
+export class EndOfMonListHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ this.emit("ENDOFMONLIST", { serverId });
+ }
+}
+
+export class MonListFullHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const limit = Number.parseInt(msg.params[1], 10);
+ const targetList = msg.params[2];
+ const targets = targetList.split(",");
+ this.emit("MONLISTFULL", { serverId, limit, targets });
+ }
+}
+
+export class WhoisKeyValueHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const target = msg.params[0];
+ const key = msg.params[1];
+ const visibility = msg.params[2];
+ const value = msg.params.slice(3).join(" ");
+ this.emit("METADATA_WHOIS", { serverId, target, key, visibility, value });
+ }
+}
+
+export class KeyValueHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const target = msg.params[1];
+ let key = msg.params[2];
+ let visibility = msg.params[3];
+ let valueStartIndex = 4;
+
+ if (msg.params[1] === msg.params[2] && msg.params.length > 5) {
+ key = msg.params[3];
+ visibility = msg.params[4];
+ valueStartIndex = 5;
+ }
+
+ const value = msg.params.slice(valueStartIndex).join(" ");
+ const cleanValue = value.startsWith(":") ? value.substring(1) : value;
+
+ this.emit("METADATA_KEYVALUE", {
+ serverId,
+ target,
+ key,
+ visibility,
+ value: cleanValue,
+ });
+ }
+}
+
+export class KeyNotSetHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const target = msg.params[0];
+ const key = msg.params[1];
+ this.emit("METADATA_KEYNOTSET", { serverId, target, key });
+ }
+}
+
+export class MetadataSubOkHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const keys = msg.params
+ .slice(1)
+ .map((key) => (key.startsWith(":") ? key.substring(1) : key));
+ this.emit("METADATA_SUBOK", { serverId, keys });
+ }
+}
+
+export class MetadataUnsubOkHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const keys = msg.params
+ .slice(1)
+ .map((key) => (key.startsWith(":") ? key.substring(1) : key));
+ this.emit("METADATA_UNSUBOK", { serverId, keys });
+ }
+}
+
+export class MetadataSubsHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const keys = msg.params
+ .slice(1)
+ .map((key) => (key.startsWith(":") ? key.substring(1) : key));
+ this.emit("METADATA_SUBS", { serverId, keys });
+ }
+}
+
+export class MetadataSyncLaterHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const target = msg.params[0];
+ const retryAfter = msg.params[1]
+ ? Number.parseInt(msg.params[1], 10)
+ : undefined;
+ this.emit("METADATA_SYNCLATER", { serverId, target, retryAfter });
+ }
+}
diff --git a/src/lib/irc/handlers/standardReplyHandlers.ts b/src/lib/irc/handlers/standardReplyHandlers.ts
new file mode 100644
index 00000000..a5ec1598
--- /dev/null
+++ b/src/lib/irc/handlers/standardReplyHandlers.ts
@@ -0,0 +1,86 @@
+import type { ParsedMessage } from "../protocol/messageParser";
+import { BaseHandler } from "./baseHandler";
+
+/**
+ * Handles FAIL command (IRCv3 standard replies)
+ */
+export class FailHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const cmd = msg.params[0];
+ const code = msg.params[1];
+ const target = msg.params[2] || undefined;
+ const message = msg.params.slice(3).join(" ");
+
+ this.emit("FAIL", {
+ serverId,
+ mtags: msg.tags,
+ command: cmd,
+ code,
+ target,
+ message,
+ });
+ }
+}
+
+/**
+ * Handles WARN command (IRCv3 standard replies)
+ */
+export class WarnHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const cmd = msg.params[0];
+ const code = msg.params[1];
+ const target = msg.params[2] || undefined;
+ const message = msg.params.slice(3).join(" ");
+
+ this.emit("WARN", {
+ serverId,
+ mtags: msg.tags,
+ command: cmd,
+ code,
+ target,
+ message,
+ });
+ }
+}
+
+/**
+ * Handles NOTE command (IRCv3 standard replies)
+ */
+export class NoteHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const cmd = msg.params[0];
+ const code = msg.params[1];
+ const target = msg.params[2] || undefined;
+ const message = msg.params.slice(3).join(" ");
+
+ this.emit("NOTE", {
+ serverId,
+ mtags: msg.tags,
+ command: cmd,
+ code,
+ target,
+ message,
+ });
+ }
+}
+
+/**
+ * Handles SUCCESS command (IRCv3 standard replies)
+ */
+export class SuccessHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const cmd = msg.params[0];
+ const code = msg.params[1];
+ const target = msg.params[2] || undefined;
+ const message = msg.params.slice(3).join(" ");
+
+ this.emit("SUCCESS", {
+ serverId,
+ mtags: msg.tags,
+ command: cmd,
+ code,
+ target,
+ message,
+ });
+ }
+}
diff --git a/src/lib/irc/handlers/userHandlers.ts b/src/lib/irc/handlers/userHandlers.ts
new file mode 100644
index 00000000..73d0d55f
--- /dev/null
+++ b/src/lib/irc/handlers/userHandlers.ts
@@ -0,0 +1,145 @@
+import type { ParsedMessage } from "../protocol/messageParser";
+import { getNickFromNuh } from "../utils/ircUtils";
+import { BaseHandler } from "./baseHandler";
+
+export class NickHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const oldNick = getNickFromNuh(msg.source);
+ let newNick = msg.params[0];
+
+ if (newNick.startsWith(":")) {
+ newNick = newNick.substring(1);
+ }
+
+ if (oldNick === this.getNick(serverId)) {
+ this.stateManager.setNick(serverId, newNick);
+ this.stateManager.updateCurrentUser(serverId, { username: newNick });
+ }
+
+ this.emit("NICK", {
+ serverId,
+ mtags: msg.tags,
+ oldNick,
+ newNick,
+ });
+ }
+}
+
+export class JoinHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const username = getNickFromNuh(msg.source);
+ const channelName =
+ msg.params[0][0] === ":" ? msg.params[0].substring(1) : msg.params[0];
+
+ let account: string | undefined;
+ let realname: string | undefined;
+
+ if (msg.params.length >= 2) {
+ account = msg.params[1] === "*" ? undefined : msg.params[1];
+ if (msg.params.length >= 3) {
+ realname = msg.params.slice(2).join(" ");
+ }
+ }
+
+ this.emit("JOIN", {
+ serverId,
+ username,
+ channelName,
+ batchTag: msg.tags?.batch,
+ account,
+ realname,
+ });
+ }
+}
+
+export class PartHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const username = getNickFromNuh(msg.source);
+ const channelName = msg.params[0];
+ const reason = msg.params.slice(1).join(" ").trim();
+
+ this.emit("PART", {
+ serverId,
+ username,
+ channelName,
+ reason: reason || undefined,
+ });
+ }
+}
+
+export class QuitHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const username = getNickFromNuh(msg.source);
+ const reason = msg.params.join(" ");
+
+ this.emit("QUIT", {
+ serverId,
+ username,
+ reason,
+ batchTag: msg.tags?.batch,
+ });
+ }
+}
+
+export class KickHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const username = getNickFromNuh(msg.source);
+ const channelName = msg.params[0];
+ const target = msg.params[1];
+ const reason = msg.params.slice(2).join(" ");
+
+ this.emit("KICK", {
+ serverId,
+ mtags: msg.tags,
+ username,
+ channelName,
+ target,
+ reason,
+ });
+ }
+}
+
+export class AwayHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const username = getNickFromNuh(msg.source);
+ const awayMessage =
+ msg.params.length > 0 ? msg.params.join(" ") : undefined;
+
+ this.emit("AWAY", {
+ serverId,
+ username,
+ awayMessage,
+ });
+ }
+}
+
+export class ChghostHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const username = getNickFromNuh(msg.source);
+ const newUser = msg.params[0];
+ const newHost = msg.params[1];
+
+ this.emit("CHGHOST", {
+ serverId,
+ username,
+ newUser,
+ newHost,
+ });
+ }
+}
+
+export class InviteHandler extends BaseHandler {
+ handle(msg: ParsedMessage, serverId: string): void {
+ const inviter = getNickFromNuh(msg.source);
+ const target = msg.params[0];
+ const channel = msg.params[1];
+
+ this.emit("INVITE", {
+ serverId,
+ mtags: msg.tags,
+ inviter,
+ target,
+ channel,
+ });
+ }
+}
diff --git a/src/lib/irc/index.ts b/src/lib/irc/index.ts
new file mode 100644
index 00000000..26e05805
--- /dev/null
+++ b/src/lib/irc/index.ts
@@ -0,0 +1,940 @@
+import type { Channel, Server, User } from "../../types";
+import { CapabilityNegotiator } from "./capabilities/capabilityNegotiator";
+import { MetadataManager } from "./capabilities/metadata";
+import { SaslAuthenticator } from "./capabilities/sasl";
+import { ConnectionManager } from "./core/connection";
+import { PingManager } from "./core/ping";
+import { ReconnectionManager } from "./core/reconnection";
+import { StateManager } from "./core/state";
+import { EventEmitter } from "./events/eventEmitter";
+import { BatchHandler } from "./handlers/batchHandlers";
+import {
+ ModeHandler,
+ RenameHandler,
+ SetnameHandler,
+ TopicHandler,
+} from "./handlers/channelHandlers";
+import {
+ NoticeHandler,
+ PrivmsgHandler,
+ RedactHandler,
+ TagmsgHandler,
+} from "./handlers/messageHandlers";
+import {
+ BanListHandler,
+ ChannelModeIsHandler,
+ EndOfBanListHandler,
+ EndOfExceptListHandler,
+ EndOfInviteListHandler,
+ EndOfMonListHandler,
+ EndOfWhoHandler,
+ EndOfWhoisHandler,
+ ExceptListHandler,
+ InviteListHandler,
+ IsupportHandler,
+ KeyNotSetHandler,
+ KeyValueHandler,
+ ListChannelHandler,
+ ListEndHandler,
+ MetadataSubOkHandler,
+ MetadataSubsHandler,
+ MetadataSyncLaterHandler,
+ MetadataUnsubOkHandler,
+ MonListHandler,
+ MonOfflineHandler,
+ MonOnlineHandler,
+ NamesHandler,
+ NickErrorHandler,
+ NoTopicHandler,
+ RplAwayHandler,
+ RplNowawayHandler,
+ RplTopicHandler,
+ RplUnawayHandler,
+ TopicWhoTimeHandler,
+ WelcomeHandler,
+ WhoisAccountHandler,
+ WhoisBotHandler,
+ WhoisChannelsHandler,
+ WhoisIdleHandler,
+ WhoisKeyValueHandler,
+ WhoisSecureHandler,
+ WhoisServerHandler,
+ WhoisSpecialHandler,
+ WhoisUserHandler,
+ WhoReplyHandler,
+ WhoxReplyHandler,
+ YoureOperHandler,
+ YourHostHandler,
+} from "./handlers/numericHandlers";
+import {
+ FailHandler,
+ NoteHandler,
+ SuccessHandler,
+ WarnHandler,
+} from "./handlers/standardReplyHandlers";
+// Import all handlers
+import {
+ AwayHandler,
+ ChghostHandler,
+ InviteHandler,
+ JoinHandler,
+ KickHandler,
+ NickHandler,
+ PartHandler,
+ QuitHandler,
+} from "./handlers/userHandlers";
+import { CommandRouter } from "./protocol/commandRouter";
+import { MessageBuilder } from "./protocol/messageBuilder";
+import { MessageParser, type ParsedMessage } from "./protocol/messageParser";
+import type { EventCallback, EventKey, EventMap } from "./types";
+
+declare const __APP_VERSION__: string;
+
+/**
+ * Main IRC Client facade that orchestrates all modules
+ */
+export class IRCClient {
+ // Core modules
+ private eventEmitter: EventEmitter;
+ private stateManager: StateManager;
+ private connectionManager: ConnectionManager;
+ private reconnectionManager: ReconnectionManager;
+ private pingManager: PingManager;
+
+ // Protocol modules
+ private messageParser: MessageParser;
+ private commandRouter: CommandRouter;
+ private messageBuilder: MessageBuilder;
+
+ // Capability modules
+ private capabilityNegotiator: CapabilityNegotiator;
+ private saslAuthenticator: SaslAuthenticator;
+ private metadataManager: MetadataManager;
+
+ public version = __APP_VERSION__;
+
+ constructor() {
+ this.eventEmitter = new EventEmitter();
+ this.stateManager = new StateManager();
+ this.messageBuilder = new MessageBuilder();
+ this.messageParser = new MessageParser();
+ this.commandRouter = new CommandRouter();
+ this.connectionManager = new ConnectionManager(this.eventEmitter);
+ this.reconnectionManager = new ReconnectionManager(this.eventEmitter);
+ this.pingManager = new PingManager();
+ this.capabilityNegotiator = new CapabilityNegotiator(
+ this.eventEmitter,
+ this.stateManager,
+ this.sendRaw.bind(this),
+ this.userOnConnect.bind(this),
+ );
+ this.saslAuthenticator = new SaslAuthenticator(
+ this.eventEmitter,
+ this.sendRaw.bind(this),
+ );
+ this.metadataManager = new MetadataManager(
+ this.eventEmitter,
+ this.sendRaw.bind(this),
+ (serverId: string) => this.stateManager.getNick(serverId),
+ );
+ this.registerHandlers();
+ }
+
+ /**
+ * Register all IRC command handlers with the CommandRouter
+ */
+ private registerHandlers(): void {
+ const CLASS_BASED_HANDLERS = [
+ { cmd: "NICK", Handler: NickHandler },
+ { cmd: "JOIN", Handler: JoinHandler },
+ { cmd: "PART", Handler: PartHandler },
+ { cmd: "QUIT", Handler: QuitHandler },
+ { cmd: "KICK", Handler: KickHandler },
+ { cmd: "AWAY", Handler: AwayHandler },
+ { cmd: "CHGHOST", Handler: ChghostHandler },
+ { cmd: "INVITE", Handler: InviteHandler },
+ { cmd: "PRIVMSG", Handler: PrivmsgHandler },
+ { cmd: "NOTICE", Handler: NoticeHandler },
+ { cmd: "TAGMSG", Handler: TagmsgHandler },
+ { cmd: "REDACT", Handler: RedactHandler },
+ { cmd: "MODE", Handler: ModeHandler },
+ { cmd: "TOPIC", Handler: TopicHandler },
+ { cmd: "RENAME", Handler: RenameHandler },
+ { cmd: "SETNAME", Handler: SetnameHandler },
+ { cmd: "BATCH", Handler: BatchHandler },
+ { cmd: "FAIL", Handler: FailHandler },
+ { cmd: "WARN", Handler: WarnHandler },
+ { cmd: "NOTE", Handler: NoteHandler },
+ { cmd: "SUCCESS", Handler: SuccessHandler },
+ { cmd: "001", Handler: WelcomeHandler },
+ { cmd: "002", Handler: YourHostHandler },
+ { cmd: "005", Handler: IsupportHandler },
+ { cmd: "381", Handler: YoureOperHandler },
+ { cmd: "301", Handler: RplAwayHandler },
+ { cmd: "305", Handler: RplUnawayHandler },
+ { cmd: "306", Handler: RplNowawayHandler },
+ { cmd: "311", Handler: WhoisUserHandler },
+ { cmd: "312", Handler: WhoisServerHandler },
+ { cmd: "317", Handler: WhoisIdleHandler },
+ { cmd: "318", Handler: EndOfWhoisHandler },
+ { cmd: "319", Handler: WhoisChannelsHandler },
+ { cmd: "320", Handler: WhoisSpecialHandler },
+ { cmd: "378", Handler: WhoisSpecialHandler },
+ { cmd: "379", Handler: WhoisSpecialHandler },
+ { cmd: "330", Handler: WhoisAccountHandler },
+ { cmd: "671", Handler: WhoisSecureHandler },
+ { cmd: "335", Handler: WhoisBotHandler },
+ { cmd: "353", Handler: NamesHandler },
+ { cmd: "331", Handler: NoTopicHandler },
+ { cmd: "332", Handler: RplTopicHandler },
+ { cmd: "333", Handler: TopicWhoTimeHandler },
+ { cmd: "324", Handler: ChannelModeIsHandler },
+ { cmd: "367", Handler: BanListHandler },
+ { cmd: "368", Handler: EndOfBanListHandler },
+ { cmd: "348", Handler: ExceptListHandler },
+ { cmd: "349", Handler: EndOfExceptListHandler },
+ { cmd: "346", Handler: InviteListHandler },
+ { cmd: "347", Handler: EndOfInviteListHandler },
+ { cmd: "352", Handler: WhoReplyHandler },
+ { cmd: "354", Handler: WhoxReplyHandler },
+ { cmd: "315", Handler: EndOfWhoHandler },
+ { cmd: "322", Handler: ListChannelHandler },
+ { cmd: "323", Handler: ListEndHandler },
+ { cmd: "431", Handler: NickErrorHandler },
+ { cmd: "432", Handler: NickErrorHandler },
+ { cmd: "433", Handler: NickErrorHandler },
+ { cmd: "436", Handler: NickErrorHandler },
+ { cmd: "730", Handler: MonOnlineHandler },
+ { cmd: "731", Handler: MonOfflineHandler },
+ { cmd: "732", Handler: MonListHandler },
+ { cmd: "733", Handler: EndOfMonListHandler },
+ { cmd: "760", Handler: WhoisKeyValueHandler },
+ { cmd: "761", Handler: KeyValueHandler },
+ { cmd: "766", Handler: KeyNotSetHandler },
+ { cmd: "770", Handler: MetadataSubOkHandler },
+ { cmd: "771", Handler: MetadataUnsubOkHandler },
+ { cmd: "772", Handler: MetadataSubsHandler },
+ { cmd: "774", Handler: MetadataSyncLaterHandler },
+ ] as const;
+
+ CLASS_BASED_HANDLERS.forEach(({ cmd, Handler }) => {
+ this.commandRouter.registerHandler(
+ cmd,
+ new Handler(this.eventEmitter, this.stateManager),
+ );
+ });
+
+ // SASL responses - inline handlers
+ this.commandRouter.registerHandler("900", {
+ handle: (msg, serverId) => {
+ // RPL_LOGGEDIN: You are now logged in as
+ const message = msg.params.slice(2).join(" ");
+ this.saslAuthenticator.handleSuccess(serverId);
+ },
+ });
+
+ this.commandRouter.registerHandler("901", {
+ handle: (msg, serverId) => {
+ // SASL authentication successful
+ this.saslAuthenticator.handleSuccess(serverId);
+ this.sendRaw(serverId, "CAP END");
+ this.stateManager.setCapNegotiationComplete(serverId, true);
+ this.userOnConnect(serverId);
+ },
+ });
+
+ this.commandRouter.registerHandler("902", {
+ handle: (msg, serverId) => {
+ // SASL authentication successful
+ this.saslAuthenticator.handleSuccess(serverId);
+ this.sendRaw(serverId, "CAP END");
+ this.stateManager.setCapNegotiationComplete(serverId, true);
+ this.userOnConnect(serverId);
+ },
+ });
+
+ this.commandRouter.registerHandler("903", {
+ handle: (msg, serverId) => {
+ // SASL authentication successful
+ this.saslAuthenticator.handleSuccess(serverId);
+ this.sendRaw(serverId, "CAP END");
+ this.stateManager.setCapNegotiationComplete(serverId, true);
+ this.userOnConnect(serverId);
+ },
+ });
+
+ this.commandRouter.registerHandler("904", {
+ handle: (msg, serverId) => {
+ // SASL authentication failed
+ const message = msg.params.slice(2).join(" ");
+ this.saslAuthenticator.handleFailure(serverId, "904", message);
+ this.sendRaw(serverId, "CAP END");
+ this.stateManager.setCapNegotiationComplete(serverId, true);
+ this.userOnConnect(serverId);
+ },
+ });
+
+ this.commandRouter.registerHandler("905", {
+ handle: (msg, serverId) => {
+ // SASL authentication failed
+ const message = msg.params.slice(2).join(" ");
+ this.saslAuthenticator.handleFailure(serverId, "905", message);
+ this.sendRaw(serverId, "CAP END");
+ this.stateManager.setCapNegotiationComplete(serverId, true);
+ this.userOnConnect(serverId);
+ },
+ });
+
+ this.commandRouter.registerHandler("906", {
+ handle: (msg, serverId) => {
+ // SASL authentication failed
+ const message = msg.params.slice(2).join(" ");
+ this.saslAuthenticator.handleFailure(serverId, "906", message);
+ this.sendRaw(serverId, "CAP END");
+ this.stateManager.setCapNegotiationComplete(serverId, true);
+ this.userOnConnect(serverId);
+ },
+ });
+
+ this.commandRouter.registerHandler("907", {
+ handle: (msg, serverId) => {
+ // SASL authentication failed
+ const message = msg.params.slice(2).join(" ");
+ this.saslAuthenticator.handleFailure(serverId, "907", message);
+ this.sendRaw(serverId, "CAP END");
+ this.stateManager.setCapNegotiationComplete(serverId, true);
+ this.userOnConnect(serverId);
+ },
+ });
+
+ this.commandRouter.registerHandler("CAP", {
+ handle: (msg, serverId) => this.handleCapCommand(msg, serverId),
+ });
+
+ this.commandRouter.registerHandler("PING", {
+ handle: (msg, serverId) => {
+ const key = msg.params.join(" ");
+ this.sendRaw(serverId, `PONG :${key}`);
+ },
+ });
+
+ this.commandRouter.registerHandler("PONG", {
+ handle: (_msg, serverId) => {
+ this.pingManager.handlePong(serverId);
+ },
+ });
+
+ this.commandRouter.registerHandler("ERROR", {
+ handle: (msg, serverId) => {
+ const errorMessage = msg.params.join(" ");
+ console.log(`IRC ERROR from server ${serverId}: ${errorMessage}`);
+ },
+ });
+
+ this.commandRouter.registerHandler("AUTHENTICATE", {
+ handle: (msg, serverId) => {
+ const param = msg.params.join(" ");
+ this.eventEmitter.triggerEvent("AUTHENTICATE", { serverId, param });
+ this.saslAuthenticator.handleAuthenticateResponse(serverId, param);
+ },
+ });
+
+ this.commandRouter.registerHandler("EXTJWT", {
+ handle: (msg, serverId) => {
+ const requestedTarget = msg.params[0];
+ const serviceName = msg.params[1];
+ let jwtToken: string;
+ if (msg.params[2] === "*") {
+ jwtToken = msg.params[3];
+ } else {
+ jwtToken = msg.params[2];
+ }
+ this.eventEmitter.triggerEvent("EXTJWT", {
+ serverId,
+ requestedTarget,
+ serviceName,
+ jwtToken,
+ });
+ },
+ });
+ }
+
+ /**
+ * Handle CAP command with special logic for negotiation
+ */
+ private handleCapCommand(msg: ParsedMessage, serverId: string): void {
+ let i = 0;
+ let caps = "";
+
+ if (msg.params[i] === "*") {
+ i++;
+ }
+
+ let subcommand = msg.params[i++];
+ if (
+ subcommand !== "LS" &&
+ subcommand !== "ACK" &&
+ subcommand !== "NEW" &&
+ subcommand !== "DEL" &&
+ subcommand !== "NAK"
+ ) {
+ // This is likely a nickname, skip it and get the real subcommand
+ subcommand = msg.params[i++];
+ }
+
+ const isFinal = subcommand === "LS" && msg.params[i] !== "*";
+ if (msg.params[i] === "*") i++;
+
+ // Build caps string from remaining params
+ while (msg.params[i]) {
+ caps += msg.params[i++];
+ if (msg.params[i]) caps += " ";
+ }
+
+ // Route to capability negotiator
+ if (subcommand === "LS") {
+ this.capabilityNegotiator.handleCapLs(serverId, caps, isFinal);
+ } else if (subcommand === "ACK") {
+ this.capabilityNegotiator.handleCapAck(serverId, caps);
+ } else if (subcommand === "NAK") {
+ this.capabilityNegotiator.handleCapNak(serverId);
+ } else if (subcommand === "NEW") {
+ this.capabilityNegotiator.handleCapNew(serverId, caps);
+ } else if (subcommand === "DEL") {
+ this.capabilityNegotiator.handleCapDel(serverId, caps);
+ }
+ }
+
+ /**
+ * Handle incoming IRC messages
+ */
+ private handleMessage(data: string, serverId: string): void {
+ const server = this.stateManager.getServer(serverId);
+ if (!server) {
+ console.error(`Server ${serverId} not found`);
+ return;
+ }
+
+ const serverName = server.name;
+ const messages = this.messageParser.parseMultiple(data, serverName);
+
+ for (const message of messages) {
+ console.log(
+ `IRC Client: Received command ${message.command} from server ${serverId}`,
+ );
+
+ // Route message to appropriate handler
+ const handled = this.commandRouter.route(message, serverId);
+ if (!handled) {
+ console.warn(`No handler registered for command: ${message.command}`);
+ }
+ }
+ }
+
+ /**
+ * Called after user registration (NICK/USER) to complete connection
+ */
+ userOnConnect(serverId: string): void {
+ const nick = this.stateManager.getNick(serverId);
+ if (!nick) {
+ console.warn(`No nick found for server ${serverId} in userOnConnect`);
+ return;
+ }
+
+ // NICK is already sent before CAP negotiation, only send USER now
+ this.sendRaw(serverId, `USER ${nick} 0 * :${nick}`);
+ }
+
+ // ==================== PUBLIC API ====================
+
+ /**
+ * Connect to an IRC server
+ */
+ async connect(
+ name: string,
+ host: string,
+ port: number,
+ nickname: string,
+ password?: string,
+ saslAccountName?: string,
+ saslPassword?: string,
+ serverId?: string,
+ ): Promise {
+ const actualServerId = serverId || `${host}:${port}`;
+
+ const existingServer = this.stateManager.getServer(actualServerId);
+ if (existingServer?.isConnected) {
+ return existingServer;
+ }
+
+ if (saslAccountName && saslPassword) {
+ this.saslAuthenticator.setCredentials(
+ actualServerId,
+ saslAccountName,
+ saslPassword,
+ );
+ this.stateManager.setSaslEnabled(actualServerId, true);
+ }
+
+ const server: Server = {
+ id: actualServerId,
+ name,
+ host,
+ port,
+ channels: [],
+ privateChats: [],
+ isConnected: false,
+ connectionState: "connecting",
+ users: [],
+ };
+
+ this.stateManager.addServer(actualServerId, server);
+ this.stateManager.setNick(actualServerId, nickname);
+
+ // Initialize current user for this server
+ this.stateManager.setCurrentUser(actualServerId, {
+ id: `${actualServerId}-${nickname}`,
+ username: nickname,
+ isOnline: true,
+ status: "online",
+ });
+
+ await this.connectionManager.connect(
+ host,
+ port,
+ actualServerId,
+ (socket: WebSocket) => {
+ server.isConnected = true;
+ server.connectionState = "connected";
+
+ this.sendRaw(actualServerId, "CAP LS 302");
+
+ this.sendRaw(actualServerId, `NICK ${nickname}`);
+ if (password) {
+ this.sendRaw(actualServerId, `PASS ${password}`);
+ }
+
+ this.pingManager.startPing(actualServerId, (msg: string) => {
+ this.sendRaw(actualServerId, msg);
+ });
+ },
+ (data: string, sid: string) => {
+ // On message
+ this.handleMessage(data, sid);
+ },
+ () => {
+ // On close
+ server.isConnected = false;
+ server.connectionState = "disconnected";
+ this.pingManager.stopPing(actualServerId);
+
+ // Start reconnection
+ this.reconnectionManager.startReconnection(actualServerId, async () => {
+ await this.connect(
+ name,
+ host,
+ port,
+ nickname,
+ password,
+ saslAccountName,
+ saslPassword,
+ actualServerId,
+ );
+ });
+ },
+ () => {
+ // On error
+ server.isConnected = false;
+ server.connectionState = "disconnected";
+ },
+ );
+
+ return server;
+ }
+
+ /**
+ * Disconnect from an IRC server
+ */
+ disconnect(serverId: string, quitMessage?: string): void {
+ this.connectionManager.disconnect(serverId, quitMessage);
+ this.reconnectionManager.clearReconnection(serverId);
+ this.pingManager.stopPing(serverId);
+ }
+
+ /**
+ * Send raw IRC command to server
+ */
+ sendRaw(serverId: string, command: string): void {
+ this.connectionManager.sendRaw(serverId, command);
+ }
+
+ /**
+ * Send a message to a channel or user
+ */
+ sendMessage(
+ serverId: string,
+ target: string,
+ message: string,
+ tags?: Record,
+ ): void {
+ const command = this.messageBuilder.buildPrivmsg(target, message, tags);
+ this.sendRaw(serverId, command);
+ }
+
+ /**
+ * Send a multiline message
+ */
+ sendMultilineMessage(
+ serverId: string,
+ target: string,
+ lines: string[],
+ batchId?: string,
+ ): void {
+ const commands = this.messageBuilder.buildMultiline(target, lines, batchId);
+ for (const cmd of commands) {
+ this.sendRaw(serverId, cmd);
+ }
+ }
+
+ /**
+ * Join a channel
+ */
+ joinChannel(serverId: string, channelName: string, key?: string): Channel {
+ const server = this.stateManager.getServer(serverId);
+ if (!server) {
+ throw new Error(`Server with ID ${serverId} not found`);
+ }
+
+ const existing = server.channels.find((c) => c.name === channelName);
+ if (existing) return existing;
+
+ const command = key ? `JOIN ${channelName} ${key}` : `JOIN ${channelName}`;
+ this.sendRaw(serverId, command);
+
+ if (server.capabilities?.includes("draft/chathistory")) {
+ this.sendRaw(serverId, `CHATHISTORY LATEST ${channelName} * 50`);
+ }
+
+ const channel: Channel = {
+ id: crypto.randomUUID(),
+ name: channelName,
+ topic: "",
+ isPrivate: false,
+ serverId,
+ unreadCount: 0,
+ isMentioned: false,
+ messages: [],
+ users: [],
+ isLoadingHistory: !!server.capabilities?.includes("draft/chathistory"),
+ needsWhoRequest: true,
+ chathistoryRequested:
+ !!server.capabilities?.includes("draft/chathistory"),
+ };
+
+ server.channels.push(channel);
+
+ // Trigger event to notify store that history loading started
+ if (server.capabilities?.includes("draft/chathistory")) {
+ this.triggerEvent("CHATHISTORY_LOADING", {
+ serverId,
+ channelName,
+ isLoading: true,
+ });
+ }
+
+ return channel;
+ }
+
+ /**
+ * Part a channel
+ */
+ partChannel(serverId: string, channelName: string, reason?: string): void {
+ const command = reason
+ ? `PART ${channelName} :${reason}`
+ : `PART ${channelName}`;
+ this.sendRaw(serverId, command);
+ }
+
+ /**
+ * Send a WHOIS query
+ */
+ whois(serverId: string, target: string): void {
+ this.sendRaw(serverId, `WHOIS ${target}`);
+ }
+
+ /**
+ * Send a WHO query
+ */
+ who(serverId: string, target: string): void {
+ this.sendRaw(serverId, `WHO ${target}`);
+ }
+
+ /**
+ * Set channel topic
+ */
+ setTopic(serverId: string, channelName: string, topic: string): void {
+ this.sendRaw(serverId, `TOPIC ${channelName} :${topic}`);
+ }
+
+ /**
+ * Request list of channels from server
+ */
+ listChannels(
+ serverId: string,
+ elist?: string,
+ filters?: {
+ minUsers?: number;
+ maxUsers?: number;
+ minCreationTime?: number;
+ maxCreationTime?: number;
+ minTopicTime?: number;
+ maxTopicTime?: number;
+ mask?: string;
+ notMask?: string;
+ },
+ ): void {
+ let command = "LIST";
+
+ if (elist && filters) {
+ // Build LIST parameters based on filters and available ELIST capabilities
+ const elistTokens = elist.toUpperCase().split("");
+ const params: string[] = [];
+
+ // User count filtering (U extension)
+ if (elistTokens.includes("U")) {
+ if (filters.minUsers && filters.minUsers > 0) {
+ params.push(`>${filters.minUsers}`);
+ }
+ if (filters.maxUsers && filters.maxUsers > 0) {
+ params.push(`<${filters.maxUsers}`);
+ }
+ }
+
+ // Creation time filtering (C extension)
+ if (elistTokens.includes("C")) {
+ if (filters.minCreationTime && filters.minCreationTime > 0) {
+ params.push(`C>${filters.minCreationTime}`);
+ }
+ if (filters.maxCreationTime && filters.maxCreationTime > 0) {
+ params.push(`C<${filters.maxCreationTime}`);
+ }
+ }
+
+ // Topic time filtering (T extension)
+ if (elistTokens.includes("T")) {
+ if (filters.minTopicTime && filters.minTopicTime > 0) {
+ params.push(`T>${filters.minTopicTime}`);
+ }
+ if (filters.maxTopicTime && filters.maxTopicTime > 0) {
+ params.push(`T<${filters.maxTopicTime}`);
+ }
+ }
+
+ // Mask filtering (M extension)
+ if (elistTokens.includes("M") && filters.mask) {
+ params.push(filters.mask);
+ }
+
+ // Non-matching mask filtering (N extension)
+ if (elistTokens.includes("N") && filters.notMask) {
+ params.push(`!${filters.notMask}`);
+ }
+
+ if (params.length > 0) {
+ command = `LIST ${params.join(" ")}`;
+ }
+ }
+
+ this.sendRaw(serverId, command);
+ }
+
+ /**
+ * Rename a channel
+ */
+ renameChannel(
+ serverId: string,
+ oldName: string,
+ newName: string,
+ reason?: string,
+ ): void {
+ const command = reason
+ ? `RENAME ${oldName} ${newName} :${reason}`
+ : `RENAME ${oldName} ${newName}`;
+ this.sendRaw(serverId, command);
+ }
+
+ /**
+ * Set realname
+ */
+ setName(serverId: string, realname: string): void {
+ this.sendRaw(serverId, `SETNAME :${realname}`);
+ }
+
+ /**
+ * Change nickname
+ */
+ changeNick(serverId: string, newNick: string): void {
+ this.sendRaw(serverId, `NICK ${newNick}`);
+ }
+
+ // ==================== METADATA COMMANDS ====================
+
+ metadataGet(serverId: string, target: string, keys: string[]): void {
+ this.metadataManager.get(serverId, target, keys);
+ }
+
+ metadataList(serverId: string, target: string): void {
+ this.metadataManager.list(serverId, target);
+ }
+
+ metadataSet(
+ serverId: string,
+ target: string,
+ key: string,
+ value?: string,
+ visibility?: string,
+ ): void {
+ this.metadataManager.set(serverId, target, key, value, visibility);
+ }
+
+ metadataClear(serverId: string, target: string): void {
+ this.metadataManager.clear(serverId, target);
+ }
+
+ metadataSub(serverId: string, keys: string[]): void {
+ this.metadataManager.subscribe(serverId, keys);
+ }
+
+ metadataUnsub(serverId: string, keys: string[]): void {
+ this.metadataManager.unsubscribe(serverId, keys);
+ }
+
+ metadataSubs(serverId: string): void {
+ this.metadataManager.listSubscriptions(serverId);
+ }
+
+ metadataSync(serverId: string, target: string): void {
+ this.metadataManager.sync(serverId, target);
+ }
+
+ // ==================== EXTJWT COMMANDS ====================
+
+ requestExtJwt(serverId: string, target?: string, serviceName?: string): void {
+ const targetParam = target || "*";
+ const command = serviceName
+ ? `EXTJWT ${targetParam} ${serviceName}`
+ : `EXTJWT ${targetParam}`;
+ this.sendRaw(serverId, command);
+ }
+
+ // ==================== MONITOR COMMANDS ====================
+
+ monitorAdd(serverId: string, targets: string[]): void {
+ const targetsStr = targets.join(",");
+ this.sendRaw(serverId, `MONITOR + ${targetsStr}`);
+ }
+
+ monitorRemove(serverId: string, targets: string[]): void {
+ const targetsStr = targets.join(",");
+ this.sendRaw(serverId, `MONITOR - ${targetsStr}`);
+ }
+
+ monitorList(serverId: string): void {
+ this.sendRaw(serverId, "MONITOR L");
+ }
+
+ monitorClear(serverId: string): void {
+ this.sendRaw(serverId, "MONITOR C");
+ }
+
+ monitorStatus(serverId: string): void {
+ this.sendRaw(serverId, "MONITOR S");
+ }
+
+ // ==================== EVENT HANDLERS ====================
+
+ on(event: K, callback: EventCallback): void {
+ this.eventEmitter.on(event, callback);
+ }
+
+ deleteHook(event: K, callback: EventCallback): void {
+ this.eventEmitter.deleteHook(event, callback);
+ }
+
+ // ==================== GETTERS ====================
+
+ getServers(): Server[] {
+ return this.stateManager.getServers();
+ }
+
+ getCurrentUser(serverId?: string): User | null {
+ if (!serverId) return null;
+ return this.stateManager.getCurrentUser(serverId);
+ }
+
+ getAllUsers(serverId: string): User[] {
+ return this.stateManager.getAllUsers(serverId);
+ }
+
+ getNick(serverId: string): string | undefined {
+ return this.stateManager.getNick(serverId);
+ }
+
+ // ==================== ADDITIONAL PUBLIC METHODS ====================
+
+ sendTyping(serverId: string, target: string, isActive: boolean): void {
+ const typingState = isActive ? "active" : "done";
+ this.sendRaw(serverId, `@+typing=${typingState} TAGMSG ${target}`);
+ }
+
+ leaveChannel(serverId: string, channelName: string): void {
+ const server = this.stateManager.getServer(serverId);
+ if (server) {
+ this.sendRaw(serverId, `PART ${channelName}`);
+ server.channels = server.channels.filter((c) => c.name !== channelName);
+ }
+ }
+
+ triggerEvent(event: K, data: EventMap[K]): void {
+ this.eventEmitter.triggerEvent(event, data);
+ }
+
+ sendRedact(
+ serverId: string,
+ target: string,
+ msgid: string,
+ reason?: string,
+ ): void {
+ const command = reason
+ ? `REDACT ${target} ${msgid} :${reason}`
+ : `REDACT ${target} ${msgid}`;
+ this.sendRaw(serverId, command);
+ }
+
+ registerAccount(
+ serverId: string,
+ account: string,
+ email: string,
+ password: string,
+ ): void {
+ this.sendRaw(serverId, `REGISTER ${account} ${email} ${password}`);
+ }
+
+ verifyAccount(serverId: string, account: string, code: string): void {
+ this.sendRaw(serverId, `VERIFY ${account} ${code}`);
+ }
+
+ markChannelAsRead(serverId: string, channelId: string): void {
+ const server = this.stateManager.getServer(serverId);
+ const channel = server?.channels.find((c) => c.id === channelId);
+ if (channel) channel.unreadCount = 0;
+ }
+
+ capAck(serverId: string, key: string, capabilities: string): void {
+ this.triggerEvent("CAP_ACKNOWLEDGED", { serverId, key, capabilities });
+ }
+
+ isCapNegotiationComplete(serverId: string): boolean {
+ return this.stateManager.isCapNegotiationComplete(serverId);
+ }
+}
diff --git a/src/lib/irc/protocol/commandRouter.ts b/src/lib/irc/protocol/commandRouter.ts
new file mode 100644
index 00000000..4808dc93
--- /dev/null
+++ b/src/lib/irc/protocol/commandRouter.ts
@@ -0,0 +1,107 @@
+import type { ParsedMessage } from "./messageParser";
+
+export interface CommandHandler {
+ handle(message: ParsedMessage, serverId: string): void;
+}
+
+/**
+ * Routes IRC commands to appropriate handlers
+ */
+export class CommandRouter {
+ private handlers: Map = new Map();
+ private numericHandlers: Map = new Map();
+
+ /**
+ * Register a handler for a command
+ * @param command Command name (e.g., "PRIVMSG") or numeric code (e.g., 353)
+ * @param handler Handler instance
+ */
+ registerHandler(command: string | number, handler: CommandHandler): void {
+ if (typeof command === "number") {
+ this.numericHandlers.set(command, handler);
+ } else {
+ this.handlers.set(command.toUpperCase(), handler);
+ }
+ }
+
+ /**
+ * Register multiple handlers at once
+ */
+ registerHandlers(
+ handlers: Array<{ command: string | number; handler: CommandHandler }>,
+ ): void {
+ for (const { command, handler } of handlers) {
+ this.registerHandler(command, handler);
+ }
+ }
+
+ /**
+ * Route a message to its handler
+ * @param message Parsed IRC message
+ * @param serverId Server ID
+ * @returns true if handler was found and executed, false otherwise
+ */
+ route(message: ParsedMessage, serverId: string): boolean {
+ const { command } = message;
+
+ // Try numeric handler first
+ const numericCommand = Number.parseInt(command, 10);
+ if (!Number.isNaN(numericCommand)) {
+ const handler = this.numericHandlers.get(numericCommand);
+ if (handler) {
+ handler.handle(message, serverId);
+ return true;
+ }
+ }
+
+ // Try string command handler
+ const handler = this.handlers.get(command.toUpperCase());
+ if (handler) {
+ handler.handle(message, serverId);
+ return true;
+ }
+
+ // No handler found
+ console.log(`No handler found for command: ${command}`);
+ return false;
+ }
+
+ /**
+ * Check if a handler is registered for a command
+ */
+ hasHandler(command: string | number): boolean {
+ if (typeof command === "number") {
+ return this.numericHandlers.has(command);
+ }
+ return this.handlers.has(command.toUpperCase());
+ }
+
+ /**
+ * Unregister a handler
+ */
+ unregisterHandler(command: string | number): void {
+ if (typeof command === "number") {
+ this.numericHandlers.delete(command);
+ } else {
+ this.handlers.delete(command.toUpperCase());
+ }
+ }
+
+ /**
+ * Get all registered command names
+ */
+ getRegisteredCommands(): string[] {
+ return [
+ ...Array.from(this.handlers.keys()),
+ ...Array.from(this.numericHandlers.keys()).map(String),
+ ];
+ }
+
+ /**
+ * Clear all handlers
+ */
+ clearAll(): void {
+ this.handlers.clear();
+ this.numericHandlers.clear();
+ }
+}
diff --git a/src/lib/irc/protocol/messageBuilder.ts b/src/lib/irc/protocol/messageBuilder.ts
new file mode 100644
index 00000000..bb2e59ae
--- /dev/null
+++ b/src/lib/irc/protocol/messageBuilder.ts
@@ -0,0 +1,124 @@
+/**
+ * Builds outgoing IRC protocol messages
+ */
+export class MessageBuilder {
+ /**
+ * Build a PRIVMSG command
+ */
+ buildPrivmsg(
+ target: string,
+ message: string,
+ tags?: Record,
+ ): string {
+ let command = "";
+ if (tags) {
+ const tagString = Object.entries(tags)
+ .map(([key, value]) => `${key}=${value}`)
+ .join(";");
+ command = `@${tagString} `;
+ }
+ command += `PRIVMSG ${target} :${message}`;
+ return command;
+ }
+
+ /**
+ * Build a multiline message batch
+ */
+ buildMultiline(target: string, lines: string[], batchId?: string): string[] {
+ const id =
+ batchId || `ml_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+ const commands: string[] = [];
+
+ // Start batch
+ commands.push(`BATCH +${id} draft/multiline ${target}`);
+
+ // Send each line
+ for (const line of lines) {
+ const splitLines = this.splitLongLine(line);
+ for (const splitLine of splitLines) {
+ commands.push(`@batch=${id} PRIVMSG ${target} :${splitLine}`);
+ }
+ }
+
+ // End batch
+ commands.push(`BATCH -${id}`);
+
+ return commands;
+ }
+
+ /**
+ * Split long lines to respect IRC message length limits (512 bytes)
+ * @param text Text to split
+ * @param maxLength Maximum length per line (default 450 to account for IRC overhead)
+ * @returns Array of split lines
+ */
+ splitLongLine(text: string, maxLength = 450): string[] {
+ if (!text) return [""];
+
+ const lines: string[] = [];
+ let remaining = text;
+
+ while (remaining.length > maxLength) {
+ // Try to split at word boundaries
+ let splitIndex = maxLength;
+ const lastSpace = remaining.lastIndexOf(" ", maxLength);
+ if (lastSpace > maxLength * 0.7) {
+ // Don't split too early
+ splitIndex = lastSpace;
+ }
+
+ lines.push(remaining.substring(0, splitIndex));
+ remaining = remaining.substring(splitIndex).trim();
+ }
+
+ if (remaining) {
+ lines.push(remaining);
+ }
+
+ return lines.length > 0 ? lines : [""];
+ }
+
+ /**
+ * Build a TAGMSG command
+ */
+ buildTagmsg(target: string, tags: Record): string {
+ const tagString = Object.entries(tags)
+ .map(([key, value]) => `${key}=${value}`)
+ .join(";");
+ return `@${tagString} TAGMSG ${target}`;
+ }
+
+ /**
+ * Build a command with optional tags
+ */
+ buildCommand(
+ command: string,
+ params: string[],
+ tags?: Record,
+ ): string {
+ let cmd = "";
+ if (tags) {
+ const tagString = Object.entries(tags)
+ .map(([key, value]) => `${key}=${value}`)
+ .join(";");
+ cmd = `@${tagString} `;
+ }
+ cmd += command;
+ if (params.length > 0) {
+ // Last param needs ':' prefix if it contains spaces
+ const lastParam = params[params.length - 1];
+ const otherParams = params.slice(0, -1);
+
+ if (otherParams.length > 0) {
+ cmd += ` ${otherParams.join(" ")}`;
+ }
+
+ if (lastParam.includes(" ")) {
+ cmd += ` :${lastParam}`;
+ } else {
+ cmd += ` ${lastParam}`;
+ }
+ }
+ return cmd;
+ }
+}
diff --git a/src/lib/irc/protocol/messageParser.ts b/src/lib/irc/protocol/messageParser.ts
new file mode 100644
index 00000000..8d2f55c3
--- /dev/null
+++ b/src/lib/irc/protocol/messageParser.ts
@@ -0,0 +1,109 @@
+import { parseMessageTags } from "../utils/ircUtils";
+
+export interface ParsedMessage {
+ tags?: Record;
+ source: string;
+ command: string;
+ params: string[];
+}
+
+/**
+ * Parses raw IRC protocol messages into structured format
+ */
+export class MessageParser {
+ /**
+ * Parse a single IRC message line
+ * @param line Raw IRC message line
+ * @param defaultSource Default source to use if message has no source prefix
+ * @returns Parsed message or null if invalid
+ */
+ parse(line: string, defaultSource: string): ParsedMessage | null {
+ const trimmedLine = line.trim();
+
+ // Skip empty lines
+ if (!trimmedLine) return null;
+
+ console.log(`IRC Parser: Parsing line: ${trimmedLine}`);
+
+ let mtags: Record | undefined;
+ let lineAfterTags = trimmedLine;
+
+ // Handle message tags first, before splitting on trailing parameter
+ if (trimmedLine[0] === "@") {
+ const spaceIndex = trimmedLine.indexOf(" ");
+ if (spaceIndex !== -1) {
+ mtags = parseMessageTags(trimmedLine.substring(0, spaceIndex));
+ lineAfterTags = trimmedLine.substring(spaceIndex + 1);
+ }
+ }
+
+ // Parse IRC message properly handling colon-prefixed trailing parameter
+ const spaceColonIndex = lineAfterTags.indexOf(" :");
+ let trailing = "";
+ let mainPart = lineAfterTags;
+
+ if (spaceColonIndex !== -1) {
+ trailing = lineAfterTags.substring(spaceColonIndex + 2); // Skip ' :'
+ mainPart = lineAfterTags.substring(0, spaceColonIndex);
+ }
+
+ const parts = mainPart.split(" ").filter((part) => part.length > 0);
+
+ // Ensure we have at least one element
+ if (parts.length === 0) return null;
+
+ let i = 0;
+ let source: string;
+
+ // Determine the source. if none, use default
+ if (parts[i][0] !== ":") {
+ source = defaultSource;
+ } else {
+ source = parts[i].substring(1);
+ i++;
+ }
+
+ // Get command
+ if (i >= parts.length) return null;
+ const command = parts[i];
+ i++;
+
+ // Collect parameters
+ const params: string[] = [];
+ for (; i < parts.length; i++) {
+ params.push(parts[i]);
+ }
+
+ // Add trailing parameter if it exists
+ if (trailing) {
+ params.push(trailing);
+ }
+
+ return {
+ tags: mtags,
+ source,
+ command,
+ params,
+ };
+ }
+
+ /**
+ * Parse multiple IRC messages from a data chunk
+ * @param data Raw data containing one or more IRC messages
+ * @param defaultSource Default source for messages without a source
+ * @returns Array of parsed messages
+ */
+ parseMultiple(data: string, defaultSource: string): ParsedMessage[] {
+ const lines = data.split("\r\n");
+ const messages: ParsedMessage[] = [];
+
+ for (const line of lines) {
+ const message = this.parse(line, defaultSource);
+ if (message) {
+ messages.push(message);
+ }
+ }
+
+ return messages;
+ }
+}
diff --git a/src/lib/irc/types.ts b/src/lib/irc/types.ts
new file mode 100644
index 00000000..8706474f
--- /dev/null
+++ b/src/lib/irc/types.ts
@@ -0,0 +1,367 @@
+import type {
+ BaseIRCEvent,
+ BaseMessageEvent,
+ BaseMetadataEvent,
+ BaseUserActionEvent,
+ Channel,
+ ConnectionState,
+ EventWithTags,
+ MetadataValueEvent,
+ Server,
+ User,
+} from "../../types";
+
+export interface EventMap {
+ ready: BaseIRCEvent & { serverName: string; nickname: string };
+ connectionStateChange: BaseIRCEvent & {
+ serverId: string;
+ connectionState: ConnectionState;
+ };
+ NICK: EventWithTags & {
+ oldNick: string;
+ newNick: string;
+ };
+ QUIT: BaseUserActionEvent & { reason: string; batchTag?: string };
+ JOIN: BaseUserActionEvent & {
+ channelName: string;
+ batchTag?: string;
+ account?: string; // From extended-join
+ realname?: string; // From extended-join
+ };
+ PART: BaseUserActionEvent & {
+ channelName: string;
+ reason?: string;
+ };
+ KICK: EventWithTags & {
+ username: string;
+ channelName: string;
+ target: string;
+ reason: string;
+ };
+ MODE: EventWithTags & {
+ sender: string;
+ target: string;
+ modestring: string;
+ modeargs: string[];
+ };
+ RPL_CHANNELMODEIS: BaseIRCEvent & {
+ channelName: string;
+ modestring: string;
+ modeargs: string[];
+ };
+ CHANMSG: BaseMessageEvent & {
+ channelName: string;
+ };
+ USERMSG: BaseMessageEvent & {
+ target: string;
+ };
+ CHANNNOTICE: BaseMessageEvent & {
+ channelName: string;
+ };
+ USERNOTICE: BaseMessageEvent;
+ TAGMSG: EventWithTags & {
+ sender: string;
+ channelName: string;
+ timestamp: Date;
+ };
+ REDACT: EventWithTags & {
+ target: string;
+ msgid: string;
+ reason: string;
+ sender: string;
+ };
+ NAMES: BaseIRCEvent & { channelName: string; users: User[] };
+ "CAP LS": BaseIRCEvent & { cliCaps: string };
+ "CAP ACK": BaseIRCEvent & { cliCaps: string };
+ ISUPPORT: BaseIRCEvent & { key: string; value: string };
+ CAP_ACKNOWLEDGED: BaseIRCEvent & { key: string; capabilities: string };
+ CAP_END: BaseIRCEvent;
+ AUTHENTICATE: BaseIRCEvent & { param: string };
+ METADATA: MetadataValueEvent;
+ METADATA_WHOIS: MetadataValueEvent;
+ METADATA_KEYVALUE: MetadataValueEvent;
+ METADATA_KEYNOTSET: BaseMetadataEvent;
+ METADATA_SUBOK: BaseIRCEvent & { keys: string[] };
+ METADATA_UNSUBOK: BaseIRCEvent & { keys: string[] };
+ METADATA_SUBS: BaseIRCEvent & { keys: string[] };
+ METADATA_SYNCLATER: BaseIRCEvent & { target: string; retryAfter?: number };
+ BATCH_START: BaseIRCEvent & {
+ batchId: string;
+ type: string;
+ parameters?: string[];
+ };
+ BATCH_END: BaseIRCEvent & { batchId: string };
+ MULTILINE_MESSAGE: BaseMessageEvent & {
+ channelName?: string;
+ lines: string[];
+ messageIds: string[];
+ };
+ METADATA_FAIL: BaseIRCEvent & {
+ subcommand: string;
+ code: string;
+ target?: string;
+ key?: string;
+ retryAfter?: number;
+ };
+ LIST_CHANNEL: {
+ serverId: string;
+ channel: string;
+ userCount: number;
+ topic: string;
+ };
+ LIST_END: { serverId: string };
+ RENAME: {
+ serverId: string;
+ oldName: string;
+ newName: string;
+ reason: string;
+ user: string;
+ };
+ SETNAME: { serverId: string; user: string; realname: string };
+ INVITE: EventWithTags & {
+ inviter: string;
+ target: string;
+ channel: string;
+ };
+ FAIL: EventWithTags & {
+ command: string;
+ code: string;
+ target?: string;
+ message: string;
+ };
+ WARN: EventWithTags & {
+ command: string;
+ code: string;
+ target?: string;
+ message: string;
+ };
+ NOTE: EventWithTags & {
+ command: string;
+ code: string;
+ target?: string;
+ message: string;
+ };
+ SUCCESS: EventWithTags & {
+ command: string;
+ code: string;
+ target?: string;
+ message: string;
+ };
+ REGISTER_SUCCESS: EventWithTags & {
+ account: string;
+ message: string;
+ };
+ REGISTER_VERIFICATION_REQUIRED: EventWithTags & {
+ account: string;
+ message: string;
+ };
+ VERIFY_SUCCESS: EventWithTags & {
+ account: string;
+ message: string;
+ };
+ WHO_REPLY: {
+ serverId: string;
+ channel: string;
+ username: string;
+ host: string;
+ server: string;
+ nick: string;
+ flags: string;
+ hopcount: string;
+ realname: string;
+ };
+ WHOX_REPLY: {
+ serverId: string;
+ channel: string;
+ username: string;
+ host: string;
+ nick: string;
+ account: string;
+ flags: string;
+ realname: string;
+ isAway: boolean;
+ opLevel: string;
+ };
+ WHO_END: { serverId: string; mask: string };
+ RPL_AWAY: {
+ serverId: string;
+ nick: string;
+ awayMessage: string;
+ };
+ RPL_YOUREOPER: BaseIRCEvent & {
+ message: string;
+ };
+ RPL_YOURHOST: BaseIRCEvent & {
+ serverName: string;
+ version: string;
+ };
+ MONONLINE: BaseIRCEvent & {
+ targets: Array<{ nick: string; user?: string; host?: string }>;
+ };
+ MONOFFLINE: BaseIRCEvent & {
+ targets: string[];
+ };
+ MONLIST: BaseIRCEvent & {
+ targets: string[];
+ };
+ ENDOFMONLIST: BaseIRCEvent;
+ MONLISTFULL: BaseIRCEvent & {
+ limit: number;
+ targets: string[];
+ };
+ EXTJWT: BaseIRCEvent & {
+ requestedTarget: string;
+ serviceName: string;
+ jwtToken: string;
+ };
+ WHOIS_BOT: {
+ serverId: string;
+ nick: string;
+ target: string;
+ message: string;
+ };
+ AWAY: {
+ serverId: string;
+ username: string;
+ awayMessage?: string;
+ };
+ CHGHOST: {
+ serverId: string;
+ username: string;
+ newUser: string;
+ newHost: string;
+ };
+ RPL_NOWAWAY: {
+ serverId: string;
+ message: string;
+ };
+ RPL_UNAWAY: {
+ serverId: string;
+ message: string;
+ };
+ NICK_ERROR: {
+ serverId: string;
+ code: string;
+ error: string;
+ nick?: string;
+ message: string;
+ };
+ CHATHISTORY_LOADING: {
+ serverId: string;
+ channelName: string;
+ isLoading: boolean;
+ };
+ RPL_BANLIST: {
+ serverId: string;
+ channel: string;
+ mask: string;
+ setter: string;
+ timestamp: number;
+ };
+ RPL_INVITELIST: {
+ serverId: string;
+ channel: string;
+ mask: string;
+ setter: string;
+ timestamp: number;
+ };
+ RPL_EXCEPTLIST: {
+ serverId: string;
+ channel: string;
+ mask: string;
+ setter: string;
+ timestamp: number;
+ };
+ RPL_ENDOFBANLIST: {
+ serverId: string;
+ channel: string;
+ };
+ RPL_ENDOFINVITELIST: {
+ serverId: string;
+ channel: string;
+ };
+ RPL_ENDOFEXCEPTLIST: {
+ serverId: string;
+ channel: string;
+ };
+ TOPIC: {
+ serverId: string;
+ channelName: string;
+ topic: string;
+ sender: string;
+ };
+ RPL_TOPIC: {
+ serverId: string;
+ channelName: string;
+ topic: string;
+ };
+ RPL_TOPICWHOTIME: {
+ serverId: string;
+ channelName: string;
+ setter: string;
+ timestamp: number;
+ };
+ RPL_NOTOPIC: {
+ serverId: string;
+ channelName: string;
+ };
+ WHOIS_USER: {
+ serverId: string;
+ nick: string;
+ username: string;
+ host: string;
+ realname: string;
+ };
+ WHOIS_SERVER: {
+ serverId: string;
+ nick: string;
+ server: string;
+ serverInfo: string;
+ };
+ WHOIS_IDLE: {
+ serverId: string;
+ nick: string;
+ idle: number;
+ signon: number;
+ };
+ WHOIS_CHANNELS: {
+ serverId: string;
+ nick: string;
+ channels: string;
+ };
+ WHOIS_SPECIAL: {
+ serverId: string;
+ nick: string;
+ message: string;
+ };
+ WHOIS_ACCOUNT: {
+ serverId: string;
+ nick: string;
+ account: string;
+ };
+ WHOIS_SECURE: {
+ serverId: string;
+ nick: string;
+ message: string;
+ };
+ WHOIS_END: {
+ serverId: string;
+ nick: string;
+ };
+}
+
+export type EventKey = keyof EventMap;
+export type EventCallback = (data: EventMap[K]) => void;
+
+export type {
+ BaseIRCEvent,
+ BaseMessageEvent,
+ BaseMetadataEvent,
+ BaseUserActionEvent,
+ Channel,
+ ConnectionState,
+ EventWithTags,
+ MetadataValueEvent,
+ Server,
+ User,
+};
diff --git a/src/lib/irc/utils/ircUtils.ts b/src/lib/irc/utils/ircUtils.ts
new file mode 100644
index 00000000..132ff53c
--- /dev/null
+++ b/src/lib/irc/utils/ircUtils.ts
@@ -0,0 +1,85 @@
+import type { User } from "../../../types";
+
+/**
+ * Extract nickname from nick!user@host format
+ */
+export function getNickFromNuh(nuh: string): string {
+ const nick = nuh.split("!")[0];
+ return nick.startsWith(":") ? nick.substring(1) : nick;
+}
+
+/**
+ * Get timestamp from IRC message tags, with fallback to current time
+ */
+export function getTimestampFromTags(
+ mtags: Record | undefined,
+): Date {
+ if (mtags?.time) {
+ return new Date(mtags.time);
+ }
+ return new Date();
+}
+
+/**
+ * Parse IRC message tags (@key=value;key2=value2)
+ */
+export function parseMessageTags(tags: string): Record {
+ const parsedTags: Record = {};
+ const tagPairs = tags.substring(1).split(";");
+
+ for (const tag of tagPairs) {
+ const [key, value] = tag.split("=");
+ parsedTags[key] = value?.trim() ?? ""; // empty string fallback
+ }
+
+ return parsedTags;
+}
+
+/**
+ * Parse NAMES response (353 numeric) into User objects
+ */
+export function parseNamesResponse(namesResponse: string): User[] {
+ const users: User[] = [];
+ for (const name of namesResponse.split(" ")) {
+ // Try to match with userhost format first (nick!user@host)
+ let regex = /([~&@%+]*)([^\s!]+)!/;
+ let match = regex.exec(name);
+
+ if (!match) {
+ // If no match, try without ! (just nickname)
+ regex = /([~&@%+]*)([^\s!]+)/;
+ match = regex.exec(name);
+ }
+
+ if (match) {
+ const [_, prefix, username] = match;
+ users.push({
+ id: username,
+ username,
+ status: prefix,
+ isOnline: true,
+ });
+ }
+ }
+ return users;
+}
+
+/**
+ * Parse ISUPPORT tokens (005 numeric)
+ */
+export function parseIsupport(tokens: string): Record {
+ const tokenMap: Record = {};
+ const tokenPairs = tokens.split(" ");
+
+ for (const token of tokenPairs) {
+ const [key, value] = token.split("=");
+ if (value) {
+ // Replace \x20 with actual space character
+ tokenMap[key] = value.replace(/\\x20/g, " ");
+ } else {
+ tokenMap[key] = ""; // empty string fallback
+ }
+ }
+
+ return tokenMap;
+}
diff --git a/src/lib/ircClient.ts b/src/lib/ircClient.ts
index 1d71d569..074c3749 100644
--- a/src/lib/ircClient.ts
+++ b/src/lib/ircClient.ts
@@ -1,2746 +1,31 @@
-import { v4 as uuidv4 } from "uuid";
-import type {
+// Re-export the main IRCClient class
+export { IRCClient } from "./irc/index";
+
+// Create and export a singleton instance for backward compatibility
+import { IRCClient } from "./irc/index";
+
+export const ircClient = new IRCClient();
+
+export default ircClient;
+
+// Re-export types from the types module
+export type {
BaseIRCEvent,
BaseMessageEvent,
BaseMetadataEvent,
BaseUserActionEvent,
- Channel,
- ConnectionState,
+ EventCallback,
+ EventKey,
+ EventMap,
EventWithTags,
MetadataValueEvent,
- Server,
- User,
-} from "../types";
-import {
+} from "./irc/types";
+
+// Re-export utility functions
+export {
+ getNickFromNuh,
+ getTimestampFromTags,
parseIsupport,
parseMessageTags,
parseNamesResponse,
-} from "./ircUtils";
-
-export interface EventMap {
- ready: BaseIRCEvent & { serverName: string; nickname: string };
- connectionStateChange: BaseIRCEvent & {
- serverId: string;
- connectionState: ConnectionState;
- };
- NICK: EventWithTags & {
- oldNick: string;
- newNick: string;
- };
- QUIT: BaseUserActionEvent & { reason: string; batchTag?: string };
- JOIN: BaseUserActionEvent & {
- channelName: string;
- batchTag?: string;
- account?: string; // From extended-join
- realname?: string; // From extended-join
- };
- PART: BaseUserActionEvent & {
- channelName: string;
- reason?: string;
- };
- KICK: EventWithTags & {
- username: string;
- channelName: string;
- target: string;
- reason: string;
- };
- MODE: EventWithTags & {
- sender: string;
- target: string;
- modestring: string;
- modeargs: string[];
- };
- RPL_CHANNELMODEIS: BaseIRCEvent & {
- channelName: string;
- modestring: string;
- modeargs: string[];
- };
- CHANMSG: BaseMessageEvent & {
- channelName: string;
- };
- USERMSG: BaseMessageEvent & {
- target: string; // The recipient of the PRIVMSG (for whispers)
- };
- CHANNNOTICE: BaseMessageEvent & {
- channelName: string;
- };
- USERNOTICE: BaseMessageEvent;
- TAGMSG: EventWithTags & {
- sender: string;
- channelName: string;
- timestamp: Date;
- };
- REDACT: EventWithTags & {
- target: string;
- msgid: string;
- reason: string;
- sender: string;
- };
- NAMES: BaseIRCEvent & { channelName: string; users: User[] };
- "CAP LS": BaseIRCEvent & { cliCaps: string };
- "CAP ACK": BaseIRCEvent & { cliCaps: string };
- ISUPPORT: BaseIRCEvent & { key: string; value: string };
- CAP_ACKNOWLEDGED: BaseIRCEvent & { key: string; capabilities: string };
- CAP_END: BaseIRCEvent;
- AUTHENTICATE: BaseIRCEvent & { param: string };
- METADATA: MetadataValueEvent;
- METADATA_WHOIS: MetadataValueEvent;
- METADATA_KEYVALUE: MetadataValueEvent;
- METADATA_KEYNOTSET: BaseMetadataEvent;
- METADATA_SUBOK: BaseIRCEvent & { keys: string[] };
- METADATA_UNSUBOK: BaseIRCEvent & { keys: string[] };
- METADATA_SUBS: BaseIRCEvent & { keys: string[] };
- METADATA_SYNCLATER: BaseIRCEvent & { target: string; retryAfter?: number };
- BATCH_START: BaseIRCEvent & {
- batchId: string;
- type: string;
- parameters?: string[];
- };
- BATCH_END: BaseIRCEvent & { batchId: string };
- MULTILINE_MESSAGE: BaseMessageEvent & {
- channelName?: string;
- lines: string[];
- messageIds: string[]; // All message IDs that make up this multiline message
- };
- METADATA_FAIL: BaseIRCEvent & {
- subcommand: string;
- code: string;
- target?: string;
- key?: string;
- retryAfter?: number;
- };
- LIST_CHANNEL: {
- serverId: string;
- channel: string;
- userCount: number;
- topic: string;
- };
- LIST_END: { serverId: string };
- RENAME: {
- serverId: string;
- oldName: string;
- newName: string;
- reason: string;
- user: string;
- };
- SETNAME: { serverId: string; user: string; realname: string };
- INVITE: EventWithTags & {
- inviter: string;
- target: string;
- channel: string;
- };
- FAIL: EventWithTags & {
- command: string;
- code: string;
- target?: string;
- message: string;
- };
- WARN: EventWithTags & {
- command: string;
- code: string;
- target?: string;
- message: string;
- };
- NOTE: EventWithTags & {
- command: string;
- code: string;
- target?: string;
- message: string;
- };
- SUCCESS: EventWithTags & {
- command: string;
- code: string;
- target?: string;
- message: string;
- };
- REGISTER_SUCCESS: EventWithTags & {
- account: string;
- message: string;
- };
- REGISTER_VERIFICATION_REQUIRED: EventWithTags & {
- account: string;
- message: string;
- };
- VERIFY_SUCCESS: EventWithTags & {
- account: string;
- message: string;
- };
- WHO_REPLY: {
- serverId: string;
- channel: string;
- username: string;
- host: string;
- server: string;
- nick: string;
- flags: string;
- hopcount: string;
- realname: string;
- };
- WHOX_REPLY: {
- serverId: string;
- channel: string;
- username: string;
- host: string;
- nick: string;
- account: string;
- flags: string;
- realname: string;
- isAway: boolean;
- opLevel: string;
- };
- WHO_END: { serverId: string; mask: string };
- RPL_AWAY: {
- serverId: string;
- nick: string;
- awayMessage: string;
- };
- RPL_YOUREOPER: BaseIRCEvent & {
- message: string;
- };
- RPL_YOURHOST: BaseIRCEvent & {
- serverName: string;
- version: string;
- };
- MONONLINE: BaseIRCEvent & {
- targets: Array<{ nick: string; user?: string; host?: string }>;
- };
- MONOFFLINE: BaseIRCEvent & {
- targets: string[]; // Just nicknames
- };
- MONLIST: BaseIRCEvent & {
- targets: string[];
- };
- ENDOFMONLIST: BaseIRCEvent;
- MONLISTFULL: BaseIRCEvent & {
- limit: number;
- targets: string[];
- };
- EXTJWT: BaseIRCEvent & {
- requestedTarget: string;
- serviceName: string;
- jwtToken: string;
- };
- WHOIS_BOT: {
- serverId: string;
- nick: string;
- target: string;
- message: string;
- };
- AWAY: {
- serverId: string;
- username: string;
- awayMessage?: string;
- };
- CHGHOST: {
- serverId: string;
- username: string;
- newUser: string;
- newHost: string;
- };
- RPL_NOWAWAY: {
- serverId: string;
- message: string;
- };
- RPL_UNAWAY: {
- serverId: string;
- message: string;
- };
- NICK_ERROR: {
- serverId: string;
- code: string;
- error: string;
- nick?: string;
- message: string;
- };
- CHATHISTORY_LOADING: {
- serverId: string;
- channelName: string;
- isLoading: boolean;
- };
- RPL_BANLIST: {
- serverId: string;
- channel: string;
- mask: string;
- setter: string;
- timestamp: number;
- };
- RPL_INVITELIST: {
- serverId: string;
- channel: string;
- mask: string;
- setter: string;
- timestamp: number;
- };
- RPL_EXCEPTLIST: {
- serverId: string;
- channel: string;
- mask: string;
- setter: string;
- timestamp: number;
- };
- RPL_ENDOFBANLIST: {
- serverId: string;
- channel: string;
- };
- RPL_ENDOFINVITELIST: {
- serverId: string;
- channel: string;
- };
- RPL_ENDOFEXCEPTLIST: {
- serverId: string;
- channel: string;
- };
- TOPIC: {
- serverId: string;
- channelName: string;
- topic: string;
- sender: string;
- };
- RPL_TOPIC: {
- serverId: string;
- channelName: string;
- topic: string;
- };
- RPL_TOPICWHOTIME: {
- serverId: string;
- channelName: string;
- setter: string;
- timestamp: number;
- };
- RPL_NOTOPIC: {
- serverId: string;
- channelName: string;
- };
- WHOIS_USER: {
- serverId: string;
- nick: string;
- username: string;
- host: string;
- realname: string;
- };
- WHOIS_SERVER: {
- serverId: string;
- nick: string;
- server: string;
- serverInfo: string;
- };
- WHOIS_IDLE: {
- serverId: string;
- nick: string;
- idle: number;
- signon: number;
- };
- WHOIS_CHANNELS: {
- serverId: string;
- nick: string;
- channels: string;
- };
- WHOIS_SPECIAL: {
- serverId: string;
- nick: string;
- message: string;
- };
- WHOIS_ACCOUNT: {
- serverId: string;
- nick: string;
- account: string;
- };
- WHOIS_SECURE: {
- serverId: string;
- nick: string;
- message: string;
- };
- WHOIS_END: {
- serverId: string;
- nick: string;
- };
-}
-
-type EventKey = keyof EventMap;
-type EventCallback = (data: EventMap[K]) => void;
-
-export class IRCClient {
- private sockets: Map = new Map();
- private servers: Map = new Map();
- private nicks: Map = new Map();
- private currentUsers: Map = new Map(); // Per-server current users
- private saslMechanisms: Map = new Map();
- private capLsAccumulated: Map> = new Map();
- private saslEnabled: Map = new Map();
- private saslCredentials: Map =
- new Map();
- private pendingConnections: Map> = new Map();
- private pendingCapReqs: Map = new Map(); // Track how many CAP REQ batches are pending ACK
- private capNegotiationComplete: Map = new Map(); // Track if CAP negotiation is complete
- private reconnectionAttempts: Map = new Map(); // Track reconnection attempts per server
- private reconnectionTimeouts: Map = new Map(); // Track reconnection timeouts per server
- private pingTimers: Map = new Map(); // Track ping timers per server
- private pongTimeouts: Map = new Map(); // Track pong timeouts per server
- private activeBatches: Map<
- string,
- Map<
- string,
- {
- type: string;
- parameters?: string[];
- messages: string[];
- concatFlags?: boolean[];
- sender?: string;
- messageIds?: string[];
- timestamps?: Date[];
- batchMsgId?: string;
- batchTime?: Date;
- }
- >
- > = new Map(); // Track active batches per server
-
- private ourCaps: string[] = [
- "multi-prefix",
- "message-tags",
- "server-time",
- "echo-message",
- "userhost-in-names",
- "draft/chathistory",
- "draft/extended-isupport",
- "sasl",
- "cap-notify",
- "draft/channel-rename",
- "setname",
- "account-notify",
- "account-tag",
- "extended-join",
- "away-notify",
- "chghost",
- "draft/metadata-2",
- "draft/message-redaction",
- "draft/account-registration",
- "batch",
- "draft/multiline",
- "draft/typing",
- "draft/channel-context",
- "znc.in/playback",
- "unrealircd.org/json-log",
- "invite-notify",
- "monitor",
- "extended-monitor",
- // Note: unrealircd.org/link-security is informational only, don't request it
- ];
-
- private eventCallbacks: {
- [K in EventKey]?: EventCallback[];
- } = {};
-
- public version = __APP_VERSION__;
-
- connect(
- name: string,
- host: string,
- port: number,
- nickname: string,
- password?: string,
- _saslAccountName?: string,
- _saslPassword?: string,
- serverId?: string,
- ): Promise {
- const connectionKey = `${host}:${port}`;
-
- // Check if there's already a pending connection to this server
- const existingConnection = this.pendingConnections.get(connectionKey);
- if (existingConnection) {
- return existingConnection;
- }
-
- // Check if already connected to this server (but allow reconnection if serverId is provided)
- if (!serverId) {
- const existingServer = Array.from(this.servers.values()).find(
- (server) => server.host === host && server.port === port,
- );
- if (existingServer) {
- return Promise.resolve(existingServer);
- }
- }
-
- // Create a new connection promise and store it
- const connectionPromise = new Promise((resolve, reject) => {
- // for local testing and automated tests, if domain is localhost or 127.0.0.1 use ws instead of wss
- const protocol = ["localhost", "127.0.0.1"].includes(host) ? "ws" : "wss";
- const url = `${protocol}://${host}:${port}`;
-
- let socket: WebSocket;
- try {
- socket = new WebSocket(url);
- } catch (error) {
- reject(new Error(`Failed to connect to ${host}:${port}`));
- return;
- }
-
- // Create server object immediately and add to servers map
- // Use provided name, default to host if name is empty
- const finalName = name?.trim() || host;
-
- // Check if we're reconnecting to an existing server
- let server: Server;
- if (serverId && this.servers.has(serverId)) {
- // Reuse existing server object for reconnection
- const existingServer = this.servers.get(serverId);
- if (existingServer) {
- server = existingServer;
- // Update connection state
- server.connectionState = "connecting";
- server.isConnected = false;
- // Reset CAP negotiation state for reconnection
- this.capNegotiationComplete.delete(serverId);
- } else {
- throw new Error(`Server ${serverId} not found despite has() check`);
- }
- } else {
- // Create new server object
- server = {
- id: serverId || uuidv4(),
- name: finalName,
- host,
- port,
- channels: [],
- privateChats: [],
- isConnected: false, // Not connected yet
- connectionState: "connecting",
- users: [],
- };
- this.servers.set(server.id, server);
- }
- this.sockets.set(server.id, socket);
- // Only enable SASL if we have both account name AND password
- this.saslEnabled.set(server.id, !!(_saslAccountName && _saslPassword));
-
- // Store SASL credentials if provided
- if (_saslAccountName && _saslPassword) {
- this.saslCredentials.set(server.id, {
- username: _saslAccountName,
- password: _saslPassword,
- });
- } else {
- }
-
- this.currentUsers.set(server.id, {
- id: uuidv4(),
- username: nickname,
- isOnline: true,
- status: "online",
- });
- this.nicks.set(server.id, nickname);
-
- socket.onopen = () => {
- //registerAllProtocolHandlers(this);
- // Send IRC commands to register the user
- if (password) {
- socket.send(`PASS ${password}`);
- }
-
- socket.send("CAP LS 302");
- socket.send(`NICK ${nickname}`);
-
- // Update server to mark as connected
- server.isConnected = true;
- server.connectionState = "connected";
- this.triggerEvent("connectionStateChange", {
- serverId: server.id,
- connectionState: "connected",
- });
-
- // Rejoin channels if this is a reconnection
- if (server.channels.length > 0) {
- for (const channel of server.channels) {
- if (serverId) {
- this.sendRaw(serverId, `JOIN ${channel.name}`);
- }
- }
- }
-
- // Start WebSocket ping timer for keepalive
- this.startWebSocketPing(server.id);
-
- socket.onclose = () => {
- console.log(`WebSocket onclose for server ${serverId}`);
- // Stop WebSocket ping timers
- this.stopWebSocketPing(server.id);
- this.sockets.delete(server.id);
- server.isConnected = false;
- // Only start reconnection if not already reconnecting (e.g., from ERROR handler)
- const wasReconnecting = server.connectionState === "reconnecting";
- server.connectionState = "disconnected";
- this.triggerEvent("connectionStateChange", {
- serverId: server.id,
- connectionState: "disconnected",
- });
- this.pendingConnections.delete(connectionKey);
- // Start reconnection logic only if not already reconnecting
- if (!wasReconnecting) {
- this.startReconnection(
- server.id,
- name,
- host,
- port,
- nickname,
- password,
- _saslAccountName,
- _saslPassword,
- );
- }
- };
-
- resolve(server);
- };
-
- socket.onerror = (error) => {
- // Mark server as disconnected but keep it in the map
- server.isConnected = false;
- server.connectionState = "disconnected";
- this.sockets.delete(server.id);
- this.pendingConnections.delete(connectionKey);
- reject(new Error(`Failed to connect to ${host}:${port}`));
- };
-
- socket.onmessage = (event) => {
- const serverId = Array.from(this.servers.keys()).find(
- (id) => this.sockets.get(id) === socket,
- );
- if (serverId) {
- this.handleMessage(event.data, serverId);
- }
- };
- });
-
- // Store the pending connection
- this.pendingConnections.set(connectionKey, connectionPromise);
-
- // Clean up the pending connection when it resolves or rejects
- connectionPromise.finally(() => {
- this.pendingConnections.delete(connectionKey);
- });
-
- return connectionPromise;
- }
-
- disconnect(serverId: string): void {
- const socket = this.sockets.get(serverId);
- if (socket) {
- socket.send("QUIT :ObsidianIRC - Bringing IRC into the future");
- socket.close();
- this.sockets.delete(serverId);
- }
- const server = this.servers.get(serverId);
- if (server) {
- server.isConnected = false;
- server.connectionState = "disconnected";
- this.triggerEvent("connectionStateChange", {
- serverId: server.id,
- connectionState: "disconnected",
- });
- const connectionKey = `${server.host}:${server.port}`;
- this.pendingConnections.delete(connectionKey);
- }
- // Clear reconnection state
- this.reconnectionAttempts.delete(serverId);
- const timeout = this.reconnectionTimeouts.get(serverId);
- if (timeout) {
- clearTimeout(timeout);
- this.reconnectionTimeouts.delete(serverId);
- }
- // Stop WebSocket ping timers
- this.stopWebSocketPing(serverId);
- }
-
- private startReconnection(
- serverId: string,
- name: string,
- host: string,
- port: number,
- nickname: string,
- password?: string,
- saslAccountName?: string,
- saslPassword?: string,
- ): void {
- console.log(`Starting reconnection for server ${serverId}`);
- const server = this.servers.get(serverId);
- if (!server) return;
-
- // Cancel any existing reconnection
- const existingTimeout = this.reconnectionTimeouts.get(serverId);
- if (existingTimeout) {
- clearTimeout(existingTimeout);
- }
-
- const attempts = this.reconnectionAttempts.get(serverId) || 0;
- this.reconnectionAttempts.set(serverId, attempts + 1);
-
- // Calculate delay based on attempt count
- let delay = 0;
- if (attempts === 0) {
- delay = 0; // Immediate retry for testing
- } else if (attempts === 1) {
- delay = 15000; // 15 seconds
- } else if (attempts === 2) {
- delay = 30000; // 30 seconds
- } else if (attempts <= 100) {
- delay = 60000; // 60 seconds for attempts 3-100
- } else {
- // After 100 attempts, stop trying
- server.connectionState = "disconnected";
- this.triggerEvent("connectionStateChange", {
- serverId: server.id,
- connectionState: "disconnected",
- });
- return;
- }
-
- server.connectionState = "reconnecting";
- this.triggerEvent("connectionStateChange", {
- serverId: server.id,
- connectionState: "reconnecting",
- });
-
- this.reconnectionTimeouts.set(
- serverId,
- setTimeout(() => {
- console.log(
- `Reconnection timeout fired for server ${serverId}, attempting reconnection`,
- );
- this.attemptReconnection(
- serverId,
- name,
- host,
- port,
- nickname,
- password,
- saslAccountName,
- saslPassword,
- );
- }, delay),
- );
- }
-
- private async attemptReconnection(
- serverId: string,
- name: string,
- host: string,
- port: number,
- nickname: string,
- password?: string,
- saslAccountName?: string,
- saslPassword?: string,
- ): Promise {
- console.log(`Attempting reconnection for server ${serverId}`);
- const server = this.servers.get(serverId);
- if (!server) return;
-
- try {
- server.connectionState = "connecting";
- this.triggerEvent("connectionStateChange", {
- serverId: server.id,
- connectionState: "connecting",
- });
- await this.connect(
- name,
- host,
- port,
- nickname,
- password,
- saslAccountName,
- saslPassword,
- serverId,
- );
- console.log(`Reconnection successful for server ${serverId}`);
- // Success - reset reconnection attempts
- this.reconnectionAttempts.delete(serverId);
- this.reconnectionTimeouts.delete(serverId);
- } catch (error) {
- console.log(`Reconnection failed for server ${serverId}:`, error);
- // Failed - try again
- this.startReconnection(
- serverId,
- name,
- host,
- port,
- nickname,
- password,
- saslAccountName,
- saslPassword,
- );
- }
- }
-
- sendRaw(serverId: string, command: string): void {
- const socket = this.sockets.get(serverId);
- if (socket && socket.readyState === WebSocket.OPEN) {
- console.log(
- `IRC Client: Sending command to server ${serverId}: ${command}`,
- );
- // Log metadata and command-related outgoing messages for debugging
- if (command.startsWith("METADATA") || command.startsWith("/")) {
- }
- socket.send(command);
- } else {
- console.error(`Socket for server ${serverId} is not open`);
- }
- }
-
- private startWebSocketPing(serverId: string): void {
- // Clear any existing ping timer
- this.stopWebSocketPing(serverId);
-
- // Send ping every 30 seconds
- const pingTimer = setInterval(() => {
- const socket = this.sockets.get(serverId);
- if (socket && socket.readyState === WebSocket.OPEN) {
- try {
- // Send WebSocket ping frame (opcode 0x9)
- // Since we can't send ping frames directly in JS, we'll send an IRC PING
- // which serves as both IRC keepalive and WebSocket activity
- const timestamp = Date.now().toString();
- this.sendRaw(serverId, `PING ${timestamp}`);
-
- // Set a timeout for pong response (10 seconds)
- const pongTimeout = setTimeout(() => {
- console.warn(
- `WebSocket ping timeout for server ${serverId}, closing connection`,
- );
- socket.close(1000, "Ping timeout");
- }, 10000);
-
- this.pongTimeouts.set(serverId, pongTimeout);
- } catch (error) {
- console.error(`Failed to send ping for server ${serverId}:`, error);
- }
- }
- }, 30000); // 30 seconds
-
- this.pingTimers.set(serverId, pingTimer);
- }
-
- private stopWebSocketPing(serverId: string): void {
- const pingTimer = this.pingTimers.get(serverId);
- if (pingTimer) {
- clearInterval(pingTimer);
- this.pingTimers.delete(serverId);
- }
-
- const pongTimeout = this.pongTimeouts.get(serverId);
- if (pongTimeout) {
- clearTimeout(pongTimeout);
- this.pongTimeouts.delete(serverId);
- }
- }
-
- joinChannel(serverId: string, channelName: string): Channel {
- const server = this.servers.get(serverId);
- if (server) {
- const existing = server.channels.find((c) => c.name === channelName);
- if (existing) return existing;
-
- this.sendRaw(serverId, `JOIN ${channelName}`);
-
- // Only request CHATHISTORY if the server supports it
- if (server.capabilities?.includes("draft/chathistory")) {
- this.sendRaw(serverId, `CHATHISTORY LATEST ${channelName} * 50`);
- }
-
- const channel: Channel = {
- id: uuidv4(),
- name: channelName,
- topic: "",
- isPrivate: false,
- serverId,
- unreadCount: 0,
- isMentioned: false,
- messages: [],
- users: [],
- isLoadingHistory: !!server.capabilities?.includes("draft/chathistory"), // Only loading if we requested history
- needsWhoRequest: true, // Need to request WHO after CHATHISTORY completes (or immediately if no CHATHISTORY)
- chathistoryRequested:
- !!server.capabilities?.includes("draft/chathistory"), // Mark that we've requested CHATHISTORY only if supported
- };
- server.channels.push(channel);
-
- // Trigger event to notify store that history loading started (only if we actually requested it)
- if (server.capabilities?.includes("draft/chathistory")) {
- this.triggerEvent("CHATHISTORY_LOADING", {
- serverId,
- channelName,
- isLoading: true,
- });
- }
-
- return channel;
- }
- throw new Error(`Server with ID ${serverId} not found`);
- }
-
- leaveChannel(serverId: string, channelName: string): void {
- const server = this.servers.get(serverId);
- if (server) {
- this.sendRaw(serverId, `PART ${channelName}`);
- server.channels = server.channels.filter((c) => c.name !== channelName);
- }
- }
-
- sendMessage(serverId: string, channelId: string, content: string): void {
- const server = this.servers.get(serverId);
- if (!server) throw new Error(`Server ${serverId} not found`);
- const channel = server.channels.find((c) => c.id === channelId);
- if (!channel) throw new Error(`Channel ${channelId} not found`);
-
- // Check if server supports multiline and message has newlines
- // Note: We'll check server capabilities from the store later via helper function
- const lines = content.split("\n");
-
- if (lines.length > 1) {
- // For now, send multiline if there are multiple lines
- // Server capability check will be done by the calling code
- this.sendMultilineMessage(serverId, channel.name, lines);
- } else {
- // Send as regular single message
- this.sendRaw(serverId, `PRIVMSG ${channel.name} :${content}`);
- }
- }
-
- sendWhisper(
- serverId: string,
- targetUser: string,
- channelName: string,
- content: string,
- ): void {
- // Send a whisper with the draft/channel-context tag
- // Format: @+draft/channel-context=#channel PRIVMSG targetUser :message
- this.sendRaw(
- serverId,
- `@+draft/channel-context=${channelName} PRIVMSG ${targetUser} :${content}`,
- );
- }
-
- setTopic(serverId: string, channelName: string, topic: string): void {
- // Send TOPIC command to set the channel topic
- // Format: TOPIC #channel :New topic text
- this.sendRaw(serverId, `TOPIC ${channelName} :${topic}`);
- }
-
- getTopic(serverId: string, channelName: string): void {
- // Send TOPIC command without parameters to get current topic
- // Format: TOPIC #channel
- this.sendRaw(serverId, `TOPIC ${channelName}`);
- }
-
- whois(serverId: string, nickname: string): void {
- // Send WHOIS command to get user information
- // Format: WHOIS nickname
- this.sendRaw(serverId, `WHOIS ${nickname}`);
- }
-
- sendMultilineMessage(
- serverId: string,
- target: string,
- lines: string[],
- ): void {
- const batchId = `ml_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-
- // Start multiline batch
- this.sendRaw(serverId, `BATCH +${batchId} draft/multiline ${target}`);
-
- // Send each line as a separate PRIVMSG with batch tag
- // Handle long lines by splitting them if needed
- for (const line of lines) {
- const splitLines = this.splitLongLine(line);
- for (const splitLine of splitLines) {
- this.sendRaw(
- serverId,
- `@batch=${batchId} PRIVMSG ${target} :${splitLine}`,
- );
- }
- }
-
- // End batch
- this.sendRaw(serverId, `BATCH -${batchId}`);
- }
-
- // Split long lines to respect IRC message length limits (512 bytes)
- private splitLongLine(text: string, maxLength = 450): string[] {
- if (!text) return [""];
-
- // Account for IRC overhead (PRIVMSG + target + formatting)
- // Conservative limit to account for formatting codes and IRC overhead
- const lines: string[] = [];
- let remaining = text;
-
- while (remaining.length > maxLength) {
- // Try to split at word boundaries
- let splitIndex = maxLength;
- const lastSpace = remaining.lastIndexOf(" ", maxLength);
- if (lastSpace > maxLength * 0.7) {
- // Don't split too early
- splitIndex = lastSpace;
- }
-
- lines.push(remaining.substring(0, splitIndex));
- remaining = remaining.substring(splitIndex).trim();
- }
-
- if (remaining) {
- lines.push(remaining);
- }
-
- return lines.length > 0 ? lines : [""];
- }
-
- sendTyping(serverId: string, target: string, isActive: boolean): void {
- const typingState = isActive ? "active" : "done";
- this.sendRaw(serverId, `@+typing=${typingState} TAGMSG ${target}`);
- }
-
- sendRedact(
- serverId: string,
- target: string,
- msgid: string,
- reason?: string,
- ): void {
- const command = reason
- ? `REDACT ${target} ${msgid} :${reason}`
- : `REDACT ${target} ${msgid}`;
- this.sendRaw(serverId, command);
- }
-
- registerAccount(
- serverId: string,
- account: string,
- email: string,
- password: string,
- ): void {
- this.sendRaw(serverId, `REGISTER ${account} ${email} ${password}`);
- }
-
- verifyAccount(serverId: string, account: string, code: string): void {
- this.sendRaw(serverId, `VERIFY ${account} ${code}`);
- }
-
- listChannels(
- serverId: string,
- elist?: string,
- filters?: {
- minUsers?: number;
- maxUsers?: number;
- minCreationTime?: number; // minutes ago
- maxCreationTime?: number; // minutes ago
- minTopicTime?: number; // minutes ago
- maxTopicTime?: number; // minutes ago
- mask?: string;
- notMask?: string;
- },
- ): void {
- let command = "LIST";
-
- if (elist && filters) {
- // Build LIST parameters based on filters and available ELIST capabilities
- const elistTokens = elist.toUpperCase().split("");
- const params: string[] = [];
-
- // User count filtering (U extension)
- if (elistTokens.includes("U")) {
- if (filters.minUsers && filters.minUsers > 0) {
- params.push(`>${filters.minUsers}`);
- }
- if (filters.maxUsers && filters.maxUsers > 0) {
- params.push(`<${filters.maxUsers}`);
- }
- }
-
- // Creation time filtering (C extension)
- if (elistTokens.includes("C")) {
- if (filters.minCreationTime && filters.minCreationTime > 0) {
- params.push(`C>${filters.minCreationTime}`);
- }
- if (filters.maxCreationTime && filters.maxCreationTime > 0) {
- params.push(`C<${filters.maxCreationTime}`);
- }
- }
-
- // Topic time filtering (T extension)
- if (elistTokens.includes("T")) {
- if (filters.minTopicTime && filters.minTopicTime > 0) {
- params.push(`T>${filters.minTopicTime}`);
- }
- if (filters.maxTopicTime && filters.maxTopicTime > 0) {
- params.push(`T<${filters.maxTopicTime}`);
- }
- }
-
- // Mask filtering (M extension)
- if (elistTokens.includes("M") && filters.mask) {
- params.push(filters.mask);
- }
-
- // Non-matching mask filtering (N extension)
- if (elistTokens.includes("N") && filters.notMask) {
- params.push(`!${filters.notMask}`);
- }
-
- if (params.length > 0) {
- command = `LIST ${params.join(" ")}`;
- }
- }
-
- this.sendRaw(serverId, command);
- }
-
- renameChannel(
- serverId: string,
- oldName: string,
- newName: string,
- reason?: string,
- ): void {
- const command = reason
- ? `RENAME ${oldName} ${newName} :${reason}`
- : `RENAME ${oldName} ${newName}`;
- this.sendRaw(serverId, command);
- }
-
- setName(serverId: string, realname: string): void {
- this.sendRaw(serverId, `SETNAME :${realname}`);
- }
-
- changeNick(serverId: string, newNick: string): void {
- this.sendRaw(serverId, `NICK ${newNick}`);
- }
-
- // Metadata commands
- metadataGet(serverId: string, target: string, keys: string[]): void {
- const keysStr = keys.join(" ");
- this.sendRaw(serverId, `METADATA ${target} GET ${keysStr}`);
- }
-
- metadataList(serverId: string, target: string): void {
- this.sendRaw(serverId, `METADATA ${target} LIST`);
- }
-
- metadataSet(
- serverId: string,
- target: string,
- key: string,
- value?: string,
- visibility?: string,
- ): void {
- // Use the provided target. If it's "*" or the current user's nickname, use "*"
- // Otherwise use the provided target (for channels, other users if admin, etc.)
- const currentNick = this.getNick(serverId);
- const actualTarget =
- target === "*" || target === currentNick ? "*" : target;
- const command =
- value !== undefined && value !== ""
- ? `METADATA ${actualTarget} SET ${key} :${value}`
- : `METADATA ${actualTarget} SET ${key}`;
- this.sendRaw(serverId, command);
- }
-
- metadataClear(serverId: string, target: string): void {
- this.sendRaw(serverId, `METADATA ${target} CLEAR`);
- }
-
- metadataSub(serverId: string, keys: string[]): void {
- // Send individual SUB commands for each key to avoid parsing issues
- keys.forEach((key) => {
- const command = `METADATA * SUB ${key}`;
- this.sendRaw(serverId, command);
- });
- }
-
- metadataUnsub(serverId: string, keys: string[]): void {
- const keysStr = keys.join(" ");
- this.sendRaw(serverId, `METADATA * UNSUB ${keysStr}`);
- }
-
- metadataSubs(serverId: string): void {
- this.sendRaw(serverId, "METADATA * SUBS");
- }
-
- metadataSync(serverId: string, target: string): void {
- this.sendRaw(serverId, `METADATA ${target} SYNC`);
- }
-
- // EXTJWT commands
- requestExtJwt(serverId: string, target?: string, serviceName?: string): void {
- // EXTJWT ( | * ) [service_name]
- const targetParam = target || "*";
- const command = serviceName
- ? `EXTJWT ${targetParam} ${serviceName}`
- : `EXTJWT ${targetParam}`;
- this.sendRaw(serverId, command);
- }
-
- // MONITOR commands
- monitorAdd(serverId: string, targets: string[]): void {
- const targetsStr = targets.join(",");
- this.sendRaw(serverId, `MONITOR + ${targetsStr}`);
- }
-
- monitorRemove(serverId: string, targets: string[]): void {
- const targetsStr = targets.join(",");
- this.sendRaw(serverId, `MONITOR - ${targetsStr}`);
- }
-
- monitorClear(serverId: string): void {
- this.sendRaw(serverId, "MONITOR C");
- }
-
- monitorList(serverId: string): void {
- this.sendRaw(serverId, "MONITOR L");
- }
-
- monitorStatus(serverId: string): void {
- this.sendRaw(serverId, "MONITOR S");
- }
-
- markChannelAsRead(serverId: string, channelId: string): void {
- const server = this.servers.get(serverId);
- const channel = server?.channels.find((c) => c.id === channelId);
- if (channel) channel.unreadCount = 0;
- }
-
- capAck(serverId: string, key: string, capabilities: string): void {
- this.triggerEvent("CAP_ACKNOWLEDGED", { serverId, key, capabilities });
- }
-
- capEnd(_serverId: string) {}
-
- isCapNegotiationComplete(serverId: string): boolean {
- return this.capNegotiationComplete.get(serverId) ?? false;
- }
-
- getNick(serverId: string): string | undefined {
- return this.nicks.get(serverId);
- }
-
- userOnConnect(serverId: string) {
- const nickname = this.nicks.get(serverId);
- if (!nickname) {
- console.error(`No nickname found for serverId ${serverId}`);
- return;
- }
- // NICK is already sent before CAP negotiation, only send USER now
- this.sendRaw(serverId, `USER ${nickname} 0 * :${nickname}`);
- }
-
- private handleMessage(data: string, serverId: string): void {
- const lines = data.split("\r\n");
- for (let line of lines) {
- let mtags: Record | undefined;
- let source: string;
- const parv: string[] = [];
- let i = 0;
- let l: string[];
- line = line.trim();
-
- // Skip empty lines
- if (!line) continue;
-
- console.log(`IRC Client: Received line from server ${serverId}: ${line}`);
-
- // Debug: Log ALL lines that contain CAP to see if CAP ACK is even being processed
- if (line.includes("CAP")) {
- }
-
- // Debug: Log all incoming IRC messages
-
- // Handle message tags first, before splitting on trailing parameter
- let lineAfterTags = line;
- if (line[0] === "@") {
- const spaceIndex = line.indexOf(" ");
- if (spaceIndex !== -1) {
- mtags = parseMessageTags(line.substring(0, spaceIndex));
- lineAfterTags = line.substring(spaceIndex + 1);
- }
- }
-
- // Parse IRC message properly handling colon-prefixed trailing parameter
- const spaceIndex = lineAfterTags.indexOf(" :");
- let trailing = "";
- let mainPart = lineAfterTags;
-
- if (spaceIndex !== -1) {
- trailing = lineAfterTags.substring(spaceIndex + 2); // Skip ' :'
- mainPart = lineAfterTags.substring(0, spaceIndex);
- }
-
- l = mainPart.split(" ").filter((part) => part.length > 0);
-
- // Ensure we have at least one element
- if (l.length === 0) continue;
-
- // Determine the source. if none, spoof as host server
- if (l[i][0] !== ":") {
- const thisServ = this.servers.get(serverId);
- const thisServName = thisServ?.name;
- if (!thisServName) {
- // something has gone horribly wrong
- return;
- }
- source = thisServName;
- } else {
- source = l[i].substring(1);
- i++;
- }
-
- const command = l[i];
- for (i++; l[i]; i++) {
- parv.push(l[i]);
- }
-
- // Add trailing parameter if it exists
- if (trailing) {
- parv.push(trailing);
- }
-
- // Debug: ALWAYS log when line contains @time and CAP
- if (line.includes("@time") && line.includes("CAP")) {
- }
-
- // Debug: log command and parv for CAP messages
- if (command === "CAP" || line.includes("CAP")) {
- }
-
- // Debug: for message tags, show what l array looks like
- if (line.includes("@time") && line.includes("CAP")) {
- }
-
- const parc = parv.length;
-
- if (command === "PING") {
- const key = parv.join(" ");
- this.sendRaw(serverId, `PONG :${key}`);
- } else if (command === "PONG") {
- // Clear pong timeout since we received a response
- const pongTimeout = this.pongTimeouts.get(serverId);
- if (pongTimeout) {
- clearTimeout(pongTimeout);
- this.pongTimeouts.delete(serverId);
- }
- } else if (command === "ERROR") {
- // Server is closing the connection - let onclose handler handle reconnection
- const errorMessage = parv.join(" ");
- console.log(`IRC ERROR from server ${serverId}: ${errorMessage}`);
-
- // Don't close the socket here, let the server close it and onclose handle reconnection
- } else if (command === "001") {
- const serverName = source;
- const nickname = parv[0]; // Our actual nick as assigned by the server
-
- // Update our stored nick to match what the server assigned us
- this.nicks.set(serverId, nickname);
-
- // Update current user's username to match server-assigned nick
- const currentUser = this.currentUsers.get(serverId);
- if (currentUser) {
- this.currentUsers.set(serverId, {
- ...currentUser,
- username: nickname,
- });
- }
-
- this.triggerEvent("ready", { serverId, serverName, nickname });
-
- // Rejoin channels if this is a reconnection (server already has channels)
- const server = this.servers.get(serverId);
- if (server) {
- console.log(
- `Server ${serverId} has ${server.channels.length} channels:`,
- server.channels.map((c) => c.name),
- );
- if (server.channels.length > 0) {
- console.log(
- `Rejoining ${server.channels.length} channels after reconnection:`,
- server.channels.map((c) => c.name),
- );
- for (const channel of server.channels) {
- console.log(`Sending JOIN for channel: ${channel.name}`);
- this.sendRaw(serverId, `JOIN ${channel.name}`);
- }
- } else {
- console.log(`No channels to rejoin for server ${serverId}`);
- }
- } else {
- console.log(`Server ${serverId} not found for rejoining channels`);
- }
- } else if (command === "NICK") {
- const oldNick = getNickFromNuh(source);
- let newNick = parv[0];
-
- // Remove leading colon if present
- if (newNick.startsWith(":")) {
- newNick = newNick.substring(1);
- }
-
- // We changed our own nick
- if (oldNick === this.nicks.get(serverId)) {
- this.nicks.set(serverId, newNick);
- // Update current user's username for this server
- const currentUser = this.currentUsers.get(serverId);
- if (currentUser) {
- this.currentUsers.set(serverId, {
- ...currentUser,
- username: newNick,
- });
- }
- }
-
- this.triggerEvent("NICK", {
- serverId,
- mtags,
- oldNick,
- newNick,
- });
- } else if (command === "QUIT") {
- const username = getNickFromNuh(source);
- const reason = parv.join(" ");
- this.triggerEvent("QUIT", {
- serverId,
- username,
- reason,
- batchTag: mtags?.batch,
- });
- } else if (command === "AWAY") {
- // AWAY command for away-notify extension
- // Format: :nick!user@host AWAY :away message
- // or: :nick!user@host AWAY (when user returns)
- const username = getNickFromNuh(source);
- const awayMessage = parv.length > 0 ? parv.join(" ") : undefined;
- this.triggerEvent("AWAY", {
- serverId,
- username,
- awayMessage,
- });
- } else if (command === "CHGHOST") {
- // CHGHOST command for chghost extension
- // Format: :nick!old_user@old_host CHGHOST new_user new_host
- const username = getNickFromNuh(source);
- const newUser = parv[0];
- const newHost = parv[1];
- this.triggerEvent("CHGHOST", {
- serverId,
- username,
- newUser,
- newHost,
- });
- } else if (command === "JOIN") {
- const username = getNickFromNuh(source);
- const channelName = parv[0][0] === ":" ? parv[0].substring(1) : parv[0];
-
- // Extended-join format: JOIN #channel account :realname
- // Standard join format: JOIN #channel
- let account: string | undefined;
- let realname: string | undefined;
-
- if (parv.length >= 2) {
- // Extended-join is enabled
- account = parv[1] === "*" ? undefined : parv[1]; // * means no account
- if (parv.length >= 3) {
- realname = parv.slice(2).join(" ");
- }
- }
-
- this.triggerEvent("JOIN", {
- serverId,
- username,
- channelName,
- batchTag: mtags?.batch,
- account,
- realname,
- });
- } else if (command === "PART") {
- const username = getNickFromNuh(source);
- const channelName = parv[0];
- parv[0] = "";
- const reason = parv.join(" ").trim();
- this.triggerEvent("PART", {
- serverId,
- username,
- channelName,
- reason,
- });
- } else if (command === "KICK") {
- const username = getNickFromNuh(source);
- const channelName = parv[0];
- const target = parv[1];
- parv[0] = "";
- parv[1] = "";
- const reasonText = parv.join(" ").trim();
- const reason = reasonText.startsWith(":")
- ? reasonText.substring(1)
- : reasonText;
- this.triggerEvent("KICK", {
- serverId,
- mtags,
- username,
- channelName,
- target,
- reason,
- });
- } else if (command === "MODE") {
- const sender = getNickFromNuh(source);
- const target = parv[0];
- const modestring = parv[1] || "";
- const modeargs = parv.slice(2);
- this.triggerEvent("MODE", {
- serverId,
- mtags,
- sender,
- target,
- modestring,
- modeargs,
- });
- } else if (command === "INVITE") {
- // Handle invite-notify capability
- // Format: : INVITE
- const inviter = getNickFromNuh(source);
- const target = parv[0];
- const channel = parv[1];
- this.triggerEvent("INVITE", {
- serverId,
- mtags,
- inviter,
- target,
- channel,
- });
- } else if (command === "PRIVMSG") {
- const target = parv[0];
- const isChannel = target.startsWith("#");
- const sender = getNickFromNuh(source);
-
- // Message content is in parv[1] and onwards after target
- const message = parv.slice(1).join(" ");
-
- // Check if this message is part of a multiline batch
- const batchId = mtags?.batch;
- if (batchId) {
- const serverBatches = this.activeBatches.get(serverId);
- const batch = serverBatches?.get(batchId);
- if (
- batch &&
- (batch.type === "multiline" || batch.type === "draft/multiline")
- ) {
- // Add this message line to the batch
- batch.messages.push(message);
-
- // Store sender from the first message
- if (!batch.sender) {
- batch.sender = sender;
- }
-
- // Track message IDs for redaction
- if (mtags?.msgid && batch.messageIds) {
- batch.messageIds.push(mtags.msgid);
- }
-
- // Track timestamps for proper ordering
- if (batch.timestamps) {
- batch.timestamps.push(getTimestampFromTags(mtags));
- }
-
- // Track if this message has the concat flag
- const hasMultilineConcat =
- mtags && mtags["draft/multiline-concat"] !== undefined;
- if (batch.concatFlags) {
- batch.concatFlags.push(!!hasMultilineConcat);
- }
-
- return; // Don't trigger individual message event, wait for batch completion
- }
- }
-
- if (isChannel) {
- const channelName = target;
- this.triggerEvent("CHANMSG", {
- serverId,
- mtags,
- sender,
- channelName,
- message,
- timestamp: getTimestampFromTags(mtags),
- });
- } else {
- this.triggerEvent("USERMSG", {
- serverId,
- mtags,
- sender,
- target, // The recipient of the PRIVMSG
- message,
- timestamp: getTimestampFromTags(mtags),
- });
- }
- } else if (command === "NOTICE") {
- const target = parv[0];
- const isChannel = target.startsWith("#");
- const sender = getNickFromNuh(source);
-
- // The message content is now properly parsed as the trailing parameter
- const message = trailing || parv.slice(1).join(" ");
-
- if (isChannel) {
- const channelName = target;
- this.triggerEvent("CHANNNOTICE", {
- serverId,
- mtags,
- sender,
- channelName,
- message,
- timestamp: getTimestampFromTags(mtags),
- });
- } else {
- this.triggerEvent("USERNOTICE", {
- serverId,
- mtags,
- sender,
- message,
- timestamp: getTimestampFromTags(mtags),
- });
- }
- } else if (command === "TAGMSG") {
- const rawTarget = parv[0] || "";
- const target = rawTarget.startsWith(":")
- ? rawTarget.substring(1)
- : rawTarget;
- const sender = getNickFromNuh(source);
- this.triggerEvent("TAGMSG", {
- serverId,
- mtags,
- sender,
- channelName: target,
- timestamp: getTimestampFromTags(mtags),
- });
- } else if (command === "REDACT") {
- const target = parv[0];
- const msgid = parv[1];
- const reason = parv[2] ? parv[2].substring(1) : ""; // Remove leading :
- const sender = getNickFromNuh(source);
- this.triggerEvent("REDACT", {
- serverId,
- mtags,
- target,
- msgid,
- reason,
- sender,
- });
- } else if (command === "RENAME") {
- const user = getNickFromNuh(source);
- const oldName = parv[0];
- const newName = parv[1];
- const reason = parv.slice(2).join(" "); // No need to remove leading : anymore
- this.triggerEvent("RENAME", {
- serverId,
- oldName,
- newName,
- reason,
- user,
- });
- } else if (command === "SETNAME") {
- const user = getNickFromNuh(source);
- const realname = parv.join(" "); // No need to remove leading : anymore
- this.triggerEvent("SETNAME", {
- serverId,
- user,
- realname,
- });
- } else if (command === "353") {
- const channelName = parv[2];
- const namesStr = parv.slice(3).join(" ").trim();
- const names = namesStr.startsWith(":")
- ? namesStr.substring(1)
- : namesStr;
- const newUsers = parseNamesResponse(names); // Parse the user list
-
- // Trigger an event to notify the UI
- this.triggerEvent("NAMES", {
- serverId,
- channelName,
- users: newUsers,
- });
- } else if (command === "381") {
- // RPL_YOUREOPER - You are now an IRC Operator
- const message = parv.slice(1).join(" ");
- this.triggerEvent("RPL_YOUREOPER", {
- serverId,
- message,
- });
- } else if (command === "002") {
- // RPL_YOURHOST - Your host is , running version
- const message = parv.slice(1).join(" ");
- // Parse the message: "Your host is , running version "
- const match = message.match(
- /Your host is ([^,]+), running version (.+)/,
- );
- if (match) {
- const serverName = match[1];
- const version = match[2];
- this.triggerEvent("RPL_YOURHOST", {
- serverId,
- serverName,
- version,
- });
- }
- } else if (command === "324") {
- // RPL_CHANNELMODEIS - Channel mode response
- const channelName = parv[1];
- const modestring = parv[2] || "";
- const modeargs = parv.slice(3);
- this.triggerEvent("RPL_CHANNELMODEIS", {
- serverId,
- channelName,
- modestring,
- modeargs,
- });
- } else if (command === "CAP") {
- console.log(
- `[CAP] Processing CAP command, parv: ${JSON.stringify(parv)}, trailing: "${trailing}"`,
- );
- console.log(`[CAP] Received CAP message: ${parv.join(" ")}`);
- console.log(`[CAP] Full parv array: ${JSON.stringify(parv)}`);
- console.log(`[CAP] Trailing parameter: "${trailing}"`);
- let i = 0;
- let caps = "";
- if (parv[i] === "*") {
- i++;
- }
- let subcommand = parv[i++];
- console.log(
- `[CAP] Subcommand: '${subcommand}', i after increment: ${i}, parv length: ${parv.length}`,
- );
- // Handle CAP ACK which has nickname before subcommand
- if (
- subcommand !== "LS" &&
- subcommand !== "ACK" &&
- subcommand !== "NEW" &&
- subcommand !== "DEL" &&
- subcommand !== "NAK"
- ) {
- // This is likely a nickname, skip it and get the real subcommand
- subcommand = parv[i++];
- }
- const isFinal = subcommand === "LS" && parv[i] !== "*";
- if (parv[i] === "*") i++;
-
- // Build caps string - use trailing parameter if available, otherwise join remaining parv
- if (trailing) {
- caps = trailing;
- } else {
- while (parv[i]) {
- caps += parv[i++];
- if (parv[i]) caps += " ";
- }
- }
-
- console.log(`[CAP] Final caps string: "${caps}"`);
-
- if (subcommand === "LS") this.onCapLs(serverId, caps, isFinal);
- else if (subcommand === "ACK") {
- this.onCapAck(serverId, caps);
- } else if (subcommand === "NAK") {
- // Server rejected some capabilities, but we should still end CAP negotiation
- this.sendRaw(serverId, "CAP END");
- this.capNegotiationComplete.set(serverId, true);
- } else if (subcommand === "NEW") this.onCapNew(serverId, caps);
- else if (subcommand === "DEL") this.onCapDel(serverId, caps);
- else {
- }
- } else if (command === "005") {
- const capabilities = parseIsupport(parv.join(" "));
- for (const [key, value] of Object.entries(capabilities)) {
- if (key === "NETWORK") {
- const server = this.servers.get(serverId);
- if (server) {
- server.networkName = value;
- this.servers.set(serverId, server);
- }
- }
- this.triggerEvent("ISUPPORT", { serverId, key, value });
- }
- } else if (command === "AUTHENTICATE") {
- const param = parv.join(" ");
- this.triggerEvent("AUTHENTICATE", { serverId, param });
- } else if (command === "BATCH") {
- // BATCH +reference-tag type [parameters...] or BATCH -reference-tag
- const batchRef = parv[0];
- const isStart = batchRef.startsWith("+");
- const batchId = batchRef.substring(1); // Remove + or -
-
- if (isStart) {
- const batchType = parv[1];
- const parameters = parv.slice(2);
-
- // Initialize batch tracking for this server if not exists
- if (!this.activeBatches.has(serverId)) {
- this.activeBatches.set(serverId, new Map());
- }
-
- // Track this batch
- this.activeBatches.get(serverId)?.set(batchId, {
- type: batchType,
- parameters,
- messages: [],
- timestamps: [],
- concatFlags: [],
- messageIds: [],
- batchMsgId: mtags?.msgid, // Store the msgid from the BATCH command itself
- batchTime: mtags?.time ? new Date(mtags.time) : undefined, // Store the time from the BATCH command
- });
-
- this.triggerEvent("BATCH_START", {
- serverId,
- batchId,
- type: batchType,
- parameters,
- });
- } else {
- // Process completed batch
- const serverBatches = this.activeBatches.get(serverId);
- const batch = serverBatches?.get(batchId);
-
- if (
- batch &&
- (batch.type === "multiline" || batch.type === "draft/multiline")
- ) {
- // Handle completed multiline batch
- // For multiline batches, parameters[0] is the target, sender comes from the PRIVMSG lines
- const target =
- batch.parameters && batch.parameters.length > 0
- ? batch.parameters[0]
- : "";
- const sender = batch.sender || "unknown";
-
- // Combine messages, handling draft/multiline-concat tags
- let combinedMessage = "";
- batch.messages.forEach((message, index) => {
- const wasConcat = batch.concatFlags?.[index];
-
- if (index === 0) {
- combinedMessage = message;
- } else {
- // Check if this message was tagged with draft/multiline-concat
- if (wasConcat) {
- // Concatenate directly without separator
- combinedMessage += message;
- } else {
- // Join with newline (normal multiline)
- combinedMessage += `\n${message}`;
- }
- }
- });
-
- this.triggerEvent("MULTILINE_MESSAGE", {
- serverId,
- mtags: batch.batchMsgId ? { msgid: batch.batchMsgId } : undefined, // Use the msgid from the BATCH command
- sender,
- channelName: target.startsWith("#") ? target : undefined,
- message: combinedMessage,
- lines: batch.messages,
- messageIds: batch.messageIds || [],
- timestamp:
- batch.batchTime ||
- (batch.timestamps && batch.timestamps.length > 0
- ? new Date(
- Math.min(...batch.timestamps.map((t) => t.getTime())),
- )
- : getTimestampFromTags(mtags)),
- });
- }
-
- // Clean up batch tracking
- serverBatches?.delete(batchId);
-
- this.triggerEvent("BATCH_END", {
- serverId,
- batchId,
- });
- }
- } else if (command === "METADATA") {
- // METADATA PARAM1 PARAM2 [PARAM3 PARAM4 etc optional params] :the actual value
- // The trailing value is the last parameter, optional params can be between PARAM2 and value
- const target = parv[0]; // PARAM1
- const key = parv[1]; // PARAM2
-
- // The actual value is the last parameter (trailing parameter from original message)
- const value = parv[parv.length - 1] || "";
-
- // Everything between key and value are optional parameters (visibility, etc.)
- const optionalParams = parv.length > 2 ? parv.slice(2, -1) : [];
-
- // For backward compatibility, assume first optional param is visibility if present
- const visibility = optionalParams.length > 0 ? optionalParams[0] : "";
-
- this.triggerEvent("METADATA", {
- serverId,
- target,
- key,
- visibility,
- value,
- });
- } else if (command === "760") {
- // RPL_WHOISKEYVALUE
- // RPL_WHOISKEYVALUE :
- const target = parv[0];
- const key = parv[1];
- const visibility = parv[2];
- const value = parv.slice(3).join(" "); // No need to remove leading : anymore
- this.triggerEvent("METADATA_WHOIS", {
- serverId,
- target,
- key,
- visibility,
- value,
- });
- } else if (command === "761") {
- // RPL_KEYVALUE
- // Format: 761 :
- const recipient = parv[0]; // The user receiving this message (usually current user)
- const target = parv[1]; // The user whose metadata this is
- let key = parv[2];
- let visibility = parv[3];
- let valueStartIndex = 4;
-
- // If target is duplicated (server bug), adjust parsing
- if (parv[1] === parv[2] && parv.length > 5) {
- key = parv[3];
- visibility = parv[4];
- valueStartIndex = 5;
- }
-
- const value = parv.slice(valueStartIndex).join(" ");
- // Remove leading ":" if present
- const cleanValue = value.startsWith(":") ? value.substring(1) : value;
-
- this.triggerEvent("METADATA_KEYVALUE", {
- serverId,
- target,
- key,
- visibility,
- value: cleanValue,
- });
- } else if (command === "766") {
- // RPL_KEYNOTSET
- // RPL_KEYNOTSET :key not set
- const target = parv[0];
- const key = parv[1];
- this.triggerEvent("METADATA_KEYNOTSET", { serverId, target, key });
- } else if (command === "770") {
- // RPL_METADATASUBOK
- // Format: 770 [ ...]
- const target = parv[0];
- const keys = parv
- .slice(1)
- .map((key) => (key.startsWith(":") ? key.substring(1) : key));
- this.triggerEvent("METADATA_SUBOK", { serverId, keys });
- } else if (command === "771") {
- // RPL_METADATAUNSUBOK
- // Format: 771 [ ...]
- const target = parv[0];
- const keys = parv
- .slice(1)
- .map((key) => (key.startsWith(":") ? key.substring(1) : key));
- this.triggerEvent("METADATA_UNSUBOK", { serverId, keys });
- } else if (command === "772") {
- // RPL_METADATASUBS
- // Format: 772 [ ...]
- const target = parv[0];
- const keys = parv
- .slice(1)
- .map((key) => (key.startsWith(":") ? key.substring(1) : key));
- this.triggerEvent("METADATA_SUBS", { serverId, keys });
- } else if (command === "774") {
- // RPL_METADATASYNCLATER
- // RPL_METADATASYNCLATER []
- const target = parv[0];
- const retryAfter = parv[1] ? Number.parseInt(parv[1], 10) : undefined;
- this.triggerEvent("METADATA_SYNCLATER", {
- serverId,
- target,
- retryAfter,
- });
- } else if (command === "730") {
- // RPL_MONONLINE
- // Format: 730 :target[!user@host][,target[!user@host]]*
- const targetList = parv.slice(1).join(" ");
- const cleanTargetList = targetList.startsWith(":")
- ? targetList.substring(1)
- : targetList;
- const targets = cleanTargetList.split(",").map((target) => {
- const parts = target.split("!");
- if (parts.length === 2) {
- const [nick, userhost] = parts;
- const [user, host] = userhost.split("@");
- return { nick, user, host };
- }
- return { nick: target };
- });
- this.triggerEvent("MONONLINE", { serverId, targets });
- } else if (command === "731") {
- // RPL_MONOFFLINE
- // Format: 731 :target[,target2]*
- const targetList = parv.slice(1).join(" ");
- const cleanTargetList = targetList.startsWith(":")
- ? targetList.substring(1)
- : targetList;
- const targets = cleanTargetList.split(",");
- this.triggerEvent("MONOFFLINE", { serverId, targets });
- } else if (command === "732") {
- // RPL_MONLIST
- // Format: 732 :target[,target2]*
- const targetList = parv.slice(1).join(" ");
- const cleanTargetList = targetList.startsWith(":")
- ? targetList.substring(1)
- : targetList;
- const targets = cleanTargetList.split(",");
- this.triggerEvent("MONLIST", { serverId, targets });
- } else if (command === "733") {
- // RPL_ENDOFMONLIST
- this.triggerEvent("ENDOFMONLIST", { serverId });
- } else if (command === "734") {
- // ERR_MONLISTFULL
- // Format: 734 :Monitor list is full.
- const limit = Number.parseInt(parv[1], 10);
- const targetList = parv[2];
- const targets = targetList.split(",");
- this.triggerEvent("MONLISTFULL", { serverId, limit, targets });
- } else if (command === "FAIL" && parv[0] === "METADATA") {
- // FAIL METADATA [] [] [] :[]
- // ERR_METADATATOOMANY, ERR_METADATATARGETINVALID, ERR_METADATANOACCESS, ERR_METADATANOKEY, ERR_METADATARATELIMITED
- const subcommand = parv[1]; // The METADATA subcommand that failed (SUB, SET, etc.)
- const code = parv[2]; // The error code
-
- // Check if the last parameter is a trailing message (starts with original ":")
- // If so, the parameters before it are the optional params
- let paramCount = parv.length;
- let errorMessage = "";
-
- // If there are more than 3 params and the last one doesn't look like a number,
- // it's likely a trailing error message
- if (paramCount > 3) {
- const lastParam = parv[paramCount - 1];
- if (lastParam && Number.isNaN(Number.parseInt(lastParam, 10))) {
- errorMessage = lastParam;
- paramCount = paramCount - 1; // Don't count the error message as a regular param
- }
- }
-
- let target: string | undefined;
- let key: string | undefined;
- let retryAfter: number | undefined;
-
- if (paramCount > 3) target = parv[3];
- if (paramCount > 4) key = parv[4];
- if (paramCount > 5 && code === "RATE_LIMITED") {
- retryAfter = Number.parseInt(parv[5], 10);
- }
-
- this.triggerEvent("METADATA_FAIL", {
- serverId,
- subcommand,
- code,
- target,
- key,
- retryAfter,
- });
- } else if (command === "322") {
- // RPL_LIST: :
- const channelName = parv[1];
- const userCount = parv[2] ? Number.parseInt(parv[2], 10) : 0;
- const topic = parv.slice(3).join(" "); // No need to remove leading : anymore
- this.triggerEvent("LIST_CHANNEL", {
- serverId,
- channel: channelName,
- userCount,
- topic,
- });
- } else if (command === "323") {
- // RPL_LISTEND
- this.triggerEvent("LIST_END", { serverId });
- } else if (command === "352") {
- // RPL_WHOREPLY: :
- // Note: hopcount and realname are in the trailing parameter together
- const channel = parv[1];
- const username = parv[2];
- const host = parv[3];
- const server = parv[4];
- const nick = parv[5];
- const flags = parv[6];
-
- // Parse trailing which contains "hopcount realname"
- const trailing = parv[7] || "";
- const spaceIndex = trailing.indexOf(" ");
- let hopcount = trailing;
- let realname = "";
-
- if (spaceIndex !== -1) {
- hopcount = trailing.substring(0, spaceIndex);
- realname = trailing.substring(spaceIndex + 1);
- }
-
- this.triggerEvent("WHO_REPLY", {
- serverId,
- channel,
- username,
- host,
- server,
- nick,
- flags,
- hopcount,
- realname,
- });
- } else if (command === "354") {
- // RPL_WHOSPCRPL (WHOX): Response format depends on requested fields
- // Our request: WHO %cuhnfaro
- // Response order: channel, username, hostname, nickname, flags, account, realname, op_level
- // Example: 354 Valware #lobby ~u knqsza5faubzs.irc mattf H@ mattf * mattf
- // Fields returned in order: c=channel, u=username, h=hostname, n=nickname, f=flags, a=account, r=realname, o=op_level
- // Note: flags contains H/G (here/gone) followed by optional status symbols (@, +, etc) and other flags like * (IRC oper) or B (bot)
- const channel = parv[1];
- const username = parv[2];
- const host = parv[3];
- const nick = parv[4];
- const flags = parv[5];
- const account = parv[6];
- const opLevelField = parv[7] || "";
- const realname = parv[8] || ""; // May be empty if not returned
-
- // Determine if user is away from flags (G=gone/away, H=here/present)
- const isAway = flags.includes("G");
-
- // Extract op level from flags field (everything after H or G)
- // Flags format: H/G followed by status symbols like @, +, ~, %, &
- // Also may include * (IRC operator) and B (bot) which we need to filter out
- // Only keep valid channel status prefixes: @ + ~ % &
- let opLevel = "";
- if (flags.length > 1) {
- // Skip the first character (H or G)
- const statusPart = flags.substring(1);
- // Filter to only include valid channel prefixes
- opLevel = statusPart
- .split("")
- .filter((char) => ["@", "+", "~", "%", "&"].includes(char))
- .join("");
- }
-
- this.triggerEvent("WHOX_REPLY", {
- serverId,
- channel,
- username,
- host,
- nick,
- account,
- flags,
- realname,
- isAway,
- opLevel,
- });
- } else if (command === "305") {
- // RPL_UNAWAY: :
- // You are no longer marked as being away
- const message = parv.slice(1).join(" ");
- this.triggerEvent("RPL_UNAWAY", {
- serverId,
- message,
- });
- } else if (command === "306") {
- // RPL_NOWAWAY: :
- // You have been marked as being away
- const message = parv.slice(1).join(" ");
- this.triggerEvent("RPL_NOWAWAY", {
- serverId,
- message,
- });
- } else if (command === "301") {
- // RPL_AWAY: :
- // User is away
- const nick = parv[1];
- const awayMessage = parv.slice(2).join(" ");
- this.triggerEvent("RPL_AWAY", {
- serverId,
- nick,
- awayMessage,
- });
- } else if (command === "315") {
- // RPL_ENDOFWHO
- const mask = parv[1];
- this.triggerEvent("WHO_END", { serverId, mask });
- } else if (command === "335") {
- // RPL_WHOISBOT: :
- const nick = parv[0];
- const target = parv[1];
- const message = parv.slice(2).join(" "); // No need to remove leading : anymore
- this.triggerEvent("WHOIS_BOT", { serverId, nick, target, message });
- } else if (command === "431") {
- // ERR_NONICKNAMEGIVEN: :No nickname given
- const message = parv.join(" "); // No need to remove leading : anymore
- this.triggerEvent("NICK_ERROR", {
- serverId,
- code: "431",
- error: "No nickname given",
- message,
- });
- } else if (command === "900") {
- // RPL_LOGGEDIN: You are now logged in as
- // This comes before SASL completion, don't end CAP negotiation yet
- const message = parv.slice(2).join(" ");
- } else if (command === "901" || command === "902" || command === "903") {
- // SASL authentication successful
- const message = parv.slice(2).join(" ");
- // Finish capability negotiation
- this.sendRaw(serverId, "CAP END");
- this.capNegotiationComplete.set(serverId, true);
- this.userOnConnect(serverId);
- } else if (
- command === "904" ||
- command === "905" ||
- command === "906" ||
- command === "907"
- ) {
- // SASL authentication failed
- const message = parv.slice(2).join(" ");
- // Still finish capability negotiation even if SASL failed
- this.sendRaw(serverId, "CAP END");
- this.capNegotiationComplete.set(serverId, true);
- this.userOnConnect(serverId);
- } else if (command === "432") {
- // ERR_ERRONEUSNICKNAME: :Erroneous nickname
- const nick = parv[1];
- const message = parv.slice(2).join(" ").substring(1);
- this.triggerEvent("NICK_ERROR", {
- serverId,
- code: "432",
- error: "Invalid nickname",
- nick,
- message,
- });
- } else if (command === "433") {
- // ERR_NICKNAMEINUSE: :Nickname is already in use
- const nick = parv[1];
- const message = parv.slice(2).join(" ").substring(1);
- this.triggerEvent("NICK_ERROR", {
- serverId,
- code: "433",
- error: "Nickname already in use",
- nick,
- message,
- });
- } else if (command === "436") {
- // ERR_NICKCOLLISION: :Nickname collision KILL from @
- const nick = parv[1];
- const message = parv.slice(2).join(" ").substring(1);
- this.triggerEvent("NICK_ERROR", {
- serverId,
- code: "436",
- error: "Nickname collision",
- nick,
- message,
- });
- } else if (command === "FAIL") {
- // Standard replies: FAIL :
- const cmd = parv[0];
- const code = parv[1];
- const target = parv[2] || undefined;
- const message = parv.slice(3).join(" ").substring(1); // Remove leading :
- this.triggerEvent("FAIL", {
- serverId,
- mtags,
- command: cmd,
- code,
- target,
- message,
- });
- } else if (command === "WARN") {
- // Standard replies: WARN :
- const cmd = parv[0];
- const code = parv[1];
- const target = parv[2] || undefined;
- const message = parv.slice(3).join(" ").substring(1); // Remove leading :
- this.triggerEvent("WARN", {
- serverId,
- mtags,
- command: cmd,
- code,
- target,
- message,
- });
- } else if (command === "NOTE") {
- // Standard replies: NOTE :
- const cmd = parv[0];
- const code = parv[1];
- const target = parv[2] || undefined;
- const message = parv.slice(3).join(" ").substring(1); // Remove leading :
- this.triggerEvent("NOTE", {
- serverId,
- mtags,
- command: cmd,
- code,
- target,
- message,
- });
- } else if (command === "SUCCESS") {
- // Standard replies: SUCCESS :
- const cmd = parv[0];
- const code = parv[1];
- const target = parv[2] || undefined;
- const message = parv.slice(3).join(" ").substring(1); // Remove leading :
- this.triggerEvent("SUCCESS", {
- serverId,
- mtags,
- command: cmd,
- code,
- target,
- message,
- });
- } else if (command === "REGISTER") {
- // Account registration responses
- const subcommand = parv[0];
- if (subcommand === "SUCCESS") {
- const account = parv[1];
- const message = parv.slice(2).join(" ").substring(1);
- this.triggerEvent("REGISTER_SUCCESS", {
- serverId,
- mtags,
- account,
- message,
- });
- } else if (subcommand === "VERIFICATION_REQUIRED") {
- const account = parv[1];
- const message = parv.slice(2).join(" ").substring(1);
- this.triggerEvent("REGISTER_VERIFICATION_REQUIRED", {
- serverId,
- mtags,
- account,
- message,
- });
- }
- } else if (command === "VERIFY") {
- // Account verification responses
- const subcommand = parv[0];
- if (subcommand === "SUCCESS") {
- const account = parv[1];
- const message = parv.slice(2).join(" ").substring(1);
- }
- } else if (command === "367") {
- // RPL_BANLIST:
- const channel = parv[1];
- const mask = parv[2];
- const setter = parv[3];
- const timestamp = Number.parseInt(parv[4], 10);
- console.log(
- `IRC Client: RPL_BANLIST parsed - channel: ${channel}, mask: ${mask}, setter: ${setter}, timestamp: ${timestamp}`,
- );
- this.triggerEvent("RPL_BANLIST", {
- serverId,
- channel,
- mask,
- setter,
- timestamp,
- });
- } else if (command === "346") {
- // RPL_INVITELIST: