@yvhitxcel/opencode-remote 0.16.3 → 0.18.0

package/dist/plugins/agents/claude-code/index.js

@@ -1,6 +1,10 @@
-// Claude Code CLI agent adapter
+// Claude Code CLI agent adapter — --print + explicit context prompt
+// @ts-nocheck — spawn options type differs between @types/node versions
 import { spawn } from 'child_process';
 import { platform } from 'os';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { registerAgentProcess, unregisterAgentProcess } from '../../../core/agent-registry.js';
 
 const LIUV_CRASH_PATTERNS = [
     'Assertion failed',
@@ -23,18 +27,13 @@ export class ClaudeCodeAgentAdapter {
     }
 
     async sendPrompt(_sessionId, prompt, history, options = {}) {
-        const projectDir = options.projectDir;
-        const contextualPrompt = this.buildContextualPrompt(prompt, history);
-
-        const args = ['--print', contextualPrompt];
-
-        return this.callClaude(args, projectDir);
-    }
-
-    buildContextualPrompt(prompt, history) {
-        if (!history || history.length === 0) return prompt;
-        const historyText = history.map(msg => `[${msg.role}]: ${msg.content}`).join('\n\n');
-        return `Previous:\n${historyText}\n\n${prompt}`;
+        const threadId = options.threadId;
+        const contextualPrompt = buildContextualPrompt(prompt, history);
+        // 跑在临时目录，避免 claude 扫描项目源码崩在 misc-lib.mjs
+        const safeCwd = join(tmpdir(), 'opencode-remote-claude');
+        const { mkdirSync, existsSync } = await import('fs');
+        if (!existsSync(safeCwd)) mkdirSync(safeCwd, { recursive: true });
+        return this.callClaude(['--print', contextualPrompt], safeCwd, threadId);
     }
 
     isCrashNoise(line) {
@@ -42,70 +41,83 @@ export class ClaudeCodeAgentAdapter {
     }
 
     extractErrorMessage(stdout, stderr, code) {
-        // 先检查 stdout：--print 模式把错误也输出到 stdout
         const stdoutLines = stdout.trim().split('\n').map(l => l.trim()).filter(Boolean);
         const stdoutErrors = stdoutLines.filter(l => !this.isCrashNoise(l));
-        if (stdoutErrors.length > 0) {
-            return stdoutErrors.join('\n');
-        }
-
-        // 再检查 stderr
+        if (stdoutErrors.length > 0) return stdoutErrors.join('\n');
         const stderrLines = stderr.trim().split('\n').map(l => l.trim()).filter(Boolean);
         const stderrReal = stderrLines.filter(l => !this.isCrashNoise(l));
-        if (stderrReal.length > 0) {
-            return stderrReal.join('\n');
-        }
-
-        // 如果全是崩溃噪音，尝试从任一流中找 Error 关键词
+        if (stderrReal.length > 0) return stderrReal.join('\n');
         const all = [...stdoutLines, ...stderrLines];
         const firstRelevant = all.find(l => /Error|error|ERROR|^\d{3}/.test(l));
         if (firstRelevant) return firstRelevant;
-
-        // 兜底
         return `进程异常退出 (code: ${code})`;
     }
 
-    callClaude(args, projectDir) {
+    callClaude(args, safeCwd, threadId) {
         return new Promise((resolve) => {
             const opts = {
                 stdio: ['ignore', 'pipe', 'pipe'],
                 shell: true,
+                cwd: safeCwd,
             };
-            if (projectDir) {
-                opts.cwd = projectDir;
-            }
-
-            console.log(`[claude-code] Spawning: claude ${args.join(' ')} in ${opts.cwd || process.cwd()}`);
-            const proc = spawn('claude', args, opts);
+// shell:true on Windows cmd.exe (and /bin/sh on POSIX) interprets several chars
+// as command syntax. Strip them so user message content can't trigger command
+// splitting, redirection, or quoting issues:
+//   \n \r — command separator (cmd.exe), treated as command end
+//   & | < > ^ — command separator / pipe / redirect / escape
+//   " ' ` — quote chars (could break out of intended argument)
+// We strip rather than escape to avoid platform-specific escape syntax.
+const safeArgs = args.map(a => {
+    if (typeof a !== 'string') return a;
+    return a
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/[&|<>^"`]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+});
+            console.log(`[claude-code] ${safeArgs.join(' ')}`);
+            const proc = spawn('claude', safeArgs, opts);
+            if (threadId) registerAgentProcess(threadId, proc, 'claude-code');
             let stdout = '';
             let stderr = '';
+            let killed = false;
             proc.stdout?.on('data', (data) => { stdout += data.toString(); });
             proc.stderr?.on('data', (data) => { stderr += data.toString(); });
 
+            const TIMEOUT_MS = parseInt(process.env.OPENCODE_TIMEOUT || '600', 10) * 1000;
             const timeout = setTimeout(() => {
-                console.log(`[claude-code] Process still running after 30s, stderr so far: ${stderr.slice(-200)}`);
-            }, 30000);
+                killed = true;
+                console.warn(`[claude-code] Timeout ${TIMEOUT_MS / 1000}s`);
+                try { proc.kill('SIGKILL'); } catch {}
+                resolve(`⏰ Claude Code 超时 (${TIMEOUT_MS / 1000}s)`);
+            }, TIMEOUT_MS);
 
             proc.on('close', (code) => {
                 clearTimeout(timeout);
-                console.log(`[claude-code] Process exited with code ${code}, stdout=${stdout.length} bytes, stderr=${stderr.length} bytes`);
-
-                if (code === 0) {
-                    resolve(stdout.trim());
-                    return;
-                }
-
+                if (threadId) unregisterAgentProcess(threadId);
+                if (killed) return;
+                console.log(`[claude-code] exit ${code}, ${stdout.length} bytes`);
+                if (code === 0) { resolve(stdout.trim()); return; }
                 const errorMsg = this.extractErrorMessage(stdout, stderr, code);
-                console.log(`[claude-code] Process failed, raw stderr:\n${stderr.trim().slice(-1000)}`);
-                console.log(`[claude-code] Error detail:\n${errorMsg}`);
-
-                resolve(`❌ Claude Code 错误 (exit code ${code}): ${errorMsg}`);
+                resolve(`❌ Claude Code 错误 (exit ${code}): ${errorMsg}`);
             });
             proc.on('error', (err) => {
                 clearTimeout(timeout);
-                console.log(`[claude-code] Spawn error: ${err.message}`);
+                if (threadId) unregisterAgentProcess(threadId);
                 resolve(`❌ Claude Code 启动失败: ${err.message}`);
             });
         });
     }
 }
+
+function buildContextualPrompt(prompt, history) {
+    if (!history || history.length === 0) return prompt;
+    const lines = history.slice(-10).map(m => {
+        const label = m.role === 'user' ? 'User' : 'Assistant';
+        return `${label}: ${m.content}`;
+    }).join('\n');
+    return `[Previous conversation — for context only, answer the LATEST question below]\n\n${lines}\n\n[Latest question]\n${prompt}`;
+}
+
+// Exported for tests
+export { buildContextualPrompt };

package/dist/plugins/agents/codex/index.js

@@ -1,6 +1,8 @@
 // OpenAI Codex CLI agent adapter
+// @ts-nocheck — spawn options type differs between @types/node versions
 import { spawn } from 'child_process';
 import { platform } from 'os';
+import { registerAgentProcess, unregisterAgentProcess } from '../../../core/agent-registry.js';
 
 const CRASH_PATTERNS = [
     'Assertion failed',
@@ -22,15 +24,18 @@ export class CodexAgentAdapter {
         });
     }
     
-    async sendPrompt(_sessionId, prompt, history) {
+    async sendPrompt(_sessionId, prompt, history, options = {}) {
         const contextualPrompt = this.buildContextualPrompt(prompt, history);
-        return this.callCodex(contextualPrompt);
+        return this.callCodex(contextualPrompt, options.threadId);
     }
     
     buildContextualPrompt(prompt, history) {
         if (!history || history.length === 0) return prompt;
-        const historyText = history.map(msg => `[${msg.role}]: ${msg.content}`).join('\n\n');
-        return `Context:\n${historyText}\n\n${prompt}`;
+        const lines = history.slice(-10).map(msg => {
+            const label = msg.role === 'user' ? 'User' : 'AI';
+            return `${label}: ${msg.content}`;
+        }).join('\n');
+        return `[Previous conversation — for context only, answer the LATEST question below]\n\n${lines}\n\n[Latest question]\n${prompt}`;
     }
 
     extractErrorMessage(stdout, stderr) {
@@ -43,17 +48,38 @@ export class CodexAgentAdapter {
         return first || null;
     }
     
-    callCodex(prompt) {
+callCodex(prompt, threadId) {
         return new Promise((resolve) => {
-            const proc = spawn('codex', ['--prompt', prompt], {
+// shell:true on Windows cmd.exe (and /bin/sh on POSIX) interprets several chars
+// as command syntax. Strip them so user message content can't trigger command
+// splitting, redirection, or quoting issues.
+const safePrompt = typeof prompt === 'string'
+    ? prompt
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/[&|<>^"`]/g, '')
+        .replace(/\s+/g, ' ').trim()
+    : prompt;
+            const proc = spawn('codex', ['exec', safePrompt], {
                 stdio: ['ignore', 'pipe', 'pipe'],
                 shell: true,
             });
+            if (threadId) registerAgentProcess(threadId, proc, 'codex');
             let stdout = '';
             let stderr = '';
+            let killed = false;
             proc.stdout?.on('data', (data) => { stdout += data.toString(); });
             proc.stderr?.on('data', (data) => { stderr += data.toString(); });
+            const TIMEOUT_MS = parseInt(process.env.OPENCODE_TIMEOUT || '600', 10) * 1000;
+            const timeout = setTimeout(() => {
+                killed = true;
+                console.warn(`[codex] Timeout after ${TIMEOUT_MS / 1000}s, killing process`);
+                try { proc.kill('SIGKILL'); } catch {}
+                resolve(`⏰ Codex 超时 (${TIMEOUT_MS / 1000}s)，任务已终止`);
+            }, TIMEOUT_MS);
             proc.on('close', (code) => {
+                clearTimeout(timeout);
+                if (threadId) unregisterAgentProcess(threadId);
+                if (killed) return;
                 if (code === 0) {
                     resolve(stdout.trim());
                 } else {

package/dist/plugins/agents/copilot/index.js

@@ -1,6 +1,8 @@
 // GitHub Copilot CLI agent adapter
+// @ts-nocheck — spawn options type differs between @types/node versions
 import { spawn } from 'child_process';
 import { platform } from 'os';
+import { registerAgentProcess, unregisterAgentProcess } from '../../../core/agent-registry.js';
 
 const CRASH_PATTERNS = [
     'Assertion failed',
@@ -22,15 +24,18 @@ export class CopilotAgentAdapter {
         });
     }
     
-    async sendPrompt(_sessionId, prompt, history) {
+    async sendPrompt(_sessionId, prompt, history, options = {}) {
         const contextualPrompt = this.buildContextualPrompt(prompt, history);
-        return this.callCopilot(contextualPrompt);
+        return this.callCopilot(contextualPrompt, options.threadId);
     }
     
     buildContextualPrompt(prompt, history) {
         if (!history || history.length === 0) return prompt;
-        const historyText = history.map(msg => `[${msg.role}]: ${msg.content}`).join('\n\n');
-        return `Context:\n${historyText}\n\n${prompt}`;
+        const lines = history.slice(-10).map(msg => {
+            const label = msg.role === 'user' ? 'User' : 'AI';
+            return `${label}: ${msg.content}`;
+        }).join('\n');
+        return `[Previous conversation — for context only, answer the LATEST question below]\n\n${lines}\n\n[Latest question]\n${prompt}`;
     }
 
     extractErrorMessage(stdout, stderr) {
@@ -43,17 +48,38 @@ export class CopilotAgentAdapter {
         return first || null;
     }
     
-    callCopilot(prompt) {
+callCopilot(prompt, threadId) {
         return new Promise((resolve) => {
-            const proc = spawn('copilot', ['suggest', '--prompt', prompt], {
+// shell:true on Windows cmd.exe (and /bin/sh on POSIX) interprets several chars
+// as command syntax. Strip them so user message content can't trigger command
+// splitting, redirection, or quoting issues.
+const safePrompt = typeof prompt === 'string'
+    ? prompt
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/[&|<>^"`]/g, '')
+        .replace(/\s+/g, ' ').trim()
+    : prompt;
+            const proc = spawn('copilot', ['-p', safePrompt], {
                 stdio: ['ignore', 'pipe', 'pipe'],
                 shell: true,
             });
+            if (threadId) registerAgentProcess(threadId, proc, 'copilot');
             let stdout = '';
             let stderr = '';
+            let killed = false;
             proc.stdout?.on('data', (data) => { stdout += data.toString(); });
             proc.stderr?.on('data', (data) => { stderr += data.toString(); });
+            const TIMEOUT_MS = parseInt(process.env.OPENCODE_TIMEOUT || '600', 10) * 1000;
+            const timeout = setTimeout(() => {
+                killed = true;
+                console.warn(`[copilot] Timeout after ${TIMEOUT_MS / 1000}s, killing process`);
+                try { proc.kill('SIGKILL'); } catch {}
+                resolve(`⏰ Copilot 超时 (${TIMEOUT_MS / 1000}s)，任务已终止`);
+            }, TIMEOUT_MS);
             proc.on('close', (code) => {
+                clearTimeout(timeout);
+                if (threadId) unregisterAgentProcess(threadId);
+                if (killed) return;
                 if (code === 0) {
                     resolve(stdout.trim());
                 } else {

package/dist/plugins/agents/opencode/index.js

@@ -1,6 +1,8 @@
 // OpenCode CLI agent adapter
+// @ts-nocheck — spawn options type differs between @types/node versions
 import { spawn } from 'child_process';
 import { platform } from 'os';
+import { registerAgentProcess, unregisterAgentProcess } from '../../../core/agent-registry.js';
 
 const CRASH_PATTERNS = [
     'Assertion failed',
@@ -23,18 +25,20 @@ export class OpenCodeAgentAdapter {
     }
     
     async sendPrompt(_sessionId, prompt, history, options = {}) {
+        const threadId = options.threadId;
         const contextualPrompt = this.buildContextualPrompt(prompt, history);
-        return this.callOpenCode(contextualPrompt);
+        return this.callOpenCode(contextualPrompt, threadId);
     }
-    
+
     buildContextualPrompt(prompt, history) {
         if (!history || history.length === 0) return prompt;
-        const historyText = history
-            .map(msg => `[${msg.role === 'user' ? 'User' : 'Assistant'}]: ${msg.content}`)
-            .join('\n\n');
-        return `Previous conversation:\n${historyText}\n\nCurrent request: ${prompt}`;
+        const lines = history.slice(-10).map(msg => {
+            const label = msg.role === 'user' ? 'User' : 'AI';
+            return `${label}: ${msg.content}`;
+        }).join('\n');
+        return `[Previous conversation — for context only, answer the LATEST question below]\n\n${lines}\n\n[Latest question]\n${prompt}`;
     }
-    
+
     extractErrorMessage(stdout, stderr) {
         const lines = [...stdout.trim().split('\n'), ...stderr.trim().split('\n')]
             .map(l => l.trim()).filter(Boolean)
@@ -45,18 +49,38 @@ export class OpenCodeAgentAdapter {
             .find(l => /Error|error|ERROR|^\d{3}/.test(l));
         return first || null;
     }
-    
-    callOpenCode(prompt) {
+
+    callOpenCode(prompt, threadId) {
         return new Promise((resolve) => {
-            const proc = spawn('opencode', ['run', '--format', 'json', prompt], {
+// shell:true on Windows cmd.exe (and /bin/sh on POSIX) interprets several chars
+// as command syntax. Strip them so user message content can't trigger command
+// splitting, redirection, or quoting issues.
+const safePrompt = typeof prompt === 'string'
+    ? prompt
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/[&|<>^"`]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+    : prompt;
+            const proc = spawn('opencode', ['run', '--format', 'json', safePrompt], {
                 stdio: ['ignore', 'pipe', 'pipe'],
                 shell: true,
             });
+            if (threadId) registerAgentProcess(threadId, proc, 'opencode');
 
             let stdout = '';
             let stderr = '';
             let fullText = '';
             let resigned = false;
+            let killed = false;
+
+            const TIMEOUT_MS = parseInt(process.env.OPENCODE_TIMEOUT || '600', 10) * 1000;
+            const timeout = setTimeout(() => {
+                killed = true;
+                console.warn(`[opencode-agent] Timeout after ${TIMEOUT_MS / 1000}s, killing process`);
+                try { proc.kill('SIGKILL'); } catch {}
+                resolve(`⏰ OpenCode 超时 (${TIMEOUT_MS / 1000}s)，任务已终止`);
+            }, TIMEOUT_MS);
 
             const STUCK_PATTERNS = [
                 'Free usage exceeded', 'quota exceeded', 'rate limit',
@@ -88,7 +112,7 @@ export class OpenCodeAgentAdapter {
                     try {
                         const event = JSON.parse(line);
                         if (event.text) fullText += event.text;
-                    } catch {}
+                    } catch (e) { console.debug('[opencode-agent] stdout parse:', e.message); }
                 }
             });
 
@@ -98,7 +122,9 @@ export class OpenCodeAgentAdapter {
             });
 
             proc.on('close', (code) => {
-                if (resigned) return;
+                clearTimeout(timeout);
+                if (threadId) unregisterAgentProcess(threadId);
+                if (resigned || killed) return;
                 if (code !== 0) {
                     const detail = this.extractErrorMessage(stdout, stderr);
                     const hint = detail

package/dist/telegram/adapter.js

@@ -38,15 +38,12 @@ export class TelegramAdapter {
     async sendCommandMenu(threadId, title) {
         if (!this.bot) return;
         const groups = [
-            ['🟢 常用', ['/help', '/status', '/start', '/reset']],
-            ['🔄 任务', ['/loop', '/refresh', '/restart']],
-            ['🤖 AI', ['/model', '/agents', '/oc', '/cc']],
-            ['🧠 专家', ['/tutorial', '/z', '/diagnose']],
-            ['📂 会话', ['/sessions', '/delsessions', '/copy', '/revert']],
-            ['⬆️ 文件', ['/upload', '/delete']],
+            ['/help', '/start', '/reset', '/diagnose'],
+            ['/restart', '/model', '/oc', '/cc'],
+            ['/cx', '/copilot'],
         ];
         const keyboard = [];
-        for (const [, cmds] of groups) {
+        for (const cmds of groups) {
             const row = cmds.map(cmd => ({ text: cmd, callback_data: `cmd:${cmd.slice(1)}` }));
             keyboard.push(row);
         }
@@ -55,14 +52,30 @@ export class TelegramAdapter {
         });
     }
 
+    // BotAdapter 接口方法
+    async reply(threadId, text) { return this.sendMessage(threadId, text); }
+    async sendTypingIndicator(threadId) { return this.sendTyping(threadId, true); }
+    async sendTypingEnd(threadId) { return this.sendTyping(threadId, false); }
+    async updateMessage(threadId, messageId, text) {
+        if (!this.bot || !messageId) return;
+        try { await this.bot.api.editMessageText(threadId, Number(messageId), text); } catch (e) { console.warn('[telegram] updateMessage failed:', e.message); }
+    }
+    async deleteMessage(threadId, messageId) {
+        if (!this.bot || !messageId) return;
+        try { await this.bot.api.deleteMessage(threadId, Number(messageId)); }
+        catch (e) { console.debug('[telegram] deleteMessage failed:', e.message); }
+    }
+
     async sendTyping(threadId, isTyping) {
         if (!this.bot) return;
         if (isTyping) {
-            try { await this.bot.api.sendChatAction(threadId, 'typing'); } catch {}
+            try { await this.bot.api.sendChatAction(threadId, 'typing'); }
+            catch (e) { console.debug('[telegram] sendChatAction failed:', e.message); }
             const existing = this.typingIntervals.get(threadId);
             if (existing) clearInterval(existing);
             const interval = setInterval(async () => {
-                try { await this.bot.api.sendChatAction(threadId, 'typing'); } catch {}
+                try { await this.bot.api.sendChatAction(threadId, 'typing'); }
+                catch (e) { console.debug('[telegram] typing-tick failed:', e.message); }
             }, 4000);
             this.typingIntervals.set(threadId, interval);
         } else {

package/dist/telegram/bot.js

@@ -1,8 +1,8 @@
 import { registry } from '../core/registry.js';
-import { sessionManager } from '../core/session.js';
 import { initOpenCode, createSession, sendMessage as sendToOpenCode, checkConnection } from '../opencode/client.js';
 import { parseMessage, routeMessage } from '../core/router.js';
 import { telegramAdapter } from './adapter.js';
+import { splitMessage } from '../utils/message-split.js';
 
 export async function startBot() {
     const { loadConfig } = await import('../core/config.js');
@@ -17,7 +17,6 @@ export async function startBot() {
         process.exit(1);
     }
 
-    await sessionManager.start();
     await registry.loadBuiltInPlugins();
     await telegramAdapter.start(config);
 
@@ -68,10 +67,6 @@ export async function startBot() {
             if (parsed.type === 'command' && parsed.command === 'reset') {
                 openCodeSessions.delete(message.threadId);
                 opencodeSessionId = null;
-                try {
-                    const session = await sessionManager.getExistingSession(platform, channelId, message.threadId);
-                    if (session) await sessionManager.resetConversation(platform, channelId, message.threadId);
-                } catch (e) { console.warn('[Telegram] Reset error:', e.message); }
             }
 
             if (parsed.type === 'default') {

package/dist/weixin/adapter.js

@@ -7,13 +7,35 @@ function createWeixinAdapter(baseUrl, token, botId) {
     const processedMessages = new Map();
     const DEDUP_WINDOW_MS = 30_000;
 
-    function isDuplicate(messageId) {
-        if (!messageId) return false;
-        const seenAt = processedMessages.get(messageId);
-        if (seenAt && Date.now() - seenAt < DEDUP_WINDOW_MS) return true;
-        processedMessages.set(messageId, Date.now());
+    // 定期清理 contextTokens 和 typingTickets，防内存泄漏
+    const CLEANUP_INTERVAL_MS = 30 * 60 * 1000;
+    let cleanupTimer = null;
+    function startCleanup() {
+        if (cleanupTimer) return;
+        cleanupTimer = setInterval(() => {
+            const cutoff = Date.now() - CLEANUP_INTERVAL_MS;
+            for (const [k, v] of contextTokens) { if (typeof v !== 'object' || !v._ts || v._ts < cutoff) contextTokens.delete(k); }
+            for (const [k, v] of typingTickets) { if (typeof v !== 'object' || !v._ts || v._ts < cutoff) typingTickets.delete(k); }
+            if (processedMessages.size > 1000) {
+                const now = Date.now();
+                for (const [id, ts] of processedMessages.entries()) {
+                    if (now - ts > DEDUP_WINDOW_MS) processedMessages.delete(id);
+                }
+            }
+        }, CLEANUP_INTERVAL_MS);
+        if (cleanupTimer.unref) cleanupTimer.unref();
+    }
+    startCleanup();
+
+    function isDuplicate(messageId, contentKey) {
+        // 优先用内容去重: 微信两条消息可能 messageId 不同但内容相同
+        const key = contentKey || messageId;
+        if (!key) return false;
+        const now = Date.now();
+        const seenAt = processedMessages.get(key);
+        if (seenAt && now - seenAt < DEDUP_WINDOW_MS) return true;
+        processedMessages.set(key, now);
         if (processedMessages.size > 1000) {
-            const now = Date.now();
             for (const [id, ts] of processedMessages.entries()) {
                 if (now - ts > DEDUP_WINDOW_MS) processedMessages.delete(id);
             }
@@ -29,7 +51,8 @@ function createWeixinAdapter(baseUrl, token, botId) {
         _token: token,
         _botId: botId,
         async reply(threadId, text) {
-            let contextToken = contextTokens.get(threadId);
+            let entry = contextTokens.get(threadId);
+            let contextToken = entry?.value || entry;
             let retryCount = 0;
             const maxRetries = 2;
 
@@ -40,7 +63,7 @@ function createWeixinAdapter(baseUrl, token, botId) {
                         const r = await getConfig({ baseUrl, token, ilinkUserId: threadId, contextToken: undefined });
                         contextToken = r.context_token || r.typing_ticket;
                         if (contextToken) {
-                            contextTokens.set(threadId, contextToken);
+                            contextTokens.set(threadId, { value: contextToken, _ts: Date.now() });
                             console.log(`[Weixin] Got contextToken: ${contextToken.slice(0, 8)}...`);
                         } else if (r.errcode === -14) {
                             console.log(`[Weixin] Session timeout, retrying with fresh token...`);
@@ -88,24 +111,24 @@ function createWeixinAdapter(baseUrl, token, botId) {
             throw err;
         },
         async sendTypingIndicator(threadId) {
-            const cachedTicket = typingTickets.get(threadId);
-            let ticket = cachedTicket;
+            const entry = typingTickets.get(threadId);
+            let ticket = entry?.value || entry;
             
             if (!ticket) {
                 try {
-                    const r = await getConfig({ baseUrl, token, ilinkUserId: threadId, contextToken: contextTokens.get(threadId) });
+                    const r = await getConfig({ baseUrl, token, ilinkUserId: threadId, contextToken: (contextTokens.get(threadId) || {}).value });
                     if (r.errcode === -14) {
                         contextTokens.delete(threadId);
                         typingTickets.delete(threadId);
                         const freshConfig = await getConfig({ baseUrl, token, ilinkUserId: threadId, contextToken: undefined });
                         ticket = freshConfig.typing_ticket;
                         if (freshConfig.context_token) {
-                            contextTokens.set(threadId, freshConfig.context_token);
+                            contextTokens.set(threadId, { value: freshConfig.context_token, _ts: Date.now() });
                         }
                     } else {
                         ticket = r.typing_ticket;
                     }
-                    if (ticket) typingTickets.set(threadId, ticket);
+                    if (ticket) typingTickets.set(threadId, { value: ticket, _ts: Date.now() });
                 } catch { console.debug('[typing] getConfig failed'); }
             }
             if (ticket) {
@@ -118,7 +141,7 @@ function createWeixinAdapter(baseUrl, token, botId) {
                         try {
                             const freshConfig = await getConfig({ baseUrl, token, ilinkUserId: threadId, contextToken: undefined });
                             if (freshConfig.typing_ticket) {
-                                typingTickets.set(threadId, freshConfig.typing_ticket);
+                                typingTickets.set(threadId, { value: freshConfig.typing_ticket, _ts: Date.now() });
                                 await sendTyping({ baseUrl, token, body: { ilink_user_id: threadId, typing_ticket: freshConfig.typing_ticket, status: 1 } });
                             }
                         } catch { console.debug('[typing] retry getConfig failed'); }
@@ -132,4 +155,3 @@ function createWeixinAdapter(baseUrl, token, botId) {
 }
 
 export { createWeixinAdapter };
-export default createWeixinAdapter;