lark-remote 0.1.0

package/dist/card/card-budget.js

@@ -0,0 +1,280 @@
+import { truncateUtf8, truncateMarkdownTables, countMarkdownTables, FEISHU_MAX_TABLES, } from './text-truncate.js';
+// 飞书卡片大小限制（安全阈值，取 run-renderer 相同值）
+const CARD_BUDGET_BYTES = 28_000;
+/**
+ * 静态卡片体积保护
+ *
+ * @param card - 原始卡片 JSON
+ * @param opts - 裁剪选项
+ * @returns 裁剪后的卡片 + 是否发生了裁剪 + 原因 + 截断前后字节数
+ */
+export function enforceCardBudget(card, opts = {}) {
+    // ========== 阶段0：table 数量保护（独立于字节预算） ==========
+    // 飞书 11310 限制：单卡 markdown table >5 就报错。此维度与字节数正交——
+    // 小体积可以含很多 table，大体积可以没有 table。必须在字节检查之前独立判断。
+    const cardStr = JSON.stringify(card);
+    const bytesBefore = Buffer.byteLength(cardStr, 'utf8');
+    const totalTables = countCardTables(JSON.parse(cardStr));
+    if (totalTables > FEISHU_MAX_TABLES) {
+        // 深拷贝后对每个 lark_md 文本做 truncateMarkdownTables
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const fixed = JSON.parse(cardStr);
+        truncateCardMarkdownTables(fixed);
+        const fixedStr = JSON.stringify(fixed);
+        // table 截断后可能仍超字节预算，继续走后续阶段
+        if (Buffer.byteLength(fixedStr, 'utf8') <= CARD_BUDGET_BYTES) {
+            return {
+                card: fixed,
+                wasTruncated: true,
+                reason: 'table_count_limited',
+                bytesBefore,
+                bytesAfter: Buffer.byteLength(fixedStr, 'utf8'),
+            };
+        }
+        // table 修好了但字节仍超，用 fixed 作为后续处理的起点
+        return enforceByteBudget(fixed, opts, bytesBefore);
+    }
+    if (bytesBefore <= CARD_BUDGET_BYTES) {
+        return { card, wasTruncated: false, bytesBefore, bytesAfter: bytesBefore };
+    }
+    // 字节超限但 table 不超限
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return enforceByteBudget(JSON.parse(cardStr), opts, bytesBefore);
+}
+/**
+ * Byte-budget enforcement, extracted so table-limit fix can delegate to it
+ * when table truncation alone doesn't bring the card under the byte limit.
+ *
+ * 裁剪判定是**结构化**的：所有 collapsible_panel 都是待裁剪对象，不看面板
+ * 标题文本。历史教训（2026-08-08，详见
+ * docs/zh/architecture/resume-card-budget-failure-analysis.md）：旧实现用
+ * emoji 标题模式（🤖👤💭🔧🟢🔴）识别「会话事件面板」，但真实
+ * sessionEventPanel 产出的标题是裸英文 type 名（emoji 在事件正文而非标题），
+ * 导致裁剪阶段对真实 resume 卡零命中，任何 >28KB 的卡片无裁剪直通极端降级，
+ * 整卡被替换成一句话。
+ *
+ * 渐进式降级（每级仍超限才进入下一级）：
+ *   阶段1 逐面板截断内容（maxPanelContentBytes）
+ *   阶段2 限制面板数量（删除最老，maxEventPanels）
+ *   阶段3 丢弃全部面板，保留骨架（header/usage/按钮）+ 省略提示
+ *   阶段4 截断剩余顶层 div 文本
+ *   阶段5 最终兜底 minimal card（骨架本身已超限的病理场景）
+ */
+function enforceByteBudget(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+truncated, opts = {}, bytesBefore) {
+    const { maxEventPanels = 5, maxPanelContentBytes = 2000, truncationHint = '📜 还有 {count} 个事件未显示', } = opts;
+    const reasons = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const elements = truncated.body?.elements ?? [];
+    const size = () => Buffer.byteLength(JSON.stringify(truncated), 'utf8');
+    const done = (wasTruncated) => ({
+        card: truncated,
+        wasTruncated,
+        reason: reasons.join('+') || undefined,
+        bytesBefore: bytesBefore ?? size(),
+        bytesAfter: size(),
+    });
+    // ========== 阶段1：裁剪所有面板的内容 ==========
+    let modifications = 0;
+    for (const el of elements) {
+        if (el.tag !== 'collapsible_panel')
+            continue;
+        for (const inner of el.elements ?? []) {
+            if (inner.tag === 'div' && inner.text?.content) {
+                const content = inner.text.content;
+                if (Buffer.byteLength(content, 'utf8') > maxPanelContentBytes) {
+                    inner.text.content = truncateUtf8(content, maxPanelContentBytes);
+                    modifications++;
+                }
+            }
+        }
+    }
+    if (modifications > 0) {
+        reasons.push('panel_content_truncated');
+    }
+    // ========== 阶段2：限制面板数量（删除最老） ==========
+    let omitted = 0;
+    const dropOldestPanels = (count) => {
+        const indices = getPanelIndices(elements)
+            .slice(0, count)
+            .sort((a, b) => b - a);
+        for (const idx of indices) {
+            elements.splice(idx, 1);
+            omitted++;
+        }
+    };
+    const panelCount = getPanelIndices(elements).length;
+    if (panelCount > maxEventPanels) {
+        dropOldestPanels(panelCount - maxEventPanels);
+        reasons.push('event_count_limited');
+    }
+    if (size() <= CARD_BUDGET_BYTES) {
+        insertOmittedHint(elements, omitted, truncationHint);
+        return done(modifications > 0 || omitted > 0);
+    }
+    // ========== 阶段3：丢弃全部面板，保留卡片骨架 ==========
+    // header（cwd/sessionId/标题）、usage、操作按钮等信息量高、体积小的元素
+    // 必须保留——整卡替换为一句话是信息损失最大的降级方式。
+    dropOldestPanels(getPanelIndices(elements).length);
+    if (omitted > 0) {
+        reasons.push('panels_dropped');
+    }
+    if (size() <= CARD_BUDGET_BYTES) {
+        insertOmittedHint(elements, omitted, truncationHint);
+        return done(true);
+    }
+    // ========== 阶段4：截断剩余顶层 div 文本 ==========
+    // 骨架元素（header/usage 等）自身超限的情况（如超大 displayTitle）。
+    insertOmittedHint(elements, omitted, truncationHint);
+    let textTruncations = 0;
+    for (const el of elements) {
+        if (el.tag === 'div' && el.text?.content) {
+            const content = el.text.content;
+            if (Buffer.byteLength(content, 'utf8') > maxPanelContentBytes) {
+                el.text.content = truncateUtf8(content, maxPanelContentBytes);
+                textTruncations++;
+            }
+        }
+    }
+    if (textTruncations > 0) {
+        reasons.push('text_truncated');
+    }
+    if (size() <= CARD_BUDGET_BYTES) {
+        return done(true);
+    }
+    // ========== 阶段5：最终兜底（原 extreme_fallback） ==========
+    const minimalCard = {
+        schema: '2.0',
+        config: { wide_screen_mode: true },
+        header: {
+            template: 'orange',
+            title: { tag: 'plain_text', content: '⚠️ 内容已截断' },
+        },
+        body: {
+            elements: [
+                {
+                    tag: 'div',
+                    text: {
+                        tag: 'lark_md',
+                        content: '会话内容过大，已自动截断。\n\n请使用 `/active` 查看完整列表。',
+                    },
+                },
+            ],
+        },
+    };
+    return {
+        card: minimalCard,
+        wasTruncated: true,
+        reason: 'extreme_fallback',
+        bytesBefore: bytesBefore ?? size(),
+        bytesAfter: Buffer.byteLength(JSON.stringify(minimalCard), 'utf8'),
+    };
+}
+/**
+ * 在卡片头部插入「N 个事件未显示」提示（仅在有面板被移除时）。
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function insertOmittedHint(elements, omitted, truncationHint) {
+    if (omitted <= 0)
+        return;
+    elements.unshift({
+        tag: 'div',
+        text: { tag: 'lark_md', content: truncationHint.replace('{count}', String(omitted)) },
+    });
+}
+/**
+ * 获取所有 collapsible_panel 的索引（结构化判定，不看标题文本）。
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getPanelIndices(elements) {
+    const indices = [];
+    for (let i = 0; i < elements.length; i++) {
+        if (elements[i].tag === 'collapsible_panel') {
+            indices.push(i);
+        }
+    }
+    return indices;
+}
+/**
+ * Count all markdown tables across every lark_md text field in a card JSON.
+ * Recursively walks elements, collapsible_panel.elements, column.elements, etc.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function countCardTables(card) {
+    let total = 0;
+    const elements = card?.body?.elements ?? [];
+    for (const el of elements) {
+        total += countElementTables(el);
+    }
+    return total;
+}
+/**
+ * Recursively count markdown tables in a single element and its children.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function countElementTables(el) {
+    let count = 0;
+    // lark_md div text
+    if (el.text?.tag === 'lark_md' && typeof el.text.content === 'string') {
+        count += countMarkdownTables(el.text.content);
+    }
+    // collapsible_panel inner elements
+    if (Array.isArray(el.elements)) {
+        for (const child of el.elements) {
+            count += countElementTables(child);
+        }
+    }
+    // column_set → columns → elements
+    if (Array.isArray(el.columns)) {
+        for (const col of el.columns) {
+            if (Array.isArray(col.elements)) {
+                for (const child of col.elements) {
+                    count += countElementTables(child);
+                }
+            }
+        }
+    }
+    return count;
+}
+/**
+ * In-place truncate markdown tables in every lark_md text field of a card,
+ * keeping at most FEISHU_MAX_TABLES per field.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function truncateCardMarkdownTables(card) {
+    const elements = card?.body?.elements ?? [];
+    for (const el of elements) {
+        truncateElementTables(el);
+    }
+}
+/**
+ * Recursively truncate markdown tables in a single element and its children.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function truncateElementTables(el) {
+    // lark_md div text
+    if (el.text?.tag === 'lark_md' && typeof el.text.content === 'string') {
+        const truncated = truncateMarkdownTables(el.text.content);
+        if (truncated !== el.text.content) {
+            el.text.content = truncated;
+        }
+    }
+    // collapsible_panel inner elements
+    if (Array.isArray(el.elements)) {
+        for (const child of el.elements) {
+            truncateElementTables(child);
+        }
+    }
+    // column_set → columns → elements
+    if (Array.isArray(el.columns)) {
+        for (const col of el.columns) {
+            if (Array.isArray(col.elements)) {
+                for (const child of col.elements) {
+                    truncateElementTables(child);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=card-budget.js.map

package/dist/card/card-session.d.ts

@@ -0,0 +1,83 @@
+import type { CardStreamController, CardStreamProducer } from '@larksuite/channel';
+/**
+ * Unified channel interface for streaming card sessions.
+ */
+export interface CardChannel {
+    streamCard(chatId: string, initial: object, producer: CardStreamProducer, opts?: {
+        replyTo?: string;
+    }): Promise<string>;
+    updateCard(messageId: string, card: object): Promise<void>;
+}
+export type StreamSettleResult = 'streamed' | 'updated' | 'unsent';
+/**
+ * Base class for single-card streaming sessions (RunCardSession, BashCardSession).
+ * Provides the shared lifecycle: start → (push/update) → finish → settle.
+ *
+ * Subclasses must implement `renderCard()` to produce the card JSON for their
+ * specific state type, and `logPrefix` / `errorPrefix` for differentiated
+ * log and error messages.
+ */
+export declare abstract class CardSession<S, RO = unknown> {
+    protected readonly connector: CardChannel;
+    protected readonly chatId: string;
+    protected readonly replyTo?: string;
+    protected readonly renderOptions: RO;
+    protected readonly startTimeoutMs: number;
+    protected readonly settleTimeoutMs: number;
+    protected state: S;
+    protected controller?: CardStreamController;
+    protected messageId?: string;
+    protected streamOutcome?: Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        error: unknown;
+    }>;
+    private releaseProducer;
+    private readonly producerReleased;
+    private resolveController;
+    private rejectController;
+    private readonly controllerReady;
+    private released;
+    /** Log prefix for differentiated messages (e.g. '[card]' vs '[bash-card]'). */
+    protected abstract get logPrefix(): string;
+    /** Prefix for timeout error messages (e.g. 'card' vs 'bash card'). */
+    protected abstract get errorPrefix(): string;
+    /** Render the current state into a card JSON object. */
+    protected abstract renderCard(state: S, options: RO): object;
+    constructor(initialState: S, opts: {
+        connector: CardChannel;
+        chatId: string;
+        replyTo?: string;
+        renderOptions?: RO;
+        startTimeoutMs?: number;
+        settleTimeoutMs?: number;
+    });
+    get currentState(): S;
+    /** The messageId of the streaming card, available after `start()` resolves. */
+    get cardMessageId(): string | undefined;
+    start(): Promise<void>;
+    settle(): Promise<StreamSettleResult>;
+    /**
+     * Whether renderCard() already enforces a size budget (so updateCard can
+     * skip enforceCardBudget). Subclasses whose renderer has its own
+     * stringify-level budget protection (e.g. RunCardSession via degraded/
+     * extreme fallback) should override this to return true.
+     */
+    protected hasOwnBudgetProtection(): boolean;
+    /**
+     * Render the current card and apply stringify-level budget enforcement unless
+     * the subclass renderer has its own budget protection. Centralizes the budget
+     * decision so start()/updateCard()/settle() stay symmetric — previously only
+     * updateCard() guarded, while start() producer and settle() fallback sent bare
+     * renderCard output (risking >28KB for BashCardSession, which has no own
+     * stringify-level safety net).
+     */
+    protected safeRenderCard(): object;
+    /**
+     * Push an update to the card. Tries controller.update first, falls back to
+     * connector.updateCard if the controller is unavailable or fails.
+     */
+    protected updateCard(): Promise<void>;
+    protected release(): void;
+}

package/dist/card/card-session.js

@@ -0,0 +1,185 @@
+import { getLogger } from '../logger/index.js';
+import { enforceCardBudget } from './card-budget.js';
+/**
+ * Base class for single-card streaming sessions (RunCardSession, BashCardSession).
+ * Provides the shared lifecycle: start → (push/update) → finish → settle.
+ *
+ * Subclasses must implement `renderCard()` to produce the card JSON for their
+ * specific state type, and `logPrefix` / `errorPrefix` for differentiated
+ * log and error messages.
+ */
+export class CardSession {
+    connector;
+    chatId;
+    replyTo;
+    renderOptions;
+    startTimeoutMs;
+    settleTimeoutMs;
+    state;
+    controller;
+    messageId;
+    streamOutcome;
+    releaseProducer;
+    producerReleased;
+    resolveController;
+    rejectController;
+    controllerReady;
+    released = false;
+    constructor(initialState, opts) {
+        this.state = initialState;
+        this.connector = opts.connector;
+        this.chatId = opts.chatId;
+        this.replyTo = opts.replyTo;
+        this.renderOptions = opts.renderOptions ?? {};
+        this.startTimeoutMs = opts.startTimeoutMs ?? 5_000;
+        this.settleTimeoutMs = opts.settleTimeoutMs ?? 5_000;
+        this.producerReleased = new Promise((resolve) => {
+            this.releaseProducer = resolve;
+        });
+        this.controllerReady = new Promise((resolve, reject) => {
+            this.resolveController = resolve;
+            this.rejectController = reject;
+        });
+    }
+    get currentState() {
+        return this.state;
+    }
+    /** The messageId of the streaming card, available after `start()` resolves. */
+    get cardMessageId() {
+        return this.messageId;
+    }
+    async start() {
+        if (this.streamOutcome) {
+            // 二次调用也套 timeout 保护：若 controllerReady 永不 settle（首次超时失败），
+            // 不能永久挂起。复用同样的 startTimeoutMs 超时。streamOutcome 已存在，
+            // 不重复创建 stream。
+            let timer;
+            const timeout = new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`${this.errorPrefix} stream start timeout`)), this.startTimeoutMs);
+            });
+            try {
+                await Promise.race([this.controllerReady, timeout]);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+            return;
+        }
+        // NOTE: the two renderCard calls below are NOT redundant. The streamCard
+        // `initial` payload is evaluated EAGERLY (at start time, before any event
+        // has arrived), while the producer's `controller.update` runs LAZILY after
+        // the controller is ready — by which time events pushed before the
+        // producer ran (see test_anchor_events_before_controller_ready_...) have
+        // already updated `this.state`. Reusing the initial card here would drop
+        // those early events. The P3-7 "reuse first render" optimization was
+        // rejected for this reason (premise "two renders with identical input"
+        // does not hold).
+        const stream = this.connector.streamCard(this.chatId, this.safeRenderCard(), async (controller) => {
+            this.controller = controller;
+            this.messageId = controller.messageId;
+            try {
+                await controller.update(this.safeRenderCard());
+            }
+            catch (error) {
+                getLogger().warn(`${this.logPrefix} initial controller update failed:`, error);
+            }
+            this.resolveController();
+            await this.producerReleased;
+        }, { replyTo: this.replyTo });
+        this.streamOutcome = stream.then(() => ({ ok: true }), (error) => {
+            if (!this.controller)
+                this.rejectController(error);
+            return { ok: false, error };
+        });
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`${this.errorPrefix} stream start timeout`)), this.startTimeoutMs);
+        });
+        try {
+            await Promise.race([this.controllerReady, timeout]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    async settle() {
+        this.release();
+        if (!this.streamOutcome)
+            return 'unsent';
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = setTimeout(() => resolve({ ok: false, error: new Error(`${this.errorPrefix} stream settle timeout`) }), this.settleTimeoutMs);
+        });
+        const outcome = await Promise.race([this.streamOutcome, timeout]);
+        if (timer)
+            clearTimeout(timer);
+        if (outcome.ok)
+            return 'streamed';
+        getLogger().warn(`${this.logPrefix} stream did not complete cleanly:`, outcome.error);
+        if (!this.messageId)
+            return 'unsent';
+        try {
+            await this.connector.updateCard(this.messageId, this.safeRenderCard());
+            return 'updated';
+        }
+        catch (error) {
+            getLogger().error(`${this.logPrefix} failed to finalize original card:`, error);
+            return 'unsent';
+        }
+    }
+    /**
+     * Whether renderCard() already enforces a size budget (so updateCard can
+     * skip enforceCardBudget). Subclasses whose renderer has its own
+     * stringify-level budget protection (e.g. RunCardSession via degraded/
+     * extreme fallback) should override this to return true.
+     */
+    hasOwnBudgetProtection() {
+        return false;
+    }
+    /**
+     * Render the current card and apply stringify-level budget enforcement unless
+     * the subclass renderer has its own budget protection. Centralizes the budget
+     * decision so start()/updateCard()/settle() stay symmetric — previously only
+     * updateCard() guarded, while start() producer and settle() fallback sent bare
+     * renderCard output (risking >28KB for BashCardSession, which has no own
+     * stringify-level safety net).
+     */
+    safeRenderCard() {
+        const card = this.renderCard(this.state, this.renderOptions);
+        return this.hasOwnBudgetProtection() ? card : enforceCardBudget(card).card;
+    }
+    /**
+     * Push an update to the card. Tries controller.update first, falls back to
+     * connector.updateCard if the controller is unavailable or fails.
+     */
+    async updateCard() {
+        const safeCard = this.safeRenderCard();
+        if (this.controller) {
+            try {
+                await this.controller.update(safeCard);
+                return;
+            }
+            catch (error) {
+                getLogger().warn(`${this.logPrefix} controller update failed; finalization will retry:`, error);
+            }
+        }
+        // Fallback: try updateCard when controller is unavailable or update failed
+        if (this.messageId) {
+            try {
+                await this.connector.updateCard(this.messageId, safeCard);
+            }
+            catch (error) {
+                getLogger().warn(`${this.logPrefix} updateCard fallback failed:`, error);
+            }
+        }
+    }
+    release() {
+        if (this.released)
+            return;
+        this.released = true;
+        this.releaseProducer();
+    }
+}
+//# sourceMappingURL=card-session.js.map

package/dist/card/card-shared.d.ts

@@ -0,0 +1,28 @@
+interface TruncateOptions {
+    suffix?: string;
+    normalizeWhitespace?: boolean;
+}
+/**
+ * Display name for an agent kind in the run card header.
+ *
+ * Reads from the global `AgentRegistry` (set up in `index.ts` at startup)
+ * when available. Falls back to a hardcoded map for callers that don't
+ * wire up the registry (notably unit tests of pure render helpers).
+ */
+export declare function agentDisplayName(kind: string): string;
+export declare function truncate(str: string, max: number, options?: TruncateOptions): string;
+interface TerminalLabelOptions {
+    prefix?: string;
+}
+export declare function terminalToLabel(terminal: string, options?: TerminalLabelOptions): string;
+export declare function terminalToColor(terminal: string): string;
+/**
+ * Create a CardKit 2.0 stop button with behaviors callback.
+ */
+export declare function stopButton(runId: string): object;
+/**
+ * Create a CardKit 2.0 "new session" button with behaviors callback.
+ * Standardized: ✨ 新会话 + primary type
+ */
+export declare function newSessionButton(): object;
+export {};

package/dist/card/card-shared.js

@@ -0,0 +1,99 @@
+import { AgentRegistry } from '../runner/index.js';
+/**
+ * Display name for an agent kind in the run card header.
+ *
+ * Reads from the global `AgentRegistry` (set up in `index.ts` at startup)
+ * when available. Falls back to a hardcoded map for callers that don't
+ * wire up the registry (notably unit tests of pure render helpers).
+ */
+export function agentDisplayName(kind) {
+    const globalReg = AgentRegistry.getGlobalInstance();
+    if (globalReg) {
+        return globalReg.getDisplayName(kind);
+    }
+    // Fallback: hardcoded default mapping for unit tests that exercise
+    // render helpers without booting the full AgentRegistry.
+    if (kind === 'claude')
+        return 'Claude';
+    if (kind === 'codex')
+        return 'Codex';
+    if (kind === 'opencode')
+        return 'Opencode';
+    if (kind === 'pi')
+        return 'Pi';
+    if (kind === 'kimi')
+        return 'Kimi';
+    return kind;
+}
+export function truncate(str, max, options) {
+    const suffix = options?.suffix ?? '…';
+    const normalize = options?.normalizeWhitespace ?? false;
+    let s = str;
+    if (normalize)
+        s = s.replace(/\s+/g, ' ').trim();
+    if (s.length <= max)
+        return s;
+    const suffixLen = suffix.length;
+    const budget = max - suffixLen;
+    if (budget <= 0)
+        return suffix;
+    let end = 0;
+    for (const ch of s) {
+        if (end + ch.length > budget)
+            break;
+        end += ch.length;
+    }
+    return s.slice(0, end) + suffix;
+}
+const TERMINAL_LABELS = {
+    done: '已完成',
+    error: '出错',
+    interrupted: '已终止',
+    idle_timeout: '已超时',
+    running: '运行中',
+    finalizing: '完成中',
+};
+export function terminalToLabel(terminal, options) {
+    const label = TERMINAL_LABELS[terminal] ?? '运行中';
+    const prefix = options?.prefix ?? '';
+    return prefix + label;
+}
+export function terminalToColor(terminal) {
+    if (terminal === 'done')
+        return 'green';
+    if (terminal === 'error')
+        return 'red';
+    if (terminal === 'interrupted')
+        return 'grey';
+    if (terminal === 'idle_timeout')
+        return 'orange';
+    if (terminal === 'finalizing')
+        return 'orange';
+    if (terminal === 'running')
+        return 'blue';
+    return 'red';
+}
+/**
+ * Create a CardKit 2.0 stop button with behaviors callback.
+ */
+export function stopButton(runId) {
+    return {
+        tag: 'button',
+        text: { content: '⏹ 停止' },
+        type: 'danger',
+        behaviors: [{ type: 'callback', value: { cmd: 'stop', runId } }],
+    };
+}
+/**
+ * Create a CardKit 2.0 "new session" button with behaviors callback.
+ * Standardized: ✨ 新会话 + primary type
+ */
+export function newSessionButton() {
+    return {
+        tag: 'button',
+        text: { content: '✨ 新会话' },
+        type: 'primary',
+        behaviors: [{ type: 'callback', value: { cmd: 'new-session' } }],
+    };
+}
+//# sourceMappingURL=card-shared.js.map