@holon-run/agentinbox 1.0.5 → 1.2.0

package/dist/src/adapters.js

@@ -197,7 +197,7 @@ class AdapterRegistry {
     async listDeliveryOperations(source, handle) {
         const module = await this.resolveDeliveryModule(source, handle);
         if (!module?.listDeliveryOperations) {
-            return [];
+            return null;
         }
         return module.listDeliveryOperations({ handle, source });
     }

package/dist/src/http.js

@@ -1870,6 +1870,8 @@ function isBadRequestError(message) {
         message.startsWith("deliver send is not supported") ||
         message.startsWith("deliveryHandle requires") ||
         message.startsWith("delivery operations are not supported") ||
+        message.startsWith("unsupported delivery surface") ||
+        message.startsWith("unsupported delivery operation") ||
         message.startsWith("source operations are not supported") ||
         message.startsWith("unknown GitHub delivery operation") ||
         message.startsWith("unknown Feishu delivery operation") ||

package/dist/src/service.js

@@ -1620,6 +1620,12 @@ class AgentInboxService {
         const handle = resolveDeliveryHandle(request);
         const source = resolveDeliverySource(this.store, request.sourceId, handle);
         const operations = await this.adapters.listDeliveryOperations(source, handle);
+        if (operations === null) {
+            throw new Error(`delivery operations are not supported for provider ${handle.provider}`);
+        }
+        if (operations.length === 0) {
+            throw new Error(noDeliveryOperationsMessage(handle));
+        }
         return {
             sourceId: source?.sourceId ?? null,
             handle,
@@ -1629,6 +1635,15 @@ class AgentInboxService {
     async invokeDelivery(request) {
         const handle = resolveDeliveryHandle(request);
         const source = resolveDeliverySource(this.store, request.sourceId, handle);
+        const operations = await this.adapters.listDeliveryOperations(source, handle);
+        if (operations !== null) {
+            if (operations.length === 0) {
+                throw new Error(noDeliveryOperationsMessage(handle));
+            }
+            if (!operations.some((operation) => operation.name === request.operation)) {
+                throw new Error(unsupportedDeliveryOperationMessage(handle, request.operation, operations));
+            }
+        }
         const attempt = {
             deliveryId: (0, util_1.generateCanonicalId)("dlv"),
             provider: handle.provider,
@@ -1648,9 +1663,9 @@ class AgentInboxService {
     }
     async sendCanonicalDeliveryViaModule(source, handle, payload, attempt) {
         const operations = await this.adapters.listDeliveryOperations(source, handle);
-        const canonicalOperation = operations.find((operation) => operation.canonicalTextAlias);
+        const canonicalOperation = operations?.find((operation) => operation.canonicalTextAlias);
         if (!canonicalOperation) {
-            throw new Error(`deliver send is not supported for ${handle.provider}/${handle.surface}; use deliver invoke`);
+            throw new Error(deliverSendUnsupportedMessage(handle, operations));
         }
         const input = payload.text != null ? { ...payload, body: String(payload.text) } : payload;
         return this.adapters.invokeDeliveryOperation(source, handle, canonicalOperation.name, input, attempt);
@@ -3885,6 +3900,43 @@ function listHostStreamKinds(hostType) {
             return ["default"];
     }
 }
+const KNOWN_DELIVERY_SURFACES = {
+    feishu: ["message_reply", "chat_message"],
+    github: ["issue_comment", "pull_request_comment", "review_comment"],
+};
+function unsupportedDeliverySurfaceMessage(handle) {
+    const supported = KNOWN_DELIVERY_SURFACES[handle.provider];
+    const supportedHint = supported?.length
+        ? ` Supported surfaces for ${handle.provider}: ${supported.join(", ")}.`
+        : "";
+    return `unsupported delivery surface for ${handle.provider}: ${handle.surface}.${supportedHint} ${deliveryActionsHelp(handle)}`;
+}
+function noDeliveryOperationsMessage(handle) {
+    if (!isKnownDeliverySurface(handle)) {
+        return unsupportedDeliverySurfaceMessage(handle);
+    }
+    return `delivery operations are not supported for ${handle.provider}/${handle.surface}. ${deliveryActionsHelp(handle)}`;
+}
+function unsupportedDeliveryOperationMessage(handle, operation, operations) {
+    const names = operations.map((item) => item.name).join(", ");
+    return `unsupported delivery operation for ${handle.provider}/${handle.surface}: ${operation}. Available operations: ${names}. ${deliveryActionsHelp(handle)}`;
+}
+function deliverSendUnsupportedMessage(handle, operations) {
+    if (!operations || operations.length === 0) {
+        if (!isKnownDeliverySurface(handle)) {
+            return unsupportedDeliverySurfaceMessage(handle);
+        }
+        return `deliver send is not supported for ${handle.provider}/${handle.surface}. ${deliveryActionsHelp(handle)}`;
+    }
+    const names = operations.map((item) => item.name).join(", ");
+    return `deliver send is not supported for ${handle.provider}/${handle.surface}; use deliver invoke with one of: ${names}. ${deliveryActionsHelp(handle)}`;
+}
+function deliveryActionsHelp(handle) {
+    return `Run \`agentinbox deliver actions --provider ${handle.provider} --surface ${handle.surface} --target ${handle.targetRef}\` to inspect supported operations and input schemas.`;
+}
+function isKnownDeliverySurface(handle) {
+    return KNOWN_DELIVERY_SURFACES[handle.provider]?.includes(handle.surface) === true;
+}
 function getHostConfigFields(hostType) {
     switch (hostType) {
         case "github":

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,24 @@ 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({
@@ -166,8 +172,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 +621,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 +684,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 +742,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 +1107,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 +1134,7 @@ function normalizeFeishuBotEvent(source, config, raw) {
             mentions,
             mentionOpenIds,
             content,
+            attachments,
             threadId,
             parentId,
         },
@@ -945,8 +1338,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 +1349,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 +1377,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) {

package/package.json

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