libero3 0.3.0

package/dist/mcp/src/timer/index.js

@@ -0,0 +1,234 @@
+import { toLocalIso } from "../clock/index.js";
+import { needsConfirmIfMissing, } from "../profile-confirm.js";
+import { lookupTargetUserLabel, resolveTargetUserLabel, } from "../profile-helpers.js";
+// ── pure helpers (algorithm = verbatim copy of original memory logic) ──
+function nowISO() {
+    return new Date().toISOString();
+}
+const IDLE_VIEW = {
+    status: "idle",
+    event: null,
+    startedAt: null,
+    pausedAt: null,
+    accumulatedMs: 0,
+    targetMs: null,
+    remainingMs: null,
+};
+function toView(session) {
+    if (session.status === "stopped")
+        return { ...IDLE_VIEW };
+    const targetMs = session.target_ms ?? null;
+    let remainingMs = null;
+    if (targetMs !== null) {
+        const elapsed = computeElapsed(session);
+        remainingMs = targetMs - elapsed;
+    }
+    return {
+        status: session.status,
+        event: session.event,
+        categoryId: session.category_id ?? undefined,
+        startedAt: toLocalIso(session.started_at),
+        pausedAt: session.status === "paused" ? toLocalIso(session.updated_at) : null,
+        accumulatedMs: session.accumulated_ms,
+        targetMs,
+        remainingMs,
+    };
+}
+function computeElapsed(session) {
+    if (session.status === "stopped")
+        return 0;
+    if (session.status === "paused")
+        return session.accumulated_ms;
+    // running
+    return (session.accumulated_ms +
+        (Date.now() - new Date(session.started_at).getTime()));
+}
+function labelFor(db, userId) {
+    if (db)
+        return lookupTargetUserLabel(db, userId);
+    return resolveTargetUserLabel(userId);
+}
+// ── factory ──
+export function createTimerTools(repo, timeBlockRepo, db) {
+    const start = async (userId, event, categoryId, taskId, targetUserId) => {
+        if (!event || event.trim() === "") {
+            throw new Error("事件名不能为空");
+        }
+        const effective = targetUserId ?? userId;
+        const userExists = await repo.userExists(effective);
+        const gate = needsConfirmIfMissing(userExists, effective);
+        if (gate)
+            return gate;
+        const active = await repo.getActive(effective);
+        if (active) {
+            throw new Error(`当前正在计时「${active.event}」，请先停止后再开始新的计时`);
+        }
+        const session = await repo.create({
+            user_id: effective,
+            event: event.trim(),
+            category_id: categoryId,
+            started_at: nowISO(),
+            task_id: taskId,
+        });
+        return {
+            ...toView(session),
+            target_user_label: labelFor(db, effective),
+        };
+    };
+    const pause = async (userId) => {
+        const active = await repo.getActive(userId);
+        if (!active || active.status !== "running") {
+            throw new Error("当前没有运行中的计时");
+        }
+        const segmentMs = Date.now() - new Date(active.started_at).getTime();
+        const accumulated = active.accumulated_ms + segmentMs;
+        const session = await repo.update(active.id, {
+            status: "paused",
+            accumulated_ms: accumulated,
+        });
+        return toView(session);
+    };
+    const resume = async (userId) => {
+        const active = await repo.getActive(userId);
+        if (active && active.status === "running") {
+            throw new Error("计时已在运行中");
+        }
+        if (!active || active.status !== "paused") {
+            throw new Error("没有可恢复的暂停计时");
+        }
+        const session = await repo.update(active.id, {
+            status: "running",
+            started_at: nowISO(),
+        });
+        return toView(session);
+    };
+    const stop = async (userId, options) => {
+        const active = await repo.getActive(userId);
+        if (!active ||
+            (active.status !== "running" && active.status !== "paused")) {
+            throw new Error("当前没有运行中的计时");
+        }
+        const endedAt = nowISO();
+        const totalMs = computeElapsed(active);
+        const durationMin = Math.round((totalMs / 60000) * 100) / 100;
+        await repo.update(active.id, {
+            status: "stopped",
+            ended_at: endedAt,
+        });
+        let timeblockId;
+        // S42 (2026-08-07): 回查匹配的 planned timeblock → 改 completed
+        // 用户场景：先排了 planned timeblock（如「羽毛球 9:00-11:00」），后开计时；
+        // 停计时期望自动标完成（带 ✓ + 划线），而不是 create 新的。
+        // 匹配规则：同 user_id + 同 title + 时间重叠 + status=planned
+        //
+        // ⚠️ 时区陷阱：planned timeblock 的 start_time/end_time 可能是 +08:00 格式（用户传入），
+        // 而 timer.session 的 started_at 是 Z 格式（nowISO()）。findOverlapping 用字符串比较，
+        // 混合时区会误判（"2026-08-07T09:00:00+08:00" vs "2026-08-07T05:00:00Z" 字符串比较 09 > 05）。
+        // 解法：调用前把 started_at/endedAt 都转 ISO UTC（Z 格式），与 line 578-581 其它 list 查询姿势一致。
+        if (timeBlockRepo) {
+            const startUtc = new Date(active.started_at).toISOString();
+            const endUtc = new Date(endedAt).toISOString();
+            const candidates = await timeBlockRepo.findOverlapping({
+                user_id: active.user_id,
+                start: startUtc,
+                end: endUtc,
+            });
+            const match = candidates.find((tb) => tb.status === "planned" &&
+                (tb.title === active.event ||
+                    tb.title.includes(active.event) ||
+                    active.event.includes(tb.title)));
+            if (match) {
+                const updated = await timeBlockRepo.update(match.id, {
+                    end_time: endedAt,
+                    status: "completed",
+                    ...(options?.rating !== undefined ? { rating: options.rating } : {}),
+                    ...(options?.rating_reason !== undefined
+                        ? { rating_reason: options.rating_reason }
+                        : {}),
+                });
+                timeblockId = updated.id;
+            }
+        }
+        // 没匹配到 planned → 走原 create 路径（仅 rating 时）
+        if (!timeblockId && options?.rating !== undefined && timeBlockRepo) {
+            const tb = await timeBlockRepo.create({
+                user_id: active.user_id,
+                title: active.event,
+                category_id: active.category_id ?? undefined,
+                start_time: active.started_at,
+                end_time: endedAt,
+                rating: options.rating,
+                rating_reason: options.rating_reason,
+                status: "completed",
+            });
+            timeblockId = tb.id;
+        }
+        const record = {
+            event: active.event,
+            categoryId: active.category_id ?? undefined,
+            startedAt: toLocalIso(active.started_at),
+            endedAt: toLocalIso(endedAt),
+            elapsedMs: totalMs,
+            durationMin,
+            timeblockId,
+            completedTaskId: active.task_id ?? undefined,
+        };
+        return record;
+    };
+    const status = async (userId) => {
+        const active = await repo.getActive(userId);
+        if (!active)
+            return { ...IDLE_VIEW };
+        return toView(active);
+    };
+    const statusAll = async () => {
+        const sessions = await repo.getAllActive();
+        return sessions.map((s) => ({
+            ...toView(s),
+            userId: s.user_id,
+        }));
+    };
+    const elapsed = async (userId) => {
+        const active = await repo.getActive(userId);
+        if (!active)
+            return 0;
+        return computeElapsed(active);
+    };
+    // ── S26: pomodoro v1 ──
+    const startFocus = async (userId, event, focusMin, categoryId, taskId) => {
+        const min = focusMin ?? 25;
+        if (min <= 0) {
+            throw new Error("focusMin 必须为正");
+        }
+        if (!event || event.trim() === "") {
+            throw new Error("事件名不能为空");
+        }
+        const userExists = await repo.userExists(userId);
+        if (!userExists) {
+            throw new Error("用户不存在");
+        }
+        const active = await repo.getActive(userId);
+        if (active) {
+            throw new Error(`当前正在计时「${active.event}」，请先停止后再开始新的计时`);
+        }
+        const session = await repo.create({
+            user_id: userId,
+            event: event.trim(),
+            category_id: categoryId,
+            started_at: nowISO(),
+            target_ms: Math.round(min * 60000),
+            task_id: taskId,
+        });
+        return toView(session);
+    };
+    const remaining = async (userId) => {
+        const active = await repo.getActive(userId);
+        if (!active)
+            return { ms: null, over: false };
+        if (active.target_ms == null)
+            return { ms: null, over: false };
+        const ms = active.target_ms - computeElapsed(active);
+        return { ms, over: ms < 0 };
+    };
+    return { start, pause, resume, stop, status, statusAll, elapsed, startFocus, remaining };
+}

package/dist/mcp/src/user-id-resolver.js

@@ -0,0 +1,30 @@
+const SYSTEM_IDS = ["libero", "default", "test", "user_01"];
+/**
+ * Resolve a default user_id for MCP tools when the LLM omits user_id.
+ */
+export function resolveDefaultUserId({ db, env, }) {
+    const envMap = env ?? process.env;
+    const fromEnv = envMap.LIBERO_DEFAULT_USER_ID?.trim();
+    if (fromEnv) {
+        return { userId: fromEnv, source: "env" };
+    }
+    const placeholders = SYSTEM_IDS.map(() => "?").join(",");
+    // ESCAPE 通过参数传 '\'，让 LIKE 里的 _ 当字面量
+    // （默认 _ 是单字符通配，会误排除 test-foo 这种 id）
+    const row = db
+        .prepare(`SELECT id FROM user_profile
+       WHERE deleted_at IS NULL
+         AND id NOT IN (${placeholders})
+         AND id NOT LIKE ? ESCAPE ?
+       ORDER BY created_at ASC
+       LIMIT 1`)
+        .get(...SYSTEM_IDS, "test\\_%", "\\");
+    if (row?.id) {
+        return { userId: row.id, source: "db" };
+    }
+    return { userId: null, source: "none" };
+}
+/** Startup log to stderr (visible in gateway / pm2 logs). */
+export function logResolvedDefaultUserId(result) {
+    console.error(`[libero-mcp] default user_id=${result.userId ?? "none"} source=${result.source}`);
+}

package/dist/mcp/src/weixin/app.js

@@ -0,0 +1,97 @@
+/**
+ * WeChat 服务号 webhook: URL 验证；文本先被动回「我先看看」，日程异步再推。
+ */
+import { appendFileSync } from "node:fs";
+import { Hono } from "hono";
+import { weixinSignatureOk } from "./signature.js";
+import { parseWeixinXml, weixinPassiveTextReply } from "./xml.js";
+const seenMsgIds = new Set();
+function rememberMsg(id) {
+    if (!id)
+        return true;
+    if (seenMsgIds.has(id))
+        return false;
+    seenMsgIds.add(id);
+    if (seenMsgIds.size > 500) {
+        const first = seenMsgIds.values().next().value;
+        if (first)
+            seenMsgIds.delete(first);
+    }
+    return true;
+}
+function wlog(path, line) {
+    const msg = `[libero-weixin] ${line}`;
+    console.error(msg);
+    if (!path)
+        return;
+    try {
+        appendFileSync(path, `${new Date().toISOString()} ${line}\n`);
+    }
+    catch {
+        /* ignore log IO */
+    }
+}
+export function createWeixinApp(opts) {
+    const app = new Hono();
+    const log = (line) => wlog(opts.logPath, line);
+    app.use("*", async (c, next) => {
+        log(`${c.req.method} ${c.req.path}`);
+        await next();
+    });
+    const signed = (c) => weixinSignatureOk({
+        token: opts.token,
+        signature: c.req.query("signature") ?? "",
+        timestamp: c.req.query("timestamp") ?? "",
+        nonce: c.req.query("nonce") ?? "",
+    });
+    const getHandshake = (c) => {
+        if (!signed(c)) {
+            log("GET reject signature");
+            return c.text("", 403);
+        }
+        log("GET echostr ok");
+        return c.text(c.req.query("echostr") ?? "", 200);
+    };
+    const postMessage = async (c) => {
+        if (!signed(c)) {
+            log(`POST reject signature path=${c.req.path}`);
+            return c.text("", 403);
+        }
+        const xml = await c.req.text();
+        const msg = parseWeixinXml(xml);
+        log(`POST path=${c.req.path} bytes=${xml.length} qs=${["signature", "timestamp", "nonce", "msg_signature", "encrypt_type"].filter((k) => c.req.query(k)).join(",")} type=${msg?.msgType ?? "none"} enc=${msg?.encrypted ?? false} content_len=${msg?.content.length ?? 0}`);
+        if (msg &&
+            (msg.msgType === "text" || msg.msgType === "voice") &&
+            (msg.msgType === "voice" ? !!msg.mediaId : !!msg.content) &&
+            rememberMsg(msg.msgId) &&
+            opts.onText) {
+            void Promise.resolve(opts.onText(msg)).catch((err) => {
+                const m = err instanceof Error ? err.message : String(err);
+                log(`onText failed: ${m}`);
+            });
+            if (msg.openid && msg.ghAccount) {
+                return c.body(weixinPassiveTextReply({
+                    toOpenid: msg.openid,
+                    fromGh: msg.ghAccount,
+                    content: "我先看看",
+                }), 200, { "Content-Type": "application/xml; charset=utf-8" });
+            }
+        }
+        return c.text("success", 200);
+    };
+    app.get("/wechat", getHandshake);
+    app.get("/wechat/", getHandshake);
+    app.post("/wechat", postMessage);
+    app.post("/wechat/", postMessage);
+    app.get("/", (c) => {
+        if (c.req.query("echostr") || c.req.query("signature"))
+            return getHandshake(c);
+        return c.text("libero-weixin ok");
+    });
+    app.post("/", postMessage);
+    app.notFound((c) => {
+        log(`404 ${c.req.method} ${c.req.path}`);
+        return c.text("success", 200);
+    });
+    return app;
+}

package/dist/mcp/src/weixin/custom-send.js

@@ -0,0 +1,82 @@
+/** 留余量给 JSON 转义 */
+export const WEIXIN_TEXT_MAX_BYTES = 2000;
+export function splitUtf8Chunks(text, maxBytes = WEIXIN_TEXT_MAX_BYTES) {
+    if (Buffer.byteLength(text, "utf8") <= maxBytes)
+        return [text];
+    const parts = [];
+    let buf = "";
+    for (const ch of text) {
+        const next = buf + ch;
+        if (Buffer.byteLength(next, "utf8") > maxBytes) {
+            if (buf)
+                parts.push(buf);
+            buf = ch;
+        }
+        else {
+            buf = next;
+        }
+    }
+    if (buf)
+        parts.push(buf);
+    return parts;
+}
+export function createWeixinSender(opts) {
+    let cache = null;
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    async function accessToken() {
+        const now = Date.now();
+        if (cache && cache.expireAt > now + 60_000)
+            return cache.token;
+        const url = `https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential` +
+            `&appid=${encodeURIComponent(opts.appId)}` +
+            `&secret=${encodeURIComponent(opts.appSecret)}`;
+        const res = await fetchImpl(url);
+        const data = (await res.json());
+        if (!data.access_token) {
+            throw new Error(`weixin token: ${data.errmsg ?? res.status}`);
+        }
+        cache = {
+            token: data.access_token,
+            expireAt: now + (data.expires_in ?? 7200) * 1000,
+        };
+        return cache.token;
+    }
+    return {
+        async sendText(openid, text) {
+            const token = await accessToken();
+            const chunks = splitUtf8Chunks(text);
+            for (const clipped of chunks) {
+                if (!clipped)
+                    continue;
+                const res = await fetchImpl(`https://api.weixin.qq.com/cgi-bin/message/custom/send?access_token=${encodeURIComponent(token)}`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        touser: openid,
+                        msgtype: "text",
+                        text: { content: clipped },
+                    }),
+                });
+                const data = (await res.json());
+                if (data.errcode && data.errcode !== 0) {
+                    throw new Error(`weixin custom send: ${data.errcode} ${data.errmsg ?? ""}`);
+                }
+            }
+        },
+        async downloadMedia(mediaId) {
+            const token = await accessToken();
+            const res = await fetchImpl(`https://api.weixin.qq.com/cgi-bin/media/get?access_token=${encodeURIComponent(token)}&media_id=${encodeURIComponent(mediaId)}`);
+            const ctype = res.headers.get("content-type") ?? "";
+            if (ctype.includes("application/json")) {
+                const data = (await res.json());
+                throw new Error(`weixin media: ${data.errmsg ?? res.status}`);
+            }
+            const bytes = Buffer.from(await res.arrayBuffer());
+            if (bytes.length < 32 && bytes.toString("utf8").includes("errcode")) {
+                throw new Error(`weixin media: ${bytes.toString("utf8").slice(0, 200)}`);
+            }
+            const format = ctype.includes("silk") ? "silk" : "amr";
+            return { bytes, format };
+        },
+    };
+}

package/dist/mcp/src/weixin/handle-text.js

@@ -0,0 +1,49 @@
+import { runChatTurn } from "../chat/loop.js";
+export async function handleWeixinText(opts) {
+    let content = opts.msg.content.trim();
+    if (opts.msg.msgType === "voice") {
+        const mediaId = opts.msg.mediaId?.trim();
+        if (!mediaId)
+            return;
+        if (!opts.asr || !opts.sender.downloadMedia) {
+            await opts.sender.sendText(opts.msg.openid, "语音还没接通（缺腾讯云 ASR 配置），先打字发我。");
+            return;
+        }
+        try {
+            const media = await opts.sender.downloadMedia(mediaId);
+            const format = (opts.msg.format || media.format || "amr").toLowerCase();
+            content = (await opts.asr.transcribe({ bytes: media.bytes, format })).trim();
+        }
+        catch (err) {
+            const m = err instanceof Error ? err.message : String(err);
+            await opts.sender.sendText(opts.msg.openid, `语音没转成字（${m}）。再发一条，或改打字。`);
+            throw err;
+        }
+        if (!content) {
+            await opts.sender.sendText(opts.msg.openid, "没听清，再说一遍或改打字。");
+            return;
+        }
+    }
+    if (!content)
+        return;
+    if (!opts.llm) {
+        await opts.sender.sendText(opts.msg.openid, "助理暂时不可用，过一会儿再试。");
+        return;
+    }
+    try {
+        const turn = await runChatTurn({
+            llm: opts.llm,
+            registry: opts.registry,
+            userId: opts.userId,
+            message: content,
+            conversationKey: `weixin:${opts.msg.openid}`,
+            mintLink: opts.mintLink,
+        });
+        await opts.sender.sendText(opts.msg.openid, turn.reply);
+    }
+    catch (err) {
+        const m = err instanceof Error ? err.message : String(err);
+        await opts.sender.sendText(opts.msg.openid, `刚才没办完（${m}）。你再说一遍，或先问「今天日程」核对。`);
+        throw err;
+    }
+}

package/dist/mcp/src/weixin/reminder-loop.js

@@ -0,0 +1,39 @@
+/**
+ * INT-weixin 提醒推送循环：到点提醒经客服消息真推送（48h 互动窗口内）。
+ * 生产背景（2026-08-20）：提醒只落库没人发，用户设了"午睡后叫我"没被叫。
+ * 失败不标记 sent → 留 pending，由既有"过期补发"被动路径兜底（下次交互补提）。
+ */
+/** 超过该时长的旧到期提醒不再主动推（不深夜轰炸隔夜账），交被动补提。 */
+export const REMINDER_PUSH_MAX_AGE_MS = 2 * 60 * 60 * 1000;
+export async function tickReminderPush(deps) {
+    const nowMs = deps.now ? Date.parse(deps.now) : Date.now();
+    const due = await deps.getDue(deps.userId, new Date(nowMs).toISOString());
+    let sent = 0;
+    let failed = 0;
+    for (const r of due) {
+        // recurring intent 归 adapter（cron）管：remind_at 是近似占位，不推（防误爆）
+        if (r.trigger_kind === "recurring")
+            continue;
+        const age = nowMs - Date.parse(r.remind_at);
+        if (!(age >= 0) || age > REMINDER_PUSH_MAX_AGE_MS)
+            continue; // 未到/过期保护
+        if (deps.openids.length === 0) {
+            failed++; // 无活跃窗口（48h 没互动）：留 pending
+            continue;
+        }
+        let delivered = false;
+        for (const openid of deps.openids) {
+            try {
+                await deps.sendText(openid, r.content);
+                await deps.markSent(r.id);
+                delivered = true;
+                break;
+            }
+            catch {
+                // 窗口外/接口失败 → 试下一个 openid
+            }
+        }
+        delivered ? sent++ : failed++;
+    }
+    return { sent, failed };
+}

package/dist/mcp/src/weixin/signature.js

@@ -0,0 +1,13 @@
+/**
+ * WeChat 服务号 URL 验证：token + timestamp + nonce 字典序拼接后 sha1，对照 signature。
+ */
+import { createHash } from "node:crypto";
+export function weixinSignatureOk(opts) {
+    if (!opts.token || !opts.signature || !opts.timestamp || !opts.nonce) {
+        return false;
+    }
+    const hashed = createHash("sha1")
+        .update([opts.token, opts.timestamp, opts.nonce].sort().join(""))
+        .digest("hex");
+    return hashed === opts.signature;
+}

package/dist/mcp/src/weixin/tencent-asr.js

@@ -0,0 +1,101 @@
+/**
+ * 腾讯云一句话识别。无 SDK：TC3 签名 + fetch。
+ * https://cloud.tencent.com/document/product/1093/35646
+ */
+import { createHash, createHmac } from "node:crypto";
+function sha256Hex(data) {
+    return createHash("sha256").update(data, "utf8").digest("hex");
+}
+function hmac(key, msg) {
+    return createHmac("sha256", key).update(msg, "utf8").digest();
+}
+export function tc3Authorization(opts) {
+    const date = new Date(opts.timestamp * 1000).toISOString().slice(0, 10);
+    const canonicalHeaders = `content-type:application/json; charset=utf-8\nhost:${opts.host}\n`;
+    const signedHeaders = "content-type;host";
+    const canonicalRequest = [
+        "POST",
+        "/",
+        "",
+        canonicalHeaders,
+        signedHeaders,
+        sha256Hex(opts.payload),
+    ].join("\n");
+    const credentialScope = `${date}/${opts.service}/tc3_request`;
+    const stringToSign = [
+        "TC3-HMAC-SHA256",
+        String(opts.timestamp),
+        credentialScope,
+        sha256Hex(canonicalRequest),
+    ].join("\n");
+    const secretDate = hmac(`TC3${opts.secretKey}`, date);
+    const secretService = hmac(secretDate, opts.service);
+    const secretSigning = hmac(secretService, "tc3_request");
+    const signature = createHmac("sha256", secretSigning)
+        .update(stringToSign, "utf8")
+        .digest("hex");
+    return (`TC3-HMAC-SHA256 Credential=${opts.secretId}/${credentialScope}, ` +
+        `SignedHeaders=${signedHeaders}, Signature=${signature}`);
+}
+function engineForFormat(format, override) {
+    if (override?.trim())
+        return override.trim();
+    return format.toLowerCase() === "silk" ? "16k_zh" : "8k_zh";
+}
+export async function sentenceRecognize(opts) {
+    const host = "asr.tencentcloudapi.com";
+    const region = opts.region ?? "ap-guangzhou";
+    const timestamp = opts.timestamp ?? Math.floor(Date.now() / 1000);
+    const voiceFormat = (opts.format || "amr").toLowerCase();
+    const payload = JSON.stringify({
+        EngSerViceType: engineForFormat(voiceFormat, opts.engine),
+        SourceType: 1,
+        VoiceFormat: voiceFormat,
+        Data: opts.bytes.toString("base64"),
+        DataLen: opts.bytes.length,
+    });
+    const authorization = tc3Authorization({
+        secretId: opts.secretId,
+        secretKey: opts.secretKey,
+        host,
+        service: "asr",
+        timestamp,
+        payload,
+    });
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const res = await fetchImpl(`https://${host}/`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json; charset=utf-8",
+            Host: host,
+            "X-TC-Action": "SentenceRecognition",
+            "X-TC-Version": "2019-06-14",
+            "X-TC-Timestamp": String(timestamp),
+            "X-TC-Region": region,
+            Authorization: authorization,
+        },
+        body: payload,
+    });
+    const raw = (await res.json());
+    const err = raw.Response?.Error;
+    if (err) {
+        throw new Error(err.Message || err.Code || "tencent asr error");
+    }
+    return (raw.Response?.Result ?? "").trim();
+}
+export function tencentAsrFromEnv(env = process.env) {
+    const secretId = env.TENCENT_SECRET_ID?.trim();
+    const secretKey = env.TENCENT_SECRET_KEY?.trim();
+    if (!secretId || !secretKey)
+        return null;
+    return {
+        transcribe: (input) => sentenceRecognize({
+            secretId,
+            secretKey,
+            bytes: input.bytes,
+            format: input.format,
+            region: env.TENCENT_ASR_REGION,
+            engine: env.TENCENT_ASR_ENGINE,
+        }),
+    };
+}

package/dist/mcp/src/weixin/xml.js

@@ -0,0 +1,37 @@
+function xmlField(xml, tag) {
+    const cdata = new RegExp(`<${tag}>\\s*<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>\\s*</${tag}>`, "i");
+    const plain = new RegExp(`<${tag}>\\s*([^<]*)\\s*</${tag}>`, "i");
+    const m = xml.match(cdata) ?? xml.match(plain);
+    return (m?.[1] ?? "").trim();
+}
+export function parseWeixinXml(xml) {
+    if (!xml || typeof xml !== "string")
+        return null;
+    const msgType = xmlField(xml, "MsgType").toLowerCase();
+    const openid = xmlField(xml, "FromUserName");
+    const encrypted = /<Encrypt>/i.test(xml);
+    if (!openid && !encrypted)
+        return null;
+    return {
+        msgType: msgType || (encrypted ? "encrypt" : ""),
+        openid,
+        ghAccount: xmlField(xml, "ToUserName"),
+        content: xmlField(xml, "Content"),
+        ...(xmlField(xml, "MediaId")
+            ? { mediaId: xmlField(xml, "MediaId") }
+            : {}),
+        ...(xmlField(xml, "Format") ? { format: xmlField(xml, "Format") } : {}),
+        msgId: xmlField(xml, "MsgId") || xmlField(xml, "CreateTime"),
+        encrypted,
+    };
+}
+export function weixinPassiveTextReply(opts) {
+    const now = Math.floor(Date.now() / 1000);
+    return (`<xml>` +
+        `<ToUserName><![CDATA[${opts.toOpenid}]]></ToUserName>` +
+        `<FromUserName><![CDATA[${opts.fromGh}]]></FromUserName>` +
+        `<CreateTime>${now}</CreateTime>` +
+        `<MsgType><![CDATA[text]]></MsgType>` +
+        `<Content><![CDATA[${opts.content}]]></Content>` +
+        `</xml>`);
+}