@rynx-ai/daemon 0.1.10 → 0.1.11-beta.2

package/bundled-plugins/plugins/lark/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/bundled-plugins/plugins/lark/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;

package/bundled-plugins/plugins/lark/dist/lark-resume-card.js

@@ -0,0 +1,105 @@
+/** 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 function buildChatApplink(chatId) {
+    return `https://applink.feishu.cn/client/chat/open?openChatId=${encodeURIComponent(chatId)}`;
+}
+/** 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 function buildOpenChatCardJson(chatId, chatName) {
+    const url = buildChatApplink(chatId);
+    const card = {
+        schema: "2.0",
+        header: {
+            title: { tag: "plain_text", content: "已 fork 到新群" },
+            template: "green",
+        },
+        body: {
+            elements: [
+                { tag: "markdown", content: `新群聊：**${chatName}**\n已搬运历史记录并带上当前会话上下文。` },
+                {
+                    tag: "button",
+                    text: { tag: "plain_text", content: "进入新群聊" },
+                    type: "primary",
+                    behaviors: [
+                        { type: "open_url", default_url: url, pc_url: url, ios_url: url, android_url: url },
+                    ],
+                },
+            ],
+        },
+    };
+    return JSON.stringify(card);
+}
+function buildResumeButton(record, target) {
+    if (record.kind === "thread" && record.threadId) {
+        return {
+            tag: "button",
+            text: { tag: "plain_text", content: "转发到此" },
+            type: "primary",
+            size: "small",
+            behaviors: [
+                {
+                    type: "callback",
+                    value: {
+                        kind: "resume_forward",
+                        shortId: record.shortId,
+                        sourceThreadId: record.threadId,
+                        targetChatId: target.chatId,
+                        ...(target.threadId ? { targetThreadId: target.threadId } : {}),
+                    },
+                },
+            ],
+        };
+    }
+    const url = buildChatApplink(record.chatId);
+    return {
+        tag: "button",
+        text: { tag: "plain_text", content: "打开" },
+        type: "primary",
+        size: "small",
+        behaviors: [
+            { type: "open_url", default_url: url, pc_url: url, ios_url: url, android_url: url },
+        ],
+    };
+}
+/**
+ * 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 function buildResumeCardJson(records, target) {
+    const elements = records.map((record, index) => ({
+        tag: "column_set",
+        flex_mode: "none",
+        horizontal_align: "left",
+        columns: [
+            {
+                tag: "column",
+                width: "weighted",
+                weight: 1,
+                vertical_align: "center",
+                elements: [
+                    {
+                        tag: "markdown",
+                        content: `**${index + 1}.** ${record.title}  <font color='grey'>\`${record.shortId}\`</font>`,
+                    },
+                ],
+            },
+            {
+                tag: "column",
+                width: "auto",
+                vertical_align: "center",
+                elements: [buildResumeButton(record, target)],
+            },
+        ],
+    }));
+    const card = {
+        schema: "2.0",
+        header: {
+            title: { tag: "plain_text", content: "最近会话" },
+            template: "blue",
+        },
+        body: { elements },
+    };
+    return JSON.stringify(card);
+}

package/bundled-plugins/plugins/lark/dist/lark-runtime-state-store.d.ts

@@ -0,0 +1,18 @@
+import type { PluginHealth } from "@rynx-ai/plugin-sdk";
+export interface LarkRuntimeInstanceState {
+    state: "starting" | "running" | "failed" | "stopping" | "stopped";
+    connected: boolean;
+    lastError: string | null;
+    lastEventAt: string | null;
+}
+export interface LarkRuntimeState {
+    active: boolean;
+    health: PluginHealth;
+    instances: Record<string, LarkRuntimeInstanceState>;
+}
+export declare class LarkRuntimeStateStore {
+    private readonly file;
+    constructor(dataDir: string);
+    read(): LarkRuntimeState;
+    write(state: LarkRuntimeState): void;
+}

package/bundled-plugins/plugins/lark/dist/lark-runtime-state-store.js

@@ -0,0 +1,95 @@
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+export class LarkRuntimeStateStore {
+    file;
+    constructor(dataDir) {
+        mkdirSync(dataDir, { recursive: true, mode: 0o700 });
+        this.file = path.join(dataDir, "lark-runtime-state.json");
+    }
+    read() {
+        if (!existsSync(this.file)) {
+            return { active: false, health: { state: "running" }, instances: {} };
+        }
+        const info = lstatSync(this.file);
+        if (!info.isFile() || info.isSymbolicLink() || info.size > 1024 * 1024) {
+            return {
+                active: false,
+                health: { state: "degraded", message: "Runtime state is unavailable" },
+                instances: {},
+            };
+        }
+        try {
+            return parseState(JSON.parse(readFileSync(this.file, "utf8")));
+        }
+        catch {
+            return {
+                active: false,
+                health: { state: "degraded", message: "Runtime state is unavailable" },
+                instances: {},
+            };
+        }
+    }
+    write(state) {
+        const temporary = `${this.file}.tmp-${randomUUID()}`;
+        try {
+            writeFileSync(temporary, `${JSON.stringify(state)}\n`, {
+                encoding: "utf8",
+                mode: 0o600,
+                flag: "wx",
+            });
+            chmodSync(temporary, 0o600);
+            renameSync(temporary, this.file);
+        }
+        finally {
+            rmSync(temporary, { force: true });
+        }
+    }
+}
+function parseState(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("invalid runtime state");
+    }
+    const record = value;
+    if (typeof record.active !== "boolean")
+        throw new Error("invalid runtime activity");
+    const health = parseHealth(record.health);
+    if (typeof record.instances !== "object" || record.instances === null ||
+        Array.isArray(record.instances)) {
+        throw new Error("invalid runtime instances");
+    }
+    const instances = {};
+    for (const [id, raw] of Object.entries(record.instances)) {
+        if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+            throw new Error("invalid runtime instance");
+        }
+        const item = raw;
+        if (!["starting", "running", "failed", "stopping", "stopped"].includes(String(item.state)) ||
+            typeof item.connected !== "boolean" ||
+            (item.lastError !== null && typeof item.lastError !== "string") ||
+            (item.lastEventAt !== null && typeof item.lastEventAt !== "string")) {
+            throw new Error("invalid runtime instance");
+        }
+        instances[id] = {
+            state: item.state,
+            connected: item.connected,
+            lastError: item.lastError,
+            lastEventAt: item.lastEventAt,
+        };
+    }
+    return { active: record.active, health, instances };
+}
+function parseHealth(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("invalid runtime health");
+    }
+    const record = value;
+    if ((record.state !== "running" && record.state !== "degraded") ||
+        (record.message !== undefined && typeof record.message !== "string")) {
+        throw new Error("invalid runtime health");
+    }
+    return {
+        state: record.state,
+        ...(typeof record.message === "string" ? { message: record.message } : {}),
+    };
+}

package/bundled-plugins/plugins/lark/dist/lark-sdk/client.d.ts

@@ -0,0 +1,8 @@
+import * as Lark from "@larksuiteoapi/node-sdk";
+export interface LarkSdkClientConfig {
+    appId?: string;
+    appSecret?: string;
+}
+export declare function createLarkSdkClientConfig(env?: NodeJS.ProcessEnv): LarkSdkClientConfig;
+export declare function createLarkSdkClient(config?: LarkSdkClientConfig, logger?: Lark.Logger): Lark.Client;
+export declare function createLarkWsClient(config?: LarkSdkClientConfig, logger?: Lark.Logger): Lark.WSClient;

package/bundled-plugins/plugins/lark/dist/lark-sdk/client.js

@@ -0,0 +1,32 @@
+import * as Lark from "@larksuiteoapi/node-sdk";
+export function createLarkSdkClientConfig(env = process.env) {
+    return {
+        appId: env.LARK_APP_ID?.trim() || undefined,
+        appSecret: env.LARK_APP_SECRET?.trim() || undefined,
+    };
+}
+export function createLarkSdkClient(config = createLarkSdkClientConfig(), logger) {
+    return new Lark.Client({
+        appId: requireLarkConfig(config.appId, "LARK_APP_ID"),
+        appSecret: requireLarkConfig(config.appSecret, "LARK_APP_SECRET"),
+        appType: Lark.AppType.SelfBuild,
+        domain: Lark.Domain.Feishu,
+        loggerLevel: Lark.LoggerLevel.info,
+        ...(logger ? { logger } : {}),
+    });
+}
+export function createLarkWsClient(config = createLarkSdkClientConfig(), logger) {
+    return new Lark.WSClient({
+        appId: requireLarkConfig(config.appId, "LARK_APP_ID"),
+        appSecret: requireLarkConfig(config.appSecret, "LARK_APP_SECRET"),
+        autoReconnect: true,
+        loggerLevel: Lark.LoggerLevel.info,
+        ...(logger ? { logger } : {}),
+    });
+}
+function requireLarkConfig(value, key) {
+    if (!value) {
+        throw new Error(`Missing required configuration ${key}`);
+    }
+    return value;
+}

package/bundled-plugins/plugins/lark/dist/lark-sdk/index.d.ts

@@ -0,0 +1 @@
+export * from "./client.js";

package/bundled-plugins/plugins/lark/dist/lark-sdk/index.js

@@ -0,0 +1 @@
+export * from "./client.js";

package/bundled-plugins/plugins/lark/dist/lark-sender.d.ts

@@ -0,0 +1,114 @@
+import * as Lark from "@larksuiteoapi/node-sdk";
+import type { LarkFetchedMessage, LarkMessageSender, LarkWsClientProvider, LarkWsClientStartOptions } from "./lark.js";
+export declare class LarkSdkMessageSender implements LarkMessageSender {
+    private readonly client;
+    constructor(client: Lark.Client);
+    getMessage({ messageId }: {
+        messageId: string;
+    }): Promise<LarkFetchedMessage | null>;
+    createText({ chatId, text, uuid, }: {
+        chatId: string;
+        text: string;
+        uuid: string;
+    }): Promise<void>;
+    createReaction({ messageId, emojiType, }: {
+        messageId: string;
+        emojiType: string;
+    }): Promise<string | undefined>;
+    deleteReaction({ messageId, reactionId, }: {
+        messageId: string;
+        reactionId: string;
+    }): Promise<void>;
+    replyText({ messageId, text, uuid, replyInThread, }: {
+        messageId: string;
+        text: string;
+        uuid: string;
+        replyInThread: boolean;
+    }): Promise<void>;
+    createCard({ cardJson }: {
+        cardJson: string;
+    }): Promise<{
+        cardId: string;
+    }>;
+    batchUpdateCard({ cardId, sequence, actions, uuid, }: {
+        cardId: string;
+        sequence: number;
+        actions: string;
+        uuid?: string;
+    }): Promise<void>;
+    sendInteractive({ chatId, cardId, uuid, }: {
+        chatId: string;
+        cardId: string;
+        uuid: string;
+    }): Promise<{
+        messageId: string;
+    }>;
+    replyInteractive({ messageId, cardId, uuid, replyInThread, }: {
+        messageId: string;
+        cardId: string;
+        uuid: string;
+        replyInThread: boolean;
+    }): Promise<{
+        messageId: string;
+    }>;
+    forwardThread({ threadId, receiveId, receiveIdType, uuid, }: {
+        /** Source thread being forwarded. */
+        threadId: string;
+        /** Target id: a chat_id, or a thread_id to land inside that thread. */
+        receiveId: string;
+        receiveIdType: "chat_id" | "thread_id";
+        uuid: string;
+    }): Promise<void>;
+    sendText({ chatId, text, uuid, }: {
+        chatId: string;
+        text: string;
+        uuid: string;
+    }): Promise<{
+        messageId: string;
+        threadId?: string;
+    }>;
+    createChat({ name, userIdList, uuid, }: {
+        name: string;
+        userIdList: string[];
+        uuid: string;
+    }): Promise<{
+        chatId: string;
+    }>;
+    getChat({ chatId }: {
+        chatId: string;
+    }): Promise<{
+        name: string;
+    }>;
+    listChatMembers({ chatId, }: {
+        chatId: string;
+    }): Promise<Array<{
+        memberId: string;
+        name: string;
+    }>>;
+    listMessages({ containerIdType, containerId, pageSize, }: {
+        containerIdType: "chat" | "thread";
+        containerId: string;
+        pageSize?: number;
+    }): Promise<Array<{
+        msgType: string;
+        senderId?: string;
+        senderType?: string;
+        content: string;
+    }>>;
+}
+export declare class LarkClientProvider implements LarkWsClientProvider {
+    readonly client: Lark.Client;
+    private readonly wsClient;
+    private botOpenIdPromise?;
+    constructor(options?: Record<string, unknown>, logger?: Lark.Logger);
+    getMessageSender(): LarkMessageSender;
+    /**
+     * This bot's own `open_id`, fetched once from the bot info API and memoized.
+     * Lets the ingestor tell, in a group hosting multiple bots, whether an
+     * incoming `@` actually targets us. Returns `null` if the lookup fails so the
+     * caller can fall back to its legacy behavior rather than going silent.
+     */
+    getBotOpenId(): Promise<string | null>;
+    start({ onMessage, onCardAction }: LarkWsClientStartOptions): Promise<void>;
+    stop(): Promise<void>;
+}