@openclaw/irc 2026.11.3 → 2026.11.5-beta.2

package/dist/.setup/channel-plugin-api-WXJUjGsf.mjs

@@ -0,0 +1,2 @@
+export { t as ircPlugin } from "./channel-DgvKz42q.mjs";
+import "../channel-plugin-api.js";

package/dist/.setup/channel-runtime-D4vKt7TE.mjs

@@ -0,0 +1,582 @@
+import { a as buildIrcConnectOptions, c as parseIrcPrefix, d as sanitizeIrcAssistantText, f as createIrcIngressSubject, h as normalizeIrcAllowEntry, i as sendMessageIrc, l as resolveIrcGroupMatch, m as isChannelTarget, o as connectIrcClient, p as ircIngressIdentity, s as parseIrcLine, u as resolveIrcGroupRequireMention, y as resolveIrcAccount } from "./channel-DgvKz42q.mjs";
+import { t as getIrcRuntime } from "./runtime-C_V9tmpk.mjs";
+import { channelIngressRoutes } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { bindIngressLifecycleToReplyOptions, createChannelIngressError, createChannelIngressMonitor, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
+import { computeBackoff } from "openclaw/plugin-sdk/runtime-env";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createChannelInboundEnvelopeBuilderAsync, logInboundDrop } from "openclaw/plugin-sdk/channel-inbound";
+import { resolveLoggerBackedRuntime } from "openclaw/plugin-sdk/extension-shared";
+import { randomUUID } from "node:crypto";
+import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
+import { createChannelPairingController } from "openclaw/plugin-sdk/channel-pairing";
+import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
+import { channelReadyPatch } from "openclaw/plugin-sdk/gateway-runtime";
+import { deliverFormattedTextWithAttachments } from "openclaw/plugin-sdk/reply-payload";
+import { GROUP_POLICY_BLOCKED_LABEL, resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
+import { escapeRegExp } from "openclaw/plugin-sdk/text-utility-runtime";
+//#region extensions/irc/src/irc-ingress.ts
+const IRC_INGRESS_PAYLOAD_VERSION = 1;
+const IRC_INGRESS_POLL_INTERVAL_MS = 1e3;
+const IrcIngressPayloadError = createChannelIngressError("IrcIngressPayloadError");
+function inspectRawPrivmsg(rawLine) {
+	const line = parseIrcLine(rawLine);
+	if (!line || line.command !== "PRIVMSG") throw new IrcIngressPayloadError("IRC ingress row is not a PRIVMSG line.");
+	const rawTarget = line.params[0]?.trim() ?? "";
+	const text = line.trailing ?? line.params[1] ?? "";
+	const prefix = parseIrcPrefix(line.prefix);
+	const senderNick = prefix.nick?.trim() ?? "";
+	if (!rawTarget || !senderNick || !text.trim()) throw new IrcIngressPayloadError("IRC PRIVMSG line is missing target, sender, or text.");
+	const isGroup = isChannelTarget(rawTarget);
+	const target = isGroup ? rawTarget : senderNick;
+	const lanePeer = normalizeLowercaseStringOrEmpty(target);
+	return {
+		laneKey: `${isGroup ? "channel" : "direct"}:${lanePeer}`,
+		message: {
+			target,
+			rawTarget,
+			senderNick,
+			senderUser: prefix.user?.trim() || void 0,
+			senderHost: prefix.host?.trim() || void 0,
+			text,
+			isGroup
+		}
+	};
+}
+function decodeIrcIngressPayload(payload, claimedId) {
+	if (!payload || typeof payload !== "object" || Array.isArray(payload) || typeof payload.eventId !== "string" || !Number.isSafeInteger(payload.receivedAt) || (payload.receivedAt ?? 0) <= 0 || typeof payload.connectionEpoch !== "string" || !payload.connectionEpoch?.trim() || typeof payload.connectedNick !== "string" || !payload.connectedNick?.trim() || typeof payload.rawLine !== "string") throw new IrcIngressPayloadError(`IRC ingress row ${claimedId} has invalid metadata.`);
+	const validPayload = payload;
+	return {
+		version: validPayload.version,
+		body: {
+			eventId: validPayload.eventId,
+			receivedAt: validPayload.receivedAt,
+			connectionEpoch: validPayload.connectionEpoch,
+			connectedNick: validPayload.connectedNick,
+			rawLine: validPayload.rawLine
+		}
+	};
+}
+function inspectIrcIngress(raw, phase) {
+	try {
+		const projection = inspectRawPrivmsg(raw.body.rawLine);
+		if (phase === "claim") raw.claimedProjection = projection;
+		return {
+			eventId: raw.body.eventId,
+			laneKey: projection.laneKey
+		};
+	} catch (error) {
+		if (phase === "admission" && error instanceof IrcIngressPayloadError) return {
+			eventId: raw.body.eventId,
+			laneKey: `invalid:${raw.body.eventId}`
+		};
+		throw error;
+	}
+}
+function resolveIrcIngressNonRetryableFailure(error) {
+	return error instanceof IrcIngressPayloadError ? {
+		reason: "invalid-event",
+		message: error.message
+	} : null;
+}
+function createIrcIngressMonitor(options) {
+	const monitor = createChannelIngressMonitor({
+		queue: () => getIrcRuntime().state.openChannelIngressQueue({ accountId: options.accountId }),
+		inspect: (raw, context) => inspectIrcIngress(raw, context.phase),
+		payload: {
+			version: IRC_INGRESS_PAYLOAD_VERSION,
+			serialize: (raw) => raw.body,
+			deserialize: (body) => ({ body }),
+			encode: ({ body }) => ({
+				version: IRC_INGRESS_PAYLOAD_VERSION,
+				...body
+			}),
+			decode: (payload, { claim }) => decodeIrcIngressPayload(payload, claim.id),
+			createClaimError: (_kind, claim) => new IrcIngressPayloadError(`IRC ingress row ${claim.id} has invalid metadata.`)
+		},
+		deliver: (raw, lifecycle, claim) => {
+			const message = {
+				...raw.claimedProjection.message,
+				messageId: claim.id,
+				timestamp: raw.body.receivedAt
+			};
+			return options.dispatch(message, lifecycle, {
+				connectedNick: raw.body.connectedNick.trim(),
+				connectionEpoch: raw.body.connectionEpoch.trim()
+			});
+		},
+		pollIntervalMs: IRC_INGRESS_POLL_INTERVAL_MS,
+		retention: {
+			completedMaxEntries: 1e3,
+			failedMaxEntries: 1e3
+		},
+		drain: {
+			resolveNonRetryableFailure: resolveIrcIngressNonRetryableFailure,
+			onLog: (message) => options.runtime.log?.(`irc ${message}`)
+		},
+		createStoppedError: () => /* @__PURE__ */ new Error("IRC ingress is stopped."),
+		onError: (error) => options.runtime.error?.(`irc ingress drain failed: ${String(error)}`)
+	});
+	return {
+		openConnection: (connectionEpoch = randomUUID()) => {
+			const epoch = connectionEpoch.trim();
+			if (!epoch) throw new Error("IRC ingress connection epoch is required.");
+			let sequence = 0;
+			return {
+				connectionEpoch: epoch,
+				accept: (rawLine, connectedNick) => {
+					if (monitor.isStopped()) return Promise.reject(/* @__PURE__ */ new Error("IRC ingress is stopped."));
+					sequence += 1;
+					const eventId = `local:${epoch}:${String(sequence).padStart(12, "0")}`;
+					const receivedAt = Date.now();
+					const normalizedNick = connectedNick.trim();
+					if (!normalizedNick) return Promise.reject(/* @__PURE__ */ new Error("IRC ingress connected nickname is required."));
+					return monitor.admit({ body: {
+						eventId,
+						rawLine,
+						receivedAt,
+						connectionEpoch: epoch,
+						connectedNick: normalizedNick
+					} }, { receivedAt }).then(() => void 0);
+				}
+			};
+		},
+		start: monitor.start,
+		pause: monitor.pause,
+		stop: monitor.stop,
+		waitForIdle: monitor.waitForIdle
+	};
+}
+//#endregion
+//#region extensions/irc/src/reconnect-backoff.ts
+const IRC_RECONNECT_BACKOFF = {
+	initialMs: 1e3,
+	maxMs: 3e4,
+	factor: 2,
+	jitter: .2
+};
+const IRC_RECONNECT_STABLE_MS = 6e4;
+function createIrcReconnectBackoff() {
+	let attempt = 0;
+	let connectedAt;
+	return {
+		markConnected: () => {
+			connectedAt = Date.now();
+		},
+		nextDelayMs: () => {
+			if (connectedAt !== void 0 && Date.now() - connectedAt >= IRC_RECONNECT_STABLE_MS) attempt = 0;
+			connectedAt = void 0;
+			attempt += 1;
+			return computeBackoff(IRC_RECONNECT_BACKOFF, attempt);
+		}
+	};
+}
+//#endregion
+//#region extensions/irc/src/monitor.ts
+const CHANNEL_ID = "irc";
+const IRC_NICK_CHARACTER = String.raw`[A-Za-z0-9_\-\[\]\\\x60^{}|~]`;
+const IRC_RFC1459_CASE_EQUIVALENTS = /* @__PURE__ */ new Map([
+	["[", "{"],
+	["{", "["],
+	["]", "}"],
+	["}", "]"],
+	["\\", "|"],
+	["|", "\\"],
+	["^", "~"],
+	["~", "^"]
+]);
+function buildIrcNickMentionPattern(value) {
+	return Array.from(value, (character) => {
+		const equivalent = IRC_RFC1459_CASE_EQUIVALENTS.get(character);
+		return equivalent ? `[${escapeRegExp(character)}${escapeRegExp(equivalent)}]` : escapeRegExp(character);
+	}).join("");
+}
+function hasEntries(entries) {
+	return normalizeStringEntries(entries).some((entry) => normalizeIrcAllowEntry(entry));
+}
+async function monitorIrcProvider(opts) {
+	const core = getIrcRuntime();
+	const cfg = opts.config ?? core.config.current();
+	const account = resolveIrcAccount({
+		cfg,
+		accountId: opts.accountId
+	});
+	const runtime = resolveLoggerBackedRuntime(opts.runtime, core.logging.getChildLogger());
+	if (!account.configured) throw new Error(`IRC is not configured for account "${account.accountId}" (need host and nick in channels.irc).`);
+	const logger = core.logging.getChildLogger({
+		channel: "irc",
+		accountId: account.accountId
+	});
+	let client = null;
+	let activeConnectionEpoch = null;
+	let ingressPause = Promise.resolve();
+	let reconnectTimer = null;
+	const reconnectBackoff = createIrcReconnectBackoff();
+	let stopped = false;
+	const monitorAbort = new AbortController();
+	const abortSignal = opts.abortSignal ? AbortSignal.any([opts.abortSignal, monitorAbort.signal]) : monitorAbort.signal;
+	const ingress = createIrcIngressMonitor({
+		accountId: account.accountId,
+		runtime,
+		dispatch: async (message, turnAdoptionLifecycle, context) => {
+			if (!client || stopped || abortSignal.aborted) return {
+				kind: "failed-retryable",
+				error: /* @__PURE__ */ new Error("IRC transport disconnected before ingress dispatch.")
+			};
+			if (normalizeLowercaseStringOrEmpty(message.senderNick) === normalizeLowercaseStringOrEmpty(context.connectedNick)) return { kind: "completed" };
+			if (!message.isGroup && context.connectionEpoch !== activeConnectionEpoch) {
+				logger.warn?.(`[${account.accountId}] dropping replayed IRC DM after the connection changed`);
+				return { kind: "completed" };
+			}
+			const deliverReply = async (target, payload) => {
+				await deliverFormattedTextWithAttachments({
+					payload: {
+						...payload,
+						text: sanitizeIrcAssistantText(payload.text ?? "")
+					},
+					send: async ({ text }) => {
+						const replyClient = client;
+						if (!replyClient || !replyClient.isReady() || stopped || abortSignal.aborted) throw new Error("IRC transport disconnected before reply send.");
+						if (!message.isGroup && context.connectionEpoch !== activeConnectionEpoch) throw new Error("IRC connection changed before private reply send.");
+						await replyClient.sendPrivmsg(target, text);
+						opts.statusSink?.({ lastOutboundAt: Date.now() });
+						core.channel.activity.record({
+							channel: "irc",
+							accountId: account.accountId,
+							direction: "outbound"
+						});
+					}
+				});
+			};
+			const pairing = createChannelPairingController({
+				core,
+				channel: CHANNEL_ID,
+				accountId: account.accountId
+			});
+			const rawBody = message.text?.trim() ?? "";
+			if (!rawBody) return { kind: "completed" };
+			if (turnAdoptionLifecycle?.abortSignal.aborted) return {
+				kind: "failed-retryable",
+				error: turnAdoptionLifecycle.abortSignal.reason
+			};
+			opts.statusSink?.({ lastInboundAt: message.timestamp });
+			const senderDisplay = message.senderHost ? `${message.senderNick}!${message.senderUser ?? "?"}@${message.senderHost}` : message.senderNick;
+			const allowNameMatching = isDangerousNameMatchingEnabled(account.config);
+			const dmPolicy = account.config.dmPolicy ?? "pairing";
+			const defaultGroupPolicy = resolveDefaultGroupPolicy(cfg);
+			const { groupPolicy, providerMissingFallbackApplied } = resolveAllowlistProviderRuntimeGroupPolicy({
+				providerConfigPresent: cfg.channels?.irc !== void 0,
+				groupPolicy: account.config.groupPolicy,
+				defaultGroupPolicy
+			});
+			warnMissingProviderGroupPolicyFallbackOnce({
+				providerMissingFallbackApplied,
+				providerKey: "irc",
+				accountId: account.accountId,
+				blockedLabel: GROUP_POLICY_BLOCKED_LABEL.channel,
+				log: (messageLocal) => runtime.log?.(messageLocal)
+			});
+			const groupMatch = resolveIrcGroupMatch({
+				groups: account.config.groups,
+				target: message.target
+			});
+			const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
+				cfg,
+				surface: CHANNEL_ID
+			});
+			const hasControlCommand = core.channel.text.hasControlCommand(rawBody, cfg);
+			const mentionRegexes = core.channel.mentions.buildMentionRegexes(cfg);
+			const mentionNick = context.connectedNick.trim() || account.nick;
+			const explicitMentionRegex = mentionNick ? new RegExp(`(?<!${IRC_NICK_CHARACTER})${buildIrcNickMentionPattern(mentionNick)}(?!${IRC_NICK_CHARACTER})[:,]?`, "i") : null;
+			const wasMentioned = core.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) || (explicitMentionRegex ? explicitMentionRegex.test(rawBody) : false);
+			const requireMention = message.isGroup ? resolveIrcGroupRequireMention({
+				groups: account.config.groups,
+				target: message.target
+			}) : false;
+			const routeGroupAllowFrom = normalizeStringEntries(groupMatch.groupConfig?.allowFrom?.length ? groupMatch.groupConfig.allowFrom : groupMatch.wildcardConfig?.allowFrom);
+			const accessGroupPolicy = groupPolicy === "open" && (hasEntries(account.config.groupAllowFrom) || hasEntries(routeGroupAllowFrom)) ? "allowlist" : groupPolicy;
+			const channelTarget = message.target.startsWith("#") || message.target.startsWith("&") ? message.target : `#${message.target}`;
+			const peerId = message.isGroup ? channelTarget : message.senderNick;
+			const route = resolveAgentRoute({
+				cfg,
+				channel: CHANNEL_ID,
+				accountId: account.accountId,
+				peer: {
+					kind: message.isGroup ? "group" : "direct",
+					id: peerId
+				}
+			});
+			const access = await core.channel.inbound.ingress.createResolver({
+				channelId: CHANNEL_ID,
+				accountId: account.accountId,
+				identity: ircIngressIdentity,
+				cfg,
+				readStoreAllowFrom: async () => await pairing.readAllowFromStore()
+			}).message({
+				subject: createIrcIngressSubject(message),
+				conversation: {
+					kind: message.isGroup ? "group" : "direct",
+					id: message.target
+				},
+				contextBinding: {
+					agentId: route.agentId,
+					sessionKey: route.sessionKey,
+					...message.messageId ? { messageId: message.messageId } : {},
+					inboundEventKind: "user_request"
+				},
+				route: message.isGroup ? channelIngressRoutes(groupPolicy === "allowlist" && {
+					id: "irc:channel",
+					allowed: groupMatch.hasConfiguredGroups && groupMatch.allowed,
+					precedence: 0,
+					matchId: "irc-channel",
+					blockReason: "channel_not_allowlisted"
+				}, (groupMatch.groupConfig?.enabled === false || groupMatch.wildcardConfig?.enabled === false) && {
+					id: "irc:channel-enabled",
+					enabled: false,
+					precedence: 10,
+					blockReason: "channel_disabled"
+				}, hasEntries(routeGroupAllowFrom) && {
+					id: "irc:channel-sender",
+					precedence: 20,
+					senderPolicy: "replace",
+					senderAllowFrom: routeGroupAllowFrom
+				}) : [],
+				mentionFacts: message.isGroup ? {
+					canDetectMention: true,
+					wasMentioned,
+					hasAnyMention: wasMentioned
+				} : void 0,
+				dmPolicy,
+				groupPolicy: accessGroupPolicy,
+				policy: {
+					groupAllowFromFallbackToAllowFrom: false,
+					mutableIdentifierMatching: allowNameMatching ? "enabled" : "disabled",
+					activation: {
+						requireMention: message.isGroup && requireMention,
+						allowTextCommands
+					}
+				},
+				allowFrom: account.config.allowFrom,
+				groupAllowFrom: account.config.groupAllowFrom,
+				command: {
+					allowTextCommands,
+					hasControlCommand
+				}
+			});
+			const commandAuthorized = access.commandAccess.authorized;
+			if (access.ingress.admission === "pairing-required") {
+				await pairing.issueChallenge({
+					senderId: normalizeLowercaseStringOrEmpty(senderDisplay),
+					senderIdLine: `Your IRC id: ${senderDisplay}`,
+					meta: { name: message.senderNick || void 0 },
+					sendPairingReply: async (text) => {
+						await deliverReply(message.senderNick, { text });
+					},
+					onReplyError: (err) => {
+						runtime.error?.(`irc: pairing reply failed for ${senderDisplay}: ${String(err)}`);
+					}
+				});
+				runtime.log?.(`irc: drop DM sender ${senderDisplay} (dmPolicy=${dmPolicy})`);
+				return { kind: "completed" };
+			}
+			if (access.ingress.admission === "skip") {
+				runtime.log?.(`irc: drop channel ${message.target} (missing-mention)`);
+				return { kind: "completed" };
+			}
+			if (access.ingress.admission !== "dispatch") {
+				if (message.isGroup && access.ingress.decisiveGateId === "command" && access.commandAccess.shouldBlockControlCommand) {
+					logInboundDrop({
+						log: (line) => runtime.log?.(line),
+						channel: CHANNEL_ID,
+						reason: "control command (unauthorized)",
+						target: senderDisplay
+					});
+					return { kind: "completed" };
+				}
+				if (message.isGroup) {
+					if (access.routeAccess.reason === "channel_not_allowlisted") runtime.log?.(`irc: drop channel ${message.target} (not allowlisted)`);
+					else if (access.routeAccess.reason === "channel_disabled") runtime.log?.(`irc: drop channel ${message.target} (disabled)`);
+					else runtime.log?.(`irc: drop group sender ${senderDisplay} (policy=${groupPolicy})`);
+				} else runtime.log?.(`irc: drop DM sender ${senderDisplay} (dmPolicy=${dmPolicy})`);
+				return { kind: "completed" };
+			}
+			if (turnAdoptionLifecycle?.abortSignal.aborted) return {
+				kind: "failed-retryable",
+				error: turnAdoptionLifecycle.abortSignal.reason
+			};
+			const fromLabel = message.isGroup ? message.target : senderDisplay;
+			const body = (await createChannelInboundEnvelopeBuilderAsync({
+				cfg,
+				route
+			}))({
+				channel: "IRC",
+				from: fromLabel,
+				timestamp: message.timestamp,
+				body: rawBody
+			});
+			const groupSystemPrompt = normalizeOptionalString(groupMatch.groupConfig?.systemPrompt);
+			const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(account.config);
+			const ctxPayload = core.channel.inbound.buildContext({
+				channelIngress: access,
+				channel: CHANNEL_ID,
+				accountId: route.accountId,
+				messageId: message.messageId,
+				timestamp: message.timestamp,
+				from: message.isGroup ? `channel:${channelTarget}` : `irc:${senderDisplay}`,
+				sender: {
+					id: senderDisplay,
+					name: message.senderNick || void 0
+				},
+				conversation: {
+					kind: message.isGroup ? "group" : "direct",
+					id: peerId,
+					label: fromLabel
+				},
+				route: {
+					agentId: route.agentId,
+					dmScope: route.dmScope,
+					accountId: route.accountId,
+					routeSessionKey: route.sessionKey
+				},
+				reply: {
+					to: message.isGroup ? `channel:${channelTarget}` : `irc:${peerId}`,
+					originatingTo: message.isGroup ? `channel:${channelTarget}` : `irc:${peerId}`
+				},
+				message: {
+					body,
+					bodyForAgent: rawBody,
+					rawBody,
+					commandBody: rawBody
+				},
+				access: {
+					commands: { authorized: commandAuthorized },
+					mentions: {
+						canDetectMention: message.isGroup,
+						wasMentioned
+					}
+				},
+				extra: {
+					GroupSubject: message.isGroup ? message.target : void 0,
+					GroupSystemPrompt: message.isGroup ? groupSystemPrompt : void 0
+				}
+			});
+			await core.channel.inbound.dispatch({
+				cfg,
+				channel: CHANNEL_ID,
+				accountId: account.accountId,
+				route: {
+					agentId: route.agentId,
+					sessionKey: route.sessionKey
+				},
+				ctxPayload,
+				delivery: {
+					deliver: async (payload) => {
+						await deliverReply(peerId, payload);
+					},
+					onError: (err, info) => {
+						runtime.error?.(`irc ${info.kind} reply failed: ${String(err)}`);
+					}
+				},
+				replyPipeline: {},
+				replyOptions: {
+					...bindIngressLifecycleToReplyOptions(turnAdoptionLifecycle),
+					skillFilter: groupMatch.groupConfig?.skills,
+					disableBlockStreaming: typeof blockStreamingEnabled === "boolean" ? !blockStreamingEnabled : void 0
+				},
+				record: { onRecordError: (err) => {
+					runtime.error?.(`irc: failed updating session meta: ${String(err)}`);
+				} }
+			});
+		}
+	});
+	function scheduleReconnect() {
+		if (stopped || abortSignal.aborted || reconnectTimer) return;
+		opts.statusSink?.({
+			connected: false,
+			lifecycle: "recovering"
+		});
+		const delayMs = reconnectBackoff.nextDelayMs();
+		reconnectTimer = setTimeout(() => {
+			reconnectTimer = null;
+			connect().catch((error) => {
+				if (stopped || abortSignal.aborted) return;
+				const message = error instanceof Error ? error.message : String(error);
+				logger.error(`[${account.accountId}] IRC reconnect failed: ${message}`);
+				opts.statusSink?.({ lastError: message });
+				scheduleReconnect();
+			});
+		}, delayMs);
+		return delayMs;
+	}
+	async function connect() {
+		if (stopped || abortSignal.aborted) return;
+		const ingressConnection = ingress.openConnection();
+		const nextClient = await connectIrcClient(buildIrcConnectOptions(account, {
+			channels: account.config.channels,
+			abortSignal,
+			onNotice: (text, target) => {
+				if (core.logging.shouldLogVerbose()) logger.debug?.(`[${account.accountId}] notice ${target ?? ""} len=${text.length}`);
+			},
+			onError: (error) => {
+				logger.error(`[${account.accountId}] IRC error: ${error.message}`);
+			},
+			onDisconnect: () => {
+				if (stopped || abortSignal.aborted) return;
+				ingressPause = ingress.pause();
+				if (activeConnectionEpoch === ingressConnection.connectionEpoch) activeConnectionEpoch = null;
+				client = null;
+				opts.statusSink?.({ lastDisconnect: { at: Date.now() } });
+				const delayMs = scheduleReconnect();
+				if (delayMs !== void 0) logger.warn?.(`[${account.accountId}] IRC connection closed; reconnecting in ${delayMs}ms`);
+			},
+			onPrivmsg: async (event) => {
+				await ingressConnection.accept(event.rawLine, event.connectedNick);
+				if (normalizeLowercaseStringOrEmpty(event.senderNick) === normalizeLowercaseStringOrEmpty(event.connectedNick)) return;
+				core.channel.activity.record({
+					channel: "irc",
+					accountId: account.accountId,
+					direction: "inbound",
+					at: Date.now()
+				});
+			}
+		}));
+		if (stopped || abortSignal.aborted) {
+			nextClient.quit("shutdown");
+			return;
+		}
+		client = nextClient;
+		activeConnectionEpoch = ingressConnection.connectionEpoch;
+		await ingressPause;
+		if (client !== nextClient || !nextClient.isReady()) {
+			if (activeConnectionEpoch === ingressConnection.connectionEpoch) activeConnectionEpoch = null;
+			return;
+		}
+		ingress.start();
+		reconnectBackoff.markConnected();
+		opts.statusSink?.(channelReadyPatch());
+		logger.info(`[${account.accountId}] connected to ${account.host}:${account.port}${account.tls ? " (tls)" : ""} as ${nextClient.nick}`);
+	}
+	try {
+		await connect();
+	} catch (error) {
+		await ingress.stop();
+		throw error;
+	}
+	let stopTask;
+	return { stop: () => {
+		stopTask ??= (async () => {
+			stopped = true;
+			if (!abortSignal.aborted) monitorAbort.abort();
+			if (reconnectTimer) {
+				clearTimeout(reconnectTimer);
+				reconnectTimer = null;
+			}
+			client?.quit("shutdown");
+			client = null;
+			activeConnectionEpoch = null;
+			await ingress.stop();
+		})();
+		return stopTask;
+	} };
+}
+//#endregion
+export { monitorIrcProvider, sendMessageIrc };

package/dist/.setup/{config-schema-Cy9tItsu.mjs → config-schema-CHwjI_aV.mjs}

@@ -1,7 +1,7 @@
 import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
 import { ChannelGroupEntrySchema, DmPolicySchema, GroupPolicySchema, MarkdownConfigSchema, ReplyRuntimeConfigSchemaShape, ReplyToModeSchema, buildChannelConfigSchema, buildMultiAccountChannelSchema, requireOpenAllowFrom } from "openclaw/plugin-sdk/channel-config-schema";
 import { z } from "zod";
-//#region extensions/irc/src/config-ui-hints.ts
+//#region extensions/irc/src/config-schema.ts
 const ircChannelConfigUiHints = {
 	"": {
 		label: "IRC",
@@ -40,8 +40,6 @@ const ircChannelConfigUiHints = {
 		configWrites: true
 	})
 };
-//#endregion
-//#region extensions/irc/src/config-schema.ts
 const IrcNickServSchema = z.object({
 	enabled: z.boolean().optional(),
 	service: z.string().optional(),

package/dist/.setup/secret-contract-api-4IT9_EK6.mjs

@@ -0,0 +1,2 @@
+export { t as channelSecrets, n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-C5i-29Hz.mjs";
+import "../secret-contract-api.js";

package/dist/.source-module-urls/4751df78f545ae971ceb22b6e4bff6086f63313240899a1d9884b970424a305e.json

@@ -0,0 +1 @@
+{"version":3,"entries":[{"output":"api.js","source":"extensions/irc/api.ts"},{"output":"channel-config-api.js","source":"extensions/irc/channel-config-api.ts"},{"output":"channel-plugin-api.js","source":"extensions/irc/channel-plugin-api.ts"},{"output":"doctor-contract-api.js","source":"extensions/irc/doctor-contract-api.ts"},{"output":"index.js","source":"extensions/irc/index.ts"},{"output":"runtime-api.js","source":"extensions/irc/runtime-api.ts"},{"output":"secret-contract-api.js","source":"extensions/irc/secret-contract-api.ts"},{"output":"setup-entry.js","source":"extensions/irc/setup-entry.ts"}],"chunks":[{"output":".setup/channel-DgvKz42q.mjs","sha256":"25591c4dd4dd69f60fa4ec7fb6dfb02cf282ba5be0799468d473d702a3b8f3cd","facadeSource":null,"sources":["extensions/irc/src/accounts.ts","extensions/irc/src/channel.ts","extensions/irc/src/client.ts","extensions/irc/src/connect-options.ts","extensions/irc/src/control-chars.ts","extensions/irc/src/ingress-identity.ts","extensions/irc/src/normalize.ts","extensions/irc/src/outbound-base.ts","extensions/irc/src/policy.ts","extensions/irc/src/probe.ts","extensions/irc/src/protocol.ts","extensions/irc/src/send.ts","extensions/irc/src/setup-core.ts","extensions/irc/src/setup-surface.ts","packages/normalization-core/src/grapheme.ts","packages/normalization-core/src/utf16-slice.ts"]},{"output":".setup/channel-plugin-api-WXJUjGsf.mjs","sha256":"ca1568fb3e79aaa3202eb330be13621927d7bd736cc66a5411dcdbc2d5685f86","facadeSource":"extensions/irc/channel-plugin-api.ts","sources":[]},{"output":".setup/channel-runtime-D4vKt7TE.mjs","sha256":"5b95ec28cfc745c4e41e4b77e218ab7d7fc0faac6f5f8c363e1ca8469eccc789","facadeSource":"extensions/irc/src/channel-runtime.ts","sources":["extensions/irc/src/irc-ingress.ts","extensions/irc/src/monitor.ts","extensions/irc/src/reconnect-backoff.ts"]},{"output":".setup/config-schema-CHwjI_aV.mjs","sha256":"283bc2145f0751e110cc8e2c2657c6ee4a408fe856cc321f42d5d5773db2cabf","facadeSource":null,"sources":["extensions/irc/src/config-schema.ts"]},{"output":".setup/runtime-C_V9tmpk.mjs","sha256":"3f1f1b4d7ee63152a339b6a4614a28f57972bf655c73e0e7083c837370bc094c","facadeSource":null,"sources":["extensions/irc/src/runtime.ts"]},{"output":".setup/secret-contract-api-4IT9_EK6.mjs","sha256":"8d9275ff824f6c76b94e80dc043be8a12df9c8b3dc7203faa58bd2fc1bf3c244","facadeSource":"extensions/irc/secret-contract-api.ts","sources":[]},{"output":".setup/secret-contract-C5i-29Hz.mjs","sha256":"2eb99571f8fac572bc6d2a7cafe7bf7f2d864101256eb7b5aa6876fd031ee914","facadeSource":null,"sources":["extensions/irc/src/secret-contract.ts"]},{"output":"api.js","sha256":"4b63dc79a62e56af35b35dc398424d255aa86619e69c90baf657f8d3ec4ff666","facadeSource":"extensions/irc/api.ts","sources":[]},{"output":"channel-config-api.js","sha256":"3aa7303e9a7129099c9a8f9d644213f440902cd4748ce379f54484a9b523f544","facadeSource":"extensions/irc/channel-config-api.ts","sources":[]},{"output":"channel-plugin-api.js","sha256":"301f596faba5b2ec8be4314e9cf464f8f32c4eb9cf7639c1994cf77c9758aff5","facadeSource":"extensions/irc/channel-plugin-api.ts","sources":[]},{"output":"doctor-contract-api.js","sha256":"de1a30eb327e6de2799b8b84a8b4bd0f607d90051a2ab67f6a08ed3d29a54505","facadeSource":"extensions/irc/doctor-contract-api.ts","sources":["extensions/irc/config-doctor-api.ts","packages/normalization-core/src/record-coerce.ts","src/config/channel-config-normalization.ts","src/plugin-sdk/legacy-webhook-listener-migration.ts"]},{"output":"index.js","sha256":"26465ab4a608138b3cec93e4593f91f076be42b0fea9edad110953d71ec2e78c","facadeSource":"extensions/irc/index.ts","sources":["extensions/irc/index.ts"]},{"output":"runtime-api.js","sha256":"52b1074caae3be2b4f35e6ab34f26576c94d3a970587212b24eb8d9ac501720c","facadeSource":"extensions/irc/runtime-api.ts","sources":[]},{"output":"secret-contract-api.js","sha256":"ba5440395ed290e6115b9fa94429ffd9302dad0a9077f89307928fdc106fa4f0","facadeSource":"extensions/irc/secret-contract-api.ts","sources":[]},{"output":"setup-entry.js","sha256":"06a83942b5b52847b2f5dd9b0a5a9edcbc52a39457309b49c31e02986c7f63d2","facadeSource":"extensions/irc/setup-entry.ts","sources":["extensions/irc/setup-entry.ts"]}],"unrenderedSources":["extensions/irc/api.ts","extensions/irc/channel-config-api.ts","extensions/irc/channel-plugin-api.ts","extensions/irc/doctor-contract-api.ts","extensions/irc/runtime-api.ts","extensions/irc/secret-contract-api.ts","extensions/irc/src/channel-runtime.ts","src/plugin-sdk/text-grapheme.ts"]}

package/dist/api.js

@@ -1,3 +1,3 @@
-import { _ as listIrcAccountIds, g as listEnabledIrcAccounts, n as ircSetupWizard, r as ircSetupAdapter, t as ircPlugin, v as resolveDefaultIrcAccountId, y as resolveIrcAccount } from "./.setup/channel-Bi4lj8N2.mjs";
+import { _ as listIrcAccountIds, g as listEnabledIrcAccounts, n as ircSetupWizard, r as ircSetupAdapter, t as ircPlugin, v as resolveDefaultIrcAccountId, y as resolveIrcAccount } from "./.setup/channel-DgvKz42q.mjs";
 import { r as setIrcRuntime } from "./.setup/runtime-C_V9tmpk.mjs";
 export { ircPlugin, ircSetupAdapter, ircSetupWizard, listEnabledIrcAccounts, listIrcAccountIds, resolveDefaultIrcAccountId, resolveIrcAccount, setIrcRuntime };

package/dist/channel-config-api.js

@@ -1,2 +1 @@
-import { t as IrcChannelConfigSchema } from "./.setup/config-schema-Cy9tItsu.mjs";
-export { IrcChannelConfigSchema };
+export { t as IrcChannelConfigSchema } from "./.setup/config-schema-CHwjI_aV.mjs";

package/dist/channel-plugin-api.js

@@ -1,2 +1 @@
-import { t as ircPlugin } from "./.setup/channel-Bi4lj8N2.mjs";
-export { ircPlugin };
+export { t as ircPlugin } from "./.setup/channel-DgvKz42q.mjs";

package/dist/runtime-api.js

@@ -1,2 +1 @@
-import { r as setIrcRuntime } from "./.setup/runtime-C_V9tmpk.mjs";
-export { setIrcRuntime };
+export { r as setIrcRuntime } from "./.setup/runtime-C_V9tmpk.mjs";

package/dist/secret-contract-api.js

@@ -1,2 +1 @@
-import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./.setup/secret-contract-C5i-29Hz.mjs";
-export { channelSecrets, collectRuntimeConfigAssignments, secretTargetRegistryEntries };
+export { t as channelSecrets, n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./.setup/secret-contract-C5i-29Hz.mjs";

package/dist/setup-entry.js

@@ -4,11 +4,11 @@ import { fileURLToPath } from "node:url";
 var setup_entry_default = defineBundledChannelSetupEntry({
 	importMetaUrl: import.meta.url,
 	plugin: {
-		specifier: fileURLToPath(new URL(".setup/channel-plugin-api-U3Pg1KLp.mjs", import.meta.url).href),
+		specifier: fileURLToPath(new URL(".setup/channel-plugin-api-WXJUjGsf.mjs", import.meta.url).href),
 		exportName: "ircPlugin"
 	},
 	secrets: {
-		specifier: fileURLToPath(new URL(".setup/secret-contract-api-ClqD0Rpm.mjs", import.meta.url).href),
+		specifier: fileURLToPath(new URL(".setup/secret-contract-api-4IT9_EK6.mjs", import.meta.url).href),
 		exportName: "channelSecrets"
 	}
 });

package/node_modules/zod/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.6.5",
+  "version": "4.6.7",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",