@greatlhd/ailo-desktop 1.0.0

package/dist/feishu-utils.js

@@ -0,0 +1,162 @@
+export function streamToBuffer(stream) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        stream.on("data", (chunk) => chunks.push(chunk));
+        stream.on("end", () => resolve(Buffer.concat(chunks)));
+        stream.on("error", reject);
+    });
+}
+function getPostContentRows(contentJson) {
+    try {
+        const root = JSON.parse(contentJson);
+        let content = root?.content;
+        if (!Array.isArray(content) && root?.post) {
+            content = (root.post.zh_cn ?? root.post.en)?.content ?? null;
+        }
+        return Array.isArray(content) ? content : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function extractTextFromPostContent(contentJson) {
+    const content = getPostContentRows(contentJson);
+    if (!content)
+        return "";
+    const parts = [];
+    for (const row of content) {
+        if (!Array.isArray(row))
+            continue;
+        const rowParts = [];
+        for (const node of row) {
+            if (node?.tag === "text" && typeof node.text === "string") {
+                rowParts.push(node.text);
+            }
+            else if (node?.tag === "at" && typeof node.user_id === "string") {
+                const name = typeof node.user_name === "string" ? node.user_name : "";
+                rowParts.push(name ? `@${name}` : `@${node.user_id}`);
+            }
+            else if (node?.tag === "a" && typeof node.text === "string") {
+                rowParts.push(node.text);
+            }
+        }
+        if (rowParts.length > 0)
+            parts.push(rowParts.join(""));
+    }
+    return parts.join("\n");
+}
+export function extractImageKeysFromPostContent(contentJson) {
+    const content = getPostContentRows(contentJson);
+    if (!content)
+        return [];
+    const keys = [];
+    for (const row of content) {
+        if (!Array.isArray(row))
+            continue;
+        for (const node of row) {
+            if (node?.tag === "img" && typeof node.image_key === "string")
+                keys.push(node.image_key);
+        }
+    }
+    return keys;
+}
+export function extractMentionElements(text, nameToIdCache) {
+    const atElements = [];
+    const seenIds = new Set();
+    let cleanText = text.replace(/@([^@(]+?)\(([a-zA-Z0-9][a-zA-Z0-9_]{9,})\)/g, (_, displayName, userId) => {
+        if (!seenIds.has(userId)) {
+            atElements.push({ userId, name: displayName.trim() });
+            seenIds.add(userId);
+        }
+        return "";
+    });
+    if (nameToIdCache?.size) {
+        const names = [...nameToIdCache.keys()].sort((a, b) => b.length - a.length);
+        for (const name of names) {
+            const openId = nameToIdCache.get(name);
+            const atMention = `@${name}`;
+            if (cleanText.includes(atMention)) {
+                if (!seenIds.has(openId)) {
+                    atElements.push({ userId: openId, name });
+                    seenIds.add(openId);
+                }
+                cleanText = cleanText.replaceAll(atMention, "");
+            }
+        }
+    }
+    cleanText = cleanText.replace(/[^\S\n]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+    return { cleanText, atElements };
+}
+export function adaptMarkdownForFeishu(text) {
+    return text
+        .replace(/^#{3,}\s+(.+)$/gm, "**$1**")
+        .replace(/^[ \t]+([-*])\s/gm, "$1 ")
+        .replace(/^[ \t]+(\d+\.)\s/gm, "$1 ");
+}
+function getDisplayWidth(str) {
+    let width = 0;
+    for (const ch of str) {
+        const code = ch.codePointAt(0) ?? 0;
+        if ((code >= 0x4e00 && code <= 0x9fff) ||
+            (code >= 0x3000 && code <= 0x303f) ||
+            (code >= 0xff00 && code <= 0xffef) ||
+            (code >= 0x3400 && code <= 0x4dbf) ||
+            (code >= 0x20000 && code <= 0x2a6df)) {
+            width += 2;
+        }
+        else {
+            width += 1;
+        }
+    }
+    return width;
+}
+function padEnd(str, targetWidth) {
+    return str + " ".repeat(Math.max(0, targetWidth - getDisplayWidth(str)));
+}
+export function convertMarkdownTablesToCodeBlock(text) {
+    const lines = text.split("\n");
+    const result = [];
+    let tableLines = [];
+    const flushTable = () => {
+        if (tableLines.length === 0)
+            return;
+        const rows = [];
+        for (const line of tableLines) {
+            const cells = line.replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim());
+            if (cells.every((c) => /^[-:]+$/.test(c)))
+                continue;
+            rows.push(cells);
+        }
+        if (rows.length === 0) {
+            result.push(...tableLines);
+            tableLines = [];
+            return;
+        }
+        const colCount = Math.max(...rows.map((r) => r.length));
+        const colWidths = Array(colCount).fill(0);
+        for (const row of rows) {
+            for (let i = 0; i < row.length; i++)
+                colWidths[i] = Math.max(colWidths[i], getDisplayWidth(row[i]));
+        }
+        const formatted = [];
+        for (let ri = 0; ri < rows.length; ri++) {
+            formatted.push(rows[ri].map((cell, ci) => padEnd(cell, colWidths[ci])).join(" | "));
+            if (ri === 0 && rows.length > 1)
+                formatted.push(colWidths.map((w) => "-".repeat(w)).join("-+-"));
+        }
+        result.push("```", ...formatted, "```");
+        tableLines = [];
+    };
+    for (const line of lines) {
+        if (/^\s*\|/.test(line))
+            tableLines.push(line);
+        else {
+            if (tableLines.length > 0)
+                flushTable();
+            result.push(line);
+        }
+    }
+    if (tableLines.length > 0)
+        flushTable();
+    return result.join("\n");
+}

package/dist/fs_tools.js

@@ -0,0 +1,398 @@
+import * as fs from "fs";
+import * as path from "path";
+import { glob } from "glob";
+import * as readline from "readline";
+const MAX_SEARCH_RESULTS = 500;
+const MAX_SEARCH_DEPTH = 10;
+const MAX_FIND_RESULTS = 200;
+const IGNORED_DIRS = ["node_modules", ".git"];
+/** 单次 read_file 最大字节数，超出则分块读取并截断提示 */
+const MAX_READ_BYTES = 2 * 1024 * 1024; // 2MB
+const PROTECTED_PATHS = [
+    "/etc", "/System", "/usr", "/bin", "/sbin", "/var", "/root", "/home",
+];
+/**
+ * 验证绝对路径安全：
+ * 1. 必须是绝对路径
+ * 2. 解析后必须在允许的基础目录下（防止 /tmp/../etc/passwd 绕过）
+ * 3. 不能在受保护路径下
+ */
+function requireAbsPath(p, param, allowedBase) {
+    if (!p)
+        throw new Error(`${param} 不能为空`);
+    if (!path.isAbsolute(p)) {
+        throw new Error(`${param} 必须是绝对路径，收到相对路径: "${p}"`);
+    }
+    const resolved = path.resolve(p);
+    // 防止 /tmp/../etc/passwd 等路径穿越
+    if (allowedBase && !resolved.startsWith(path.resolve(allowedBase))) {
+        throw new Error(`${param} 必须在 ${allowedBase} 下，收到: ${p}`);
+    }
+    // 禁止操作受保护的系统路径
+    for (const protected_ of PROTECTED_PATHS) {
+        if (resolved === protected_ || resolved.startsWith(protected_ + path.sep)) {
+            throw new Error(`${param} 禁止操作系统关键路径: ${p}`);
+        }
+    }
+    return resolved;
+}
+export async function fsTool(name, args) {
+    switch (name) {
+        case "read_file":
+            return readFile(args);
+        case "write_file":
+            return writeFile(args);
+        case "edit_file":
+            return editFile(args);
+        case "list_directory":
+            return listDirectory(args);
+        case "find_files":
+            return findFiles(args);
+        case "search_content":
+            return searchContent(args);
+        case "delete_file":
+            return deleteFile(args);
+        case "move_file":
+            return moveFile(args);
+        case "copy_file":
+            return copyFile(args);
+        case "append_file":
+            return appendFile(args);
+        default:
+            throw new Error(`unknown fs tool: ${name}`);
+    }
+}
+async function readFile(args) {
+    const filePath = requireAbsPath(args.path, "path");
+    if (!fs.existsSync(filePath))
+        throw new Error(`文件不存在: ${filePath}`);
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile())
+        throw new Error(`路径不是文件: ${filePath}`);
+    const rawOffset = args.offset ?? 1;
+    if (rawOffset < 1)
+        throw new Error("offset 必须 >= 1（1-indexed）");
+    const offset = rawOffset - 1;
+    const limit = Math.min(args.limit ?? 1000, 5000);
+    if (stat.size > MAX_READ_BYTES) {
+        // 大文件：流式读取指定行范围
+        const rl = readline.createInterface({
+            input: fs.createReadStream(filePath),
+            crlfDelay: Infinity,
+        });
+        const result = [];
+        let lineIdx = 0;
+        let emitted = 0;
+        for await (const line of rl) {
+            if (lineIdx >= offset) {
+                result.push(line);
+                emitted++;
+                if (emitted >= limit)
+                    break;
+            }
+            lineIdx++;
+        }
+        rl.close();
+        if (result.length === 0) {
+            return `...[文件共 ${stat.size} 字节，offset ${rawOffset} 超出总行数]`;
+        }
+        const startLineNum = offset + 1;
+        return result.map((line, i) => `${String(startLineNum + i).padStart(6)}|${line}`).join("\n");
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    const slice = limit !== undefined ? lines.slice(offset, offset + limit) : lines.slice(offset);
+    return slice.map((line, i) => `${String(offset + i + 1).padStart(6)}|${line}`).join("\n");
+}
+function writeFile(args) {
+    const filePath = requireAbsPath(args.path, "path");
+    const content = args.content;
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const oldContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf-8") : "";
+    fs.writeFileSync(filePath, content, "utf-8");
+    return [{
+            type: "text",
+            text: JSON.stringify({
+                filePath,
+                bytes: content.length,
+                oldBytes: oldContent.length,
+                newBytes: content.length,
+                oldLines: oldContent ? oldContent.split("\n").length : 0,
+                newLines: content.split("\n").length,
+                created: !oldContent,
+                success: true,
+            }, null, 2),
+        }];
+}
+function editFile(args) {
+    const filePath = requireAbsPath(args.path, "path");
+    const oldStr = args.old_string;
+    const newStr = args.new_string;
+    const replaceAll = args.replace_all ?? false;
+    if (!fs.existsSync(filePath))
+        throw new Error(`文件不存在: ${filePath}`);
+    const content = fs.readFileSync(filePath, "utf-8");
+    if (!content.includes(oldStr)) {
+        throw new Error("old_string 在文件中未找到");
+    }
+    const originalContent = content;
+    const oldLines = originalContent.split("\n");
+    let newContent;
+    let occurrences = 0;
+    if (replaceAll) {
+        const escaped = escapeRegex(oldStr);
+        occurrences = (content.match(new RegExp(escaped, "g")) || []).length;
+        newContent = content.split(oldStr).join(newStr);
+    }
+    else {
+        const idx = content.indexOf(oldStr);
+        newContent = content.slice(0, idx) + newStr + content.slice(idx + oldStr.length);
+        occurrences = 1;
+    }
+    const newLines = newContent.split("\n");
+    const additions = newLines.length - oldLines.length;
+    // 精确定位 oldStr 在原文件中的行号
+    const oldStrIdx = originalContent.indexOf(oldStr);
+    const oldStrLineCount = oldStr.split("\n").length;
+    const oldLineIdx = originalContent.slice(0, oldStrIdx).split("\n").length - 1;
+    const lineStart = Math.max(0, oldLineIdx - 2);
+    const lineEnd = Math.min(oldLines.length, oldLineIdx + oldStrLineCount + 2);
+    fs.writeFileSync(filePath, newContent, "utf-8");
+    return [{
+            type: "text",
+            text: JSON.stringify({
+                filePath,
+                oldString: oldStr,
+                newString: newStr,
+                replaceAll,
+                occurrences,
+                additions,
+                deletions: newLines.length - oldLines.length + additions,
+                oldLines: oldLines.length,
+                newLines: newLines.length,
+                hunk: {
+                    oldStart: lineStart + 1,
+                    oldLines: lineEnd - lineStart,
+                    newStart: lineStart + 1,
+                    newLines: lineEnd - lineStart + additions,
+                    lines: [
+                        ...oldLines.slice(lineStart, oldLineIdx).map((l) => ` ${l}`),
+                        ...oldStr.split("\n").map((l) => `-${l}`),
+                        ...newStr.split("\n").map((l) => `+${l}`),
+                        ...oldLines.slice(oldLineIdx + oldStrLineCount, lineEnd).map((l) => ` ${l}`),
+                    ],
+                },
+                success: true,
+            }, null, 2),
+        }];
+}
+function listDirectory(args) {
+    const dirPath = requireAbsPath(args.path, "path");
+    if (!fs.existsSync(dirPath))
+        throw new Error(`目录不存在: ${dirPath}`);
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    const lines = entries.map((e) => {
+        const suffix = e.isDirectory() ? "/" : "";
+        try {
+            const stat = fs.statSync(path.join(dirPath, e.name));
+            const size = e.isDirectory() ? "-" : formatSize(stat.size);
+            return `${e.name}${suffix}  (${size})`;
+        }
+        catch {
+            return `${e.name}${suffix}`;
+        }
+    });
+    return lines.join("\n") || "(空目录)";
+}
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+async function findFiles(args) {
+    const pattern = args.pattern;
+    const directory = requireAbsPath(args.directory || process.cwd(), "directory");
+    const maxResults = args.max_results || MAX_FIND_RESULTS;
+    // 防护：禁止路径穿越 pattern（如 ../, /tmp 等）
+    if (pattern.includes("..") || pattern.startsWith("/") || /^[a-zA-Z]:\\/i.test(pattern)) {
+        throw new Error("pattern 不允许包含路径穿越或绝对路径");
+    }
+    const matches = await glob(pattern, {
+        cwd: directory,
+        absolute: true,
+        nodir: false,
+        ignore: IGNORED_DIRS.map(d => `**/${d}/**`),
+    });
+    const limited = matches.slice(0, maxResults);
+    if (limited.length === 0)
+        return "未找到匹配文件";
+    let result = limited.join("\n");
+    if (matches.length > maxResults) {
+        result += `\n... 还有 ${matches.length - maxResults} 个结果`;
+    }
+    return result;
+}
+function searchContent(args) {
+    const query = args.query;
+    const directory = requireAbsPath(args.directory || process.cwd(), "directory");
+    const useRegex = args.regex ?? false;
+    const ignoreCase = args.ignore_case ?? false;
+    const contextLines = args.context_lines ?? 0;
+    const outputMode = args.output_mode ?? "content";
+    const headLimit = args.limit ?? 100;
+    const offset = args.offset ?? 0;
+    let pattern;
+    try {
+        pattern = useRegex
+            ? new RegExp(query, ignoreCase ? "gi" : "g")
+            : new RegExp(escapeRegex(query), ignoreCase ? "gi" : "g");
+    }
+    catch {
+        throw new Error(`无效的正则表达式: "${query}"`);
+    }
+    const results = [];
+    const fileMatches = new Map();
+    searchDir(directory, pattern, contextLines, results, 0, MAX_SEARCH_RESULTS, fileMatches);
+    if (outputMode === "files_with_matches") {
+        const files = Array.from(fileMatches.keys());
+        const totalFiles = files.length;
+        const paged = files.slice(offset, offset + headLimit);
+        const appliedOffset = offset > 0 ? offset : undefined;
+        const appliedLimit = totalFiles > offset + headLimit ? headLimit : undefined;
+        return [{
+                type: "text",
+                text: JSON.stringify({
+                    mode: "files_with_matches",
+                    numFiles: totalFiles,
+                    filenames: paged,
+                    appliedLimit,
+                    appliedOffset,
+                }, null, 2),
+            }];
+    }
+    if (outputMode === "count") {
+        const totalMatches = Array.from(fileMatches.values()).reduce((a, b) => a + b, 0);
+        const totalFiles = fileMatches.size;
+        const appliedOffset = offset > 0 ? offset : undefined;
+        const appliedLimit = totalFiles > offset + headLimit ? headLimit : undefined;
+        return [{
+                type: "text",
+                text: JSON.stringify({
+                    mode: "count",
+                    numFiles: totalFiles,
+                    numMatches: totalMatches,
+                    appliedLimit,
+                    appliedOffset,
+                }, null, 2),
+            }];
+    }
+    // content mode (default)
+    const totalMatches = results.length;
+    const totalFiles = fileMatches.size;
+    const paged = results.slice(offset, offset + headLimit);
+    const appliedOffset = offset > 0 ? offset : undefined;
+    const appliedLimit = totalMatches > offset + headLimit ? headLimit : undefined;
+    return [{
+            type: "text",
+            text: JSON.stringify({
+                mode: "content",
+                numFiles: totalFiles,
+                filenames: Array.from(fileMatches.keys()),
+                content: paged.join("\n") || "未找到匹配内容",
+                numMatches: totalMatches,
+                appliedLimit,
+                appliedOffset,
+            }, null, 2),
+        }];
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function searchDir(dir, pattern, ctx, results, depth, limit, fileMatches) {
+    if (depth > MAX_SEARCH_DEPTH || results.length >= limit)
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (results.length >= limit)
+            return;
+        const full = path.join(dir, e.name);
+        if (IGNORED_DIRS.includes(e.name))
+            continue;
+        if (e.isDirectory()) {
+            searchDir(full, pattern, ctx, results, depth + 1, limit, fileMatches);
+        }
+        else if (e.isFile()) {
+            try {
+                const content = fs.readFileSync(full, "utf-8");
+                const lines = content.split("\n");
+                let fileMatchCount = 0;
+                for (let i = 0; i < lines.length; i++) {
+                    if (pattern.test(lines[i])) {
+                        fileMatchCount++;
+                        const start = Math.max(0, i - ctx);
+                        const end = Math.min(lines.length, i + ctx + 1);
+                        const block = lines.slice(start, end).map((l, j) => {
+                            const lineNum = start + j + 1;
+                            const marker = (start + j === i) ? ":" : "-";
+                            return `${String(lineNum).padStart(4)}${marker} ${l}`;
+                        });
+                        results.push(`${full}:\n${block.join("\n")}`);
+                        if (results.length >= limit)
+                            return;
+                    }
+                }
+                if (fileMatchCount > 0 && fileMatches) {
+                    fileMatches.set(full, (fileMatches.get(full) ?? 0) + fileMatchCount);
+                }
+            }
+            catch { /* skip binary / unreadable files */ }
+        }
+    }
+}
+function deleteFile(args) {
+    const filePath = requireAbsPath(args.path, "path");
+    const recursive = args.recursive ?? false;
+    if (!fs.existsSync(filePath))
+        throw new Error(`路径不存在: ${filePath}`);
+    fs.rmSync(filePath, { recursive, force: true });
+    return `已删除 ${filePath}`;
+}
+function moveFile(args) {
+    const src = requireAbsPath(args.source, "source");
+    const dst = requireAbsPath(args.destination, "destination");
+    if (!fs.existsSync(src))
+        throw new Error(`源路径不存在: ${src}`);
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    fs.renameSync(src, dst);
+    return `已移动 ${src} → ${dst}`;
+}
+function copyFile(args) {
+    const src = requireAbsPath(args.source, "source");
+    const dst = requireAbsPath(args.destination, "destination");
+    if (!fs.existsSync(src))
+        throw new Error(`源路径不存在: ${src}`);
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+        fs.cpSync(src, dst, { recursive: true });
+    }
+    else {
+        fs.copyFileSync(src, dst);
+    }
+    return `已复制 ${src} → ${dst}`;
+}
+function appendFile(args) {
+    const filePath = requireAbsPath(args.path, "path");
+    const content = args.content;
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.appendFileSync(filePath, content, "utf-8");
+    return `已追加到 ${filePath}（${content.length} 字符）`;
+}