@shadowob/openclaw-shadowob 1.1.1 → 1.1.3

package/dist/chunk-JGLINAN5.js

@@ -1,1064 +0,0 @@
-// src/monitor.ts
-import nodeCrypto from "crypto";
-import fsPromises from "fs/promises";
-import nodeOs from "os";
-import nodePath from "path";
-import { ShadowClient, ShadowSocket } from "@shadowob/sdk";
-
-// src/runtime.ts
-import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
-var store = createPluginRuntimeStore(
-  "Shadow runtime not initialized \u2014 plugin not registered yet"
-);
-var setShadowRuntime = store.setRuntime;
-var getShadowRuntime = store.getRuntime;
-var tryGetShadowRuntime = store.tryGetRuntime;
-
-// src/monitor.ts
-async function getDataDir() {
-  const dataDir = process.env.OPENCLAW_DATA_DIR;
-  return dataDir || nodePath.join(nodeOs.homedir(), ".openclaw");
-}
-function resolveSessionStore(cfg) {
-  const raw = cfg.session?.store;
-  if (typeof raw === "string") return raw;
-  if (raw && typeof raw === "object") {
-    const pathValue = raw.path;
-    if (typeof pathValue === "string") return pathValue;
-  }
-  return void 0;
-}
-function createTypingCallbacks(params) {
-  const {
-    start,
-    stop,
-    onStartError,
-    onStopError,
-    keepaliveIntervalMs = 2e3,
-    maxDurationMs = 12e4
-  } = params;
-  let keepaliveTimer = null;
-  let maxDurationTimer = null;
-  const cleanup = () => {
-    if (keepaliveTimer) {
-      clearInterval(keepaliveTimer);
-      keepaliveTimer = null;
-    }
-    if (maxDurationTimer) {
-      clearTimeout(maxDurationTimer);
-      maxDurationTimer = null;
-    }
-  };
-  return {
-    onReplyStart: async () => {
-      try {
-        await start();
-      } catch (err) {
-        onStartError(err);
-        return;
-      }
-      keepaliveTimer = setInterval(async () => {
-        try {
-          await start();
-        } catch (err) {
-          onStartError(err);
-        }
-      }, keepaliveIntervalMs);
-      maxDurationTimer = setTimeout(() => {
-        cleanup();
-        stop?.().catch((err) => onStopError?.(err));
-      }, maxDurationMs);
-    },
-    onIdle: () => {
-      cleanup();
-    },
-    onCleanup: () => {
-      cleanup();
-      stop?.().catch((err) => onStopError?.(err));
-    }
-  };
-}
-async function processShadowMessage(params) {
-  const {
-    message,
-    account,
-    accountId,
-    config,
-    runtime,
-    core,
-    botUserId,
-    botUsername,
-    agentId,
-    channelPolicies,
-    channelServerMap,
-    socket
-  } = params;
-  const cfg = config;
-  const senderLabel = message.author?.username ?? message.authorId;
-  if (message.authorId === botUserId) {
-    runtime.log?.(`[msg] Skipping own message ${message.id}`);
-    return;
-  }
-  let isProcessingBuddyMessage = false;
-  if (message.author?.isBot) {
-    const policy2 = channelPolicies.get(message.channelId);
-    const policyConfig2 = policy2?.config;
-    if (!policyConfig2?.replyToBuddy) {
-      runtime.log?.(
-        `[msg] Skipping bot message from ${senderLabel} (replyToBuddy=false) (${message.id})`
-      );
-      return;
-    }
-    const maxDepth = policyConfig2.maxBuddyChainDepth ?? 3;
-    const chainMeta = message.metadata?.agentChain;
-    if (chainMeta) {
-      if (chainMeta.depth >= maxDepth) {
-        runtime.log?.(
-          `[msg] Buddy chain depth ${chainMeta.depth} >= max ${maxDepth}, stopping loop (${message.id})`
-        );
-        return;
-      }
-      if (chainMeta.participants?.includes(botUserId)) {
-        runtime.log?.(
-          `[msg] Already in buddy chain [${chainMeta.participants.join(", ")}], skipping to prevent loop (${message.id})`
-        );
-        return;
-      }
-      const senderAgentId = message.author?.id;
-      if (senderAgentId && policyConfig2.buddyBlacklist?.includes(senderAgentId)) {
-        runtime.log?.(
-          `[msg] Sender agent ${senderAgentId} is in blacklist, skipping (${message.id})`
-        );
-        return;
-      }
-      if (senderAgentId && policyConfig2.buddyWhitelist?.length && !policyConfig2.buddyWhitelist.includes(senderAgentId)) {
-        runtime.log?.(
-          `[msg] Sender agent ${senderAgentId} not in whitelist, skipping (${message.id})`
-        );
-        return;
-      }
-    }
-    isProcessingBuddyMessage = true;
-    runtime.log?.(
-      `[msg] Processing bot message from ${senderLabel} (replyToBuddy=true) (${message.id})`
-    );
-  }
-  const channelId = message.channelId;
-  const policy = channelPolicies.get(channelId);
-  if (policy && !policy.listen) {
-    runtime.log?.(`[msg] Policy blocks listen for channel ${channelId}, skipping`);
-    return;
-  }
-  if (policy && !policy.reply) {
-    runtime.log?.(`[msg] Policy blocks reply for channel ${channelId}, skipping (${message.id})`);
-    return;
-  }
-  let wasMentionedExplicitly = false;
-  if (policy?.mentionOnly) {
-    const escapedUsername = botUsername.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const mentionRegex2 = new RegExp(`@${escapedUsername}(?:\\s|$)`, "i");
-    wasMentionedExplicitly = mentionRegex2.test(message.content);
-    if (!wasMentionedExplicitly) {
-      runtime.log?.(
-        `[msg] mentionOnly policy \u2014 no @${botUsername} mention found, skipping (${message.id})`
-      );
-      return;
-    }
-    runtime.log?.(
-      `[msg] mentionOnly policy \u2014 @${botUsername} mentioned, processing (${message.id})`
-    );
-  }
-  const policyConfig = policy?.config;
-  if (policyConfig?.replyToUsers?.length) {
-    const allowedUsers = policyConfig.replyToUsers.map((u) => u.toLowerCase());
-    const senderUser = (message.author?.username ?? "").toLowerCase();
-    if (!allowedUsers.includes(senderUser)) {
-      runtime.log?.(
-        `[msg] replyToUsers policy \u2014 sender "${senderUser}" not in allowed list, skipping (${message.id})`
-      );
-      return;
-    }
-  }
-  if (policyConfig?.keywords?.length) {
-    const lowerContent = message.content.toLowerCase();
-    const matched = policyConfig.keywords.some((kw) => lowerContent.includes(kw.toLowerCase()));
-    if (!matched) {
-      runtime.log?.(`[msg] keywords policy \u2014 no matching keyword found, skipping (${message.id})`);
-      return;
-    }
-    runtime.log?.(`[msg] keywords policy \u2014 keyword matched, processing (${message.id})`);
-  }
-  const smartReplyEnabled = policyConfig?.smartReply !== false;
-  if (smartReplyEnabled && !isProcessingBuddyMessage && !wasMentionedExplicitly) {
-    const mentionPattern = /@([a-zA-Z0-9_\-\u4e00-\u9fa5]+)/g;
-    const allMentions = message.content.match(mentionPattern) || [];
-    const mentionsWithoutSelf = allMentions.filter((m) => {
-      const mentionedUser = m.slice(1).toLowerCase();
-      return mentionedUser !== botUsername.toLowerCase();
-    });
-    if (allMentions.length > 0 && mentionsWithoutSelf.length === allMentions.length) {
-      runtime.log?.(
-        `[msg] Smart reply: message @mentions others (${allMentions.join(", ")}) but not @${botUsername}, skipping (${message.id})`
-      );
-      return;
-    }
-    const replyToData = message.replyTo;
-    if (replyToData?.authorId && replyToData.authorId !== botUserId) {
-      const selfMentioned = allMentions.some((m) => {
-        const mentionedUser = m.slice(1).toLowerCase();
-        return mentionedUser === botUsername.toLowerCase();
-      });
-      if (!selfMentioned) {
-        runtime.log?.(
-          `[msg] Smart reply: message is a reply to another user (${replyToData.authorId}), not this Buddy, skipping (${message.id})`
-        );
-        return;
-      }
-    }
-  }
-  runtime.log?.(
-    `[msg] Processing message from ${senderLabel}: "${message.content.slice(0, 80)}" (${message.id})`
-  );
-  const senderName = message.author?.displayName ?? message.author?.username ?? "Unknown";
-  const senderUsername = message.author?.username ?? "";
-  const senderId = message.authorId;
-  const rawBody = message.content;
-  const chatType = message.threadId ? "thread" : "channel";
-  const peerId = message.threadId ? `${channelId}:thread:${message.threadId}` : channelId;
-  const route = core.channel.routing.resolveAgentRoute({
-    cfg,
-    channel: "shadowob",
-    accountId,
-    peer: { kind: "group", id: peerId }
-  });
-  runtime.log?.(`[routing] Resolved agent: ${route.agentId} (account ${accountId})`);
-  const body = core.channel.reply.formatAgentEnvelope({
-    channel: "Shadow",
-    from: senderName,
-    timestamp: new Date(message.createdAt).getTime(),
-    envelope: core.channel.reply.resolveEnvelopeFormatOptions(cfg),
-    body: rawBody
-  });
-  const attachmentUrls = (message.attachments ?? []).map((a) => a.url).filter(Boolean);
-  const markdownMediaRegex = /!?\[[^\]]*\]\(([^)]+)\)/g;
-  const markdownUrls = [];
-  for (const mdMatch of rawBody.matchAll(markdownMediaRegex)) {
-    const url = mdMatch[1];
-    if (url.startsWith("/") && url.includes("/uploads/")) {
-      markdownUrls.push(url);
-    } else if (url.startsWith("http")) {
-      markdownUrls.push(url);
-    }
-  }
-  const allRawUrls = [.../* @__PURE__ */ new Set([...attachmentUrls, ...markdownUrls])];
-  const mediaClient = new ShadowClient(account.serverUrl, account.token);
-  const localMediaPaths = [];
-  const localMediaTypes = [];
-  const resolvedMediaUrls = [];
-  const inferMimeType = (filename, headerType) => {
-    const ext = filename.split(".").pop()?.toLowerCase() ?? "";
-    const map = {
-      jpg: "image/jpeg",
-      jpeg: "image/jpeg",
-      png: "image/png",
-      gif: "image/gif",
-      webp: "image/webp",
-      svg: "image/svg+xml",
-      mp4: "video/mp4",
-      webm: "video/webm",
-      mp3: "audio/mpeg",
-      wav: "audio/wav",
-      ogg: "audio/ogg",
-      pdf: "application/pdf"
-    };
-    return map[ext] ?? headerType ?? "application/octet-stream";
-  };
-  if (allRawUrls.length > 0) {
-    const dataDir = await getDataDir();
-    const mediaDir = nodePath.join(dataDir, "media", "inbound");
-    await fsPromises.mkdir(mediaDir, { recursive: true });
-    for (const rawUrl of allRawUrls) {
-      try {
-        const downloaded = await mediaClient.downloadFile(rawUrl);
-        const uuid = nodeCrypto.randomUUID();
-        const ext = nodePath.extname(downloaded.filename) || ".bin";
-        const safeBase = downloaded.filename.replace(/[^a-zA-Z0-9._\u4e00-\u9fff-]/g, "_").slice(0, 100);
-        const localFilename = `${safeBase}---${uuid}${ext.startsWith(".") ? "" : "."}${ext}`;
-        const localPath = nodePath.join(mediaDir, localFilename);
-        await fsPromises.writeFile(localPath, new Uint8Array(downloaded.buffer));
-        localMediaPaths.push(localPath);
-        localMediaTypes.push(inferMimeType(downloaded.filename, downloaded.contentType));
-        const baseUrl = account.serverUrl.replace(/\/$/, "");
-        resolvedMediaUrls.push(rawUrl.startsWith("/") ? `${baseUrl}${rawUrl}` : rawUrl);
-        runtime.log?.(
-          `[media] Downloaded ${rawUrl} \u2192 ${localPath} (${downloaded.buffer.byteLength} bytes)`
-        );
-      } catch (err) {
-        runtime.error?.(`[media] Failed to download ${rawUrl}: ${String(err)}`);
-      }
-    }
-  }
-  const mediaCtx = {};
-  if (localMediaPaths.length > 0) {
-    mediaCtx.MediaPath = localMediaPaths[0];
-    mediaCtx.MediaPaths = localMediaPaths;
-    mediaCtx.MediaUrl = resolvedMediaUrls[0];
-    mediaCtx.MediaUrls = resolvedMediaUrls;
-    mediaCtx.MediaType = localMediaTypes[0];
-    mediaCtx.MediaTypes = localMediaTypes;
-  }
-  let cleanBody = rawBody;
-  if (localMediaPaths.length > 0) {
-    cleanBody = rawBody.replace(/!?\[[^\]]*\]\([^)]*\/uploads\/[^)]+\)/g, "").replace(/\n{2,}/g, "\n").trim();
-    if (!cleanBody) cleanBody = "[Media attached]";
-  }
-  const serverInfo = channelServerMap.get(channelId);
-  const escapedBotUsername = botUsername.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const mentionRegex = new RegExp(`@${escapedBotUsername}(?:\\s|$)`, "i");
-  const wasMentioned = mentionRegex.test(message.content);
-  const triggerChain = message.metadata?.agentChain;
-  const ctxPayload = core.channel.reply.finalizeInboundContext({
-    Body: body,
-    BodyForAgent: cleanBody,
-    RawBody: rawBody,
-    CommandBody: cleanBody,
-    From: `shadowob:user:${senderId}`,
-    To: `shadowob:channel:${channelId}`,
-    SessionKey: route.sessionKey,
-    AccountId: route.accountId,
-    ChatType: chatType,
-    ConversationLabel: peerId,
-    SenderName: senderName,
-    SenderId: senderId,
-    SenderUsername: senderUsername,
-    Provider: "shadowob",
-    Surface: "shadowob",
-    MessageSid: message.id,
-    WasMentioned: wasMentioned,
-    OriginatingChannel: "shadowob",
-    OriginatingTo: `shadowob:channel:${channelId}`,
-    ...serverInfo ? {
-      ServerId: serverInfo.serverId,
-      ServerSlug: serverInfo.serverSlug,
-      ServerName: serverInfo.serverName,
-      ChannelName: serverInfo.channelName
-    } : {},
-    BotUserId: botUserId,
-    BotUsername: botUsername,
-    AgentId: route.agentId,
-    ChannelId: channelId,
-    ...message.threadId ? { ThreadId: message.threadId } : {},
-    ...message.replyToId ? { ReplyToId: message.replyToId } : {},
-    ...mediaCtx
-  });
-  const storePath = core.channel.session.resolveStorePath(resolveSessionStore(cfg), {
-    agentId: route.agentId
-  });
-  await core.channel.session.recordInboundSession({
-    storePath,
-    sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
-    ctx: ctxPayload,
-    onRecordError: (err) => {
-      runtime.error?.(`Failed updating session meta: ${String(err)}`);
-    }
-  });
-  if (policy && !policy.reply) {
-    runtime.log?.(`[msg] Policy blocks reply for channel ${channelId}, skipping dispatch`);
-    return;
-  }
-  runtime.log?.(`[msg] Dispatching to AI pipeline for message ${message.id}`);
-  const client = new ShadowClient(account.serverUrl, account.token);
-  const typingCbs = createTypingCallbacks({
-    start: async () => {
-      socket.sendTyping(channelId);
-    },
-    onStartError: (err) => {
-      runtime.error?.(`[typing] Failed to send typing indicator: ${String(err)}`);
-    }
-  });
-  socket.updateActivity(channelId, "thinking");
-  typingCbs.onReplyStart().catch(() => {
-  });
-  try {
-    if (core.channel.reply.createReplyDispatcherWithTyping) {
-      const { markDispatchIdle, markRunComplete } = core.channel.reply.createReplyDispatcherWithTyping({
-        typingCallbacks: typingCbs,
-        deliver: async (payload) => {
-          socket.updateActivity(channelId, "working");
-          await deliverShadowReply({
-            payload,
-            channelId,
-            threadId: message.threadId ?? void 0,
-            replyToId: message.id,
-            client,
-            runtime,
-            agentChain: triggerChain,
-            agentId,
-            botUserId
-          });
-        }
-      });
-      await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-        ctx: ctxPayload,
-        cfg,
-        dispatcherOptions: {
-          deliver: async (payload) => {
-            socket.updateActivity(channelId, "working");
-            await deliverShadowReply({
-              payload,
-              channelId,
-              threadId: message.threadId ?? void 0,
-              replyToId: message.id,
-              client,
-              runtime,
-              agentChain: triggerChain,
-              agentId,
-              botUserId
-            });
-          }
-        }
-      });
-      markDispatchIdle();
-      markRunComplete();
-    } else {
-      await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-        ctx: ctxPayload,
-        cfg,
-        dispatcherOptions: {
-          deliver: async (payload) => {
-            socket.updateActivity(channelId, "working");
-            socket.sendTyping(channelId);
-            await deliverShadowReply({
-              payload,
-              channelId,
-              threadId: message.threadId ?? void 0,
-              replyToId: message.id,
-              client,
-              runtime,
-              agentChain: triggerChain,
-              agentId,
-              botUserId
-            });
-          }
-        }
-      });
-    }
-    socket.updateActivity(channelId, "ready");
-  } catch (err) {
-    runtime.error?.(`[msg] AI dispatch failed for message ${message.id}: ${String(err)}`);
-    socket.updateActivity(channelId, null);
-    throw err;
-  } finally {
-    typingCbs.onCleanup?.();
-    setTimeout(() => {
-      socket.updateActivity(channelId, null);
-    }, 3e3);
-  }
-}
-async function deliverShadowReply(params) {
-  const {
-    payload,
-    channelId,
-    threadId,
-    replyToId,
-    client,
-    runtime,
-    agentChain,
-    agentId,
-    botUserId
-  } = params;
-  try {
-    if (!payload.text && !(payload.mediaUrl || payload.mediaUrls?.length)) {
-      runtime.error?.("[reply] No text or media in reply payload");
-      return;
-    }
-    const text = payload.text ?? "";
-    runtime.log?.(`[reply] Sending reply to channel ${channelId}: "${text.slice(0, 80)}"`);
-    const mediaUrls = [payload.mediaUrl, ...payload.mediaUrls ?? []].filter(Boolean);
-    const newAgentChain = agentId ? {
-      agentId,
-      depth: (agentChain?.depth ?? 0) + 1,
-      participants: [...agentChain?.participants ?? [], botUserId].filter(
-        Boolean
-      ),
-      startedAt: agentChain?.startedAt ?? Date.now(),
-      rootMessageId: agentChain?.rootMessageId ?? replyToId
-    } : void 0;
-    let sentMessage = null;
-    if (text || mediaUrls.length > 0) {
-      const contentToSend = text || "\u200B";
-      if (threadId) {
-        sentMessage = await client.sendToThread(threadId, contentToSend);
-      } else {
-        sentMessage = await client.sendMessage(channelId, contentToSend, {
-          replyToId,
-          metadata: newAgentChain ? { agentChain: newAgentChain } : void 0
-        });
-      }
-      runtime.log?.(
-        `[reply] Message created (${sentMessage.id})${text ? "" : " [media-only placeholder]"}${newAgentChain ? ` [chain depth: ${newAgentChain.depth}]` : ""}`
-      );
-    }
-    if (mediaUrls.length > 0) {
-      const messageId = sentMessage?.id;
-      for (const mediaUrl of mediaUrls) {
-        try {
-          runtime.log?.(`[reply] Uploading media: ${mediaUrl}`);
-          await client.uploadMediaFromUrl(mediaUrl, messageId);
-          runtime.log?.(`[reply] Media uploaded successfully`);
-        } catch (err) {
-          runtime.error?.(`[reply] Failed to upload media ${mediaUrl}: ${String(err)}`);
-        }
-      }
-    }
-    runtime.log?.(`[reply] Reply delivered successfully`);
-  } catch (err) {
-    runtime.error?.(`[reply] Failed to send reply: ${String(err)}`);
-  }
-}
-async function processShadowDmMessage(params) {
-  const {
-    dmMessage,
-    account,
-    accountId,
-    config,
-    runtime,
-    core,
-    botUserId,
-    botUsername,
-    shadowAgentId,
-    socket
-  } = params;
-  const cfg = config;
-  const senderLabel = dmMessage.author?.username ?? dmMessage.senderId;
-  if (dmMessage.senderId === botUserId || dmMessage.authorId === botUserId) {
-    runtime.log?.(`[dm] Skipping own DM message ${dmMessage.id}`);
-    return;
-  }
-  if (dmMessage.author?.isBot) {
-    runtime.log?.(`[dm] Skipping bot DM from ${senderLabel} (${dmMessage.id})`);
-    return;
-  }
-  runtime.log?.(
-    `[dm] Processing DM from ${senderLabel}: "${dmMessage.content.slice(0, 80)}" (${dmMessage.id})`
-  );
-  const senderName = dmMessage.author?.displayName ?? dmMessage.author?.username ?? "Unknown";
-  const senderUsername = dmMessage.author?.username ?? "";
-  const senderId = dmMessage.senderId;
-  const rawBody = dmMessage.content;
-  const dmChannelId = dmMessage.dmChannelId;
-  const attachments = dmMessage.attachments ?? [];
-  let bodyWithAttachments = rawBody;
-  if (attachments.length > 0) {
-    const attachmentLines = attachments.map(
-      (a) => `[Attachment: ${a.filename} (${a.contentType}): ${a.url}]`
-    );
-    bodyWithAttachments = rawBody ? `${rawBody}
-${attachmentLines.join("\n")}` : attachmentLines.join("\n");
-  }
-  const peerId = `dm:${dmChannelId}`;
-  const route = core.channel.routing.resolveAgentRoute({
-    cfg,
-    channel: "shadowob",
-    accountId,
-    peer: { kind: "direct", id: peerId }
-  });
-  runtime.log?.(`[routing] DM resolved agent: ${route.agentId} (account ${accountId})`);
-  const body = core.channel.reply.formatAgentEnvelope({
-    channel: "Shadow DM",
-    from: senderName,
-    timestamp: new Date(dmMessage.createdAt).getTime(),
-    envelope: core.channel.reply.resolveEnvelopeFormatOptions(cfg),
-    body: bodyWithAttachments
-  });
-  const ctxPayload = core.channel.reply.finalizeInboundContext({
-    Body: body,
-    BodyForAgent: bodyWithAttachments,
-    RawBody: rawBody,
-    CommandBody: rawBody,
-    From: `shadowob:user:${senderId}`,
-    To: `shadowob:dm:${dmChannelId}`,
-    SessionKey: route.sessionKey,
-    AccountId: route.accountId,
-    ChatType: "dm",
-    ConversationLabel: peerId,
-    SenderName: senderName,
-    SenderId: senderId,
-    SenderUsername: senderUsername,
-    Provider: "shadowob",
-    Surface: "shadowob",
-    MessageSid: dmMessage.id,
-    WasMentioned: true,
-    OriginatingChannel: "shadowob",
-    OriginatingTo: `shadowob:dm:${dmChannelId}`,
-    BotUserId: botUserId,
-    BotUsername: botUsername,
-    AgentId: route.agentId,
-    ChannelId: dmChannelId
-  });
-  const storePath = core.channel.session.resolveStorePath(resolveSessionStore(cfg), {
-    agentId: route.agentId
-  });
-  await core.channel.session.recordInboundSession({
-    storePath,
-    sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
-    ctx: ctxPayload,
-    onRecordError: (err) => {
-      runtime.error?.(`Failed updating DM session meta: ${String(err)}`);
-    }
-  });
-  runtime.log?.(`[dm] Dispatching to AI pipeline for DM message ${dmMessage.id}`);
-  const client = new ShadowClient(account.serverUrl, account.token);
-  const triggerChain = dmMessage.metadata?.agentChain;
-  const typingCbs = createTypingCallbacks({
-    start: async () => {
-      socket.sendDmTyping(dmChannelId);
-    },
-    onStartError: (err) => {
-      runtime.error?.(`[dm-typing] Failed to send typing indicator: ${String(err)}`);
-    }
-  });
-  typingCbs.onReplyStart().catch(() => {
-  });
-  try {
-    await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-      ctx: ctxPayload,
-      cfg,
-      dispatcherOptions: {
-        deliver: async (payload) => {
-          socket.sendDmTyping(dmChannelId);
-          await deliverShadowDmReply({
-            payload,
-            dmChannelId,
-            replyToId: dmMessage.id,
-            client,
-            runtime,
-            agentChain: triggerChain,
-            agentId: shadowAgentId,
-            botUserId
-          });
-        }
-      }
-    });
-  } catch (err) {
-    runtime.error?.(`[dm] AI dispatch failed for DM message ${dmMessage.id}: ${String(err)}`);
-    throw err;
-  } finally {
-    typingCbs.onCleanup?.();
-  }
-}
-async function deliverShadowDmReply(params) {
-  const { payload, dmChannelId, replyToId, client, runtime, agentChain, agentId, botUserId } = params;
-  try {
-    if (!payload.text && !(payload.mediaUrl || payload.mediaUrls?.length)) {
-      runtime.error?.("[dm-reply] No text or media in DM reply payload");
-      return;
-    }
-    const text = payload.text ?? "";
-    runtime.log?.(`[dm-reply] Sending DM reply to channel ${dmChannelId}: "${text.slice(0, 80)}"`);
-    const mediaUrls = [payload.mediaUrl, ...payload.mediaUrls ?? []].filter(Boolean);
-    const newAgentChain = agentId ? {
-      agentId,
-      depth: (agentChain?.depth ?? 0) + 1,
-      participants: [...agentChain?.participants ?? [], botUserId].filter(
-        Boolean
-      ),
-      startedAt: agentChain?.startedAt ?? Date.now(),
-      rootMessageId: agentChain?.rootMessageId ?? replyToId
-    } : void 0;
-    let sentMessage = null;
-    if (text || mediaUrls.length > 0) {
-      const contentToSend = text || "\u200B";
-      sentMessage = await client.sendDmMessage(dmChannelId, contentToSend, {
-        replyToId,
-        metadata: newAgentChain ? { agentChain: newAgentChain } : void 0
-      });
-      runtime.log?.(
-        `[dm-reply] DM message created (${sentMessage.id})${text ? "" : " [media-only placeholder]"}${newAgentChain ? ` [chain depth: ${newAgentChain.depth}]` : ""}`
-      );
-    }
-    if (mediaUrls.length > 0) {
-      const messageId = sentMessage?.id;
-      for (const mediaUrl of mediaUrls) {
-        try {
-          runtime.log?.(`[dm-reply] Uploading media: ${mediaUrl}`);
-          await client.uploadMediaFromUrl(mediaUrl, messageId);
-          runtime.log?.(`[dm-reply] Media uploaded successfully`);
-        } catch (err) {
-          runtime.error?.(`[dm-reply] Failed to upload media ${mediaUrl}: ${String(err)}`);
-        }
-      }
-    }
-    runtime.log?.(`[dm-reply] DM reply delivered successfully`);
-  } catch (err) {
-    runtime.error?.(`[dm-reply] Failed to send DM reply: ${String(err)}`);
-  }
-}
-async function getSessionCachePath(accountId) {
-  const dataDir = await getDataDir();
-  return nodePath.join(dataDir, "shadow", `session-cache-${accountId}.json`);
-}
-async function saveSessionCache(accountId, data) {
-  try {
-    const cachePath = await getSessionCachePath(accountId);
-    await fsPromises.mkdir(nodePath.dirname(cachePath), { recursive: true });
-    await fsPromises.writeFile(cachePath, JSON.stringify(data), "utf-8");
-  } catch {
-  }
-}
-async function loadSessionCache(accountId) {
-  try {
-    const cachePath = await getSessionCachePath(accountId);
-    const raw = await fsPromises.readFile(cachePath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-async function monitorShadowProvider(options) {
-  const { account, accountId, config, runtime, abortSignal } = options;
-  const core = getShadowRuntime();
-  let stopped = false;
-  const client = new ShadowClient(account.serverUrl, account.token);
-  const me = await client.getMe();
-  const botUserId = me.id;
-  runtime.log?.(`Shadow bot connected as ${me.username} (${botUserId})`);
-  const agentId = account.agentId ?? me.agentId ?? null;
-  if (!agentId) {
-    runtime.error?.(
-      "[config] Cannot resolve agentId \u2014 heartbeat and remote config will be unavailable"
-    );
-  } else {
-    runtime.log?.(`[config] Resolved agentId: ${agentId}`);
-  }
-  let remoteConfig = null;
-  const channelPolicies = /* @__PURE__ */ new Map();
-  const channelServerMap = /* @__PURE__ */ new Map();
-  const allChannelIds = [];
-  if (agentId) {
-    try {
-      remoteConfig = await client.getAgentConfig(agentId);
-      runtime.log?.(`[config] Fetched remote config: ${remoteConfig.servers.length} server(s)`);
-      for (const server of remoteConfig.servers) {
-        runtime.log?.(
-          `[config] Server "${server.name}" (${server.id}) \u2014 ${server.channels.length} channel(s)`
-        );
-        for (const ch of server.channels) {
-          channelPolicies.set(ch.id, ch.policy);
-          channelServerMap.set(ch.id, {
-            serverId: server.id,
-            serverSlug: server.slug ?? server.id,
-            serverName: server.name,
-            channelName: ch.name
-          });
-          if (ch.policy.listen) {
-            allChannelIds.push(ch.id);
-            runtime.log?.(
-              `[config]   \u2713 #${ch.name} (${ch.id}) \u2014 listen=true reply=${ch.policy.reply} mentionOnly=${ch.policy.mentionOnly}`
-            );
-          } else {
-            runtime.log?.(`[config]   \u2717 #${ch.name} (${ch.id}) \u2014 listen=false, skipping`);
-          }
-        }
-      }
-      runtime.log?.(
-        `[config] Monitoring ${allChannelIds.length} channel(s) across ${remoteConfig.servers.length} server(s)`
-      );
-      void saveSessionCache(accountId, { remoteConfig, botUserId, botUsername: me.username });
-    } catch (err) {
-      runtime.error?.(`[config] Failed to fetch remote config: ${String(err)}`);
-      const cached = await loadSessionCache(accountId);
-      if (cached) {
-        runtime.log?.("[config] Loaded session from cache \u2014 using cached config");
-        remoteConfig = cached.remoteConfig;
-        for (const server of remoteConfig.servers) {
-          for (const ch of server.channels) {
-            channelPolicies.set(ch.id, ch.policy);
-            channelServerMap.set(ch.id, {
-              serverId: server.id,
-              serverSlug: server.slug ?? server.id,
-              serverName: server.name,
-              channelName: ch.name
-            });
-            if (ch.policy.listen) allChannelIds.push(ch.id);
-          }
-        }
-        runtime.log?.(`[config] Restored ${allChannelIds.length} channel(s) from cache`);
-      } else {
-        runtime.log?.("[config] No cached session \u2014 falling back to monitoring no channels");
-      }
-    }
-  }
-  let heartbeatInterval = null;
-  if (agentId) {
-    const sendHeartbeat = async () => {
-      try {
-        await client.sendHeartbeat(agentId);
-        runtime.log?.("[heartbeat] Heartbeat sent");
-      } catch (err) {
-        runtime.error?.(`[heartbeat] Heartbeat failed: ${String(err)}`);
-      }
-    };
-    void sendHeartbeat();
-    heartbeatInterval = setInterval(sendHeartbeat, 3e4);
-  }
-  runtime.log?.(`[ws] Connecting to Shadow WebSocket at ${account.serverUrl}`);
-  const socket = new ShadowSocket({
-    serverUrl: account.serverUrl,
-    token: account.token,
-    transports: ["websocket", "polling"]
-  });
-  socket.onConnect(() => {
-    runtime.log?.(`[ws] Connected (sid=${socket.raw.id})`);
-    if (allChannelIds.length === 0) {
-      runtime.log?.("[ws] No channels to join \u2014 allChannelIds is empty");
-    }
-    for (const chId of allChannelIds) {
-      runtime.log?.(`[ws] Emitting channel:join for ${chId}`);
-      socket.joinChannel(chId).then((ack) => {
-        if (ack?.ok) runtime.log?.(`[ws] \u2713 Joined channel room ${chId} (server confirmed)`);
-        else runtime.log?.(`[ws] channel:join for ${chId} \u2014 no ack received (older server?)`);
-      });
-    }
-    runtime.log?.(
-      `[ws] Emitted channel:join for ${allChannelIds.length} channel(s), listening for messages`
-    );
-    (async () => {
-      try {
-        const dmChannels = await client.listDmChannels();
-        for (const ch of dmChannels) {
-          socket.joinDmChannel(ch.id);
-          runtime.log?.(`[ws] Joined DM room dm:${ch.id}`);
-        }
-        runtime.log?.(`[ws] Joined ${dmChannels.length} DM channel room(s)`);
-      } catch (err) {
-        runtime.error?.(`[ws] Failed to join DM rooms: ${String(err)}`);
-      }
-    })();
-  });
-  socket.onConnectError((err) => {
-    runtime.error?.(`[ws] Connection error: ${err.message}`);
-  });
-  socket.onDisconnect((reason) => {
-    runtime.log?.(`[ws] Disconnected: ${reason}`);
-  });
-  socket.raw.io.on("reconnect", (attempt) => {
-    runtime.log?.(`[ws] Reconnected after ${attempt} attempt(s)`);
-  });
-  socket.raw.io.on("reconnect_attempt", (attempt) => {
-    runtime.log?.(`[ws] Reconnect attempt #${attempt}`);
-  });
-  socket.on("server:joined", async (data) => {
-    if (!agentId) return;
-    runtime.log?.(`[ws] Received server:joined for server ${data.serverId} \u2014 refreshing channels`);
-    try {
-      const updatedConfig = await client.getAgentConfig(agentId);
-      runtime.log?.(`[config] Refreshed config: ${updatedConfig.servers.length} server(s)`);
-      for (const server of updatedConfig.servers) {
-        for (const ch of server.channels) {
-          channelServerMap.set(ch.id, {
-            serverId: server.id,
-            serverSlug: server.slug ?? server.id,
-            serverName: server.name,
-            channelName: ch.name
-          });
-          if (!channelPolicies.has(ch.id)) {
-            channelPolicies.set(ch.id, ch.policy);
-            if (ch.policy.listen) {
-              allChannelIds.push(ch.id);
-              runtime.log?.(`[config] New channel: #${ch.name} (${ch.id}) \u2014 joining`);
-              socket.joinChannel(ch.id).then((ack) => {
-                if (ack?.ok) runtime.log?.(`[ws] \u2713 Joined new channel room ${ch.id}`);
-              });
-            }
-          } else {
-            channelPolicies.set(ch.id, ch.policy);
-          }
-        }
-      }
-      remoteConfig = updatedConfig;
-    } catch (err) {
-      runtime.error?.(`[config] Failed to refresh config after server:joined: ${String(err)}`);
-    }
-  });
-  socket.on(
-    "channel:created",
-    async (data) => {
-      runtime.log?.(
-        `[ws] Received channel:created: #${data.name} (${data.id}) in server ${data.serverId} \u2014 ignoring (bot must be explicitly added)`
-      );
-    }
-  );
-  socket.on(
-    "agent:policy-changed",
-    (data) => {
-      if (data.agentId !== agentId) return;
-      if (!data.channelId) return;
-      const mentionOnly = data.mentionOnly ?? false;
-      runtime.log?.(
-        `[ws] Received agent:policy-changed for channel ${data.channelId}: mentionOnly=${mentionOnly}, reply=${data.reply}, config=${JSON.stringify(data.config ?? {})}`
-      );
-      const existing = channelPolicies.get(data.channelId);
-      if (existing) {
-        channelPolicies.set(data.channelId, {
-          ...existing,
-          mentionOnly,
-          reply: data.reply ?? existing.reply,
-          config: data.config ?? existing.config
-        });
-      } else {
-        channelPolicies.set(data.channelId, {
-          listen: true,
-          reply: data.reply ?? true,
-          mentionOnly,
-          config: data.config ?? {}
-        });
-      }
-    }
-  );
-  socket.on("channel:member-added", (data) => {
-    runtime.log?.(
-      `[ws] Received channel:member-added: channel ${data.channelId} in server ${data.serverId}`
-    );
-    if (!channelPolicies.has(data.channelId)) {
-      const defaultPolicy = {
-        listen: true,
-        reply: true,
-        mentionOnly: false,
-        config: {}
-      };
-      channelPolicies.set(data.channelId, defaultPolicy);
-      allChannelIds.push(data.channelId);
-    }
-    socket.joinChannel(data.channelId).then((ack) => {
-      if (ack?.ok) runtime.log?.(`[ws] \u2713 Joined channel room ${data.channelId} after member-added`);
-    });
-  });
-  socket.on("channel:member-removed", (data) => {
-    runtime.log?.(
-      `[ws] Received channel:member-removed: channel ${data.channelId} in server ${data.serverId}`
-    );
-    channelPolicies.delete(data.channelId);
-    const idx = allChannelIds.indexOf(data.channelId);
-    if (idx !== -1) allChannelIds.splice(idx, 1);
-    socket.leaveChannel(data.channelId);
-    runtime.log?.(`[ws] Left channel room ${data.channelId} after member-removed`);
-  });
-  const processedDmIds = /* @__PURE__ */ new Set();
-  socket.on(
-    "dm:message:new",
-    (dmMessage) => {
-      if (processedDmIds.has(dmMessage.id)) {
-        runtime.log?.(`[ws] Skipping duplicate dm:message:new ${dmMessage.id}`);
-        return;
-      }
-      processedDmIds.add(dmMessage.id);
-      if (processedDmIds.size > 500) {
-        const first = processedDmIds.values().next().value;
-        if (first) processedDmIds.delete(first);
-      }
-      const senderLabel = dmMessage.author?.username ?? dmMessage.senderId;
-      runtime.log?.(
-        `[ws] \u2190 dm:message:new from ${senderLabel} in DM ${dmMessage.dmChannelId}: "${dmMessage.content?.slice(0, 60)}" (${dmMessage.id})`
-      );
-      if (stopped) {
-        runtime.log?.("[ws] Monitor stopped, ignoring DM message");
-        return;
-      }
-      const processWithRetry = async (attempt = 0) => {
-        try {
-          await processShadowDmMessage({
-            dmMessage,
-            account,
-            accountId,
-            config,
-            runtime,
-            core,
-            botUserId,
-            botUsername: me.username,
-            shadowAgentId: agentId,
-            socket
-          });
-        } catch (err) {
-          const MAX_RETRIES = 2;
-          runtime.error?.(`[ws] DM processing failed (attempt ${attempt + 1}): ${String(err)}`);
-          if (attempt < MAX_RETRIES) {
-            await new Promise((r) => setTimeout(r, 1e3 * (attempt + 1)));
-            return processWithRetry(attempt + 1);
-          }
-          runtime.error?.(
-            `[ws] DM permanently failed after ${MAX_RETRIES + 1} attempts: ${dmMessage.id}`
-          );
-        }
-      };
-      void processWithRetry();
-    }
-  );
-  socket.on("message:new", (message) => {
-    const senderLabel = message.author?.username ?? message.authorId;
-    runtime.log?.(
-      `[ws] \u2190 message:new from ${senderLabel} in channel ${message.channelId}: "${message.content?.slice(0, 60)}" (${message.id})`
-    );
-    if (stopped) {
-      runtime.log?.("[ws] Monitor stopped, ignoring message");
-      return;
-    }
-    if (allChannelIds.length > 0 && !allChannelIds.includes(message.channelId)) {
-      runtime.log?.(`[ws] Message from unmonitored channel ${message.channelId}, ignoring`);
-      return;
-    }
-    const processWithRetry = async (attempt = 0) => {
-      try {
-        await processShadowMessage({
-          message,
-          account,
-          accountId,
-          config,
-          runtime,
-          core,
-          botUserId,
-          botUsername: me.username,
-          agentId,
-          channelPolicies,
-          channelServerMap,
-          socket
-        });
-      } catch (err) {
-        const MAX_RETRIES = 2;
-        runtime.error?.(`[ws] Message processing failed (attempt ${attempt + 1}): ${String(err)}`);
-        if (attempt < MAX_RETRIES) {
-          await new Promise((r) => setTimeout(r, 1e3 * (attempt + 1)));
-          return processWithRetry(attempt + 1);
-        }
-        runtime.error?.(
-          `[ws] Message permanently failed after ${MAX_RETRIES + 1} attempts: ${message.id}`
-        );
-      }
-    };
-    void processWithRetry();
-  });
-  socket.connect();
-  const stop = () => {
-    runtime.log?.("[lifecycle] Stopping Shadow monitor...");
-    stopped = true;
-    if (heartbeatInterval) clearInterval(heartbeatInterval);
-    socket.disconnect();
-    runtime.log?.("[lifecycle] Shadow monitor stopped");
-  };
-  abortSignal.addEventListener("abort", stop, { once: true });
-  await new Promise((resolve) => {
-    if (abortSignal.aborted) {
-      resolve();
-      return;
-    }
-    abortSignal.addEventListener("abort", () => resolve(), { once: true });
-  });
-  return { stop };
-}
-
-export {
-  setShadowRuntime,
-  getShadowRuntime,
-  tryGetShadowRuntime,
-  monitorShadowProvider
-};