botmux 3.10.0 → 3.23.1

package/dist/im/lark/md-card.js

@@ -1,872 +0,0 @@
-/**
- * Markdown → Feishu interactive card v2 body builder.
- *
- * Shared by `cli.ts` (`botmux send`) and `core/worker-pool.ts` (bridge
- * fallback final_output forwarding) so a model reply going through either
- * path renders identically in the Lark thread — same chrome, same markdown
- * rendering, same table widget.
- *
- * Implementation note: parsing is delegated to `markdown-it` (CommonMark +
- * GFM tables) instead of hand-rolled regex. The previous regex-based fence
- * splitter mis-fired on two real cases observed in production:
- *   1. Code fences directly adjacent to a prose line (no blank line) — Feishu's
- *      markdown widget needs blank lines around fences, and the old splitter
- *      didn't enforce them, so fences leaked through as literal `\`\`\`` text.
- *   2. Nested 3-backtick fences — the non-greedy regex closed the outer fence
- *      at the first inner one, garbling everything after it.
- * markdown-it tokenizes correctly per CommonMark and gives us blank-line
- * normalization for free. For nested fences users should use 4+ backticks for
- * the outer block (CommonMark spec).
- */
-import { homedir } from 'node:os';
-import { existsSync } from 'node:fs';
-import { randomBytes } from 'node:crypto';
-import { resolve } from 'node:path';
-import MarkdownIt from 'markdown-it';
-import { t } from '../../i18n/index.js';
-import { REPLY_CARD_FOOTER_ELEMENT_ID, REPLY_CARD_FOOTER_MARKER, } from './reply-card-footer-signature.js';
-export { REPLY_CARD_FOOTER_MARKER } from './reply-card-footer-signature.js';
-const md = new MarkdownIt({ html: false, linkify: false, breaks: false });
-const MAX_LOCAL_HOME_LINK_REPAIRS = 256;
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/**
- * Find home-prefix occurrences that are worth asking markdown-it about. The
- * scan deliberately over-matches prose and code: a unique, URL-safe marker is
- * injected before each occurrence and only markers that markdown-it returns
- * as the start of a real `link_open` href are accepted. This keeps CommonMark
- * semantics (containers, code, tables, and all newline styles) in one parser
- * instead of recreating source maps or inline rules here.
- */
-function collectLocalHomeLinkCandidates(input, relativeHome) {
-    const homeOccurrence = new RegExp(`${escapeRegExp(relativeHome)}(?=$|[/?#>:()\\s\\\\])`, 'gi');
-    const candidates = [];
-    for (const match of input.matchAll(homeOccurrence)) {
-        const start = match.index;
-        candidates.push({
-            id: candidates.length,
-            start,
-            end: start + match[0].length,
-            value: '',
-        });
-    }
-    return candidates;
-}
-function chooseLinkMarkerPrefix(input) {
-    let prefix;
-    do {
-        prefix = `bmxlocallink${randomBytes(12).toString('hex')}x`;
-    } while (input.includes(prefix));
-    return prefix;
-}
-/** Return only candidates that markdown-it confirms start a real link href. */
-function validateLocalHomeLinkCandidates(input, candidates) {
-    if (candidates.length === 0)
-        return [];
-    const markerPrefix = chooseLinkMarkerPrefix(input);
-    const markedParts = [];
-    let sourceCursor = 0;
-    for (const candidate of candidates) {
-        const marker = `${markerPrefix}${candidate.id}x/`;
-        markedParts.push(input.slice(sourceCursor, candidate.start), marker);
-        sourceCursor = candidate.start;
-    }
-    markedParts.push(input.slice(sourceCursor));
-    const marked = markedParts.join('');
-    const byId = new Map(candidates.map(candidate => [candidate.id, candidate]));
-    const confirmed = new Set();
-    const markerPattern = new RegExp(`^${escapeRegExp(markerPrefix)}(\\d+)x/`);
-    const anyMarkerPattern = new RegExp(`${escapeRegExp(markerPrefix)}\\d+x/`, 'g');
-    for (const token of md.parse(marked, {})) {
-        if (token.type !== 'inline')
-            continue;
-        for (const child of token.children ?? []) {
-            if (child.type !== 'link_open')
-                continue;
-            const href = child.attrGet('href') ?? '';
-            const markerMatch = href.match(markerPattern);
-            if (!markerMatch)
-                continue;
-            const id = Number(markerMatch[1]);
-            const candidate = byId.get(id);
-            if (!candidate)
-                continue;
-            const marker = markerMatch[0];
-            candidate.value = md.normalizeLinkText(href.slice(marker.length).replace(anyMarkerPattern, ''));
-            confirmed.add(id);
-        }
-    }
-    return candidates.filter(candidate => confirmed.has(candidate.id));
-}
-/**
- * Restore the leading slash when a model emits the current user's home path
- * as a relative Markdown link destination. Codex file links are normally
- * absolute (`/Users/alice/...` or `/home/alice/...`); without the slash,
- * Feishu resolves the destination as a relative URL and cannot open it.
- *
- * The repair is intentionally narrow: it only matches the current host home
- * prefix and only in destinations markdown-it recognizes as real inline links.
- * Web links, existing absolute paths, other users' homes, and general
- * relative links are left unchanged. An ambiguous home-shaped target is only
- * repaired when the absolute file exists and the same target does not exist
- * relative to the current working directory.
- */
-export function normalizeLocalHomeLinks(input, homeDir = homedir(), cwd = process.cwd(), pathExists = existsSync, mode = 'filesystem') {
-    if (mode === 'disabled')
-        return input;
-    const relativeHome = homeDir.replace(/^\/+/, '').replace(/\/+$/, '');
-    if (!relativeHome || relativeHome === homeDir)
-        return input;
-    const homePrefix = new RegExp(`^${escapeRegExp(relativeHome)}(?=$|[/?#])`, 'i');
-    const normalizedHome = resolve(homeDir);
-    const pathExistence = new Map();
-    const cachedPathExists = (path) => {
-        let exists = pathExistence.get(path);
-        if (exists === undefined) {
-            exists = pathExists(path);
-            pathExistence.set(path, exists);
-        }
-        return exists;
-    };
-    const confirmedDestinations = validateLocalHomeLinkCandidates(input, collectLocalHomeLinkCandidates(input, relativeHome));
-    // Filesystem mode caps synchronous probes over untrusted model output.
-    // Lexical mode performs no I/O, so it can repair every confirmed link.
-    const destinations = mode === 'filesystem'
-        ? confirmedDestinations.slice(0, MAX_LOCAL_HOME_LINK_REPAIRS)
-        : confirmedDestinations;
-    const repairs = [];
-    for (const destination of destinations) {
-        const homeMatch = destination.value.match(homePrefix);
-        if (!homeMatch)
-            continue;
-        const relativeTarget = destination.value.split(/[?#]/, 1)[0];
-        const absoluteTargetText = `${relativeHome}${destination.value.slice(homeMatch[0].length)}`
-            .split(/[?#]/, 1)[0];
-        const strippedRelativeTarget = relativeTarget.replace(/:\d+(?::\d+)?$/, '');
-        const strippedAbsoluteTargetText = absoluteTargetText.replace(/:\d+(?::\d+)?$/, '');
-        const targetTexts = [{ relative: relativeTarget, absolute: absoluteTargetText }];
-        const hasPositionSuffix = strippedRelativeTarget !== relativeTarget &&
-            strippedAbsoluteTargetText !== absoluteTargetText;
-        if (hasPositionSuffix) {
-            targetTexts.push({ relative: strippedRelativeTarget, absolute: strippedAbsoluteTargetText });
-        }
-        const targetCandidates = targetTexts.map(target => ({
-            relative: resolve(cwd, target.relative),
-            absolute: resolve('/', target.absolute),
-        }));
-        if (targetCandidates[0].absolute !== normalizedHome &&
-            !targetCandidates[0].absolute.startsWith(`${normalizedHome}/`))
-            continue;
-        // A numeric suffix can be a Codex source position. Never let removing it
-        // create a second candidate outside HOME (for example `..:123`). In
-        // filesystem mode the exact literal filename remains eligible; lexical
-        // mode cannot distinguish it safely, so it leaves the link unchanged.
-        const strippedCandidateIsSafe = targetCandidates.length === 1 ||
-            targetCandidates[1].absolute === normalizedHome ||
-            targetCandidates[1].absolute.startsWith(`${normalizedHome}/`);
-        if (mode === 'lexical' && !strippedCandidateIsSafe)
-            continue;
-        if (mode === 'filesystem') {
-            const safeCandidates = strippedCandidateIsSafe ? targetCandidates : targetCandidates.slice(0, 1);
-            // Preserve the source spelling/case for cwd-relative disambiguation. On
-            // a case-sensitive filesystem, `Home/alice/a` and `home/alice/a` differ.
-            if (safeCandidates.some(target => cachedPathExists(target.relative)))
-                continue;
-            if (!safeCandidates.some(target => cachedPathExists(target.absolute)))
-                continue;
-        }
-        const rawHome = input.slice(destination.start, destination.end);
-        if (rawHome.toLowerCase() !== homeMatch[0].toLowerCase())
-            continue;
-        repairs.push({ start: destination.start, end: destination.end });
-    }
-    if (repairs.length === 0)
-        return input;
-    const outputParts = [];
-    let outputCursor = 0;
-    for (const repair of repairs) {
-        outputParts.push(input.slice(outputCursor, repair.start), `/${relativeHome}`);
-        outputCursor = repair.end;
-    }
-    outputParts.push(input.slice(outputCursor));
-    return outputParts.join('');
-}
-/** Default footer brand when a bot has no custom `brandLabel` configured. */
-export const DEFAULT_BRAND_LABEL = '[botmux](https://github.com/deepcoldy/botmux)';
-/**
- * Resolve the brand segment to render in a card footer from a bot's configured
- * `brandLabel` (see {@link resolveBrandLabel}):
- *   • `undefined` (unset)  → the default botmux link
- *   • `''` / whitespace    → `null` (brand suppressed)
- *   • any other string     → one trimmed line (markdown allowed)
- * Returning `null` lets callers drop the brand — and, when there's also no
- * recipient, the whole footer (HR included) — so an empty brand reads clean.
- */
-export function brandFooterSegment(brand) {
-    if (brand === undefined)
-        return DEFAULT_BRAND_LABEL;
-    const normalized = brand
-        .trim()
-        .replace(/[ \t]*(?:\r\n?|\n|\u2028|\u2029)+[ \t]*/g, ' ');
-    return normalized || null;
-}
-function compactTokenCount(value) {
-    const units = [
-        { threshold: 1_000_000_000, suffix: 'B' },
-        { threshold: 1_000_000, suffix: 'M' },
-        { threshold: 1_000, suffix: 'K' },
-    ];
-    let unitIndex = units.findIndex(candidate => value >= candidate.threshold);
-    if (unitIndex < 0)
-        return Math.round(value).toString();
-    let unit = units[unitIndex];
-    let scaled = value / unit.threshold;
-    // Avoid boundary artifacts such as 1000K/1000M after one-decimal rounding.
-    if (unitIndex > 0 && Number(scaled.toFixed(1)) >= 1_000) {
-        unit = units[--unitIndex];
-        scaled = value / unit.threshold;
-    }
-    return `${scaled.toFixed(1).replace(/\.0$/, '')}${unit.suffix}`;
-}
-function isNonNegativeFinite(value) {
-    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
-}
-/** Format usage as one segment shared by reply-card footers and the live
- * streaming card. The caller supplies native facts; this module only formats
- * them and never infers a context window or token count. Returns null when no
- * valid native metric is available.
- *
- * `variant`:
- *   - `'footer'` (default): minimal — context only. Reply-card footers are
- *     cramped (brand · usage · 发送给), so the large cumulative token string is
- *     dropped here (it lives on the streaming card / usage ledger). 上下文占用
- *     is the one glanceable "how full am I" metric worth keeping.
- *   - `'streaming'`: rich — context + `本轮 ↑X ↓Y`(per-turn delta, matches the
- *     CLI TUI) + `累计 ↑A ↓B`(session total). The live card has room and
- *     refreshes during execution. */
-export function cardUsageFooterSegment(usage, locale, variant = 'footer') {
-    const parts = [];
-    if (usage.context && isNonNegativeFinite(usage.context.usedTokens)) {
-        const used = compactTokenCount(usage.context.usedTokens);
-        const window = usage.context.windowTokens;
-        const windowSuffix = isNonNegativeFinite(window) && window > 0
-            ? `/${compactTokenCount(window)}`
-            : '';
-        const percentSuffix = isNonNegativeFinite(usage.context.percentUsed)
-            ? ` (${Math.min(100, Math.round(usage.context.percentUsed))}%)`
-            : '';
-        const suffix = `${windowSuffix}${percentSuffix}`;
-        parts.push(`${t('card.usage.context', undefined, locale)} ${used}${suffix}`);
-    }
-    // Footer variant is context-only (keeps the cramped reply-card footer clean);
-    // the token breakdown below is streaming-only.
-    if (variant !== 'streaming') {
-        return parts.length > 0 ? parts.join(' · ') : null;
-    }
-    // Per-turn delta (streaming only): small ↑↓ for the latest turn, labelled 本轮.
-    const turn = usage.turnTokens;
-    if (turn
-        && isNonNegativeFinite(turn.in)
-        && isNonNegativeFinite(turn.out)
-        && (turn.in > 0 || turn.out > 0)) {
-        parts.push(`${t('card.usage.turn', undefined, locale)} `
-            + `↑${compactTokenCount(turn.in)} ↓${compactTokenCount(turn.out)}`);
-    }
-    if (usage.tokens
-        && isNonNegativeFinite(usage.tokens.in)
-        && isNonNegativeFinite(usage.tokens.out)
-        // Suppress an all-zero token line: a brand-new session (or a synthetic /
-        // zero-usage transcript record read before the real turn lands) yields
-        // in=out=0, which would render a meaningless "↑0 ↓0". Omit it like any
-        // other missing metric until there is real usage to show.
-        && (usage.tokens.in > 0 || usage.tokens.out > 0)) {
-        parts.push(`${t('card.usage.total', undefined, locale)} `
-            + `↑${compactTokenCount(usage.tokens.in)} ↓${compactTokenCount(usage.tokens.out)}`);
-    }
-    return parts.length > 0 ? parts.join(' · ') : null;
-}
-/** Build the one canonical footer shared by all Bot Session reply cards.
- * Ordering, i18n, the parser marker, grey styling, and recipient rendering live
- * here so direct sends and daemon fallbacks cannot drift apart. */
-export function buildReplyCardFooter(opts) {
-    const parts = [];
-    const brandSeg = brandFooterSegment(opts.brand);
-    if (brandSeg)
-        parts.push(brandSeg);
-    let hasUsage = false;
-    if (opts.usage) {
-        const usageSeg = cardUsageFooterSegment(opts.usage, opts.locale);
-        if (usageSeg) {
-            parts.push(usageSeg);
-            hasUsage = true;
-        }
-    }
-    const recipientOpenIds = [...new Set((opts.recipientOpenIds ?? []).filter(Boolean))];
-    const hasRecipient = recipientOpenIds.length > 0;
-    if (hasRecipient) {
-        parts.push(`${t('card.sent_to', undefined, opts.locale)}`
-            + recipientOpenIds.map(id => `<at id=${id}></at>`).join(' '));
-    }
-    if (parts.length === 0)
-        return null;
-    // The marker is a visible, versioned link that lets the parser identify a
-    // card's footer (and strip it before a bot-to-bot relay). It doubles as the
-    // first separator. But a BRAND-ONLY footer (no usage, no recipient — the
-    // common case now that usageDisplay defaults to the streaming card body and
-    // the reply-card footer is context-only) needs no marker: appending it renders
-    // a dangling "botmux ·". The default/repository brand is plain link text with
-    // no `@`, so it cannot trigger bot-to-bot pollution and does not need the
-    // ownership marker (the parser already treats a bare repo link as ordinary
-    // content, matching the long-standing "brand-only is undecidable, keep it"
-    // contract). Any footer carrying usage or a recipient is still signed.
-    const signMarker = hasUsage || hasRecipient;
-    let signedContent;
-    if (!signMarker) {
-        signedContent = parts[0]; // brand-only — no marker
-    }
-    else if (parts.length > 1) {
-        signedContent = `${parts[0]} ${REPLY_CARD_FOOTER_MARKER} ${parts.slice(1).join(' · ')}`;
-    }
-    else {
-        // usage-only / recipient-only (brand disabled) — still marked for parsing.
-        signedContent = `${parts[0]} ${REPLY_CARD_FOOTER_MARKER}`;
-    }
-    const content = `<font color='grey'>${signedContent}</font>`;
-    return {
-        content,
-        element: {
-            tag: 'markdown',
-            element_id: REPLY_CARD_FOOTER_ELEMENT_ID,
-            text_size: 'notation_small_v2',
-            content,
-        },
-    };
-}
-/** Clone a caller-supplied schema-2 card and append the canonical reply
- * footer. Returns null for cards without a v2 `body.elements` array or when a
- * caller-owned element already occupies the globally unique footer id. */
-export function appendReplyCardFooterToV2Card(card, opts) {
-    const cloned = JSON.parse(JSON.stringify(card));
-    if (cloned.schema !== '2.0')
-        return null;
-    const body = cloned.body;
-    if (!body || !Array.isArray(body.elements))
-        return null;
-    const header = cloned.header;
-    const i18nHeaderTagLists = header?.i18n_text_tag_list
-        && typeof header.i18n_text_tag_list === 'object'
-        ? Object.values(header.i18n_text_tag_list)
-        : [];
-    if (containsReplyCardFooterId(body.elements)
-        || containsReplyCardFooterId(header?.text_tag_list)
-        || containsReplyCardFooterId(i18nHeaderTagLists)) {
-        return null;
-    }
-    const footer = buildReplyCardFooter(opts);
-    if (footer)
-        body.elements.push({ tag: 'hr' }, footer.element);
-    return cloned;
-}
-function containsReplyCardFooterId(value) {
-    if (Array.isArray(value))
-        return value.some(containsReplyCardFooterId);
-    if (!value || typeof value !== 'object')
-        return false;
-    const record = value;
-    if (record.element_id === REPLY_CARD_FOOTER_ELEMENT_ID)
-        return true;
-    // Follow only documented component-child slots. Callback `value`, behavior
-    // payloads, and other arbitrary business JSON are deliberately outside the
-    // card component tree even when they contain tag/element_id-shaped fields.
-    return containsReplyCardFooterId(record.elements)
-        || containsReplyCardFooterId(record.columns)
-        || containsReplyCardFooterId(record.actions)
-        || containsReplyCardFooterId(record.extra);
-}
-/** Build a Feishu native `table` element from a `table_open … table_close` token slice. */
-function buildTableFromTokens(tokens) {
-    const headerCells = [];
-    const bodyRows = [];
-    let inHead = false;
-    let inBody = false;
-    let currentRow = null;
-    let inCell = false;
-    for (const t of tokens) {
-        switch (t.type) {
-            case 'thead_open':
-                inHead = true;
-                break;
-            case 'thead_close':
-                inHead = false;
-                break;
-            case 'tbody_open':
-                inBody = true;
-                break;
-            case 'tbody_close':
-                inBody = false;
-                break;
-            case 'tr_open':
-                currentRow = [];
-                break;
-            case 'tr_close':
-                if (inBody && currentRow)
-                    bodyRows.push(currentRow);
-                currentRow = null;
-                break;
-            case 'th_open':
-            case 'td_open':
-                inCell = true;
-                break;
-            case 'th_close':
-            case 'td_close':
-                inCell = false;
-                break;
-            case 'inline':
-                if (inCell) {
-                    if (inHead)
-                        headerCells.push(t.content);
-                    else if (currentRow)
-                        currentRow.push(t.content);
-                }
-                break;
-        }
-    }
-    if (headerCells.length === 0)
-        return null;
-    const columns = headerCells.map((h, i) => ({
-        name: `c${i}`,
-        display_name: h || ' ',
-        data_type: 'lark_md',
-        width: 'auto',
-    }));
-    const rows = bodyRows.map(r => {
-        const o = {};
-        for (let i = 0; i < headerCells.length; i++)
-            o[`c${i}`] = r[i] ?? '';
-        return o;
-    });
-    return {
-        tag: 'table',
-        page_size: Math.min(10, Math.max(1, rows.length || 1)),
-        row_height: 'low',
-        header_style: {
-            text_align: 'left',
-            text_size: 'normal',
-            background_style: 'grey',
-            text_color: 'default',
-            bold: true,
-            lines: 1,
-        },
-        columns,
-        rows,
-    };
-}
-function sliceLines(lines, map) {
-    return lines.slice(map[0], map[1]).join('\n');
-}
-/** Find index of the matching close token at the same nesting depth. */
-function findMatchingClose(tokens, openIdx) {
-    const open = tokens[openIdx];
-    const close = open.type.replace(/_open$/, '_close');
-    let depth = 1;
-    for (let j = openIdx + 1; j < tokens.length; j++) {
-        if (tokens[j].type === open.type)
-            depth++;
-        else if (tokens[j].type === close) {
-            depth--;
-            if (depth === 0)
-                return j;
-        }
-    }
-    return tokens.length - 1;
-}
-/**
- * Defensive unescape: when a line consists solely of 3+ backslash-escaped
- * backticks (with optional ≤3-space indent and an info string with no
- * backticks), strip the backslashes so markdown-it sees a real fence.
- *
- * This shields against a common LLM/shell bug: writing `botmux send "$(cat
- * <<'EOF' \`\`\` ... \`\`\` EOF)"` puts literal `\\\`` into the markdown
- * because the model over-escapes inside a single-quoted heredoc. markdown-it
- * then treats each `\\\`` as a CommonMark backslash-escape (literal backtick),
- * so no fence opens and the code block renders as flat text in the card.
- *
- * The regex is intentionally tight — only whole lines that are pure escaped
- * fences are touched. Inline `\\\`` and code-block bodies that mention
- * `\\\`\\\`\\\`` (e.g. a markdown tutorial) are unaffected.
- */
-function unescapeFenceLines(input) {
-    return input.replace(/^[ ]{0,3}(?:\\`){3,}[^\n`]*$/gm, m => m.replace(/\\`/g, '`'));
-}
-/** Normalize source bytes that must be settled before the card is rendered. */
-export function prepareCardMarkdown(input, cwd = process.cwd(), localHomeLinkMode = 'filesystem') {
-    input = unescapeFenceLines(input);
-    return normalizeLocalHomeLinks(input, homedir(), cwd, existsSync, localHomeLinkMode);
-}
-/**
- * Split markdown into card v2 body elements:
- *   1. Pipe tables → native `table` widget (Feishu's markdown widget can't
- *      render them as a grid).
- *   2. Headings → bold (Feishu's markdown widget doesn't render ATX `#`).
- *   3. Code fences → re-emitted with the original backtick run, joined with
- *      blank lines on either side (Feishu's widget needs them to recognise the
- *      fence).
- *   4. Everything else → original source slice, glued by blank lines.
- *
- * All non-table blocks are merged into a single `markdown` element to keep
- * card element counts modest.
- */
-export function buildCardBodyElements(input, cwd = process.cwd(), localHomeLinkMode = 'filesystem') {
-    if (!input)
-        return [];
-    // Recover model-escaped fences first so markdown-it can classify their
-    // contents as code before local-link normalization inspects link tokens.
-    input = prepareCardMarkdown(input, cwd, localHomeLinkMode);
-    // Pre-pass: a line that is nothing but 2+ images renders as a side-by-side
-    // image row (column_set) instead of stacked full-width images. Everything
-    // else flows through the markdown element builder unchanged. Fence-aware so
-    // image-looking lines inside ``` code blocks are left intact.
-    const elements = [];
-    for (const seg of splitImageRowSegments(input)) {
-        if (seg.type === 'imgrow')
-            elements.push(imageRowElement(seg.keys));
-        else
-            elements.push(...buildMarkdownElements(seg.content));
-    }
-    return elements;
-}
-function buildMarkdownElements(input) {
-    if (!input)
-        return [];
-    input = unescapeFenceLines(input);
-    const tokens = md.parse(input, {});
-    const lines = input.split('\n');
-    const elements = [];
-    const buf = [];
-    const flushBuf = () => {
-        const text = buf.join('\n\n').replace(/\n{3,}/g, '\n\n').trim();
-        if (text)
-            elements.push({ tag: 'markdown', content: text });
-        buf.length = 0;
-    };
-    let i = 0;
-    while (i < tokens.length) {
-        const t = tokens[i];
-        if (t.level !== 0) {
-            i++;
-            continue;
-        }
-        if (t.type === 'table_open') {
-            flushBuf();
-            const j = findMatchingClose(tokens, i);
-            const tableEl = buildTableFromTokens(tokens.slice(i, j + 1));
-            if (tableEl)
-                elements.push(tableEl);
-            else if (t.map)
-                buf.push(sliceLines(lines, t.map));
-            i = j + 1;
-            continue;
-        }
-        if (t.type === 'heading_open') {
-            const inline = tokens[i + 1];
-            const text = (inline?.content ?? '').replace(/^#{1,6}\s+/, '').trim();
-            if (text)
-                buf.push(`**${text}**`);
-            i += 3; // heading_open, inline, heading_close
-            continue;
-        }
-        if (t.type === 'fence' || t.type === 'code_block') {
-            const fence = t.markup || '```';
-            const info = (t.info || '').trim();
-            const content = t.content.replace(/\n+$/, '');
-            buf.push(`${fence}${info}\n${content}\n${fence}`);
-            i++;
-            continue;
-        }
-        if (t.type === 'hr') {
-            buf.push('---');
-            i++;
-            continue;
-        }
-        if (t.type === 'html_block') {
-            if (t.map)
-                buf.push(sliceLines(lines, t.map));
-            i++;
-            continue;
-        }
-        // Generic open token (paragraph_open, bullet_list_open, ordered_list_open,
-        // blockquote_open, …): slice source by the open-token's line map and skip
-        // to the matching close.
-        if (t.type.endsWith('_open') && t.map) {
-            buf.push(sliceLines(lines, t.map));
-            i = findMatchingClose(tokens, i) + 1;
-            continue;
-        }
-        i++;
-    }
-    flushBuf();
-    return elements;
-}
-/** A single uploaded image rendered full-width (legacy single-image look). */
-function singleImgElement(imgKey) {
-    return { tag: 'img', img_key: imgKey, alt: { tag: 'plain_text', content: '' }, mode: 'fit_horizontal', preview: true };
-}
-/**
- * One row of N images side by side, each scaled to fit its column (aspect ratio
- * preserved — wide menu cards keep their full content, just smaller). A
- * `column_set` with equal weighted columns is used instead of the native
- * `img_combination` widget because the latter crops images to fill square-ish
- * cells, which would lop the sides off landscape images.
- */
-function imageRowElement(imgKeys) {
-    return {
-        tag: 'column_set',
-        flex_mode: 'none',
-        horizontal_spacing: 'small',
-        columns: imgKeys.map(k => ({
-            tag: 'column',
-            width: 'weighted',
-            weight: 1,
-            vertical_align: 'center',
-            elements: [singleImgElement(k)],
-        })),
-    };
-}
-/** A markdown image token: `![alt](src)`, capturing the src (img_key). */
-const IMG_TOKEN_SRC = /!\[[^\]]*\]\(([^)\s]+)\)/g;
-/**
- * A whole line that is nothing but 2+ image tokens (the "image row" form).
- * At most 3 leading spaces: a 4+-space indent is a CommonMark indented code
- * block, whose contents `markdown-it` protects — the pre-pass must not yank an
- * indented `![](k1) ![](k2)` line out of one and promote it to a native row.
- */
-const IMG_ROW_LINE = /^ {0,3}(?:!\[[^\]]*\]\([^)\s]+\)\s*){2,}$/;
-/**
- * Feishu-uploaded image keys look like `img_v2_<id>` / `img_v3_<id>` (the
- * `<id>` is alphanumerics, `-` and `_`). Only a line whose every src is a full
- * such key is promoted to a native `img` row — a model reply may emit a
- * `![](https://…) ![](…)` URL line (or other non-key src like `img_v2foo.png`),
- * and a native `img` element with a non-key as its "img_key" makes Feishu reject
- * the whole card. Non-key lines fall through to the markdown widget unchanged
- * (same as before this feature existed).
- */
-const FEISHU_IMG_KEY = /^img_v\d+_[A-Za-z0-9_-]+$/i;
-/**
- * Split a markdown body into segments, pulling out lines that consist solely of
- * 2+ image tokens as `imgrow` segments (→ side-by-side row). Fence-aware: lines
- * inside ``` / ~~~ code blocks are never treated as image rows.
- */
-function splitImageRowSegments(input) {
-    const segs = [];
-    let buf = [];
-    const flush = () => { if (buf.length) {
-        segs.push({ type: 'text', content: buf.join('\n') });
-        buf = [];
-    } };
-    // Track the open fence's char AND run length so a 4-backtick outer block
-    // isn't closed by an inner 3-backtick fence. Per CommonMark a closing fence
-    // is the same char, length ≥ the opening run, and nothing but whitespace
-    // after the run (no info string).
-    let fenceChar = '';
-    let fenceLen = 0;
-    for (const line of input.split('\n')) {
-        const fence = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
-        if (fence) {
-            const run = fence[1];
-            const ch = run[0];
-            if (!fenceChar) {
-                fenceChar = ch; // opening fence
-                fenceLen = run.length;
-            }
-            else if (ch === fenceChar && run.length >= fenceLen && fence[2].trim() === '') {
-                fenceChar = ''; // valid closing fence
-                fenceLen = 0;
-            }
-            buf.push(line);
-            continue;
-        }
-        if (!fenceChar && IMG_ROW_LINE.test(line)) {
-            const keys = Array.from(line.matchAll(IMG_TOKEN_SRC), m => m[1]);
-            if (keys.every(k => FEISHU_IMG_KEY.test(k))) {
-                flush();
-                segs.push({ type: 'imgrow', keys });
-                continue;
-            }
-        }
-        buf.push(line);
-    }
-    flush();
-    return segs;
-}
-/**
- * Build card body elements from a `botmux send` body whose images were uploaded
- * via `--images` and referenced by `![alt](img:N)` placeholders (`N` is the
- * 0-based --images index):
- *
- *   - `![](img:3)`    — single index → full-width inline image.
- *   - `![](img:0,1)`  — 2+ comma-separated indices → one row of images side by
- *                       side. Row width = group size: `img:0,1` two per row,
- *                       `img:0,1,2` three per row. Each placeholder is one row.
- *   - any image not named by a placeholder is appended full-width at the end.
- *
- * Placeholders are resolved to plain `![](img_key)` markdown (grouped ones onto
- * a single line) and handed to {@link buildCardBodyElements}, whose image-row
- * pre-pass turns multi-image lines into the actual `column_set` rows. This keeps
- * one rendering path: a caller that embeds `![](img_key)` directly and puts two
- * on a line (e.g. the menu poster) gets the same grid without using `--images`.
- */
-export function buildImageCardElements(md, imageKeys, cwd = process.cwd(), localHomeLinkMode = 'filesystem') {
-    if (imageKeys.length === 0)
-        return md ? buildCardBodyElements(md, cwd, localHomeLinkMode) : [];
-    const used = new Set();
-    const keyAt = (idx) => Number.isInteger(idx) && idx >= 0 && idx < imageKeys.length ? imageKeys[idx] : null;
-    // Grouped placeholder `![](img:0,1[,2…])` → space-joined image tokens on one
-    // line so the row pre-pass picks them up.
-    let resolved = md.replace(/!\[[^\]]*\]\(img:(\d+(?:\s*,\s*\d+)+)\)/g, (full, list) => {
-        const keys = [];
-        for (const part of list.split(',')) {
-            const idx = Number(part.trim());
-            const key = keyAt(idx);
-            if (key) {
-                used.add(idx);
-                keys.push(key);
-            }
-        }
-        if (keys.length === 0)
-            return full; // all out of range → literal
-        return keys.map(k => `![](${k})`).join(' ');
-    });
-    // Single-index placeholder `![alt](img:N)` → inline image (legacy).
-    resolved = resolved.replace(/!\[([^\]]*)\]\(img:(\d+)\)/g, (full, alt, idxStr) => {
-        const key = keyAt(Number(idxStr));
-        if (!key)
-            return full;
-        used.add(Number(idxStr));
-        return `![${alt}](${key})`;
-    });
-    // Trailing: images never referenced by any placeholder → single full-width,
-    // each on its own line (stacked, legacy behaviour).
-    const trailing = imageKeys.map((k, i) => (used.has(i) ? '' : `![](${k})`)).filter(Boolean).join('\n\n');
-    if (trailing)
-        resolved = resolved ? `${resolved}\n\n${trailing}` : trailing;
-    return buildCardBodyElements(resolved, cwd, localHomeLinkMode);
-}
-/**
- * Heuristic: does `text` contain markdown syntax that renders badly as plain
- * text in Feishu (code fences, headings, lists, bold, inline code, links,
- * tables, blockquotes, hr)? Callers use this to decide between an interactive
- * card and a plain post.
- */
-export function hasMarkdown(text) {
-    if (!text)
-        return false;
-    return (/```/.test(text) ||
-        /^#{1,6}\s/m.test(text) ||
-        /^\s{0,3}[-*+]\s+\S/m.test(text) ||
-        /^\s{0,3}\d+\.\s+\S/m.test(text) ||
-        /\*\*[^*\n]+\*\*/.test(text) ||
-        /(^|[^`])`[^`\n]+`([^`]|$)/.test(text) ||
-        /\[[^\]\n]+\]\([^)\n]+\)/.test(text) ||
-        /^\s*\|.+\|\s*$/m.test(text) ||
-        /^>\s/m.test(text) ||
-        /^(?:---|\*\*\*|___)\s*$/m.test(text));
-}
-/**
- * Build a complete Feishu interactive card (schema 2.0) from a markdown
- * body, with the same footer chrome `botmux send` uses: HR + small grey
- * brand segment + optional `发送给：@<owner>` mention.
- *
- * `recipientOpenId` (when given) renders as `<at id=…></at>` in the
- * footer — typically the session owner. Pass `undefined` to omit the
- * addressing line (e.g. top-level broadcasts have no specific recipient).
- *
- * `brand` is the sending bot's configured `brandLabel` (see
- * {@link brandFooterSegment}): unset → default botmux link, `''` → brand
- * suppressed, else custom. When brand, usage, and recipient are all absent the
- * whole footer (HR included) is omitted.
- */
-export function buildMarkdownCard(md, recipientOpenId, brand, locale, workingDir, localHomeLinkMode = 'filesystem', usage) {
-    const elements = md ? buildCardBodyElements(md, workingDir, localHomeLinkMode) : [];
-    const footer = buildReplyCardFooter({
-        brand,
-        recipientOpenIds: recipientOpenId ? [recipientOpenId] : [],
-        usage,
-        locale,
-    });
-    // No brand, usage, or recipient → no footer at all (skip the orphan HR too).
-    if (footer) {
-        elements.push({ tag: 'hr' });
-        elements.push(footer.element);
-    }
-    return JSON.stringify({
-        schema: '2.0',
-        config: { update_multi: true },
-        body: { direction: 'vertical', elements },
-    });
-}
-/** Prefix every line with `> ` so Feishu's markdown widget renders it as a
- *  blockquote even when the body contains blank lines. Empty lines become a
- *  bare `>` to keep the quote block contiguous. */
-function quoteLines(text) {
-    return text
-        .split('\n')
-        .map(line => (line.length === 0 ? '>' : `> ${line}`))
-        .join('\n');
-}
-/**
- * Build a contextual reply card: a title strip, an optional quoted user
- * prompt, and the assistant body rendered through the same markdown-it
- * pipeline as `buildMarkdownCard`. Used by:
- *   • `/adopt` 前最后一轮 preamble — surfaces the last turn of the
- *     adopted CLI session.
- *   • Local-terminal turns synced back to Lark — when the user types
- *     directly into the adopted pane, both sides of the exchange are
- *     posted so the thread sees a complete conversation.
- *
- * Empty `userText` is rendered as a `(空)` placeholder inside the quote so
- * the visual layout stays consistent; pass `undefined` to omit the user
- * section entirely (headless variant).
- */
-export function buildContextualReplyCard(opts) {
-    const { title, userText, assistantText, assistantLabel, recipientOpenId, brand, locale, workingDir, localHomeLinkMode = 'filesystem', usage, } = opts;
-    const elements = [];
-    elements.push({
-        tag: 'markdown',
-        text_size: 'heading_2_v2',
-        content: title,
-    });
-    if (userText !== undefined) {
-        const u = userText.trim();
-        elements.push({
-            tag: 'markdown',
-            content: `**👤 ${t('card.you', undefined, locale)}**\n\n${quoteLines(u || t('common.empty_paren', undefined, locale))}`,
-        });
-    }
-    elements.push({ tag: 'hr' });
-    elements.push({
-        tag: 'markdown',
-        content: `**🤖 ${assistantLabel}**`,
-    });
-    const bodyElements = assistantText.trim()
-        ? buildCardBodyElements(assistantText, workingDir, localHomeLinkMode)
-        : [{ tag: 'markdown', content: `*${t('common.empty_paren', undefined, locale)}*` }];
-    for (const el of bodyElements)
-        elements.push(el);
-    const footer = buildReplyCardFooter({
-        brand,
-        recipientOpenIds: recipientOpenId ? [recipientOpenId] : [],
-        usage,
-        locale,
-    });
-    if (footer) {
-        elements.push({ tag: 'hr' });
-        elements.push(footer.element);
-    }
-    return JSON.stringify({
-        schema: '2.0',
-        config: { update_multi: true },
-        body: { direction: 'vertical', elements },
-    });
-}
-//# sourceMappingURL=md-card.js.map