@cubeai/dsh-feishu-channels 0.0.0-stage → 0.2.0

package/src/engine/secure-file.js

@@ -0,0 +1,8 @@
+import { writeFileAtomicSync } from './atomic-file.js';
+/**
+ * 覆盖写入仅供当前用户读取的本地状态文件。
+ * POSIX 上 mode/chmod 会强制 0600；Windows 会继续继承用户目录 ACL。
+ */
+export function writePrivateFileSync(file, data) {
+    writeFileAtomicSync(file, data, 0o600);
+}

package/src/engine/seen-store.js

@@ -0,0 +1,43 @@
+import { readFileSync } from 'node:fs';
+import { backupCorruptFileSync, writeFileAtomicSync } from './atomic-file.js';
+/** 去重最近见过的消息 id，避免重启或重复投递打两次。 */
+export class SeenStore {
+    file;
+    limit;
+    ids = [];
+    known = new Set();
+    constructor(file, limit = 2000) {
+        this.file = file;
+        this.limit = limit;
+        this.load();
+    }
+    has(id) {
+        return this.known.has(id);
+    }
+    add(id) {
+        if (!id || this.has(id))
+            return;
+        this.ids.push(id);
+        this.known.add(id);
+        if (this.ids.length > this.limit) {
+            this.ids = this.ids.slice(-this.limit);
+            this.known = new Set(this.ids);
+        }
+        this.flush();
+    }
+    load() {
+        try {
+            const parsed = JSON.parse(readFileSync(this.file, 'utf8'));
+            this.ids = Array.isArray(parsed.ids) ? parsed.ids.filter((item) => typeof item === 'string') : [];
+            this.known = new Set(this.ids);
+        }
+        catch {
+            backupCorruptFileSync(this.file);
+            this.ids = [];
+            this.known.clear();
+        }
+    }
+    flush() {
+        writeFileAtomicSync(this.file, `${JSON.stringify({ ids: this.ids }, null, 2)}\n`);
+    }
+}

package/src/engine/session-export.js

@@ -0,0 +1,64 @@
+import { fileOperation, timeoutSignal } from './abort.js';
+import { replyText } from './command-locale.js';
+/** 复用宿主已注册的 Chat ZIP 路由；不连接网络，不接收任意 URL 或会话 ID 参数。 */
+export async function exportSession(host, channel, chatId, sessionId, parent, stillCurrent) {
+    const signal = timeoutSignal(120_000, parent);
+    const fallback = () => replyText('会话未能导出或发送。请在网页 Chat 中打开这条会话，执行 /export 下载 ZIP。');
+    try {
+        signal.throwIfAborted();
+        const connection = host.get('connection');
+        if (!channel.sendFile || !connection?.createSharedFetchHandler)
+            throw new Error('export-unavailable');
+        if (!stillCurrent())
+            throw new Error('binding-changed');
+        // 这是宿主内部已授权的路由分发；准入和命令权限由 IM 网关先检查。
+        const url = new URL('http://dsh.invalid/api/session.export');
+        url.searchParams.set('sessionId', sessionId);
+        url.searchParams.set('includeDescendants', 'false');
+        // 0.2.1 的共享路由要求真实宿主 Peer；旧宿主没有此字段且忽略额外参数。
+        const pending = connection.createSharedFetchHandler('/api').fetch(new Request(url, { signal }), connection.browserPeer);
+        void pending.then(response => { if (signal.aborted)
+            void response.body?.cancel().catch(() => { }); }, () => { });
+        const response = await fileOperation(pending, signal);
+        const reader = response.body?.getReader();
+        let complete = false;
+        const chunks = [];
+        let size = 0;
+        try {
+            if (!response.ok || !response.headers.get('content-type')?.toLowerCase().startsWith('application/zip') || !reader)
+                throw new Error('export-response');
+            for (;;) {
+                const part = await fileOperation(reader.read(), signal);
+                if (part.done) {
+                    complete = true;
+                    break;
+                }
+                size += part.value.byteLength;
+                // 渠道接口接收完整字节；流式限额避免会话附件耗尽插件内存。
+                if (size > 32 * 1024 * 1024)
+                    throw new Error('export-too-large');
+                chunks.push(part.value);
+            }
+        }
+        finally {
+            if (!complete)
+                void reader?.cancel().catch(() => { });
+            reader?.releaseLock();
+        }
+        if (!size)
+            throw new Error('export-empty');
+        signal.throwIfAborted();
+        if (!stillCurrent())
+            throw new Error('binding-changed');
+        const name = `session-${sessionId.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 100)}.zip`;
+        await fileOperation(channel.sendFile(chatId, { name, data: Buffer.concat(chunks, size) }, signal), signal);
+        return replyText('会话已导出，ZIP 文件已发送。');
+    }
+    catch (error) {
+        if (parent.aborted)
+            throw parent.reason;
+        if (error instanceof Error && error.message === 'export-too-large')
+            throw new Error(replyText('会话 ZIP 超过 32 MiB，未发送。请在网页 Chat 中执行 /export 下载。'));
+        throw new Error(fallback(), { cause: error });
+    }
+}

package/src/engine/session-history.js

@@ -0,0 +1,30 @@
+/**
+ * 官方 Session 没有公开 events，同步活日志是 snapshotEvents。
+ * events 只服务夹具和非官方对象；空数组继续往下看，避免把“还没写上”当成没有历史。
+ */
+export function readLiveSessionHistory(session) {
+    if (Array.isArray(session?.events) && session.events.length > 0)
+        return session.events;
+    if (typeof session?.snapshotEvents === 'function') {
+        const snapshot = session.snapshotEvents();
+        if (Array.isArray(snapshot))
+            return snapshot;
+    }
+    if (Array.isArray(session?.events))
+        return session.events;
+    return undefined;
+}
+/** 冷读优先 inspect；空结果或失败再回退活日志，不能把一次空存储前缀当成日志不存在。 */
+export async function readSessionHistory(host, session, signal) {
+    const id = session?.id;
+    const controller = host?.get?.('sessionController');
+    if (id && typeof controller?.inspect === 'function') {
+        try {
+            const inspection = await controller.inspect(id, signal);
+            if (Array.isArray(inspection?.events) && inspection.events.length > 0)
+                return inspection.events;
+        }
+        catch { /* 继续回退，不能把一次冷读失败当成日志不存在。 */ }
+    }
+    return readLiveSessionHistory(session);
+}

package/src/engine/session-id.js

@@ -0,0 +1,62 @@
+/** Feishu channel session identity: separate from web tasks by id prefix. */
+export const DFC_ORIGIN = 'dfc';
+export const DFC_SESSION_PREFIX = 'dfc:';
+
+export function sessionKeyOf(channel, kind, chatId) {
+    return `${channel}:${kind}:${chatId}`;
+}
+
+let lastStamp = 0;
+
+/** New sessions use a timestamped unique id; same-millisecond creates increment. */
+export function createFeishuSessionId(channel, kind, chatId, now = Date.now()) {
+    const stamp = now <= lastStamp ? lastStamp + 1 : now;
+    lastStamp = stamp;
+    return `${DFC_SESSION_PREFIX}${channel}:${kind}:${stamp}:${chatId}`;
+}
+
+export function isFeishuSessionId(sessionId) {
+    return typeof sessionId === 'string' && sessionId.startsWith(DFC_SESSION_PREFIX);
+}
+
+const CHANNEL_IDS = ['feishu'];
+const STAMP_RE = /^\d{13,}$/;
+
+export function parseFeishuSessionId(sessionId) {
+    if (!isFeishuSessionId(sessionId))
+        return undefined;
+    const rest = sessionId.slice(DFC_SESSION_PREFIX.length);
+    const first = rest.indexOf(':');
+    const second = rest.indexOf(':', first + 1);
+    if (first <= 0 || second <= first)
+        return undefined;
+    const channel = rest.slice(0, first);
+    const kind = rest.slice(first + 1, second);
+    let chatId = rest.slice(second + 1);
+    const third = chatId.indexOf(':');
+    if (third > 0 && STAMP_RE.test(chatId.slice(0, third))) {
+        chatId = chatId.slice(third + 1);
+    }
+    const platform = channel.split('_', 1)[0];
+    const validInstance = CHANNEL_IDS.includes(platform) && /^[a-z0-9_-]+$/.test(channel);
+    if (!validInstance || (kind !== 'dm' && kind !== 'group') || chatId === '')
+        return undefined;
+    return { channel, kind, chatId };
+}
+
+export function isFeishuOrigin(origin) {
+    return origin === DFC_ORIGIN;
+}
+
+/** Task list visibility: exclude channel sessions and subagents. */
+export function isTaskSession(input) {
+    if (input.blank === true)
+        return false;
+    if (isFeishuOrigin(input.origin))
+        return false;
+    if (typeof input.id === 'string' && isFeishuSessionId(input.id))
+        return false;
+    if (input.origin === 'subagent')
+        return false;
+    return true;
+}

package/src/engine/session-store.js

@@ -0,0 +1,109 @@
+import { constants, copyFileSync, readFileSync } from 'node:fs';
+import { backupCorruptFileSync, writeFileAtomicSync } from './atomic-file.js';
+export class SessionMapStore {
+    file;
+    records = {};
+    historyBackupTaken = false;
+    constructor(file) {
+        this.file = file;
+        this.load();
+    }
+    list() {
+        return Object.values(this.records).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    get(key) {
+        return this.records[key];
+    }
+    /** 按会话查找不需要列表的更新时间排序。 */
+    findSession(sessionId) {
+        let detached;
+        for (const key in this.records) {
+            const record = this.records[key];
+            if (record.sessionId !== sessionId)
+                continue;
+            if (!record.detached)
+                return record;
+            detached = record;
+        }
+        return detached;
+    }
+    upsert(key, record) {
+        const before = { ...this.records };
+        const old = this.records[key];
+        if (old && old.sessionId !== record.sessionId) {
+            this.backupBeforeHistory();
+            this.records[`history:${old.sessionId}`] = old;
+        }
+        this.records[key] = record;
+        if (key !== `history:${record.sessionId}`)
+            delete this.records[`history:${record.sessionId}`];
+        try {
+            this.flush();
+        }
+        catch (error) {
+            this.records = before;
+            throw error;
+        }
+    }
+    retain(key) {
+        const record = this.records[key];
+        if (!record)
+            return;
+        this.backupBeforeHistory();
+        this.records[`history:${record.sessionId}`] = record;
+        delete this.records[key];
+        this.flush();
+    }
+    saveHistory(record) {
+        if (this.list().some(item => item.sessionId === record.sessionId))
+            return;
+        this.backupBeforeHistory();
+        this.upsert(`history:${record.sessionId}`, record);
+    }
+    updateSession(record) {
+        for (const key of Object.keys(this.records)) {
+            if (this.records[key]?.sessionId === record.sessionId)
+                this.records[key] = record;
+        }
+        this.flush();
+    }
+    removeSession(sessionId) {
+        for (const key of Object.keys(this.records)) {
+            if (this.records[key]?.sessionId === sessionId)
+                delete this.records[key];
+        }
+        this.flush();
+    }
+    remove(key) {
+        delete this.records[key];
+        this.flush();
+    }
+    load() {
+        try {
+            const parsed = JSON.parse(readFileSync(this.file, 'utf8'));
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                throw new TypeError('会话映射顶层必须是对象');
+            this.records = parsed;
+        }
+        catch {
+            backupCorruptFileSync(this.file);
+            this.records = {};
+        }
+    }
+    flush() {
+        writeFileAtomicSync(this.file, `${JSON.stringify(this.records, null, 2)}\n`);
+    }
+    backupBeforeHistory() {
+        if (this.historyBackupTaken)
+            return;
+        try {
+            copyFileSync(this.file, `${this.file}.before-history.json`, constants.COPYFILE_EXCL);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ENOENT' && code !== 'EEXIST')
+                throw error;
+        }
+        this.historyBackupTaken = true;
+    }
+}

package/src/engine/session-title.js

@@ -0,0 +1,29 @@
+import { stripVTControlCharacters } from 'node:util';
+/** 仅接受已知宿主标题来源；未知事件不能覆盖迁移前的名称。 */
+export function readSessionTitle(data) {
+    if (!data || typeof data !== 'object')
+        return undefined;
+    const value = data;
+    if (typeof value.title !== 'string' || !value.title.trim())
+        return undefined;
+    const kind = value.source?.kind;
+    if (kind !== 'user' && kind !== 'provider' && kind !== 'fallback')
+        return undefined;
+    return { title: value.title, source: kind === 'user' ? 'user' : 'host' };
+}
+/** 首条原始消息的本地兜底标题；不调用重命名接口，以免锁住宿主自动命名。 */
+export function initialSessionTitle(text) {
+    const clean = stripVTControlCharacters(text).replace(/[\u0000-\u001f\u007f-\u009f\u200b\u200e\u200f\u202a-\u202e\u2060-\u2064\u2066-\u206f\ufeff]/gu, ' ')
+        .replace(/\s+/gu, ' ').trim();
+    if (!clean)
+        return undefined;
+    if (Buffer.byteLength(clean, 'utf8') <= 60)
+        return clean;
+    let title = '';
+    for (const { segment } of new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(clean)) {
+        if (Buffer.byteLength(title + segment, 'utf8') > 57)
+            break;
+        title += segment;
+    }
+    return `${title.trimEnd()}…`;
+}

package/src/engine/split.js

@@ -0,0 +1,291 @@
+/**
+ * 长文分片：按渠道上限切分，尽量保持 Markdown 结构完整。
+ *
+ * 规则（思路参考 dsh-im，按本仓库的单分片器架构实现）：
+ * - 代码围栏和 GFM 管道表格作为整体参与装片，不拦腰切断；
+ * - 超长围栏拆正文，每片补齐自己的开始和结束标记；
+ * - 超长表格按行拆分，每片重复表头和分隔行；
+ * - 序号前缀只加在纯文字片开头，表格和围栏片不加，否则会破坏结构。
+ */
+const FENCE_MARKER = /^\s{0,3}(`{3,}|~{3,})/;
+/** 序号前缀的最小预留空间；长文按可能的片数扩展。 */
+const PREFIX_ALLOWANCE = 8;
+function codePointLength(value) {
+    return [...value].length;
+}
+/** 表格单元格：跳过转义竖线和行内代码里的竖线，并允许省略外围竖线。 */
+function tableCells(line) {
+    const source = line.endsWith('\r') ? line.slice(0, -1) : line;
+    const cells = [];
+    let cell = '';
+    let separators = 0;
+    let index = 0;
+    while (index < source.length) {
+        const char = source[index];
+        if (char === '\\' && index + 1 < source.length) {
+            cell += source[index + 1];
+            index += 2;
+            continue;
+        }
+        if (char === '`') {
+            let run = 1;
+            while (source[index + run] === '`')
+                run += 1;
+            const marker = '`'.repeat(run);
+            const end = source.indexOf(marker, index + run);
+            if (end === -1) {
+                cell += marker;
+                index += run;
+                continue;
+            }
+            cell += source.slice(index, end + run);
+            index = end + run;
+            continue;
+        }
+        if (char === '|') {
+            cells.push(cell);
+            cell = '';
+            separators += 1;
+            index += 1;
+            continue;
+        }
+        cell += char;
+        index += 1;
+    }
+    if (separators === 0)
+        return null;
+    cells.push(cell);
+    if (cells[0].trim() === '')
+        cells.shift();
+    if (cells.at(-1)?.trim() === '')
+        cells.pop();
+    return cells.length > 0 ? cells : null;
+}
+function fenceMarkerOf(line) {
+    return FENCE_MARKER.exec(line)?.[1];
+}
+/** 结束标记：与开始标记同字符，且不短于开始标记，行内不能有其他内容。 */
+function isFenceClose(line, marker) {
+    const found = fenceMarkerOf(line);
+    if (!found || found[0] !== marker[0] || found.length < marker.length)
+        return false;
+    return line.trim() === found;
+}
+/** 返回表格结束位置（不含）；不是表格返回 -1。 */
+function tableEnd(lines, start) {
+    const header = tableCells(lines[start] ?? '');
+    if (!header)
+        return -1;
+    const separator = tableCells(lines[start + 1] ?? '');
+    if (!separator || separator.length !== header.length)
+        return -1;
+    if (!separator.every((cell) => /^\s*:?-+:?\s*$/.test(cell)))
+        return -1;
+    let end = start + 2;
+    while (end < lines.length) {
+        const cells = tableCells(lines[end] ?? '');
+        if (!cells)
+            break;
+        end += 1;
+    }
+    return end;
+}
+/** 切成「纯文字 / 围栏 / 表格」三种块。未闭合的围栏会补上结束标记。 */
+function toBlocks(text) {
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    const blocks = [];
+    let prose = [];
+    const flushProse = () => {
+        if (!prose.length)
+            return;
+        blocks.push({ kind: 'prose', text: prose.join('\n') });
+        prose = [];
+    };
+    for (let index = 0; index < lines.length; index += 1) {
+        const marker = fenceMarkerOf(lines[index] ?? '');
+        if (marker) {
+            let closing = -1;
+            for (let at = index + 1; at < lines.length; at += 1) {
+                if (isFenceClose(lines[at] ?? '', marker)) {
+                    closing = at;
+                    break;
+                }
+            }
+            flushProse();
+            const body = lines.slice(index, closing === -1 ? lines.length : closing + 1);
+            if (closing === -1)
+                body.push(marker);
+            blocks.push({ kind: 'fence', text: body.join('\n') });
+            index = (closing === -1 ? lines.length : closing + 1) - 1;
+            continue;
+        }
+        const end = tableEnd(lines, index);
+        if (end > index) {
+            flushProse();
+            blocks.push({ kind: 'table', text: lines.slice(index, end).join('\n') });
+            index = end - 1;
+            continue;
+        }
+        prose.push(lines[index] ?? '');
+    }
+    flushProse();
+    return blocks;
+}
+/** 纯文字按换行、句末标点、硬切三级降级。 */
+function splitProse(text, max) {
+    if (codePointLength(text) <= max)
+        return [text];
+    const chars = [...text];
+    const parts = [];
+    let rest = chars;
+    while (rest.length > 0) {
+        if (rest.length <= max) {
+            parts.push(rest.join(''));
+            break;
+        }
+        const window = rest.slice(0, max);
+        let cut = 0;
+        for (let index = window.length - 1; index >= 0; index -= 1) {
+            if (window[index] === '\n') {
+                cut = index + 1;
+                break;
+            }
+        }
+        if (cut === 0) {
+            for (let index = window.length - 1; index >= 0; index -= 1) {
+                if ('。！？…；'.includes(window[index] ?? '')) {
+                    cut = index + 1;
+                    break;
+                }
+            }
+        }
+        if (cut === 0)
+            cut = max;
+        parts.push(rest.slice(0, cut).join(''));
+        rest = rest.slice(cut);
+    }
+    return parts;
+}
+/** 超长围栏：拆正文，每片补齐自己的开始和结束标记。 */
+function splitFence(lines, max) {
+    if (lines.length < 2)
+        return [];
+    const opening = lines[0];
+    const closing = lines.at(-1);
+    const bodyMax = max - codePointLength(opening) - codePointLength(closing) - 2;
+    if (bodyMax < 16)
+        return [];
+    return splitProse(lines.slice(1, -1).join('\n'), bodyMax)
+        .map((piece) => `${opening}\n${piece}${piece.endsWith('\n') ? '' : '\n'}${closing}`);
+}
+/** 超长表格：按行拆分，每片重复表头和分隔行。 */
+function splitTable(lines, max) {
+    const prefix = `${lines[0] ?? ''}\n${lines[1] ?? ''}`;
+    const rowMax = max - codePointLength(prefix) - 1;
+    if (rowMax < 8)
+        return [];
+    const pieces = [];
+    let current = prefix;
+    let filled = false;
+    const flush = () => {
+        if (!filled)
+            return;
+        pieces.push(current);
+        current = prefix;
+        filled = false;
+    };
+    for (const row of lines.slice(2)) {
+        for (const rowPiece of codePointLength(row) <= rowMax ? [row] : splitProse(row, rowMax)) {
+            if (filled && codePointLength(`${current}\n${rowPiece}`) > max)
+                flush();
+            current = `${current}\n${rowPiece}`;
+            filled = true;
+        }
+    }
+    flush();
+    return pieces;
+}
+function splitBlock(block, max) {
+    if (codePointLength(block.text) <= max)
+        return [{ text: block.text, plain: block.kind === 'prose' }];
+    const lines = block.text.split('\n');
+    if (block.kind === 'fence') {
+        const pieces = splitFence(lines, max);
+        if (pieces.length)
+            return pieces.map((piece) => ({ text: piece, plain: false }));
+    }
+    if (block.kind === 'table') {
+        const pieces = splitTable(lines, max);
+        if (pieces.length)
+            return pieces.map((piece) => ({ text: piece, plain: false }));
+    }
+    return splitProse(block.text, max).map((piece) => ({ text: piece, plain: block.kind === 'prose' }));
+}
+export function markdownTableOffsets(text) {
+    const lines = (text ?? '').replace(/\r\n?/g, '\n').split('\n');
+    const offsets = [];
+    let offset = 0;
+    for (const line of lines) {
+        offsets.push(offset);
+        offset += line.length + 1;
+    }
+    const starts = [];
+    let marker;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? '';
+        if (marker) {
+            if (isFenceClose(line, marker))
+                marker = undefined;
+            continue;
+        }
+        const opening = fenceMarkerOf(line);
+        if (opening) {
+            marker = opening;
+            continue;
+        }
+        const end = tableEnd(lines, index);
+        if (end > index) {
+            starts.push(offsets[index]);
+            index = end - 1;
+        }
+    }
+    return starts;
+}
+export function splitText(text, max) {
+    if (max <= 0)
+        return text === '' ? [] : [text];
+    if (text === '')
+        return [];
+    const allowance = Math.max(PREFIX_ALLOWANCE, 2 * String(codePointLength(text)).length + 3);
+    // 极小上限优先保留正文，避免编号本身占满整片。
+    const numbered = max > allowance + 16;
+    const budget = numbered ? max - allowance : max;
+    const segments = toBlocks(text)
+        .flatMap((block) => splitBlock(block, block.kind === 'prose' ? budget : max))
+        .filter((segment) => segment.text !== '');
+    const chunks = [];
+    for (const segment of segments) {
+        const last = chunks.at(-1);
+        if (last) {
+            const merged = [...last.map((item) => item.text), segment.text].join('\n');
+            if (codePointLength(merged) <= (last[0].plain ? budget : max)) {
+                last.push(segment);
+                continue;
+            }
+        }
+        chunks.push([segment]);
+    }
+    const parts = chunks
+        .map((chunk) => {
+        const text = chunk.map((item) => item.text).join('\n').replace(/^\n+/, '').replace(/\n+$/, '');
+        const firstLine = text.split('\n', 1)[0] ?? '';
+        // 前缀只能加在纯文字开头：围栏标记或表格首行前面加序号会破坏结构。
+        const structural = firstLine === '' || FENCE_MARKER.test(firstLine) || tableEnd(text.split('\n'), 0) > 0;
+        return { text, plain: chunk[0].plain && !structural };
+    })
+        .filter((part) => part.text !== '');
+    if (parts.length <= 1)
+        return parts.map((part) => part.text);
+    const total = parts.length;
+    return parts.map((part, index) => (numbered && part.plain ? `（${index + 1}/${total}）${part.text}` : part.text));
+}

package/src/engine/workspace-path.js

@@ -0,0 +1,9 @@
+/** 按运行平台比较工作区路径，避免在大小写敏感文件系统上错误复用会话。 */
+export function sameWorkspacePath(left, right, platform = process.platform) {
+    const normalize = (value) => {
+        const separators = platform === 'win32' ? /[\\/]+/g : /\/+/g;
+        const normalized = value.replace(separators, '/').replace(/\/+$/, '');
+        return platform === 'win32' ? normalized.toLowerCase() : normalized;
+    };
+    return normalize(left) === normalize(right);
+}