502 lines
22 KiB
JavaScript
502 lines
22 KiB
JavaScript
'use strict';
|
||
// Bot 主邏輯：長輪詢、指令、佇列、進度回報。實際跑 AI 的是 engines/（codex 或 claude），
|
||
// 這裡只認共同介面 run({ config, prompt, threadId, images, onProgress }) → { text, threadId, usage, model }。
|
||
const fs = require('fs');
|
||
const os = require('os');
|
||
const path = require('path');
|
||
const crypto = require('crypto');
|
||
const { createTelegram } = require('./telegram');
|
||
const { getEngine } = require('./engines');
|
||
const { createSessionStore } = require('./sessions');
|
||
const { TGBOT_HOME } = require('./pm2util');
|
||
|
||
// codex 的模型快取與全域預設（config.toml），給 footer 顯示 ctx% 與模型/強度用
|
||
function loadModelMeta() {
|
||
try {
|
||
const cache = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.codex', 'models_cache.json'), 'utf-8'));
|
||
const map = {};
|
||
for (const m of cache.models || []) map[m.slug] = m;
|
||
return map;
|
||
} catch {
|
||
return {};
|
||
}
|
||
}
|
||
|
||
function loadCodexDefaults() {
|
||
try {
|
||
const toml = fs.readFileSync(path.join(os.homedir(), '.codex', 'config.toml'), 'utf-8');
|
||
return {
|
||
model: toml.match(/^\s*model\s*=\s*"([^"]+)"/m)?.[1] || '',
|
||
effort: toml.match(/^\s*model_reasoning_effort\s*=\s*"([^"]+)"/m)?.[1] || '',
|
||
tier: toml.match(/^\s*service_tier\s*=\s*"([^"]+)"/m)?.[1] || '',
|
||
};
|
||
} catch {
|
||
return { model: '', effort: '', tier: '' };
|
||
}
|
||
}
|
||
|
||
// — ✅ 16:06:32 | ctx 24% +1.2k | gpt-5.6-sol / high
|
||
function buildFooter({ model, effort, usage, contextWindow }) {
|
||
const time = new Date().toLocaleTimeString('zh-TW', { hour12: false });
|
||
const parts = [`— ✅ ${time}`];
|
||
|
||
if (usage) {
|
||
const used = (usage.input_tokens || 0) + (usage.output_tokens || 0);
|
||
// 本輪新消耗（扣掉 cache 命中的部分）
|
||
const fresh = Math.max(0, (usage.input_tokens || 0) - (usage.cached_input_tokens || 0)) + (usage.output_tokens || 0);
|
||
const freshStr = fresh >= 1000 ? `+${(fresh / 1000).toFixed(1)}k` : `+${fresh}`;
|
||
parts.push(contextWindow ? `ctx ${Math.round((used / contextWindow) * 100)}% ${freshStr}` : freshStr);
|
||
}
|
||
|
||
if (model) parts.push(effort ? `${model} / ${effort}` : model);
|
||
return `\n\n${parts.join(' | ')}`;
|
||
}
|
||
|
||
// AI 要傳檔案給使用者的交件匣（在工作目錄底下，沙盒內可寫）；舊名稱也一併收
|
||
const OUTBOX_DIRNAME = '.tgbot-outbox';
|
||
const LEGACY_OUTBOX_DIRNAMES = ['.tgcodex-outbox'];
|
||
// codex 內建 imagegen 技能的預設輸出位置（依會話 id 分資料夾）
|
||
const GENERATED_IMAGES_DIR = path.join(os.homedir(), '.codex', 'generated_images');
|
||
|
||
// 這一輪 codex 用 imagegen 生成、但沒複製進交件匣的圖（模型偶爾會忘）
|
||
function collectGeneratedImages(threadId, sinceMs) {
|
||
if (!threadId) return [];
|
||
const dir = path.join(GENERATED_IMAGES_DIR, String(threadId));
|
||
try {
|
||
return fs.readdirSync(dir)
|
||
.filter((f) => /\.(png|jpe?g|gif|webp)$/i.test(f))
|
||
.map((f) => path.join(dir, f))
|
||
.filter((p) => {
|
||
try {
|
||
const st = fs.statSync(p);
|
||
return st.isFile() && st.mtimeMs >= sinceMs;
|
||
} catch { return false; }
|
||
})
|
||
.sort();
|
||
} catch {
|
||
return [];
|
||
}
|
||
}
|
||
|
||
function md5File(p) {
|
||
try {
|
||
return crypto.createHash('md5').update(fs.readFileSync(p)).digest('hex');
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
const OUTBOX_RULE =
|
||
`【系統規則】若要把圖片或檔案傳給使用者，請將檔案寫入工作目錄下的 ${OUTBOX_DIRNAME}/ 資料夾，` +
|
||
'bot 會在回覆後自動傳送到 Telegram 並清空該資料夾。';
|
||
const MAX_OUTBOX_FILES = 10;
|
||
|
||
const SESSION_MODE_LABELS = { 'per-chat': '各聊天室獨立', shared: '所有聊天室共用', stateless: '每則訊息獨立（不保留記憶）' };
|
||
|
||
const NEW_COMMANDS = ['/new', '!clear', '!reset', '!new', '!清除', '!重置', '!新會話'];
|
||
const STATUS_COMMANDS = ['/status', '!status', '!狀態'];
|
||
const HELP_COMMANDS = ['/start', '/help', '!help', '!幫助'];
|
||
|
||
function startBot(config) {
|
||
const t = createTelegram(config.telegramToken);
|
||
const sessions = createSessionStore(config.stateDir);
|
||
const engine = getEngine(config.engine);
|
||
const modelMeta = engine.id === 'codex' ? loadModelMeta() : {};
|
||
const codexDefaults = engine.id === 'codex' ? loadCodexDefaults() : { model: '', effort: '', tier: '' };
|
||
|
||
let botId = null;
|
||
let botUsername = null;
|
||
// 同一個工作目錄不能同時跑兩個 AI（會互相踩檔案），全域串行
|
||
let queue = Promise.resolve();
|
||
|
||
// footer / 自動重置用：這輪實際的模型、強度、上下文視窗
|
||
function resolveDisplay(result) {
|
||
const model = result?.model || config.model || codexDefaults.model || '';
|
||
const effort = config.reasoningEffort || codexDefaults.effort || modelMeta[model]?.default_reasoning_level || '';
|
||
const contextWindow = result?.usage?.context_window || modelMeta[model]?.context_window || null;
|
||
return { model, effort, contextWindow };
|
||
}
|
||
|
||
function shouldRespond(message) {
|
||
if (message.chat.type === 'private') return true;
|
||
const text = message.text || message.caption || '';
|
||
const entities = message.entities || message.caption_entities || [];
|
||
// 訊息中所有被 tag 的 bot（Telegram bot username 一定以 bot 結尾；
|
||
// tag 到一般使用者不算，不影響回覆觸發）
|
||
const botMentions = entities
|
||
.filter((e) => e.type === 'mention')
|
||
.map((e) => text.slice(e.offset + 1, e.offset + e.length))
|
||
.filter((u) => /bot$/i.test(u));
|
||
if (botMentions.length > 0) {
|
||
// 有明確 tag 時以 tag 為準：只有第一個被 tag 的 bot 回應。
|
||
// 就算這則訊息是回覆我的（例如回覆我的訊息但 tag 別的 bot），我也讓位。
|
||
return botMentions[0].toLowerCase() === botUsername.toLowerCase();
|
||
}
|
||
if (message.reply_to_message?.from?.id === botId) return true;
|
||
return entities.some((e) => e.type === 'text_mention' && e.user?.id === botId);
|
||
}
|
||
|
||
function stripMention(text) {
|
||
if (!botUsername) return text.trim();
|
||
return text.replace(new RegExp(`@${botUsername}`, 'gi'), '').trim();
|
||
}
|
||
|
||
// 群組指令會帶 @BotName 後綴（例如 /new@MyBot）
|
||
function matchCommand(text, commands) {
|
||
const head = text.split(/\s/, 1)[0].replace(new RegExp(`@${botUsername}$`, 'i'), '');
|
||
return commands.includes(head.toLowerCase());
|
||
}
|
||
|
||
// 把 AI 放進交件匣的檔案傳到 Telegram（傳完清掉），
|
||
// 再補傳這一輪 codex imagegen 生成但沒進交件匣的圖（用內容 hash 去重，避免重複傳）。
|
||
async function flushOutputs(chatId, replyTo, threadId, sinceMs) {
|
||
const sentHashes = new Set();
|
||
let sentCount = 0;
|
||
|
||
const send = async (file, { deleteAfter }) => {
|
||
const hash = md5File(file);
|
||
if (!hash || sentHashes.has(hash)) return;
|
||
try {
|
||
await t.sendFile(chatId, file, { replyTo });
|
||
sentHashes.add(hash);
|
||
sentCount++;
|
||
if (deleteAfter) fs.unlinkSync(file);
|
||
} catch (err) {
|
||
console.error('傳送檔案失敗：', file, err.message);
|
||
await t.sendMessage(chatId, `⚠️ 檔案傳送失敗：${path.basename(file)}（${err.message}）`).catch(() => {});
|
||
}
|
||
};
|
||
|
||
// 1) 交件匣（明確交付：任何檔案類型）
|
||
let outbox = [];
|
||
for (const dirname of [OUTBOX_DIRNAME, ...LEGACY_OUTBOX_DIRNAMES]) {
|
||
const dir = path.join(config.workDir, dirname);
|
||
try {
|
||
outbox.push(...fs.readdirSync(dir)
|
||
.map((f) => path.join(dir, f))
|
||
.filter((p) => { try { return fs.statSync(p).isFile(); } catch { return false; } })
|
||
.sort());
|
||
} catch { /* 沒有這個交件匣 */ }
|
||
}
|
||
for (const file of outbox.slice(0, MAX_OUTBOX_FILES)) {
|
||
await send(file, { deleteAfter: true });
|
||
}
|
||
if (outbox.length > MAX_OUTBOX_FILES) {
|
||
await t.sendMessage(chatId, `⚠️ 交件匣一次最多傳 ${MAX_OUTBOX_FILES} 個檔案，還有 ${outbox.length - MAX_OUTBOX_FILES} 個留在 ${OUTBOX_DIRNAME}/`).catch(() => {});
|
||
}
|
||
|
||
// 2) 保險網：codex imagegen 這一輪的產圖（不刪原檔，codex 之後編輯圖片可能還要用）
|
||
if (engine.supportsImageGen) {
|
||
for (const file of collectGeneratedImages(threadId, sinceMs).slice(0, MAX_OUTBOX_FILES)) {
|
||
if (sentCount >= MAX_OUTBOX_FILES) break;
|
||
await send(file, { deleteAfter: false });
|
||
}
|
||
}
|
||
}
|
||
|
||
function cleanTmp() {
|
||
const ttl = 24 * 60 * 60 * 1000;
|
||
try {
|
||
for (const f of fs.readdirSync(config.tmpDir)) {
|
||
const p = path.join(config.tmpDir, f);
|
||
try {
|
||
if (Date.now() - fs.statSync(p).mtimeMs > ttl) fs.unlinkSync(p);
|
||
} catch { /* ignore */ }
|
||
}
|
||
} catch { /* ignore */ }
|
||
}
|
||
|
||
// 取出訊息附圖（photo 取最大尺寸；image/* 的 document 也支援）
|
||
function pickPhoto(message) {
|
||
if (message.photo?.length) {
|
||
const largest = message.photo[message.photo.length - 1];
|
||
return { fileId: largest.file_id, uniqueId: largest.file_unique_id, ext: '.jpg' };
|
||
}
|
||
const doc = message.document;
|
||
if (doc && /^image\//.test(doc.mime_type || '')) {
|
||
const ext = path.extname(doc.file_name || '') || '.' + (doc.mime_type.split('/')[1] || 'png');
|
||
return { fileId: doc.file_id, uniqueId: doc.file_unique_id, ext };
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// 使用者引用／回覆的文字（圈選引用優先，其次是被回覆的整則訊息）
|
||
function quotedTextOf(message) {
|
||
return message.quote?.text || message.reply_to_message?.text || message.reply_to_message?.caption || '';
|
||
}
|
||
|
||
// Telegram 限制：bot 永遠看不到其他 bot 的訊息——使用者「回覆另一隻 bot ＋ tag 我」時，
|
||
// reply_to_message 會被整個剝掉。繞法：每隻 bot 把自己在各聊天室的最後一則回覆
|
||
// 寫進共用資料夾，收到「只有 tag 沒內容」時就拿同聊天室最近一則兄弟 bot 的發言當輸入。
|
||
const CHATLAST_DIR = path.join(TGBOT_HOME, 'chatlast');
|
||
const SIBLING_MAX_AGE_MS = 6 * 60 * 60 * 1000; // 超過 6 小時的舊訊息就不當引用
|
||
|
||
function recordChatLast(chatId, text) {
|
||
try {
|
||
fs.mkdirSync(CHATLAST_DIR, { recursive: true });
|
||
fs.writeFileSync(
|
||
path.join(CHATLAST_DIR, `${chatId}.json`),
|
||
JSON.stringify({ botUsername, text, ts: Date.now() }) + '\n'
|
||
);
|
||
} catch { /* 純輔助功能，失敗不影響回覆 */ }
|
||
}
|
||
|
||
function siblingLastOf(chatId) {
|
||
try {
|
||
const j = JSON.parse(fs.readFileSync(path.join(CHATLAST_DIR, `${chatId}.json`), 'utf-8'));
|
||
if (!j.text || Date.now() - j.ts > SIBLING_MAX_AGE_MS) return null;
|
||
return j;
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
function buildPrompt(message, content, { includeOwnReply = false } = {}) {
|
||
const from = message.from || {};
|
||
const name = [from.first_name, from.last_name].filter(Boolean).join(' ') || '未知使用者';
|
||
const sender = from.username ? `${name}（@${from.username}）` : name;
|
||
const parts = [OUTBOX_RULE];
|
||
const replied = message.reply_to_message;
|
||
// 回覆我自己的訊息通常已在會話記憶裡，不重複貼；但使用者沒打字只回覆時例外（那就是輸入本身）
|
||
if (replied && (includeOwnReply || replied.from?.id !== botId) && (replied.text || replied.caption)) {
|
||
parts.push(`【被回覆的訊息】\n${replied.text || replied.caption}`);
|
||
}
|
||
if (message.quote?.text) {
|
||
parts.push(`【使用者圈選引用的段落，請聚焦於此】\n${message.quote.text}`);
|
||
}
|
||
parts.push(`【來自 Telegram 的 ${sender}】\n${content}`);
|
||
return parts.join('\n\n');
|
||
}
|
||
|
||
function statusText(chatId) {
|
||
const s = sessionKeyOf(chatId) ? sessions.get(sessionKeyOf(chatId)) : null;
|
||
const { model, effort } = resolveDisplay(null);
|
||
return [
|
||
'📋 目前狀態',
|
||
`引擎：${engine.label}`,
|
||
`工作目錄：${config.workDir}`,
|
||
`沙盒模式：${config.sandbox}`,
|
||
`模型：${model || `（${engine.label} 預設）`}`,
|
||
`推理強度：${effort || '（預設）'}`,
|
||
`會話模式：${SESSION_MODE_LABELS[config.sessionMode] || config.sessionMode}`,
|
||
config.sessionMode === 'stateless'
|
||
? '會話：每則訊息獨立，不保留記憶'
|
||
: s ? `會話：${s.threadId}\n最後使用：${s.updatedAt}` : '會話：尚未建立（下一則訊息會開新會話）',
|
||
].join('\n');
|
||
}
|
||
|
||
const HELP_TEXT = [
|
||
`🤖 我是 ${engine.label} bot，訊息直接丟給我就會在專案目錄裡動工。`,
|
||
'',
|
||
'指令：',
|
||
'/new — 開新會話（清除目前對話記憶）',
|
||
'/status — 查看會話與設定',
|
||
'/help — 顯示這則說明',
|
||
'',
|
||
'群組中要 @我 或回覆我的訊息才會觸發。可以直接傳圖片（附文字說明）。',
|
||
].join('\n');
|
||
|
||
// 會話 key：獨立模式用 chat id，共用模式所有聊天室用同一把
|
||
// stateless 模式回傳 null：永遠開新會話、不存
|
||
function sessionKeyOf(chatId) {
|
||
if (config.sessionMode === 'stateless') return null;
|
||
return config.sessionMode === 'shared' ? 'shared' : chatId;
|
||
}
|
||
|
||
async function handleMessage(message) {
|
||
if (!message || message.from?.id === botId) return;
|
||
const chatId = message.chat.id;
|
||
const sessionKey = sessionKeyOf(chatId);
|
||
const text = message.text || message.caption || '';
|
||
const photo = pickPhoto(message);
|
||
if (!text && !photo) return;
|
||
if (!shouldRespond(message)) return;
|
||
|
||
const content = stripMention(text);
|
||
|
||
if (matchCommand(content, HELP_COMMANDS)) {
|
||
await t.sendMessage(chatId, HELP_TEXT, { replyTo: message.message_id });
|
||
return;
|
||
}
|
||
if (matchCommand(content, NEW_COMMANDS)) {
|
||
if (sessionKey) sessions.clear(sessionKey);
|
||
await t.sendMessage(
|
||
chatId,
|
||
config.sessionMode === 'stateless'
|
||
? 'ℹ️ 此 bot 每則訊息都是獨立會話，本來就不保留記憶。'
|
||
: config.sessionMode === 'shared'
|
||
? '🆕 已開新會話（此 bot 為共用會話模式，所有聊天室的記憶一併清除）。'
|
||
: '🆕 已開新會話，之前的對話記憶已清除。',
|
||
{ replyTo: message.message_id }
|
||
);
|
||
return;
|
||
}
|
||
if (matchCommand(content, STATUS_COMMANDS)) {
|
||
await t.sendMessage(chatId, statusText(chatId), { replyTo: message.message_id });
|
||
return;
|
||
}
|
||
// 只有「引用／回覆 + tag 我」沒打字：直接把引用內容當作這次的輸入。
|
||
// 引用的是其他 bot 的訊息時 Telegram 不給內容，改拿共用記錄裡同聊天室最近一則 bot 發言。
|
||
const quoted = quotedTextOf(message);
|
||
const sibling = (!content && !photo && !quoted) ? siblingLastOf(chatId) : null;
|
||
const quotedOnly = !content && !photo && !!(quoted || sibling);
|
||
if (!content && !photo && !quotedOnly) {
|
||
await t.sendMessage(chatId, HELP_TEXT, { replyTo: message.message_id });
|
||
return;
|
||
}
|
||
|
||
await t.react(chatId, message.message_id, '👀');
|
||
const statusMsg = await t.sendMessage(chatId, `🤔 ${engine.label} 處理中...`, { replyTo: message.message_id });
|
||
|
||
// Telegram 對 editMessageText 限流很兇：至少隔 3 秒、且不重疊
|
||
let lastEdit = 0;
|
||
let editing = false;
|
||
const onProgress = (progressText) => {
|
||
const now = Date.now();
|
||
if (editing || now - lastEdit < 3000) return;
|
||
editing = true;
|
||
lastEdit = now;
|
||
const body = `🚧 ${engine.label} 處理中...\n\n${progressText}`;
|
||
t.tg('editMessageText', {
|
||
chat_id: chatId,
|
||
message_id: statusMsg.message_id,
|
||
text: body.length > 3900 ? body.slice(0, 3900) + '...' : body,
|
||
}).catch(() => {}).finally(() => { editing = false; });
|
||
};
|
||
|
||
try {
|
||
const images = [];
|
||
if (photo) {
|
||
cleanTmp();
|
||
const dest = path.join(config.tmpDir, `${Date.now()}-${photo.uniqueId}${photo.ext}`);
|
||
await t.downloadFile(photo.fileId, dest);
|
||
images.push(dest);
|
||
}
|
||
|
||
let fallback = '（使用者只傳了圖片，請描述並依上下文處理）';
|
||
if (quotedOnly && (quoted || !sibling)) {
|
||
fallback = '（使用者沒有輸入文字，只引用了上面的內容並 tag 我：請直接把引用內容當作這次的輸入來處理）';
|
||
} else if (quotedOnly && sibling) {
|
||
fallback =
|
||
`【引用的 bot 訊息（@${sibling.botUsername} 在本聊天室的最近發言）】\n${sibling.text}\n\n` +
|
||
'（使用者沒有輸入文字，只引用了訊息並 tag 我：請直接把上面引用的內容當作這次的輸入來處理）';
|
||
}
|
||
const prompt = buildPrompt(message, content || fallback, { includeOwnReply: quotedOnly });
|
||
const existing = sessionKey ? sessions.get(sessionKey) : null;
|
||
const turnStart = Date.now();
|
||
|
||
let result;
|
||
let sessionResetNote = '';
|
||
let tid = existing?.threadId || null;
|
||
const MAX_ATTEMPTS = 2;
|
||
for (let attempt = 1; ; attempt++) {
|
||
try {
|
||
result = await engine.run({ config, prompt, threadId: tid, images, onProgress });
|
||
break;
|
||
} catch (err) {
|
||
// 舊會話 resume 不了：1) 會話已被引擎清掉 2) 換模型後 codex 拒絕跨模型 resume
|
||
// → 清掉會話、開新會話重跑（tid=null 之後不會再進這個分支，不會無限迴圈）
|
||
const sessionGone = /session|thread|conversation/i.test(err.message) && /not.*found|找不到|no .*(session|thread|conversation)/i.test(err.message);
|
||
const modelMismatch = /recorded with model/i.test(err.message);
|
||
if (tid && (sessionGone || modelMismatch)) {
|
||
if (sessionKey) sessions.clear(sessionKey);
|
||
tid = null;
|
||
sessionResetNote = modelMismatch
|
||
? '🆕 模型設定已變更，舊會話無法沿用，已自動開新會話（先前的對話記憶未帶入）。\n\n'
|
||
: '🆕 舊會話已失效，已自動開新會話。\n\n';
|
||
continue;
|
||
}
|
||
// 暫時性連線中斷（服務端切斷串流等）
|
||
if (err.transient) {
|
||
if (err.threadId) tid = err.threadId;
|
||
if (tid && sessionKey) sessions.set(sessionKey, tid); // 會話已建立，先記下來以便 resume
|
||
// 中斷前若圖已生成，直接交付，不重跑（避免重複生圖、多花時間）
|
||
if (engine.supportsImageGen && collectGeneratedImages(tid, turnStart).length > 0) {
|
||
result = { text: '（回覆文字因連線中斷遺失，圖片如下）', threadId: tid, usage: null };
|
||
sessionResetNote += '⚠️ 連線在回覆途中中斷，但圖片已生成完畢，直接送上。\n\n';
|
||
break;
|
||
}
|
||
if (attempt < MAX_ATTEMPTS) {
|
||
await t.tg('editMessageText', {
|
||
chat_id: chatId,
|
||
message_id: statusMsg.message_id,
|
||
text: `⚠️ 連線中斷，自動重試中（${attempt + 1}/${MAX_ATTEMPTS}）…`,
|
||
}).catch(() => {});
|
||
continue;
|
||
}
|
||
}
|
||
throw err;
|
||
}
|
||
}
|
||
|
||
if (result.threadId && sessionKey) sessions.set(sessionKey, result.threadId);
|
||
|
||
const display = resolveDisplay(result);
|
||
let ctxNote = '';
|
||
// 上下文用量過高就自動開新會話：越積越慢（尤其含圖），也容易在串流時被切斷
|
||
if (sessionKey && config.autoResetCtxPercent > 0 && result.usage && display.contextWindow) {
|
||
const pct = Math.round(((result.usage.input_tokens || 0) + (result.usage.output_tokens || 0)) / display.contextWindow * 100);
|
||
if (pct >= config.autoResetCtxPercent) {
|
||
sessions.clear(sessionKey);
|
||
ctxNote += `\n\n🧹 對話記憶已用到 ${pct}%，下一則訊息會自動開新會話（避免越來越慢）。`;
|
||
}
|
||
}
|
||
// claude 在非互動模式下被擋掉的操作（例如 workspace-write 不能執行指令），讓使用者知道
|
||
if (Array.isArray(result.denials) && result.denials.length > 0) {
|
||
const tools = [...new Set(result.denials.map((d) => d.tool_name).filter(Boolean))].join('、');
|
||
ctxNote += `\n\n⚠️ 有 ${result.denials.length} 個操作因沙盒權限被拒${tools ? `（${tools}）` : ''}；目前沙盒為 ${config.sandbox}。`;
|
||
}
|
||
|
||
const footer = buildFooter({ ...display, usage: result.usage });
|
||
const html = t.mdToTgHtml(sessionResetNote + (result.text || `（${engine.label} 沒有回覆文字）`) + ctxNote + footer);
|
||
await t.editOrSplit(chatId, statusMsg.message_id, html, { html: true });
|
||
recordChatLast(chatId, result.text || '');
|
||
await flushOutputs(chatId, message.message_id, result.threadId, turnStart);
|
||
await t.react(chatId, message.message_id, '👍');
|
||
} catch (error) {
|
||
console.error('處理訊息失敗：', error);
|
||
await t.editOrSplit(chatId, statusMsg.message_id, `❌ 發生錯誤：${error.message}`).catch(() => {});
|
||
await t.react(chatId, message.message_id, '');
|
||
}
|
||
}
|
||
|
||
async function pollLoop() {
|
||
let offset = 0;
|
||
for (;;) {
|
||
try {
|
||
const updates = await t.tg('getUpdates', { offset, timeout: 50, allowed_updates: ['message'] });
|
||
for (const update of updates) {
|
||
offset = update.update_id + 1;
|
||
queue = queue
|
||
.then(() => handleMessage(update.message))
|
||
.catch((err) => console.error('處理訊息錯誤：', err));
|
||
}
|
||
} catch (err) {
|
||
console.error('輪詢錯誤：', err.message);
|
||
await new Promise((r) => setTimeout(r, 5000));
|
||
}
|
||
}
|
||
}
|
||
|
||
async function start() {
|
||
const me = await t.tg('getMe', {});
|
||
botId = me.id;
|
||
botUsername = me.username;
|
||
await t.tg('setMyCommands', {
|
||
commands: [
|
||
{ command: 'new', description: '開新會話（清除對話記憶）' },
|
||
{ command: 'status', description: '查看會話與設定' },
|
||
{ command: 'help', description: '使用說明' },
|
||
],
|
||
}).catch(() => {});
|
||
|
||
console.log(`✅ @${botUsername} 已啟動（引擎：${engine.label}）`);
|
||
console.log(` 工作目錄：${config.workDir}`);
|
||
console.log(` 沙盒模式：${config.sandbox}`);
|
||
await pollLoop();
|
||
}
|
||
|
||
return { start };
|
||
}
|
||
|
||
module.exports = { startBot, buildFooter, loadModelMeta, loadCodexDefaults };
|