@rynx-ai/plugin-channel-lark 0.1.9

package/dist/lark-content.d.ts

@@ -0,0 +1,30 @@
+import type { LarkMessageReceiveEvent } from "./lark.js";
+export declare function extractLarkTextPrompt(event: LarkMessageReceiveEvent): string;
+export declare function isLarkNewSessionCommand(prompt: string): boolean;
+export declare function isLarkStopCommand(prompt: string): boolean;
+export interface LarkCommand {
+    /** Lower-cased command name without the leading slash, e.g. `search`. */
+    name: string;
+    /** Trimmed argument string after the command name (may be empty). */
+    args: string;
+}
+/**
+ * Parse a `/command [args...]` message into `{ name, args }`. Returns null for
+ * non-command text. The command name must start with a letter so bare `/` or
+ * `/123` is not treated as a command. Used for the informational slash-command
+ * registry (`/help`, `/models`, `/search`); `/new` and `/stop` keep their
+ * exact-match predicates above for backward compatibility.
+ */
+export declare function parseLarkCommand(prompt: string): LarkCommand | null;
+export declare function chunkLarkReplyText(text: string, maxBytes?: number): string[];
+/**
+ * Wrap a turn that replies to a Lark message card so the agent receives the
+ * full card content as context. Intentionally generic: it makes no assumption
+ * about the card's purpose and names no specific skill. The agent inspects the
+ * card content and decides how to handle the request (and which skill, if any,
+ * matches).
+ */
+export declare function buildLarkCardReplyPrompt({ userPrompt, cardContent, }: {
+    userPrompt: string;
+    cardContent: string;
+}): string;

package/dist/lark-content.js

@@ -0,0 +1,138 @@
+import { Buffer } from "node:buffer";
+const LARK_TEXT_MAX_BYTES = 120 * 1024;
+export function extractLarkTextPrompt(event) {
+    try {
+        const parsed = JSON.parse(event.message.content);
+        let text = "";
+        if (event.message.message_type === "text") {
+            text = typeof parsed.text === "string" ? parsed.text : "";
+        }
+        if (event.message.message_type === "post") {
+            text = extractLarkPostPrompt(parsed, event.message.mentions ?? []);
+        }
+        for (const mention of event.message.mentions ?? []) {
+            text = text.replaceAll(mention.key, `@${mention.name}`);
+        }
+        return text.replace(/^(\s*@\S+\s*)+/, "").trim();
+    }
+    catch {
+        return "";
+    }
+}
+export function isLarkNewSessionCommand(prompt) {
+    return prompt === "/new";
+}
+export function isLarkStopCommand(prompt) {
+    const normalized = prompt.trim();
+    return normalized === "/stop" || normalized === "/cancel";
+}
+/**
+ * Parse a `/command [args...]` message into `{ name, args }`. Returns null for
+ * non-command text. The command name must start with a letter so bare `/` or
+ * `/123` is not treated as a command. Used for the informational slash-command
+ * registry (`/help`, `/models`, `/search`); `/new` and `/stop` keep their
+ * exact-match predicates above for backward compatibility.
+ */
+export function parseLarkCommand(prompt) {
+    const trimmed = prompt.trim();
+    if (!trimmed.startsWith("/")) {
+        return null;
+    }
+    const match = /^\/([a-zA-Z][\w-]*)(?:\s+([\s\S]*))?$/.exec(trimmed);
+    if (!match) {
+        return null;
+    }
+    return { name: match[1].toLowerCase(), args: (match[2] ?? "").trim() };
+}
+export function chunkLarkReplyText(text, maxBytes = LARK_TEXT_MAX_BYTES) {
+    if (!text) {
+        return [];
+    }
+    if (Buffer.byteLength(text, "utf8") <= maxBytes) {
+        return [text];
+    }
+    const chunks = [];
+    let current = "";
+    for (const character of text) {
+        const next = `${current}${character}`;
+        if (current && Buffer.byteLength(next, "utf8") > maxBytes) {
+            chunks.push(current);
+            current = character;
+            continue;
+        }
+        current = next;
+    }
+    if (current) {
+        chunks.push(current);
+    }
+    return chunks;
+}
+/**
+ * Wrap a turn that replies to a Lark message card so the agent receives the
+ * full card content as context. Intentionally generic: it makes no assumption
+ * about the card's purpose and names no specific skill. The agent inspects the
+ * card content and decides how to handle the request (and which skill, if any,
+ * matches).
+ */
+export function buildLarkCardReplyPrompt({ userPrompt, cardContent, }) {
+    const trimmedPrompt = userPrompt.trim();
+    return [
+        "The user replied to a Lark message card. The full card content is included below — use it as context to handle the user's request, and if one of your skills matches this kind of card, use that skill.",
+        trimmedPrompt ? `User reply: ${trimmedPrompt}` : "User reply: (empty)",
+        "Lark card content:",
+        "```json",
+        cardContent,
+        "```",
+    ].join("\n");
+}
+function extractLarkPostPrompt(parsed, mentions) {
+    const locale = resolveLarkPostLocale(parsed);
+    if (!locale) {
+        return "";
+    }
+    const lines = [];
+    if (typeof locale.title === "string" && locale.title.trim()) {
+        lines.push(locale.title.trim());
+    }
+    for (const block of locale.content ?? []) {
+        const line = block
+            .map((item) => renderLarkPostItem(item, mentions))
+            .join("")
+            .trim();
+        if (line) {
+            lines.push(line);
+        }
+    }
+    return lines.join("\n");
+}
+function resolveLarkPostLocale(parsed) {
+    if (Array.isArray(parsed.content)) {
+        return parsed;
+    }
+    for (const value of Object.values(parsed)) {
+        if (value &&
+            typeof value === "object" &&
+            Array.isArray(value.content)) {
+            return value;
+        }
+    }
+    return null;
+}
+function renderLarkPostItem(item, mentions) {
+    if (item.tag === "at") {
+        return `@${item.user_name ?? resolveMentionName(item, mentions)}`;
+    }
+    if (typeof item.text === "string") {
+        return item.text;
+    }
+    if (item.tag === "a" && typeof item.href === "string") {
+        return item.href;
+    }
+    return "";
+}
+function resolveMentionName(item, mentions) {
+    if (item.user_name) {
+        return item.user_name;
+    }
+    return mentions.at(0)?.name ?? "用户";
+}

package/dist/lark-conversation-directory.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Lark adapter over the channel-agnostic @rynx-ai/core conversation directory.
+ * Keeps the Lark-facing record shape + API (so the resume card, mirror index,
+ * and ingestor are unchanged) while delegating storage + indexing to core's
+ * generic FileConversationDirectory, parameterized over Lark's routing payload
+ * (chat/thread ids). The plugin runtime supplies one explicit file per instance.
+ */
+import { deriveConversationShortId as coreDeriveConversationShortId } from "@rynx-ai/core";
+/** Conversation kind, derived from the inbound message. */
+export type LarkConversationKind = "p2p" | "group" | "thread";
+export interface LarkConversationRecord {
+    /** Stable conversation key (= the bot's sessionKey), e.g. `lark:t:chat:oc_x`. */
+    conversationKey: string;
+    /** Stable short id (6 hex chars derived from the key) for `/resume <id>`. */
+    shortId: string;
+    chatId: string;
+    /** Present only for topic-thread conversations. */
+    threadId?: string;
+    kind: LarkConversationKind;
+    /** Last user message text (truncated), used as the display title. */
+    title: string;
+    /** open_ids that have sent a message in this conversation. */
+    participants: string[];
+    updatedAt: string;
+}
+export interface LarkRecordConversationInput {
+    conversationKey: string;
+    chatId: string;
+    threadId?: string;
+    kind: LarkConversationKind;
+    title: string;
+    participantOpenId?: string;
+}
+export interface LarkConversationDirectory {
+    readonly filePath: string;
+    record(input: LarkRecordConversationInput): Promise<LarkConversationRecord>;
+    /** Conversations the given user has participated in, newest first. */
+    listForUser(openId: string, limit?: number): Promise<LarkConversationRecord[]>;
+    getByShortId(shortId: string): Promise<LarkConversationRecord | null>;
+    get(conversationKey: string): Promise<LarkConversationRecord | null>;
+}
+/** Re-exported from @rynx-ai/core (kept here for existing importers). */
+export declare const deriveConversationShortId: typeof coreDeriveConversationShortId;
+export declare class FileLarkConversationDirectory implements LarkConversationDirectory {
+    private readonly core;
+    constructor({ filePath, now, }: {
+        filePath: string;
+        now?: () => string;
+    });
+    get filePath(): string;
+    record(input: LarkRecordConversationInput): Promise<LarkConversationRecord>;
+    listForUser(openId: string, limit?: number): Promise<LarkConversationRecord[]>;
+    getByShortId(shortId: string): Promise<LarkConversationRecord | null>;
+    get(conversationKey: string): Promise<LarkConversationRecord | null>;
+}
+/** Non-persistent test/direct-construction helper. Production uses the file
+ * implementation with an explicit context.dataDir-scoped path. */
+export declare class MemoryLarkConversationDirectory implements LarkConversationDirectory {
+    readonly filePath = "memory://lark-conversations";
+    private readonly records;
+    record(input: LarkRecordConversationInput): Promise<LarkConversationRecord>;
+    listForUser(openId: string, limit?: number): Promise<LarkConversationRecord[]>;
+    getByShortId(shortId: string): Promise<LarkConversationRecord | null>;
+    get(conversationKey: string): Promise<LarkConversationRecord | null>;
+}

package/dist/lark-conversation-directory.js

@@ -0,0 +1,106 @@
+/**
+ * Lark adapter over the channel-agnostic @rynx-ai/core conversation directory.
+ * Keeps the Lark-facing record shape + API (so the resume card, mirror index,
+ * and ingestor are unchanged) while delegating storage + indexing to core's
+ * generic FileConversationDirectory, parameterized over Lark's routing payload
+ * (chat/thread ids). The plugin runtime supplies one explicit file per instance.
+ */
+import { deriveConversationShortId as coreDeriveConversationShortId, FileConversationDirectory, } from "@rynx-ai/core";
+const TITLE_MAX_CHARS = 40;
+/** Re-exported from @rynx-ai/core (kept here for existing importers). */
+export const deriveConversationShortId = coreDeriveConversationShortId;
+function truncateTitle(title) {
+    const normalized = title.replace(/\s+/g, " ").trim();
+    if (normalized.length <= TITLE_MAX_CHARS) {
+        return normalized;
+    }
+    return `${normalized.slice(0, TITLE_MAX_CHARS - 1)}…`;
+}
+function toLarkRecord(entry) {
+    return {
+        conversationKey: entry.key,
+        shortId: entry.shortId,
+        chatId: entry.meta.chatId,
+        threadId: entry.meta.threadId,
+        kind: entry.meta.kind,
+        title: entry.title || "(无标题)",
+        participants: entry.participants,
+        updatedAt: entry.updatedAt,
+    };
+}
+export class FileLarkConversationDirectory {
+    core;
+    constructor({ filePath, now, }) {
+        this.core = new FileConversationDirectory({ filePath, now });
+    }
+    get filePath() {
+        return this.core.filePath;
+    }
+    async record(input) {
+        const entry = await this.core.record({
+            key: input.conversationKey,
+            title: truncateTitle(input.title),
+            participant: input.participantOpenId,
+            // Keep a previously-recorded threadId when this message didn't carry one.
+            meta: (previous) => ({
+                chatId: input.chatId,
+                threadId: input.threadId ?? previous?.threadId,
+                kind: input.kind,
+            }),
+        });
+        return toLarkRecord(entry);
+    }
+    async listForUser(openId, limit = 5) {
+        const entries = await this.core.listRecent({
+            limit,
+            where: (entry) => entry.participants.includes(openId),
+        });
+        return entries.map(toLarkRecord);
+    }
+    async getByShortId(shortId) {
+        const entry = await this.core.getByShortId(shortId);
+        return entry ? toLarkRecord(entry) : null;
+    }
+    async get(conversationKey) {
+        const entry = await this.core.get(conversationKey);
+        return entry ? toLarkRecord(entry) : null;
+    }
+}
+/** Non-persistent test/direct-construction helper. Production uses the file
+ * implementation with an explicit context.dataDir-scoped path. */
+export class MemoryLarkConversationDirectory {
+    filePath = "memory://lark-conversations";
+    records = new Map();
+    async record(input) {
+        const previous = this.records.get(input.conversationKey);
+        const participants = new Set(previous?.participants ?? []);
+        if (input.participantOpenId)
+            participants.add(input.participantOpenId);
+        const record = {
+            conversationKey: input.conversationKey,
+            shortId: deriveConversationShortId(input.conversationKey),
+            chatId: input.chatId,
+            ...(input.threadId ?? previous?.threadId
+                ? { threadId: input.threadId ?? previous?.threadId }
+                : {}),
+            kind: input.kind,
+            title: truncateTitle(input.title) || "(无标题)",
+            participants: [...participants],
+            updatedAt: new Date().toISOString(),
+        };
+        this.records.set(input.conversationKey, record);
+        return record;
+    }
+    async listForUser(openId, limit = 5) {
+        return [...this.records.values()]
+            .filter((record) => record.participants.includes(openId))
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+            .slice(0, limit);
+    }
+    async getByShortId(shortId) {
+        return [...this.records.values()].find((record) => record.shortId === shortId) ?? null;
+    }
+    async get(conversationKey) {
+        return this.records.get(conversationKey) ?? null;
+    }
+}

package/dist/lark-diff-card.d.ts

@@ -0,0 +1,25 @@
+/** Per-file change stats from `git diff --numstat` (plus untracked files). */
+export interface DiffFileStat {
+    path: string;
+    /** Added lines, or `null` for binary files (numstat reports `-`). */
+    additions: number | null;
+    /** Removed lines, or `null` for binary files. */
+    deletions: number | null;
+    /** True for files surfaced by `git ls-files --others` (not yet staged). */
+    untracked?: boolean;
+}
+export interface DiffCardInput {
+    files: DiffFileStat[];
+    totalAdditions: number;
+    totalDeletions: number;
+    /** Unified diff body to embed (already capped by the caller). */
+    diffBody: string;
+    /** Whether `diffBody` was truncated. */
+    truncated: boolean;
+}
+/**
+ * Render `/diff` as a CardKit card: a summary line, a per-file change list, and
+ * the full unified diff inside a collapsed panel (a ```diff fenced block so
+ * Feishu colors the +/- lines). Far more readable than a raw text dump.
+ */
+export declare function buildDiffCardJson(input: DiffCardInput): string;

package/dist/lark-diff-card.js

@@ -0,0 +1,58 @@
+import { renderDiffMarkdown } from "./lark-card-stream.js";
+/** Cap the per-file list so a huge change set doesn't blow up the card. */
+const FILE_LIST_LIMIT = 40;
+function renderFileLine(file) {
+    if (file.untracked) {
+        return `\`${file.path}\`　<font color='grey'>未跟踪</font>`;
+    }
+    if (file.additions === null || file.deletions === null) {
+        return `\`${file.path}\`　<font color='grey'>二进制</font>`;
+    }
+    return `\`${file.path}\`　<font color='green'>+${file.additions}</font> <font color='red'>-${file.deletions}</font>`;
+}
+/**
+ * Render `/diff` as a CardKit card: a summary line, a per-file change list, and
+ * the full unified diff inside a collapsed panel (a ```diff fenced block so
+ * Feishu colors the +/- lines). Far more readable than a raw text dump.
+ */
+export function buildDiffCardJson(input) {
+    const { files, totalAdditions, totalDeletions, diffBody, truncated } = input;
+    const summary = `共 **${files.length}** 个文件　` +
+        `<font color='green'>+${totalAdditions}</font>　` +
+        `<font color='red'>-${totalDeletions}</font>`;
+    const shown = files.slice(0, FILE_LIST_LIMIT);
+    const fileLines = shown.map(renderFileLine);
+    const hidden = files.length - shown.length;
+    if (hidden > 0) {
+        fileLines.push(`<font color='grey'>… 还有 ${hidden} 个文件</font>`);
+    }
+    const elements = [
+        { tag: "markdown", content: summary },
+        { tag: "hr" },
+        { tag: "markdown", content: fileLines.join("\n") },
+    ];
+    if (diffBody.trim()) {
+        elements.push({
+            tag: "collapsible_panel",
+            expanded: false,
+            header: {
+                title: {
+                    tag: "plain_text",
+                    content: truncated ? "完整 diff（已截断）" : "完整 diff",
+                },
+                vertical_align: "center",
+                icon: { tag: "standard_icon", token: "down-small-ccm_outlined" },
+            },
+            elements: [{ tag: "markdown", content: renderDiffMarkdown(diffBody) }],
+        });
+    }
+    const card = {
+        schema: "2.0",
+        header: {
+            title: { tag: "plain_text", content: "📝 工作区改动" },
+            template: "blue",
+        },
+        body: { elements },
+    };
+    return JSON.stringify(card);
+}

package/dist/lark-fork-transcript.d.ts

@@ -0,0 +1,16 @@
+export interface ForkTranscriptMessage {
+    msgType: string;
+    senderId?: string;
+    senderType?: string;
+    content: string;
+}
+/** Extract a human-readable line from a Feishu message body `content` (a JSON
+ *  string whose shape depends on `msgType`). Non-text types become a short
+ *  placeholder so the transcript stays readable. */
+export declare function extractMessageText(msgType: string, content: string): string;
+/**
+ * Render a conversation history as a transcript: one `名字：内容` line per
+ * message. `nameById` maps a user open_id to a display name; messages from the
+ * bot (sender_type !== "user") are labelled 机器人. Bounded to a sane size.
+ */
+export declare function buildForkTranscript(messages: ForkTranscriptMessage[], nameById: Map<string, string>): string;

package/dist/lark-fork-transcript.js

@@ -0,0 +1,141 @@
+const TRANSCRIPT_MAX_BYTES = 80 * 1024;
+/** Extract a human-readable line from a Feishu message body `content` (a JSON
+ *  string whose shape depends on `msgType`). Non-text types become a short
+ *  placeholder so the transcript stays readable. */
+export function extractMessageText(msgType, content) {
+    try {
+        const parsed = JSON.parse(content);
+        if (msgType === "text") {
+            return typeof parsed.text === "string" ? parsed.text.trim() : "";
+        }
+        if (msgType === "post") {
+            return extractPostText(parsed);
+        }
+        if (msgType === "interactive") {
+            return extractCardText(parsed) || "[卡片]";
+        }
+    }
+    catch {
+        // fall through to placeholder
+    }
+    switch (msgType) {
+        case "image":
+            return "[图片]";
+        case "file":
+            return "[文件]";
+        case "audio":
+            return "[语音]";
+        case "media":
+            return "[视频]";
+        case "sticker":
+            return "[表情]";
+        case "interactive":
+            return "[卡片]";
+        default:
+            return msgType ? `[${msgType}]` : "";
+    }
+}
+const CARD_TEXT_KEYS = new Set([
+    "text",
+    "content",
+    "title",
+    "lines",
+    "elements",
+    "columns",
+    "plain_text",
+    "i18n",
+    "header",
+    "body",
+]);
+const CARD_TEXT_MAX_CHARS = 400;
+/** Best-effort visible-text extraction from an interactive card body. Returns
+ *  "" when the card carries no inline text (e.g. a bare card_id reference), so
+ *  the caller can fall back to a "[卡片]" placeholder. */
+function extractCardText(parsed) {
+    const fragments = [];
+    collectCardText(parsed, fragments);
+    const seen = new Set();
+    const deduped = [];
+    for (const fragment of fragments) {
+        const normalized = fragment.replace(/\s+/g, " ").trim();
+        if (!normalized || seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        deduped.push(normalized);
+    }
+    const joined = deduped.join(" ");
+    if (!joined) {
+        return "";
+    }
+    return joined.length > CARD_TEXT_MAX_CHARS
+        ? `${joined.slice(0, CARD_TEXT_MAX_CHARS)}…`
+        : joined;
+}
+function collectCardText(value, out) {
+    if (typeof value === "string") {
+        out.push(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectCardText(item, out);
+        }
+        return;
+    }
+    if (!value || typeof value !== "object") {
+        return;
+    }
+    for (const [key, nested] of Object.entries(value)) {
+        if (CARD_TEXT_KEYS.has(key)) {
+            collectCardText(nested, out);
+        }
+    }
+}
+function extractPostText(parsed) {
+    // post content is { <locale>: { title, content: item[][] } } or already the
+    // locale object. Collect title + any text/link fragments.
+    const locale = Array.isArray(parsed.content)
+        ? parsed
+        : Object.values(parsed).find((value) => value && typeof value === "object" && Array.isArray(value.content));
+    if (!locale) {
+        return "[富文本]";
+    }
+    const parts = [];
+    if (typeof locale.title === "string" && locale.title.trim()) {
+        parts.push(locale.title.trim());
+    }
+    for (const block of locale.content ?? []) {
+        for (const item of block) {
+            if (typeof item.text === "string") {
+                parts.push(item.text);
+            }
+            else if (item.tag === "a" && typeof item.href === "string") {
+                parts.push(item.href);
+            }
+        }
+    }
+    return parts.join(" ").trim() || "[富文本]";
+}
+/**
+ * Render a conversation history as a transcript: one `名字：内容` line per
+ * message. `nameById` maps a user open_id to a display name; messages from the
+ * bot (sender_type !== "user") are labelled 机器人. Bounded to a sane size.
+ */
+export function buildForkTranscript(messages, nameById) {
+    const lines = [];
+    for (const message of messages) {
+        const text = extractMessageText(message.msgType, message.content);
+        if (!text) {
+            continue;
+        }
+        const isBot = message.senderType !== "user" || !message.senderId;
+        const name = isBot ? "机器人" : nameById.get(message.senderId) || "用户";
+        lines.push(`${name}：${text}`);
+    }
+    let transcript = lines.join("\n");
+    if (Buffer.byteLength(transcript, "utf8") > TRANSCRIPT_MAX_BYTES) {
+        transcript = `${transcript.slice(0, TRANSCRIPT_MAX_BYTES)}\n…（记录过长已截断）`;
+    }
+    return transcript;
+}

package/dist/lark-resume-card.d.ts

@@ -0,0 +1,31 @@
+import type { LarkConversationRecord } from "./lark-conversation-directory.js";
+/** applink that opens a chat (p2p or group) in the Feishu client. Topic
+ *  threads have no deep-link, so those are forwarded instead (see the
+ *  `resume_forward` card action). */
+export declare function buildChatApplink(chatId: string): string;
+/** A single-button card whose button opens `chatId` (used by /fork to give the
+ *  user a one-tap entry into the new group from the current conversation). */
+export declare function buildOpenChatCardJson(chatId: string, chatName: string): string;
+/** Where /resume was invoked — the forward lands here. When `threadId` is
+ *  set (invoked inside a topic thread) the forward targets that thread so it
+ *  appears in-place; otherwise it targets the chat. */
+export interface ResumeTarget {
+    chatId: string;
+    threadId?: string;
+}
+export interface ResumeForwardValue {
+    kind: "resume_forward";
+    shortId: string;
+    /** The topic thread being resumed (forwarded). */
+    sourceThreadId: string;
+    /** Current chat to forward into. */
+    targetChatId: string;
+    /** Current thread to forward into, when /resume was invoked inside one. */
+    targetThreadId?: string;
+}
+/**
+ * Build a CardKit 2.0 card listing recent conversations. Each row shows the
+ * title + short id, with a button that either opens the chat (applink) or
+ * forwards the topic thread into `targetChatId`.
+ */
+export declare function buildResumeCardJson(records: LarkConversationRecord[], target: ResumeTarget): string;