lark-remote 0.5.12 → 0.5.13

package/dist/message-handlers.js

@@ -0,0 +1,275 @@
+import fs from 'node:fs';
+import { COMPACT_ACTION_CMDS, DIRECT_RETURN_CMDS, SESSION_MUTATING_ACTION_CMDS, isImmediateAction, } from './router/index.js';
+import { InboundTurnAssembler } from './inbound/turn-assembler.js';
+import { InboundAuthorizer } from './inbound/authorize.js';
+import { stripPlaceholders } from './inbound/placeholder.js';
+import { agentDisplayName } from './card/card-shared.js';
+import { sleep } from './common/sleep.js';
+import { bestEffortUnlink } from './common/fs.js';
+import { dispatchOrderExecForQueue } from './router/order-exec-dispatch.js';
+import { buildCardActionFullValue } from './router/card-action-payload.js';
+import { actionFeedbackText } from './router/card-action-feedback.js';
+const SESSION_MUTATING_FLUSH_BUDGET_MS = 2_000;
+/**
+ * /stop 命令别名单源：普通消息的停止分支与 clone 活跃期拦截的排除条件
+ * 共用同一判定，防止将来加别名时两处漂移。
+ */
+export function isStopCommand(text) {
+    const t = text.trim().toLowerCase();
+    return t === '/stop' || t === '/t';
+}
+export function setupMessageHandlers(deps) {
+    const { connector, router, bridge, sessionStore, workspaceStore, binder, logger, config, cloneSession, } = deps;
+    // 入站统一装配器：图/文任意顺序 → 同一个 turn、同一个 prompt。
+    const assembler = new InboundTurnAssembler({
+        onCommit: (turn, prompt) => {
+            const messageId = turn.messageIds[turn.messageIds.length - 1] ?? '';
+            const ctx = {
+                userId: turn.userId,
+                chatId: turn.chatId,
+                messageId,
+                turnMessageIds: turn.messageIds,
+            };
+            let cwd = sessionStore.getCwd(turn.userId) ?? '';
+            if (!cwd) {
+                const recent = [...workspaceStore.list()].sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+                if (recent.length > 0)
+                    cwd = recent[0].path;
+            }
+            const binding = bridge.currentBinding(turn.userId);
+            bridge.enqueue(cwd, async () => {
+                await router.handle(prompt, ctx, {
+                    cwdOverride: cwd,
+                    binding,
+                    allowCommandPrefix: false,
+                });
+            }, {
+                taskMeta: {
+                    userId: turn.userId,
+                    chatId: turn.chatId,
+                    messageId,
+                    messagePreview: prompt.slice(0, 3000),
+                    binding,
+                },
+            });
+        },
+        onReceipt: async (ctx, text) => {
+            await bridge.sendResult({ text }, ctx);
+        },
+    });
+    router.setInboundFlusher(() => assembler.flushAll('flush'));
+    const authorizer = new InboundAuthorizer({
+        binder,
+        onBind: (userId, chatId) => {
+            let resolvedCwd;
+            try {
+                resolvedCwd = fs.realpathSync(process.cwd());
+            }
+            catch {
+                resolvedCwd = process.cwd();
+            }
+            if (!sessionStore.getCwd(userId)) {
+                sessionStore.setCwd(userId, resolvedCwd);
+            }
+            return (async () => {
+                try {
+                    await connector.sendWithRetry(chatId, {
+                        text: `✅ 已绑定到本账号，此后仅你可使用本应用\n` +
+                            `📂 当前工作目录: \`${resolvedCwd}\`\n` +
+                            `🤖 默认 Agent: ${agentDisplayName(config.defaultAgent)}\n` +
+                            `💡 直接输入消息即可开始对话，或 /cd 切换目录`,
+                    });
+                    const helpResult = router.cmdHelp();
+                    if (helpResult.card) {
+                        await connector.sendWithRetry(chatId, { card: helpResult.card });
+                    }
+                }
+                catch (err) {
+                    logger.error('[binder] onboarding send failed:', err);
+                }
+            })();
+        },
+    });
+    connector.setInboundMediaDetectedHandler((msg) => {
+        const authorization = authorizer.authorize(msg.userId, msg.chatId);
+        if (authorization === 'rejected') {
+            logger.warn(`[media] rejected inbound media from non-owner ${msg.userId}`);
+            return;
+        }
+        if (cloneSession.isActive()) {
+            logger.info(`[media] dropped inbound media during clone session ${msg.messageId}`);
+            return;
+        }
+        if (!router.config.inboundMedia.enabled) {
+            assembler.ingest({
+                kind: 'rejected',
+                userId: msg.userId,
+                chatId: msg.chatId,
+                messageId: msg.messageId,
+                replyToMessageId: msg.replyToMessageId,
+                rawContentType: msg.rawContentType,
+                rejectedKind: 'file',
+                reason: '入站媒体保存已关闭（inboundMedia.enabled: false），未保存文件。' +
+                    '如需自动保存图片/文件，请开启后重试',
+            });
+            return;
+        }
+        const outcome = (async () => {
+            const payload = await connector.downloadInboundMedia(msg, {
+                maxFileSizeMb: router.config.inboundMedia.maxFileSizeMb,
+            });
+            try {
+                return await bridge.saveInboundMedia(payload);
+            }
+            catch (err) {
+                for (const item of payload.media)
+                    bestEffortUnlink(item.tempPath);
+                throw err;
+            }
+        })();
+        assembler.ingest({
+            kind: 'media',
+            userId: msg.userId,
+            chatId: msg.chatId,
+            messageId: msg.messageId,
+            replyToMessageId: msg.replyToMessageId,
+            rawContentType: msg.rawContentType,
+            outcome,
+        });
+    });
+    connector.setMessageHandler((msg) => {
+        const decision = authorizer.authorize(msg.userId, msg.chatId);
+        if (decision === 'rejected' || decision === 'bind_success')
+            return;
+        logger.info(`message from ${msg.userId} (${msg.rawContentType}): ${msg.content.slice(0, 100)}`);
+        void connector.addReaction(msg.messageId, 'Typing');
+        if (cloneSession.isActive() && !isStopCommand(msg.content)) {
+            void cloneSession
+                .handleMessage(msg.content, {
+                userId: msg.userId,
+                chatId: msg.chatId,
+                messageId: msg.messageId,
+            })
+                .catch((err) => logger.error('[clone] message handling failed:', err));
+            return;
+        }
+        const content = router.expandAliasMessage(msg.content);
+        if (isStopCommand(content)) {
+            void (async () => {
+                const interrupt = await bridge.interruptCurrentRunDetailed({
+                    userId: msg.userId,
+                    chatId: msg.chatId,
+                });
+                const ctx = { userId: msg.userId, chatId: msg.chatId, messageId: msg.messageId };
+                if (!interrupt.stopped) {
+                    await bridge.sendResult({ text: '当前没有运行中的进程' }, ctx);
+                }
+                else if ((interrupt.stoppedCount ?? 1) > 1) {
+                    await bridge.sendResult({ text: `✅ 已停止 ${interrupt.stoppedCount} 个运行中的任务` }, ctx);
+                }
+            })().catch((err) => logger.error('[control] /stop failed:', err));
+            return;
+        }
+        const stripped = stripPlaceholders(content);
+        if (stripped.unknownTags.length > 0) {
+            logger.warn(`[inbound] unknown placeholder tags stripped: ${stripped.unknownTags.join(', ')} ` +
+                `(msg_type=${msg.rawContentType})`);
+        }
+        const commandEligible = msg.rawContentType === 'text' && stripped.kinds.length === 0 && stripped.clean !== '';
+        if (commandEligible && (stripped.clean.startsWith('/') || stripped.clean.startsWith('!'))) {
+            void (async () => {
+                await assembler.flush(msg.userId, msg.chatId, 'flush');
+                await router.handle(stripped.clean, {
+                    userId: msg.userId,
+                    chatId: msg.chatId,
+                    messageId: msg.messageId,
+                }, { allowCommandPrefix: true });
+            })().catch((err) => logger.error('[control] command failed:', err));
+            return;
+        }
+        assembler.ingest({
+            kind: 'text',
+            userId: msg.userId,
+            chatId: msg.chatId,
+            messageId: msg.messageId,
+            replyToMessageId: msg.replyToMessageId,
+            rawContentType: msg.rawContentType,
+            text: stripped.clean,
+            placeholders: stripped.kinds,
+            unknownTags: stripped.unknownTags,
+        });
+    });
+    connector.setCardActionHandler(async (action) => {
+        if (!binder.isOwner(action.operator.openId)) {
+            binder.recordRejectedCardAction(action.operator.openId);
+            return;
+        }
+        const actionValue = action.action.value;
+        if (!actionValue?.cmd)
+            return;
+        logger.info(`card action: ${actionValue.cmd}`);
+        const userId = action.operator.openId;
+        const chatId = action.chatId;
+        const messageId = action.messageId;
+        void connector.addReaction(messageId, 'Typing');
+        if (actionValue.cmd === 'stop') {
+            void router
+                .handleCardAction({ ...actionValue, cmd: 'stop' }, { userId, chatId, messageId })
+                .catch((err) => logger.error('[control] card stop failed:', err));
+            return;
+        }
+        const isImmediate = isImmediateAction(actionValue.cmd);
+        const cwd = sessionStore.getCwd(userId) ?? '';
+        const fullValue = buildCardActionFullValue(actionValue, action);
+        if (SESSION_MUTATING_ACTION_CMDS.has(actionValue.cmd)) {
+            const flushP = assembler
+                .flush(userId, chatId, 'flush')
+                .catch((err) => logger.error('[control] inbound flush failed:', err));
+            await Promise.race([flushP, sleep(SESSION_MUTATING_FLUSH_BUDGET_MS)]);
+        }
+        if (DIRECT_RETURN_CMDS.has(actionValue.cmd)) {
+            return router.handleCardAction(fullValue, { userId, chatId, messageId });
+        }
+        if (actionValue.cmd === 'order.exec') {
+            void dispatchOrderExecForQueue({
+                router,
+                bridge,
+                cwd,
+                orderId: actionValue.orderId,
+                ctx: { userId, chatId, messageId },
+            }).catch((err) => logger.error('[control] order.exec dispatch failed:', err));
+            return;
+        }
+        const forwardActionFeedback = (res) => {
+            const text = actionFeedbackText(res);
+            if (!text)
+                return;
+            void bridge
+                .sendResult({ text }, { userId, chatId, messageId })
+                .catch((err) => logger.error('[control] card action feedback failed:', err));
+        };
+        if (isImmediate) {
+            bridge.enqueueImmediate(cwd, async () => {
+                const res = await router.handleCardAction(fullValue, { userId, chatId, messageId });
+                forwardActionFeedback(res);
+            });
+        }
+        else {
+            bridge.enqueue(cwd, async () => {
+                const res = await router.handleCardAction(fullValue, { userId, chatId, messageId });
+                forwardActionFeedback(res);
+            }, {
+                taskMeta: {
+                    userId,
+                    chatId,
+                    messageId: router.mintQueueTaskKey('card', actionValue.cmd),
+                    feishuReplyTo: messageId,
+                    messagePreview: `card action: ${actionValue.cmd}`,
+                    kind: COMPACT_ACTION_CMDS.has(actionValue.cmd) ? 'compact' : 'command',
+                    editable: !COMPACT_ACTION_CMDS.has(actionValue.cmd),
+                },
+            });
+        }
+    });
+}
+//# sourceMappingURL=message-handlers.js.map

package/dist/router/card-action-payload.d.ts

@@ -9,7 +9,7 @@
  * out-of-band fields.
  *
  * Extracted from src/index.ts so the entry transform is behavior-testable
- * (the main() wiring itself cannot be injected, see index-wiring.test.ts).
+ * (see message-handlers.ts / message-handlers.test.ts).
  */
 import type { CardActionEvent } from '@larksuite/channel';
 import type { CardActionPayload } from './index.js';

package/dist/router/card-action-payload.js

@@ -9,7 +9,7 @@
  * out-of-band fields.
  *
  * Extracted from src/index.ts so the entry transform is behavior-testable
- * (the main() wiring itself cannot be injected, see index-wiring.test.ts).
+ * (see message-handlers.ts / message-handlers.test.ts).
  */
 /**
  * Build the full card action payload for router.handleCardAction.

package/dist/router/commands/ls.d.ts

@@ -0,0 +1,9 @@
+import type { CommandContext, CommandResult } from '../../bridge/index.js';
+export declare const LS_PAGE_SIZE = 30;
+export interface LsCommandOptions {
+    cwd?: string;
+    offset?: number;
+    rootDir?: string;
+    q?: string;
+}
+export declare function buildLsCommand(args: string[], _ctx: CommandContext, options: LsCommandOptions): CommandResult;

package/dist/router/commands/ls.js

@@ -0,0 +1,243 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { cardButton } from '../../card/card-shared.js';
+import { paginationBar, searchBar } from '../card-helpers.js';
+import { inspectPath, statPath } from '../path-validation.js';
+import { pageSlice } from '../paging.js';
+export const LS_PAGE_SIZE = 30;
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+}
+function buildFileCard(filePath) {
+    const resolution = statPath(filePath);
+    const stat = resolution.ok ? resolution.stat : undefined;
+    const sizeText = stat ? formatBytes(stat.size) : '未知';
+    const mtimeText = stat ? stat.mtime.toLocaleString('zh-CN', { hour12: false }) : '未知';
+    const parentDir = path.dirname(filePath);
+    const buttons = [
+        cardButton('📎 下载', { cmd: 'ls.file', path: filePath }, { type: 'primary', size: 'small' }),
+    ];
+    if (parentDir !== filePath) {
+        buttons.push(cardButton('上级', { cmd: 'ls.browse', path: parentDir, root: parentDir }, { type: 'default', size: 'small' }));
+    }
+    return {
+        card: {
+            schema: '2.0',
+            config: { wide_screen_mode: true, update_multi: true },
+            header: {
+                title: { tag: 'plain_text', content: `📄 ${path.basename(filePath)}` },
+                template: 'blue',
+            },
+            body: {
+                elements: [
+                    { tag: 'div', text: { tag: 'lark_md', content: `\`${filePath}\`\n${sizeText}` } },
+                    { tag: 'div', text: { tag: 'lark_md', content: `修改时间: ${mtimeText}` } },
+                    {
+                        tag: 'column_set',
+                        columns: buttons.map((button) => ({
+                            tag: 'column',
+                            width: 'auto',
+                            elements: [button],
+                        })),
+                    },
+                ],
+            },
+        },
+    };
+}
+export function buildLsCommand(args, _ctx, options) {
+    const { cwd, offset = 0, rootDir } = options;
+    if (!cwd)
+        return { text: '请先使用 /cd <path> 设置工作目录' };
+    const filter = options.q?.trim() || undefined;
+    let targetDir = cwd;
+    if (args[0]) {
+        const arg = args[0].startsWith('~') ? path.join(os.homedir(), args[0].slice(1)) : args[0];
+        const potentialDir = path.resolve(cwd, arg);
+        const kind = inspectPath(potentialDir);
+        if (kind === 'missing' || kind === 'unreadable') {
+            return { text: `ls: ${args[0]}: No such file or directory` };
+        }
+        if (kind === 'file')
+            return buildFileCard(potentialDir);
+        targetDir = potentialDir;
+    }
+    const browseRoot = rootDir ? path.resolve(cwd, rootDir) : targetDir;
+    try {
+        const entries = fs.readdirSync(targetDir, { withFileTypes: true });
+        const dirs = [];
+        const files = [];
+        for (const entry of entries) {
+            let isDir = entry.isDirectory();
+            let size;
+            if (!isDir) {
+                const resolution = statPath(path.join(targetDir, entry.name));
+                if (resolution.ok) {
+                    isDir = resolution.stat.isDirectory();
+                    if (!isDir)
+                        size = resolution.stat.size;
+                }
+            }
+            if (isDir)
+                dirs.push(entry.name);
+            else
+                files.push({ name: entry.name, size });
+        }
+        dirs.sort((a, b) => a.localeCompare(b));
+        files.sort((a, b) => a.name.localeCompare(b.name));
+        const allItems = [
+            ...dirs.map((name) => ({ name, isDir: true })),
+            ...files.map((file) => ({ name: file.name, isDir: false, size: file.size })),
+        ];
+        const ql = filter?.toLowerCase();
+        const visibleItems = ql
+            ? allItems.filter((item) => item.name.toLowerCase().includes(ql))
+            : allItems;
+        const visibleDirCount = visibleItems.reduce((count, item) => count + (item.isDir ? 1 : 0), 0);
+        const visibleFileCount = visibleItems.length - visibleDirCount;
+        const { totalCount, totalPages, safeOffset, currentPage, pageItems, hasPagination } = pageSlice(visibleItems, offset, LS_PAGE_SIZE);
+        const parentDir = path.dirname(targetDir);
+        const headerElements = [];
+        if (parentDir !== targetDir) {
+            headerElements.push(cardButton('上级', { cmd: 'ls.browse', path: parentDir, root: browseRoot }, { type: 'default', size: 'small' }));
+        }
+        if (targetDir !== browseRoot) {
+            headerElements.push(cardButton('返回', { cmd: 'ls.browse', path: browseRoot, root: browseRoot }, { type: 'default', size: 'small' }));
+        }
+        headerElements.push(cardButton('刷新', {
+            cmd: 'ls.refresh',
+            path: targetDir,
+            offset: safeOffset,
+            root: browseRoot,
+            ...(filter ? { q: filter } : {}),
+        }, { type: 'default', size: 'small' }));
+        if (targetDir !== cwd) {
+            headerElements.push(cardButton('切换', { cmd: 'ls.switch', path: targetDir, root: browseRoot }, { type: 'primary', size: 'small' }));
+        }
+        const dirButton = (name) => cardButton(`📁 ${name}`, { cmd: 'ls.browse', path: path.join(targetDir, name), root: browseRoot }, { type: 'default' });
+        const fileButton = (name, size) => cardButton(`📄 ${name}${size !== undefined ? ` (${formatBytes(size)})` : ''}`, { cmd: 'ls.file', path: path.join(targetDir, name) }, { type: 'default', size: 'small' });
+        const elements = [
+            {
+                tag: 'div',
+                text: {
+                    tag: 'lark_md',
+                    content: `\`${targetDir}\`\n共 ${visibleDirCount} 目录, ${visibleFileCount} 文件`,
+                },
+            },
+            {
+                tag: 'column_set',
+                columns: headerElements.map((element) => ({
+                    tag: 'column',
+                    width: 'auto',
+                    elements: [element],
+                })),
+            },
+            { tag: 'hr' },
+            searchBar({
+                cmd: 'ls.filter',
+                placeholder: '搜索本层目录/文件名，输完回车',
+                currentQuery: filter,
+                extra: { path: targetDir, root: browseRoot },
+            }),
+        ];
+        if (filter) {
+            elements.push({
+                tag: 'div',
+                text: {
+                    tag: 'lark_md',
+                    content: `🔍 筛选："${filter}" · 命中 ${totalCount} 项（点「清除筛选」取消）`,
+                },
+            });
+        }
+        const pageDirs = pageItems.filter((item) => item.isDir);
+        const pageFiles = pageItems.filter((item) => !item.isDir);
+        if (filter && visibleItems.length === 0) {
+            elements.push({
+                tag: 'div',
+                text: { tag: 'lark_md', content: `🔍 无匹配条目（关键词："${filter}"）` },
+            });
+        }
+        else {
+            elements.push({
+                tag: 'div',
+                text: { tag: 'lark_md', content: `**📂 目录 (${visibleDirCount})**` },
+            });
+            if (pageDirs.length > 0) {
+                for (const dir of pageDirs) {
+                    elements.push({
+                        tag: 'column_set',
+                        flex_mode: 'none',
+                        columns: [{ tag: 'column', width: 'auto', elements: [dirButton(dir.name)] }],
+                    });
+                }
+            }
+            else if (visibleDirCount === 0) {
+                elements.push({ tag: 'div', text: { tag: 'lark_md', content: '无子目录' } });
+            }
+            else {
+                elements.push({
+                    tag: 'div',
+                    text: { tag: 'lark_md', content: `（第 ${currentPage} 页无目录）` },
+                });
+            }
+            elements.push({ tag: 'hr' });
+            elements.push({
+                tag: 'div',
+                text: { tag: 'lark_md', content: `**📄 文件 (${visibleFileCount})**` },
+            });
+            if (pageFiles.length > 0) {
+                for (const file of pageFiles) {
+                    elements.push({
+                        tag: 'column_set',
+                        flex_mode: 'none',
+                        columns: [
+                            { tag: 'column', width: 'auto', elements: [fileButton(file.name, file.size)] },
+                        ],
+                    });
+                }
+            }
+            else if (visibleFileCount === 0) {
+                elements.push({ tag: 'div', text: { tag: 'lark_md', content: '无文件' } });
+            }
+            else {
+                elements.push({
+                    tag: 'div',
+                    text: { tag: 'lark_md', content: `（第 ${currentPage} 页无文件）` },
+                });
+            }
+        }
+        if (hasPagination) {
+            elements.push({ tag: 'hr' });
+            elements.push(...paginationBar({
+                cmd: 'ls.page',
+                offset: safeOffset,
+                pageSize: LS_PAGE_SIZE,
+                total: totalCount,
+                extra: { path: targetDir, root: browseRoot, ...(filter ? { q: filter } : {}) },
+                label: `**第 ${currentPage}/${totalPages} 页**（共 ${totalCount} 项）`,
+            }));
+        }
+        return {
+            card: {
+                schema: '2.0',
+                config: { wide_screen_mode: true, update_multi: true },
+                header: {
+                    title: { tag: 'plain_text', content: `📁 ${path.basename(targetDir)}` },
+                    template: 'blue',
+                },
+                body: { elements },
+            },
+        };
+    }
+    catch (err) {
+        return { text: `读取目录失败: ${err.message}` };
+    }
+}
+//# sourceMappingURL=ls.js.map

package/dist/router/commands/order.d.ts

@@ -0,0 +1,12 @@
+import type { CommandContext, CommandResult } from '../../bridge/index.js';
+import type { OrderEntry } from '../../order/index.js';
+export declare const ORDER_PAGE_SIZE = 8;
+export interface OrderCommandDeps {
+    reload(): void;
+    list(): OrderEntry[];
+    save(text: string): void;
+    updateText(id: string, text: string): void;
+    setAlias(id: string, alias: string | undefined): void;
+    resolveTarget(target: string): OrderEntry | undefined;
+}
+export declare function buildOrderCommand(args: string[], ctx: CommandContext, offset: number, deps: OrderCommandDeps): CommandResult;