@openclaw/line 2026.9.1-beta.1 → 2026.9.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-1rY8OJw8.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

@@ -1,20 +1,7 @@
 import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 //#region extensions/line/index.ts
-function createLineCardCommandLoader(api) {
-	return createLazyRuntimeModule(async () => {
-		let registered = null;
-		const { registerLineCardCommand } = await import("./card-command-CmU47gD9.js");
-		registerLineCardCommand({
-			...api,
-			registerCommand(command) {
-				registered = command;
-			}
-		});
-		if (!registered) throw new Error("LINE card command registration unavailable");
-		return registered;
-	});
-}
+const loadLineCardCommand = createLazyRuntimeModule(() => import("./card-command-pwvE48Wb.js"));
 var line_default = defineBundledChannelEntry({
 	id: "line",
 	name: "LINE",
@@ -29,14 +16,15 @@ var line_default = defineBundledChannelEntry({
 		exportName: "setLineRuntime"
 	},
 	registerFull(api) {
-		const loadLineCardCommand = createLineCardCommandLoader(api);
 		api.registerCommand({
 			name: "card",
-			description: "Send a rich card message (LINE).",
+			description: "Send a rich card message.",
+			channels: ["line"],
 			acceptsArgs: true,
 			requireAuth: false,
 			async handler(ctx) {
-				return await (await loadLineCardCommand()).handler(ctx);
+				const { handleLineCardCommand } = await loadLineCardCommand();
+				return await handleLineCardCommand(ctx.args);
 			}
 		});
 	}

package/dist/{markdown-to-line-BmZ4hhfC.js → markdown-to-line-B-sj-7II.js}

@@ -1,4 +1,4 @@
-import { d as normalizeLineAction, h as uriAction, i as createReceiptCard, p as postbackAction, u as messageAction } from "./send-receipt-CCPTalf9.js";
+import { C as toFlexMessage, S as fitsLineFlexBubble, _ as normalizeLineAction, g as messageAction, u as createReceiptCard, x as uriAction, y as postbackAction } from "./send-retry-ChpfJ-LM.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/template-messages.ts
@@ -145,18 +145,6 @@ 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,
@@ -168,7 +156,7 @@ const LINE_MARKDOWN_OPTIONS = {
 	preserveSourceBlockSpacing: true
 };
 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,
@@ -212,10 +200,13 @@ function projectPlainText(ir, omitted = [], additionalInsertions = [], onSegment
 		text: TRANSCRIPT_ROLE_PREFIX
 	});
 	const inlineCodeSpans = ir.styles.filter((span) => span.style === "code" && !omitted.some((range) => rangesOverlap(range, span)));
-	for (const span of inlineCodeSpans) if (stripMarkdown(ir.text.slice(span.start, span.end), { assistantTranscriptRoleHeaders: true }).startsWith(TRANSCRIPT_ROLE_PREFIX)) insertions.push({
-		position: span.start,
-		text: TRANSCRIPT_ROLE_PREFIX
-	});
+	for (const span of inlineCodeSpans) {
+		const code = ir.text.slice(span.start, span.end);
+		if (stripMarkdown(code, { assistantTranscriptRoleHeaders: true }).startsWith(TRANSCRIPT_ROLE_PREFIX)) insertions.push({
+			position: span.start,
+			text: TRANSCRIPT_ROLE_PREFIX
+		});
+	}
 	insertions.sort((left, right) => left.position - right.position);
 	const underlineTags = [...ir.text.matchAll(/<\/?u>/gi)].map((match) => ({
 		start: match.index,
@@ -420,7 +411,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: {
@@ -458,7 +449,7 @@ function processLineMessage(text) {
 	const plainTextInsertions = [];
 	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) {
+		if (!bubble || !fitsLineFlexBubble(bubble)) {
 			plainTextInsertions.push({
 				position: table.placeholderOffset,
 				text: `\n\n${formatOversizedTableAsBullets(table)}\n\n`
@@ -472,10 +463,18 @@ function processLineMessage(text) {
 		});
 	}
 	for (const span of codeSpans) {
-		const message = toFlexMessage("Code", convertCodeBlockToFlexBubble(toCodeBlock(ir, span)));
+		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 = [];
@@ -491,4 +490,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, 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 };
+export { stripMarkdown$1 as a, createCarouselColumn as c, processLineMessage as i, createConfirmTemplate as l, convertTableToFlexBubble as n, buildTemplateMessageFromPayload as o, hasMarkdownToConvert as r, createButtonTemplate as s, convertCodeBlockToFlexBubble as t, createTemplateCarousel as u };