@actagent/irc 2026.6.2

package/src/inbound.ts

@@ -0,0 +1,440 @@
+// Irc plugin module implements inbound behavior.
+import { logInboundDrop } from "actagent/plugin-sdk/channel-inbound";
+import {
+  channelIngressRoutes,
+  createChannelIngressResolver,
+  defineStableChannelIngressIdentity,
+} from "actagent/plugin-sdk/channel-ingress-runtime";
+import { createChannelPairingController } from "actagent/plugin-sdk/channel-pairing";
+import type { ACTAgentConfig } from "actagent/plugin-sdk/config-contracts";
+import { isDangerousNameMatchingEnabled } from "actagent/plugin-sdk/dangerous-name-runtime";
+import { resolveInboundRouteEnvelopeBuilderWithRuntime } from "actagent/plugin-sdk/inbound-envelope";
+import {
+  deliverFormattedTextWithAttachments,
+  type OutboundReplyPayload,
+} from "actagent/plugin-sdk/reply-payload";
+import type { RuntimeEnv } from "actagent/plugin-sdk/runtime";
+import {
+  GROUP_POLICY_BLOCKED_LABEL,
+  resolveAllowlistProviderRuntimeGroupPolicy,
+  resolveDefaultGroupPolicy,
+  warnMissingProviderGroupPolicyFallbackOnce,
+} from "actagent/plugin-sdk/runtime-group-policy";
+import {
+  normalizeLowercaseStringOrEmpty,
+  normalizeOptionalString,
+  normalizeStringEntries,
+} from "actagent/plugin-sdk/string-coerce-runtime";
+import type { ResolvedIrcAccount } from "./accounts.js";
+import { buildIrcAllowlistCandidates, normalizeIrcAllowEntry } from "./normalize.js";
+import { resolveIrcGroupMatch, resolveIrcRequireMention } from "./policy.js";
+import { getIrcRuntime } from "./runtime.js";
+import { sendMessageIrc } from "./send.js";
+import type { CoreConfig, IrcInboundMessage } from "./types.js";
+
+const CHANNEL_ID = "irc" as const;
+const IRC_NICK_KIND = "plugin:irc-nick" as const;
+type IrcGroupPolicy = "open" | "allowlist" | "disabled";
+
+const ircIngressIdentity = defineStableChannelIngressIdentity({
+  key: "irc-id",
+  normalizeEntry: normalizeIrcStableEntry,
+  normalizeSubject: normalizeLowercaseStringOrEmpty,
+  sensitivity: "pii",
+  aliases: [
+    ...["irc-id-nick-user", "irc-id-nick-host"].map((key) => ({
+      key,
+      kind: "stable-id" as const,
+      normalizeEntry: () => null,
+      normalizeSubject: normalizeLowercaseStringOrEmpty,
+      sensitivity: "pii" as const,
+    })),
+    {
+      key: "irc-nick",
+      kind: IRC_NICK_KIND,
+      normalizeEntry: normalizeIrcNickEntry,
+      normalizeSubject: normalizeLowercaseStringOrEmpty,
+      dangerous: true,
+      sensitivity: "pii",
+    },
+  ],
+  isWildcardEntry: (entry) => normalizeIrcAllowEntry(entry) === "*",
+  resolveEntryId: ({ entryIndex, fieldKey }) =>
+    `irc-entry-${entryIndex + 1}:${fieldKey === "irc-nick" ? "nick" : "id"}`,
+});
+
+const escapeIrcRegexLiteral = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+function isBareNick(value: string): boolean {
+  return !value.includes("!") && !value.includes("@");
+}
+
+function normalizeIrcStableEntry(value: string): string | null {
+  const normalized = normalizeIrcAllowEntry(value);
+  if (!normalized || normalized === "*" || isBareNick(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+
+function normalizeIrcNickEntry(value: string): string | null {
+  const normalized = normalizeIrcAllowEntry(value);
+  if (!normalized || normalized === "*" || !isBareNick(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+
+function hasEntries(entries: Array<string | number> | undefined): boolean {
+  return normalizeStringEntries(entries).some((entry) => normalizeIrcAllowEntry(entry));
+}
+
+function createIrcIngressSubject(message: IrcInboundMessage) {
+  const candidates = buildIrcAllowlistCandidates(message, { allowNameMatching: true });
+  const stableCandidates = candidates.filter((candidate) => !isBareNick(candidate));
+  const nick = normalizeLowercaseStringOrEmpty(message.senderNick);
+  return {
+    stableId: stableCandidates[stableCandidates.length - 1] ?? nick,
+    aliases: {
+      "irc-id-nick-user": stableCandidates.find(
+        (candidate) => candidate.includes("!") && !candidate.includes("@"),
+      ),
+      "irc-id-nick-host": stableCandidates.find(
+        (candidate) => !candidate.includes("!") && candidate.includes("@"),
+      ),
+      "irc-nick": nick,
+    },
+  };
+}
+
+function routeDescriptorsForIrcGroup(params: {
+  isGroup: boolean;
+  groupPolicy: IrcGroupPolicy;
+  groupAllowed: boolean;
+  hasConfiguredGroups: boolean;
+  groupEnabled: boolean;
+  routeGroupAllowFrom: string[];
+}) {
+  if (!params.isGroup) {
+    return [];
+  }
+  return channelIngressRoutes(
+    params.groupPolicy === "allowlist" && {
+      id: "irc:channel",
+      allowed: params.hasConfiguredGroups && params.groupAllowed,
+      precedence: 0,
+      matchId: "irc-channel",
+      blockReason: "channel_not_allowlisted",
+    },
+    !params.groupEnabled && {
+      id: "irc:channel-enabled",
+      enabled: false,
+      precedence: 10,
+      blockReason: "channel_disabled",
+    },
+    hasEntries(params.routeGroupAllowFrom) && {
+      id: "irc:channel-sender",
+      precedence: 20,
+      senderPolicy: "replace",
+      senderAllowFrom: params.routeGroupAllowFrom,
+    },
+  );
+}
+
+async function deliverIrcReply(params: {
+  payload: OutboundReplyPayload;
+  cfg: CoreConfig;
+  target: string;
+  accountId: string;
+  sendReply?: (target: string, text: string, replyToId?: string) => Promise<void>;
+  statusSink?: (patch: { lastOutboundAt?: number }) => void;
+}) {
+  await deliverFormattedTextWithAttachments({
+    payload: params.payload,
+    send: async ({ text, replyToId }) => {
+      if (params.sendReply) {
+        await params.sendReply(params.target, text, replyToId);
+      } else {
+        await sendMessageIrc(params.target, text, {
+          cfg: params.cfg,
+          accountId: params.accountId,
+          replyTo: replyToId,
+        });
+      }
+      params.statusSink?.({ lastOutboundAt: Date.now() });
+    },
+  });
+}
+
+export async function handleIrcInbound(params: {
+  message: IrcInboundMessage;
+  account: ResolvedIrcAccount;
+  config: CoreConfig;
+  runtime: RuntimeEnv;
+  connectedNick?: string;
+  sendReply?: (target: string, text: string, replyToId?: string) => Promise<void>;
+  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
+}): Promise<void> {
+  const { message, account, config, runtime, connectedNick, statusSink } = params;
+  const core = getIrcRuntime();
+  const pairing = createChannelPairingController({
+    core,
+    channel: CHANNEL_ID,
+    accountId: account.accountId,
+  });
+
+  const rawBody = message.text?.trim() ?? "";
+  if (!rawBody) {
+    return;
+  }
+
+  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(config);
+  const { groupPolicy, providerMissingFallbackApplied } =
+    resolveAllowlistProviderRuntimeGroupPolicy({
+      providerConfigPresent: config.channels?.irc !== undefined,
+      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: config as ACTAgentConfig,
+    surface: CHANNEL_ID,
+  });
+  const hasControlCommand = core.channel.text.hasControlCommand(rawBody, config as ACTAgentConfig);
+  const mentionRegexes = core.channel.mentions.buildMentionRegexes(config as ACTAgentConfig);
+  const mentionNick = connectedNick?.trim() || account.nick;
+  const explicitMentionRegex = mentionNick
+    ? new RegExp(`\\b${escapeIrcRegexLiteral(mentionNick)}\\b[:,]?`, "i")
+    : null;
+  const wasMentioned =
+    core.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes) ||
+    (explicitMentionRegex ? explicitMentionRegex.test(rawBody) : false);
+  const requireMention = message.isGroup
+    ? resolveIrcRequireMention({
+        groupConfig: groupMatch.groupConfig,
+        wildcardConfig: groupMatch.wildcardConfig,
+      })
+    : false;
+  const routeGroupAllowFrom = normalizeStringEntries(
+    groupMatch.groupConfig?.allowFrom?.length
+      ? groupMatch.groupConfig.allowFrom
+      : groupMatch.wildcardConfig?.allowFrom,
+  );
+  const accessGroupPolicy: IrcGroupPolicy =
+    groupPolicy === "open" &&
+    (hasEntries(account.config.groupAllowFrom) || hasEntries(routeGroupAllowFrom))
+      ? "allowlist"
+      : groupPolicy;
+  const access = await createChannelIngressResolver({
+    channelId: CHANNEL_ID,
+    accountId: account.accountId,
+    identity: ircIngressIdentity,
+    cfg: config as ACTAgentConfig,
+    readStoreAllowFrom: async () => await pairing.readAllowFromStore(),
+  }).message({
+    subject: createIrcIngressSubject(message),
+    conversation: {
+      kind: message.isGroup ? "group" : "direct",
+      id: message.target,
+    },
+    route: routeDescriptorsForIrcGroup({
+      isGroup: message.isGroup,
+      groupPolicy,
+      groupAllowed: groupMatch.allowed,
+      hasConfiguredGroups: groupMatch.hasConfiguredGroups,
+      groupEnabled:
+        groupMatch.groupConfig?.enabled !== false && groupMatch.wildcardConfig?.enabled !== false,
+      routeGroupAllowFrom,
+    }),
+    mentionFacts: message.isGroup
+      ? {
+          canDetectMention: true,
+          wasMentioned,
+          hasAnyMention: wasMentioned,
+        }
+      : undefined,
+    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 || undefined },
+      sendPairingReply: async (text) => {
+        await deliverIrcReply({
+          payload: { text },
+          cfg: config,
+          target: message.senderNick,
+          accountId: account.accountId,
+          sendReply: params.sendReply,
+          statusSink,
+        });
+      },
+      onReplyError: (err) => {
+        runtime.error?.(`irc: pairing reply failed for ${senderDisplay}: ${String(err)}`);
+      },
+    });
+    runtime.log?.(`irc: drop DM sender ${senderDisplay} (dmPolicy=${dmPolicy})`);
+    return;
+  }
+  if (access.ingress.admission === "skip") {
+    runtime.log?.(`irc: drop channel ${message.target} (missing-mention)`);
+    return;
+  }
+  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;
+    }
+    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;
+  }
+
+  const channelTarget =
+    message.target.startsWith("#") || message.target.startsWith("&")
+      ? message.target
+      : `#${message.target}`;
+  const peerId = message.isGroup ? channelTarget : message.senderNick;
+  const { route, buildEnvelope } = resolveInboundRouteEnvelopeBuilderWithRuntime({
+    cfg: config as ACTAgentConfig,
+    channel: CHANNEL_ID,
+    accountId: account.accountId,
+    peer: {
+      kind: message.isGroup ? "group" : "direct",
+      id: peerId,
+    },
+    runtime: core.channel,
+    sessionStore: config.session?.store,
+  });
+
+  const fromLabel = message.isGroup ? message.target : senderDisplay;
+  const { storePath, body } = buildEnvelope({
+    channel: "IRC",
+    from: fromLabel,
+    timestamp: message.timestamp,
+    body: rawBody,
+  });
+
+  const groupSystemPrompt = normalizeOptionalString(groupMatch.groupConfig?.systemPrompt);
+
+  const ctxPayload = core.channel.reply.finalizeInboundContext({
+    Body: body,
+    RawBody: rawBody,
+    CommandBody: rawBody,
+    From: message.isGroup ? `channel:${channelTarget}` : `irc:${senderDisplay}`,
+    To: message.isGroup ? `channel:${channelTarget}` : `irc:${peerId}`,
+    SessionKey: route.sessionKey,
+    AccountId: route.accountId,
+    ChatType: message.isGroup ? "group" : "direct",
+    ConversationLabel: fromLabel,
+    SenderName: message.senderNick || undefined,
+    SenderId: senderDisplay,
+    GroupSubject: message.isGroup ? message.target : undefined,
+    GroupSystemPrompt: message.isGroup ? groupSystemPrompt : undefined,
+    Provider: CHANNEL_ID,
+    Surface: CHANNEL_ID,
+    WasMentioned: message.isGroup ? wasMentioned : undefined,
+    MessageSid: message.messageId,
+    Timestamp: message.timestamp,
+    OriginatingChannel: CHANNEL_ID,
+    OriginatingTo: message.isGroup ? `channel:${channelTarget}` : `irc:${peerId}`,
+    CommandAuthorized: commandAuthorized,
+  });
+
+  await core.channel.inbound.dispatchReply({
+    cfg: config as ACTAgentConfig,
+    channel: CHANNEL_ID,
+    accountId: account.accountId,
+    agentId: route.agentId,
+    routeSessionKey: route.sessionKey,
+    storePath,
+    ctxPayload,
+    recordInboundSession: core.channel.session.recordInboundSession,
+    dispatchReplyWithBufferedBlockDispatcher:
+      core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
+    delivery: {
+      deliver: async (payload) => {
+        await deliverIrcReply({
+          payload,
+          cfg: config,
+          target: peerId,
+          accountId: account.accountId,
+          sendReply: params.sendReply,
+          statusSink,
+        });
+      },
+      onError: (err, info) => {
+        runtime.error?.(`irc ${info.kind} reply failed: ${String(err)}`);
+      },
+    },
+    replyPipeline: {},
+    replyOptions: {
+      skillFilter: groupMatch.groupConfig?.skills,
+      disableBlockStreaming:
+        typeof account.config.blockStreaming === "boolean"
+          ? !account.config.blockStreaming
+          : undefined,
+    },
+    record: {
+      onRecordError: (err) => {
+        runtime.error?.(`irc: failed updating session meta: ${String(err)}`);
+      },
+    },
+  });
+}

package/src/message-adapter.ts

@@ -0,0 +1,29 @@
+// Irc plugin module implements message adapter behavior.
+import { defineChannelMessageAdapter } from "actagent/plugin-sdk/channel-outbound";
+import { sendMessageIrc } from "./send.js";
+import type { CoreConfig } from "./types.js";
+
+export const ircMessageAdapter = defineChannelMessageAdapter({
+  id: "irc",
+  durableFinal: {
+    capabilities: {
+      text: true,
+      media: true,
+      replyTo: true,
+    },
+  },
+  send: {
+    text: async ({ cfg, to, text, accountId, replyToId }) =>
+      await sendMessageIrc(to, text, {
+        cfg: cfg as CoreConfig,
+        accountId: accountId ?? undefined,
+        replyTo: replyToId ?? undefined,
+      }),
+    media: async ({ cfg, to, text, mediaUrl, accountId, replyToId }) =>
+      await sendMessageIrc(to, mediaUrl ? `${text}\n\nAttachment: ${mediaUrl}` : text, {
+        cfg: cfg as CoreConfig,
+        accountId: accountId ?? undefined,
+        replyTo: replyToId ?? undefined,
+      }),
+  },
+});

package/src/monitor.test.ts

@@ -0,0 +1,44 @@
+// Irc tests cover monitor plugin behavior.
+import { describe, expect, it } from "vitest";
+import { resolveIrcInboundTarget } from "./monitor.js";
+
+describe("irc monitor inbound target", () => {
+  it("keeps channel target for group messages", () => {
+    expect(
+      resolveIrcInboundTarget({
+        target: "#actagent",
+        senderNick: "alice",
+      }),
+    ).toEqual({
+      isGroup: true,
+      target: "#actagent",
+      rawTarget: "#actagent",
+    });
+  });
+
+  it("maps DM target to sender nick and preserves raw target", () => {
+    expect(
+      resolveIrcInboundTarget({
+        target: "actagent-bot",
+        senderNick: "alice",
+      }),
+    ).toEqual({
+      isGroup: false,
+      target: "alice",
+      rawTarget: "actagent-bot",
+    });
+  });
+
+  it("falls back to raw target when sender nick is empty", () => {
+    expect(
+      resolveIrcInboundTarget({
+        target: "actagent-bot",
+        senderNick: " ",
+      }),
+    ).toEqual({
+      isGroup: false,
+      target: "actagent-bot",
+      rawTarget: "actagent-bot",
+    });
+  });
+});

package/src/monitor.ts

@@ -0,0 +1,150 @@
+// Irc plugin module implements monitor behavior.
+import { resolveLoggerBackedRuntime } from "actagent/plugin-sdk/extension-shared";
+import { normalizeLowercaseStringOrEmpty } from "actagent/plugin-sdk/string-coerce-runtime";
+import { resolveIrcAccount } from "./accounts.js";
+import { connectIrcClient, type IrcClient } from "./client.js";
+import { buildIrcConnectOptions } from "./connect-options.js";
+import { handleIrcInbound } from "./inbound.js";
+import { isChannelTarget } from "./normalize.js";
+import { makeIrcMessageId } from "./protocol.js";
+import type { RuntimeEnv } from "./runtime-api.js";
+import { getIrcRuntime } from "./runtime.js";
+import type { CoreConfig, IrcInboundMessage } from "./types.js";
+
+type IrcMonitorOptions = {
+  accountId?: string;
+  config?: CoreConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
+  onMessage?: (message: IrcInboundMessage, client: IrcClient) => void | Promise<void>;
+};
+
+export function resolveIrcInboundTarget(params: { target: string; senderNick: string }): {
+  isGroup: boolean;
+  target: string;
+  rawTarget: string;
+} {
+  const rawTarget = params.target;
+  const isGroup = isChannelTarget(rawTarget);
+  if (isGroup) {
+    return { isGroup: true, target: rawTarget, rawTarget };
+  }
+  const senderNick = params.senderNick.trim();
+  return { isGroup: false, target: senderNick || rawTarget, rawTarget };
+}
+
+export async function monitorIrcProvider(opts: IrcMonitorOptions): Promise<{ stop: () => void }> {
+  const core = getIrcRuntime();
+  const cfg = opts.config ?? (core.config.current() as CoreConfig);
+  const account = resolveIrcAccount({
+    cfg,
+    accountId: opts.accountId,
+  });
+
+  const runtime: RuntimeEnv = 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: IrcClient | null = null;
+
+  client = await connectIrcClient(
+    buildIrcConnectOptions(account, {
+      channels: account.config.channels,
+      abortSignal: opts.abortSignal,
+      onLine: (line) => {
+        if (core.logging.shouldLogVerbose()) {
+          logger.debug?.(`[${account.accountId}] << ${line}`);
+        }
+      },
+      onNotice: (text, target) => {
+        if (core.logging.shouldLogVerbose()) {
+          logger.debug?.(`[${account.accountId}] notice ${target ?? ""}: ${text}`);
+        }
+      },
+      onError: (error) => {
+        logger.error(`[${account.accountId}] IRC error: ${error.message}`);
+      },
+      onPrivmsg: async (event) => {
+        if (!client) {
+          return;
+        }
+        if (
+          normalizeLowercaseStringOrEmpty(event.senderNick) ===
+          normalizeLowercaseStringOrEmpty(client.nick)
+        ) {
+          return;
+        }
+
+        const inboundTarget = resolveIrcInboundTarget({
+          target: event.target,
+          senderNick: event.senderNick,
+        });
+        const message: IrcInboundMessage = {
+          messageId: makeIrcMessageId(),
+          target: inboundTarget.target,
+          rawTarget: inboundTarget.rawTarget,
+          senderNick: event.senderNick,
+          senderUser: event.senderUser,
+          senderHost: event.senderHost,
+          text: event.text,
+          timestamp: Date.now(),
+          isGroup: inboundTarget.isGroup,
+        };
+
+        core.channel.activity.record({
+          channel: "irc",
+          accountId: account.accountId,
+          direction: "inbound",
+          at: message.timestamp,
+        });
+
+        if (opts.onMessage) {
+          await opts.onMessage(message, client);
+          return;
+        }
+
+        await handleIrcInbound({
+          message,
+          account,
+          config: cfg,
+          runtime,
+          connectedNick: client.nick,
+          sendReply: async (target, text) => {
+            client?.sendPrivmsg(target, text);
+            opts.statusSink?.({ lastOutboundAt: Date.now() });
+            core.channel.activity.record({
+              channel: "irc",
+              accountId: account.accountId,
+              direction: "outbound",
+            });
+          },
+          statusSink: opts.statusSink,
+        });
+      },
+    }),
+  );
+
+  logger.info(
+    `[${account.accountId}] connected to ${account.host}:${account.port}${account.tls ? " (tls)" : ""} as ${client.nick}`,
+  );
+
+  return {
+    stop: () => {
+      client?.quit("shutdown");
+      client = null;
+    },
+  };
+}