dsh-lark-agent 0.1.2 → 0.2.0

package/dist/live-reply.js

@@ -0,0 +1,389 @@
+import { cardMarkdown, markdownBlocks, plainLabel } from './replies.js';
+// CardKit rejects cards over 30 KB, measured on the card JSON.
+const CARD_BYTES = 28_000;
+const LIVE_STEP_BYTES = 6_000;
+const LIVE_ANSWER_BYTES = 20_000;
+const FINAL_STEP_BYTES = 8_000;
+const MAX_KEPT_CHARS = 40_000;
+// One card entity accepts at most 10 operations per second.
+const STREAM_INTERVAL_MS = 500;
+const FULL_INTERVAL_MS = 2_000;
+// Feishu turns streaming mode off 10 minutes after it was last turned on.
+const REOPEN_AFTER_MS = 9 * 60_000;
+const TRUNCATED = '回复超过了飞书卡片的长度上限，后面的内容没有显示。完整回复在电脑上的这段 Harness 会话里，也可以让我整理成文档。';
+const grey = (markdown) => `<font color='grey'>${markdown}</font>`;
+const bytes = (value) => Buffer.byteLength(typeof value === 'string' ? value : JSON.stringify(value), 'utf8');
+const code = (value) => '`' + value.replace(/`/g, 'ˋ') + '`';
+/** The longest prefix of text within maxBytes, never splitting a code point. */
+function head(text, maxBytes) {
+    let size = 0, end = 0;
+    for (const point of text) {
+        size += Buffer.byteLength(point, 'utf8');
+        if (size > maxBytes)
+            break;
+        end += point.length;
+    }
+    return text.slice(0, end);
+}
+/**
+ * A suffix of text within maxBytes. The cut moves in coarse steps so that
+ * successive updates mostly share a prefix, which keeps Feishu's typewriter
+ * effect instead of redrawing the whole element.
+ */
+function tail(text, maxBytes) {
+    if (bytes(text) <= maxBytes)
+        return text;
+    let size = 0, start = text.length;
+    while (start > 0) {
+        const pair = start >= 2 && (text.charCodeAt(start - 1) & 0xfc00) === 0xdc00 && (text.charCodeAt(start - 2) & 0xfc00) === 0xd800;
+        const width = Buffer.byteLength(text.slice(start - (pair ? 2 : 1), start), 'utf8');
+        if (size + width > maxBytes)
+            break;
+        size += width;
+        start -= pair ? 2 : 1;
+    }
+    let cut = Math.ceil(start / 1_000) * 1_000;
+    const newline = text.indexOf('\n', cut);
+    if (newline >= 0 && newline - cut < 200)
+        cut = newline + 1;
+    if (cut < text.length && (text.charCodeAt(cut) & 0xfc00) === 0xdc00)
+        cut++;
+    return text.slice(Math.min(cut, text.length));
+}
+/**
+ * One streaming reply card: the answer, with reasoning and tool steps in a
+ * panel that stays folded unless the reader opens it. Only the initial reply
+ * is a send; every later operation updates the same card entity and is safe
+ * to supersede or repeat. A reply never continues in another message.
+ */
+export class LiveReply {
+    transport;
+    target;
+    options;
+    phase = 'thinking';
+    steps = [];
+    trimmed = false;
+    answer = '';
+    separator = false;
+    mark = { steps: 0, tail: -1, answer: 0 };
+    tools = 0;
+    note;
+    cardId;
+    sequence = 0;
+    sent = new Map();
+    dirty = false;
+    layoutDirty = false;
+    degraded = false;
+    streamFailures = 0;
+    closed = false;
+    loop;
+    wake;
+    streamingSince = 0;
+    startedAt;
+    answeredAt;
+    finishedAt;
+    constructor(transport, target, options = {}) {
+        this.transport = transport;
+        this.target = target;
+        this.options = options;
+        this.startedAt = this.now();
+    }
+    /** Send the card. False means nothing was sent, so the caller keeps its ordinary reply. */
+    async open() {
+        try {
+            this.cardId = await this.transport.createCardEntity(this.card());
+        }
+        catch {
+            this.audit('live-card-unavailable');
+            return false;
+        }
+        this.streamingSince = this.now();
+        this.markSent();
+        try {
+            await this.transport.replyCardEntity(this.target.messageId, this.cardId, { idempotencyKey: this.target.idempotencyKey, inThread: this.target.inThread });
+        }
+        // The reply may still have been delivered. Never send another message for this
+        // turn; updating a card nobody received is harmless.
+        catch {
+            this.audit('live-card-delivery-unknown');
+        }
+        if (this.dirty)
+            this.schedule();
+        return true;
+    }
+    push(event) {
+        if (this.closed)
+            return;
+        switch (event.type) {
+            case 'attempt': {
+                const last = this.steps.at(-1);
+                this.mark = { steps: this.steps.length, tail: last?.kind === 'reasoning' ? last.text.length : -1, answer: this.answer.length };
+                this.separator = this.answer.length > 0;
+                break;
+            }
+            case 'discard': {
+                this.steps.length = Math.min(this.steps.length, this.mark.steps);
+                const last = this.steps.at(-1);
+                if (this.mark.tail >= 0 && last?.kind === 'reasoning')
+                    last.text = last.text.slice(0, this.mark.tail);
+                this.answer = this.answer.slice(0, this.mark.answer);
+                this.separator = this.answer.length > 0;
+                break;
+            }
+            case 'reasoning': {
+                const last = this.steps.at(-1);
+                if (last?.kind === 'reasoning')
+                    last.text += event.text;
+                else
+                    this.steps.push({ kind: 'reasoning', text: event.text });
+                this.trim();
+                break;
+            }
+            case 'text':
+                if (this.answer.length > 70_000)
+                    return;
+                if (this.separator) {
+                    this.answer += '\n\n';
+                    this.separator = false;
+                }
+                this.answer += event.text;
+                // The folded panel's title switches from "thinking" to the time it took.
+                if (this.phase === 'thinking') {
+                    this.phase = 'answering';
+                    this.answeredAt = this.now();
+                    this.layoutDirty = true;
+                }
+                break;
+            case 'tool':
+                if (this.steps.some(step => step.kind === 'tool' && step.callId === event.callId))
+                    return;
+                this.steps.push({ kind: 'tool', callId: event.callId, name: event.name, ...(event.detail ? { detail: event.detail } : {}), state: 'running' });
+                this.tools++;
+                this.layoutDirty = true;
+                this.trim();
+                break;
+            case 'tool-done': {
+                const step = this.steps.find(item => item.kind === 'tool' && item.callId === event.callId);
+                if (step?.kind !== 'tool')
+                    return;
+                step.state = event.ok ? 'done' : 'failed';
+                break;
+            }
+        }
+        this.schedule();
+    }
+    /** Stop streaming and write the final card. True only when Feishu confirmed it. */
+    async finish(final) {
+        if (this.closed)
+            return false;
+        this.closed = true;
+        this.wake?.();
+        await this.loop;
+        this.finishedAt = this.now();
+        this.phase = final.phase;
+        if (final.answer !== undefined)
+            this.answer = final.answer;
+        if (final.reasoning && !this.steps.some(step => step.kind === 'reasoning'))
+            this.steps.unshift({ kind: 'reasoning', text: final.reasoning });
+        for (const step of this.steps)
+            if (step.kind === 'tool' && step.state === 'running')
+                step.state = final.phase === 'done' ? 'done' : 'failed';
+        this.note = final.note;
+        const card = this.finalCard();
+        if (!this.cardId)
+            return false;
+        for (let attempt = 0; attempt < 3; attempt++) {
+            try {
+                await this.transport.updateCardEntity(this.cardId, card, ++this.sequence);
+                return true;
+            }
+            catch {
+                if (attempt < 2)
+                    await this.sleep(500 * 3 ** attempt);
+            }
+        }
+        this.audit('live-card-final-failed');
+        return false;
+    }
+    now() { return (this.options.now ?? Date.now)(); }
+    sleep(ms) { return (this.options.sleep ?? (wait => new Promise(done => setTimeout(done, wait))))(ms); }
+    audit(stage) { try {
+        this.options.audit?.(stage);
+    }
+    catch { /* Diagnostics only. */ } }
+    /** Keep only what the card can still show; the turn result stays authoritative. */
+    trim() {
+        let total = this.steps.reduce((sum, step) => sum + (step.kind === 'reasoning' ? step.text.length : 200), 0);
+        while (total > MAX_KEPT_CHARS && this.steps.length > 1) {
+            const removed = this.steps.shift();
+            total -= removed.kind === 'reasoning' ? removed.text.length : 200;
+            this.mark.steps = Math.max(0, this.mark.steps - 1);
+            this.trimmed = true;
+        }
+        const only = this.steps[0];
+        if (this.steps.length === 1 && only?.kind === 'reasoning' && only.text.length > MAX_KEPT_CHARS) {
+            const cut = only.text.length - MAX_KEPT_CHARS / 2;
+            only.text = only.text.slice(cut);
+            this.mark.tail = Math.max(-1, this.mark.tail - cut);
+            this.trimmed = true;
+        }
+    }
+    schedule() {
+        this.dirty = true;
+        if (!this.cardId || this.closed || this.loop)
+            return;
+        this.loop = this.run().finally(() => {
+            this.loop = undefined;
+            if (this.dirty && !this.closed)
+                this.schedule();
+        });
+    }
+    async run() {
+        while (this.dirty && !this.closed) {
+            this.dirty = false;
+            const started = this.now();
+            await this.flush();
+            const wait = (this.degraded ? FULL_INTERVAL_MS : STREAM_INTERVAL_MS) - (this.now() - started);
+            if (wait > 0 && !this.closed)
+                await this.pause(wait);
+        }
+    }
+    /** Pacing between updates; finishing the reply ends it early. */
+    async pause(ms) {
+        await Promise.race([this.sleep(ms), new Promise(done => { this.wake = done; })]);
+        this.wake = undefined;
+    }
+    async flush() {
+        const cardId = this.cardId;
+        if (this.degraded || this.layoutDirty || this.now() - this.streamingSince > REOPEN_AFTER_MS) {
+            this.layoutDirty = false;
+            try {
+                // A complete card also turns streaming mode back on.
+                await this.transport.updateCardEntity(cardId, this.card(), ++this.sequence);
+                this.streamingSince = this.now();
+                this.markSent();
+                this.degraded = this.streamFailures >= 3;
+            }
+            catch {
+                this.degraded = true;
+            }
+            return;
+        }
+        for (const [id, content] of [['think', this.thinkContent()], ['answer', this.answerContent()]]) {
+            if (this.closed)
+                return;
+            if (this.sent.get(id) === content)
+                continue;
+            try {
+                await this.transport.streamCardText(cardId, id, content, ++this.sequence);
+                this.sent.set(id, content);
+            }
+            catch {
+                this.streamFailures++;
+                this.degraded = true;
+                this.audit('live-card-degraded');
+                return;
+            }
+        }
+    }
+    markSent() {
+        this.sent.set('think', this.thinkContent());
+        this.sent.set('answer', this.answerContent());
+    }
+    stepsMarkdown(maxBytes) {
+        const parts = this.steps.map(step => step.kind === 'reasoning' ? cardMarkdown(step.text.trim())
+            : `${step.state === 'running' ? '⏳' : step.state === 'done' ? '✅' : '⚠️'} ${code(step.name)}${step.detail ? ' ' + code(step.detail) : ''}`)
+            .filter(Boolean);
+        const text = parts.join('\n\n');
+        const shown = tail(text, maxBytes);
+        return (this.trimmed || shown.length < text.length) && shown ? `${grey('…')}\n${shown}` : shown;
+    }
+    thinkContent() {
+        return this.stepsMarkdown(LIVE_STEP_BYTES) || grey('正在思考…');
+    }
+    answerContent() {
+        if (!this.answer)
+            return grey('…');
+        const shown = head(this.answer, LIVE_ANSWER_BYTES);
+        return cardMarkdown(shown) + (shown.length < this.answer.length ? `\n\n${grey('……')}` : '');
+    }
+    panelTitle() {
+        const tools = this.tools ? ` · 使用工具 ${this.tools} 次` : '';
+        if (this.phase === 'thinking')
+            return `💭 思考中…${tools}`;
+        const seconds = Math.max(1, Math.round(((this.answeredAt ?? this.finishedAt ?? this.now()) - this.startedAt) / 1000));
+        return `💭 思考了 ${seconds} 秒${tools}`;
+    }
+    /** The folded process panel. Readers open it when they want the reasoning and tool steps. */
+    panel(content) {
+        return {
+            tag: 'collapsible_panel', element_id: 'think_panel', expanded: false,
+            header: { title: { tag: 'markdown', content: this.panelTitle() }, vertical_align: 'center',
+                icon: { tag: 'standard_icon', token: 'down-small-ccm_outlined', size: '16px 16px' }, icon_position: 'follow_text', icon_expanded_angle: -180 },
+            border: { color: 'grey', corner_radius: '5px' }, vertical_spacing: '8px', padding: '8px 8px 8px 8px',
+            elements: [{ tag: 'markdown', element_id: 'think', content, text_size: 'notation' }],
+        };
+    }
+    /** Live layout when steps is undefined; a final layout otherwise ('' leaves out the panel). */
+    card(final) {
+        const elements = [];
+        if (!final)
+            elements.push(this.panel(this.thinkContent()));
+        else if (final.steps)
+            elements.push(this.panel(final.steps));
+        elements.push({ tag: 'markdown', element_id: 'answer',
+            content: final ? (final.answer.trim() ? cardMarkdown(final.answer) : grey('（没有文字回复）')) : this.answerContent() });
+        const note = [this.note, final?.truncated ? TRUNCATED : undefined].filter(Boolean).join(' ');
+        if (final && note)
+            elements.push({ tag: 'markdown', element_id: 'note', content: grey(cardMarkdown(note)), text_size: 'notation' });
+        const summary = final ? plainLabel(final.answer || this.note || '回复', 60) || '回复' : this.answer ? '正在回复…' : '正在思考…';
+        return {
+            schema: '2.0',
+            config: { update_multi: true, enable_forward: false, width_mode: 'default', summary: { content: summary }, streaming_mode: !final,
+                ...(final ? {} : { streaming_config: { print_frequency_ms: { default: 30 }, print_step: { default: 2 }, print_strategy: 'fast' } }) },
+            body: { direction: 'vertical', vertical_spacing: '8px', padding: '12px 16px 12px 16px', elements },
+        };
+    }
+    /** The answer comes first. The folded process only gets the space that is left. */
+    finalCard() {
+        // Reserve room for the folded title, so its time and tool count stay visible even beside a long answer.
+        const minimal = this.steps.length ? grey('思考过程较长，卡片里没有显示。') : '';
+        let answer = this.answer, truncated = false;
+        const fits = (candidate, steps) => bytes(this.card({ answer: candidate, steps, truncated })) <= CARD_BYTES;
+        if (!fits(answer, minimal)) {
+            truncated = true;
+            // Cut between top-level blocks so what is shown stays valid Markdown.
+            const blocks = markdownBlocks(this.answer);
+            let low = 1, high = blocks.length - 1, best = 0;
+            while (low <= high) {
+                const middle = (low + high) >> 1;
+                if (fits(blocks.slice(0, middle).join(''), minimal)) {
+                    best = middle;
+                    low = middle + 1;
+                }
+                else
+                    high = middle - 1;
+            }
+            if (best > 0)
+                answer = blocks.slice(0, best).join('');
+            else {
+                // One oversized block, such as a long code listing: cut it by size.
+                let budget = 20_000;
+                answer = head(this.answer, budget);
+                while (answer && !fits(answer, minimal))
+                    answer = head(this.answer, budget = Math.floor(budget * 0.7));
+            }
+        }
+        if (minimal) {
+            let budget = Math.min(FINAL_STEP_BYTES, CARD_BYTES - bytes(this.card({ answer, steps: '', truncated })) - 800);
+            while (budget > 300) {
+                const steps = this.stepsMarkdown(budget);
+                if (steps && fits(answer, steps))
+                    return this.card({ answer, steps, truncated });
+                budget = Math.floor(budget * 0.7);
+            }
+        }
+        return this.card({ answer, steps: minimal, truncated });
+    }
+}
+//# sourceMappingURL=live-reply.js.map

package/dist/onboarding/controller.js

@@ -8,7 +8,7 @@ import { LarkCli } from '../lark-cli.js';
 import { LockHeldError } from '../lock.js';
 import { BOT_SCOPES, CARD_SCOPE, LarkPlatformError } from './lark-platform.js';
 import { createChallenge, PairingError, waitForPairing } from './pairing.js';
-import { documentScopesReady } from '../rich-scopes.js';
+import { defaultScopesReady } from '../rich-scopes.js';
 const restoreDelay = (attempt) => Math.min(10 * 60_000, 5_000 * 2 ** Math.min(attempt, 10));
 const messages = {
     idle: '把助手带到飞书，先用飞书确认创建。',
@@ -167,7 +167,7 @@ export class ConnectionController {
             this.documentJob = this.deps.platform.inspect(record.profile, aborter.signal).then(inspection => {
                 if (!aborter.signal.aborted && !this.closed && this.record?.appId === record.appId) {
                     if (inspection.appId === record.appId && (!record.botOpenId || inspection.botOpenId === record.botOpenId)) {
-                        this.documentsReady = inspection.scopeStatus === 'verified' && documentScopesReady(inspection.grantedScopes);
+                        this.documentsReady = inspection.scopeStatus === 'verified' && defaultScopesReady(inspection.grantedScopes);
                     }
                 }
             }).catch(() => { })
@@ -202,13 +202,13 @@ export class ConnectionController {
                 if (this.documentJob)
                     return this.snapshot();
                 const record = this.record, aborter = this.documentAborter = new AbortController();
-                this.documentSetup = { phase: 'preparing', message: '正在准备文档与画板授权，聊天连接继续保持。' };
+                this.documentSetup = { phase: 'preparing', message: '正在准备默认权限授权，聊天连接继续保持。' };
                 this.documentJob = this.deps.platform.enableDocuments(record.profile, info => {
                     const url = officialDestination(info.url), expiresAt = Date.now() + info.expireIn * 1000;
                     void (this.deps.qr ?? (url => QRCode.toDataURL(url, { width: 256, margin: 2 })))(url).then(image => {
                         if (aborter.signal.aborted || this.closed || this.documentAborter !== aborter)
                             return;
-                        this.documentSetup = { phase: 'scanning', message: '用飞书扫码补充文档与画板权限，无需重新创建或配对机器人。', qr: { url, image, expiresAt } };
+                        this.documentSetup = { phase: 'scanning', message: '用飞书扫码补充实时回复、文档与画板权限，无需重新创建或配对机器人。', qr: { url, image, expiresAt } };
                     }).catch(() => { if (!aborter.signal.aborted) {
                         this.documentSetup = { phase: 'error', message: '二维码未能生成，请重试。' };
                         aborter.abort();
@@ -352,7 +352,7 @@ export class ConnectionController {
         this.assertCurrent(signal);
         let record = this.record;
         let inspection = await this.deps.platform.inspect(record.profile, signal);
-        this.documentsReady = inspection.scopeStatus === 'verified' && documentScopesReady(inspection.grantedScopes);
+        this.documentsReady = inspection.scopeStatus === 'verified' && defaultScopesReady(inspection.grantedScopes);
         this.assertCurrent(signal);
         if (inspection.appId !== record.appId || (record.botOpenId && inspection.botOpenId && record.botOpenId !== inspection.botOpenId)) {
             throw new SetupError('机器人身份发生变化，请断开后重新绑定。', false);
@@ -442,8 +442,10 @@ export class ConnectionController {
         const cwd = join(directory, 'workspace');
         await mkdir(cwd, { recursive: true, mode: 0o700 });
         return parseConfig({ profile: record.profile, botOpenId: record.botOpenId, stateDir: join(directory, 'state'),
-            executable: this.deps.executable ?? 'lark-cli', users: [{ openId: record.ownerOpenId, direct: true,
-                    groupChats: [], cwd, allowedTools: [] }], cardInteractions: record.cards, loadingReaction: record.loading, botMenu: this.menuReady }, directory);
+            executable: this.deps.executable ?? 'lark-cli', users: [{ openId: record.ownerOpenId, direct: true, directMode: 'harness',
+                    groupChats: [], cwd, allowedTools: [] }], cardInteractions: record.cards, loadingReaction: record.loading, botMenu: this.menuReady,
+            // Without the CardKit scope a live card cannot be created and replies fall back to ordinary messages.
+            streamingCards: true }, directory);
     }
     async bind(message, signal) {
         this.assertCurrent(signal);

package/dist/onboarding/lark-platform.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 import { BOT_MENU_EVENT } from '../bot-menu.js';
-import { DOCUMENT_SCOPES, documentScopesReady } from '../rich-scopes.js';
+import { DOCUMENT_SCOPES, STREAMING_SCOPE, defaultScopesReady } from '../rich-scopes.js';
 export class LarkPlatformError extends Error {
     code;
     constructor(code) {
@@ -197,7 +197,7 @@ export class LarkPlatform {
                 appPreset: { name: request.name, desc: request.description ?? '在飞书中与 dsh 个人助手对话' },
                 addons: {
                     preset: false,
-                    scopes: { tenant: [...new Set([...BOT_SCOPES, ...SETUP_SCOPES, ...DOCUMENT_SCOPES, ...(request.cardInteractions ? [CARD_SCOPE] : []),
+                    scopes: { tenant: [...new Set([...BOT_SCOPES, ...SETUP_SCOPES, ...DOCUMENT_SCOPES, STREAMING_SCOPE, ...(request.cardInteractions ? [CARD_SCOPE] : []),
                                 ...(request.loadingReaction ? [REACTION_SCOPE] : [])])] },
                     events: { items: { tenant: ['im.message.receive_v1', BOT_MENU_EVENT] } },
                     ...(request.cardInteractions ? { callbacks: { items: ['card.action.trigger'] } } : {}),
@@ -250,10 +250,10 @@ export class LarkPlatform {
             if (current.appId !== selected.appId)
                 fail('APP_MISMATCH');
             // Another host may already have completed the upgrade; never ask for another scan just to refresh UI state.
-            if (current.scopeStatus === 'verified' && documentScopesReady(current.grantedScopes))
+            if (current.scopeStatus === 'verified' && defaultScopesReady(current.grantedScopes))
                 return;
             const result = await this.registrar({ source: 'dsh-larkbot', appId: selected.appId, signal,
-                addons: { preset: false, scopes: { tenant: [...DOCUMENT_SCOPES] } },
+                addons: { preset: false, scopes: { tenant: [...DOCUMENT_SCOPES, STREAMING_SCOPE] } },
                 onQRCodeReady: info => {
                     checkSignal(signal);
                     let url;
@@ -274,7 +274,7 @@ export class LarkPlatform {
             if (result.client_id !== selected.appId || (result.user_info?.tenant_brand && result.user_info.tenant_brand !== selected.brand))
                 fail('APP_MISMATCH');
             const inspection = await this.inspect(profile, signal);
-            if (inspection.appId !== selected.appId || inspection.scopeStatus !== 'verified' || !documentScopesReady(inspection.grantedScopes))
+            if (inspection.appId !== selected.appId || inspection.scopeStatus !== 'verified' || !defaultScopesReady(inspection.grantedScopes))
                 fail('MISSING_SCOPE');
         }
         catch (error) {

package/dist/permission-controls.d.ts

@@ -0,0 +1,13 @@
+import type { PermissionOption } from './dsh-runtime.js';
+import type { ReplyAction, ReplyPanel } from './replies.js';
+/** What the chat shows: the effective preset when a session is live, else the chat's saved choice. */
+export interface PermissionView {
+    options: PermissionOption[];
+    current?: string;
+}
+/** Presets that let Harness act without asking get a second confirmation. */
+export declare const unattended: (id: string) => boolean;
+export declare function permissionStateText(view: PermissionView): string;
+type Issue = (label: string, command: string, primary: boolean, confirm?: ReplyAction['confirm']) => ReplyAction | undefined;
+export declare function permissionPanel(view: PermissionView, issue: Issue, changed?: boolean): ReplyPanel;
+export {};

package/dist/permission-controls.js

@@ -0,0 +1,26 @@
+/** Presets that let Harness act without asking get a second confirmation. */
+export const unattended = (id) => /full|danger|auto/.test(id);
+function currentName(view) {
+    if (!view.current)
+        return '跟随电脑上的默认设置';
+    return view.options.find(option => option.id === view.current)?.name ?? '自定义（在电脑上调整过）';
+}
+export function permissionStateText(view) {
+    return `当前权限模式：${currentName(view)}。\n可选：${view.options.map(option => option.name).join('、')}。只影响这个私聊里的对话。`;
+}
+export function permissionPanel(view, issue, changed = false) {
+    const actions = [];
+    for (const option of view.options) {
+        const current = option.id === view.current;
+        const action = issue(`${current ? '✓ ' : ''}${option.name}`, `/permission use ${option.id}`, current, !current && unattended(option.id) ? { title: `切换到「${option.name}」？`,
+            text: '之后 Harness 执行命令、修改文件都不再询问，在飞书发一句话就能直接操作这台电脑。随时可以切回。' } : undefined);
+        if (action)
+            actions.push(action);
+    }
+    const summary = `当前：${currentName(view)}`;
+    return { title: changed ? '权限模式已更新' : '权限模式', subtitle: '只影响这个私聊里的对话', summary,
+        sections: [{ text: summary }, ...view.options.filter(option => option.description).map(option => ({ title: option.name, text: option.description }))],
+        actions, actionColumns: 1,
+        note: '需要确认的操作由这里的模式决定；电脑上其他会话和默认设置不受影响。' };
+}
+//# sourceMappingURL=permission-controls.js.map

package/dist/permission-preferences.d.ts

@@ -0,0 +1,26 @@
+/** Both keys must be derived by the bridge from the verified sender and chat. */
+export interface PermissionPreferenceContext {
+    ownerKey: string;
+    conversationKey: string;
+}
+/** Safe for chat replies: no identity keys, paths or I/O details. */
+export declare class PermissionPreferencesError extends Error {
+    readonly code: 'INVALID_INPUT' | 'CAPACITY' | 'CORRUPT' | 'WRITE_FAILED' | 'UNAVAILABLE';
+    constructor(code: 'INVALID_INPUT' | 'CAPACITY' | 'CORRUPT' | 'WRITE_FAILED' | 'UNAVAILABLE');
+}
+/**
+ * The permission preset a private chat chose in Feishu. It applies to that
+ * chat's sessions only; the host's own default for other sessions is untouched.
+ * One bot process owns this store under its state-directory lock.
+ */
+export declare class PermissionPreferencesStore {
+    private readonly directory;
+    private document;
+    private tail;
+    private uncertain;
+    private constructor();
+    static open(directory: string): Promise<PermissionPreferencesStore>;
+    get(context: PermissionPreferenceContext): Promise<string | undefined>;
+    set(context: PermissionPreferenceContext, preset: string): Promise<void>;
+    private persist;
+}