@holon-run/agentinbox 1.1.0 → 1.3.0

package/dist/src/cli.js

@@ -533,6 +533,27 @@ async function main() {
         await printRemote(client, `/agents/${encodeURIComponent(agentId)}/targets/${encodeURIComponent(targetId)}/resume`, {});
         return;
     }
+    if (command === "agent" && normalized[1] === "target" && normalized[2] === "update") {
+        const [agentId, targetId] = normalized.slice(3, 5);
+        if (!agentId || !targetId) {
+            throw new Error("usage: agentinbox agent target update <agentId> <targetId> [--url URL] [--activation-mode MODE] [--notify-lease-ms N] [--min-unacked-items N]");
+        }
+        const body = {};
+        const url = takeFlagValue(normalized, "--url");
+        if (url)
+            body.url = url;
+        const activationMode = takeFlagValue(normalized, "--activation-mode");
+        if (activationMode)
+            body.activationMode = activationMode;
+        const notifyLeaseMs = takeFlagValue(normalized, "--notify-lease-ms");
+        if (notifyLeaseMs)
+            body.notifyLeaseMs = parseOptionalNumber(notifyLeaseMs);
+        const minUnackedItems = takeFlagValue(normalized, "--min-unacked-items");
+        if (minUnackedItems)
+            body.minUnackedItems = parseOptionalNumber(minUnackedItems);
+        await printRemote(client, `/agents/${encodeURIComponent(agentId)}/targets/${encodeURIComponent(targetId)}`, body, "PATCH");
+        return;
+    }
     if (command === "subscription" && normalized[1] === "add") {
         const args = normalized.slice(2);
         const positionals = positionalArgs(args, [
@@ -1154,11 +1175,17 @@ function clientArgsForCommand(args) {
     if (isAgentTargetAddWebhookCommand(args)) {
         return withoutFlagValues(args, "--url");
     }
+    if (isAgentTargetUpdateCommand(args)) {
+        return withoutFlagValues(args, "--url");
+    }
     return args;
 }
 function isAgentTargetAddWebhookCommand(args) {
     return args[0] === "agent" && args[1] === "target" && args[2] === "add" && args[3] === "webhook";
 }
+function isAgentTargetUpdateCommand(args) {
+    return args[0] === "agent" && args[1] === "target" && args[2] === "update";
+}
 function withoutFlagValues(args, flag) {
     const filtered = [];
     for (let index = 0; index < args.length; index += 1) {
@@ -1514,6 +1541,7 @@ Usage:
   agentinbox agent target list <agentId> [--limit N]
   agentinbox agent target remove <agentId> <targetId>
   agentinbox agent target resume <agentId> <targetId>
+  agentinbox agent target update <agentId> <targetId> [--url URL] [--activation-mode MODE] [--notify-lease-ms N] [--min-unacked-items N]
 `,
         timer: `agentinbox timer
 

package/dist/src/http.js

@@ -1061,6 +1061,45 @@ function buildFastifyServer(service) {
             minUnackedItems: body.minUnackedItems ?? null,
         });
     });
+    app.patch("/agents/:agentId/targets/:targetId", {
+        schema: {
+            tags: ["agents"],
+            params: {
+                type: "object",
+                required: ["agentId", "targetId"],
+                properties: {
+                    agentId: { type: "string", minLength: 1 },
+                    targetId: { type: "string", minLength: 1 },
+                },
+            },
+            body: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    url: { type: "string" },
+                    activationMode: { type: "string" },
+                    notifyLeaseMs: { type: "integer", minimum: 1 },
+                    minUnackedItems: { type: "integer", minimum: 1 },
+                },
+            },
+            response: {
+                200: jsonObjectSchema,
+                400: errorResponseSchema,
+            },
+        },
+    }, async (request) => {
+        const params = request.params;
+        const body = request.body;
+        if (!body.url && body.activationMode === undefined && body.notifyLeaseMs === undefined && body.minUnackedItems === undefined) {
+            throw new Error("at least one of --url, --activation-mode, --notify-lease-ms, --min-unacked-items must be provided");
+        }
+        return service.updateWebhookActivationTarget(decodeURIComponent(params.agentId), decodeURIComponent(params.targetId), {
+            url: body.url,
+            activationMode: body.activationMode,
+            notifyLeaseMs: body.notifyLeaseMs ?? null,
+            minUnackedItems: body.minUnackedItems ?? null,
+        });
+    });
     app.delete("/agents/:agentId/targets/:targetId", {
         schema: {
             tags: ["agents"],

package/dist/src/service.js

@@ -774,6 +774,29 @@ class AgentInboxService {
         this.markAgentActive(agentId);
         return target;
     }
+    updateWebhookActivationTarget(agentId, targetId, input) {
+        this.getAgent(agentId);
+        const existing = this.getActivationTarget(targetId);
+        if (existing.agentId !== agentId) {
+            throw new Error(`activation target ${targetId} does not belong to agent ${agentId}`);
+        }
+        if (existing.kind !== "webhook") {
+            throw new Error(`activation target ${targetId} is not a webhook target`);
+        }
+        validateNotifyLeaseMs(input.notifyLeaseMs);
+        validateMinUnackedItems(input.minUnackedItems);
+        const mode = normalizeWebhookActivationMode(input.activationMode ?? existing.mode);
+        const now = (0, util_1.nowIso)();
+        const target = this.store.updateWebhookActivationTarget(targetId, {
+            url: input.url ?? existing.url,
+            mode,
+            notifyLeaseMs: input.notifyLeaseMs ?? existing.notifyLeaseMs,
+            minUnackedItems: input.minUnackedItems !== undefined ? input.minUnackedItems : existing.minUnackedItems ?? null,
+            updatedAt: now,
+            lastSeenAt: now,
+        });
+        return target;
+    }
     listActivationTargets(agentId, limit) {
         if (agentId) {
             this.getAgent(agentId);

package/dist/src/source_schema.js

@@ -134,6 +134,7 @@ const SOURCE_SCHEMAS = {
             { name: "mentions", type: "string[]", description: "Mention names extracted from the message." },
             { name: "mentionOpenIds", type: "string[]", description: "Mention open_ids extracted from the message." },
             { name: "content", type: "string|null", description: "Normalized message content string." },
+            { name: "attachments", type: "object[]", description: "Message attachments and Feishu/Lark document links that can be saved by source operations." },
             { name: "threadId", type: "string|null", description: "Thread or root message ID when present." },
             { name: "parentId", type: "string|null", description: "Parent message ID when present." },
         ],

package/dist/src/sources/feishu.js

@@ -10,18 +10,22 @@ exports.invokeFeishuSourceOperation = invokeFeishuSourceOperation;
 exports.normalizeFeishuBotEvent = normalizeFeishuBotEvent;
 exports.parseFeishuSourceConfig = parseFeishuSourceConfig;
 const uxc_daemon_client_1 = require("@holon-run/uxc-daemon-client");
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const node_os_1 = require("node:os");
+const node_util_1 = require("node:util");
 exports.FEISHU_OPENAPI_ENDPOINT = "https://open.feishu.cn/open-apis";
 exports.FEISHU_IM_SCHEMA_URL = "https://raw.githubusercontent.com/holon-run/uxc/main/skills/feishu-openapi-skill/references/feishu-im.openapi.json";
-const FEISHU_BOT_SCHEMA_FILE = (0, node_path_1.join)((0, node_os_1.tmpdir)(), "agentinbox-feishu-bot.openapi.json");
 exports.DEFAULT_FEISHU_EVENT_TYPES = ["im.message.receive_v1"];
 const DEFAULT_CONTEXT_BOUND_SECONDS = 7 * 24 * 60 * 60;
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 class FeishuUxcClient {
     client;
-    constructor(client = new uxc_daemon_client_1.UxcDaemonClient({ env: process.env })) {
+    commandRunner;
+    constructor(client = new uxc_daemon_client_1.UxcDaemonClient({ env: process.env }), commandRunner = defaultFeishuCommandRunner) {
         this.client = client;
+        this.commandRunner = commandRunner;
     }
     async sendChatMessage(input) {
         await this.client.call({
@@ -125,10 +129,8 @@ class FeishuUxcClient {
             operation: "get:/bot/v3/info",
             payload: {},
             options: {
-                auth: input.auth,
-                schema_url: ensureFeishuBotSchemaFile(),
-                refresh_schema: true,
-                no_cache: true,
+                auth: input.auth ?? undefined,
+                schema_url: exports.FEISHU_IM_SCHEMA_URL,
             },
         });
         const openId = findStringField(response.data, "open_id");
@@ -166,8 +168,97 @@ class FeishuUxcClient {
         });
         return response.data;
     }
+    async fetchDocumentMarkdown(input) {
+        const result = await this.commandRunner("lark-cli", [
+            "docs",
+            "+fetch",
+            "--api-version",
+            "v2",
+            "--doc",
+            input.document,
+            "--doc-format",
+            "markdown",
+            "--format",
+            "json",
+            ...(input.identity ? ["--as", input.identity] : []),
+        ]);
+        const parsed = JSON.parse(result.stdout);
+        const content = findStringField(parsed, "content");
+        if (content == null) {
+            throw new Error("lark-cli docs +fetch response did not include document.content");
+        }
+        return content;
+    }
+    async downloadMessageResource(input) {
+        if (!(0, node_path_1.isAbsolute)(input.outputPath)) {
+            throw new Error("downloadMessageResource requires an absolute outputPath");
+        }
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(input.outputPath), { recursive: true });
+        await this.commandRunner("lark-cli", [
+            "im",
+            "+messages-resources-download",
+            "--message-id",
+            input.messageId,
+            "--file-key",
+            input.fileKey,
+            "--type",
+            input.resourceType,
+            "--output",
+            (0, node_path_1.basename)(input.outputPath),
+            ...(input.identity ? ["--as", input.identity] : []),
+        ], { cwd: (0, node_path_1.dirname)(input.outputPath) });
+    }
+    async downloadDriveFile(input) {
+        if (!(0, node_path_1.isAbsolute)(input.outputPath)) {
+            throw new Error("downloadDriveFile requires an absolute outputPath");
+        }
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(input.outputPath), { recursive: true });
+        await this.commandRunner("lark-cli", [
+            "drive",
+            "+download",
+            "--file-token",
+            input.fileToken,
+            "--output",
+            input.outputPath,
+            ...(input.overwrite ? ["--overwrite"] : []),
+            ...(input.identity ? ["--as", input.identity] : []),
+        ]);
+    }
+    async exportDriveResource(input) {
+        if (!(0, node_path_1.isAbsolute)(input.outputPath)) {
+            throw new Error("exportDriveResource requires an absolute outputPath");
+        }
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(input.outputPath), { recursive: true });
+        await this.commandRunner("lark-cli", [
+            "drive",
+            "+export",
+            "--token",
+            input.token,
+            "--doc-type",
+            input.docType,
+            "--file-extension",
+            input.fileExtension,
+            "--output-dir",
+            (0, node_path_1.dirname)(input.outputPath),
+            "--file-name",
+            (0, node_path_1.basename)(input.outputPath),
+            ...(input.subId ? ["--sub-id", input.subId] : []),
+            ...(input.overwrite ? ["--overwrite"] : []),
+            ...(input.identity ? ["--as", input.identity] : []),
+        ]);
+    }
 }
 exports.FeishuUxcClient = FeishuUxcClient;
+async function defaultFeishuCommandRunner(command, args, options) {
+    const result = await execFileAsync(command, args, {
+        cwd: options?.cwd,
+        maxBuffer: 50 * 1024 * 1024,
+    });
+    return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
+}
 class FeishuDeliveryAdapter {
     client;
     constructor(client) {
@@ -526,6 +617,54 @@ function feishuSourceOperations() {
                 required: ["chat", "warnings"],
             },
         },
+        {
+            name: "list_message_attachments",
+            title: "List Message Attachments",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                required: ["messageId"],
+                properties: {
+                    messageId: { type: "string", minLength: 1 },
+                },
+            },
+            outputSchema: {
+                type: "object",
+                additionalProperties: true,
+                required: ["messageId", "attachments", "warnings"],
+            },
+        },
+        {
+            name: "save_attachment",
+            title: "Save Attachment",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                anyOf: [
+                    { required: ["attachment", "outputPath"] },
+                    { required: ["attachment", "outputDir"] },
+                    { required: ["messageId", "attachmentId", "outputPath"] },
+                    { required: ["messageId", "attachmentId", "outputDir"] },
+                ],
+                properties: {
+                    attachment: { type: "object", additionalProperties: true },
+                    messageId: { type: "string", minLength: 1 },
+                    attachmentId: { type: "string", minLength: 1 },
+                    outputPath: { type: "string", minLength: 1 },
+                    outputDir: { type: "string", minLength: 1 },
+                    fileName: { type: "string", minLength: 1 },
+                    format: { type: "string", minLength: 1 },
+                    subId: { type: "string", minLength: 1 },
+                    identity: { type: "string", enum: ["user", "bot"] },
+                    overwrite: { type: "boolean" },
+                },
+            },
+            outputSchema: {
+                type: "object",
+                additionalProperties: true,
+                required: ["attachmentId", "kind", "path", "format"],
+            },
+        },
     ];
 }
 async function invokeFeishuSourceOperation(source, operation, input, client = new FeishuUxcClient()) {
@@ -541,6 +680,12 @@ async function invokeFeishuSourceOperation(source, operation, input, client = ne
     if (operation === "get_chat") {
         return getFeishuChat(source, input, client);
     }
+    if (operation === "list_message_attachments") {
+        return listFeishuMessageAttachments(source, input, client);
+    }
+    if (operation === "save_attachment") {
+        return saveFeishuAttachment(source, input, client);
+    }
     if (operation !== "get_message_context") {
         throw new Error(`unknown Feishu source operation: ${operation}`);
     }
@@ -593,6 +738,243 @@ async function invokeFeishuSourceOperation(source, operation, input, client = ne
         },
     };
 }
+async function listFeishuMessageAttachments(source, input, client) {
+    const messageId = asString(input.messageId);
+    if (!messageId) {
+        throw new Error("list_message_attachments requires input.messageId");
+    }
+    const config = parseFeishuSourceConfig(source);
+    const raw = await client.getMessage({
+        endpoint: config.endpoint,
+        schemaUrl: config.schemaUrl,
+        auth: config.uxcAuth,
+        messageId,
+    });
+    const message = normalizeFeishuMessage(raw);
+    return {
+        messageId,
+        attachments: message?.attachments ?? [],
+        warnings: message ? [] : [{ code: "message_not_found", message: "Feishu message was not found or could not be normalized" }],
+    };
+}
+async function saveFeishuAttachment(source, input, client) {
+    const attachment = await resolveFeishuAttachment(source, input, client);
+    const outputPath = resolveAttachmentOutputPath(attachment, input);
+    const identity = asString(input.identity);
+    const overwrite = asBoolean(input.overwrite) ?? false;
+    const requestedFormat = asString(input.format)?.toLowerCase();
+    const subId = asString(input.subId);
+    if (attachment.kind === "image" || attachment.resourceType === "image") {
+        rejectConvertedOriginalDownload(requestedFormat, attachment.kind);
+        const fileKey = attachment.fileKey;
+        const messageId = attachment.messageId ?? asString(input.messageId);
+        if (!fileKey || !messageId) {
+            throw new Error("save_attachment requires messageId and fileKey for Feishu image resources");
+        }
+        await client.downloadMessageResource({
+            messageId,
+            fileKey,
+            resourceType: "image",
+            outputPath,
+            identity: identity ?? undefined,
+        });
+        return savedAttachmentResult(attachment, outputPath, requestedFormat ?? "original");
+    }
+    if (attachment.fileKey) {
+        rejectConvertedOriginalDownload(requestedFormat, attachment.kind);
+        const messageId = attachment.messageId ?? asString(input.messageId);
+        if (!messageId) {
+            throw new Error("save_attachment requires messageId for Feishu message file resources");
+        }
+        await client.downloadMessageResource({
+            messageId,
+            fileKey: attachment.fileKey,
+            resourceType: "file",
+            outputPath,
+            identity: identity ?? undefined,
+        });
+        return savedAttachmentResult(attachment, outputPath, requestedFormat ?? "original");
+    }
+    if (attachment.kind === "doc" || attachment.kind === "docx" || attachment.kind === "wiki") {
+        const document = attachment.url ?? attachment.token;
+        if (!document) {
+            throw new Error("save_attachment requires url or token for Feishu doc/docx/wiki attachments");
+        }
+        const markdown = await client.fetchDocumentMarkdown({
+            document,
+            identity: identity ?? undefined,
+        });
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(outputPath), { recursive: true });
+        (0, node_fs_1.writeFileSync)(outputPath, markdown, {
+            encoding: "utf8",
+            flag: overwrite ? "w" : "wx",
+        });
+        return savedAttachmentResult(attachment, outputPath, "markdown");
+    }
+    if (attachment.kind === "sheet") {
+        const extension = requestedFormat ?? "xlsx";
+        if (extension === "csv" && !subId) {
+            throw new Error("save_attachment requires input.subId when exporting a Feishu sheet as csv");
+        }
+        if (!attachment.token) {
+            throw new Error("save_attachment requires token for Feishu sheet attachments");
+        }
+        await client.exportDriveResource({
+            token: attachment.token,
+            docType: "sheet",
+            fileExtension: extension,
+            outputPath,
+            subId: extension === "csv" ? subId ?? undefined : undefined,
+            identity: identity ?? undefined,
+            overwrite,
+        });
+        return savedAttachmentResult(attachment, outputPath, extension);
+    }
+    if (attachment.kind === "bitable" || attachment.kind === "base") {
+        const extension = requestedFormat ?? "base";
+        if (extension === "csv" && !subId) {
+            throw new Error("save_attachment requires input.subId when exporting a Feishu base as csv");
+        }
+        if (!attachment.token) {
+            throw new Error("save_attachment requires token for Feishu base attachments");
+        }
+        await client.exportDriveResource({
+            token: attachment.token,
+            docType: "bitable",
+            fileExtension: extension,
+            outputPath,
+            subId: extension === "csv" ? subId ?? undefined : undefined,
+            identity: identity ?? undefined,
+            overwrite,
+        });
+        return savedAttachmentResult(attachment, outputPath, extension);
+    }
+    if (attachment.token && attachment.kind === "drive_file") {
+        rejectConvertedOriginalDownload(requestedFormat, attachment.kind);
+        await client.downloadDriveFile({
+            fileToken: attachment.token,
+            outputPath,
+            identity: identity ?? undefined,
+            overwrite,
+        });
+        return savedAttachmentResult(attachment, outputPath, requestedFormat ?? "original");
+    }
+    throw new Error(`save_attachment does not support Feishu attachment kind: ${attachment.kind}`);
+}
+function rejectConvertedOriginalDownload(requestedFormat, kind) {
+    if (requestedFormat && requestedFormat !== "original") {
+        throw new Error(`save_attachment cannot convert Feishu ${kind} attachments; omit input.format or use "original"`);
+    }
+}
+async function resolveFeishuAttachment(source, input, client) {
+    const direct = normalizeAttachmentInput(input.attachment);
+    if (direct) {
+        return direct;
+    }
+    const messageId = asString(input.messageId);
+    const attachmentId = asString(input.attachmentId);
+    if (!messageId || !attachmentId) {
+        throw new Error("save_attachment requires either input.attachment or input.messageId and input.attachmentId");
+    }
+    const listed = await listFeishuMessageAttachments(source, { messageId }, client);
+    const attachments = Array.isArray(listed.attachments) ? listed.attachments : [];
+    const found = attachments
+        .map((item) => normalizeAttachmentInput(item))
+        .find((item) => item?.attachmentId === attachmentId);
+    if (!found) {
+        throw new Error(`save_attachment could not find attachmentId ${attachmentId} on message ${messageId}`);
+    }
+    return found;
+}
+function normalizeAttachmentInput(value) {
+    const raw = asRecord(value);
+    const kind = asString(raw.kind);
+    if (!kind) {
+        return null;
+    }
+    const messageId = asString(raw.messageId) ?? asString(raw.message_id);
+    const fileKey = asString(raw.fileKey) ?? asString(raw.file_key);
+    const token = asString(raw.token);
+    const url = asString(raw.url);
+    const attachment = makeFeishuAttachment({
+        kind,
+        messageId,
+        fileKey,
+        resourceType: asString(raw.resourceType) === "image" ? "image" : asString(raw.resourceType) === "file" ? "file" : null,
+        token,
+        url,
+        name: asString(raw.name) ?? asString(raw.fileName) ?? asString(raw.file_name),
+        mimeType: asString(raw.mimeType) ?? asString(raw.mime_type),
+        size: asNumber(raw.size),
+        raw,
+    });
+    return {
+        ...attachment,
+        attachmentId: asString(raw.attachmentId) ?? asString(raw.attachment_id) ?? attachment.attachmentId,
+    };
+}
+function resolveAttachmentOutputPath(attachment, input) {
+    const outputPath = asString(input.outputPath);
+    if (outputPath) {
+        if (!(0, node_path_1.isAbsolute)(outputPath)) {
+            throw new Error("save_attachment requires input.outputPath to be absolute");
+        }
+        return outputPath;
+    }
+    const outputDir = asString(input.outputDir);
+    if (!outputDir) {
+        throw new Error("save_attachment requires input.outputPath or input.outputDir");
+    }
+    if (!(0, node_path_1.isAbsolute)(outputDir)) {
+        throw new Error("save_attachment requires input.outputDir to be absolute");
+    }
+    return (0, node_path_1.join)(outputDir, safeAttachmentFileName(attachment, input));
+}
+function safeAttachmentFileName(attachment, input) {
+    const explicit = asString(input.fileName);
+    const format = asString(input.format)?.toLowerCase();
+    const baseName = explicit
+        ?? attachment.name
+        ?? attachment.token
+        ?? attachment.fileKey
+        ?? attachment.attachmentId;
+    const safe = baseName.replace(/[\/\\:\0]/g, "_").trim() || attachment.attachmentId;
+    if ((0, node_path_1.extname)(safe)) {
+        return safe;
+    }
+    const extension = attachmentExtension(attachment, format);
+    return extension ? `${safe}.${extension}` : safe;
+}
+function attachmentExtension(attachment, format) {
+    if (format && format !== "original") {
+        return format === "markdown" ? "md" : format;
+    }
+    if (attachment.kind === "doc" || attachment.kind === "docx" || attachment.kind === "wiki") {
+        return "md";
+    }
+    if (attachment.kind === "sheet") {
+        return "xlsx";
+    }
+    if (attachment.kind === "bitable" || attachment.kind === "base") {
+        return "base";
+    }
+    return null;
+}
+function savedAttachmentResult(attachment, outputPath, format) {
+    return {
+        attachmentId: attachment.attachmentId,
+        kind: attachment.kind,
+        path: outputPath,
+        format,
+        provider: "feishu",
+        source: {
+            messageId: attachment.messageId,
+            fileKey: attachment.fileKey,
+            token: attachment.token,
+            url: attachment.url,
+        },
+    };
+}
 async function listFeishuChats(source, input, client) {
     const config = parseFeishuSourceConfig(source);
     const raw = await withFeishuChatDiscoveryError("list_chats", () => client.listChats({
@@ -721,6 +1103,12 @@ function normalizeFeishuBotEvent(source, config, raw) {
     const senderId = asString(asRecord(sender.sender_id).open_id) ?? asString(sender.sender_id);
     const senderType = asString(sender.sender_type);
     const content = stringifyFeishuMessageContent(messageType, asString(message.content), message.mentions);
+    const attachments = extractFeishuMessageAttachments({
+        messageId,
+        messageType,
+        rawContent: asString(message.content),
+        rawMessage: message,
+    });
     const threadId = asString(message.thread_id) ?? asString(message.root_id);
     const parentId = asString(message.parent_id);
     return {
@@ -742,6 +1130,7 @@ function normalizeFeishuBotEvent(source, config, raw) {
             mentions,
             mentionOpenIds,
             content,
+            attachments,
             threadId,
             parentId,
         },
@@ -945,8 +1334,10 @@ function normalizeFeishuMessage(raw) {
     }
     const sender = asRecord(message.sender);
     const messageType = asString(message.msg_type) ?? asString(message.message_type) ?? "unknown";
+    const messageId = asString(message.message_id) ?? "";
+    const rawContent = messageContentString(message);
     return {
-        messageId: asString(message.message_id) ?? "",
+        messageId,
         chatId: asString(message.chat_id),
         chatType: asString(message.chat_type),
         messageType,
@@ -954,10 +1345,16 @@ function normalizeFeishuMessage(raw) {
         senderType: asString(sender.sender_type) ?? asString(asRecord(sender.id).user_id) ?? null,
         mentions: extractMentionNames(message.mentions),
         mentionOpenIds: extractMentionOpenIds(message.mentions),
-        content: stringifyFeishuMessageContent(messageType, messageContentString(message), message.mentions),
+        content: stringifyFeishuMessageContent(messageType, rawContent, message.mentions),
         createdAt: fromUnixMillisString(asString(message.create_time)),
         threadId: asString(message.thread_id) ?? asString(message.root_id),
         parentId: asString(message.parent_id),
+        attachments: extractFeishuMessageAttachments({
+            messageId,
+            messageType,
+            rawContent,
+            rawMessage: message,
+        }),
         raw: message,
     };
 }
@@ -976,6 +1373,146 @@ function normalizeFeishuMessages(raw) {
         .map((item) => normalizeFeishuMessage(item))
         .filter((item) => item !== null);
 }
+function extractFeishuMessageAttachments(input) {
+    const parsedContent = parseJsonContent(input.rawContent);
+    const attachments = [];
+    const content = asRecord(parsedContent);
+    if (input.messageType === "image") {
+        const imageKey = asString(content.image_key);
+        if (imageKey) {
+            attachments.push(makeFeishuAttachment({
+                kind: "image",
+                messageId: input.messageId,
+                fileKey: imageKey,
+                resourceType: "image",
+                raw: content,
+            }));
+        }
+    }
+    if (input.messageType === "file" || input.messageType === "audio" || input.messageType === "video" || input.messageType === "media") {
+        const fileKey = asString(content.file_key);
+        if (fileKey) {
+            attachments.push(makeFeishuAttachment({
+                kind: input.messageType,
+                messageId: input.messageId,
+                fileKey,
+                resourceType: "file",
+                name: asString(content.file_name) ?? asString(content.name),
+                mimeType: asString(content.mime_type),
+                size: asNumber(content.size),
+                raw: content,
+            }));
+        }
+    }
+    for (const url of extractUrls(parsedContent)) {
+        const link = feishuAttachmentFromUrl(url, input.messageId);
+        if (link) {
+            attachments.push(link);
+        }
+    }
+    return dedupeFeishuAttachments(attachments);
+}
+function parseJsonContent(rawContent) {
+    if (!rawContent) {
+        return null;
+    }
+    try {
+        return JSON.parse(rawContent);
+    }
+    catch {
+        return rawContent;
+    }
+}
+function makeFeishuAttachment(input) {
+    const stable = [
+        input.messageId ?? "",
+        input.kind,
+        input.fileKey ?? "",
+        input.token ?? "",
+        input.url ?? "",
+    ].join(":");
+    return {
+        attachmentId: `att_${(0, node_crypto_1.createHash)("sha1").update(stable).digest("hex").slice(0, 16)}`,
+        provider: "feishu",
+        kind: input.kind,
+        messageId: input.messageId ?? null,
+        fileKey: input.fileKey ?? null,
+        resourceType: input.resourceType ?? null,
+        token: input.token ?? null,
+        url: input.url ?? null,
+        name: input.name ?? null,
+        mimeType: input.mimeType ?? null,
+        size: input.size ?? null,
+        raw: input.raw ?? {},
+    };
+}
+function extractUrls(value) {
+    const urls = new Set();
+    const visit = (current) => {
+        if (typeof current === "string") {
+            const matches = current.match(/https?:\/\/[^\s"'<>]+/g) ?? [];
+            for (const match of matches) {
+                urls.add(match.replace(/[),.;，。]+$/, ""));
+            }
+            return;
+        }
+        if (Array.isArray(current)) {
+            for (const child of current) {
+                visit(child);
+            }
+            return;
+        }
+        if (current && typeof current === "object") {
+            for (const child of Object.values(current)) {
+                visit(child);
+            }
+        }
+    };
+    visit(value);
+    return Array.from(urls).sort();
+}
+function feishuAttachmentFromUrl(url, messageId) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    const parts = parsed.pathname.split("/").filter(Boolean);
+    const patterns = [
+        { segment: "docx", kind: "docx" },
+        { segment: "doc", kind: "doc" },
+        { segment: "wiki", kind: "wiki" },
+        { segment: "sheets", kind: "sheet" },
+        { segment: "sheet", kind: "sheet" },
+        { segment: "base", kind: "bitable" },
+        { segment: "bitable", kind: "bitable" },
+        { segment: "file", kind: "drive_file" },
+    ];
+    for (const pattern of patterns) {
+        const index = parts.indexOf(pattern.segment);
+        const token = index >= 0 ? parts[index + 1] : null;
+        if (token) {
+            return makeFeishuAttachment({
+                kind: pattern.kind,
+                messageId,
+                token,
+                url,
+                name: token,
+                raw: { url },
+            });
+        }
+    }
+    return null;
+}
+function dedupeFeishuAttachments(attachments) {
+    const byId = new Map();
+    for (const attachment of attachments) {
+        byId.set(attachment.attachmentId, attachment);
+    }
+    return Array.from(byId.values());
+}
 function normalizeFeishuChat(raw) {
     const chat = firstFeishuChat(raw);
     if (!chat) {
@@ -1332,50 +1869,3 @@ function asStringArray(value) {
         .map((item) => asString(item))
         .filter((item) => Boolean(item));
 }
-function ensureFeishuBotSchemaFile() {
-    const body = JSON.stringify(FEISHU_BOT_OPENAPI_SCHEMA);
-    (0, node_fs_1.writeFileSync)(FEISHU_BOT_SCHEMA_FILE, body, "utf8");
-    return FEISHU_BOT_SCHEMA_FILE;
-}
-const FEISHU_BOT_OPENAPI_SCHEMA = {
-    openapi: "3.0.3",
-    info: {
-        title: "Feishu Bot Info",
-        version: "1.0.0",
-    },
-    servers: [
-        {
-            url: exports.FEISHU_OPENAPI_ENDPOINT,
-        },
-    ],
-    // Feishu's docs site does not currently expose this as a stable
-    // machine-readable OpenAPI document to UXC, so keep the tiny operation
-    // schema needed for bot self-identification close to the adapter.
-    paths: {
-        "/bot/v3/info": {
-            get: {
-                operationId: "get:/bot/v3/info",
-                summary: "Get bot information for the current app",
-                responses: {
-                    "200": {
-                        description: "OK",
-                    },
-                },
-                security: [
-                    {
-                        bearerAuth: [],
-                    },
-                ],
-            },
-        },
-    },
-    components: {
-        securitySchemes: {
-            bearerAuth: {
-                type: "http",
-                scheme: "bearer",
-                bearerFormat: "tenant_access_token",
-            },
-        },
-    },
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holon-run/agentinbox",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Local event subscription and delivery service for agents.",
   "license": "Apache-2.0",
   "repository": {