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

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

@@ -0,0 +1,30 @@
+import type { PluginExecutionDefaults } from "@rynx-ai/plugin-sdk";
+export interface LarkInstanceConfig {
+    id: string;
+    name: string;
+    enabled: boolean;
+    appId: string;
+    appSecret: string;
+    defaultAgent?: string;
+    executionDefaults: PluginExecutionDefaults;
+}
+export declare class LarkConfigStore {
+    private readonly file;
+    constructor(dataDir: string);
+    list(): LarkInstanceConfig[];
+    get(id: string): LarkInstanceConfig | undefined;
+    upsert(input: {
+        id?: string;
+        name: string;
+        enabled: boolean;
+        appId: string;
+        appSecret?: string;
+        defaultAgent?: string | null;
+        runtime?: PluginExecutionDefaults["runtime"];
+        allowedRoots?: string[];
+    }): LarkInstanceConfig;
+    remove(id: string): boolean;
+    setEnabled(id: string, enabled: boolean): LarkInstanceConfig;
+    private read;
+    private write;
+}

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

@@ -0,0 +1,135 @@
+import { randomUUID } from "node:crypto";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+const INSTANCE_ID_PATTERN = /^[a-z][a-z0-9-]{0,62}$/;
+export class LarkConfigStore {
+    file;
+    constructor(dataDir) {
+        mkdirSync(dataDir, { recursive: true, mode: 0o700 });
+        this.file = path.join(dataDir, "lark-config.json");
+    }
+    list() {
+        return structuredClone(this.read().instances);
+    }
+    get(id) {
+        return this.list().find((instance) => instance.id === id);
+    }
+    upsert(input) {
+        const state = this.read();
+        const id = input.id ?? `instance-${randomUUID().slice(0, 8)}`;
+        if (!INSTANCE_ID_PATTERN.test(id))
+            throw new Error("Lark instance id is invalid");
+        const existing = state.instances.find((instance) => instance.id === id);
+        const secret = input.appSecret?.trim() || existing?.appSecret;
+        if (!secret)
+            throw new Error("App Secret is required");
+        const appId = input.appId.trim();
+        const name = input.name.trim();
+        if (!appId)
+            throw new Error("App ID is required");
+        if (!name)
+            throw new Error("instance name is required");
+        const defaultAgent = input.defaultAgent === undefined
+            ? existing?.defaultAgent
+            : input.defaultAgent?.trim() || undefined;
+        const roots = input.allowedRoots ?? existing?.executionDefaults.allowedRoots ?? [];
+        if (!Array.isArray(roots) || roots.some((root) => typeof root !== "string" || !path.isAbsolute(root))) {
+            throw new Error("allowed roots must be absolute paths");
+        }
+        const instance = {
+            id,
+            name,
+            enabled: input.enabled,
+            appId,
+            appSecret: secret,
+            ...(defaultAgent ? { defaultAgent } : {}),
+            executionDefaults: {
+                runtime: input.runtime ?? existing?.executionDefaults.runtime ?? "codex",
+                allowedRoots: [...new Set(roots.map((root) => path.resolve(root)))],
+                ...(defaultAgent ? { defaultAgent } : {}),
+            },
+        };
+        const index = state.instances.findIndex((item) => item.id === id);
+        if (index >= 0)
+            state.instances[index] = instance;
+        else
+            state.instances.push(instance);
+        this.write(state);
+        return structuredClone(instance);
+    }
+    remove(id) {
+        const state = this.read();
+        const filtered = state.instances.filter((instance) => instance.id !== id);
+        if (filtered.length === state.instances.length)
+            return false;
+        this.write({ ...state, instances: filtered });
+        return true;
+    }
+    setEnabled(id, enabled) {
+        const state = this.read();
+        const instance = state.instances.find((item) => item.id === id);
+        if (!instance)
+            throw new Error(`Lark instance "${id}" not found`);
+        instance.enabled = enabled;
+        this.write(state);
+        return structuredClone(instance);
+    }
+    read() {
+        if (!existsSync(this.file))
+            return { schemaVersion: 1, instances: [] };
+        const info = lstatSync(this.file);
+        if (!info.isFile() || info.isSymbolicLink() || info.size > 1024 * 1024) {
+            throw new Error("Lark plugin configuration is invalid");
+        }
+        return parseState(JSON.parse(readFileSync(this.file, "utf8")));
+    }
+    write(state) {
+        const temporary = `${this.file}.tmp-${randomUUID()}`;
+        try {
+            writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\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("Lark plugin configuration must be an object");
+    }
+    const record = value;
+    if (record.schemaVersion !== 1 || !Array.isArray(record.instances)) {
+        throw new Error("Lark plugin configuration schema is invalid");
+    }
+    const ids = new Set();
+    const instances = record.instances.map((value) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            throw new Error("Lark instance configuration is invalid");
+        }
+        const instance = value;
+        if (!INSTANCE_ID_PATTERN.test(instance.id) ||
+            typeof instance.name !== "string" || !instance.name ||
+            typeof instance.enabled !== "boolean" ||
+            typeof instance.appId !== "string" || !instance.appId ||
+            typeof instance.appSecret !== "string" || !instance.appSecret ||
+            (instance.defaultAgent !== undefined &&
+                (typeof instance.defaultAgent !== "string" || !instance.defaultAgent.trim())) ||
+            !instance.executionDefaults ||
+            !["codex", "traex", "claude"].includes(instance.executionDefaults.runtime) ||
+            !Array.isArray(instance.executionDefaults.allowedRoots) ||
+            !instance.executionDefaults.allowedRoots.every((root) => typeof root === "string" && path.isAbsolute(root))) {
+            throw new Error("Lark instance configuration is invalid");
+        }
+        if (ids.has(instance.id))
+            throw new Error(`duplicate Lark instance id "${instance.id}"`);
+        ids.add(instance.id);
+        return structuredClone(instance);
+    });
+    return { schemaVersion: 1, instances };
+}

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