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

package/bundled-plugins/plugins/lark/dist/lark-sender.js

@@ -0,0 +1,323 @@
+import * as Lark from "@larksuiteoapi/node-sdk";
+import { createLarkSdkClient, createLarkWsClient } from "./lark-sdk/index.js";
+export class LarkSdkMessageSender {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getMessage({ messageId }) {
+        const response = await this.client.im.v1.message.get({
+            path: {
+                message_id: messageId,
+            },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to get the Feishu message.");
+        }
+        const item = response.data?.items?.[0];
+        if (!item) {
+            return null;
+        }
+        return {
+            messageId: item.message_id,
+            msgType: item.msg_type,
+            body: {
+                content: item.body?.content,
+            },
+        };
+    }
+    async createText({ chatId, text, uuid, }) {
+        const response = await this.client.im.message.create({
+            params: {
+                receive_id_type: "chat_id",
+            },
+            data: {
+                receive_id: chatId,
+                msg_type: "text",
+                content: JSON.stringify({ text }),
+                uuid,
+            },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to send Feishu chat message.");
+        }
+    }
+    async createReaction({ messageId, emojiType, }) {
+        const response = await this.client.im.messageReaction.create({
+            path: {
+                message_id: messageId,
+            },
+            data: {
+                reaction_type: {
+                    emoji_type: emojiType,
+                },
+            },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to add Feishu message reaction.");
+        }
+        return response.data?.reaction_id;
+    }
+    async deleteReaction({ messageId, reactionId, }) {
+        const response = await this.client.im.messageReaction.delete({
+            path: {
+                message_id: messageId,
+                reaction_id: reactionId,
+            },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to delete Feishu message reaction.");
+        }
+    }
+    async replyText({ messageId, text, uuid, replyInThread, }) {
+        const response = await this.client.im.message.reply({
+            path: {
+                message_id: messageId,
+            },
+            data: {
+                msg_type: "text",
+                content: JSON.stringify({ text }),
+                reply_in_thread: replyInThread,
+                uuid,
+            },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to reply to the Feishu message.");
+        }
+    }
+    async createCard({ cardJson }) {
+        const response = await this.client.cardkit.v1.card.create({
+            data: {
+                type: "card_json",
+                data: cardJson,
+            },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to create the Feishu CardKit card.");
+        }
+        const cardId = response.data?.card_id;
+        if (!cardId) {
+            throw new Error("Feishu CardKit create returned no card_id.");
+        }
+        return { cardId };
+    }
+    async batchUpdateCard({ cardId, sequence, actions, uuid, }) {
+        const response = await this.client.cardkit.v1.card.batchUpdate({
+            data: {
+                sequence,
+                actions,
+                ...(uuid ? { uuid } : {}),
+            },
+            path: {
+                card_id: cardId,
+            },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to batch update the Feishu CardKit card.");
+        }
+    }
+    async sendInteractive({ chatId, cardId, uuid, }) {
+        const response = await this.client.im.message.create({
+            params: {
+                receive_id_type: "chat_id",
+            },
+            data: {
+                receive_id: chatId,
+                msg_type: "interactive",
+                content: JSON.stringify({ type: "card", data: { card_id: cardId } }),
+                uuid,
+            },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to send the Feishu interactive card.");
+        }
+        const messageId = response.data?.message_id;
+        if (!messageId) {
+            throw new Error("Feishu interactive send returned no message_id.");
+        }
+        return { messageId };
+    }
+    async replyInteractive({ messageId, cardId, uuid, replyInThread, }) {
+        const response = await this.client.im.message.reply({
+            path: {
+                message_id: messageId,
+            },
+            data: {
+                msg_type: "interactive",
+                content: JSON.stringify({ type: "card", data: { card_id: cardId } }),
+                reply_in_thread: replyInThread,
+                uuid,
+            },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to reply with the Feishu interactive card.");
+        }
+        const replyMessageId = response.data?.message_id;
+        if (!replyMessageId) {
+            throw new Error("Feishu interactive reply returned no message_id.");
+        }
+        return { messageId: replyMessageId };
+    }
+    async forwardThread({ threadId, receiveId, receiveIdType, uuid, }) {
+        const response = await this.client.im.v1.thread.forward({
+            path: { thread_id: threadId },
+            params: { receive_id_type: receiveIdType, uuid },
+            data: { receive_id: receiveId },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to forward the Feishu thread.");
+        }
+    }
+    async sendText({ chatId, text, uuid, }) {
+        const response = await this.client.im.message.create({
+            params: { receive_id_type: "chat_id" },
+            data: {
+                receive_id: chatId,
+                msg_type: "text",
+                content: JSON.stringify({ text }),
+                uuid,
+            },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to send Feishu chat message.");
+        }
+        const data = response.data;
+        return { messageId: data?.message_id ?? "", threadId: data?.thread_id };
+    }
+    async createChat({ name, userIdList, uuid, }) {
+        const response = await this.client.im.v1.chat.create({
+            params: { user_id_type: "open_id", uuid },
+            data: { name, user_id_list: userIdList, group_message_type: "chat" },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to create the Feishu chat.");
+        }
+        const chatId = response.data?.chat_id;
+        if (!chatId) {
+            throw new Error("Feishu chat create returned no chat_id.");
+        }
+        return { chatId };
+    }
+    async getChat({ chatId }) {
+        const response = await this.client.im.v1.chat.get({ path: { chat_id: chatId } });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to get the Feishu chat.");
+        }
+        const name = response.data?.name ?? "";
+        return { name };
+    }
+    async listChatMembers({ chatId, }) {
+        const response = await this.client.im.v1.chatMembers.get({
+            path: { chat_id: chatId },
+            params: { member_id_type: "open_id", page_size: 100 },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to list Feishu chat members.");
+        }
+        const items = response.data
+            ?.items ?? [];
+        return items
+            .filter((item) => item.member_id)
+            .map((item) => ({ memberId: item.member_id, name: item.name ?? "" }));
+    }
+    async listMessages({ containerIdType, containerId, pageSize = 50, }) {
+        const response = await this.client.im.v1.message.list({
+            params: {
+                container_id_type: containerIdType,
+                container_id: containerId,
+                sort_type: "ByCreateTimeAsc",
+                page_size: pageSize,
+            },
+        });
+        if (response.code && response.code !== 0) {
+            throw new Error(response.msg ?? "Failed to list Feishu messages.");
+        }
+        const items = response.data?.items ?? [];
+        return items.map((item) => ({
+            msgType: item.msg_type ?? "",
+            senderId: item.sender?.id,
+            senderType: item.sender?.sender_type,
+            content: item.body?.content ?? "",
+        }));
+    }
+}
+/** Read a per-instance string option, trimmed; undefined when absent/blank. */
+function larkOption(options, key) {
+    const value = options?.[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+export class LarkClientProvider {
+    client;
+    wsClient;
+    botOpenIdPromise;
+    constructor(options, logger) {
+        // Credentials come from this channel instance's stored config (`options`).
+        const appId = larkOption(options, "LARK_APP_ID");
+        const appSecret = larkOption(options, "LARK_APP_SECRET");
+        this.client = createLarkSdkClient({ appId: appId, appSecret: appSecret }, logger);
+        this.wsClient = createLarkWsClient({ appId: appId, appSecret: appSecret }, logger);
+    }
+    getMessageSender() {
+        return new LarkSdkMessageSender(this.client);
+    }
+    /**
+     * 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.
+     */
+    async getBotOpenId() {
+        if (!this.botOpenIdPromise) {
+            this.botOpenIdPromise = this.client
+                .request({
+                method: "GET",
+                url: "/open-apis/bot/v3/info",
+            })
+                .then((response) => response?.bot?.open_id ?? null)
+                .catch(() => null);
+        }
+        return this.botOpenIdPromise;
+    }
+    async start({ onMessage, onCardAction }) {
+        const handlers = {
+            "im.message.receive_v1": async (data) => {
+                onMessage(data);
+            },
+        };
+        if (onCardAction) {
+            // Feishu CardKit button clicks arrive as `card.action.trigger` events
+            // over the same WS pipe (self-built bot, persistent connection).
+            // The return value (e.g. `{ toast: {...} }`) is forwarded back to
+            // Feishu so the user gets immediate UI feedback — also required for
+            // Feishu to consider the callback well-formed (avoids error 200340).
+            handlers["card.action.trigger"] = async (data) => {
+                const payload = data;
+                const rawValue = payload.action?.value;
+                const value = rawValue && typeof rawValue === "object" && !Array.isArray(rawValue)
+                    ? rawValue
+                    : null;
+                // `option` carries the picked value of a `select_static`; `form_value`
+                // carries all fields of a `form_submit`. Both are surfaced so settings
+                // cards can read selections without a dedicated form round-trip.
+                const option = typeof payload.action?.option === "string" ? payload.action.option : null;
+                const rawForm = payload.action?.form_value;
+                const formValue = rawForm && typeof rawForm === "object" && !Array.isArray(rawForm)
+                    ? rawForm
+                    : null;
+                return await onCardAction({
+                    value,
+                    option,
+                    formValue,
+                    messageId: payload.context?.open_message_id,
+                });
+            };
+        }
+        const eventDispatcher = new Lark.EventDispatcher({}).register(handlers);
+        await this.wsClient.start({
+            eventDispatcher,
+        });
+    }
+    async stop() {
+        this.wsClient.close();
+    }
+}

package/bundled-plugins/plugins/lark/dist/lark-session-store.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Lark binding over the channel-agnostic @rynx-ai/core conversation session store.
+ * The store engine (the conversation → current-session + execution binding) lives
+ * in core; Lark only supplies the per-instance file path + keeps the historical
+ * `Lark*` export names so existing importers are unchanged.
+ */
+import { FileConversationSessionStore, type ConversationSessionStoreOptions } from "@rynx-ai/core";
+export type { ConversationSessionRecord as LarkActiveSessionRecord, ConversationSessionStore as LarkActiveSessionStore, SessionSettingsUpdate as LarkSettingsUpdate, EnsureSessionResult as LarkEnsureSessionResult, RotateSessionResult as LarkRotateSessionResult, SessionExecution as LarkSessionExecution, } from "@rynx-ai/core";
+/** File-backed active-session store for a Lark bot instance: the core engine with
+ *  the Lark per-instance file path injected by default. */
+export declare class FileLarkActiveSessionStore extends FileConversationSessionStore {
+    constructor(options: ConversationSessionStoreOptions);
+}

package/bundled-plugins/plugins/lark/dist/lark-session-store.js

@@ -0,0 +1,14 @@
+/**
+ * Lark binding over the channel-agnostic @rynx-ai/core conversation session store.
+ * The store engine (the conversation → current-session + execution binding) lives
+ * in core; Lark only supplies the per-instance file path + keeps the historical
+ * `Lark*` export names so existing importers are unchanged.
+ */
+import { FileConversationSessionStore, } from "@rynx-ai/core";
+/** File-backed active-session store for a Lark bot instance: the core engine with
+ *  the Lark per-instance file path injected by default. */
+export class FileLarkActiveSessionStore extends FileConversationSessionStore {
+    constructor(options) {
+        super(options);
+    }
+}

package/bundled-plugins/plugins/lark/dist/lark-settings-card.d.ts

@@ -0,0 +1,55 @@
+import type { AgentRuntimeId } from "@rynx-ai/core";
+import type { ReasoningEffort } from "@rynx-ai/core";
+/** Sentinel option value meaning "use the runtime/model default". */
+export declare const SETTINGS_DEFAULT_VALUE = "__default__";
+export interface SettingsCardModelOption {
+    value: string;
+    label: string;
+    isDefault?: boolean;
+    /** Reasoning efforts this model supports; empty/unknown → full effort set. */
+    supportedEfforts?: ReasoningEffort[];
+}
+export interface SettingsCardRuntimeOption {
+    value: AgentRuntimeId;
+    label: string;
+}
+export interface SettingsCardInput {
+    sessionKey: string;
+    /** `/runtime` shows the runtime selector; `/model` hides it. */
+    includeRuntime: boolean;
+    runtimeOptions: SettingsCardRuntimeOption[];
+    /** Models available for the selected runtime (excludes the default sentinel). */
+    models: SettingsCardModelOption[];
+    /** Pre-selected dropdown values (drive `initial_option`). */
+    selectedRuntime: AgentRuntimeId;
+    selectedModel: string;
+    selectedEffort: string;
+}
+export declare const SETTINGS_EFFORT_VALUES: ReasoningEffort[];
+/**
+ * Build the `/runtime` / `/model` settings card object: dropdowns for runtime
+ * (optional), model and reasoning effort, plus confirm / cancel buttons.
+ * Selections round-trip via `card.action.trigger` callbacks (`settings_select`
+ * per change — runtime/model changes re-render this card; `settings_apply` /
+ * `settings_cancel` on the buttons). The effort options reflect the currently
+ * selected model's supported efforts.
+ */
+export declare function buildSettingsCard(input: SettingsCardInput): Record<string, unknown>;
+/** String form of {@link buildSettingsCard} (for the initial card send). */
+export declare function buildSettingsCardJson(input: SettingsCardInput): string;
+/**
+ * Build a static result card shown after the user confirms or cancels the
+ * settings card — replaces the interactive form with a plain conclusion.
+ * Returned as a plain object so it can be embedded in a card-action response.
+ */
+export declare function buildSettingsResultCard(input: {
+    includeRuntime: boolean;
+    template: "green" | "grey";
+    content: string;
+}): Record<string, unknown>;
+/** String form of {@link buildSettingsResultCard}. */
+export declare function buildSettingsResultCardJson(input: {
+    includeRuntime: boolean;
+    template: "green" | "grey";
+    content: string;
+}): string;

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

@@ -0,0 +1,158 @@
+/** Sentinel option value meaning "use the runtime/model default". */
+export const SETTINGS_DEFAULT_VALUE = "__default__";
+export const SETTINGS_EFFORT_VALUES = [
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+    "ultra",
+];
+const EFFORT_LABELS = {
+    minimal: "minimal · 最小",
+    low: "low · 低",
+    medium: "medium · 中",
+    high: "high · 高",
+    xhigh: "xhigh · 极高",
+    none: "none · 关闭",
+    max: "max · 最大",
+    ultra: "ultra · 自动委派",
+};
+/**
+ * Effort options for the currently-selected model: the model's own
+ * `supportedEfforts` when it advertises them, otherwise the full effort set.
+ * Always prefixed with the "follow the model default" sentinel.
+ */
+function effortOptionsFor(models, selectedModel) {
+    const model = models.find((m) => m.value === selectedModel);
+    const supported = Array.from(new Set(model?.supportedEfforts ?? []));
+    const values = supported.length > 0 ? supported : SETTINGS_EFFORT_VALUES;
+    return [
+        { text: plainText("默认（跟随模型）"), value: SETTINGS_DEFAULT_VALUE },
+        ...values.map((value) => ({ text: plainText(EFFORT_LABELS[value] ?? value), value })),
+    ];
+}
+function plainText(content) {
+    return { tag: "plain_text", content };
+}
+function buildSelect(field, sessionKey, includeRuntime, placeholder, options, initialValue) {
+    return {
+        tag: "select_static",
+        name: field,
+        placeholder: plainText(placeholder),
+        initial_option: initialValue,
+        options,
+        behaviors: [
+            {
+                type: "callback",
+                value: { kind: "settings_select", field, sessionKey, includeRuntime },
+            },
+        ],
+    };
+}
+function labelMarkdown(content) {
+    return { tag: "markdown", content };
+}
+/**
+ * Build the `/runtime` / `/model` settings card object: dropdowns for runtime
+ * (optional), model and reasoning effort, plus confirm / cancel buttons.
+ * Selections round-trip via `card.action.trigger` callbacks (`settings_select`
+ * per change — runtime/model changes re-render this card; `settings_apply` /
+ * `settings_cancel` on the buttons). The effort options reflect the currently
+ * selected model's supported efforts.
+ */
+export function buildSettingsCard(input) {
+    const { sessionKey, includeRuntime, models, selectedRuntime, selectedModel, selectedEffort } = input;
+    const elements = [];
+    elements.push(labelMarkdown(includeRuntime
+        ? "选择**运行时 / 模型 / 思考强度**，点击确认后对新会话生效。"
+        : "为当前运行时选择**模型 / 思考强度**，点击确认后对新会话生效。"));
+    if (includeRuntime) {
+        const runtimeOptions = input.runtimeOptions.map((option) => ({
+            text: plainText(option.label),
+            value: option.value,
+        }));
+        elements.push(labelMarkdown("**运行时**"));
+        elements.push(buildSelect("runtime", sessionKey, includeRuntime, "选择运行时", runtimeOptions, selectedRuntime));
+    }
+    const modelOptions = [
+        { text: plainText("跟随运行时默认"), value: SETTINGS_DEFAULT_VALUE },
+        ...models.map((model) => ({
+            text: plainText(`${model.label}${model.isDefault ? " ⭐️" : ""}`),
+            value: model.value,
+        })),
+    ];
+    elements.push(labelMarkdown("**模型**"));
+    elements.push(buildSelect("model", sessionKey, includeRuntime, "选择模型", modelOptions, selectedModel));
+    elements.push(labelMarkdown("**思考强度**"));
+    elements.push(buildSelect("effort", sessionKey, includeRuntime, "选择思考强度", effortOptionsFor(models, selectedModel), selectedEffort));
+    const confirmButton = {
+        tag: "button",
+        text: plainText("确认"),
+        type: "primary",
+        size: "medium",
+        behaviors: [
+            {
+                type: "callback",
+                value: { kind: "settings_apply", sessionKey, includeRuntime },
+            },
+        ],
+    };
+    const cancelButton = {
+        tag: "button",
+        text: plainText("取消"),
+        type: "default",
+        size: "medium",
+        behaviors: [
+            {
+                type: "callback",
+                value: { kind: "settings_cancel", sessionKey, includeRuntime },
+            },
+        ],
+    };
+    // `flex_mode: "none"` + auto-width columns keep the two buttons sized to
+    // their content and sitting adjacent on the left (weighted columns would
+    // stretch each button across half the card, pushing 取消 to the far right).
+    elements.push({
+        tag: "column_set",
+        flex_mode: "none",
+        horizontal_spacing: "8px",
+        columns: [
+            { tag: "column", width: "auto", elements: [confirmButton] },
+            { tag: "column", width: "auto", elements: [cancelButton] },
+        ],
+    });
+    return {
+        schema: "2.0",
+        header: {
+            title: plainText(includeRuntime ? "⚙️ 运行设置" : "⚙️ 模型设置"),
+            template: "blue",
+        },
+        body: { elements },
+    };
+}
+/** String form of {@link buildSettingsCard} (for the initial card send). */
+export function buildSettingsCardJson(input) {
+    return JSON.stringify(buildSettingsCard(input));
+}
+/**
+ * Build a static result card shown after the user confirms or cancels the
+ * settings card — replaces the interactive form with a plain conclusion.
+ * Returned as a plain object so it can be embedded in a card-action response.
+ */
+export function buildSettingsResultCard(input) {
+    return {
+        schema: "2.0",
+        header: {
+            title: plainText(input.includeRuntime ? "⚙️ 运行设置" : "⚙️ 模型设置"),
+            template: input.template,
+        },
+        body: { elements: [{ tag: "markdown", content: input.content }] },
+    };
+}
+/** String form of {@link buildSettingsResultCard}. */
+export function buildSettingsResultCardJson(input) {
+    return JSON.stringify(buildSettingsResultCard(input));
+}

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

@@ -0,0 +1,39 @@
+export interface LarkSetupField {
+    key: "LARK_APP_ID" | "LARK_APP_SECRET";
+    label: string;
+    type: "string" | "secret";
+    required: boolean;
+    help?: string;
+}
+export type LarkAuthorizationMaterial = {
+    kind: "qr";
+    url: string;
+    expireIn?: number;
+} | {
+    kind: "link";
+    url: string;
+    label?: string;
+} | {
+    kind: "status";
+    text: string;
+};
+export interface LarkAuthorizationCredentials {
+    LARK_APP_ID: string;
+    LARK_APP_SECRET: string;
+    botName?: string;
+}
+/**
+ * Minimal tenant (app-identity) scopes the Lark channel needs: receive/send
+ * messages, add reactions, read chat + members, upload/download resources, and
+ * resolve user display info. Pre-filled into the scan-confirm page; editable.
+ */
+export declare const LARK_BOT_SCOPES: string[];
+/** The bot only needs to be told when a message arrives. */
+export declare const LARK_BOT_EVENTS: string[];
+/** Config mode 1: paste an existing app's credentials. */
+export declare const larkConfigSchema: LarkSetupField[];
+/**
+ * Scan-to-create/authorize. Emits a `qr` material and `status` updates, then
+ * resolves with the App ID / App Secret to persist. Aborts via `signal`.
+ */
+export declare function authorizeLark(emit: (material: LarkAuthorizationMaterial) => void, signal: AbortSignal): Promise<LarkAuthorizationCredentials>;