larkin 0.2.70

package/dist/agent/reminder-store.mjs

@@ -0,0 +1,205 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+export const nowIso = (ms) => new Date(ms ?? Date.now()).toISOString();
+export const newId = () => crypto.randomUUID().replace(/-/g, "");
+// Host and Agent transport are separate processes. mkdir is the cross-process mutex;
+// the timeout and stale-lock ages intentionally preserve the established production contract.
+export function withLock(file, fn, timeoutMs = 2_000) {
+    const lockDir = `${file}.lock`;
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        try {
+            fs.mkdirSync(lockDir);
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            try {
+                if (Date.now() - fs.statSync(lockDir).mtimeMs > 10_000) {
+                    fs.rmdirSync(lockDir);
+                    continue;
+                }
+            }
+            catch { /* another process may be reclaiming the same stale directory */ }
+            if (Date.now() > deadline)
+                throw new Error("reminders.json 锁等待超时");
+            const until = Date.now() + 15;
+            while (Date.now() < until) { /* preserve the existing short synchronous critical section */ }
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        try {
+            fs.rmdirSync(lockDir);
+        }
+        catch { /* best effort: preserve existing crash-recovery semantics */ }
+    }
+}
+export function load(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (parsed && Array.isArray(parsed.reminders))
+            return parsed;
+    }
+    catch { /* missing and damaged stores both project to an empty store */ }
+    return { reminders: [] };
+}
+export function save(file, store) {
+    const temporary = `${file}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify(store, null, 2)}\n`);
+    fs.renameSync(temporary, file);
+}
+export function mutate(file, fn, lockTimeoutMs = 2_000) {
+    return withLock(file, () => {
+        const store = load(file);
+        const result = fn(store);
+        save(file, store);
+        return result;
+    }, lockTimeoutMs);
+}
+const WEEKDAYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+function validTz(tz) {
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: tz });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function wallParts(ms, tz) {
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: tz,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        weekday: "short",
+        hour12: false,
+    });
+    const parts = {};
+    for (const part of formatter.formatToParts(ms))
+        parts[part.type] = part.value;
+    return {
+        y: Number(parts.year),
+        mo: Number(parts.month),
+        d: Number(parts.day),
+        hh: parts.hour === "24" ? 0 : Number(parts.hour),
+        mm: Number(parts.minute),
+        ss: Number(parts.second),
+        wd: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].indexOf(parts.weekday),
+    };
+}
+function utcOffsetMs(ms, tz) {
+    const wall = wallParts(ms, tz);
+    return Date.UTC(wall.y, wall.mo - 1, wall.d, wall.hh, wall.mm, wall.ss) - Math.floor(ms / 1_000) * 1_000;
+}
+function wallToUtc(y, mo, d, hh, mm, tz) {
+    const firstGuess = Date.UTC(y, mo - 1, d, hh, mm);
+    const secondGuess = firstGuess - utcOffsetMs(firstGuess, tz);
+    return firstGuess - utcOffsetMs(secondGuess, tz);
+}
+export function parseRepeat(rule, tz) {
+    const normalized = String(rule || "").trim();
+    const normalizedTz = tz || undefined;
+    const zone = validTz(normalizedTz) ? normalizedTz : Intl.DateTimeFormat().resolvedOptions().timeZone;
+    let match = normalized.match(/^every:(\d+)(s|m|h|d)$/);
+    if (match) {
+        const multipliers = { s: 1_000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+        const unit = match[2];
+        const period = Number(match[1]) * multipliers[unit];
+        if (period < 60_000)
+            return { error: "间隔太短：every 至少 1 分钟（如 every:15m）" };
+        return {
+            kind: "interval",
+            description: `every ${match[1]}${unit}`,
+            next: (afterMs, anchorMs) => {
+                const base = Number.isFinite(anchorMs) ? Number(anchorMs) : afterMs;
+                const count = Math.max(1, Math.floor((afterMs - base) / period) + 1);
+                return base + count * period;
+            },
+        };
+    }
+    match = normalized.match(/^daily@(\d{1,2}):(\d{2})$/);
+    if (match) {
+        const [hours, minutes] = [Number(match[1]), Number(match[2])];
+        if (hours > 23 || minutes > 59)
+            return { error: `无效时间 ${match[1]}:${match[2]}` };
+        return {
+            kind: "daily",
+            description: `daily@${String(hours).padStart(2, "0")}:${match[2]} (${zone})`,
+            next: (afterMs) => {
+                const wall = wallParts(afterMs, zone);
+                for (let offset = 0; offset <= 2; offset += 1) {
+                    const candidate = wallToUtc(wall.y, wall.mo, wall.d + offset, hours, minutes, zone);
+                    if (candidate > afterMs)
+                        return candidate;
+                }
+                return null;
+            },
+        };
+    }
+    match = normalized.match(/^weekly:([a-z,]+)@(\d{1,2}):(\d{2})$/);
+    if (match) {
+        const days = match[1].split(",").map((day) => WEEKDAYS.indexOf(day.trim()));
+        const [hours, minutes] = [Number(match[2]), Number(match[3])];
+        if (days.some((day) => day < 0))
+            return { error: `无效星期（可用: ${WEEKDAYS.join(",")}）：${match[1]}` };
+        if (hours > 23 || minutes > 59)
+            return { error: `无效时间 ${match[2]}:${match[3]}` };
+        return {
+            kind: "weekly",
+            description: `weekly:${match[1]}@${String(hours).padStart(2, "0")}:${match[3]} (${zone})`,
+            next: (afterMs) => {
+                const wall = wallParts(afterMs, zone);
+                for (let offset = 0; offset <= 8; offset += 1) {
+                    const candidate = wallToUtc(wall.y, wall.mo, wall.d + offset, hours, minutes, zone);
+                    if (candidate > afterMs && days.includes(wallParts(candidate, zone).wd))
+                        return candidate;
+                }
+                return null;
+            },
+        };
+    }
+    return { error: `无法识别的 repeat 规则：${JSON.stringify(normalized)}。支持 every:<N><s|m|h|d>、daily@HH:MM、weekly:mon,fri@HH:MM` };
+}
+export function toSummary(reminder) {
+    let recurrence = null;
+    if (reminder.repeat) {
+        const parsed = parseRepeat(reminder.repeat, reminder.tz || undefined);
+        recurrence = "error" in parsed
+            ? { kind: "unsupported", description: String(reminder.repeat) }
+            : { kind: parsed.kind, description: parsed.description };
+    }
+    return {
+        reminderId: reminder.reminderId,
+        ownerAgentId: reminder.ownerAgentId,
+        title: reminder.title,
+        fireAt: reminder.fireAt,
+        firedAt: reminder.firedAt ?? null,
+        createdAt: reminder.createdAt,
+        status: reminder.status,
+        msgRef: reminder.msgRef ?? null,
+        msgPermalink: reminder.msgPermalink ?? null,
+        recurrence,
+    };
+}
+export function appendEvent(reminder, eventType, actorType, actorId, nextFireAt, ms) {
+    if (!Array.isArray(reminder.events))
+        reminder.events = [];
+    reminder.events.push({
+        eventId: newId(),
+        reminderId: reminder.reminderId,
+        eventType,
+        actorType,
+        actorId: actorId ?? null,
+        occurredAt: nowIso(ms),
+        nextFireAt: nextFireAt ?? null,
+        metadata: null,
+    });
+}

package/dist/agent/transport-business-context.cjs

@@ -0,0 +1,486 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFeishuError = formatFeishuError;
+exports.createTransportBusinessContext = createTransportBusinessContext;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const agent_state_store_js_1 = require("./agent-state-store.cjs");
+const channel_transport_js_1 = require("../feishu/channel-transport.cjs");
+const larkinConfig = __importStar(require("../platform/config.cjs"));
+const history_projection_js_1 = require("./history-projection.cjs");
+const inbox_projection_js_1 = require("./inbox-projection.cjs");
+const message_policy_js_1 = require("../feishu/message-policy.cjs");
+const outbound_transport_js_1 = require("../feishu/outbound-transport.cjs");
+const reminder_routes_js_1 = require("./reminder-routes.cjs");
+const transport_shell_js_1 = require("./transport-shell.cjs");
+const agent_lark_cli_workspace_js_1 = require("../app/agent-lark-cli-workspace.cjs");
+function formatFeishuError(error, grantLink = null) {
+    if (!error)
+        return null;
+    const parts = [];
+    if (error.message)
+        parts.push(error.message);
+    if (error.missing_scopes?.length)
+        parts.push(`missing_scopes: ${error.missing_scopes.join(", ")}`);
+    const tag = [error.type, error.subtype].filter(Boolean).join("/");
+    const meta = [tag, error.code != null ? `code ${error.code}` : "", error.log_id ? `log_id ${error.log_id}` : ""].filter(Boolean).join(" | ");
+    if (meta)
+        parts.push(`(${meta})`);
+    let output = `飞书接口报错：${parts.join("　")}`;
+    const isScope = error.code !== 230027
+        && (error.subtype === "app_scope_not_applied" || error.code === 99991672 || Boolean(error.missing_scopes?.length));
+    if (error.code === 230027) {
+        output += "\n\n[系统提示] 请检查 bot/app 是否已加入目标 chat/thread（membership），并确认该目标允许当前 app 执行操作（target authorization）；这不是 OAuth scope apply 错误。";
+    }
+    if (isScope) {
+        output += grantLink
+            ? `\n\n授权链接（请 app owner 本人打开确认，约50分钟内有效，确认后即生效）：\n${grantLink}`
+            : "\n\n[系统提示] 当前没有可用的授权链接。请勿自行拼造或猜测任何 scope-apply / 开发者后台链接（那类链接对本应用无效）。只需如实说明缺少上述 scope、需有开发者后台权限者去补充；有可用链接时系统会在此处给出。";
+    }
+    return output;
+}
+function createTransportBusinessContext(env = process.env) {
+    const { config } = larkinConfig.loadConfig(env);
+    const selectedAgent = larkinConfig.selectAgent(config, env);
+    const stateStore = (0, agent_state_store_js_1.createAgentStateStore)(config.larkinHome, selectedAgent.agentId);
+    if (path.resolve(stateStore.paths.root) !== path.resolve(selectedAgent.stateDir)) {
+        throw new Error(`Agent ${selectedAgent.agentId} state store 路径不一致`);
+    }
+    if (!config.serverId)
+        throw new Error("config.serverId 未配置");
+    const paths = stateStore.paths;
+    const attachmentDir = path.join(paths.root, "attachments");
+    const attachmentIndexFile = path.join(paths.root, "attachments.json");
+    const transportLogFile = path.join(paths.root, "transport.log");
+    const dryRun = env.LARKIN_FEISHU_DRYRUN === "1";
+    const agentId = selectedAgent.agentId;
+    const agentName = selectedAgent.name;
+    const agentRuntime = selectedAgent.runtime;
+    const agentModel = selectedAgent.model;
+    const agentEffort = selectedAgent.effort ?? null;
+    const serverId = config.serverId;
+    const unknownCreatedAt = "1970-01-01T00:00:00.000Z";
+    const log = (...parts) => {
+        const line = `[feishu-transport] ${parts.join(" ")}\n`;
+        process.stderr.write(line);
+        try {
+            fs.appendFileSync(transportLogFile, `${new Date().toISOString()} ${line}`);
+        }
+        catch { /* best effort */ }
+    };
+    const logRequest = (method, requestPath, body) => {
+        try {
+            fs.appendFileSync(transportLogFile, `${new Date().toISOString()} REQ ${method} ${requestPath} body=${JSON.stringify(body).slice(0, 300)}\n`);
+        }
+        catch { /* best effort */ }
+    };
+    let signatureCache = null;
+    const senderSignature = (senderId) => {
+        if (!senderId)
+            return null;
+        try {
+            const mtime = fs.statSync(paths.senderProfiles).mtimeMs;
+            if (!signatureCache || signatureCache.mtime !== mtime) {
+                signatureCache = { mtime, data: JSON.parse(fs.readFileSync(paths.senderProfiles, "utf8")) };
+            }
+            return signatureCache.data[senderId]?.description || null;
+        }
+        catch {
+            return null;
+        }
+    };
+    let identityCache;
+    const botIdentity = () => {
+        if (identityCache !== undefined)
+            return identityCache;
+        try {
+            identityCache = JSON.parse(fs.readFileSync(paths.botIdentity, "utf8"));
+        }
+        catch {
+            identityCache = null;
+        }
+        return identityCache;
+    };
+    const appendConversation = (item) => {
+        try {
+            fs.appendFileSync(paths.conversation, `${JSON.stringify({ ...item, text: (0, transport_shell_js_1.safeConversationExcerpt)(item.text) })}\n`);
+        }
+        catch (error) {
+            log(`conversation 写失败: ${error.message}`);
+        }
+    };
+    const loadMap = () => {
+        try {
+            return JSON.parse(fs.readFileSync(paths.map, "utf8"));
+        }
+        catch {
+            return {};
+        }
+    };
+    const resolveChatId = (target) => (0, transport_shell_js_1.resolveMappedChatId)(loadMap(), target);
+    const larkArgs = (...rest) => rest;
+    const larkCli = (args, cwd) => {
+        const managed = (0, agent_lark_cli_workspace_js_1.managedOfficialLarkCli)(selectedAgent, process.env);
+        const options = {
+            encoding: "utf8",
+            env: managed.env,
+            ...(cwd ? { cwd } : {}),
+        };
+        const result = (0, node_child_process_1.spawnSync)(managed.command.command, [...managed.command.argsPrefix, ...larkArgs(...args)], options);
+        return { code: result.status, stdout: result.stdout || "", stderr: result.stderr || "" };
+    };
+    const larkJsonOut = (args) => {
+        let result;
+        try {
+            result = larkCli(args);
+        }
+        catch {
+            return null;
+        }
+        const clean = (value) => value.split("\n").filter((line) => !/^\[page|fetching/.test(line.trim())).join("\n");
+        for (const value of [result.stdout, result.stderr]) {
+            try {
+                const parsed = JSON.parse(clean(value));
+                if (parsed && typeof parsed === "object")
+                    return parsed;
+            }
+            catch { /* try next stream */ }
+        }
+        return null;
+    };
+    const memberData = (chatId) => {
+        const result = larkJsonOut(["im", "+chat-members-list", "--chat-id", chatId, "--json"]);
+        return result?.ok && result.data ? result.data : null;
+    };
+    const userIds = new Map();
+    const chatUserIdSet = (chatId) => {
+        if (userIds.has(chatId))
+            return userIds.get(chatId) ?? null;
+        const result = larkJsonOut(["im", "+chat-members-list", "--chat-id", chatId, "--member-id-type", "user_id", "--json"]);
+        const set = result?.ok && result.data
+            ? new Set((result.data.users || []).flatMap((user) => user.member_id ? [user.member_id] : []))
+            : null;
+        userIds.set(chatId, set);
+        return set;
+    };
+    const memberNames = (chatId) => {
+        const names = {};
+        const data = memberData(chatId);
+        if (!data)
+            return names;
+        for (const user of data.users || [])
+            if (user.member_id)
+                names[user.member_id] = user.name || user.member_id;
+        for (const bot of data.bots || []) {
+            const name = bot.name || bot.member_id || "bot";
+            if (bot.member_id)
+                names[bot.member_id] = name;
+            if (bot.app_id)
+                names[bot.app_id] = name;
+        }
+        return names;
+    };
+    const pairCache = new Map();
+    const memberNameIdPairs = (chatId) => {
+        const cached = pairCache.get(chatId);
+        if (cached)
+            return cached;
+        const byName = {};
+        for (const [id, name] of Object.entries(memberNames(chatId))) {
+            if (!name || name === id)
+                continue;
+            if (!byName[name] || (id.startsWith("ou_") && !byName[name].startsWith("ou_")))
+                byName[name] = id;
+        }
+        const pairs = Object.entries(byName).sort((left, right) => right[0].length - left[0].length);
+        pairCache.set(chatId, pairs);
+        return pairs;
+    };
+    const renderMentions = (content, chatId) => {
+        let mentioned = false;
+        let output = String(content).replace(/@(ou_[A-Za-z0-9]+|on_[A-Za-z0-9]+)/g, (_whole, id) => {
+            mentioned = true;
+            return `<at id="${id}"></at>`;
+        });
+        if (chatId && output.includes("@")) {
+            const pairs = memberNameIdPairs(chatId);
+            let rendered = "";
+            for (let index = 0; index < output.length;) {
+                if (output[index] === "@") {
+                    const rest = output.slice(index + 1);
+                    const hit = pairs.find(([name]) => rest.startsWith(name) && !/^[\p{L}\p{N}_]/u.test(rest.slice(name.length)));
+                    if (hit) {
+                        mentioned = true;
+                        rendered += `<at id="${hit[1]}"></at>`;
+                        index += hit[0].length + 1;
+                        continue;
+                    }
+                }
+                rendered += output[index];
+                index += 1;
+            }
+            output = rendered;
+        }
+        const ids = chatId ? chatUserIdSet(chatId) : null;
+        if (ids?.size) {
+            output = output.replace(/@([A-Za-z0-9]{2,})/g, (whole, token) => {
+                if (!ids.has(token))
+                    return whole;
+                mentioned = true;
+                return `<at id="${token}"></at>`;
+            });
+        }
+        return { content: output, mentioned };
+    };
+    const larkSend = (chatId, content, idempotencyKey) => {
+        const rendered = renderMentions(content, chatId);
+        const args = ["im", "+messages-send", "--chat-id", chatId, rendered.mentioned || (0, transport_shell_js_1.looksLikeMarkdown)(rendered.content) ? "--markdown" : "--text", rendered.content, "--json"];
+        if (idempotencyKey)
+            args.push("--idempotency-key", String(idempotencyKey));
+        if (dryRun)
+            args.push("--dry-run");
+        return larkCli(args);
+    };
+    const larkReply = (messageId, content, idempotencyKey, chatId) => {
+        const rendered = renderMentions(content, chatId);
+        const args = ["im", "+messages-reply", "--message-id", messageId, "--reply-in-thread", rendered.mentioned || (0, transport_shell_js_1.looksLikeMarkdown)(rendered.content) ? "--markdown" : "--text", rendered.content, "--json"];
+        if (idempotencyKey)
+            args.push("--idempotency-key", String(idempotencyKey));
+        if (dryRun)
+            args.push("--dry-run");
+        return larkCli(args);
+    };
+    const larkSendMedia = (chatId, reply, attachment, idempotencyKey) => {
+        const flag = (0, transport_shell_js_1.isImageMime)(attachment.mimeType) ? "--image" : "--file";
+        const replyTo = reply?.in_topic && reply.reply_to ? reply.reply_to : null;
+        const args = replyTo
+            ? ["im", "+messages-reply", "--message-id", replyTo, "--reply-in-thread", flag, attachment.file, "--json"]
+            : ["im", "+messages-send", "--chat-id", chatId, flag, attachment.file, "--json"];
+        if (idempotencyKey)
+            args.push("--idempotency-key", idempotencyKey);
+        if (dryRun)
+            args.push("--dry-run");
+        return larkCli(args, attachmentDir);
+    };
+    const replyContextFor = (target) => {
+        try {
+            return JSON.parse(fs.readFileSync(paths.replyctx, "utf8"))[target] || null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const outbound = (0, outbound_transport_js_1.createOutboundTransport)({
+        attachmentDir, attachmentIndexFile, resolveChatId, replyContextFor,
+        sendText: larkSend, replyText: larkReply, sendMedia: larkSendMedia,
+        appendConversation, botDisplayName: () => botIdentity()?.name, agentName, dryRun, log,
+    });
+    const liveGrantLink = () => {
+        try {
+            const file = env.LARKIN_GRANT_URL_FILE || "/tmp/larkin-grant-url.txt";
+            if (!fs.existsSync(file))
+                return null;
+            const alive = (0, node_child_process_1.spawnSync)("pgrep", ["-f", "grant-scopes.mjs"], { encoding: "utf8" });
+            if (!alive.stdout.trim())
+                return null;
+            const url = fs.readFileSync(file, "utf8").trim();
+            return /^https?:\/\//.test(url) ? url : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const feishuError = (result) => {
+        return formatFeishuError(result?.error, liveGrantLink());
+    };
+    const query = (requestPath, name) => {
+        try {
+            return new URL(`http://x${requestPath.startsWith("/") ? requestPath : `/${requestPath}`}`).searchParams.get(name);
+        }
+        catch {
+            return null;
+        }
+    };
+    const channelContext = (target) => {
+        const value = String(target || "");
+        const base = value.split(":").slice(0, 2).join(":");
+        return {
+            chat_id: resolveChatId(value),
+            channel_type: value.startsWith("dm:") ? "dm" : "channel",
+            channel_name: base.replace(/^#/, "").replace(/^dm:@/, ""),
+        };
+    };
+    const chatMetaCache = {};
+    const chatMeta = (chatId) => {
+        if (!chatId)
+            return null;
+        if (Object.hasOwn(chatMetaCache, chatId))
+            return chatMetaCache[chatId];
+        const result = larkJsonOut(["im", "chats", "get", "--chat-id", chatId, "--json"]);
+        const meta = result?.ok && result.data
+            ? { name: result.data.name || "", chat_mode: result.data.chat_mode || "", chat_type: result.data.chat_type || "" }
+            : null;
+        chatMetaCache[chatId] = meta;
+        return meta;
+    };
+    const topicShort = (target) => {
+        const body = String(target || "").replace(/^#/, "").replace(/^dm:@/, "");
+        const index = body.indexOf(":");
+        return index >= 0 ? body.slice(index + 1, index + 9) : "";
+    };
+    const topicDescriptor = (thread) => {
+        const result = larkJsonOut(["im", "+threads-messages-list", "--thread", thread, "--order", "asc", "--page-size", "1", "--json"]);
+        const first = result?.ok && result.data ? (result.data.messages || result.data.items || [])[0] : undefined;
+        if (!first)
+            return null;
+        let content = typeof first.content === "string" ? first.content : JSON.stringify(first.content || "");
+        try {
+            const parsed = JSON.parse(content);
+            content = typeof parsed.text === "string" ? parsed.text : (typeof parsed.content === "string" ? parsed.content : content);
+        }
+        catch { /* plain text */ }
+        const normalized = content.replace(/\[([^\]]+)\]\((https?:[^)]+)\)/g, "$1").replace(/https?:\/\/\S+/g, "").replace(/\s+/g, " ").trim();
+        return normalized ? normalized.slice(0, 48) : null;
+    };
+    const channelLabel = (target) => {
+        const chatId = resolveChatId(target);
+        const meta = chatMeta(chatId);
+        let label = meta?.name || target.replace(/^#/, "").replace(/^dm:@/, "");
+        const short = topicShort(target);
+        const context = replyContextFor(target);
+        if (short) {
+            const thread = context && (context.thread_id || context.reply_to);
+            const descriptor = thread ? topicDescriptor(thread) : null;
+            if (descriptor)
+                label += ` › ${descriptor}`;
+        }
+        return { label, chatId, meta, ctx: context, topicShort: short };
+    };
+    let appInfoCache;
+    const feishuAppInfo = () => {
+        if (appInfoCache !== undefined)
+            return appInfoCache;
+        appInfoCache = null;
+        const result = larkJsonOut(["api", "GET", `/open-apis/application/v6/applications/${selectedAgent.feishuAppId}`, "--params", '{"lang":"zh_cn"}']);
+        const app = result?.ok && result.data?.app;
+        if (app)
+            appInfoCache = { name: app.app_name || null, description: app.description || null, avatarUrl: app.avatar_url || null };
+        return appInfoCache;
+    };
+    let botNameCache;
+    const botDisplayName = () => {
+        if (botNameCache !== undefined)
+            return botNameCache;
+        botNameCache = null;
+        const identity = botIdentity();
+        if (identity?.name)
+            return (botNameCache = identity.name);
+        const knownChat = Object.values(loadMap()).find((value) => value.startsWith("oc_"));
+        if (knownChat) {
+            const bots = memberData(knownChat)?.bots || [];
+            const mine = bots.find((bot) => bot.app_id === selectedAgent.feishuAppId || (identity?.open_id && bot.member_id === identity.open_id)) || (bots.length === 1 ? bots[0] : null);
+            if (mine?.name)
+                botNameCache = mine.name;
+        }
+        return botNameCache;
+    };
+    const resolveMember = (chatId, raw) => {
+        const handle = String(raw || "").replace(/^@/, "").trim();
+        if (!handle)
+            return null;
+        if (/^ou_[A-Za-z0-9]+$/.test(handle))
+            return { ids: [handle], type: "open_id" };
+        if (/^on_[A-Za-z0-9]+$/.test(handle))
+            return { ids: [handle], type: "union_id" };
+        if (/^(cli_|app_)[A-Za-z0-9]+$/.test(handle))
+            return { ids: [handle], type: "app_id" };
+        const data = memberData(chatId);
+        const user = data?.users?.find((candidate) => candidate.name === handle && candidate.member_id);
+        if (user?.member_id)
+            return { ids: [user.member_id], type: "open_id" };
+        const bot = data?.bots?.find((candidate) => candidate.name === handle);
+        if (bot?.app_id)
+            return { ids: [bot.app_id], type: "app_id" };
+        if (bot?.member_id)
+            return { ids: [bot.member_id], type: "open_id" };
+        return /^[A-Za-z0-9._-]{2,}$/.test(handle) ? { ids: [handle], type: "user_id" } : null;
+    };
+    const projectMessage = (message, channelType, channelName, names) => {
+        const senderId = String(message.sender?.id || "");
+        const isBot = Boolean(message.sender && (message.sender.sender_type === "app" || message.sender.id_type === "app_id"));
+        const self = Boolean(isBot && senderId && senderId === selectedAgent.feishuAppId);
+        return (0, history_projection_js_1.projectFeishuHistoryEnvelope)({
+            message, channelType, channelName, names,
+            selectedAppId: selectedAgent.feishuAppId,
+            botIdentity: (0, history_projection_js_1.parseFeishuText)(message) !== null || self ? botIdentity() : null,
+            senderDescription: self ? null : (0, message_policy_js_1.signatureDescription)(senderSignature(senderId)),
+        });
+    };
+    const channelTransport = (0, channel_transport_js_1.createChannelTransport)({
+        dryRun, selectedAgent, agentId, agentName, agentRuntime, agentModel, agentEffort, serverId, unknownCreatedAt,
+        query, resolveChatId, resolveMemberTo: resolveMember, channelContext, channelLabel, chatMeta,
+        invalidateChatMeta: (chatId) => { delete chatMetaCache[chatId]; },
+        rememberChannel: (target, chatId, meta) => {
+            try {
+                const map = loadMap();
+                map[target] = chatId;
+                stateStore.writeJson("map", map);
+                chatMetaCache[chatId] = {
+                    name: typeof meta.name === "string" ? meta.name : "",
+                    chat_mode: typeof meta.chat_mode === "string" ? meta.chat_mode : "",
+                    chat_type: typeof meta.chat_type === "string" ? meta.chat_type : "",
+                };
+            }
+            catch { /* preserve best-effort map update */ }
+        },
+        mappedChannels: loadMap, larkJsonOut, feishuError, botDisplayName, feishuAppInfo, log,
+    });
+    const reminderRoutes = (0, reminder_routes_js_1.createReminderRoutes)({ stateFile: paths.reminders, agentId, query, log });
+    try {
+        fs.appendFileSync(transportLogFile, `${new Date().toISOString()} INIT profile=${selectedAgent.feishuProfile} larkCfgDir=${selectedAgent.larkConfigDir} inbox=${paths.inbox}\n`);
+    }
+    catch { /* best effort */ }
+    return {
+        stateStore, dryRun, agentId, agentName, serverId, transportLogFile,
+        outbound, channelTransport, reminderRoutes,
+        loadMap, larkJsonOut, feishuError, query, channelContext, chatMeta, topicShort,
+        memberNames, projectMessage,
+        projectInboxEvents: inbox_projection_js_1.projectInboxEvents,
+        sortVisibleHistory: history_projection_js_1.sortVisibleHistory,
+        logRequest, log,
+    };
+}