@nextclaw/channel-plugin-feishu 0.2.29-beta.0 → 0.2.29-beta.2

package/dist/src/doc-schema.js

@@ -0,0 +1,148 @@
+import { Type } from "@sinclair/typebox";
+//#region src/doc-schema.ts
+const tableCreationProperties = {
+	doc_token: Type.String({ description: "Document token" }),
+	parent_block_id: Type.Optional(Type.String({ description: "Parent block ID (default: document root)" })),
+	row_size: Type.Integer({
+		description: "Table row count",
+		minimum: 1
+	}),
+	column_size: Type.Integer({
+		description: "Table column count",
+		minimum: 1
+	}),
+	column_width: Type.Optional(Type.Array(Type.Number({ minimum: 1 }), { description: "Column widths in px (length should match column_size)" }))
+};
+const FeishuDocSchema = Type.Union([
+	Type.Object({
+		action: Type.Literal("read"),
+		doc_token: Type.String({ description: "Document token (extract from URL /docx/XXX)" })
+	}),
+	Type.Object({
+		action: Type.Literal("write"),
+		doc_token: Type.String({ description: "Document token" }),
+		content: Type.String({ description: "Markdown content to write (replaces entire document content)" })
+	}),
+	Type.Object({
+		action: Type.Literal("append"),
+		doc_token: Type.String({ description: "Document token" }),
+		content: Type.String({ description: "Markdown content to append to end of document" })
+	}),
+	Type.Object({
+		action: Type.Literal("insert"),
+		doc_token: Type.String({ description: "Document token" }),
+		content: Type.String({ description: "Markdown content to insert" }),
+		after_block_id: Type.String({ description: "Insert content after this block ID. Use list_blocks to find block IDs." })
+	}),
+	Type.Object({
+		action: Type.Literal("create"),
+		title: Type.String({ description: "Document title" }),
+		folder_token: Type.Optional(Type.String({ description: "Target folder token (optional)" })),
+		grant_to_requester: Type.Optional(Type.Boolean({ description: "Grant edit permission to the trusted requesting Feishu user from runtime context (default: true)." }))
+	}),
+	Type.Object({
+		action: Type.Literal("list_blocks"),
+		doc_token: Type.String({ description: "Document token" })
+	}),
+	Type.Object({
+		action: Type.Literal("get_block"),
+		doc_token: Type.String({ description: "Document token" }),
+		block_id: Type.String({ description: "Block ID (from list_blocks)" })
+	}),
+	Type.Object({
+		action: Type.Literal("update_block"),
+		doc_token: Type.String({ description: "Document token" }),
+		block_id: Type.String({ description: "Block ID (from list_blocks)" }),
+		content: Type.String({ description: "New text content" })
+	}),
+	Type.Object({
+		action: Type.Literal("delete_block"),
+		doc_token: Type.String({ description: "Document token" }),
+		block_id: Type.String({ description: "Block ID" })
+	}),
+	Type.Object({
+		action: Type.Literal("create_table"),
+		...tableCreationProperties
+	}),
+	Type.Object({
+		action: Type.Literal("write_table_cells"),
+		doc_token: Type.String({ description: "Document token" }),
+		table_block_id: Type.String({ description: "Table block ID" }),
+		values: Type.Array(Type.Array(Type.String()), {
+			description: "2D matrix values[row][col] to write into table cells",
+			minItems: 1
+		})
+	}),
+	Type.Object({
+		action: Type.Literal("create_table_with_values"),
+		...tableCreationProperties,
+		values: Type.Array(Type.Array(Type.String()), {
+			description: "2D matrix values[row][col] to write into table cells",
+			minItems: 1
+		})
+	}),
+	Type.Object({
+		action: Type.Literal("insert_table_row"),
+		doc_token: Type.String({ description: "Document token" }),
+		block_id: Type.String({ description: "Table block ID" }),
+		row_index: Type.Optional(Type.Number({ description: "Row index to insert at (-1 for end, default: -1)" }))
+	}),
+	Type.Object({
+		action: Type.Literal("insert_table_column"),
+		doc_token: Type.String({ description: "Document token" }),
+		block_id: Type.String({ description: "Table block ID" }),
+		column_index: Type.Optional(Type.Number({ description: "Column index to insert at (-1 for end, default: -1)" }))
+	}),
+	Type.Object({
+		action: Type.Literal("delete_table_rows"),
+		doc_token: Type.String({ description: "Document token" }),
+		block_id: Type.String({ description: "Table block ID" }),
+		row_start: Type.Number({ description: "Start row index (0-based)" }),
+		row_count: Type.Optional(Type.Number({ description: "Number of rows to delete (default: 1)" }))
+	}),
+	Type.Object({
+		action: Type.Literal("delete_table_columns"),
+		doc_token: Type.String({ description: "Document token" }),
+		block_id: Type.String({ description: "Table block ID" }),
+		column_start: Type.Number({ description: "Start column index (0-based)" }),
+		column_count: Type.Optional(Type.Number({ description: "Number of columns to delete (default: 1)" }))
+	}),
+	Type.Object({
+		action: Type.Literal("merge_table_cells"),
+		doc_token: Type.String({ description: "Document token" }),
+		block_id: Type.String({ description: "Table block ID" }),
+		row_start: Type.Number({ description: "Start row index" }),
+		row_end: Type.Number({ description: "End row index (exclusive)" }),
+		column_start: Type.Number({ description: "Start column index" }),
+		column_end: Type.Number({ description: "End column index (exclusive)" })
+	}),
+	Type.Object({
+		action: Type.Literal("upload_image"),
+		doc_token: Type.String({ description: "Document token" }),
+		url: Type.Optional(Type.String({ description: "Remote image URL (http/https)" })),
+		file_path: Type.Optional(Type.String({ description: "Local image file path" })),
+		image: Type.Optional(Type.String({ description: "Image as data URI (data:image/png;base64,...) or plain base64 string. Use instead of url/file_path for DALL-E outputs, canvas screenshots, etc." })),
+		parent_block_id: Type.Optional(Type.String({ description: "Parent block ID (default: document root)" })),
+		filename: Type.Optional(Type.String({ description: "Optional filename override" })),
+		index: Type.Optional(Type.Integer({
+			minimum: 0,
+			description: "Insert position (0-based index among siblings). Omit to append."
+		}))
+	}),
+	Type.Object({
+		action: Type.Literal("upload_file"),
+		doc_token: Type.String({ description: "Document token" }),
+		url: Type.Optional(Type.String({ description: "Remote file URL (http/https)" })),
+		file_path: Type.Optional(Type.String({ description: "Local file path" })),
+		parent_block_id: Type.Optional(Type.String({ description: "Parent block ID (default: document root)" })),
+		filename: Type.Optional(Type.String({ description: "Optional filename override" }))
+	}),
+	Type.Object({
+		action: Type.Literal("color_text"),
+		doc_token: Type.String({ description: "Document token" }),
+		block_id: Type.String({ description: "Text block ID to update" }),
+		content: Type.String({ description: "Text with color markup. Tags: [red], [green], [blue], [orange], [yellow], [purple], [grey], [bold], [bg:yellow]. Example: \"Revenue [green]+15%[/green] YoY\"" })
+	})
+]);
+//#endregion
+export { FeishuDocSchema };

package/dist/src/docx-batch-insert.js

@@ -0,0 +1,104 @@
+import { cleanBlocksForDescendant } from "./docx-table-ops.js";
+//#region src/docx-batch-insert.ts
+const BATCH_SIZE = 1e3;
+/**
+* Collect all descendant blocks for a given first-level block ID.
+* Recursively traverses the block tree to gather all children.
+*/
+function collectDescendants(blockMap, rootId) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	function collect(blockId) {
+		if (visited.has(blockId)) return;
+		visited.add(blockId);
+		const block = blockMap.get(blockId);
+		if (!block) return;
+		result.push(block);
+		const children = block.children;
+		if (Array.isArray(children)) for (const childId of children) collect(childId);
+		else if (typeof children === "string") collect(children);
+	}
+	collect(rootId);
+	return result;
+}
+/**
+* Insert a single batch of blocks using Descendant API.
+*
+* @param parentBlockId - Parent block to insert into (defaults to docToken)
+* @param index - Position within parent's children (-1 = end)
+*/
+async function insertBatch(client, docToken, blocks, firstLevelBlockIds, parentBlockId = docToken, index = -1) {
+	const descendants = cleanBlocksForDescendant(blocks);
+	if (descendants.length === 0) return [];
+	const res = await client.docx.documentBlockDescendant.create({
+		path: {
+			document_id: docToken,
+			block_id: parentBlockId
+		},
+		data: {
+			children_id: firstLevelBlockIds,
+			descendants,
+			index
+		}
+	});
+	if (res.code !== 0) throw new Error(`${res.msg} (code: ${res.code})`);
+	return res.data?.children ?? [];
+}
+/**
+* Insert blocks in batches for large documents (>1000 blocks).
+*
+* Batches are split to ensure BOTH children_id AND descendants
+* arrays stay under the 1000 block API limit.
+*
+* @param client - Feishu API client
+* @param docToken - Document ID
+* @param blocks - All blocks from Convert API
+* @param firstLevelBlockIds - IDs of top-level blocks to insert
+* @param logger - Optional logger for progress updates
+* @param parentBlockId - Parent block to insert into (defaults to docToken = document root)
+* @param startIndex - Starting position within parent (-1 = end). For multi-batch inserts,
+*   each batch advances this by the number of first-level IDs inserted so far.
+* @returns Inserted children blocks and any skipped block IDs
+*/
+async function insertBlocksInBatches(client, docToken, blocks, firstLevelBlockIds, logger, parentBlockId = docToken, startIndex = -1) {
+	const allChildren = [];
+	const batches = [];
+	let currentBatch = {
+		firstLevelIds: [],
+		blocks: []
+	};
+	const usedBlockIds = /* @__PURE__ */ new Set();
+	const blockMap = /* @__PURE__ */ new Map();
+	for (const block of blocks) blockMap.set(block.block_id, block);
+	for (const firstLevelId of firstLevelBlockIds) {
+		const newBlocks = collectDescendants(blockMap, firstLevelId).filter((b) => !usedBlockIds.has(b.block_id));
+		if (newBlocks.length > 1e3) throw new Error(`Block "${firstLevelId}" has ${newBlocks.length} descendants, which exceeds the Feishu API limit of ${BATCH_SIZE} blocks per request. Please split the content into smaller sections.`);
+		if (currentBatch.blocks.length + newBlocks.length > 1e3 && currentBatch.blocks.length > 0) {
+			batches.push(currentBatch);
+			currentBatch = {
+				firstLevelIds: [],
+				blocks: []
+			};
+		}
+		currentBatch.firstLevelIds.push(firstLevelId);
+		for (const block of newBlocks) {
+			currentBatch.blocks.push(block);
+			usedBlockIds.add(block.block_id);
+		}
+	}
+	if (currentBatch.blocks.length > 0) batches.push(currentBatch);
+	let currentIndex = startIndex;
+	for (let i = 0; i < batches.length; i++) {
+		const batch = batches[i];
+		logger?.info?.(`feishu_doc: Inserting batch ${i + 1}/${batches.length} (${batch.blocks.length} blocks)...`);
+		const children = await insertBatch(client, docToken, batch.blocks, batch.firstLevelIds, parentBlockId, currentIndex);
+		allChildren.push(...children);
+		if (currentIndex !== -1) currentIndex += batch.firstLevelIds.length;
+	}
+	return {
+		children: allChildren,
+		skipped: []
+	};
+}
+//#endregion
+export { BATCH_SIZE, insertBlocksInBatches };

package/dist/src/docx-color-text.js

@@ -0,0 +1,80 @@
+//#region src/docx-color-text.ts
+const TEXT_COLOR = {
+	red: 1,
+	orange: 2,
+	yellow: 3,
+	green: 4,
+	blue: 5,
+	purple: 6,
+	grey: 7,
+	gray: 7
+};
+const BACKGROUND_COLOR = {
+	red: 1,
+	orange: 2,
+	yellow: 3,
+	green: 4,
+	blue: 5,
+	purple: 6,
+	grey: 7,
+	gray: 7
+};
+/**
+* Parse color markup into segments.
+*
+* Supports:
+*   [red]text[/red]               → red text
+*   [bg:yellow]text[/bg]          → yellow background
+*   [bold]text[/bold]             → bold
+*   [green bold]text[/green]      → green + bold
+*/
+function parseColorMarkup(content) {
+	const segments = [];
+	const KNOWN = "(?:bg:[a-z]+|bold|red|orange|yellow|green|blue|purple|gr[ae]y)";
+	const tagPattern = new RegExp(`\\[(${KNOWN}(?:\\s+${KNOWN})*)\\](.*?)\\[\\/(?:[^\\]]+)\\]|([^[]+|\\[)`, "gis");
+	let match;
+	while ((match = tagPattern.exec(content)) !== null) if (match[3] !== void 0) {
+		if (match[3]) segments.push({ text: match[3] });
+	} else {
+		const tagStr = match[1].toLowerCase().trim();
+		const text = match[2];
+		const tags = tagStr.split(/\s+/);
+		const segment = { text };
+		for (const tag of tags) if (tag.startsWith("bg:")) {
+			const color = tag.slice(3);
+			if (BACKGROUND_COLOR[color]) segment.bgColor = BACKGROUND_COLOR[color];
+		} else if (tag === "bold") segment.bold = true;
+		else if (TEXT_COLOR[tag]) segment.textColor = TEXT_COLOR[tag];
+		if (text) segments.push(segment);
+	}
+	return segments;
+}
+/**
+* Update a text block with colored segments.
+*/
+async function updateColorText(client, docToken, blockId, content) {
+	const segments = parseColorMarkup(content);
+	const elements = segments.map((seg) => ({ text_run: {
+		content: seg.text,
+		text_element_style: {
+			...seg.textColor && { text_color: seg.textColor },
+			...seg.bgColor && { background_color: seg.bgColor },
+			...seg.bold && { bold: true }
+		}
+	} }));
+	const res = await client.docx.documentBlock.patch({
+		path: {
+			document_id: docToken,
+			block_id: blockId
+		},
+		data: { update_text_elements: { elements } }
+	});
+	if (res.code !== 0) throw new Error(res.msg);
+	return {
+		success: true,
+		segments: segments.length,
+		block: res.data?.block
+	};
+}
+//#endregion
+export { updateColorText };

package/dist/src/docx-table-ops.js

@@ -0,0 +1,197 @@
+//#region src/docx-table-ops.ts
+const MIN_COLUMN_WIDTH = 50;
+const MAX_COLUMN_WIDTH = 400;
+const DEFAULT_TABLE_WIDTH = 730;
+/**
+* Calculate adaptive column widths based on cell content length.
+*
+* Algorithm:
+* 1. For each column, find the max content length across all rows
+* 2. Weight CJK characters as 2x width (they render wider)
+* 3. Calculate proportional widths based on content length
+* 4. Apply min/max constraints
+* 5. Redistribute remaining space to fill total table width
+*
+* Total width is derived from the original column_width values returned
+* by the Convert API, ensuring tables match Feishu's expected dimensions.
+*
+* @param blocks - Array of blocks from Convert API
+* @param tableBlockId - The block_id of the table block
+* @returns Array of column widths in pixels
+*/
+function calculateAdaptiveColumnWidths(blocks, tableBlockId) {
+	const tableBlock = blocks.find((b) => b.block_id === tableBlockId && b.block_type === 31);
+	if (!tableBlock?.table?.property) return [];
+	const { row_size, column_size, column_width: originalWidths } = tableBlock.table.property;
+	const totalWidth = originalWidths && originalWidths.length > 0 ? originalWidths.reduce((a, b) => a + b, 0) : DEFAULT_TABLE_WIDTH;
+	const cellIds = tableBlock.children || [];
+	const blockMap = /* @__PURE__ */ new Map();
+	for (const block of blocks) blockMap.set(block.block_id, block);
+	function getCellText(cellId) {
+		const cell = blockMap.get(cellId);
+		if (!cell?.children) return "";
+		let text = "";
+		const childIds = Array.isArray(cell.children) ? cell.children : [cell.children];
+		for (const childId of childIds) {
+			const child = blockMap.get(childId);
+			if (child?.text?.elements) {
+				for (const elem of child.text.elements) if (elem.text_run?.content) text += elem.text_run.content;
+			}
+		}
+		return text;
+	}
+	function getWeightedLength(text) {
+		return [...text].reduce((sum, char) => {
+			return sum + (char.charCodeAt(0) > 255 ? 2 : 1);
+		}, 0);
+	}
+	const maxLengths = new Array(column_size).fill(0);
+	for (let row = 0; row < row_size; row++) for (let col = 0; col < column_size; col++) {
+		const cellId = cellIds[row * column_size + col];
+		if (cellId) {
+			const length = getWeightedLength(getCellText(cellId));
+			maxLengths[col] = Math.max(maxLengths[col], length);
+		}
+	}
+	const totalLength = maxLengths.reduce((a, b) => a + b, 0);
+	if (totalLength === 0) {
+		const equalWidth = Math.max(MIN_COLUMN_WIDTH, Math.min(MAX_COLUMN_WIDTH, Math.floor(totalWidth / column_size)));
+		return new Array(column_size).fill(equalWidth);
+	}
+	let widths = maxLengths.map((len) => {
+		const proportion = len / totalLength;
+		return Math.round(proportion * totalWidth);
+	});
+	widths = widths.map((w) => Math.max(MIN_COLUMN_WIDTH, Math.min(MAX_COLUMN_WIDTH, w)));
+	let remaining = totalWidth - widths.reduce((a, b) => a + b, 0);
+	while (remaining > 0) {
+		const growable = widths.map((w, i) => w < MAX_COLUMN_WIDTH ? i : -1).filter((i) => i >= 0);
+		if (growable.length === 0) break;
+		const perColumn = Math.floor(remaining / growable.length);
+		if (perColumn === 0) break;
+		for (const i of growable) {
+			const add = Math.min(perColumn, MAX_COLUMN_WIDTH - widths[i]);
+			widths[i] += add;
+			remaining -= add;
+		}
+	}
+	return widths;
+}
+/**
+* Clean blocks for Descendant API with adaptive column widths.
+*
+* - Removes parent_id from all blocks
+* - Fixes children type (string → array) for TableCell blocks
+* - Removes merge_info (read-only, causes API error)
+* - Calculates and applies adaptive column_width for tables
+*
+* @param blocks - Array of blocks from Convert API
+* @returns Cleaned blocks ready for Descendant API
+*/
+function cleanBlocksForDescendant(blocks) {
+	const tableWidths = /* @__PURE__ */ new Map();
+	for (const block of blocks) if (block.block_type === 31) {
+		const widths = calculateAdaptiveColumnWidths(blocks, block.block_id);
+		tableWidths.set(block.block_id, widths);
+	}
+	return blocks.map((block) => {
+		const { parent_id: _parentId, ...cleanBlock } = block;
+		if (cleanBlock.block_type === 32 && typeof cleanBlock.children === "string") cleanBlock.children = [cleanBlock.children];
+		if (cleanBlock.block_type === 31 && cleanBlock.table) {
+			const { cells: _cells, ...tableWithoutCells } = cleanBlock.table;
+			const { row_size, column_size } = tableWithoutCells.property || {};
+			const adaptiveWidths = tableWidths.get(block.block_id);
+			cleanBlock.table = { property: {
+				row_size,
+				column_size,
+				...adaptiveWidths?.length && { column_width: adaptiveWidths }
+			} };
+		}
+		return cleanBlock;
+	});
+}
+async function insertTableRow(client, docToken, blockId, rowIndex = -1) {
+	const res = await client.docx.documentBlock.patch({
+		path: {
+			document_id: docToken,
+			block_id: blockId
+		},
+		data: { insert_table_row: { row_index: rowIndex } }
+	});
+	if (res.code !== 0) throw new Error(res.msg);
+	return {
+		success: true,
+		block: res.data?.block
+	};
+}
+async function insertTableColumn(client, docToken, blockId, columnIndex = -1) {
+	const res = await client.docx.documentBlock.patch({
+		path: {
+			document_id: docToken,
+			block_id: blockId
+		},
+		data: { insert_table_column: { column_index: columnIndex } }
+	});
+	if (res.code !== 0) throw new Error(res.msg);
+	return {
+		success: true,
+		block: res.data?.block
+	};
+}
+async function deleteTableRows(client, docToken, blockId, rowStart, rowCount = 1) {
+	const res = await client.docx.documentBlock.patch({
+		path: {
+			document_id: docToken,
+			block_id: blockId
+		},
+		data: { delete_table_rows: {
+			row_start_index: rowStart,
+			row_end_index: rowStart + rowCount
+		} }
+	});
+	if (res.code !== 0) throw new Error(res.msg);
+	return {
+		success: true,
+		rows_deleted: rowCount,
+		block: res.data?.block
+	};
+}
+async function deleteTableColumns(client, docToken, blockId, columnStart, columnCount = 1) {
+	const res = await client.docx.documentBlock.patch({
+		path: {
+			document_id: docToken,
+			block_id: blockId
+		},
+		data: { delete_table_columns: {
+			column_start_index: columnStart,
+			column_end_index: columnStart + columnCount
+		} }
+	});
+	if (res.code !== 0) throw new Error(res.msg);
+	return {
+		success: true,
+		columns_deleted: columnCount,
+		block: res.data?.block
+	};
+}
+async function mergeTableCells(client, docToken, blockId, rowStart, rowEnd, columnStart, columnEnd) {
+	const res = await client.docx.documentBlock.patch({
+		path: {
+			document_id: docToken,
+			block_id: blockId
+		},
+		data: { merge_table_cells: {
+			row_start_index: rowStart,
+			row_end_index: rowEnd,
+			column_start_index: columnStart,
+			column_end_index: columnEnd
+		} }
+	});
+	if (res.code !== 0) throw new Error(res.msg);
+	return {
+		success: true,
+		block: res.data?.block
+	};
+}
+//#endregion
+export { cleanBlocksForDescendant, deleteTableColumns, deleteTableRows, insertTableColumn, insertTableRow, mergeTableCells };