polycopy 0.1.1 → 0.1.4

package/dist/cli.js

@@ -155,7 +155,7 @@ function findPolycopyPids() {
     return pid;
   }).filter((pid) => pid !== null);
 }
-function stopDaemon() {
+async function stopDaemon() {
   const pid = getRunningPid();
   if (!pid) {
     const fallbackPids = findPolycopyPids();
@@ -166,39 +166,46 @@ function stopDaemon() {
     console.log(
       `⚠️  未找到 PID 文件，尝试停止前台/后台进程 (${fallbackPids.length} 个)`
     );
-    fallbackPids.forEach((fallbackPid) => {
-      try {
-        process.kill(fallbackPid, "SIGTERM");
-        console.log(`✅ 已发送停止信号 (PID: ${fallbackPid})`);
-      } catch (error) {
-        console.error(`❌ 停止失败 (PID: ${fallbackPid}):`, error);
-      }
-    });
+    await Promise.all(
+      fallbackPids.map((fallbackPid) => stopPid(fallbackPid))
+    );
     return;
   }
+  await stopPid(pid, true);
+}
+async function stopPid(pid, isPrimary = false) {
   try {
     process.kill(pid, "SIGTERM");
     console.log(`✅ 已发送停止信号 (PID: ${pid})`);
-    let attempts = 0;
-    const checkInterval = setInterval(() => {
-      attempts++;
-      try {
-        process.kill(pid, 0);
-        if (attempts >= 10) {
-          process.kill(pid, "SIGKILL");
-          console.log("⚠️  进程未响应，已强制终止");
-          clearInterval(checkInterval);
-          removePid();
-        }
-      } catch {
-        console.log("✅ 进程已停止");
-        clearInterval(checkInterval);
+  } catch (error) {
+    console.error(`❌ 停止失败 (PID: ${pid}):`, error);
+    if (isPrimary) {
+      removePid();
+    }
+    return;
+  }
+  const maxAttempts = 20;
+  for (let attempts = 0; attempts < maxAttempts; attempts++) {
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    try {
+      process.kill(pid, 0);
+    } catch {
+      console.log("✅ 进程已停止");
+      if (isPrimary) {
         removePid();
       }
-    }, 500);
+      return;
+    }
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+    console.log("⚠️  进程未响应，已强制终止");
   } catch (error) {
-    console.error("❌ 停止失败:", error);
-    removePid();
+    console.error(`❌ 强制终止失败 (PID: ${pid}):`, error);
+  } finally {
+    if (isPrimary) {
+      removePid();
+    }
   }
 }
 async function runConfig() {
@@ -272,7 +279,7 @@ async function main() {
   const command = args[0];
   switch (command) {
     case "stop":
-      stopDaemon();
+      await stopDaemon();
       break;
     case "log":
     case "logs":

package/dist/config.js

@@ -1,5 +1,5 @@
 "use strict";
-const init = require("./init-C5cwUXyD.js");
+const init = require("./init-Bs-N_AZi.js");
 async function main() {
   try {
     await init.runConfigWizard();

package/dist/index.js

@@ -1,5 +1,5 @@
 "use strict";
-const init = require("./init-C5cwUXyD.js");
+const init = require("./init-Bs-N_AZi.js");
 const grammy = require("grammy");
 const wallet = require("@ethersproject/wallet");
 const clobClient = require("@polymarket/clob-client");
@@ -32,23 +32,445 @@ function _interopNamespace(e) {
 }
 const setPromiseInterval__default = /* @__PURE__ */ _interopDefault(setPromiseInterval);
 const fs__namespace = /* @__PURE__ */ _interopNamespace(fs);
-class Notifier {
+function parseSignalMetadata(messageText) {
+  const match = messageText.match(/🤖\s*({.*})/s);
+  if (!match) {
+    return null;
+  }
+  try {
+    const jsonStr = match[1];
+    const metadata = JSON.parse(jsonStr);
+    if (!metadata.eventId || !metadata.assetId || !metadata.outcome || !metadata.endTime) {
+      init.logger.error("解析失败: 缺少必需字段", {
+        hasEventId: !!metadata.eventId,
+        hasAssetId: !!metadata.assetId,
+        hasOutcome: !!metadata.outcome,
+        hasEndTime: !!metadata.endTime
+      });
+      return null;
+    }
+    if (metadata.outcome !== "Up" && metadata.outcome !== "Down") {
+      init.logger.error("解析失败: outcome 值无效", {
+        outcome: metadata.outcome,
+        expected: "Up 或 Down"
+      });
+      return null;
+    }
+    if (typeof metadata.endTime !== "number" || metadata.endTime <= 0) {
+      init.logger.error("解析失败: endTime 值无效", {
+        endTime: metadata.endTime,
+        expected: "毫秒级时间戳"
+      });
+      return null;
+    }
+    return metadata;
+  } catch (error) {
+    init.logger.error("解析信号元数据失败:", error);
+    if (error instanceof Error) {
+      init.logger.line("", `错误详情: ${error.message}`);
+    }
+    return null;
+  }
+}
+class TelegramListener {
+  bot;
+  onSignalCallback;
+  onChatIdsChangedCallback;
+  targetChatIds;
+  // 运行时监听的频道 ID 集合（自动管理）
+  constructor(bot, targetChatIds = []) {
+    this.bot = bot;
+    this.targetChatIds = new Set(targetChatIds);
+    this.setupHandlers();
+  }
+  /**
+   * 设置消息处理器
+   */
+  setupHandlers() {
+    this.bot.on("channel_post", async (ctx) => {
+      await this.handleChannelPost(ctx);
+    });
+    this.bot.on("edited_channel_post", async (ctx) => {
+      await this.handleChannelPost(ctx);
+    });
+    this.bot.on("my_chat_member", async (ctx) => {
+      await this.handleMyChatMemberUpdate(ctx);
+    });
+    this.bot.catch((err) => {
+      init.logger.error("Telegram Bot 错误:", err);
+      if (err.error) {
+        init.logger.line("", `错误详情: ${err.error}`);
+      }
+      if (err.ctx) {
+        init.logger.line("", `上下文信息:`, {
+          chatId: err.ctx.chat?.id,
+          messageId: err.ctx.message?.message_id
+        });
+      }
+    });
+  }
+  /**
+   * 处理 Bot 自己的成员状态变更
+   */
+  async handleMyChatMemberUpdate(ctx) {
+    const update = ctx.myChatMember;
+    if (!update) {
+      return;
+    }
+    const chatId = update.chat.id;
+    const chatTitle = update.chat.title || "未知频道";
+    const oldStatus = update.old_chat_member.status;
+    const newStatus = update.new_chat_member.status;
+    const chatType = update.chat.type;
+    if (chatType !== "channel") {
+      return;
+    }
+    const isAdmin = newStatus === "administrator" || newStatus === "creator";
+    const wasAdmin = oldStatus === "administrator" || oldStatus === "creator";
+    const isRemoved = newStatus === "left" || newStatus === "kicked";
+    const wasRemoved = oldStatus === "left" || oldStatus === "kicked";
+    if (oldStatus !== newStatus) {
+      let action = "";
+      let canListen = false;
+      let reason = "";
+      if (isRemoved) {
+        action = "❌ 频道主已移除 Bot";
+        canListen = false;
+        reason = "Bot 已被移除";
+      } else if (wasRemoved && isAdmin) {
+        action = "✅ 频道主已添加 Bot 为管理员";
+        canListen = true;
+      } else if (isAdmin && !wasAdmin) {
+        action = "✅ 频道主已授予 Bot 管理员权限";
+        canListen = true;
+      } else if (wasAdmin && !isAdmin) {
+        action = "⚠️  频道主已移除 Bot 的管理员权限";
+        canListen = false;
+        reason = "Bot 不再是管理员";
+      } else if (wasRemoved && !isAdmin) {
+        action = "⚠️  频道主已添加 Bot，但未授予管理员权限";
+        canListen = false;
+        reason = "需要管理员权限才能监听";
+      } else if (oldStatus === "restricted" && isAdmin) {
+        action = "✅ 频道主已授予 Bot 管理员权限";
+        canListen = true;
+      } else if (wasAdmin && newStatus === "restricted") {
+        action = "⚠️  频道主已限制 Bot 的权限";
+        canListen = false;
+        reason = "Bot 权限受限，无法监听";
+      } else if (oldStatus === "restricted" && !isAdmin) {
+        action = `状态变更: ${oldStatus} → ${newStatus}`;
+        canListen = false;
+        reason = "需要管理员权限才能监听";
+      } else {
+        action = `状态变更: ${oldStatus} → ${newStatus}`;
+        canListen = isAdmin;
+        if (!canListen) {
+          reason = "需要管理员权限才能监听";
+        }
+      }
+      init.logger.info(`📢 频道状态更新: ${chatTitle}`);
+      init.logger.line("", action);
+      init.logger.line(
+        "",
+        `当前状态: ${canListen ? "✅ 可监听预测消息" : "❌ 无法监听预测消息"}`
+      );
+      if (reason) {
+        init.logger.line("", `原因: ${reason}`);
+      }
+    }
+    if (isAdmin && !this.targetChatIds.has(chatId)) {
+      this.targetChatIds.add(chatId);
+      await this.saveChatIds();
+      init.logger.line("📡", "已自动开始监听此频道");
+    }
+    if ((isRemoved || !isAdmin) && this.targetChatIds.has(chatId)) {
+      this.targetChatIds.delete(chatId);
+      await this.saveChatIds();
+      if (isRemoved) {
+        init.logger.line("⏹️", "已停止监听此频道（Bot 已被移除）");
+      } else {
+        init.logger.line("⏹️", "已停止监听此频道（Bot 不再是管理员）");
+      }
+    }
+  }
+  /**
+   * 保存频道 ID 列表到配置（用于持久化）
+   */
+  async saveChatIds() {
+    if (!this.onChatIdsChangedCallback) {
+      return;
+    }
+    try {
+      const chatIds = Array.from(this.targetChatIds);
+      await this.onChatIdsChangedCallback(chatIds);
+    } catch (error) {
+      init.logger.error("保存频道 ID 列表时出错:", error);
+    }
+  }
+  /**
+   * 处理频道消息（channel_post 和 edited_channel_post）
+   */
+  async handleChannelPost(ctx) {
+    const message = ctx.channelPost || ctx.editedChannelPost;
+    if (!message) {
+      return;
+    }
+    await this.processMessage(message, ctx);
+  }
+  /**
+   * 处理频道消息（统一的消息处理逻辑）
+   */
+  async processMessage(message, ctx) {
+    if (!message) {
+      return;
+    }
+    const chatId = message.chat.id;
+    const chatTitle = message.chat.title || "未知频道";
+    const isChannel = chatId < 0 && chatId.toString().startsWith("-100");
+    const messageText = message.text || message.caption || "";
+    if (!messageText) {
+      return;
+    }
+    if (isChannel && !this.targetChatIds.has(chatId)) {
+      this.targetChatIds.add(chatId);
+      init.logger.info(`➕ 自动添加频道到监听列表: ${chatTitle} (ID: ${chatId})`);
+      await this.saveChatIds();
+      init.logger.line("💾", "已保存到配置文件");
+    }
+    if (!isChannel) {
+      return;
+    }
+    if (!this.targetChatIds.has(chatId)) {
+      return;
+    }
+    const metadata = parseSignalMetadata(messageText);
+    if (!metadata) {
+      if (messageText.includes("🤖")) {
+        const emojiIndex = messageText.indexOf("🤖");
+        const jsonStart = emojiIndex + 1;
+        const jsonEnd = Math.min(jsonStart + 200, messageText.length);
+        init.logger.warning(`解析预测消息失败:`);
+        init.logger.line("", `频道 ID: ${chatId}`);
+        init.logger.line(
+          "",
+          `消息片段: ${messageText.substring(emojiIndex, jsonEnd)}${messageText.length > jsonEnd ? "..." : ""}`
+        );
+        init.logger.line("", "提示: 请检查消息格式是否正确");
+      }
+      return;
+    }
+    const parsedSignal = {
+      metadata,
+      rawMessage: messageText,
+      messageId: message.message_id,
+      chatId,
+      timestamp: message.date * 1e3
+    };
+    if (this.onSignalCallback) {
+      try {
+        await this.onSignalCallback(parsedSignal);
+      } catch (error) {
+        init.logger.error("处理信号时出错:", error);
+      }
+    }
+  }
+  /**
+   * 设置信号回调函数
+   */
+  onSignal(callback) {
+    this.onSignalCallback = callback;
+  }
+  /**
+   * 设置频道 ID 列表变更回调函数（当频道自动添加/移除时调用，用于持久化）
+   */
+  onChatIdsChanged(callback) {
+    this.onChatIdsChangedCallback = callback;
+  }
+  /**
+   * 设置监听的频道 ID 列表（用于启动时加载已保存的配置）
+   */
+  setTargetChatIds(chatIds) {
+    this.targetChatIds = new Set(chatIds);
+  }
+  /**
+   * 启动监听
+   * @param onReady 可选回调，在频道检查完成后、开始监听之前调用
+   */
+  async start(onReady) {
+    try {
+      init.logger.info("正在启动 Bot...");
+      const botInfo = await this.bot.api.getMe();
+      const botId = botInfo.id;
+      init.logger.info(`Bot 信息: @${botInfo.username} (ID: ${botId})`);
+      await this.checkAndDisplayChannels(botId);
+      if (onReady) {
+        await onReady();
+      }
+      init.logger.info("开始监听预测消息...");
+      await this.bot.start({
+        drop_pending_updates: true,
+        allowed_updates: [
+          "channel_post",
+          "edited_channel_post",
+          "my_chat_member"
+        ]
+      });
+    } catch (error) {
+      init.logger.error("启动 Bot 失败:", error);
+      throw error;
+    }
+  }
+  /**
+   * 检查并显示 Bot 所在的频道
+   * 验证配置文件中保存的频道，检查 Bot 是否仍在频道中以及是否是管理员
+   */
+  async checkAndDisplayChannels(botId) {
+    const chatIds = Array.from(this.targetChatIds);
+    if (chatIds.length === 0) {
+      init.logger.info(`📋 当前没有保存的频道配置`);
+      init.logger.line(
+        "",
+        "提示: 当 Bot 被添加为频道管理员时，会自动添加到监听列表"
+      );
+      return;
+    }
+    init.logger.info(`📋 检查 Bot 所在的频道:`);
+    const validChannels = [];
+    const invalidChannels = [];
+    for (const chatId of chatIds) {
+      try {
+        const chat = await this.bot.api.getChat(chatId);
+        const chatTitle = chat.title || "未知频道";
+        try {
+          const member = await this.bot.api.getChatMember(chatId, botId);
+          const isAdmin = member.status === "administrator" || member.status === "creator";
+          validChannels.push({
+            id: chatId,
+            title: chatTitle,
+            isAdmin
+          });
+        } catch (error) {
+          invalidChannels.push({
+            id: chatId,
+            reason: "无法获取成员信息（可能已被移除）"
+          });
+        }
+      } catch (error) {
+        invalidChannels.push({
+          id: chatId,
+          reason: "无法获取频道信息（可能已被移除）"
+        });
+      }
+    }
+    if (validChannels.length > 0) {
+      const adminChannels = validChannels.filter((c) => c.isAdmin);
+      const nonAdminChannels = validChannels.filter((c) => !c.isAdmin);
+      if (adminChannels.length > 0) {
+        init.logger.info(`📡 可监听频道 (${adminChannels.length} 个):`);
+        adminChannels.forEach((channel, index) => {
+          init.logger.item(
+            `${index + 1}. ${channel.title} (ID: ${channel.id}) 👑 管理员`,
+            1
+          );
+        });
+      }
+      if (nonAdminChannels.length > 0) {
+        init.logger.warning(`无法监听频道 (${nonAdminChannels.length} 个):`);
+        nonAdminChannels.forEach((channel, index) => {
+          init.logger.item(`${index + 1}. ${channel.title}`, 1);
+          init.logger.item(`ID: ${channel.id}`, 2);
+          init.logger.item(`状态: 🚫 非管理员（无法接收预测消息）`, 2);
+          init.logger.item(`原因: 需要管理员权限才能监听`, 2);
+        });
+        nonAdminChannels.forEach((channel) => {
+          this.targetChatIds.delete(channel.id);
+        });
+        if (nonAdminChannels.length > 0) {
+          await this.saveChatIds();
+          init.logger.line("💾", "已清理无法监听的频道并保存配置");
+        }
+      }
+    }
+    if (invalidChannels.length > 0) {
+      init.logger.error(`无效频道 (${invalidChannels.length} 个):`);
+      invalidChannels.forEach((channel, index) => {
+        init.logger.item(`${index + 1}. ID: ${channel.id}`, 1);
+        init.logger.item(`原因: ${channel.reason}`, 2);
+      });
+      invalidChannels.forEach((channel) => {
+        this.targetChatIds.delete(channel.id);
+      });
+      if (invalidChannels.length > 0) {
+        await this.saveChatIds();
+        init.logger.line("💾", "已清理无效频道并保存配置");
+      }
+    }
+  }
+  /**
+   * 停止监听
+   */
+  async stop() {
+    await this.bot.stop();
+  }
+  /**
+   * 获取 bot 信息（用于验证 token 是否有效）
+   */
+  async getBotInfo() {
+    try {
+      return this.bot.api.getMe();
+    } catch (error) {
+      throw new Error(`获取 Bot 信息失败: ${error}`);
+    }
+  }
+}
+class TelegramService {
   bot = null;
+  listener = null;
   adminChatId = null;
-  initialized = false;
+  notifyEnabled = false;
   /**
-   * 初始化通知器
+   * 初始化 Telegram 服务
    */
-  init(botToken, adminChatId) {
+  init(botToken, adminChatId, targetChatIds = []) {
+    if (this.listener) {
+      return;
+    }
+    this.bot = new grammy.Bot(botToken);
+    this.listener = new TelegramListener(this.bot, targetChatIds);
     if (!adminChatId) {
       init.logger.warning("未配置管理员 Chat ID，通知功能已禁用");
+      this.notifyEnabled = false;
       return;
     }
-    this.bot = new grammy.Bot(botToken);
     this.adminChatId = adminChatId;
-    this.initialized = true;
+    this.notifyEnabled = true;
     init.logger.info("管理员通知已启用");
   }
+  /**
+   * 设置频道 ID 列表变更回调
+   */
+  onChatIdsChanged(callback) {
+    this.ensureListener().onChatIdsChanged(callback);
+  }
+  /**
+   * 设置预测信号回调
+   */
+  onSignal(callback) {
+    this.ensureListener().onSignal(callback);
+  }
+  /**
+   * 启动监听
+   */
+  async start(onReady) {
+    await this.ensureListener().start(onReady);
+  }
+  /**
+   * 停止监听
+   */
+  async stop() {
+    await this.ensureListener().stop();
+  }
   /**
    * 发送错误通知
    */
@@ -67,11 +489,17 @@ class Notifier {
   async success(message, details) {
     await this.send(`🟢 ${message}`, details);
   }
+  ensureListener() {
+    if (!this.listener) {
+      throw new Error("TelegramService 未初始化");
+    }
+    return this.listener;
+  }
   /**
    * 发送消息给管理员
    */
   async send(message, details) {
-    if (!this.initialized || !this.bot || !this.adminChatId) {
+    if (!this.notifyEnabled || !this.bot || !this.adminChatId) {
       return;
     }
     const fullMessage = details ? `${message}
@@ -87,7 +515,7 @@ ${details}` : message;
     }
   }
 }
-const notifier = new Notifier();
+const telegramService = new TelegramService();
 const CLOB_HOST = "https://clob.polymarket.com";
 class ClobClientWrapper {
   client = null;
@@ -658,7 +1086,10 @@ class Redeemer {
       if (errorMsg.includes("429") || errorMsg.includes("Too Many Requests")) {
         const resetSeconds = this.parseResetSeconds(errorMsg);
         init.logger.warning(`获取仓位限流，${resetSeconds} 秒后重试`);
-        notifier.warning("API 限流", `获取仓位限流，${resetSeconds} 秒后重试`);
+        telegramService.warning(
+          "API 限流",
+          `获取仓位限流，${resetSeconds} 秒后重试`
+        );
         this.pauseAndRestart((resetSeconds + 60) * 1e3);
         return;
       }
@@ -693,7 +1124,7 @@ class Redeemer {
           init.logger.error(
             `Redeem 失败: 执行成功但仍存在 ${record.matchedCount} 次 (conditionId: ${position.conditionId.slice(0, 10)}...)`
           );
-          notifier.error(
+          telegramService.error(
             "Redeem 失败",
             `执行成功但仓位仍存在 ${record.matchedCount} 次
 conditionId: ${position.conditionId}
@@ -710,7 +1141,7 @@ conditionId: ${position.conditionId}
           if (errorMsg.includes("429") || errorMsg.includes("Too Many Requests")) {
             const resetSeconds = this.parseResetSeconds(errorMsg);
             init.logger.warning(`Redeem 限流，${resetSeconds} 秒后重试`);
-            notifier.warning("Redeem 限流", `${resetSeconds} 秒后重试`);
+            telegramService.warning("Redeem 限流", `${resetSeconds} 秒后重试`);
             this.pauseAndRestart((resetSeconds + 60) * 1e3);
             return;
           }
@@ -719,7 +1150,7 @@ conditionId: ${position.conditionId}
             `Redeem 异常 (第 ${record.failedCount} 次): ${errorMsg}`
           );
           if (record.failedCount >= MAX_MATCH_TIMES) {
-            notifier.error(
+            telegramService.error(
               "Redeem 异常",
               `重试 ${record.failedCount} 次仍失败
 conditionId: ${position.conditionId}
@@ -743,7 +1174,7 @@ conditionId: ${position.conditionId}
     if (successItems.length > 0) {
       const successTitle = `自动 redeem: 成功 ${successItems.length} 个`;
       const successLines = this.logPositions(successTitle, successItems);
-      notifier.success(successTitle, successLines.join("\n"));
+      telegramService.success(successTitle, successLines.join("\n"));
       this.onRedeemSuccess?.();
     }
     init.logger.info(`redeem 状态: ${this.records.size} 个待确认`);
@@ -881,7 +1312,7 @@ class Trader {
     if (amountMode === "fixed" && balance < amountValue) {
       const msg = `余额不足: ${balance} USDC < ${amountValue} USDC`;
       init.logger.warning(msg);
-      notifier.warning(
+      telegramService.warning(
         "余额不足",
         `当前余额: ${balance} USDC
 需要金额: ${amountValue} USDC`
@@ -890,7 +1321,7 @@ class Trader {
     }
     if (amountMode === "percentage" && balance <= 0) {
       init.logger.warning(`余额为零: ${balance} USDC`);
-      notifier.warning("余额为零", `当前余额: ${balance} USDC`);
+      telegramService.warning("余额为零", `当前余额: ${balance} USDC`);
       return;
     }
     const orderAmount = amountMode === "fixed" ? amountValue : balance * amountValue;
@@ -901,7 +1332,7 @@ class Trader {
     const buyResult = await this.client.createBuyOrder(assetId, buyPrice, size);
     if (!buyResult.success) {
       init.logger.error(`买单失败: ${buyResult.errorMsg}`);
-      notifier.error(
+      telegramService.error(
         "买单失败",
         `事件: ${metadata.eventId}
 错误: ${buyResult.errorMsg}`
@@ -941,7 +1372,7 @@ class Trader {
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
       init.logger.error(`订单监控异常: ${errorMsg}`);
-      notifier.error(
+      telegramService.error(
         "订单监控异常",
         `事件: ${eventId}
 订单: ${orderId}
@@ -969,11 +1400,11 @@ class Trader {
         break;
       case "FAILED":
         init.logger.error("订单执行失败");
-        notifier.error("订单执行失败", `订单 ID: ${orderId}`);
+        telegramService.error("订单执行失败", `订单 ID: ${orderId}`);
         break;
       case "TIMEOUT":
         init.logger.warning("订单超时，尝试取消");
-        notifier.warning("订单超时", `订单 ID: ${orderId}
+        telegramService.warning("订单超时", `订单 ID: ${orderId}
 已尝试取消`);
         await this.client.cancelOrder(orderId);
         break;
@@ -1016,7 +1447,7 @@ class Trader {
     if (!this.relayClient.isInitialized()) {
       const msg = "仓位同步超时且 Redeem 不可用";
       init.logger.warning(msg);
-      notifier.warning(
+      telegramService.warning(
         msg,
         `Asset: ${assetId.substring(0, 20)}...
 预期数量: ${expectedSize.toFixed(4)}
@@ -1040,7 +1471,7 @@ class Trader {
       init.logger.success(`卖单已提交: ${sellResult.orderId}`);
     } else {
       init.logger.error(`卖单提交失败: ${sellResult.errorMsg}`);
-      notifier.error("卖单提交失败", `错误: ${sellResult.errorMsg}`);
+      telegramService.error("卖单提交失败", `错误: ${sellResult.errorMsg}`);
     }
   }
   /**
@@ -1092,7 +1523,11 @@ async function main() {
   init.logger.init();
   init.logger.section("PolyMarket 跟单机器人");
   const config = await init.ensureConfig();
-  notifier.init(config.telegram.botToken, config.telegram.adminChatId);
+  telegramService.init(
+    config.telegram.botToken,
+    config.telegram.adminChatId,
+    config.telegram.targetChatIds || []
+  );
   const autoTradeEnabled = init.canAutoTrade(config);
   if (!autoTradeEnabled) {
     init.logger.warning("自动跟单功能未启用");
@@ -1122,11 +1557,7 @@ async function main() {
       init.logger.line("", "当前不会跟单任何预测消息");
     }
   }
-  const listener = new init.TelegramListener(
-    config.telegram.botToken,
-    config.telegram.targetChatIds || []
-  );
-  listener.onChatIdsChanged((chatIds) => {
+  telegramService.onChatIdsChanged((chatIds) => {
     const telegram = init.configLocal.getItem("telegram");
     if (!telegram) {
       init.logger.error("警告: 无法保存频道 ID，telegram 配置不存在");
@@ -1136,7 +1567,7 @@ async function main() {
     init.configLocal.setItem("telegram", telegram);
     init.logger.line("💾", `已保存频道 ID 列表: ${chatIds.length} 个频道`);
   });
-  listener.onSignal(async (signal) => {
+  telegramService.onSignal(async (signal) => {
     init.logger.info(`📨 收到预测信号:`);
     init.logger.line("", `事件: ${signal.metadata.eventId}`);
     init.logger.line(
@@ -1161,29 +1592,25 @@ async function main() {
     enterDaemonMode();
     return;
   }
-  const runMode = process.env.POLYCOPY_DAEMON_CHILD === "1" ? "后台模式" : "前台模式";
-  notifier.success("程序已启动", `模式: ${runMode}
-PID: ${process.pid}`);
   let isShuttingDown = false;
-  const shutdown = () => {
+  const shutdown = async () => {
     if (isShuttingDown) return;
     isShuttingDown = true;
     process.removeAllListeners("SIGINT");
     process.removeAllListeners("SIGTERM");
     init.logger.blank();
     init.logger.info("正在退出...");
-    notifier.warning("程序已停止", `模式: ${runMode}
-PID: ${process.pid}`);
-    setTimeout(() => {
-      process.exit(0);
-    }, 1e3);
-    Promise.all([trader.shutdown(), listener.stop()]).finally(() => {
-      process.exit(0);
-    });
+    await Promise.all([trader.shutdown(), telegramService.stop()]);
+    await init.logger.flush();
+    process.exit(0);
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-  await listener.start(() => {
+  process.prependListener("SIGINT", () => {
+    shutdown();
+  });
+  process.prependListener("SIGTERM", () => {
+    shutdown();
+  });
+  await telegramService.start(() => {
     if (trader.isInitialized()) {
       trader.startRedeemer();
     }

package/dist/{init-C5cwUXyD.js → init-Bs-N_AZi.js}

@@ -98,6 +98,7 @@ const winstonLogger = winston__default.default.createLogger({
 });
 class Logger {
   initialized = false;
+  flushing = false;
   /**
    * 初始化日志模块（输出日志路径信息）
    */
@@ -190,400 +191,27 @@ ${this.withTimestamp(`❌ ${formatted}`)}`);
     console.log(this.withTimestamp(formatted));
     winstonLogger.info(formatted);
   }
-}
-const logger = new Logger();
-function parseSignalMetadata(messageText) {
-  const match = messageText.match(/🤖\s*({.*})/s);
-  if (!match) {
-    return null;
-  }
-  try {
-    const jsonStr = match[1];
-    const metadata = JSON.parse(jsonStr);
-    if (!metadata.eventId || !metadata.assetId || !metadata.outcome || !metadata.endTime) {
-      logger.error("解析失败: 缺少必需字段", {
-        hasEventId: !!metadata.eventId,
-        hasAssetId: !!metadata.assetId,
-        hasOutcome: !!metadata.outcome,
-        hasEndTime: !!metadata.endTime
-      });
-      return null;
-    }
-    if (metadata.outcome !== "Up" && metadata.outcome !== "Down") {
-      logger.error("解析失败: outcome 值无效", {
-        outcome: metadata.outcome,
-        expected: "Up 或 Down"
-      });
-      return null;
-    }
-    if (typeof metadata.endTime !== "number" || metadata.endTime <= 0) {
-      logger.error("解析失败: endTime 值无效", {
-        endTime: metadata.endTime,
-        expected: "毫秒级时间戳"
-      });
-      return null;
-    }
-    return metadata;
-  } catch (error) {
-    logger.error("解析信号元数据失败:", error);
-    if (error instanceof Error) {
-      logger.line("", `错误详情: ${error.message}`);
-    }
-    return null;
-  }
-}
-class TelegramListener {
-  bot;
-  onSignalCallback;
-  onChatIdsChangedCallback;
-  targetChatIds;
-  // 运行时监听的频道 ID 集合（自动管理）
-  constructor(botToken, targetChatIds = []) {
-    this.bot = new grammy.Bot(botToken);
-    this.targetChatIds = new Set(targetChatIds);
-    this.setupHandlers();
-  }
-  /**
-   * 设置消息处理器
-   */
-  setupHandlers() {
-    this.bot.on("channel_post", async (ctx) => {
-      await this.handleChannelPost(ctx);
-    });
-    this.bot.on("edited_channel_post", async (ctx) => {
-      await this.handleChannelPost(ctx);
-    });
-    this.bot.on("my_chat_member", async (ctx) => {
-      await this.handleMyChatMemberUpdate(ctx);
-    });
-    this.bot.catch((err) => {
-      logger.error("Telegram Bot 错误:", err);
-      if (err.error) {
-        logger.line("", `错误详情: ${err.error}`);
-      }
-      if (err.ctx) {
-        logger.line("", `上下文信息:`, {
-          chatId: err.ctx.chat?.id,
-          messageId: err.ctx.message?.message_id
-        });
-      }
-    });
-  }
-  /**
-   * 处理 Bot 自己的成员状态变更
-   */
-  async handleMyChatMemberUpdate(ctx) {
-    const update = ctx.myChatMember;
-    if (!update) {
-      return;
-    }
-    const chatId = update.chat.id;
-    const chatTitle = update.chat.title || "未知频道";
-    const oldStatus = update.old_chat_member.status;
-    const newStatus = update.new_chat_member.status;
-    const chatType = update.chat.type;
-    if (chatType !== "channel") {
-      return;
-    }
-    const isAdmin = newStatus === "administrator" || newStatus === "creator";
-    const wasAdmin = oldStatus === "administrator" || oldStatus === "creator";
-    const isRemoved = newStatus === "left" || newStatus === "kicked";
-    const wasRemoved = oldStatus === "left" || oldStatus === "kicked";
-    if (oldStatus !== newStatus) {
-      let action = "";
-      let canListen = false;
-      let reason = "";
-      if (isRemoved) {
-        action = "❌ 频道主已移除 Bot";
-        canListen = false;
-        reason = "Bot 已被移除";
-      } else if (wasRemoved && isAdmin) {
-        action = "✅ 频道主已添加 Bot 为管理员";
-        canListen = true;
-      } else if (isAdmin && !wasAdmin) {
-        action = "✅ 频道主已授予 Bot 管理员权限";
-        canListen = true;
-      } else if (wasAdmin && !isAdmin) {
-        action = "⚠️  频道主已移除 Bot 的管理员权限";
-        canListen = false;
-        reason = "Bot 不再是管理员";
-      } else if (wasRemoved && !isAdmin) {
-        action = "⚠️  频道主已添加 Bot，但未授予管理员权限";
-        canListen = false;
-        reason = "需要管理员权限才能监听";
-      } else if (oldStatus === "restricted" && isAdmin) {
-        action = "✅ 频道主已授予 Bot 管理员权限";
-        canListen = true;
-      } else if (wasAdmin && newStatus === "restricted") {
-        action = "⚠️  频道主已限制 Bot 的权限";
-        canListen = false;
-        reason = "Bot 权限受限，无法监听";
-      } else if (oldStatus === "restricted" && !isAdmin) {
-        action = `状态变更: ${oldStatus} → ${newStatus}`;
-        canListen = false;
-        reason = "需要管理员权限才能监听";
-      } else {
-        action = `状态变更: ${oldStatus} → ${newStatus}`;
-        canListen = isAdmin;
-        if (!canListen) {
-          reason = "需要管理员权限才能监听";
-        }
-      }
-      logger.info(`📢 频道状态更新: ${chatTitle}`);
-      logger.line("", action);
-      logger.line(
-        "",
-        `当前状态: ${canListen ? "✅ 可监听预测消息" : "❌ 无法监听预测消息"}`
-      );
-      if (reason) {
-        logger.line("", `原因: ${reason}`);
-      }
-    }
-    if (isAdmin && !this.targetChatIds.has(chatId)) {
-      this.targetChatIds.add(chatId);
-      await this.saveChatIds();
-      logger.line("📡", "已自动开始监听此频道");
-    }
-    if ((isRemoved || !isAdmin) && this.targetChatIds.has(chatId)) {
-      this.targetChatIds.delete(chatId);
-      await this.saveChatIds();
-      if (isRemoved) {
-        logger.line("⏹️", "已停止监听此频道（Bot 已被移除）");
-      } else {
-        logger.line("⏹️", "已停止监听此频道（Bot 不再是管理员）");
-      }
-    }
-  }
-  /**
-   * 保存频道 ID 列表到配置（用于持久化）
-   */
-  async saveChatIds() {
-    if (!this.onChatIdsChangedCallback) {
-      return;
-    }
-    try {
-      const chatIds = Array.from(this.targetChatIds);
-      await this.onChatIdsChangedCallback(chatIds);
-    } catch (error) {
-      logger.error("保存频道 ID 列表时出错:", error);
-    }
-  }
-  /**
-   * 处理频道消息（channel_post 和 edited_channel_post）
-   */
-  async handleChannelPost(ctx) {
-    const message = ctx.channelPost || ctx.editedChannelPost;
-    if (!message) {
-      return;
-    }
-    await this.processMessage(message, ctx);
-  }
-  /**
-   * 处理频道消息（统一的消息处理逻辑）
-   */
-  async processMessage(message, ctx) {
-    if (!message) {
-      return;
-    }
-    const chatId = message.chat.id;
-    const chatTitle = message.chat.title || "未知频道";
-    const isChannel = chatId < 0 && chatId.toString().startsWith("-100");
-    const messageText = message.text || message.caption || "";
-    if (!messageText) {
-      return;
-    }
-    if (isChannel && !this.targetChatIds.has(chatId)) {
-      this.targetChatIds.add(chatId);
-      logger.info(`➕ 自动添加频道到监听列表: ${chatTitle} (ID: ${chatId})`);
-      await this.saveChatIds();
-      logger.line("💾", "已保存到配置文件");
-    }
-    if (!isChannel) {
-      return;
-    }
-    if (!this.targetChatIds.has(chatId)) {
-      return;
-    }
-    const metadata = parseSignalMetadata(messageText);
-    if (!metadata) {
-      if (messageText.includes("🤖")) {
-        const emojiIndex = messageText.indexOf("🤖");
-        const jsonStart = emojiIndex + 1;
-        const jsonEnd = Math.min(jsonStart + 200, messageText.length);
-        logger.warning(`解析预测消息失败:`);
-        logger.line("", `频道 ID: ${chatId}`);
-        logger.line(
-          "",
-          `消息片段: ${messageText.substring(emojiIndex, jsonEnd)}${messageText.length > jsonEnd ? "..." : ""}`
-        );
-        logger.line("", "提示: 请检查消息格式是否正确");
-      }
-      return;
-    }
-    const parsedSignal = {
-      metadata,
-      rawMessage: messageText,
-      messageId: message.message_id,
-      chatId,
-      timestamp: message.date * 1e3
-    };
-    if (this.onSignalCallback) {
-      try {
-        await this.onSignalCallback(parsedSignal);
-      } catch (error) {
-        logger.error("处理信号时出错:", error);
-      }
-    }
-  }
   /**
-   * 设置信号回调函数
+   * 刷新日志输出（用于进程退出前）
    */
-  onSignal(callback) {
-    this.onSignalCallback = callback;
-  }
-  /**
-   * 设置频道 ID 列表变更回调函数（当频道自动添加/移除时调用，用于持久化）
-   */
-  onChatIdsChanged(callback) {
-    this.onChatIdsChangedCallback = callback;
-  }
-  /**
-   * 设置监听的频道 ID 列表（用于启动时加载已保存的配置）
-   */
-  setTargetChatIds(chatIds) {
-    this.targetChatIds = new Set(chatIds);
-  }
-  /**
-   * 启动监听
-   * @param onReady 可选回调，在频道检查完成后、开始监听之前调用
-   */
-  async start(onReady) {
-    try {
-      logger.info("正在启动 Bot...");
-      const botInfo = await this.bot.api.getMe();
-      const botId = botInfo.id;
-      logger.info(`Bot 信息: @${botInfo.username} (ID: ${botId})`);
-      await this.checkAndDisplayChannels(botId);
-      if (onReady) {
-        await onReady();
-      }
-      logger.info("开始监听预测消息...");
-      await this.bot.start({
-        drop_pending_updates: true,
-        allowed_updates: [
-          "channel_post",
-          "edited_channel_post",
-          "my_chat_member"
-        ]
-      });
-    } catch (error) {
-      logger.error("启动 Bot 失败:", error);
-      throw error;
-    }
-  }
-  /**
-   * 检查并显示 Bot 所在的频道
-   * 验证配置文件中保存的频道，检查 Bot 是否仍在频道中以及是否是管理员
-   */
-  async checkAndDisplayChannels(botId) {
-    const chatIds = Array.from(this.targetChatIds);
-    if (chatIds.length === 0) {
-      logger.info(`📋 当前没有保存的频道配置`);
-      logger.line(
-        "",
-        "提示: 当 Bot 被添加为频道管理员时，会自动添加到监听列表"
-      );
+  async flush(timeoutMs = 1e3) {
+    if (this.flushing) {
       return;
     }
-    logger.info(`📋 检查 Bot 所在的频道:`);
-    const validChannels = [];
-    const invalidChannels = [];
-    for (const chatId of chatIds) {
-      try {
-        const chat = await this.bot.api.getChat(chatId);
-        const chatTitle = chat.title || "未知频道";
-        try {
-          const member = await this.bot.api.getChatMember(chatId, botId);
-          const isAdmin = member.status === "administrator" || member.status === "creator";
-          validChannels.push({
-            id: chatId,
-            title: chatTitle,
-            isAdmin
-          });
-        } catch (error) {
-          invalidChannels.push({
-            id: chatId,
-            reason: "无法获取成员信息（可能已被移除）"
-          });
-        }
-      } catch (error) {
-        invalidChannels.push({
-          id: chatId,
-          reason: "无法获取频道信息（可能已被移除）"
-        });
-      }
-    }
-    if (validChannels.length > 0) {
-      const adminChannels = validChannels.filter((c) => c.isAdmin);
-      const nonAdminChannels = validChannels.filter((c) => !c.isAdmin);
-      if (adminChannels.length > 0) {
-        logger.info(`📡 可监听频道 (${adminChannels.length} 个):`);
-        adminChannels.forEach((channel, index) => {
-          logger.item(
-            `${index + 1}. ${channel.title} (ID: ${channel.id}) 👑 管理员`,
-            1
-          );
-        });
-      }
-      if (nonAdminChannels.length > 0) {
-        logger.warning(`无法监听频道 (${nonAdminChannels.length} 个):`);
-        nonAdminChannels.forEach((channel, index) => {
-          logger.item(`${index + 1}. ${channel.title}`, 1);
-          logger.item(`ID: ${channel.id}`, 2);
-          logger.item(`状态: 🚫 非管理员（无法接收预测消息）`, 2);
-          logger.item(`原因: 需要管理员权限才能监听`, 2);
-        });
-        nonAdminChannels.forEach((channel) => {
-          this.targetChatIds.delete(channel.id);
-        });
-        if (nonAdminChannels.length > 0) {
-          await this.saveChatIds();
-          logger.line("💾", "已清理无法监听的频道并保存配置");
-        }
-      }
-    }
-    if (invalidChannels.length > 0) {
-      logger.error(`无效频道 (${invalidChannels.length} 个):`);
-      invalidChannels.forEach((channel, index) => {
-        logger.item(`${index + 1}. ID: ${channel.id}`, 1);
-        logger.item(`原因: ${channel.reason}`, 2);
-      });
-      invalidChannels.forEach((channel) => {
-        this.targetChatIds.delete(channel.id);
+    this.flushing = true;
+    await new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        resolve();
+      }, timeoutMs);
+      winstonLogger.once("finish", () => {
+        clearTimeout(timeout);
+        resolve();
       });
-      if (invalidChannels.length > 0) {
-        await this.saveChatIds();
-        logger.line("💾", "已清理无效频道并保存配置");
-      }
-    }
-  }
-  /**
-   * 停止监听
-   */
-  async stop() {
-    await this.bot.stop();
-  }
-  /**
-   * 获取 bot 信息（用于验证 token 是否有效）
-   */
-  async getBotInfo() {
-    try {
-      return this.bot.api.getMe();
-    } catch (error) {
-      throw new Error(`获取 Bot 信息失败: ${error}`);
-    }
+      winstonLogger.end();
+    });
   }
 }
+const logger = new Logger();
 let globalRl = null;
 function getReadlineInterface() {
   if (!globalRl) {
@@ -602,9 +230,8 @@ function question(query) {
 }
 async function validateBotToken(botToken) {
   try {
-    const listener = new TelegramListener(botToken);
-    await listener.getBotInfo();
-    await listener.stop();
+    const bot = new grammy.Bot(botToken);
+    await bot.api.getMe();
     return true;
   } catch (error) {
     logger.error(`Bot Token 验证失败: ${error}`);
@@ -966,7 +593,6 @@ async function ensureConfig() {
   }
   return config;
 }
-exports.TelegramListener = TelegramListener;
 exports.canAutoTrade = canAutoTrade;
 exports.configLocal = configLocal;
 exports.ensureConfig = ensureConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polycopy",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "polycopy test",
   "main": "dist/index.js",
   "bin": {