@openclaw/line 2026.8.1-beta.2 → 2026.8.1

package/dist/doctor-contract-api.js

@@ -0,0 +1,141 @@
+import { a as eventIdFor, i as errorText, o as laneKeyFor, r as LineWebhookPayloadError, s as legacyEventIdFor, t as LINE_WEBHOOK_SPOOL_INVALID_EVENT_REASON } from "./webhook-spool-contract-CNe2h1I2.js";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/line/src/webhook-spool-migration.ts
+/** Pre-drain (#109655) rows stored the event object under `event` instead of the
+*  canonical serialized `rawEvent`; anything else is not a migratable row. */
+function parseLegacySpoolPayload(payload) {
+	if (!isRecord(payload) || "rawEvent" in payload) return null;
+	if (typeof payload.destination !== "string") return null;
+	if (!isRecord(payload.event)) return null;
+	return {
+		destination: payload.destination,
+		event: payload.event
+	};
+}
+/** A dead-letter carries the pre-fix decoder's signature when the canonical spool
+*  rejected a pre-drain row before this migration existed. The identity fence and
+*  ordinary delivery failures write different reasons or messages, so neither is
+*  ever treated as recoverable. */
+function isLegacyDecodeDeadLetter(row) {
+	return row.reason === "invalid-event" && row.message === "LINE webhook spool payload is invalid." && parseLegacySpoolPayload(row.payload) !== null;
+}
+/** Counts pre-drain rows (pending, still claimed, or decoder-dead-lettered)
+*  without mutating anything. */
+async function countLegacySpoolRows(queue) {
+	const pending = await queue.listPending({ limit: "all" });
+	const claims = await queue.listClaims();
+	const failed = await queue.listFailed?.({ limit: "all" }) ?? [];
+	return pending.filter((record) => parseLegacySpoolPayload(record.payload) !== null).length + claims.filter((claim) => parseLegacySpoolPayload(claim.payload) !== null).length + failed.filter((row) => isLegacyDecodeDeadLetter(row)).length;
+}
+/** One-time upgrade migration: rewrite pre-drain (#109655) rows into the canonical
+*  payload and message:/event: keyspace before the spool drains, so the runtime
+*  reader keeps a single row contract. Idempotent — enqueue deduplicates by id, so
+*  a rerun after a crash only re-completes the leftover legacy rows. */
+async function migrateLineLegacySpoolRows(queue) {
+	const result = {
+		migrated: 0,
+		reconciled: 0,
+		deadLettered: 0,
+		recovered: 0,
+		failures: []
+	};
+	await queue.recoverStaleClaims({
+		staleMs: 0,
+		shouldRecover: (claim) => parseLegacySpoolPayload(claim.payload) !== null
+	});
+	const failed = await queue.listFailed?.({ limit: "all" }) ?? [];
+	for (const row of failed) {
+		if (!isLegacyDecodeDeadLetter(row)) continue;
+		try {
+			if ((await queue.resubmit?.(row.id, { resubmittedAt: row.receivedAt }))?.kind === "resubmitted") result.recovered += 1;
+		} catch (error) {
+			result.failures.push(`row ${row.id}: ${errorText(error)}`);
+		}
+	}
+	const pending = await queue.listPending({
+		limit: "all",
+		orderBy: "received"
+	});
+	for (const record of pending) {
+		const legacy = parseLegacySpoolPayload(record.payload);
+		if (!legacy) continue;
+		let eventId;
+		try {
+			if (record.id !== legacyEventIdFor(legacy.event)) throw new LineWebhookPayloadError("LINE webhook event identity changed after durable admission.");
+			eventId = eventIdFor(legacy.event);
+		} catch (error) {
+			await queue.fail(record.id, {
+				reason: LINE_WEBHOOK_SPOOL_INVALID_EVENT_REASON,
+				message: errorText(error)
+			});
+			result.deadLettered += 1;
+			continue;
+		}
+		try {
+			const admitted = await queue.enqueue(eventId, {
+				version: 1,
+				rawEvent: JSON.stringify(legacy.event),
+				destination: legacy.destination
+			}, {
+				receivedAt: record.receivedAt,
+				laneKey: laneKeyFor(legacy.event, eventId)
+			});
+			await queue.complete(record.id);
+			if (admitted.kind === "completed" || admitted.kind === "failed") result.reconciled += 1;
+			else result.migrated += 1;
+		} catch (error) {
+			result.failures.push(`row ${record.id}: ${errorText(error)}`);
+		}
+	}
+	return result;
+}
+//#endregion
+//#region extensions/line/doctor-contract-api.ts
+const LINE_CHANNEL_ID = "line";
+/** Pre-drain rows can outlive the account config that admitted them, so the sweep
+*  enumerates accounts from the host's queue lane instead of the config; a host
+*  without the lane fails visibly rather than silently skipping the migration. */
+function lineSpoolQueueAccess(context) {
+	const access = context.channelIngressQueues?.find((entry) => entry.channelId === LINE_CHANNEL_ID);
+	if (!access) throw new Error("LINE pre-drain spool migration requires the doctor host's channel ingress queue access.");
+	return access;
+}
+/** Doctor-owned upgrade migration for pre-drain (#109655) webhook spool rows. */
+const stateMigrations = [{
+	id: "line-pre-drain-spool-rows",
+	label: "LINE pre-drain webhook spool rows",
+	async detectLegacyState(params) {
+		const spool = lineSpoolQueueAccess(params.context);
+		const preview = [];
+		for (const accountId of await spool.listChannelIngressQueueAccountIds()) {
+			const count = await countLegacySpoolRows(spool.openChannelIngressQueueForInspection({ accountId }));
+			if (count > 0) preview.push(`- LINE pre-drain spool rows (account "${accountId}"): ${count} row(s) -> canonical ingress contract`);
+		}
+		return preview.length > 0 ? { preview } : null;
+	},
+	async migrateLegacyState(params) {
+		const spool = lineSpoolQueueAccess(params.context);
+		const lineConfig = params.config.channels?.line;
+		const configuredAccountIds = /* @__PURE__ */ new Set([...Object.keys(lineConfig?.accounts ?? {}), ...lineConfig ? ["default"] : []]);
+		const openForMigration = spool.openChannelIngressQueue;
+		if (!openForMigration) throw new Error("LINE pre-drain spool migration requires mutable ingress access from the doctor host's exclusive repair section.");
+		const changes = [];
+		const warnings = [];
+		for (const accountId of await spool.listChannelIngressQueueAccountIds()) {
+			const result = await migrateLineLegacySpoolRows(openForMigration({ accountId }));
+			if (result.migrated > 0 || result.reconciled > 0 || result.deadLettered > 0 || result.recovered > 0) {
+				const recovered = result.recovered > 0 ? ` (${result.recovered} recovered from the dead-letter table)` : "";
+				const reconciled = result.reconciled > 0 ? `, ${result.reconciled} already settled under the canonical id` : "";
+				const dispatchNote = configuredAccountIds.has(accountId) ? "" : ` (account not currently configured, so these stay queued until it is restored)`;
+				changes.push(`Migrated LINE pre-drain spool rows (account "${accountId}"): ${result.migrated} queued under the canonical contract, ${result.deadLettered} dead-lettered at the identity fence${reconciled}${recovered}${dispatchNote}`);
+			}
+			for (const failure of result.failures) warnings.push(`Failed migrating a LINE pre-drain spool row (account "${accountId}", ${failure}); the row stays pending and the migration retries on the next run`);
+		}
+		return {
+			changes,
+			warnings
+		};
+	}
+}];
+//#endregion
+export { stateMigrations };

package/dist/index.js

@@ -4,7 +4,7 @@ import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 function createLineCardCommandLoader(api) {
 	return createLazyRuntimeModule(async () => {
 		let registered = null;
-		const { registerLineCardCommand } = await import("./card-command-DALdUSnc.js");
+		const { registerLineCardCommand } = await import("./card-command-BywtX77U.js");
 		registerLineCardCommand({
 			...api,
 			registerCommand(command) {

package/dist/{markdown-to-line-D4I-6lm6.js → markdown-to-line-CG9Jy22s.js}

@@ -1,18 +1,6 @@
-import { f as messageAction, g as uriAction, h as postbackAction, o as createReceiptCard, p as normalizeLineAction } from "./flex-templates-BBBlNqpV.js";
+import { g as postbackAction, m as normalizeLineAction, p as messageAction, s as createReceiptCard, v as uriAction } from "./send-retry-CUvrarfE.js";
 import { markdownToIRWithMeta, stripMarkdown, stripMarkdown as stripMarkdown$1 } from "openclaw/plugin-sdk/text-chunking";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-//#region extensions/line/src/flex-templates/message.ts
-/**
-* Wrap a FlexContainer in a FlexMessage
-*/
-function toFlexMessage(altText, contents) {
-	return {
-		type: "flex",
-		altText,
-		contents
-	};
-}
-//#endregion
 //#region extensions/line/src/template-messages.ts
 const COMPACT_TEMPLATE_TEXT_LIMIT = 60;
 const TEMPLATE_ALT_TEXT_LIMIT = 1500;
@@ -157,6 +145,18 @@ function buildTemplateMessageFromPayload(payload) {
 	}
 }
 //#endregion
+//#region extensions/line/src/flex-templates/message.ts
+/**
+* Wrap a FlexContainer in a FlexMessage
+*/
+function toFlexMessage(altText, contents) {
+	return {
+		type: "flex",
+		altText,
+		contents
+	};
+}
+//#endregion
 //#region extensions/line/src/markdown-to-line.ts
 const LINE_MARKDOWN_OPTIONS = {
 	assistantTranscriptRoleHeaders: true,
@@ -169,6 +169,7 @@ const LINE_MARKDOWN_OPTIONS = {
 };
 const TRANSCRIPT_ROLE_PREFIX = "[assistant-authored transcript] ";
 const LINE_FLEX_BUBBLE_MAX_BYTES = 3e4;
+const LINE_FLEX_CODE_CARD_MAX_CHARS = 2e3;
 function parseLineMarkdown(text, tableMode = "block") {
 	return markdownToIRWithMeta(text, {
 		...LINE_MARKDOWN_OPTIONS,
@@ -420,7 +421,7 @@ function convertTableToFlexBubble(table) {
 /** Convert a code block to a LINE Flex Message bubble. */
 function convertCodeBlockToFlexBubble(block) {
 	const titleText = block.language ? `Code (${block.language})` : "Code";
-	const displayCode = block.code.length > 2e3 ? truncateUtf16Safe(block.code, 2e3) + "\n..." : block.code;
+	const displayCode = block.code.length > LINE_FLEX_CODE_CARD_MAX_CHARS ? `${truncateUtf16Safe(block.code, LINE_FLEX_CODE_CARD_MAX_CHARS)}\n...` : block.code;
 	return {
 		type: "bubble",
 		body: {
@@ -455,13 +456,10 @@ function convertCodeBlockToFlexBubble(block) {
 function processLineMessage(text) {
 	const { ir, tables } = parseLineMarkdown(text);
 	const codeSpans = codeBlockSpans(ir);
-	const flexMessages = [];
 	const plainTextInsertions = [];
-	let hasOversizedTable = false;
 	for (const table of tables) {
 		const bubble = table.rowCells.length > 10 && (table.headers.length !== 2 || table.rowCells.length > 12 || [table.headerCells, ...table.rowCells].some((cells) => cells.some((cell) => renderTableCell(cell, "-").hasMarkup))) ? void 0 : convertTableToFlexBubble(toMarkdownTable(table));
 		if (!bubble || Buffer.byteLength(JSON.stringify(bubble), "utf8") > LINE_FLEX_BUBBLE_MAX_BYTES) {
-			hasOversizedTable = true;
 			plainTextInsertions.push({
 				position: table.placeholderOffset,
 				text: `\n\n${formatOversizedTableAsBullets(table)}\n\n`
@@ -469,25 +467,31 @@ function processLineMessage(text) {
 			continue;
 		}
 		const message = toFlexMessage("Table", bubble);
-		flexMessages.push(message);
 		plainTextInsertions.push({
 			position: table.placeholderOffset,
 			message
 		});
 	}
 	for (const span of codeSpans) {
-		const message = toFlexMessage("Code", convertCodeBlockToFlexBubble(toCodeBlock(ir, span)));
-		flexMessages.push(message);
+		const block = toCodeBlock(ir, span);
+		if (!block.code.trim()) continue;
+		if (block.code.length > LINE_FLEX_CODE_CARD_MAX_CHARS) {
+			plainTextInsertions.push({
+				position: span.start,
+				text: `\n\n${block.code}\n\n`
+			});
+			continue;
+		}
 		plainTextInsertions.push({
 			position: span.start,
-			message
+			message: toFlexMessage("Code", convertCodeBlockToFlexBubble(block))
 		});
 	}
 	const segments = [];
 	return {
-		text: projectPlainText(ir, codeSpans, plainTextInsertions, hasOversizedTable ? (segment) => segments.push(segment) : void 0),
-		flexMessages,
-		...hasOversizedTable ? { segments } : {}
+		text: projectPlainText(ir, codeSpans, plainTextInsertions, (segment) => segments.push(segment)),
+		flexMessages: segments.flatMap((segment) => segment.type === "flex" ? [segment.message] : []),
+		...plainTextInsertions.length > 0 ? { segments } : {}
 	};
 }
 /** Check if text contains markdown that needs conversion. */
@@ -496,4 +500,4 @@ function hasMarkdownToConvert(text) {
 	return tables.length > 0 || ir.styles.length > 0 || ir.links.length > 0 || /<\/?u>/i.test(ir.text) || ir.text !== text.trimEnd();
 }
 //#endregion
-export { stripMarkdown$1 as a, createCarouselColumn as c, toFlexMessage as d, processLineMessage as i, createConfirmTemplate as l, convertTableToFlexBubble as n, buildTemplateMessageFromPayload as o, hasMarkdownToConvert as r, createButtonTemplate as s, convertCodeBlockToFlexBubble as t, createTemplateCarousel as u };
+export { stripMarkdown$1 as a, createButtonTemplate as c, createTemplateCarousel as d, processLineMessage as i, createCarouselColumn as l, convertTableToFlexBubble as n, toFlexMessage as o, hasMarkdownToConvert as r, buildTemplateMessageFromPayload as s, convertCodeBlockToFlexBubble as t, createConfirmTemplate as u };