@aka_openclaw_plugin/mychat 0.1.1 → 0.1.3

package/chunk-ZECSAALT.js

@@ -1,853 +0,0 @@
-import {
-  mychatConfigSchema
-} from "./chunk-5KQQEVLS.js";
-import {
-  getMychatRuntime,
-  init_runtime,
-  runtime_exports
-} from "./chunk-VJXCCUPC.js";
-import {
-  __esm,
-  __export,
-  __toCommonJS
-} from "./chunk-PNKVD2UK.js";
-
-// src/client/http-client.ts
-var http_client_exports = {};
-__export(http_client_exports, {
-  createMychatHttpClient: () => createMychatHttpClient
-});
-function createMychatHttpClient(params) {
-  const { baseUrl, token } = params;
-  const base = baseUrl.replace(/\/+$/, "");
-  async function request(method, path, body) {
-    try {
-      const headers = {
-        authorization: `Bearer ${token}`
-      };
-      if (body !== void 0) {
-        headers["content-type"] = "application/json";
-      }
-      const response = await fetch(`${base}${path}`, {
-        method,
-        headers,
-        body: body !== void 0 ? JSON.stringify(body) : void 0
-      });
-      if (!response.ok) {
-        return null;
-      }
-      return await response.json();
-    } catch {
-      return null;
-    }
-  }
-  return {
-    async getSelf() {
-      return request("GET", "/api/bot/self");
-    },
-    async getMe() {
-      return request("GET", "/api/auth/me");
-    },
-    async sendMessage(body) {
-      return request("POST", "/api/bot/messages", body);
-    },
-    async listMessages(params2) {
-      const searchParams = new URLSearchParams();
-      if (params2.conversationId) searchParams.set("conversationId", params2.conversationId);
-      if (params2.limit) searchParams.set("limit", String(params2.limit));
-      if (params2.after) searchParams.set("after", String(params2.after));
-      const qs = searchParams.toString();
-      const result = await request(
-        "GET",
-        `/api/bot/messages${qs ? `?${qs}` : ""}`
-      );
-      return result?.messages ?? [];
-    },
-    async addReaction(messageId, body) {
-      return request("POST", `/api/bot/messages/${messageId}/reactions`, body);
-    },
-    async removeReaction(messageId, emoji) {
-      return request("POST", `/api/bot/messages/${messageId}/reactions`, {
-        emoji,
-        action: "remove"
-      });
-    },
-    async uploadFile(params2) {
-      try {
-        const formData = new FormData();
-        let blob;
-        if (params2.file instanceof Blob) {
-          blob = params2.file;
-        } else {
-          const bytes = new Uint8Array(
-            params2.file.buffer,
-            params2.file.byteOffset,
-            params2.file.byteLength
-          );
-          blob = new Blob([bytes], { type: params2.mimeType });
-        }
-        formData.append("file", blob, params2.filename);
-        if (params2.scopeKind) formData.append("scopeKind", params2.scopeKind);
-        if (params2.scopeId) formData.append("scopeId", params2.scopeId);
-        const response = await fetch(`${base}/api/bot/uploads`, {
-          method: "POST",
-          headers: { authorization: `Bearer ${token}` },
-          body: formData
-        });
-        if (!response.ok) return null;
-        return await response.json();
-      } catch {
-        return null;
-      }
-    },
-    async healthCheck() {
-      const start = Date.now();
-      try {
-        const response = await fetch(`${base}/health`);
-        const latencyMs = Date.now() - start;
-        return { ok: response.ok, latencyMs };
-      } catch {
-        return { ok: false, latencyMs: Date.now() - start };
-      }
-    }
-  };
-}
-var init_http_client = __esm({
-  "src/client/http-client.ts"() {
-    "use strict";
-  }
-});
-
-// src/client/ws-client.ts
-var ws_client_exports = {};
-__export(ws_client_exports, {
-  createMychatWsClient: () => createMychatWsClient
-});
-function createMychatWsClient(params) {
-  const { wsUrl, token, botSelfId, reconnect } = params;
-  const initialDelay = reconnect?.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
-  const maxDelay = reconnect?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
-  const backoffMultiplier = reconnect?.backoffMultiplier ?? DEFAULT_BACKOFF_MULTIPLIER;
-  let ws = null;
-  let connected = false;
-  let reconnectTimer = null;
-  let currentDelay = initialDelay;
-  const handlers = /* @__PURE__ */ new Set();
-  function buildUrl() {
-    const url = new URL(wsUrl);
-    if (!url.pathname.includes("/ws/bot")) {
-      url.pathname = url.pathname.replace(/\/+$/, "") + "/ws/bot";
-    }
-    return url.toString();
-  }
-  function scheduleReconnect() {
-    if (reconnectTimer) return;
-    reconnectTimer = setTimeout(() => {
-      reconnectTimer = null;
-      currentDelay = Math.min(currentDelay * backoffMultiplier, maxDelay);
-      connect();
-    }, currentDelay);
-  }
-  function connect() {
-    if (ws) return;
-    try {
-      const url = buildUrl();
-      const urlWithToken = new URL(url);
-      urlWithToken.searchParams.set("token", token);
-      ws = new WebSocket(urlWithToken.toString());
-      ws.onopen = () => {
-        connected = true;
-        currentDelay = initialDelay;
-        if (botSelfId) {
-          ws?.send(
-            JSON.stringify({
-              type: "subscribe",
-              body: {
-                subscribe: {
-                  conversationId: botSelfId
-                }
-              }
-            })
-          );
-        }
-      };
-      ws.onmessage = (event) => {
-        try {
-          const message = JSON.parse(event.data);
-          for (const handler of handlers) {
-            handler(message);
-          }
-        } catch {
-        }
-      };
-      ws.onclose = () => {
-        connected = false;
-        ws = null;
-        scheduleReconnect();
-      };
-      ws.onerror = () => {
-        ws?.close();
-      };
-    } catch {
-      scheduleReconnect();
-    }
-  }
-  function disconnect() {
-    if (reconnectTimer) {
-      clearTimeout(reconnectTimer);
-      reconnectTimer = null;
-    }
-    connected = false;
-    ws?.close();
-    ws = null;
-  }
-  return {
-    connect,
-    disconnect,
-    onMessage(handler) {
-      handlers.add(handler);
-      return () => {
-        handlers.delete(handler);
-      };
-    },
-    isConnected() {
-      return connected;
-    }
-  };
-}
-var DEFAULT_INITIAL_DELAY_MS, DEFAULT_MAX_DELAY_MS, DEFAULT_BACKOFF_MULTIPLIER;
-var init_ws_client = __esm({
-  "src/client/ws-client.ts"() {
-    "use strict";
-    DEFAULT_INITIAL_DELAY_MS = 1e3;
-    DEFAULT_MAX_DELAY_MS = 3e4;
-    DEFAULT_BACKOFF_MULTIPLIER = 2;
-  }
-});
-
-// src/channel.ts
-import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
-
-// src/shared.ts
-import { createChannelPluginBase } from "openclaw/plugin-sdk/channel-core";
-
-// src/accounts.ts
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/channel-plugin-common";
-var DEFAULT_DM_POLICY = "open";
-var DEFAULT_GROUP_POLICY = "open";
-var DEFAULT_HISTORY_LIMIT = 50;
-var DEFAULT_MEDIA_MAX_MB = 10;
-function resolveWsUrl(baseUrl) {
-  const url = new URL(baseUrl);
-  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-  url.pathname = url.pathname.replace(/\/+$/, "") + "/ws/bot";
-  return url.toString();
-}
-function mergeAccountConfig(channel, account) {
-  if (!account) return channel;
-  return {
-    ...channel,
-    ...account,
-    actions: {
-      messages: account.actions?.messages ?? channel.actions?.messages ?? true,
-      threads: account.actions?.threads ?? channel.actions?.threads ?? true,
-      reactions: account.actions?.reactions ?? channel.actions?.reactions ?? true
-    },
-    groups: { ...channel.groups ?? {}, ...account.groups ?? {} },
-    reconnect: account.reconnect ?? channel.reconnect
-  };
-}
-function resolveMychatAccounts(cfg) {
-  const channelConfig = cfg.channels;
-  const mychatConfig = channelConfig?.mychat;
-  if (!mychatConfig) return [];
-  const accounts = mychatConfig.accounts ?? {};
-  const accountIds = Object.keys(accounts);
-  if (accountIds.length === 0) {
-    const resolved = resolveSingleAccount({
-      accountId: DEFAULT_ACCOUNT_ID,
-      config: mychatConfig
-    });
-    return resolved ? [resolved] : [];
-  }
-  return accountIds.map((id) => {
-    const merged = mergeAccountConfig(mychatConfig, accounts[id]);
-    return resolveSingleAccount({ accountId: id, config: merged });
-  }).filter(Boolean);
-}
-function resolveSingleAccount(params) {
-  const { accountId, config } = params;
-  const enabled = config.enabled ?? true;
-  if (!enabled) return null;
-  const token = resolveToken(config);
-  if (!token) return null;
-  const baseUrl = config.baseUrl.replace(/\/+$/, "");
-  const wsUrl = config.wsUrl ?? resolveWsUrl(baseUrl);
-  return {
-    accountId: normalizeAccountId(accountId),
-    enabled,
-    name: config.name,
-    baseUrl,
-    wsUrl,
-    token,
-    defaultTo: config.defaultTo,
-    dmPolicy: config.dmPolicy ?? DEFAULT_DM_POLICY,
-    groupPolicy: config.groupPolicy ?? DEFAULT_GROUP_POLICY,
-    allowFrom: config.allowFrom ?? [],
-    groupAllowFrom: config.groupAllowFrom ?? [],
-    requireMention: config.requireMention ?? false,
-    historyLimit: config.historyLimit ?? DEFAULT_HISTORY_LIMIT,
-    mediaMaxMb: config.mediaMaxMb ?? DEFAULT_MEDIA_MAX_MB,
-    actions: {
-      messages: config.actions?.messages ?? true,
-      threads: config.actions?.threads ?? true,
-      reactions: config.actions?.reactions ?? true
-    },
-    groups: config.groups ?? {},
-    reconnect: config.reconnect ?? {}
-  };
-}
-function resolveToken(config) {
-  if (config.token) return config.token;
-  if (typeof process !== "undefined") {
-    const envToken = process.env.MYCHAT_BOT_TOKEN;
-    if (envToken) return envToken;
-  }
-  return null;
-}
-function resolveMychatAccount(params) {
-  const accounts = resolveMychatAccounts(params.cfg);
-  if (accounts.length === 0) return null;
-  if (!params.accountId) return accounts[0];
-  return accounts.find((a) => a.accountId === params.accountId) ?? accounts[0] ?? null;
-}
-
-// src/logger.ts
-var PREFIX = "mychat";
-function mychatLogPrefix(feature) {
-  return `[${PREFIX}:${feature}]`;
-}
-function getMychatLogger() {
-  try {
-    const mod = (init_runtime(), __toCommonJS(runtime_exports));
-    const runtime = mod.tryGetMychatRuntime?.();
-    const logger = runtime?.logger;
-    if (!logger) return null;
-    return {
-      debug: (m) => logger.debug?.(m),
-      info: (m) => logger.info(m),
-      warn: (m) => logger.warn(m),
-      error: (m) => logger.error(m)
-    };
-  } catch {
-    return null;
-  }
-}
-
-// src/monitor/listeners.ts
-function createMychatMessageListener(params) {
-  const { handler } = params;
-  return {
-    handle(message) {
-      handler.handleMessage(message).catch(() => {
-      });
-    }
-  };
-}
-function createMychatReactionListener(params) {
-  const logger = getMychatLogger();
-  const prefix = mychatLogPrefix("reaction");
-  return {
-    handle(message) {
-      const emoji = message.body?.reaction;
-      const action = message.body?.action ?? "add";
-      const target = message.body?.target;
-      const senderId = message.from?.id;
-      if (logger) logger.debug(`${prefix} ${action} ${emoji} on ${target} by ${senderId}`);
-    }
-  };
-}
-function createMychatTypingListener(params) {
-  const logger = getMychatLogger();
-  const prefix = mychatLogPrefix("typing");
-  return {
-    handle(message) {
-      const senderId = message.from?.id;
-      if (senderId === params.account.accountId) return;
-      if (logger) logger.debug(`${prefix} from ${senderId}`);
-    }
-  };
-}
-
-// src/monitor/provider.startup.ts
-function createMychatProviderClients(account, botSelfId) {
-  const { createMychatHttpClient: createMychatHttpClient2 } = (init_http_client(), __toCommonJS(http_client_exports));
-  const { createMychatWsClient: createMychatWsClient2 } = (init_ws_client(), __toCommonJS(ws_client_exports));
-  const httpClient = createMychatHttpClient2({
-    baseUrl: account.baseUrl,
-    token: account.token
-  });
-  const wsClient = createMychatWsClient2({
-    wsUrl: account.wsUrl,
-    token: account.token,
-    botSelfId,
-    reconnect: account.reconnect
-  });
-  return { httpClient, wsClient };
-}
-function registerMychatMonitorListeners(params) {
-  const { account, handler, wsClient } = params;
-  const messageListener = createMychatMessageListener({ account, handler });
-  const reactionListener = createMychatReactionListener({ account });
-  const typingListener = createMychatTypingListener({ account });
-  wsClient.onMessage((message) => {
-    switch (message.type) {
-      case "message":
-      case "stream":
-        messageListener.handle(message);
-        break;
-      case "reaction":
-        reactionListener.handle(message);
-        break;
-      case "typing":
-        typingListener.handle(message);
-        break;
-      default:
-        break;
-    }
-  });
-}
-
-// src/monitor/provider.lifecycle.ts
-var DEFAULT_READY_TIMEOUT_MS = 15e3;
-function createMychatProviderLifecycle(params) {
-  const { httpClient, wsClient, readyTimeoutMs = DEFAULT_READY_TIMEOUT_MS } = params;
-  const logger = getMychatLogger();
-  const prefix = mychatLogPrefix("lifecycle");
-  return {
-    async waitForReady() {
-      const start = Date.now();
-      wsClient.connect();
-      while (Date.now() - start < readyTimeoutMs) {
-        if (wsClient.isConnected()) {
-          const botSelf = await httpClient.getSelf();
-          if (botSelf) {
-            logger?.info(`${prefix} bot connected botId=${botSelf.botId}`);
-            return botSelf;
-          }
-        }
-        await new Promise((r) => setTimeout(r, 500));
-      }
-      logger?.warn(`${prefix} ready timeout`);
-      return null;
-    },
-    shutdown() {
-      wsClient.disconnect();
-      logger?.info(`${prefix} shutdown`);
-    }
-  };
-}
-
-// src/monitor/inbound-dedupe.ts
-var MAX_CACHE_SIZE = 500;
-function createMychatInboundDedupe() {
-  const seen = /* @__PURE__ */ new Set();
-  return {
-    isDuplicate(messageId) {
-      if (seen.has(messageId)) return true;
-      seen.add(messageId);
-      if (seen.size > MAX_CACHE_SIZE) {
-        const first = seen.values().next().value;
-        if (first !== void 0) seen.delete(first);
-      }
-      return false;
-    }
-  };
-}
-
-// src/monitor/message-text.ts
-function extractMychatMessageText(message) {
-  return message.body?.text ?? "";
-}
-function extractMentionUserIds(message) {
-  const mentions = message.body?.mentions ?? [];
-  return mentions.map((m) => m.userId).filter(Boolean);
-}
-function isBotMentioned(message, botUserId) {
-  if (!botUserId) return false;
-  const mentionIds = extractMentionUserIds(message);
-  if (mentionIds.includes(botUserId)) return true;
-  const text = message.body?.text ?? "";
-  return text.includes(`@${botUserId}`);
-}
-
-// src/monitor/message-handler.preflight.ts
-function mychatPreflight(message, account) {
-  const senderId = message.from?.id;
-  if (!senderId) {
-    return { allowed: false, reason: "no-sender" };
-  }
-  if (senderId === account.accountId) {
-    return { allowed: false, reason: "self" };
-  }
-  const toKind = message.to?.kind ?? "direct";
-  if (toKind === "direct" || toKind === "channel") {
-    if (account.dmPolicy === "disabled") {
-      return { allowed: false, reason: "dm-disabled" };
-    }
-    if (account.dmPolicy === "allowlist" && account.allowFrom.length > 0) {
-      if (!account.allowFrom.includes(senderId)) {
-        return { allowed: false, reason: "dm-not-allowed" };
-      }
-    }
-  }
-  if (toKind === "group") {
-    if (account.groupPolicy === "disabled") {
-      return { allowed: false, reason: "group-disabled" };
-    }
-    if (account.groupPolicy === "allowlist" && account.groupAllowFrom.length > 0) {
-      if (!account.groupAllowFrom.includes(senderId)) {
-        return { allowed: false, reason: "group-not-allowed" };
-      }
-    }
-    const groupId = message.to?.id;
-    if (groupId && account.groups[groupId]) {
-      const groupConfig = account.groups[groupId];
-      if (groupConfig.enabled === false) {
-        return { allowed: false, reason: "group-disabled" };
-      }
-      if (groupConfig.requireMention && !isBotMentioned(message, account.accountId)) {
-        return { allowed: false, reason: "mention-required" };
-      }
-    }
-    if (account.requireMention && !isBotMentioned(message, account.accountId)) {
-      return { allowed: false, reason: "mention-required" };
-    }
-  }
-  return { allowed: true };
-}
-
-// src/monitor/inbound-context.ts
-function buildMychatInboundContext(message, account) {
-  if (message.type !== "message" && message.type !== "stream") return null;
-  const senderId = message.from?.id;
-  if (!senderId) return null;
-  const text = message.body?.text ?? "";
-  const toKind = message.to?.kind ?? "direct";
-  const chatType = toKind === "group" || toKind === "channel" ? "group" : "direct";
-  return {
-    messageId: message.id,
-    text,
-    senderId,
-    senderName: message.from?.name,
-    chatType,
-    conversationId: message.to?.id ?? message.body?.conversationId,
-    threadId: message.body?.parentId,
-    replyTo: message.body?.parentId,
-    mentions: message.body?.mentions ?? [],
-    attachments: message.body?.attachments ?? [],
-    timestamp: message.timestamp
-  };
-}
-
-// src/monitor/message-media.ts
-function resolveMychatMediaAttachments(message) {
-  const attachments = message.body?.attachments ?? [];
-  return attachments.filter(
-    (a) => a.url && (a.mimeType.startsWith("image/") || a.mimeType.startsWith("video/") || a.mimeType.startsWith("audio/") || a.mimeType === "application/pdf")
-  );
-}
-
-// src/monitor/message-handler.process.ts
-function processMychatInbound(message, account) {
-  const context = buildMychatInboundContext(message, account);
-  if (!context) return null;
-  const text = extractMychatMessageText(message);
-  const media = resolveMychatMediaAttachments(message);
-  return { context, text, media };
-}
-
-// src/monitor/message-handler.ts
-function createMychatMessageHandler(params) {
-  const { account, onInbound } = params;
-  const dedupe = createMychatInboundDedupe();
-  const logger = getMychatLogger();
-  const prefix = mychatLogPrefix("handler");
-  return {
-    async handleMessage(message) {
-      if (dedupe.isDuplicate(message.id)) return;
-      const preflight = mychatPreflight(message, account);
-      if (!preflight.allowed) {
-        if (logger) logger.debug(`${prefix} message rejected reason=${preflight.reason} messageId=${message.id}`);
-        return;
-      }
-      const result = processMychatInbound(message, account);
-      if (!result) return;
-      if (logger) logger.debug(`${prefix} message accepted messageId=${result.context.messageId} chatType=${result.context.chatType}`);
-      await onInbound(result);
-    }
-  };
-}
-
-// src/monitor/provider.ts
-async function monitorMychatProvider(ctx, account) {
-  const logger = getMychatLogger();
-  const prefix = mychatLogPrefix("provider");
-  if (logger) logger.info(`${prefix} starting accountId=${account.accountId}`);
-  const { createMychatHttpClient: createMychatHttpClient2 } = (init_http_client(), __toCommonJS(http_client_exports));
-  const httpClient = createMychatHttpClient2({
-    baseUrl: account.baseUrl,
-    token: account.token
-  });
-  const botSelf = await httpClient.getSelf();
-  if (!botSelf) {
-    if (logger) logger.error(`${prefix} failed to get bot identity`);
-    throw new Error("MyChat provider failed to get bot identity");
-  }
-  const health = await httpClient.healthCheck();
-  if (!health.ok) {
-    if (logger) logger.warn(`${prefix} health check failed latencyMs=${health.latencyMs}`);
-  }
-  const { wsClient } = createMychatProviderClients(account, botSelf.botId);
-  const handler = createMychatMessageHandler({
-    account,
-    onInbound: async (result) => {
-      ctx.runtime?.channel?.turn?.({
-        text: result.text,
-        context: result.context,
-        media: result.media
-      });
-    }
-  });
-  registerMychatMonitorListeners({ account, handler, wsClient });
-  const lifecycle = createMychatProviderLifecycle({ httpClient, wsClient });
-  const readyBotSelf = await lifecycle.waitForReady();
-  if (!readyBotSelf) {
-    if (logger) logger.error(`${prefix} failed to connect`);
-    lifecycle.shutdown();
-    throw new Error("MyChat provider failed to connect");
-  }
-  return {
-    unsubscribe() {
-      lifecycle.shutdown();
-    }
-  };
-}
-
-// src/shared.ts
-function createMychatPluginBase() {
-  const base = createChannelPluginBase({
-    id: "mychat",
-    setup: {
-      applyAccountConfig(params) {
-        return params.cfg;
-      }
-    },
-    meta: {
-      label: "MyChat",
-      docsPath: "docs/plugins/mychat",
-      blurb: "Connect to MyChat server via bot token",
-      aliases: ["mychat"]
-    },
-    capabilities: {
-      chatTypes: ["direct", "group", "thread"],
-      reactions: true,
-      media: true,
-      threads: true
-    },
-    reload: { configPrefixes: ["channels.mychat"] },
-    configSchema: mychatConfigSchema,
-    config: {
-      listAccountIds(cfg) {
-        return resolveMychatAccounts(cfg).map((a) => a.accountId);
-      },
-      resolveAccount(cfg, accountId) {
-        return resolveMychatAccount({ cfg, accountId });
-      },
-      async inspectAccount(account) {
-        return {
-          accountId: account.accountId,
-          enabled: account.enabled,
-          label: account.name ?? account.baseUrl
-        };
-      }
-    }
-  });
-  return {
-    ...base,
-    gateway: {
-      async startAccount(ctx) {
-        const result = await monitorMychatProvider(ctx, ctx.account);
-        return {
-          unsubscribe: result.unsubscribe
-        };
-      }
-    }
-  };
-}
-
-// src/outbound/outbound-adapter.ts
-init_runtime();
-
-// src/outbound/outbound-payload.ts
-async function sendMychatOutboundPayload(ctx, body) {
-  const logger = getMychatLogger();
-  const prefix = mychatLogPrefix("outbound");
-  try {
-    const result = await ctx.httpClient.sendMessage(body);
-    if (result) {
-      if (logger) logger.debug(`${prefix} message sent id=${result.id} status=${result.status}`);
-      return { messageId: result.id, ok: true };
-    }
-    return { ok: false };
-  } catch (error) {
-    if (logger) logger.error(`${prefix} send failed error=${error instanceof Error ? error.message : String(error)}`);
-    return { ok: false };
-  }
-}
-
-// src/outbound/outbound-send-context.ts
-function createMychatOutboundSendContext(params) {
-  return {
-    account: params.account,
-    httpClient: params.httpClient
-  };
-}
-
-// src/outbound/outbound-adapter.ts
-var TEXT_CHUNK_LIMIT = 4e3;
-function chunkText(text, limit) {
-  if (text.length <= limit) return [text];
-  const chunks = [];
-  let remaining = text;
-  while (remaining.length > 0) {
-    chunks.push(remaining.slice(0, limit));
-    remaining = remaining.slice(limit);
-  }
-  return chunks;
-}
-var mychatOutbound = {
-  deliveryMode: "direct",
-  textChunkLimit: TEXT_CHUNK_LIMIT,
-  async sendText(params) {
-    const logger = getMychatLogger();
-    const runtime = getMychatRuntime();
-    const account = runtime.mychat;
-    if (!account) {
-      if (logger) logger.error(`${mychatLogPrefix("outbound")} no runtime account`);
-      return { channel: "mychat", messageId: "", ok: false };
-    }
-    const ctx = createMychatOutboundSendContext({
-      account: params.account ?? {},
-      httpClient: account.httpClient
-    });
-    const chunks = chunkText(params.text, TEXT_CHUNK_LIMIT);
-    let lastOk = false;
-    let lastMessageId = "";
-    for (const chunk of chunks) {
-      const result = await sendMychatOutboundPayload(ctx, {
-        to: params.target ?? "",
-        text: chunk,
-        type: params.chatType,
-        replyTo: params.replyTo
-      });
-      lastOk = result.ok;
-      if (result.messageId) lastMessageId = result.messageId;
-    }
-    return { channel: "mychat", messageId: lastMessageId, ok: lastOk };
-  },
-  async sendMedia(params) {
-    const logger = getMychatLogger();
-    const runtime = getMychatRuntime();
-    const account = runtime.mychat;
-    if (!account) {
-      if (logger) logger.error(`${mychatLogPrefix("outbound")} no runtime account`);
-      return { channel: "mychat", messageId: "", ok: false };
-    }
-    if (params.media) {
-      const uploadResult = await account.httpClient.uploadFile({
-        file: params.media,
-        filename: params.filename ?? "upload",
-        mimeType: params.mimeType ?? "application/octet-stream"
-      });
-      if (uploadResult) {
-        const ctx = createMychatOutboundSendContext({
-          account: params.account ?? {},
-          httpClient: account.httpClient
-        });
-        const result = await sendMychatOutboundPayload(ctx, {
-          to: params.target ?? "",
-          text: params.text ?? "",
-          type: params.chatType,
-          attachments: [uploadResult.attachment]
-        });
-        return { channel: "mychat", messageId: result.messageId ?? "", ok: result.ok };
-      }
-    }
-    return { channel: "mychat", messageId: "", ok: false };
-  },
-  async sendPayload(params) {
-    const logger = getMychatLogger();
-    const runtime = getMychatRuntime();
-    const account = runtime.mychat;
-    if (!account) {
-      if (logger) logger.error(`${mychatLogPrefix("outbound")} no runtime account`);
-      return { channel: "mychat", messageId: "", ok: false };
-    }
-    const ctx = createMychatOutboundSendContext({
-      account: params.account ?? {},
-      httpClient: account.httpClient
-    });
-    const result = await sendMychatOutboundPayload(ctx, {
-      to: params.target ?? "",
-      text: params.text ?? "",
-      type: params.chatType,
-      replyTo: params.replyTo
-    });
-    return { channel: "mychat", messageId: result.messageId ?? "", ok: result.ok };
-  }
-};
-
-// src/threading/threading.ts
-var mychatThreading = {
-  replyToMode: "always",
-  resolveReplyTo(params) {
-    return {
-      threadId: params.inbound?.threadId ?? params.inbound?.conversationId,
-      replyTo: params.inbound?.messageId
-    };
-  },
-  sanitizeThreadName(name) {
-    return name.slice(0, 100).replace(/[^\w\s-]/g, "");
-  }
-};
-
-// src/channel.ts
-var mychatPlugin = createChatChannelPlugin({
-  base: createMychatPluginBase(),
-  security: {
-    dm: {
-      channelKey: "dmPolicy",
-      resolvePolicy(account) {
-        return account.dmPolicy ?? "open";
-      },
-      resolveAllowFrom(account) {
-        return account.allowFrom;
-      }
-    }
-  },
-  pairing: {
-    text: {
-      idLabel: "MyChat Username",
-      message: "To connect to MyChat, configure your bot token and server URL in the channel config.",
-      notify() {
-      }
-    }
-  },
-  threading: mychatThreading,
-  outbound: mychatOutbound
-});
-
-export {
-  mychatPlugin
-};