dsh-lark-agent 0.1.2 → 0.2.0

package/dist/bridge.js

@@ -1,4 +1,6 @@
-import { createHash } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
+import { realpath, stat } from 'node:fs/promises';
+import { basename, isAbsolute, relative, sep } from 'node:path';
 import { DshRuntimeError } from './dsh-runtime.js';
 import { authorize, chunksByBytes, ownerKey, parseMessage, sessionKey } from './message.js';
 import { MemoryStoreError } from './memory-store.js';
@@ -10,14 +12,58 @@ import { modelChoice, thinkingChoice, modelControlPanel, modelStateText, sameSel
 import { botMenuCommand, BOT_MENU_EVENT } from './bot-menu.js';
 import { CommandFeedback } from './command-feedback.js';
 import { PresentationError, presentationDraft, presentationCard, presentationText } from './presentation.js';
+import { LiveReply } from './live-reply.js';
+import { answeredText, approvalCard, questionAnswers, questionCard, simpleQuestion } from './interaction-cards.js';
+import { permissionPanel, permissionStateText } from './permission-controls.js';
 class ArtifactDeliveryError extends Error {
 }
+const APPROVAL_TIMEOUT_MS = 5 * 60_000;
+const QUESTION_TIMEOUT_MS = 10 * 60_000;
+// After a live card cannot be created (for example, before the CardKit scope is
+// granted), use ordinary replies for a while instead of failing every turn.
+const LIVE_RETRY_MS = 10 * 60_000;
+const MAX_FILE_BYTES = 30 * 1024 * 1024;
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+const TIMEOUT_TEXT = '本次处理超时，已请求取消。请缩小问题范围后重试。';
+const STOPPING_TEXT = '连接正在关闭，本次处理已停止。';
+/** Only a regular file inside the user's own workspace is uploaded; anything else is just named. */
+async function uploadable(workspace, path) {
+    let real;
+    try {
+        real = await realpath(path);
+    }
+    catch {
+        return { reason: '找不到这个文件' };
+    }
+    const inside = relative(workspace, real);
+    if (!inside || inside === '..' || inside.startsWith('..' + sep) || isAbsolute(inside))
+        return { reason: '不在这个私聊的工作区内，没有上传' };
+    let info;
+    try {
+        info = await stat(real);
+    }
+    catch {
+        return { reason: '无法读取' };
+    }
+    if (!info.isFile())
+        return { reason: '不是普通文件' };
+    if (info.size === 0)
+        return { reason: '是空文件' };
+    if (info.size > MAX_FILE_BYTES)
+        return { reason: '超过飞书 30 MB 的文件上限' };
+    if (/[\u0000-\u001f\u007f]/.test(basename(real)))
+        return { reason: '文件名含有无法发送的字符' };
+    return { path: real, image: /\.(?:png|jpe?g|gif|webp)$/i.test(real) && info.size <= MAX_IMAGE_BYTES };
+}
 const HELP = `直接把想做的事告诉我就好。
 
 比如：帮我理清一个问题、整理一段文字，或者接着刚才的话题继续。你也可以在私聊告诉我，以后希望我怎样配合你。
 
 私聊底部菜单可以新建话题、找历史对话，或调整模型和思考深度。
 也可以发 /new 换话题、/sessions 找对话、/model 看模型、/thinking 调深度、/stop 停下来。`;
+const HARNESS_HELP = `
+
+这里连着你电脑上的 Harness：可以让我查资料、读网页、处理工作区里的文件，回复会实时显示，思考过程折叠在卡片里；需要你确认的操作，我会先发卡片问你。发 /permission（或在 设置 → 模型 里点「权限模式」）可以切换权限，比如改成不再询问的「完全权限」。`;
 const ADVANCED_HELP = `高级命令（按需使用）：
 /new 或 /reset：归档当前会话，下一条消息开启新会话；长期记忆保留
 /sessions：选择以前的对话；/sessions detail 查看完整列表和 ID
@@ -27,6 +73,7 @@ const ADVANCED_HELP = `高级命令（按需使用）：
 /stop：停止当前处理并取消排队消息
 /results：查看当前话题的作品；/result <ID>：查看内容；/publish <ID>：在本人私聊生成飞书文档或画板
 /model：查看当前模型并选择；/thinking：选择当前模型支持的思考深度
+/permission：本人私聊切换 Harness 权限模式（如仅可查看、工作区内修改、完全权限）
 /remember <内容>：私聊保存私密个人记忆；群聊仅保存当前聊天记忆
 /remember --chat <内容>：只在当前聊天／话题保存记忆
 /memory：列出可用记忆（最多 20 条）
@@ -86,6 +133,8 @@ export class BotBridge {
     failedDisposals = new Set();
     cardActionsReady = false;
     progress;
+    interactions = new Map();
+    liveUnavailableUntil = 0;
     constructor(config, runtime, transport, ledger, state, audit = () => undefined, progressTransport, artifactPublisher) {
         this.config = config;
         this.runtime = runtime;
@@ -125,7 +174,7 @@ export class BotBridge {
             return;
         }
         let formValues;
-        if (binding.command.startsWith('/answer ')) {
+        if (binding.command.startsWith('/answer ') || binding.command.startsWith('/reply ')) {
             if (data.action_name !== 'dsh_submit' || typeof data.form_value !== 'string' || data.form_value.length > 8000)
                 return;
             try {
@@ -137,7 +186,7 @@ export class BotBridge {
             if (!formValues || typeof formValues !== 'object' || Array.isArray(formValues))
                 return;
         }
-        const mutation = /^\/(?:(?:new|resume|forget|answer)(?: |$)|(?:model|thinking) use )/.test(binding.command);
+        const mutation = /^\/(?:(?:new|resume|forget|answer)(?: |$)|(?:model|thinking|permission) use )/.test(binding.command);
         return { messageId: data.message_id, senderId: binding.ownerId, chatId: binding.chatId,
             chatType: binding.chatType, threadId: binding.threadId, text: binding.command,
             requestId: `card:${data.event_id}`, actionNonce: mutation ? binding.nonce : undefined,
@@ -201,6 +250,12 @@ export class BotBridge {
                 return;
             if (!message.menu && message.chatType === 'p2p')
                 await this.state.directChats?.record(message.senderId, message.chatId);
+            // A running turn holds its queue while it waits for its approval or
+            // question, so those answers must not queue behind it.
+            if (message.requestId?.startsWith('card:') && /^\/(?:approve|deny|choose|reply) /.test(message.text)) {
+                await this.answerInteraction(message);
+                return;
+            }
             const key = sessionKey(message, this.config);
             let lane = this.lanes.get(key);
             if (message.text === '/stop') {
@@ -228,7 +283,7 @@ export class BotBridge {
             const generation = lane.generation;
             current.pending++;
             this.pending++;
-            const finishProgress = message.menu ? () => undefined : this.progress.begin(message.messageId);
+            const finishProgress = message.menu || this.streams(message, user) ? () => undefined : this.progress.begin(message.messageId);
             const acceptedAt = Date.now();
             const job = current.tail.then(async () => {
                 if (this.stopped || generation !== current.generation)
@@ -354,48 +409,88 @@ export class BotBridge {
         lane.controller = controller;
         let timedOut = false;
         const timer = setTimeout(() => { timedOut = true; controller.abort(); }, this.config.turnTimeoutMs);
+        const harness = message.chatType === 'p2p' && lane.user.directMode === 'harness';
+        let live;
+        // Once a live card exists it carries this turn's whole outcome; nothing else is sent as text.
+        const conclude = async (final) => {
+            const card = live;
+            live = undefined;
+            if (!await card.finish(final))
+                this.audit({ stage: 'live-card-unconfirmed', messageId: message.messageId });
+        };
         try {
             await this.ensureSession(message, lane);
             if (controller.signal.aborted) {
                 if (timedOut)
-                    await this.reply(message, '本次处理超时，已请求取消。请缩小问题范围后重试。');
+                    await this.reply(message, TIMEOUT_TEXT);
                 return;
             }
             const context = this.context(message);
             const memoryText = promptMemories(await this.state.memories.list(context));
             const artifactsText = this.state.artifacts && lane.saved ? JSON.stringify((await this.state.artifacts.list(this.artifactContext(message, lane.saved.id)))
                 .map(row => ({ id: row.id, title: row.draft.title, kind: row.draft.kind }))) : undefined;
-            const result = await lane.session.run(text, controller.signal, { memoryText, ...(artifactsText ? { artifactsText } : {}) });
+            if (this.streams(message, lane.user)) {
+                const candidate = new LiveReply(this.liveTransport(), { messageId: message.messageId, inThread: Boolean(message.threadId),
+                    idempotencyKey: createHash('sha256').update(JSON.stringify([this.config.botOpenId, message.requestId ?? message.messageId, 'live'])).digest('hex').slice(0, 48) }, { audit: stage => this.audit({ stage, messageId: message.messageId }) });
+                if (await candidate.open())
+                    live = candidate;
+                else
+                    this.liveUnavailableUntil = Date.now() + LIVE_RETRY_MS;
+            }
+            const turnContext = { memoryText, ...(artifactsText ? { artifactsText } : {}) };
+            // Only the owner's harness-mode chat can be asked anything; a restricted session gets no hooks at all.
+            const observer = live || harness ? {
+                ...(live ? { stream: (event) => live?.push(event) } : {}),
+                ...(harness ? { approve: (prompt, signal) => this.approve(message, prompt, signal),
+                    ask: (questions, signal) => this.ask(message, questions, signal) } : {}),
+            } : undefined;
+            const result = await (observer ? lane.session.run(text, controller.signal, turnContext, observer)
+                : lane.session.run(text, controller.signal, turnContext));
             // Native conversation data must be durable before acknowledging a turn.
             await lane.session.checkpoint();
             await this.state.sessions.touch(this.sessionContext(message), lane.saved.id);
             clearTimeout(timer);
             if (controller.signal.aborted || this.stopped) {
-                if (timedOut && !this.stopped)
-                    await this.reply(message, '本次处理超时，已请求取消。请缩小问题范围后重试。');
+                if (live)
+                    await conclude({ phase: 'stopped', note: timedOut ? TIMEOUT_TEXT : this.stopped ? STOPPING_TEXT : '已停止。' });
+                else if (timedOut && !this.stopped)
+                    await this.reply(message, TIMEOUT_TEXT);
                 return;
             }
             const answer = typeof result === 'string' ? result : result.text;
             const artifacts = typeof result === 'string' ? [] : result.artifacts;
+            const files = typeof result === 'string' ? [] : result.files ?? [];
             const bounded = Array.from(answer).slice(0, this.config.maxOutputChars).join('');
+            const truncated = bounded.length < answer.length;
             // The answer is already in native history. Send it before artifact work
             // that can fail, so a storage limit cannot swallow a complete reply.
-            if (bounded || !artifacts.length)
-                await this.reply(message, bounded ? bounded + (bounded.length < answer.length ? '\n\n（回复已截断）' : '') : 'dsh 本次没有返回文本。', controller.signal);
+            if (live)
+                await conclude({ phase: 'done', answer: bounded || (artifacts.length || files.length ? '已整理好，见下方。' : 'dsh 本次没有返回文本。'),
+                    ...(typeof result !== 'string' && result.reasoning ? { reasoning: result.reasoning } : {}), ...(truncated ? { note: '回复已截断。' } : {}) });
+            else if (bounded || !artifacts.length)
+                await this.reply(message, bounded ? bounded + (truncated ? '\n\n（回复已截断）' : '') : 'dsh 本次没有返回文本。', controller.signal);
             await this.presentArtifacts(message, lane, artifacts, controller.signal);
+            await this.deliverFiles(message, lane, files, controller.signal);
             this.audit({ stage: 'replied', messageId: message.messageId });
         }
         catch (error) {
             clearTimeout(timer);
             if (error instanceof ArtifactDeliveryError)
                 throw error;
+            const known = error instanceof DshRuntimeError || error instanceof MemoryStoreError || error instanceof SessionStoreError || error instanceof ModelPreferencesError || error instanceof PresentationError;
+            if (live) {
+                const stopped = timedOut || controller.signal.aborted || this.stopped;
+                await conclude({ phase: stopped ? 'stopped' : 'failed', note: timedOut ? TIMEOUT_TEXT : this.stopped ? STOPPING_TEXT
+                        : controller.signal.aborted ? '已停止。' : known ? error.message : '处理没有完成，请稍后重试。' }).catch(() => undefined);
+                return;
+            }
             if (this.stopped)
                 return;
             if (timedOut)
-                await this.reply(message, '本次处理超时，已请求取消。请缩小问题范围后重试。');
+                await this.reply(message, TIMEOUT_TEXT);
             else if (!controller.signal.aborted) {
                 // Transport failures may have delivered partial output. Do not send an extra ambiguous retry.
-                if (error instanceof DshRuntimeError || error instanceof MemoryStoreError || error instanceof SessionStoreError || error instanceof ModelPreferencesError || error instanceof PresentationError)
+                if (known)
                     await this.reply(message, error.message);
                 else
                     this.audit({ stage: 'delivery-or-runtime-failed', messageId: message.messageId });
@@ -406,6 +501,161 @@ export class BotBridge {
             lane.controller = undefined;
         }
     }
+    /** Whether this message's reply streams into a live card, which makes the typing reaction redundant. */
+    streams(message, user) {
+        return message.chatType === 'p2p' && user.directMode === 'harness' && this.config.streamingCards && this.config.responseMode !== 'text'
+            && !message.text.startsWith('/') && Date.now() >= this.liveUnavailableUntil && this.liveTransport() !== undefined;
+    }
+    liveTransport() {
+        const transport = this.transport;
+        return transport.createCardEntity && transport.replyCardEntity && transport.streamCardText && transport.updateCardEntity
+            ? transport : undefined;
+    }
+    canInteract(message) {
+        return message.chatType === 'p2p' && !this.stopped && this.cardActionsReady && this.config.cardInteractions && this.config.responseMode !== 'text'
+            && Boolean(this.state.actions && this.transport.createFeedback && this.transport.updateFeedback);
+    }
+    issueAction(message, command) {
+        return this.state.actions.issue({ ownerId: message.senderId, chatId: message.chatId, chatType: message.chatType,
+            threadId: message.threadId, sourceMessageId: message.messageId, command });
+    }
+    /** Ask the owner about one Harness approval. Anything but an explicit allow denies the call. */
+    async approve(message, prompt, signal) {
+        if (!this.canInteract(message) || signal.aborted)
+            return false;
+        const id = randomBytes(6).toString('hex');
+        // Register before the card exists, so even an immediate click finds it.
+        const pending = this.waitForAnswer(id, message, answer => answer.verb === 'approve' ? true : answer.verb === 'deny' ? false : undefined, signal, APPROVAL_TIMEOUT_MS);
+        const card = await this.openInteraction(message, id, approvalCard(prompt, { allow: this.issueAction(message, `/approve ${id}`),
+            deny: this.issueAction(message, `/deny ${id}`) }));
+        if (!card) {
+            pending.cancel();
+            return false;
+        }
+        const outcome = await pending.result;
+        const allowed = outcome.kind === 'answer' && outcome.value;
+        await this.closeInteraction(card, approvalCard(prompt, undefined, outcome.kind === 'answer' ? (allowed ? '已允许这一次。' : '已拒绝，这次不会执行。')
+            : outcome.kind === 'timeout' ? '5 分钟内没有确认，已按拒绝处理。' : '本次处理已停止，没有执行。'));
+        return allowed;
+    }
+    /** Ask the owner a Harness question. Without an answer the host gets an error and continues. */
+    async ask(message, questions, signal) {
+        const unavailable = '这里无法用卡片提问。请把问题写在回复里，由主人直接回答。';
+        if (!this.canInteract(message))
+            throw new Error(unavailable);
+        const id = randomBytes(6).toString('hex');
+        const first = questions[0];
+        const tokens = simpleQuestion(questions)
+            ? { choose: Array.from({ length: first.options.length + 1 }, (_unused, index) => this.issueAction(message, `/choose ${id} ${index}`)) }
+            : { reply: this.issueAction(message, `/reply ${id}`) };
+        const pending = this.waitForAnswer(id, message, answer => questionAnswers(questions, answer), signal, QUESTION_TIMEOUT_MS);
+        const card = await this.openInteraction(message, id, questionCard(questions, tokens));
+        if (!card) {
+            pending.cancel();
+            throw new Error(unavailable);
+        }
+        const outcome = await pending.result;
+        await this.closeInteraction(card, questionCard(questions, undefined, outcome.kind === 'answer' ? answeredText(questions, outcome.value)
+            : outcome.kind === 'timeout' ? '10 分钟内没有回答，已按未回答继续。' : '本次处理已停止，提问已关闭。'));
+        if (outcome.kind !== 'answer')
+            throw new Error(outcome.kind === 'timeout' ? '主人没有在 10 分钟内回答。' : '提问已取消。');
+        return outcome.value;
+    }
+    waitForAnswer(id, message, parse, signal, timeoutMs) {
+        let finish;
+        const result = new Promise(resolve => {
+            let done = false;
+            const timer = setTimeout(() => finish({ kind: 'timeout' }), timeoutMs);
+            const onAbort = () => finish({ kind: 'cancelled' });
+            const entry = { ownerId: message.senderId, chatId: message.chatId, stop: onAbort,
+                settle: answer => {
+                    const value = parse(answer);
+                    if (value === undefined || done)
+                        return false;
+                    finish({ kind: 'answer', value });
+                    return true;
+                } };
+            finish = outcome => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                signal.removeEventListener('abort', onAbort);
+                if (this.interactions.get(id) === entry)
+                    this.interactions.delete(id);
+                resolve(outcome);
+            };
+            this.interactions.set(id, entry);
+            signal.addEventListener('abort', onAbort, { once: true });
+            if (signal.aborted)
+                onAbort();
+        });
+        return { result, cancel: () => finish({ kind: 'cancelled' }) };
+    }
+    async openInteraction(message, id, payload) {
+        if (payload.kind !== 'card' || this.stopped)
+            return;
+        const idempotencyKey = createHash('sha256').update(JSON.stringify([this.config.botOpenId, message.requestId ?? message.messageId, 'interaction', id]))
+            .digest('hex').slice(0, 48);
+        try {
+            return await this.transport.createFeedback({ messageId: message.messageId, inThread: Boolean(message.threadId) }, payload, { idempotencyKey });
+        }
+        catch {
+            this.audit({ stage: 'interaction-card-failed', messageId: message.messageId });
+            return;
+        }
+    }
+    async closeInteraction(messageId, payload) {
+        if (payload.kind !== 'card')
+            return;
+        try {
+            await this.transport.updateFeedback(messageId, payload);
+        }
+        catch {
+            this.audit({ stage: 'interaction-update-failed', messageId });
+        }
+    }
+    async answerInteraction(message) {
+        const match = /^\/(approve|deny|choose|reply) ([a-f0-9]{12})(?: ([0-9]{1,2}))?$/.exec(message.text);
+        const pending = match ? this.interactions.get(match[2]) : undefined;
+        if (!match || !pending || pending.ownerId !== message.senderId || pending.chatId !== message.chatId) {
+            await this.reply(message, '这张卡片已经失效。需要的话，直接在聊天里告诉我。');
+            return;
+        }
+        if (!pending.settle({ verb: match[1], ...(match[3] === undefined ? {} : { index: Number(match[3]) }),
+            ...(message.formValues === undefined ? {} : { formValues: message.formValues }) }))
+            await this.reply(message, '这次选择无效，请在卡片上重新选择后提交。');
+    }
+    /** Send files the host's delivery tool presented, from this user's workspace only. */
+    async deliverFiles(message, lane, files, signal) {
+        if (!files.length || signal.aborted || this.stopped)
+            return;
+        const workspace = await realpath(lane.user.cwd).catch(() => undefined);
+        const notes = [];
+        for (const [index, file] of files.entries()) {
+            if (signal.aborted || this.stopped)
+                return;
+            const name = basename(file.path);
+            const checked = workspace && this.transport.replyFile ? await uploadable(workspace, file.path) : { reason: '这个连接不能发送文件' };
+            if ('reason' in checked) {
+                notes.push(`${name}：${checked.reason}（电脑上的位置：${file.path}）`);
+                continue;
+            }
+            const idempotencyKey = createHash('sha256').update(JSON.stringify([this.config.botOpenId, message.requestId ?? message.messageId, 'file', index, checked.path]))
+                .digest('hex').slice(0, 48);
+            try {
+                await this.transport.replyFile(message.messageId, checked.path, { idempotencyKey, inThread: Boolean(message.threadId), image: checked.image });
+                this.audit({ stage: 'file-sent', messageId: message.messageId });
+            }
+            catch {
+                // The upload may still have arrived. Name it instead of sending again.
+                notes.push(`${name}：发送结果没有确认，请在电脑上查看 ${file.path}`);
+                this.audit({ stage: 'file-send-unknown', messageId: message.messageId });
+            }
+        }
+        if (notes.length)
+            await this.reply(message, `有 ${notes.length} 个文件没有发到这里：\n${notes.join('\n')}`, signal);
+    }
     commandFeedback(message) {
         // Private controls contain no model-generated output. Group replies retain
         // their existing authorization gate and native typing reaction.
@@ -456,6 +706,7 @@ export class BotBridge {
         const context = this.context(message);
         return {
             cwd: lane.user.cwd, allowedTools: lane.user.allowedTools,
+            mode: message.chatType === 'p2p' && lane.user.directMode === 'harness' ? 'harness' : 'restricted',
             provider: this.config.provider, model: this.config.model,
             presentation: Boolean(this.state.artifacts),
             ...selection,
@@ -498,6 +749,7 @@ export class BotBridge {
             : await this.runtime.create(this.policy(message, lane, modelPreference?.selection));
         try {
             await handle.checkpoint();
+            await this.applyPermission(message, lane, handle);
             if (!modelPreference && handle.modelSelection && this.state.modelPreferences) {
                 await this.state.modelPreferences.set(this.context(message), handle.modelSelection(), { expectedRevision: null });
             }
@@ -550,9 +802,12 @@ export class BotBridge {
         const context = this.context(message);
         const conversation = this.sessionContext(message);
         if (command === 'help')
-            return args === 'advanced' ? ADVANCED_HELP : HELP;
+            return args === 'advanced' ? ADVANCED_HELP
+                : HELP + (message.chatType === 'p2p' && lane.user.directMode === 'harness' ? HARNESS_HELP : '');
         if (command === 'model' || command === 'thinking')
             return this.modelCommand(message, lane, command, args);
+        if (command === 'permission')
+            return this.permissionCommand(message, lane, args);
         if (command === 'whoami')
             return `用户：${message.senderId}\n聊天：${message.chatId}\n范围：${message.chatType === 'p2p' ? '私聊' : '群聊'}${message.threadId ? '／独立话题' : ''}\n身份由飞书验证。个人记忆默认仅本人私聊可读，群聊仅可用本人明确授权的条目。`;
         if (command === 'status') {
@@ -603,6 +858,7 @@ export class BotBridge {
             const handle = await this.runtime.resume(this.policy(message, lane, preference?.selection), target.nativeId);
             try {
                 await handle.checkpoint();
+                await this.applyPermission(message, lane, handle);
                 if (!preference && handle.modelSelection && this.state.modelPreferences)
                     await this.state.modelPreferences.set(context, handle.modelSelection(), { expectedRevision: null });
                 await this.bindRestoredSession(conversation, target, handle);
@@ -672,6 +928,57 @@ export class BotBridge {
         }
         return '未知命令。发送 /help 查看可用命令。';
     }
+    harness(message, lane) {
+        return message.chatType === 'p2p' && lane.user.directMode === 'harness';
+    }
+    /** The host's presets, from the live session when there is one. Undefined when the host offers none. */
+    permissionView(lane) {
+        const live = lane.session?.permissionState?.();
+        if (live)
+            return live;
+        const options = this.runtime.permissionOptions?.() ?? [];
+        return options.length ? { options } : undefined;
+    }
+    /** What this chat runs: the live session's preset, else the chat's saved choice. */
+    async permissionChoice(message, lane) {
+        if (lane.unavailable)
+            await this.unload(lane);
+        const view = this.permissionView(lane);
+        if (!view)
+            return;
+        if (view.current)
+            return view;
+        const saved = await this.state.permissionPreferences?.get(this.context(message));
+        return saved && view.options.some(option => option.id === saved) ? { ...view, current: saved } : view;
+    }
+    /** Owner-only: switch this private chat's Harness permission preset, like the App's selector. */
+    async permissionCommand(message, lane, args) {
+        if (!this.harness(message, lane))
+            return '权限模式只能在你和我的私聊里切换。';
+        const view = await this.permissionChoice(message, lane);
+        if (!view)
+            throw new DshRuntimeError('PERMISSION_UNAVAILABLE');
+        if (!args)
+            return permissionStateText(view);
+        const choice = /^use ([a-z][a-z0-9-]{0,39})$/.exec(args)?.[1];
+        const option = view.options.find(item => item.id === choice);
+        if (!option)
+            return '请通过权限模式卡片选择，或发送 /permission 查看可用选项。';
+        // Save first: a later session in this chat starts in the chosen mode even if the live switch fails.
+        await this.state.permissionPreferences?.set(this.context(message), option.id);
+        lane.session?.setPermission?.(option.id);
+        message.permissionChanged = true;
+        return `已切换为「${option.name}」。这个私聊里的对话都会使用它；电脑上其他会话不受影响。`;
+    }
+    /** Bring a newly opened harness session to the chat's saved permission preset. */
+    async applyPermission(message, lane, handle) {
+        if (!this.harness(message, lane) || !handle.setPermission)
+            return;
+        const saved = await this.state.permissionPreferences?.get(this.context(message));
+        const state = saved ? handle.permissionState?.() : undefined;
+        if (state && state.current !== saved && state.options.some(option => option.id === saved))
+            handle.setPermission(saved);
+    }
     async modelState(message, lane) {
         if (!this.runtime.catalog || !this.runtime.resolveModelSelection || !this.state.modelPreferences)
             throw new DshRuntimeError('MODEL_UNAVAILABLE');
@@ -740,18 +1047,32 @@ export class BotBridge {
     async commandPanel(message, lane) {
         const match = /^\/(\S+)(?:\s+([\s\S]*))?$/.exec(message.text);
         const command = match?.[1]?.toLowerCase(), args = (match?.[2] ?? '').trim();
+        const interactive = this.cardActionsReady && this.config.cardInteractions && Boolean(this.state.actions);
+        const issue = (target, extra = {}) => this.state.actions.issue({
+            ownerId: message.senderId, chatId: message.chatId, chatType: message.chatType, threadId: message.threadId,
+            sourceMessageId: message.messageId, command: target, ...extra
+        });
         if ((command === 'model' || command === 'thinking') && (!args || /^page [0-9]{1,4}$/.test(args) || message.modelChanged)) {
             const state = await this.modelState(message, lane);
             const current = await this.state.sessions.current(this.sessionContext(message));
-            const interactive = this.cardActionsReady && this.config.cardInteractions && Boolean(this.state.actions);
-            return modelControlPanel(command, state.catalog, state.selection, (label, target, mutation, primary) => {
+            const panel = modelControlPanel(command, state.catalog, state.selection, (label, target, mutation, primary) => {
                 if (!interactive)
                     return;
-                const token = this.state.actions.issue({ ownerId: message.senderId, chatId: message.chatId, chatType: message.chatType,
-                    threadId: message.threadId, sourceMessageId: message.messageId, command: target, expectedSessionId: current?.id ?? null,
+                const token = issue(target, { expectedSessionId: current?.id ?? null,
                     ...(mutation ? { expectedModelRevision: state.preference?.revision ?? null } : {}) });
                 return { label, value: { token }, primary };
             }, /^page /.test(args) ? Number(args.slice(5)) : 0, message.modelChanged);
+            // The settings menu reaches the permission switch from here, without another menu entry.
+            if (interactive && this.harness(message, lane) && this.permissionView(lane))
+                panel.actions = [...panel.actions ?? [], { label: '权限模式', value: { token: issue('/permission') } }];
+            return panel;
+        }
+        if (command === 'permission' && (!args || message.permissionChanged) && this.harness(message, lane)) {
+            const view = await this.permissionChoice(message, lane);
+            if (!view)
+                return;
+            return permissionPanel(view, (label, target, primary, confirm) => interactive
+                ? { label, value: { token: issue(target) }, primary, ...(confirm ? { confirm } : {}) } : undefined, message.permissionChanged);
         }
         // Ordinary conversation and diagnostics stay out of management cards.
         // A card is useful here because the user explicitly wants to pick a topic.
@@ -762,7 +1083,6 @@ export class BotBridge {
         const sessions = await this.state.sessions.list(conversation);
         if (!sessions.length)
             return;
-        const interactive = this.cardActionsReady && this.config.cardInteractions && Boolean(this.state.actions);
         const actions = [];
         const add = (label, target, options = {}) => {
             if (!interactive)
@@ -961,6 +1281,8 @@ export class BotBridge {
             lane.controller?.abort();
             lane.session?.cancel();
         }
+        for (const interaction of [...this.interactions.values()])
+            interaction.stop();
         await Promise.allSettled([...this.admissions]);
         await Promise.all([...this.lanes.values()].map(lane => lane.tail));
         await this.sweepTail;

package/dist/card-actions.js

@@ -5,7 +5,7 @@ import { join } from 'node:path';
 const TTL_MS = 24 * 60 * 60 * 1000;
 const MAX_TOKEN_LENGTH = 3000;
 const HEX_ID = /^[a-f0-9]{12}$/;
-const COMMAND = /^(?:\/(?:help|status|sessions|memory|new|model|thinking|results)|\/(?:model|thinking) (?:use [a-f0-9]{16}|page [0-9]{1,4})|\/memory (?:global|chat|show [a-f0-9]{12})|\/(?:resume|forget|result|publish|answer) [a-f0-9]{12})$/;
+const COMMAND = /^(?:\/(?:help|status|sessions|memory|new|model|thinking|results)|\/(?:model|thinking) (?:use [a-f0-9]{16}|page [0-9]{1,4})|\/memory (?:global|chat|show [a-f0-9]{12})|\/(?:resume|forget|result|publish|answer|approve|deny|reply) [a-f0-9]{12}|\/choose [a-f0-9]{12} [0-9]{1,2}|\/permission(?: use [a-z][a-z0-9-]{0,39})?)$/;
 const PAYLOAD_KEYS = ['version', 'namespace', 'issuedAt', 'expiresAt', 'nonce', 'binding'];
 const BINDING_KEYS = ['ownerId', 'chatId', 'chatType', 'threadId', 'sourceMessageId', 'command', 'expectedSessionId', 'expectedModelRevision'];
 function record(value) {

package/dist/client.cjs

@@ -531,8 +531,8 @@ function ConnectionCard({ api }) {
       ] }),
       /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "lark-connected-row", children: [
         /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [
-          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: "\u6587\u6863\u4E0E\u753B\u677F" }),
-          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: snapshot.capabilities.documents ? "\u5DF2\u542F\u7528 \xB7 \u79C1\u804A\u4F5C\u54C1\u4EC5\u4F9B\u672C\u4EBA\u67E5\u770B" : "\u628A\u590D\u6742\u65B9\u6848\u6574\u7406\u6210\u53EF\u6253\u5F00\u7684\u6587\u6863\u548C\u56FE\u793A" })
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: "\u5B9E\u65F6\u56DE\u590D\u3001\u6587\u6863\u4E0E\u753B\u677F" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: snapshot.capabilities.documents ? "\u5DF2\u542F\u7528 \xB7 \u56DE\u590D\u5B9E\u65F6\u663E\u793A\uFF0C\u79C1\u804A\u4F5C\u54C1\u4EC5\u4F9B\u672C\u4EBA\u67E5\u770B" : "\u5B9E\u65F6\u663E\u793A\u56DE\u590D\u548C\u601D\u8003\u8FC7\u7A0B\uFF0C\u5E76\u628A\u590D\u6742\u65B9\u6848\u6574\u7406\u6210\u6587\u6863\u548C\u56FE\u793A" })
         ] }),
         !snapshot.capabilities.documents && !snapshot.documentSetup && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { className: "lark-secondary", disabled, onClick: () => void mutate("enable-documents"), children: "\u8865\u5145\u9ED8\u8BA4\u6743\u9650" })
       ] }),
@@ -540,7 +540,7 @@ function ConnectionCard({ api }) {
         /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: snapshot.documentSetup.message }),
         snapshot.documentSetup.phase === "preparing" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "lark-spinner", "aria-label": "\u6B63\u5728\u51C6\u5907\u6388\u6743" }),
         snapshot.documentSetup.qr && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
-          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "lark-qr", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("img", { src: snapshot.documentSetup.qr.image, alt: "\u6587\u6863\u4E0E\u753B\u677F\u8865\u5145\u6388\u6743\u4E8C\u7EF4\u7801" }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "lark-qr", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("img", { src: snapshot.documentSetup.qr.image, alt: "\u9ED8\u8BA4\u6743\u9650\u8865\u5145\u6388\u6743\u4E8C\u7EF4\u7801" }) }),
           /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: snapshot.documentSetup.qr.expiresAt <= now ? "\u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u53D6\u6D88\u540E\u91CD\u8BD5\u3002" : "\u626B\u7801\u786E\u8BA4\u540E\u81EA\u52A8\u5B8C\u6210\uFF0C\u804A\u5929\u8FDE\u63A5\u7EE7\u7EED\u4FDD\u6301\u3002" }),
           snapshot.documentSetup.qr.expiresAt > now && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(External, { url: snapshot.documentSetup.qr.url, children: "\u6253\u5F00\u98DE\u4E66\u6388\u6743" })
         ] }),

package/dist/config.d.ts

@@ -4,6 +4,12 @@ export interface UserPolicy {
     groupChats: string[];
     cwd: string;
     allowedTools: string[];
+    /**
+     * 'harness': this user's private chat is a channel into an ordinary Harness
+     * session, with the host's prompt, tools and approvals. Group chats always
+     * use the restricted assistant and allowedTools.
+     */
+    directMode: 'harness' | 'restricted';
 }
 export interface BotConfig {
     profile: string;
@@ -26,6 +32,8 @@ export interface BotConfig {
     cardInteractions: boolean;
     loadingReaction: boolean;
     botMenu: boolean;
+    /** Stream harness-mode private replies into a CardKit card (needs cardkit:card:write). */
+    streamingCards: boolean;
 }
 export declare function parseConfig(value: unknown, baseDir?: string): BotConfig;
 export declare function loadConfig(path: string): Promise<BotConfig>;

package/dist/config.js

@@ -45,11 +45,13 @@ export function parseConfig(value, baseDir = process.cwd()) {
         const allowedTools = strings(user.allowedTools ?? [], 'user.allowedTools');
         if (allowedTools.some(t => !/^[a-zA-Z0-9_.:-]+$/.test(t) || t === 'run_code'))
             throw new Error('allowedTools requires exact tool names; run_code and wildcards are forbidden');
+        if (user.directMode !== undefined && user.directMode !== 'harness' && user.directMode !== 'restricted')
+            throw new Error('user.directMode must be harness or restricted');
         return {
             openId: id(user.openId, 'ou', 'user.openId'),
             direct: user.direct === true,
             groupChats: strings(user.groupChats ?? [], 'user.groupChats').map(v => id(v, 'oc', 'group chat')),
-            cwd: resolve(cwd), allowedTools,
+            cwd: resolve(cwd), allowedTools, directMode: user.directMode ?? 'restricted',
         };
     });
     if (new Set(users.map(u => u.openId)).size !== users.length)
@@ -62,6 +64,8 @@ export function parseConfig(value, baseDir = process.cwd()) {
         throw new Error('loadingReaction must be boolean');
     if (data.botMenu !== undefined && typeof data.botMenu !== 'boolean')
         throw new Error('botMenu must be boolean');
+    if (data.streamingCards !== undefined && typeof data.streamingCards !== 'boolean')
+        throw new Error('streamingCards must be boolean');
     return {
         profile, botOpenId: id(data.botOpenId, 'ou', 'botOpenId'),
         executable: string(data.executable ?? 'lark-cli', 'executable'),
@@ -69,7 +73,8 @@ export function parseConfig(value, baseDir = process.cwd()) {
         provider: data.provider === undefined ? undefined : string(data.provider, 'provider'),
         model: data.model === undefined ? undefined : string(data.model, 'model'),
         users,
-        turnTimeoutMs: integer(data.turnTimeoutMs, 120_000, 1000, 1_800_000, 'turnTimeoutMs'),
+        // A harness-mode chat does research and tool work, and may wait minutes for an approval.
+        turnTimeoutMs: integer(data.turnTimeoutMs, users.some(user => user.directMode === 'harness') ? 900_000 : 120_000, 1000, 1_800_000, 'turnTimeoutMs'),
         idleTimeoutMs: integer(data.idleTimeoutMs, 1_800_000, 1000, 86_400_000, 'idleTimeoutMs'),
         maxSessions: integer(data.maxSessions, 100, 1, 1000, 'maxSessions'),
         maxSessionsPerUser: integer(data.maxSessionsPerUser, 10, 1, 100, 'maxSessionsPerUser'),
@@ -82,6 +87,7 @@ export function parseConfig(value, baseDir = process.cwd()) {
         cardInteractions: data.cardInteractions === true,
         loadingReaction: data.loadingReaction === true,
         botMenu: data.botMenu === true,
+        streamingCards: data.streamingCards === true,
     };
 }
 export async function loadConfig(path) {